Utils

dsa

# ComputeStyleString?(go)

# ComputeStyleMap?(go)

# MapToInline?(go)

# InlineToMap?(go)

# GetWH?(go)

# SetWH?(go)

# GetMP?(go)

# convertMarginToIndividualProperties?(go)

# ConvertToPixels?(go)

# evaluateCalcExpression?(go)

# GetTextBounds?(go)

# Merge?(go)

# ExMerge?(go)

# Max?(go)

# Min?(go)

# FindRelative?(go)

# ParseFloat?(go)

# GetStructField?(go)

# SetStructFieldValue?(go)

# Check?(go)

# GetInnerText?(go)

# GetPositionOffsetNode?(go)

# IsParent?(go)

  1package utils
  2
  3import (
  4	"fmt"
  5	"gui/element"
  6	"gui/font"
  7	"math"
  8	"reflect"
  9	"regexp"
 10	"strconv"
 11	"strings"
 12
 13	"golang.org/x/net/html"
 14)
 15
 16func ComputeStyleString(n element.Node) string {
 17	styles := map[string]string{}
 18	wh := GetWH(n)
 19	styles["width"] = fmt.Sprint(wh.Width)
 20	styles["width"] = fmt.Sprint(wh.Height)
 21	m := GetMP(n, "marign")
 22	styles["margin-top"] = fmt.Sprint(m.Top)
 23	styles["margin-left"] = fmt.Sprint(m.Left)
 24	styles["margin-right"] = fmt.Sprint(m.Right)
 25	styles["margin-bottom"] = fmt.Sprint(m.Bottom)
 26	p := GetMP(n, "padding")
 27	styles["padding-top"] = fmt.Sprint(p.Top)
 28	styles["padding-left"] = fmt.Sprint(p.Left)
 29	styles["padding-right"] = fmt.Sprint(p.Right)
 30	styles["padding-bottom"] = fmt.Sprint(p.Bottom)
 31	return MapToInline(styles)
 32}
 33
 34func ComputeStyleMap(n element.Node) map[string]float32 {
 35	inline := InlineToMap(n.Style["computed"])
 36	parsed := map[string]float32{}
 37	mt, _ := strconv.ParseFloat(inline["margin-top"], 32)
 38	parsed["margin-top"] = float32(mt)
 39	ml, _ := strconv.ParseFloat(inline["margin-left"], 32)
 40	parsed["margin-left"] = float32(ml)
 41	mr, _ := strconv.ParseFloat(inline["margin-right"], 32)
 42	parsed["margin-right"] = float32(mr)
 43	mb, _ := strconv.ParseFloat(inline["margin-bottom"], 32)
 44	parsed["margin-bottom"] = float32(mb)
 45
 46	pt, _ := strconv.ParseFloat(inline["padding-top"], 32)
 47	parsed["padding-top"] = float32(pt)
 48	pl, _ := strconv.ParseFloat(inline["padding-left"], 32)
 49	parsed["padding-left"] = float32(pl)
 50	pr, _ := strconv.ParseFloat(inline["padding-right"], 32)
 51	parsed["padding-right"] = float32(pr)
 52	pb, _ := strconv.ParseFloat(inline["padding-bottom"], 32)
 53	parsed["padding-bottom"] = float32(pb)
 54
 55	width, _ := strconv.ParseFloat(inline["width"], 32)
 56	parsed["width"] = float32(width)
 57	height, _ := strconv.ParseFloat(inline["height"], 32)
 58	parsed["height"] = float32(height)
 59	return parsed
 60}
 61
 62// MapToInlineCSS converts a map[string]string to a string formatted like inline CSS style
 63func MapToInline(m map[string]string) string {
 64	var cssStrings []string
 65	for key, value := range m {
 66		cssStrings = append(cssStrings, fmt.Sprintf("%s: %s;", key, value))
 67	}
 68	return strings.Join(cssStrings, " ")
 69}
 70
 71// InlineCSSToMap converts a string formatted like inline CSS style to a map[string]string
 72func InlineToMap(cssString string) map[string]string {
 73	cssMap := make(map[string]string)
 74	declarations := strings.Split(cssString, ";")
 75	for _, declaration := range declarations {
 76		parts := strings.Split(strings.TrimSpace(declaration), ":")
 77		if len(parts) == 2 {
 78			key := strings.TrimSpace(parts[0])
 79			value := strings.TrimSpace(parts[1])
 80			cssMap[key] = value
 81		}
 82	}
 83	return cssMap
 84}
 85
 86type WidthHeight struct {
 87	Width  float32
 88	Height float32
 89}
 90
 91func GetWH(n element.Node) WidthHeight {
 92	fs := font.GetFontSize(n.Style)
 93
 94	var pwh WidthHeight
 95	if n.Parent != nil {
 96		pwh = GetWH(*n.Parent)
 97	} else {
 98		pwh = WidthHeight{}
 99		if n.Style["width"] != "" {
100			str := strings.TrimSuffix(n.Style["width"], "px")
101			// Convert the string to float32
102			f, _ := strconv.ParseFloat(str, 32)
103			pwh.Width = float32(f)
104		}
105		if n.Style["height"] != "" {
106			str := strings.TrimSuffix(n.Style["height"], "px")
107			// Convert the string to float32
108			f, _ := strconv.ParseFloat(str, 32)
109			pwh.Height = float32(f)
110		}
111	}
112
113	width, _ := ConvertToPixels(n.Style["width"], fs, pwh.Width)
114	if n.Style["min-width"] != "" {
115		minWidth, _ := ConvertToPixels(n.Style["min-width"], fs, pwh.Width)
116		width = Max(width, minWidth)
117	}
118
119	if n.Style["max-width"] != "" {
120		maxWidth, _ := ConvertToPixels(n.Style["max-width"], fs, pwh.Width)
121		width = Min(width, maxWidth)
122	}
123
124	height, _ := ConvertToPixels(n.Style["height"], fs, pwh.Height)
125	if n.Style["min-height"] != "" {
126		minHeight, _ := ConvertToPixels(n.Style["min-height"], fs, pwh.Height)
127		height = Max(height, minHeight)
128	}
129
130	if n.Style["max-height"] != "" {
131		maxHeight, _ := ConvertToPixels(n.Style["max-height"], fs, pwh.Height)
132		height = Min(height, maxHeight)
133	}
134	return WidthHeight{
135		Width:  width,
136		Height: height,
137	}
138}
139
140func SetWH(width, height float32) {
141	// could have a calculated style so map[string]string{"computed":"width: 100;x: 100;etc..",}
142	// then make a function that can parse/update all of them as needed..
143	// might still run into the issue of things not always being updated
144}
145
146type MarginPadding struct {
147	Top    float32
148	Left   float32
149	Right  float32
150	Bottom float32
151}
152
153func GetMP(n element.Node, t string) MarginPadding {
154	fs := font.GetFontSize(n.Style)
155	m := MarginPadding{}
156
157	wh := GetWH(n)
158
159	if n.Style[t] != "" {
160		left, right, top, bottom := convertMarginToIndividualProperties(n.Style[t])
161		if n.Style[t+"-left"] == "" {
162			n.Style[t+"-left"] = left
163		}
164		if n.Style[t+"-right"] == "" {
165			n.Style[t+"-right"] = right
166		}
167		if n.Style[t+"-top"] == "" {
168			n.Style[t+"-top"] = top
169		}
170		if n.Style[t+"-bottom"] == "" {
171			n.Style[t+"-bottom"] = bottom
172		}
173	}
174	if n.Style[t+"-left"] != "" || n.Style[t+"-right"] != "" {
175		l, _ := ConvertToPixels(n.Style[t+"-left"], fs, wh.Width)
176		r, _ := ConvertToPixels(n.Style[t+"-right"], fs, wh.Width)
177		m.Left = l
178		m.Right = r
179	}
180	if n.Style[t+"-top"] != "" || n.Style[t+"-bottom"] != "" {
181		top, _ := ConvertToPixels(n.Style[t+"-top"], fs, wh.Height)
182		b, _ := ConvertToPixels(n.Style[t+"-bottom"], fs, wh.Height)
183		m.Top = top
184		m.Bottom = b
185	}
186	if t == "margin" {
187		if n.Style["margin"] == "auto" && n.Style["margin-left"] == "" && n.Style["margin-right"] == "" {
188			// this dont work
189			m.Left = Max((n.Parent.Properties.Width-wh.Width)/2, 0)
190			m.Right = Max((n.Parent.Properties.Width-wh.Width)/2, 0)
191		}
192	}
193
194	return m
195}
196
197func convertMarginToIndividualProperties(margin string) (string, string, string, string) {
198	// Remove extra whitespace
199	margin = strings.TrimSpace(margin)
200
201	if margin == "" {
202		return "0px", "0px", "0px", "0px"
203	}
204
205	// Regular expression to match values with optional units
206	re := regexp.MustCompile(`(-?\d+(\.\d+)?)(\w*|\%)?`)
207
208	// Extract numerical values from the margin property
209	matches := re.FindAllStringSubmatch(margin, -1)
210
211	// Initialize variables for individual margins
212	var left, right, top, bottom string
213
214	switch len(matches) {
215	case 1:
216		// If only one value is provided, apply it to all margins
217		left = matches[0][0]
218		right = matches[0][0]
219		top = matches[0][0]
220		bottom = matches[0][0]
221	case 2:
222		// If two values are provided, apply the first to top and bottom, and the second to left and right
223		top = matches[0][0]
224		bottom = matches[0][0]
225		left = matches[1][0]
226		right = matches[1][0]
227	case 3:
228		// If three values are provided, apply the first to top, the second to left and right, and the third to bottom
229		top = matches[0][0]
230		left = matches[1][0]
231		right = matches[1][0]
232		bottom = matches[2][0]
233	case 4:
234		// If four values are provided, apply them to top, right, bottom, and left, respectively
235		top = matches[0][0]
236		right = matches[1][0]
237		bottom = matches[2][0]
238		left = matches[3][0]
239	}
240
241	return left, right, top, bottom
242}
243
244// ConvertToPixels converts a CSS measurement to pixels.
245func ConvertToPixels(value string, em, max float32) (float32, error) {
246	unitFactors := map[string]float32{
247		"px": 1,
248		"em": em,
249		"pt": 1.33,
250		"pc": 16.89,
251		"%":  max / 100,
252		"vw": max / 100,
253		"vh": max / 100,
254		"cm": 37.79527559,
255	}
256
257	re := regexp.MustCompile(`calc\(([^)]*)\)|^(\d+(?:\.\d+)?)\s*([a-zA-Z\%]+)$`)
258	match := re.FindStringSubmatch(value)
259
260	if match != nil {
261		if len(match[1]) > 0 {
262			calcResult, err := evaluateCalcExpression(match[1], em, max)
263			if err != nil {
264				return 0, err
265			}
266			return calcResult, nil
267		}
268
269		if len(match[2]) > 0 && len(match[3]) > 0 {
270			numericValue, err := strconv.ParseFloat(match[2], 64)
271			if err != nil {
272				return 0, fmt.Errorf("error parsing numeric value: %v", err)
273			}
274			return float32(numericValue) * unitFactors[match[3]], nil
275		}
276	}
277
278	return 0, fmt.Errorf("invalid input format: %s", value)
279}
280
281// evaluateCalcExpression recursively evaluates 'calc()' expressions
282func evaluateCalcExpression(expression string, em, max float32) (float32, error) {
283	terms := strings.FieldsFunc(expression, func(c rune) bool {
284		return c == '+' || c == '-' || c == '*' || c == '/'
285	})
286
287	operators := strings.FieldsFunc(expression, func(c rune) bool {
288		return c != '+' && c != '-' && c != '*' && c != '/'
289	})
290
291	var result float32
292
293	for i, term := range terms {
294		value, err := ConvertToPixels(strings.TrimSpace(term), em, max)
295		if err != nil {
296			return 0, err
297		}
298
299		if i > 0 {
300			switch operators[i-1] {
301			case "+":
302				result += value
303			case "-":
304				result -= value
305			case "*":
306				result *= value
307			case "/":
308				if value != 0 {
309					result /= value
310				} else {
311					return 0, fmt.Errorf("division by zero in 'calc()' expression")
312				}
313			}
314		} else {
315			result = value
316		}
317	}
318
319	return result, nil
320}
321
322func GetTextBounds(text string, fontSize, width, height float32) (float32, float32) {
323	w := float32(len(text) * int(fontSize))
324	h := fontSize
325	if width > 0 && height > 0 {
326		if w > width {
327			height = Max(height, float32(math.Ceil(float64(w/width)))*h)
328		}
329		return width, height
330	} else {
331		return w, h
332	}
333
334}
335
336func Merge(m1, m2 map[string]string) map[string]string {
337	// Create a new map and copy m1 into it
338	result := make(map[string]string)
339	for k, v := range m1 {
340		result[k] = v
341	}
342
343	// Merge m2 into the new map
344	for k, v := range m2 {
345		result[k] = v
346	}
347
348	return result
349}
350
351func ExMerge(m1, m2 map[string]string) map[string]string {
352	// Create a new map and copy m1 into it
353	result := make(map[string]string)
354	for k, v := range m1 {
355		result[k] = v
356	}
357
358	// Merge m2 into the new map only if the key is not already present
359	for k, v := range m2 {
360		if result[k] == "" {
361			result[k] = v
362		}
363	}
364
365	return result
366}
367
368func Max(a, b float32) float32 {
369	if a > b {
370		return a
371	} else {
372		return b
373	}
374}
375
376func Min(a, b float32) float32 {
377	if a < b {
378		return a
379	} else {
380		return b
381	}
382}
383
384func FindRelative(n *element.Node, styleMap map[string]map[string]string) (float32, float32) {
385	pos := styleMap[n.Properties.Id]["position"]
386
387	if pos == "relative" {
388		x, _ := strconv.ParseFloat(styleMap[n.Properties.Id]["x"], 32)
389		y, _ := strconv.ParseFloat(styleMap[n.Properties.Id]["y"], 32)
390		return float32(x), float32(y)
391	} else {
392		if n.Parent != nil {
393			x, y := FindRelative(n.Parent, styleMap)
394			return x, y
395		} else {
396			return 0, 0
397		}
398	}
399}
400
401func ParseFloat(str string, def float32) float32 {
402	var a float32
403	if str == "" {
404		a = 0
405	} else {
406		v, _ := strconv.ParseFloat(str, 32)
407		a = float32(v)
408	}
409	return a
410}
411
412// getStructField uses reflection to get the value of a struct field by name
413func GetStructField(data interface{}, fieldName string) (interface{}, error) {
414	val := reflect.ValueOf(data)
415
416	// Make sure we have a pointer to a struct
417	if val.Kind() != reflect.Ptr || val.Elem().Kind() != reflect.Struct {
418		return nil, fmt.Errorf("expected a pointer to a struct")
419	}
420
421	// Get the struct field by name
422	field := val.Elem().FieldByName(fieldName)
423
424	// Check if the field exists
425	if !field.IsValid() {
426		return nil, fmt.Errorf("field not found: %s", fieldName)
427	}
428
429	return field.Interface(), nil
430}
431
432func SetStructFieldValue(data interface{}, fieldName string, newValue interface{}) error {
433	val := reflect.ValueOf(data)
434
435	// Make sure we have a pointer to a struct
436	if val.Kind() != reflect.Ptr || val.Elem().Kind() != reflect.Struct {
437		return fmt.Errorf("expected a pointer to a struct")
438	}
439
440	// Get the struct field by name
441	field := val.Elem().FieldByName(fieldName)
442
443	// Check if the field exists
444	if !field.IsValid() {
445		return fmt.Errorf("field not found: %s", fieldName)
446	}
447
448	// Check if the new value type is assignable to the field type
449	if !reflect.ValueOf(newValue).Type().AssignableTo(field.Type()) {
450		return fmt.Errorf("incompatible types for field %s", fieldName)
451	}
452
453	// Set the new value
454	field.Set(reflect.ValueOf(newValue))
455
456	return nil
457}
458
459func Check(e error) {
460	if e != nil {
461		panic(e)
462	}
463}
464
465func GetInnerText(n *html.Node) string {
466	var result strings.Builder
467
468	var getText func(*html.Node)
469	getText = func(n *html.Node) {
470		if n.Type == html.TextNode {
471			result.WriteString(n.Data)
472		}
473
474		for c := n.FirstChild; c != nil; c = c.NextSibling {
475			getText(c)
476		}
477	}
478
479	getText(n)
480
481	return result.String()
482}
483
484func GetPositionOffsetNode(n *element.Node) *element.Node {
485	pos := n.Style["position"]
486
487	if pos == "relative" {
488		return n
489	} else {
490		if n.Parent.TagName != "ROOT" {
491			if n.Parent.Style != nil {
492				return GetPositionOffsetNode(n.Parent)
493			} else {
494				return nil
495			}
496		} else {
497			return n.Parent
498		}
499	}
500}
501
502func IsParent(n element.Node, name string) bool {
503	if n.Parent.TagName != "ROOT" {
504		if n.Parent.TagName == name {
505			return true
506		} else {
507			return IsParent(*n.Parent, name)
508		}
509	} else {
510		return false
511	}
512}