updated to raylib

icons.go

@@ -0,0 +1,164 @@
+package main
+
+import (
+	"math"
+
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+// drawBrowserIcon now draws:
+// - Semi-transparent rounded square background with color mixing based on contrast/theme
+// - 1px accent outline inside (replaced by outside highlight in steps.go highlight function? Here we still draw 1px line)
+// - A 1px horizontal top line
+// - An 'X' in the top-right corner
+//
+// Background mixing and accent colors are adjusted for better contrast in light theme.
+func drawBrowserIcon(x, y, width, height float32, theme string, col rl.Color, contrastLevel int) {
+	roundness := float32(0.2)
+	segments := int32(8)
+
+	accentColor := getAccentColorForContrast(col, contrastLevel, theme)
+	bgColor := getMixedBackgroundColor(theme, col, contrastLevel)
+	bgColor.A = 200 // semi-transparent background
+
+	r := rl.Rectangle{X: x, Y: y, Width: width, Height: height}
+	rl.DrawRectangleRounded(r, roundness, segments, bgColor)
+
+	// Draw 1px accent outline inside the shape
+	rl.DrawRectangleRoundedLines(r, roundness, segments, accentColor)
+
+	// Horizontal top line
+	lineY := y + 10
+	startX := x + 5
+	endX := x + width - 5
+	rl.DrawLine(int32(startX), int32(lineY), int32(endX), int32(lineY), accentColor)
+
+	// 'X' close button in top-right corner
+	xRight := endX - 5
+	xLeft := xRight - 4
+	yTop := y + 4
+	yBottom := yTop + 4
+	rl.DrawLine(int32(xLeft), int32(yTop), int32(xRight), int32(yBottom), accentColor)
+	rl.DrawLine(int32(xLeft), int32(yBottom), int32(xRight), int32(yTop), accentColor)
+}
+
+// getMixedBackgroundColor creates a background that mixes the base theme color with the accent color differently
+// based on contrast for better visibility in light theme.
+func getMixedBackgroundColor(theme string, baseColor rl.Color, contrastLevel int) rl.Color {
+	var base rl.Color
+	if theme == "Light" {
+		// Use a slightly darker off-white to ensure lines stand out
+		base = rl.Color{R: 240, G: 240, B: 240, A: 255}
+	} else {
+		base = rl.Color{R: 20, G: 20, B: 20, A: 255}
+	}
+
+	// Default accent reference
+	accent := getAccentColorForContrast(baseColor, 1, theme)
+
+	var factor float32
+	switch contrastLevel {
+	case 0:
+		factor = 0.0
+	case 1:
+		factor = 0.2
+	case 2:
+		factor = 0.5
+	}
+
+	return blendColors(base, accent, factor)
+}
+
+func blendColors(c1, c2 rl.Color, factor float32) rl.Color {
+	R := float32(c1.R)*(1-factor) + float32(c2.R)*factor
+	G := float32(c1.G)*(1-factor) + float32(c2.G)*factor
+	B := float32(c1.B)*(1-factor) + float32(c2.B)*factor
+	return rl.Color{R: uint8(R), G: uint8(G), B: uint8(B), A: 255}
+}
+
+func getAccentColorForContrast(base rl.Color, contrastLevel int, theme string) rl.Color {
+	h, s, v := rgbToHsv(base.R, base.G, base.B)
+	switch contrastLevel {
+	case 0: // Low contrast
+		s *= 0.2
+		v *= 0.8
+	case 1: // Default
+		if theme == "Light" {
+			// Clamp v lower so line is visible against light bg
+			if v > 0.6 {
+				v = 0.6
+			}
+		} else {
+			v *= 0.9
+		}
+	case 2: // High
+		s = float32(math.Min(float64(s*1.5), 1.0))
+		if theme == "Light" {
+			if v < 0.7 {
+				v = 0.7
+			}
+		} else {
+			v = float32(math.Min(float64(v*1.1), 1.0))
+		}
+	}
+	r, g, b := hsvToRgb(h, s, v)
+	return rl.Color{R: r, G: g, B: b, A: 255}
+}
+
+func rgbToHsv(r, g, b uint8) (float32, float32, float32) {
+	R := float32(r) / 255.0
+	G := float32(g) / 255.0
+	B := float32(b) / 255.0
+
+	max := float32(math.Max(math.Max(float64(R), float64(G)), float64(B)))
+	min := float32(math.Min(math.Min(float64(R), float64(G)), float64(B)))
+	delta := max - min
+
+	var h float32
+	if delta < 0.00001 {
+		h = 0
+	} else if max == R {
+		h = (G - B) / delta
+		if G < B {
+			h += 6
+		}
+	} else if max == G {
+		h = (B-R)/delta + 2
+	} else {
+		h = (R-G)/delta + 4
+	}
+	h *= 60.0 / 360.0
+
+	s := float32(0)
+	if max > 0 {
+		s = delta / max
+	}
+	v := max
+	return h, s, v
+}
+
+func hsvToRgb(h, s, v float32) (uint8, uint8, uint8) {
+	h = h * 6.0
+	i := int(math.Floor(float64(h)))
+	f := h - float32(i)
+	p := v * (1 - s)
+	q := v * (1 - s*f)
+	t := v * (1 - s*(1-f))
+
+	var R, G, B float32
+	switch i {
+	case 0:
+		R, G, B = v, t, p
+	case 1:
+		R, G, B = q, v, p
+	case 2:
+		R, G, B = p, v, t
+	case 3:
+		R, G, B = p, q, v
+	case 4:
+		R, G, B = t, p, v
+	default:
+		R, G, B = v, p, q
+	}
+	return uint8(R * 255), uint8(G * 255), uint8(B * 255)
+}