CStyle

daslk

# StyleSheet?(go)

# StyleTag?(go)

# CreateDocument?(go)

# CreateNode?(go)

# GetStyles?(go)

# Render?(go)

# AddPlugin?(go)

# hash?(go)

# ComputeNodeStyle?(go)

# initNodes?(go)

# InitNode?(go)

# parseBorderShorthand?(go)

# CompleteBorder?(go)

# flatten?(go)

# genTextNode?(go)

# GetPositionOffsetNode?(go)

  1package cstyle
  2
  3// package aui/goldie
  4// https://pkg.go.dev/automated.sh/goldie
  5// https://pkg.go.dev/automated.sh/aui
  6// https://pkg.go.dev/automated.sh/oat
  7
  8import (
  9	"crypto/md5"
 10	"encoding/hex"
 11	"fmt"
 12	"gui/color"
 13	"gui/element"
 14	"gui/font"
 15	"gui/parser"
 16	"gui/utils"
 17	"os"
 18	"slices"
 19	"sort"
 20	"strconv"
 21	"strings"
 22
 23	"golang.org/x/net/html"
 24)
 25
 26type Plugin struct {
 27	Styles  map[string]string
 28	Level   int
 29	Handler func(*element.Node)
 30}
 31
 32type CSS struct {
 33	Width       float32
 34	Height      float32
 35	StyleSheets []map[string]map[string]string
 36	Plugins     []Plugin
 37	Document    *element.Node
 38}
 39
 40func (c *CSS) StyleSheet(path string) {
 41	// Parse the CSS file
 42	dat, err := os.ReadFile(path)
 43	utils.Check(err)
 44	styles := parser.ParseCSS(string(dat))
 45
 46	c.StyleSheets = append(c.StyleSheets, styles)
 47}
 48
 49func (c *CSS) StyleTag(css string) {
 50	styles := parser.ParseCSS(css)
 51	c.StyleSheets = append(c.StyleSheets, styles)
 52}
 53
 54func (c *CSS) CreateDocument(doc *html.Node) element.Node {
 55	id := doc.FirstChild.Data + "0"
 56	n := doc.FirstChild
 57	node := element.Node{
 58		Parent: &element.Node{
 59			Properties: element.Properties{
 60				Id:     "ROOT",
 61				X:      0,
 62				Y:      0,
 63				Width:  c.Width,
 64				Height: c.Height,
 65				EM:     16,
 66				Type:   3,
 67				Node: &html.Node{Attr: []html.Attribute{
 68					{Key: "Width", Val: fmt.Sprint(c.Width)},
 69					{Key: "Height", Val: fmt.Sprint(c.Height)},
 70				}},
 71			},
 72
 73			Style: map[string]string{
 74				"width":  strconv.FormatFloat(float64(c.Width), 'f', -1, 32) + "px",
 75				"height": strconv.FormatFloat(float64(c.Height), 'f', -1, 32) + "px",
 76			},
 77		},
 78		Properties: element.Properties{
 79			Node: n,
 80			Id:   id,
 81			X:    0,
 82			Y:    0,
 83			Type: 3,
 84		},
 85	}
 86	i := 0
 87	for child := n.FirstChild; child != nil; child = child.NextSibling {
 88		if child.Type == html.ElementNode {
 89			node.Children = append(node.Children, CreateNode(node, child, fmt.Sprint(i)))
 90			i++
 91		}
 92	}
 93	return initNodes(&node, *c)
 94}
 95
 96func CreateNode(parent element.Node, n *html.Node, slug string) element.Node {
 97	id := n.Data + slug
 98	node := element.Node{
 99		Parent:    &parent,
100		TagName:   n.Data,
101		InnerText: utils.GetInnerText(n),
102		Properties: element.Properties{
103			Id:   id,
104			Type: n.Type,
105			Node: n,
106		},
107	}
108	for _, attr := range n.Attr {
109		if attr.Key == "class" {
110			classes := strings.Split(attr.Val, " ")
111			for _, class := range classes {
112				node.ClassList.Add(class)
113			}
114		} else if attr.Key == "id" {
115			node.Id = attr.Val
116		} else if attr.Key == "contenteditable" && (attr.Val == "" || attr.Val == "true") {
117			node.Properties.Editable = true
118		} else if attr.Key == "href" {
119			node.Href = attr.Val
120		} else if attr.Key == "src" {
121			node.Src = attr.Val
122		} else if attr.Key == "title" {
123			node.Title = attr.Val
124		}
125	}
126	i := 0
127	for child := n.FirstChild; child != nil; child = child.NextSibling {
128		if child.Type == html.ElementNode {
129			node.Children = append(node.Children, CreateNode(node, child, slug+fmt.Sprint(i)))
130			i++
131		}
132	}
133	return node
134}
135
136var inheritedProps = []string{
137	"color",
138	"cursor",
139	"font",
140	"font-family",
141	"font-size",
142	"font-style",
143	"font-weight",
144	"letter-spacing",
145	"line-height",
146	"text-align",
147	"text-indent",
148	"text-justify",
149	"text-shadow",
150	"text-transform",
151	"visibility",
152	"word-spacing",
153	"display",
154}
155
156// need to get rid of the .props for the most part all styles should be computed dynamically
157// can keep like focusable and stuff that describes the element
158
159// currently the append child does not work due to the props and other stuff not existing so it fails
160// moving to a real time style compute would fix that
161
162// :hover is parsed correctly but because the hash func doesn't invalidate it becuase the val
163// is updated in the props. change to append :hover to style to create the effect
164//							or merge the class with the styles? idk have to think more
165
166func (c *CSS) GetStyles(n element.Node) map[string]string {
167	styles := map[string]string{}
168	for k, v := range n.Style {
169		styles[k] = v
170	}
171	if n.Parent != nil {
172		ps := c.GetStyles(*n.Parent)
173		for _, v := range inheritedProps {
174			if ps[v] != "" {
175				styles[v] = ps[v]
176			}
177		}
178
179	}
180	hovered := false
181	if slices.Contains(n.ClassList.Classes, ":hover") {
182		hovered = true
183	}
184
185	for _, styleSheet := range c.StyleSheets {
186		for selector := range styleSheet {
187			// fmt.Println(selector, n.Properties.Id)
188			key := selector
189			if strings.Contains(selector, ":hover") && hovered {
190				selector = strings.Replace(selector, ":hover", "", -1)
191			}
192			if element.TestSelector(selector, &n) {
193				for k, v := range styleSheet[key] {
194					styles[k] = v
195				}
196			}
197
198		}
199	}
200	inline := parser.ParseStyleAttribute(n.GetAttribute("style") + ";")
201	styles = utils.Merge(styles, inline)
202	// add hover and focus css events
203
204	return styles
205}
206
207func (c *CSS) Render(doc element.Node) []element.Node {
208	return flatten(doc)
209}
210
211func (c *CSS) AddPlugin(plugin Plugin) {
212	c.Plugins = append(c.Plugins, plugin)
213}
214
215func hash(n *element.Node) string {
216	// Create a new FNV-1a hash
217	hasher := md5.New()
218
219	// Extract and sort the keys
220	var keys []string
221	for key := range n.Style {
222		keys = append(keys, key)
223	}
224	sort.Strings(keys)
225
226	// Concatenate all values into a single string
227	var concatenatedValues string
228	for _, key := range keys {
229		concatenatedValues += key + n.Style[key]
230	}
231	concatenatedValues += n.ClassList.Value
232	concatenatedValues += n.Id
233	hasher.Write([]byte(concatenatedValues))
234	sum := hasher.Sum(nil)
235	str := hex.EncodeToString(sum)
236	if n.Properties.Hash != str {
237		fmt.Println(n.Properties.Id)
238		fmt.Println(concatenatedValues)
239		fmt.Println(n.Properties.Hash, str)
240	}
241
242	return str
243}
244
245func (c *CSS) ComputeNodeStyle(n *element.Node) *element.Node {
246	plugins := c.Plugins
247	hv := hash(n)
248	if n.Properties.Hash != hv {
249		fmt.Println("RELOAD")
250		// this is kinda a sloppy way to do this but it works ig
251		n.Style = c.GetStyles(*n)
252		n.Properties.Hash = hv
253	}
254	styleMap := n.Style
255
256	if styleMap["display"] == "none" {
257		n.Properties.X = 0
258		n.Properties.Y = 0
259		n.Properties.Width = 0
260		n.Properties.Height = 0
261		return n
262	}
263
264	width, height := n.Properties.Width, n.Properties.Height
265	x, y := n.Parent.Properties.X, n.Parent.Properties.Y
266
267	var top, left, right, bottom bool = false, false, false, false
268
269	m := utils.GetMP(*n, "margin")
270	p := utils.GetMP(*n, "padding")
271
272	if styleMap["position"] == "absolute" {
273		base := GetPositionOffsetNode(n)
274		if styleMap["top"] != "" {
275			v, _ := utils.ConvertToPixels(styleMap["top"], float32(n.Properties.EM), n.Parent.Properties.Width)
276			y = v + base.Properties.Y
277			top = true
278		}
279		if styleMap["left"] != "" {
280			v, _ := utils.ConvertToPixels(styleMap["left"], float32(n.Properties.EM), n.Parent.Properties.Width)
281			x = v + base.Properties.X
282			left = true
283		}
284		if styleMap["right"] != "" {
285			v, _ := utils.ConvertToPixels(styleMap["right"], float32(n.Properties.EM), n.Parent.Properties.Width)
286			x = (base.Properties.Width - width) - v
287			right = true
288		}
289		if styleMap["bottom"] != "" {
290			v, _ := utils.ConvertToPixels(styleMap["bottom"], float32(n.Properties.EM), n.Parent.Properties.Width)
291			y = (base.Properties.Height - height) - v
292			bottom = true
293		}
294	} else {
295		for i, v := range n.Parent.Children {
296			if v.Properties.Id == n.Properties.Id {
297				if i-1 > 0 {
298					sibling := n.Parent.Children[i-1]
299					if styleMap["display"] == "inline" {
300						if sibling.Style["display"] == "inline" {
301							y = sibling.Properties.Y
302						} else {
303							y = sibling.Properties.Y + sibling.Properties.Height
304						}
305					} else {
306						y = sibling.Properties.Y + sibling.Properties.Height
307					}
308				}
309				break
310			} else if styleMap["display"] != "inline" {
311				mc := utils.GetMP(v, "margin")
312				pc := utils.GetMP(v, "padding")
313				y += mc.Top + mc.Bottom + pc.Top + pc.Bottom + v.Properties.Height
314			}
315		}
316	}
317
318	// Display modes need to be calculated here
319
320	relPos := !top && !left && !right && !bottom
321
322	if left || relPos {
323		x += m.Left
324	}
325	if top || relPos {
326		y += m.Top
327	}
328	if right {
329		x -= m.Right
330	}
331	if bottom {
332		y -= m.Bottom
333	}
334
335	if len(n.Children) == 0 {
336		// Confirm text exists
337		if len(n.InnerText) > 0 {
338			innerWidth := width
339			innerHeight := height
340			genTextNode(n, &innerWidth, &innerHeight, p)
341			width = innerWidth + p.Left + p.Right
342			height = innerHeight
343		}
344	}
345
346	n.Properties.X = x
347	n.Properties.Y = y
348	n.Properties.Width = width
349	n.Properties.Height = height
350
351	// Call children here
352
353	var childYOffset float32
354	for i, v := range n.Children {
355		v.Parent = n
356		n.Children[i] = *c.ComputeNodeStyle(&v)
357		if styleMap["height"] == "" {
358			if n.Children[i].Style["position"] != "absolute" && n.Children[i].Properties.Y > childYOffset {
359				childYOffset = n.Children[i].Properties.Y
360				m := utils.GetMP(n.Children[i], "margin")
361				p := utils.GetMP(n.Children[i], "padding")
362				n.Properties.Height += n.Children[i].Properties.Height
363				n.Properties.Height += m.Top
364				n.Properties.Height += m.Bottom
365				n.Properties.Height += p.Top
366				n.Properties.Height += p.Bottom
367			}
368
369		}
370	}
371
372	// Sorting the array by the Level field
373	sort.Slice(plugins, func(i, j int) bool {
374		return plugins[i].Level < plugins[j].Level
375	})
376
377	for _, v := range plugins {
378		matches := true
379		for name, value := range v.Styles {
380			if styleMap[name] != value && !(value == "*") {
381				matches = false
382			}
383		}
384		if matches {
385			v.Handler(n)
386		}
387	}
388
389	return n
390}
391
392func initNodes(n *element.Node, c CSS) element.Node {
393	n = InitNode(n, c)
394	for i, ch := range n.Children {
395		if ch.Properties.Type == html.ElementNode {
396			ch.Parent = n
397			cn := initNodes(&ch, c)
398
399			n.Children[i] = cn
400
401		}
402	}
403
404	return *n
405}
406
407func InitNode(n *element.Node, c CSS) *element.Node {
408	n.Style = c.GetStyles(*n)
409	border, err := CompleteBorder(n.Style)
410	if err == nil {
411		n.Properties.Border = border
412	}
413
414	fs, _ := utils.ConvertToPixels(n.Style["font-size"], n.Parent.Properties.EM, n.Parent.Properties.Width)
415	n.Properties.EM = fs
416
417	width, _ := utils.ConvertToPixels(n.Style["width"], n.Properties.EM, n.Parent.Properties.Width)
418	if n.Style["min-width"] != "" {
419		minWidth, _ := utils.ConvertToPixels(n.Style["min-width"], n.Properties.EM, n.Parent.Properties.Width)
420		width = utils.Max(width, minWidth)
421	}
422
423	if n.Style["max-width"] != "" {
424		maxWidth, _ := utils.ConvertToPixels(n.Style["max-width"], n.Properties.EM, n.Parent.Properties.Width)
425		width = utils.Min(width, maxWidth)
426	}
427
428	height, _ := utils.ConvertToPixels(n.Style["height"], n.Properties.EM, n.Parent.Properties.Height)
429	if n.Style["min-height"] != "" {
430		minHeight, _ := utils.ConvertToPixels(n.Style["min-height"], n.Properties.EM, n.Parent.Properties.Height)
431		height = utils.Max(height, minHeight)
432	}
433
434	if n.Style["max-height"] != "" {
435		maxHeight, _ := utils.ConvertToPixels(n.Style["max-height"], n.Properties.EM, n.Parent.Properties.Height)
436		height = utils.Min(height, maxHeight)
437	}
438
439	n.Properties.Width = width
440	n.Properties.Height = height
441
442	bold, italic := false, false
443
444	if n.Style["font-weight"] == "bold" {
445		bold = true
446	}
447
448	if n.Style["font-style"] == "italic" {
449		italic = true
450	}
451
452	f, _ := font.LoadFont(n.Style["font-family"], int(n.Properties.EM), bold, italic)
453	letterSpacing, _ := utils.ConvertToPixels(n.Style["letter-spacing"], n.Properties.EM, width)
454	wordSpacing, _ := utils.ConvertToPixels(n.Style["word-spacing"], n.Properties.EM, width)
455	lineHeight, _ := utils.ConvertToPixels(n.Style["line-height"], n.Properties.EM, width)
456	if lineHeight == 0 {
457		lineHeight = n.Properties.EM + 3
458	}
459
460	n.Properties.Text.LineHeight = int(lineHeight)
461	n.Properties.Text.Font = f
462	n.Properties.Text.WordSpacing = int(wordSpacing)
463	n.Properties.Text.LetterSpacing = int(letterSpacing)
464	return n
465}
466
467func parseBorderShorthand(borderShorthand string) (element.Border, error) {
468	// Split the shorthand into components
469	borderComponents := strings.Fields(borderShorthand)
470
471	// Ensure there are at least 1 component (width or style or color)
472	if len(borderComponents) >= 1 {
473		width := "0px" // Default width
474		style := "solid"
475		borderColor := "#000000" // Default color
476
477		// Extract style and color if available
478		if len(borderComponents) >= 1 {
479			width = borderComponents[0]
480		}
481
482		// Extract style and color if available
483		if len(borderComponents) >= 2 {
484			style = borderComponents[1]
485		}
486		if len(borderComponents) >= 3 {
487			borderColor = borderComponents[2]
488		}
489
490		parsedColor, _ := color.Color(borderColor)
491
492		return element.Border{
493			Width:  width,
494			Style:  style,
495			Color:  parsedColor,
496			Radius: "", // Default radius
497		}, nil
498	}
499
500	return element.Border{}, fmt.Errorf("invalid border shorthand format")
501}
502
503func CompleteBorder(cssProperties map[string]string) (element.Border, error) {
504	border, err := parseBorderShorthand(cssProperties["border"])
505	border.Radius = cssProperties["border-radius"]
506
507	return border, err
508}
509
510func flatten(n element.Node) []element.Node {
511	var nodes []element.Node
512	nodes = append(nodes, n)
513
514	children := n.Children
515	if len(children) > 0 {
516		for _, ch := range children {
517			chNodes := flatten(ch)
518			nodes = append(nodes, chNodes...)
519		}
520	}
521	return nodes
522}
523
524func genTextNode(n *element.Node, width, height *float32, p utils.MarginPadding) {
525	wb := " "
526
527	if n.Style["word-wrap"] == "break-word" {
528		wb = ""
529	}
530
531	if n.Style["text-wrap"] == "wrap" || n.Style["text-wrap"] == "balance" {
532		wb = ""
533	}
534
535	letterSpacing, _ := utils.ConvertToPixels(n.Style["letter-spacing"], n.Properties.EM, *width)
536	wordSpacing, _ := utils.ConvertToPixels(n.Style["word-spacing"], n.Properties.EM, *width)
537
538	var dt float32
539
540	if n.Style["text-decoration-thickness"] == "auto" || n.Style["text-decoration-thickness"] == "" {
541		dt = 2
542	} else {
543		dt, _ = utils.ConvertToPixels(n.Style["text-decoration-thickness"], n.Properties.EM, *width)
544	}
545
546	col := color.Parse(n.Style, "font")
547
548	n.Properties.Text.Color = col
549	n.Properties.Text.Align = n.Style["text-align"]
550	n.Properties.Text.WordBreak = wb
551	n.Properties.Text.WordSpacing = int(wordSpacing)
552	n.Properties.Text.LetterSpacing = int(letterSpacing)
553	n.Properties.Text.WhiteSpace = n.Style["white-space"]
554	n.Properties.Text.DecorationThickness = int(dt)
555	n.Properties.Text.Overlined = n.Style["text-decoration"] == "overline"
556	n.Properties.Text.Underlined = n.Style["text-decoration"] == "underline"
557	n.Properties.Text.LineThrough = n.Style["text-decoration"] == "linethrough"
558	n.Properties.Text.EM = int(n.Properties.EM)
559	n.Properties.Text.Width = int(n.Parent.Properties.Width)
560
561	if n.Style["word-spacing"] == "" {
562		n.Properties.Text.WordSpacing = font.MeasureSpace(&n.Properties.Text)
563	}
564	if n.Parent.Properties.Width != 0 && n.Style["display"] != "inline" && n.Style["width"] == "" {
565		*width = (n.Parent.Properties.Width - p.Right) - p.Left
566	} else if n.Style["width"] == "" {
567		*width = utils.Max(*width, float32(font.MeasureLongest(n)))
568	} else if n.Style["width"] != "" {
569		*width, _ = utils.ConvertToPixels(n.Style["width"], n.Properties.EM, n.Parent.Properties.Width)
570	}
571
572	n.Properties.Text.Width = int(*width)
573	h := font.Render(n)
574	if n.Style["height"] == "" {
575		*height = h
576	}
577
578}
579
580func GetPositionOffsetNode(n *element.Node) *element.Node {
581	pos := n.Style["position"]
582
583	if pos == "relative" {
584		return n
585	} else {
586		if n.Parent.Properties.Node != nil {
587			return GetPositionOffsetNode(n.Parent)
588		} else {
589			return nil
590		}
591	}
592}