Author: LakeFox
Email: [email protected]
Date: Mon, 8 Apr 2024 14:51:56 -0500
cstyle/main.go
Added state
Commits
ae78990ed5b06e02833bd8e578a3af1df49adc00 ae742fdbda42322f4fa1d30761f516bf1ad45a70 1ae1fe418977632fafe3e61c5f02e87f0cad6c87 099527773e9bc03b40b9ce5d8a492ebbcdebcf32 b6acff3a27a7c66e35ab7ea5ffe48f1a69efaf11 07144afe32b8dd752fc4d80efd81529e2df9e4e5 ca735fa2c136dd5f35a5ccf2ffe2133b906c7f94 e2ea9c897ee1e89f89cd5c043632326348191b3a 10f4ce166028ee8ff926170d4d9e17d54e63a4a4 4bd704181610864a1fc4ebe65f20220ea1f1c00b 1c468e139a0f87655e4222b8512c38bec429d067 d8d6cadd2741b05c7a121ccb6753c5a48b8ad1b4 4c0529a8475408ee41d4e4dbd9c969db14594d37 ed8180f077d294d1e2f347f6c30d2977e8670b42 9113424c26a247352fe7b111fff39d1562f6c342 f783d5cacccf047368f8f20fc687bf5ad8f6f66a 66084134570c2a3d87e1336a2ab2ca50341b93b2 031df3b2fd4851345dd6f4c443057141d5b9e65b baf5d8cc1ccf27d14e4e58edcc4c170bba6445df e9c8f7961cf8b188938535b318b50397a76268ba 29572e238d6ba3f401717032bd12a2f409bf1ea9 d6025b04ef9516745adae85a478cbf9f98433597 476d6415583067674f395660961e33b9b40c3e66 906dd99de66ad7df92011a52fb19e0319224741e 4c44132d28d06548d2c90c2f8ca72dd3047fa52d 79e4c754771ba514b29a36e96a7570f266de3c41 36aaa13c4ea4d1235c64febfe9a8fd797037bbb2 6d4b83918686647193953a59c166baf7455b4996 c6a1e4a5102e9a3b5045957c22a0a73ac1a7ca4c db934f090648cdcd96e2f5f12a9bad762c60bfcd 7af8fc3f425ca3814ce1088fbd8a7f82513a1bb2 1c650539c11b715b14ee9013ad7d7faa8f733a7a 717ed8747f4df855c63e13ff95dcab720b8713cd 1c786f0d0efe1a47c285564824c9503881bef393 af527f354d956456e2e71a7f81f1470e74888e69 94ded12a3e3953459ccfbec2f225cecb43b47c73 c0081dc2f877de951fd8b0cd37136568a7ebb586 cbc825d6b458d50debc5913c6b5ed442138d7462 0a3baa3c4708754c79d023ad0addb4cbfb2844c2 a07b34e07b359327e413ccb7ea2dcdf1a91504de 4bf00213a866402775b162fb6f4b7b0bc37a8af7 1b690fa946047f4b897b417d8bc3b02c54cfdb2d 83b05e82a5f28bbe288565ae8a65943ba681cb4a 37d58d4f9de6af12611dada7ba5ae42d51ef05c6 8bbfc0ded0504595111765963d396a4574773e05 81049efedf0b3b521fb2949d8eb03d5ba681b0a5 6dcb369a2fa2bb69f94598fb4224a1349a80db6c c3e4d0cb62570c56ef5bc530f57eeea613f083fc 82d0fbb470daae4091bf30fb57707d66bd193992 166ec9ab6f4a3af0fe522a7dbe166951d2b39b31 992895a8842900d9a0803e7099611d650aba257d 4904b0b2812f9f0f45a59f2efacae89dabe9fe7c 36beac951788f5fb7ab2eeb3381300b07993bfe8 541818a92a5be6442879cd9b3420e1ef27f6e663 43ac3a1bbe6e727869a26ab8697c035eb60577fa d2afd27150a869ff41b8e100e82f20af54146105 0374f24d4685954662fa9db05939a8cbcd492b1c ed04d15b29d4df0329e8a4725c1a371a5cb0a20e 39fc4123096b04a4584b48d6efbb1acd5acacbf9 18315df2eb529bab6c5c79607ecb94626b170ae6 c519a195b90ad689d60d85365252e433b7488eaf d0d2839012c26032488bfe657797b4b590f926c7 8e0cb82ccac15fbc3e08bb53b148563e62437a44 d4413acd4dbad43507018f24e0456a9bc432d156 0dc05886b3ae0c59667f03a245e0728ab094f130 c9a3652d779d9700d9a9d797fd0c58d349a58de1 76425d002c70c3d853c117389a3b407efc53c7c2 fb409ef93b05cd4268e83c7201da73b6b29d482a da1cce88d00f7f7c373df1ce66b18e26e3a2d6e9 fa74cd48bb8959855c9d6b874f874671611611f7 610079be424f3a72ad02aa62e1c89607481750e0 60fda643c807730c3774beaa10a0910a31a4278a 6d2bcdcad816fd2b31c612fe45d3fd5a2fb14f98 b2d960e7d263bee55badbca47dc5d4d4f2d61084 f2ba1e3a96dd571d142c5a37c462743a21148e5f 25cbd33758fdb18f79aa1cf6500d1c1c024ee516 cde2d71846d1f69e5f386d354006465d61a4d19c cf708c22c45491dbdbbdbbb4450b08969f2e33bc 7bda495fbc9ea2c3aa87ac73a5cf4881eecf1482 9499d6967b394b70a22d9be34f47ee1b7a3fc55e 3aa3e67cd8ab769bc2c12b46fc77b11be2b1a0dd abed4927dc46e3e952fd21472f7ae4150ee16044 73953118e02b4c2d8159279624810dddd75e9100 031e4b18d91d825b56ef1e9eda5f1638bcd26629 fa3e1c57efa140ea58f56c6abf1f5f12f9bf2c7d a9b1b82a40fa6c462a9919b2832a89eb6bb47784 a8bf5e2504bdbe257686d48c2bfcaf061abfc95d e2830e4a6650ca8a1c53116a6d86f2975951dbbf 4a48b4c6905999527a7fc8d32e53d8c347c9ac74 9cfdb8c7ddce3a1b34a6590d8872f820601c2c53 128fad8298e89eadafa5feea43ca94f5115b9090 95d4595418fa814d47707441f2dc98d07eac12d6 5e35f7131d999b406eaeafc689374e3426845e6d 3402992fd25a64838e7acecfba3fad645c6c2511 8fcabdf5a34e7d80de988c10426c27adb0622087 1884dd57148595841cfb324f5b812d8640964978 6008cc8c3444f86d729ae5a81ae26919da1bb516 03d40c0d7e8feda38add1d89e3805df74997d915 810685c4aac0a651beaecd0488443a3b293b315d a666abc115c6693b355d5a8ef9cdfc3d77a088ca bcd3619f96c4157ee5b6450bc2bd1f23f27c9d81 9c428f6ab674582e022ea469ef2ac1e3f7ccb933 6e99df4296470d349da01f2e29698dbb34692a0f ed739dfaeb1ca5da10b2c75236faee40bacaf851 006a9351f3320662bff0b96d5d27daa1ba4e52e4 d6b38763cf83ad275aed0450151a97098f48859a 4ea031466d93057705a52caf2dfa21929b215730 a1bead3d96a11f4badedbd5a6eb984473c1cd309 7aa36472009f43cad843b465f67d2927f3428fdf 5f875adcd63ebd9ac9dfaef3ea16e6a6d3735503 4c0cc347e5e52d8ed99e84d42b309c4541d9280c c3de867fbbc27aaefba7aa88f97b5b1406c7c58e 00754639948b6612016ed5c434e97f44e7c65ed6 ffe16b1e768209b1c2021301a142b7fcd9a35a4b 800e568c600187f7228b228874ad20fb57f35166 d36b349e0eea73e99253b64fae3afeb5c4c276ca a7d8eff776e4e28a85e7835ee7ff6d50775748e7 bd0bd280c89d5d742e0ef13673c854436657466f 42da0bb422cdca21c8491af40ca9631206d8e964 e81415f70bedf456983b18692b4ae04355f15283 09c0a9a40ca6d8a8b6eaa6f06ce3f8c2440f7ee1 26eaa5b9c8cc2a84f9de04e17e01f201c122989e 649f49d0618e3c8cb940c4d259a536dfcc66020f 27ec987a8e8a9bc645f6cd38d9f8d5d52e7dbedb eb566ec8284ba205d27699a9bf465e26158b5098 4bdf14d6decad2ef14a77c108227273dd700e9a3 5598cb31dc238e16f58da2f793a1e2f7f5768dba 0bfe812e3d1f25756efcf92162961f5d55c3a5d8 9f96c81ba868d6269f3698c64ca8a83e74b0510f d5f01925db8323eeabbc43ec1b72a685da00dd6b f09195ec50a24c35947cb52feca1978ac5599871 0a10380275edaffc88632ef444a15b15c47ec17e 3f08ca6c77812c1d39f2949d2bab7416c77cc4ca af784841593347b2fd440fb78872fe9ac0fe1c09 9aa492880457b6fc20968f5d036cb6fe912e8964 c622cc4a0d279b98570b0af11fc67278e3355556 4d5dead4c4d3b3e34198e59e6ee0f6b3ca7c64b1 2191ceb040dd58a0794250e9e6c795a509b9fad5 775c1d3bc761967ff2f0a83e345c951117a5e9aa ace03eee6a19e6a12ad12c25e310ac3d223d2d48 f10dbc643cb334dc70657a086a38aadb59b59e29 ea63ec4d6f32b8a652d495d9c66d777313271e4a 038178b09b92d678107449519b75a977a08f45e9 f9cdbbb9ebfc1db9261b430427aa719be56a53c1 0a200674c645cf59ae69f25a25440db0b89c0c30 2e7189bb5db8a803c0ade25613a50bfcc264746a e6ca3edcf724fb8f2457423d9261ab73faf1f5da 6ff2d4a7c2fbc14ea856eb891f019c7978905834 72fac5e32be9bbf531dc8e324f2b865eb265ec4f 351cd2077d369fc0a9b9ec8675ede29288d41f35 061dd2a2659df35d1edd4ba74d67e6e72b531bf7 3c32ab918568bf4f59b0a8b393020de888dc2c3e 08fa11670d73b4f71226541761e09a99fc8a17c9 9d94e556f3eb471fd312af194ca7c4b82b67da6c db70db80c56513ebad6b95b66273e623198c5f44 e666311a274481b4af90702c916004ccbf9b6d8a 9780e12fa7acfb3a5be7d4171068c8c100858c53 baee9c1074cbf844b7c4a3c837ebb17f7861d075 0aae4ce623c90bfd7ea6c4f20967bf50001dc22f c8b42e81407d55a6444986deb435fa8144822c49 9e9967bb87524a82ae9411ca974d3b081ec52c53 3eac611da268444f07e1f718ffd18c7f47bc2a4c fbb2b3a689be07c57cde471e651ba06d7ecf7316 28d61bf3fae304b22ce0380c93a6f997e8c77e32 992c464588845b09ff2b4a61b5de719b9cdaf356 716fff934be2016bc00b2fcf17e19bc0ecfdeeb0 69a2005824c09fa33828ec5ffa24b9df8cd5bcc0 4fa6810e9e944c7d0c4ff06bed6a534e33869034 8dbbcec096317e9016c2f3478be4d458dbb34ad8 2c7c01be15245ae8997185fee247c00106cc81db 5af9b8d40ec97f5741d9a69161ef4aa10c879724 c9851e1b750de6c324c749b4bff5725d79e2b610 0a9f5a297bb97486fc23bb3a0bb39cb8b5b8cc27 aa4bda96b90fab60bf383c255d60b9580b5b6a31 cd8a892d7f6ca71c5d591d4282d98083462d77fe 98cc1a202fd2dbf27e87378c1588edc5eb1c3d60 d3068f5500a98d2a2b71d4c01d5296477224b743 1b28153bff1449200899115d4a1d9f612fac716c d992717d5df7bf68a5907446f9b31c78b5a01f51 497033c40c559bceb5c7980c8d48bd1d935188e3 d967a66b91fd990264e5a4b134385d80e5980c57 a397e9dda8244b6977adb9daeb5ab5ddff6e6140 60b804dc01593469962dae00a1e4004f0a8d7c53 a7b240cf9199d727e494b97ad2d9b65440a9ef1c 2458e3538eef44deb6f3d6a4831aef19414fd0ed c19139b782f5124ea86fc1610fe13ea85f77a279 c67f095bcad89fc6e6b635792a96ed0ed295e1a8 9ecebc8512dbb2a0ed61df1901eafd3832893bf8 95a551f86f299d7f8b424c26da3ff77400368fed ae5c8d61d8c75ed4b01dac60edd37859bc8f9d8f e54f11cae13b053a44afe10cdb47b65f535caca9 9b4fcfd0bee437354defe7e0f431857ff21c0edb ee5c2a995e1b9affef5a8e12f23cff8b0813d2ab 034c3e1601aaa0cba81118030a849485eea2b7ea 0cce165ede3a66867a863d5cb86afff5db406587 375b4fd6eca2d9d63959f9c755de6f8c5d89d302 8bec92a21036bedb734571d443f7b1a14daaa6eb 14d0b11516cd8bbdea84a3fa6cf53cff9619d902 c1e77a9311a8679328d0dc1337dd940682296927 6ab614d3e218d4c5cb3f69001a71350d3d7c65ec 77f6db23a5b65257959cc55e03eff09ee8f25cfc 64b7a40bb5620ec0522d9609fc961cff9cafe68a 62dca0c033d444aa579970c4c871b802c2a82d60 21f5480d3441d7c918a817368172bc14d714a3e8 3fc038d8db20f298b843a7eeeb31f25abf5a2788 492236c84ca4cfc3d8aea9d32d75b6a65a2fe52a 759a12b81483024d52d7b2055f66d675c05ea372 50580213060d8392a2da78eec0b8f08adddeba62 6374e3bb760d470dacdadfc14ef7cb824d9e194c 964b76fe981ab840a2cbc8a807789abae92ae660 b30861536f72d0ffc97c8780b62759fb764ed40b 5edb09e6ea1ba70cdac64a2196481b1f038301c2 34eeb6773589a95ecf66484b999cf443e57632d0 4ee9c48fa4b6f983c03acf77e8d04720fe43e1a6 88ebb8d8af483c96640f7df804e87fca20284c4d ce9fadbe2bd8bac62b475a387a8577f8a806fd52 9e7eb5f80cde5398270e1c4c85258118e22fe8ef a19227e38c38ceb21695ac14ea7754002980cf55 4277bc56f4490533734b1ed78fb5a9c8575f7afb 424479529f31e00ff3263795d42218a026fa528a 91c0289a560e3f3860d7b39549010adf917b8d1b 62a80750f59f92786acc48b18c3365d021bc5590 c0de5849434d88dd115eac9e5bc8eafcd0a0fa76 f869b8a4d7f88ac88437c9f3cfb4416784990e98 ee80bb3fe9cdd54af1ce4aba7f5e2fd136a2499c 8563a689d5957e4fd3ff9fecfbf97def28de4bff de8179675f9250b28678671addf56e33e5829e79 43b815a08101d267bc5d937d0b003a419bb2abd9 9e4164f6b3f847f371351a324905def648ea1747 1f26e1cc07a0de2edb516769b74e99b965b6d75d c36c0e51aad0f40f3f61406e786ba198ab6d90f9 c727bae4cb644789b0a975ec665c8b02652d4651 a61b91abb5ba8128c1438cc59b2f054c71f28d2a 2e1cecf0bba482b9976f3d8f274611195b0cf2f8 707ef18dccda6b917e1b421291e47e658555b3d2 b456956bfd85041b5b70b50d5fb2eaf3c9de64f2 f39d14d001e3dd0e73c4f8200f4132b47ebb40d3 9f0bcb8f5d1922199afb7bc8f8bb57bb10d0fe12 e877036f029a0198d9da39775443c8ac2132309b 2391f2f3881dbdabf96ca33c931e9cd5f42cedc9 82189594b7e20243f5ece31c6f7b804d6b83b0d7 5abd3260994cc77992f5c6437bdcdf45c32d9867 2519053ee4c5b2ce1c2851fee0d47d612d27aa1f 05584371da7da40cdab309ea2809c51c02069384 b61c8342cee8a0942ce276c2d2de773347ab4dcd c7b80824ade46956377b955838b73325d6fbe4d9 9866874e4701f30f1a293a7fd2e5d242bbf82c4f 2308aecbde415948894a55e53201c5abb7184039 e8b44094228f41fa5996788b977d07072fcf87a6 2facd93337f682bd8aa1222805c46720a53edc99 2d9288cec441356241f7d59d120de06ee7b97fdd
Diff 
diff --git a/cstyle/main.go b/cstyle/main.go
index b9ab091..ccd95c8 100644
--- a/cstyle/main.go
+++ b/cstyle/main.go
@@ -24 +24 @@ type Plugin struct {
-	Handler func(*element.Node, *map[string]element.State)
+	Handler func(*element.Node)
@@ -119,0 +120,4 @@ func (c *CSS) GetStyles(n element.Node) map[string]string {
+func (c *CSS) Render(doc element.Node) []element.Node {
+	return flatten(doc)
+}
+
@@ -124,4 +128 @@ func (c *CSS) AddPlugin(plugin Plugin) {
-func CheckNode(n *element.Node, state *map[string]element.State) {
-	s := *state
-	self := s[n.Properties.Id]
-
+func CheckNode(n *element.Node) {
@@ -129,8 +130,8 @@ func CheckNode(n *element.Node, state *map[string]element.State) {
-	// fmt.Printf("ID: %v\n", n.Id)
-	// fmt.Printf("Classes: %v\n", n.ClassList.Classes)
-	fmt.Printf("Text: %v\n", self.Text.Text)
-	fmt.Printf("X: %v, Y: %v\n", self.X, self.Y)
-	fmt.Printf("Width: %v, Height: %v\n", self.Width, self.Height)
-	// fmt.Printf("Styles: %v\n\n\n", n.Style)
-	// w := utils.GetWH(*n)
-	// fmt.Printf("Calc WH: %v, %v\n\n\n", w.Width, w.Height)
+	fmt.Printf("ID: %v\n", n.Id)
+	fmt.Printf("Classes: %v\n", n.ClassList.Classes)
+	fmt.Printf("Text: %v\n", n.InnerText)
+	fmt.Printf("X: %v, Y: %v\n", n.Properties.X, n.Properties.Y)
+	fmt.Printf("Width: %v, Height: %v\n", n.Properties.Computed["width"], n.Properties.Computed["height"])
+	fmt.Printf("Styles: %v\n\n\n", n.Style)
+	w := utils.GetWH(*n)
+	fmt.Printf("Calc WH: %v, %v\n\n\n", w.Width, w.Height)
@@ -139 +140 @@ func CheckNode(n *element.Node, state *map[string]element.State) {
-func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State) *element.Node {
+func (c *CSS) ComputeNodeStyle(n *element.Node) *element.Node {
@@ -146,8 +146,0 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-	s := *state
-	self := s[n.Properties.Id]
-	parent := s[n.Parent.Properties.Id]
-
-	self.Background = color.Parse(n.Style, "background")
-
-	fs, _ := utils.ConvertToPixels(n.Style["font-size"], parent.EM, parent.Width)
-	self.EM = fs
@@ -156,4 +149,4 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-		self.X = 0
-		self.Y = 0
-		self.Width = 0
-		self.Height = 0
+		n.Properties.X = 0
+		n.Properties.Y = 0
+		n.Properties.Computed["width"] = 0
+		n.Properties.Computed["height"] = 0
@@ -167 +160 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-	x, y := parent.X, parent.Y
+	x, y := n.Parent.Properties.X, n.Parent.Properties.Y
@@ -174,3 +166,0 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-	self.Margin = m
-	self.Padding = p
-
@@ -178,2 +168 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-		bas := utils.GetPositionOffsetNode(n)
-		base := s[bas.Properties.Id]
+		base := utils.GetPositionOffsetNode(n)
@@ -181,2 +170,2 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-			v, _ := utils.ConvertToPixels(n.Style["top"], self.EM, parent.Width)
-			y = v + base.Y
+			v, _ := utils.ConvertToPixels(n.Style["top"], float32(n.Properties.EM), n.Parent.Properties.Computed["width"])
+			y = v + base.Properties.Y
@@ -186,2 +175,2 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-			v, _ := utils.ConvertToPixels(n.Style["left"], self.EM, parent.Width)
-			x = v + base.X
+			v, _ := utils.ConvertToPixels(n.Style["left"], float32(n.Properties.EM), n.Parent.Properties.Computed["width"])
+			x = v + base.Properties.X
@@ -191,2 +180,2 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-			v, _ := utils.ConvertToPixels(n.Style["right"], self.EM, parent.Width)
-			x = (base.Width - width) - v
+			v, _ := utils.ConvertToPixels(n.Style["right"], float32(n.Properties.EM), n.Parent.Properties.Computed["width"])
+			x = (base.Properties.Computed["width"] - width) - v
@@ -196,2 +185,2 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-			v, _ := utils.ConvertToPixels(n.Style["bottom"], self.EM, parent.Width)
-			y = (base.Height - height) - v
+			v, _ := utils.ConvertToPixels(n.Style["bottom"], float32(n.Properties.EM), n.Parent.Properties.Computed["width"])
+			y = (base.Properties.Computed["height"] - height) - v
@@ -204,2 +193 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-					sib := n.Parent.Children[i-1]
-					sibling := s[sib.Properties.Id]
+					sibling := n.Parent.Children[i-1]
@@ -207,2 +195,2 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-						if sib.Style["display"] == "inline" {
-							y = sibling.Y
+						if sibling.Style["display"] == "inline" {
+							y = sibling.Properties.Y
@@ -210 +198 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-							y = sibling.Y + sibling.Height
+							y = sibling.Properties.Y + sibling.Properties.Computed["height"]
@@ -213 +201 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-						y = sibling.Y + sibling.Height
+						y = sibling.Properties.Y + sibling.Properties.Computed["height"]
@@ -218,2 +206,3 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-				vState := s[v.Properties.Id]
-				y += vState.Margin.Top + vState.Margin.Bottom + vState.Padding.Top + vState.Padding.Bottom + vState.Height
+				mc := utils.GetMP(v, "margin")
+				pc := utils.GetMP(v, "padding")
+				y += mc.Top + mc.Bottom + pc.Top + pc.Bottom + v.Properties.Computed["height"]
@@ -240,0 +230,25 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
+	bold, italic := false, false
+
+	if n.Style["font-weight"] == "bold" {
+		bold = true
+	}
+
+	if n.Style["font-style"] == "italic" {
+		italic = true
+	}
+
+	if n.Properties.Text.Font == nil {
+		f, _ := font.LoadFont(n.Style["font-family"], int(n.Properties.EM), bold, italic)
+		letterSpacing, _ := utils.ConvertToPixels(n.Style["letter-spacing"], n.Properties.EM, width)
+		wordSpacing, _ := utils.ConvertToPixels(n.Style["word-spacing"], n.Properties.EM, width)
+		lineHeight, _ := utils.ConvertToPixels(n.Style["line-height"], n.Properties.EM, width)
+		if lineHeight == 0 {
+			lineHeight = n.Properties.EM + 3
+		}
+
+		n.Properties.Text.LineHeight = int(lineHeight)
+		n.Properties.Text.Font = f
+		n.Properties.Text.WordSpacing = int(wordSpacing)
+		n.Properties.Text.LetterSpacing = int(letterSpacing)
+	}
+
@@ -246 +260 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-			genTextNode(n, &innerWidth, &innerHeight, p, state)
+			genTextNode(n, &innerWidth, &innerHeight, p)
@@ -252,4 +266,4 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-	self.X = x
-	self.Y = y
-	self.Width = width
-	self.Height = height
+	n.Properties.X = x
+	n.Properties.Y = y
+	n.Properties.Computed["width"] = width
+	n.Properties.Computed["height"] = height
@@ -257,4 +271 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-	(*state)[n.Properties.Id] = self
-	(*state)[n.Parent.Properties.Id] = parent
-
-	// CheckNode(n, state)
+	CheckNode(n)
@@ -267 +278 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-		n.Children[i] = *c.ComputeNodeStyle(&v, state)
+		n.Children[i] = *c.ComputeNodeStyle(&v)
@@ -269,8 +280,9 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-			cState := s[n.Children[i].Properties.Id]
-			if n.Children[i].Style["position"] != "absolute" && cState.Y > childYOffset {
-				childYOffset = cState.Y
-				self.Height += cState.Height
-				self.Height += cState.Margin.Top
-				self.Height += cState.Margin.Bottom
-				self.Height += cState.Padding.Top
-				self.Height += cState.Padding.Bottom
+			if n.Children[i].Style["position"] != "absolute" && n.Children[i].Properties.Y > childYOffset {
+				childYOffset = n.Children[i].Properties.Y
+				m := utils.GetMP(n.Children[i], "margin")
+				p := utils.GetMP(n.Children[i], "padding")
+				n.Properties.Computed["height"] += n.Children[i].Properties.Computed["height"]
+				n.Properties.Computed["height"] += m.Top
+				n.Properties.Computed["height"] += m.Bottom
+				n.Properties.Computed["height"] += p.Top
+				n.Properties.Computed["height"] += p.Bottom
@@ -282,2 +293,0 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-	(*state)[n.Properties.Id] = self
-
@@ -297 +307 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
-			v.Handler(n, state)
+			v.Handler(n)
@@ -303,0 +314,60 @@ func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State)
+func InitNode(n *element.Node, c CSS) *element.Node {
+	n.Style = c.GetStyles(*n)
+	border, err := CompleteBorder(n.Style)
+	if err == nil {
+		n.Properties.Border = border
+	}
+
+	fs, _ := utils.ConvertToPixels(n.Style["font-size"], n.Parent.Properties.EM, n.Parent.Properties.Computed["width"])
+	n.Properties.EM = fs
+
+	width, _ := utils.ConvertToPixels(n.Style["width"], n.Properties.EM, n.Parent.Properties.Computed["width"])
+	if n.Style["min-width"] != "" {
+		minWidth, _ := utils.ConvertToPixels(n.Style["min-width"], n.Properties.EM, n.Parent.Properties.Computed["width"])
+		width = utils.Max(width, minWidth)
+	}
+
+	if n.Style["max-width"] != "" {
+		maxWidth, _ := utils.ConvertToPixels(n.Style["max-width"], n.Properties.EM, n.Parent.Properties.Computed["width"])
+		width = utils.Min(width, maxWidth)
+	}
+
+	height, _ := utils.ConvertToPixels(n.Style["height"], n.Properties.EM, n.Parent.Properties.Computed["height"])
+	if n.Style["min-height"] != "" {
+		minHeight, _ := utils.ConvertToPixels(n.Style["min-height"], n.Properties.EM, n.Parent.Properties.Computed["height"])
+		height = utils.Max(height, minHeight)
+	}
+
+	if n.Style["max-height"] != "" {
+		maxHeight, _ := utils.ConvertToPixels(n.Style["max-height"], n.Properties.EM, n.Parent.Properties.Computed["height"])
+		height = utils.Min(height, maxHeight)
+	}
+
+	n.Properties.Computed["width"] = width
+	n.Properties.Computed["height"] = height
+
+	bold, italic := false, false
+
+	if n.Style["font-weight"] == "bold" {
+		bold = true
+	}
+
+	if n.Style["font-style"] == "italic" {
+		italic = true
+	}
+
+	f, _ := font.LoadFont(n.Style["font-family"], int(n.Properties.EM), bold, italic)
+	letterSpacing, _ := utils.ConvertToPixels(n.Style["letter-spacing"], n.Properties.EM, width)
+	wordSpacing, _ := utils.ConvertToPixels(n.Style["word-spacing"], n.Properties.EM, width)
+	lineHeight, _ := utils.ConvertToPixels(n.Style["line-height"], n.Properties.EM, width)
+	if lineHeight == 0 {
+		lineHeight = n.Properties.EM + 3
+	}
+
+	n.Properties.Text.LineHeight = int(lineHeight)
+	n.Properties.Text.Font = f
+	n.Properties.Text.WordSpacing = int(wordSpacing)
+	n.Properties.Text.LetterSpacing = int(letterSpacing)
+	return n
+}
+
@@ -347,4 +417,3 @@ func CompleteBorder(cssProperties map[string]string) (element.Border, error) {
-func genTextNode(n *element.Node, width, height *float32, p element.MarginPadding, state *map[string]element.State) {
-	s := *state
-	self := s[n.Properties.Id]
-	parent := s[n.Parent.Properties.Id]
+func flatten(n element.Node) []element.Node {
+	var nodes []element.Node
+	nodes = append(nodes, n)
@@ -352,20 +421,6 @@ func genTextNode(n *element.Node, width, height *float32, p element.MarginPaddin
-	bold, italic := false, false
-
-	if n.Style["font-weight"] == "bold" {
-		bold = true
-	}
-
-	if n.Style["font-style"] == "italic" {
-		italic = true
-	}
-
-	if self.Text.Font == nil {
-		f, _ := font.LoadFont(n.Style["font-family"], int(self.EM), bold, italic)
-		self.Text.Font = f
-	}
-
-	letterSpacing, _ := utils.ConvertToPixels(n.Style["letter-spacing"], self.EM, *width)
-	wordSpacing, _ := utils.ConvertToPixels(n.Style["word-spacing"], self.EM, *width)
-	lineHeight, _ := utils.ConvertToPixels(n.Style["line-height"], self.EM, *width)
-	if lineHeight == 0 {
-		lineHeight = self.EM + 3
+	children := n.Children
+	if len(children) > 0 {
+		for _, ch := range children {
+			chNodes := flatten(ch)
+			nodes = append(nodes, chNodes...)
+		}
@@ -372,0 +428,2 @@ func genTextNode(n *element.Node, width, height *float32, p element.MarginPaddin
+	return nodes
+}
@@ -374,3 +431 @@ func genTextNode(n *element.Node, width, height *float32, p element.MarginPaddin
-	self.Text.LineHeight = int(lineHeight)
-	self.Text.WordSpacing = int(wordSpacing)
-	self.Text.LetterSpacing = int(letterSpacing)
+func genTextNode(n *element.Node, width, height *float32, p utils.MarginPadding) {
@@ -386,0 +442,3 @@ func genTextNode(n *element.Node, width, height *float32, p element.MarginPaddin
+	letterSpacing, _ := utils.ConvertToPixels(n.Style["letter-spacing"], n.Properties.EM, *width)
+	wordSpacing, _ := utils.ConvertToPixels(n.Style["word-spacing"], n.Properties.EM, *width)
+
@@ -392 +450 @@ func genTextNode(n *element.Node, width, height *float32, p element.MarginPaddin
-		dt, _ = utils.ConvertToPixels(n.Style["text-decoration-thickness"], self.EM, *width)
+		dt, _ = utils.ConvertToPixels(n.Style["text-decoration-thickness"], n.Properties.EM, *width)
@@ -397,13 +455,12 @@ func genTextNode(n *element.Node, width, height *float32, p element.MarginPaddin
-	self.Text.Color = col
-	self.Text.Align = n.Style["text-align"]
-	self.Text.WordBreak = wb
-	self.Text.WordSpacing = int(wordSpacing)
-	self.Text.LetterSpacing = int(letterSpacing)
-	self.Text.WhiteSpace = n.Style["white-space"]
-	self.Text.DecorationThickness = int(dt)
-	self.Text.Overlined = n.Style["text-decoration"] == "overline"
-	self.Text.Underlined = n.Style["text-decoration"] == "underline"
-	self.Text.LineThrough = n.Style["text-decoration"] == "linethrough"
-	self.Text.EM = int(self.EM)
-	self.Text.Width = int(parent.Width)
-	self.Text.Text = n.InnerText
+	n.Properties.Text.Color = col
+	n.Properties.Text.Align = n.Style["text-align"]
+	n.Properties.Text.WordBreak = wb
+	n.Properties.Text.WordSpacing = int(wordSpacing)
+	n.Properties.Text.LetterSpacing = int(letterSpacing)
+	n.Properties.Text.WhiteSpace = n.Style["white-space"]
+	n.Properties.Text.DecorationThickness = int(dt)
+	n.Properties.Text.Overlined = n.Style["text-decoration"] == "overline"
+	n.Properties.Text.Underlined = n.Style["text-decoration"] == "underline"
+	n.Properties.Text.LineThrough = n.Style["text-decoration"] == "linethrough"
+	n.Properties.Text.EM = int(n.Properties.EM)
+	n.Properties.Text.Width = int(n.Parent.Properties.Computed["width"])
@@ -412 +469 @@ func genTextNode(n *element.Node, width, height *float32, p element.MarginPaddin
-		self.Text.WordSpacing = font.MeasureSpace(&self.Text)
+		n.Properties.Text.WordSpacing = font.MeasureSpace(&n.Properties.Text)
@@ -414,2 +471,2 @@ func genTextNode(n *element.Node, width, height *float32, p element.MarginPaddin
-	if parent.Width != 0 && n.Style["display"] != "inline" && n.Style["width"] == "" {
-		*width = (parent.Width - p.Right) - p.Left
+	if n.Parent.Properties.Computed["width"] != 0 && n.Style["display"] != "inline" && n.Style["width"] == "" {
+		*width = (n.Parent.Properties.Computed["width"] - p.Right) - p.Left
@@ -417 +474 @@ func genTextNode(n *element.Node, width, height *float32, p element.MarginPaddin
-		*width = utils.Max(*width, float32(font.MeasureLongest(&self)))
+		*width = utils.Max(*width, float32(font.MeasureLongest(n)))
@@ -419 +476 @@ func genTextNode(n *element.Node, width, height *float32, p element.MarginPaddin
-		*width, _ = utils.ConvertToPixels(n.Style["width"], self.EM, parent.Width)
+		*width, _ = utils.ConvertToPixels(n.Style["width"], n.Properties.EM, n.Parent.Properties.Computed["width"])
@@ -422,2 +479,2 @@ func genTextNode(n *element.Node, width, height *float32, p element.MarginPaddin
-	self.Text.Width = int(*width)
-	h := font.Render(&self)
+	n.Properties.Text.Width = int(*width)
+	h := font.Render(n)

package cstyle

// package aui/goldie
// https://pkg.go.dev/automated.sh/goldie
// https://pkg.go.dev/automated.sh/aui
// https://pkg.go.dev/automated.sh/oat

import (
	"fmt"
	"gui/color"
	"gui/element"
	"gui/font"
	"gui/parser"
	"gui/utils"
	"os"
	"slices"
	"sort"
	"strings"
)

type Plugin struct {
	Styles  map[string]string
	Level   int
	Handler func(*element.Node, *map[string]element.State)
}

type CSS struct {
	Width       float32
	Height      float32
	StyleSheets []map[string]map[string]string
	Plugins     []Plugin
	Document    *element.Node
}

func (c *CSS) StyleSheet(path string) {
	// Parse the CSS file
	dat, err := os.ReadFile(path)
	utils.Check(err)
	styles := parser.ParseCSS(string(dat))

	c.StyleSheets = append(c.StyleSheets, styles)
}

func (c *CSS) StyleTag(css string) {
	styles := parser.ParseCSS(css)
	c.StyleSheets = append(c.StyleSheets, styles)
}

var inheritedProps = []string{
	"color",
	"cursor",
	"font",
	"font-family",
	"font-size",
	"font-style",
	"font-weight",
	"letter-spacing",
	"line-height",
	"text-align",
	"text-indent",
	"text-justify",
	"text-shadow",
	"text-transform",
	"visibility",
	"word-spacing",
	"display",
}

// need to get rid of the .props for the most part all styles should be computed dynamically
// can keep like focusable and stuff that describes the element

// currently the append child does not work due to the props and other stuff not existing so it fails
// moving to a real time style compute would fix that

// :hover is parsed correctly but because the hash func doesn't invalidate it becuase the val
// is updated in the props. change to append :hover to style to create the effect
//							or merge the class with the styles? idk have to think more

func (c *CSS) GetStyles(n element.Node) map[string]string {
	styles := map[string]string{}

	if n.Parent != nil {
		ps := c.GetStyles(*n.Parent)
		for _, v := range inheritedProps {
			if ps[v] != "" {
				styles[v] = ps[v]
			}
		}
	}
	for k, v := range n.Style {
		styles[k] = v
	}
	hovered := false
	if slices.Contains(n.ClassList.Classes, ":hover") {
		hovered = true
	}

	for _, styleSheet := range c.StyleSheets {
		for selector := range styleSheet {
			// fmt.Println(selector, n.Properties.Id)
			key := selector
			if strings.Contains(selector, ":hover") && hovered {
				selector = strings.Replace(selector, ":hover", "", -1)
			}
			if element.TestSelector(selector, &n) {
				for k, v := range styleSheet[key] {
					styles[k] = v
				}
			}

		}
	}
	inline := parser.ParseStyleAttribute(n.GetAttribute("style") + ";")
	styles = utils.Merge(styles, inline)
	// add hover and focus css events

	return styles
}

func (c *CSS) AddPlugin(plugin Plugin) {
	c.Plugins = append(c.Plugins, plugin)
}

func CheckNode(n *element.Node, state *map[string]element.State) {
	s := *state
	self := s[n.Properties.Id]

	fmt.Println(n.TagName, n.Properties.Id)
	// fmt.Printf("ID: %v\n", n.Id)
	// fmt.Printf("Classes: %v\n", n.ClassList.Classes)
	fmt.Printf("Text: %v\n", self.Text.Text)
	fmt.Printf("X: %v, Y: %v\n", self.X, self.Y)
	fmt.Printf("Width: %v, Height: %v\n", self.Width, self.Height)
	// fmt.Printf("Styles: %v\n\n\n", n.Style)
	// w := utils.GetWH(*n)
	// fmt.Printf("Calc WH: %v, %v\n\n\n", w.Width, w.Height)
}

func (c *CSS) ComputeNodeStyle(n *element.Node, state *map[string]element.State) *element.Node {
	// Head is not renderable
	if utils.IsParent(*n, "head") {
		return n
	}
	plugins := c.Plugins
	n.Style = c.GetStyles(*n)
	s := *state
	self := s[n.Properties.Id]
	parent := s[n.Parent.Properties.Id]

	self.Background = color.Parse(n.Style, "background")

	fs, _ := utils.ConvertToPixels(n.Style["font-size"], parent.EM, parent.Width)
	self.EM = fs

	if n.Style["display"] == "none" {
		self.X = 0
		self.Y = 0
		self.Width = 0
		self.Height = 0
		return n
	}

	wh := utils.GetWH(*n)
	width := wh.Width
	height := wh.Height

	x, y := parent.X, parent.Y

	var top, left, right, bottom bool = false, false, false, false

	m := utils.GetMP(*n, "margin")
	p := utils.GetMP(*n, "padding")

	self.Margin = m
	self.Padding = p

	if n.Style["position"] == "absolute" {
		bas := utils.GetPositionOffsetNode(n)
		base := s[bas.Properties.Id]
		if n.Style["top"] != "" {
			v, _ := utils.ConvertToPixels(n.Style["top"], self.EM, parent.Width)
			y = v + base.Y
			top = true
		}
		if n.Style["left"] != "" {
			v, _ := utils.ConvertToPixels(n.Style["left"], self.EM, parent.Width)
			x = v + base.X
			left = true
		}
		if n.Style["right"] != "" {
			v, _ := utils.ConvertToPixels(n.Style["right"], self.EM, parent.Width)
			x = (base.Width - width) - v
			right = true
		}
		if n.Style["bottom"] != "" {
			v, _ := utils.ConvertToPixels(n.Style["bottom"], self.EM, parent.Width)
			y = (base.Height - height) - v
			bottom = true
		}
	} else {
		for i, v := range n.Parent.Children {
			if v.Properties.Id == n.Properties.Id {
				if i-1 > 0 {
					sib := n.Parent.Children[i-1]
					sibling := s[sib.Properties.Id]
					if n.Style["display"] == "inline" {
						if sib.Style["display"] == "inline" {
							y = sibling.Y
						} else {
							y = sibling.Y + sibling.Height
						}
					} else {
						y = sibling.Y + sibling.Height
					}
				}
				break
			} else if n.Style["display"] != "inline" {
				vState := s[v.Properties.Id]
				y += vState.Margin.Top + vState.Margin.Bottom + vState.Padding.Top + vState.Padding.Bottom + vState.Height
			}
		}
	}

	// Display modes need to be calculated here

	relPos := !top && !left && !right && !bottom

	if left || relPos {
		x += m.Left
	}
	if top || relPos {
		y += m.Top
	}
	if right {
		x -= m.Right
	}
	if bottom {
		y -= m.Bottom
	}

	if len(n.Children) == 0 {
		// Confirm text exists
		if len(n.InnerText) > 0 {
			innerWidth := width
			innerHeight := height
			genTextNode(n, &innerWidth, &innerHeight, p, state)
			width = innerWidth + p.Left + p.Right
			height = innerHeight
		}
	}

	self.X = x
	self.Y = y
	self.Width = width
	self.Height = height

	(*state)[n.Properties.Id] = self
	(*state)[n.Parent.Properties.Id] = parent

	// CheckNode(n, state)

	// Call children here

	var childYOffset float32
	for i, v := range n.Children {
		v.Parent = n
		n.Children[i] = *c.ComputeNodeStyle(&v, state)
		if n.Style["height"] == "" {
			cState := s[n.Children[i].Properties.Id]
			if n.Children[i].Style["position"] != "absolute" && cState.Y > childYOffset {
				childYOffset = cState.Y
				self.Height += cState.Height
				self.Height += cState.Margin.Top
				self.Height += cState.Margin.Bottom
				self.Height += cState.Padding.Top
				self.Height += cState.Padding.Bottom
			}

		}
	}

	(*state)[n.Properties.Id] = self

	// Sorting the array by the Level field
	sort.Slice(plugins, func(i, j int) bool {
		return plugins[i].Level < plugins[j].Level
	})

	for _, v := range plugins {
		matches := true
		for name, value := range v.Styles {
			if n.Style[name] != value && !(value == "*") {
				matches = false
			}
		}
		if matches {
			v.Handler(n, state)
		}
	}

	return n
}

func parseBorderShorthand(borderShorthand string) (element.Border, error) {
	// Split the shorthand into components
	borderComponents := strings.Fields(borderShorthand)

	// Ensure there are at least 1 component (width or style or color)
	if len(borderComponents) >= 1 {
		width := "0px" // Default width
		style := "solid"
		borderColor := "#000000" // Default color

		// Extract style and color if available
		if len(borderComponents) >= 1 {
			width = borderComponents[0]
		}

		// Extract style and color if available
		if len(borderComponents) >= 2 {
			style = borderComponents[1]
		}
		if len(borderComponents) >= 3 {
			borderColor = borderComponents[2]
		}

		parsedColor, _ := color.Color(borderColor)

		return element.Border{
			Width:  width,
			Style:  style,
			Color:  parsedColor,
			Radius: "", // Default radius
		}, nil
	}

	return element.Border{}, fmt.Errorf("invalid border shorthand format")
}

func CompleteBorder(cssProperties map[string]string) (element.Border, error) {
	border, err := parseBorderShorthand(cssProperties["border"])
	border.Radius = cssProperties["border-radius"]

	return border, err
}

func genTextNode(n *element.Node, width, height *float32, p element.MarginPadding, state *map[string]element.State) {
	s := *state
	self := s[n.Properties.Id]
	parent := s[n.Parent.Properties.Id]

	bold, italic := false, false

	if n.Style["font-weight"] == "bold" {
		bold = true
	}

	if n.Style["font-style"] == "italic" {
		italic = true
	}

	if self.Text.Font == nil {
		f, _ := font.LoadFont(n.Style["font-family"], int(self.EM), bold, italic)
		self.Text.Font = f
	}

	letterSpacing, _ := utils.ConvertToPixels(n.Style["letter-spacing"], self.EM, *width)
	wordSpacing, _ := utils.ConvertToPixels(n.Style["word-spacing"], self.EM, *width)
	lineHeight, _ := utils.ConvertToPixels(n.Style["line-height"], self.EM, *width)
	if lineHeight == 0 {
		lineHeight = self.EM + 3
	}

	self.Text.LineHeight = int(lineHeight)
	self.Text.WordSpacing = int(wordSpacing)
	self.Text.LetterSpacing = int(letterSpacing)
	wb := " "

	if n.Style["word-wrap"] == "break-word" {
		wb = ""
	}

	if n.Style["text-wrap"] == "wrap" || n.Style["text-wrap"] == "balance" {
		wb = ""
	}

	var dt float32

	if n.Style["text-decoration-thickness"] == "auto" || n.Style["text-decoration-thickness"] == "" {
		dt = 2
	} else {
		dt, _ = utils.ConvertToPixels(n.Style["text-decoration-thickness"], self.EM, *width)
	}

	col := color.Parse(n.Style, "font")

	self.Text.Color = col
	self.Text.Align = n.Style["text-align"]
	self.Text.WordBreak = wb
	self.Text.WordSpacing = int(wordSpacing)
	self.Text.LetterSpacing = int(letterSpacing)
	self.Text.WhiteSpace = n.Style["white-space"]
	self.Text.DecorationThickness = int(dt)
	self.Text.Overlined = n.Style["text-decoration"] == "overline"
	self.Text.Underlined = n.Style["text-decoration"] == "underline"
	self.Text.LineThrough = n.Style["text-decoration"] == "linethrough"
	self.Text.EM = int(self.EM)
	self.Text.Width = int(parent.Width)
	self.Text.Text = n.InnerText

	if n.Style["word-spacing"] == "" {
		self.Text.WordSpacing = font.MeasureSpace(&self.Text)
	}
	if parent.Width != 0 && n.Style["display"] != "inline" && n.Style["width"] == "" {
		*width = (parent.Width - p.Right) - p.Left
	} else if n.Style["width"] == "" {
		*width = utils.Max(*width, float32(font.MeasureLongest(&self)))
	} else if n.Style["width"] != "" {
		*width, _ = utils.ConvertToPixels(n.Style["width"], self.EM, parent.Width)
	}

	self.Text.Width = int(*width)
	h := font.Render(&self)
	if n.Style["height"] == "" {
		*height = h
	}

}