func (a TextAlign) Float64() float64 {
	switch a {
	case TextAlignCenter:
		return 0.5
	case TextAlignRight:
		return 1.0
	default:
		return 0.0
	}
}

func Hex(hex uint32) Color {
	return Color{
		R:	float32((hex>>16)&0xFF) / colorMax8,
		G:	float32((hex>>8)&0xFF) / colorMax8,
		B:	float32(hex&0xFF) / colorMax8,
		A:	1,
	}
}

func HexA(hex uint32) Color {
	return Color{
		R:	float32((hex>>24)&0xFF) / colorMax8,
		G:	float32((hex>>16)&0xFF) / colorMax8,
		B:	float32((hex>>8)&0xFF) / colorMax8,
		A:	float32(hex&0xFF) / colorMax8,
	}
}

func (c Color) IsOpaque() bool {
	return c.A >= 1.0
}

func (c Color) IsTransparent() bool {
	return c.A <= 0.0
}

func (c Color) Lerp(other Color, t float32) Color {
	return Color{
		R:	c.R + (other.R-c.R)*t,
		G:	c.G + (other.G-c.G)*t,
		B:	c.B + (other.B-c.B)*t,
		A:	c.A + (other.A-c.A)*t,
	}
}

func RGB(r, g, b float32) Color {
	return Color{R: r, G: g, B: b, A: 1}
}

func RGB8(r, g, b uint8) Color {
	return Color{
		R:	float32(r) / colorMax8,
		G:	float32(g) / colorMax8,
		B:	float32(b) / colorMax8,
		A:	1,
	}
}

func RGBA(r, g, b, a float32) Color {
	return Color{R: r, G: g, B: b, A: a}
}

func RGBA8(r, g, b, a uint8) Color {
	return Color{
		R:	float32(r) / colorMax8,
		G:	float32(g) / colorMax8,
		B:	float32(b) / colorMax8,
		A:	float32(a) / colorMax8,
	}
}

func (c Color) RGBA8() (r, g, b, a uint8) {
	return uint8(clamp01(c.R) * colorMax8),
		uint8(clamp01(c.G) * colorMax8),
		uint8(clamp01(c.B) * colorMax8),
		uint8(clamp01(c.A) * colorMax8)
}

func (a TextAlign) String() string {
	if int(a) < len(textAlignNames) {
		return textAlignNames[a]
	}
	return unknownStr
}

func (m TextMode) String() string {
	if int(m) >= 0 && int(m) < len(textModeNames) {
		return textModeNames[m]
	}
	return unknownStr
}

func (c Color) WithAlpha(a float32) Color {
	return Color{R: c.R, G: c.G, B: c.B, A: a}
}

type TextStyle struct {
	// FontFamily is the font family name (e.g., "Inter", "NotoSansCJK").
	// Empty string falls back to the default embedded font.
	FontFamily	string

	// FontSize is the font size in logical pixels.
	FontSize	float32

	// Bold selects bold weight (700). When false, regular weight (400) is used.
	Bold	bool

	// Italic selects italic style. When false, normal style is used.
	Italic	bool

	// Color is the text color.
	Color	Color

	// Align controls horizontal text alignment within bounds.
	Align	TextAlign
}

type Color struct {
	R, G, B, A float32
}

type Canvas interface {
	// Clear fills the entire canvas with the given color.
	Clear(color Color)

	// DrawRect fills a rectangle with the given color.
	DrawRect(r geometry.Rect, color Color)

	// FillRectDirect fills a rectangle using CPU-only rendering, bypassing
	// the GPU shape accelerator. Used for dirty-region background clearing
	// where GPU acceleration is counterproductive (it blocks the compositor
	// non-MSAA blit-only fast path, causing 10x GPU overhead).
	FillRectDirect(r geometry.Rect, color Color)

	// StrokeRect draws the outline of a rectangle.
	//
	// The strokeWidth specifies the line thickness in logical pixels.
	StrokeRect(r geometry.Rect, color Color, strokeWidth float32)

	// DrawRoundRect fills a rounded rectangle with the given color.
	//
	// The radius specifies the corner radius.
	DrawRoundRect(r geometry.Rect, color Color, radius float32)

	// StrokeRoundRect draws the outline of a rounded rectangle.
	StrokeRoundRect(r geometry.Rect, color Color, radius float32, strokeWidth float32)

	// DrawCircle fills a circle with the given color.
	//
	// The center and radius specify the circle geometry.
	DrawCircle(center geometry.Point, radius float32, color Color)

	// StrokeCircle draws the outline of a circle.
	StrokeCircle(center geometry.Point, radius float32, color Color, strokeWidth float32)

	// StrokeArc draws a circular arc outline from startAngle with the given sweep.
	// Angles are in radians. startAngle=0 is 3 o'clock, positive is counterclockwise.
	// The arc is rendered as a single stroke operation using cubic Bézier curves.
	StrokeArc(center geometry.Point, radius float32, startAngle, sweepAngle float64,
		color Color, strokeWidth float32)

	// DrawLine draws a line between two points.
	DrawLine(from, to geometry.Point, color Color, strokeWidth float32)

	// DrawText draws text within the given bounding rectangle.
	//
	// The fontSize is in logical pixels. The bold flag selects bold weight.
	// The align parameter controls horizontal alignment.
	DrawText(text string, bounds geometry.Rect, fontSize float32, color Color, bold bool, align TextAlign)

	// MeasureText returns the width in pixels of the given text string
	// when rendered at the specified font size and weight.
	// This is essential for accurate cursor positioning in text fields.
	MeasureText(text string, fontSize float32, bold bool) float32

	// DrawImage draws an image at the specified position.
	//
	// The image is drawn with its top-left corner at the given point.
	// The image is composited using source-over blending. This method
	// is used by RepaintBoundary to blit cached subtree renders.
	DrawImage(img image.Image, at geometry.Point)

	// PushClip pushes a clipping rectangle onto the clip stack.
	//
	// All subsequent drawing operations will be clipped to this rectangle
	// intersected with any parent clip rectangles.
	PushClip(r geometry.Rect)

	// PushClipRoundRect pushes a rounded rectangle clipping region.
	//
	// All subsequent drawing operations will be clipped to this rounded
	// rectangle. Uses GPU SDF-based clipping when available (gg.ClipRoundRect).
	PushClipRoundRect(r geometry.Rect, radius float32)

	// PopClip removes the most recently pushed clipping region.
	//
	// Must be called for each PushClip or PushClipRoundRect call.
	PopClip()

	// PushTransform pushes a translation transform onto the transform stack.
	//
	// All subsequent drawing operations will be offset by the given point.
	PushTransform(offset geometry.Point)

	// PopTransform removes the most recently pushed transform.
	//
	// Must be called for each PushTransform call.
	PopTransform()

	// TransformOffset returns the current cumulative transform offset.
	//
	// This is the total translation applied by all PushTransform calls
	// currently on the transform stack.
	TransformOffset() geometry.Point

	// ScreenOriginBase returns the screen-space base offset for this canvas.
	//
	// For the main window canvas this is (0,0). For SceneCanvas inside
	// RepaintBoundary recording, this is the boundary widget's screen position.
	// Without this, PushTransform(-bounds.Min) for local coords makes
	// TransformOffset() return local values, and StampScreenOrigin computes
	// wrong ScreenOrigin → dirty.Collector reports regions at (0,0).
	//
	// Flutter equivalent: PaintingContext.offset in RenderObject.paint().
	ScreenOriginBase() geometry.Point

	// ClipBounds returns the current clip rectangle.
	//
	// This is the intersection of all PushClip/PushClipRoundRect regions
	// currently on the clip stack. Used for viewport culling: containers
	// skip Draw on children whose bounds don't intersect the clip region,
	// preventing offscreen widgets from ticking animations.
	ClipBounds() geometry.Rect

	// ReplayScene renders a previously recorded scene.Scene display list
	// into this canvas. Used by RepaintBoundary to replay cached content
	// without re-executing the child widget's Draw method.
	//
	// For Canvas (gg.Context wrapper): renders the scene via GPU scene
	// renderer, which routes commands through gg.Context's GPU accelerator.
	// For SceneCanvas: merges the child scene into the parent scene via
	// Scene.Append (O(commands), zero re-encoding).
	//
	// If s is nil or empty, this is a no-op.
	ReplayScene(s *scene.Scene)
}

type DamageController interface {
	SetDamageTracking(enabled bool)
}

type BoundaryRecorder interface {
	IsBoundaryRecording() bool
}

type ArcStroker interface {
	// StrokeArcStyled draws a circular arc with the specified line cap style.
	StrokeArcStyled(center geometry.Point, radius float32, startAngle, sweepAngle float64,
		color Color, strokeWidth float32, lineCap LineCap)
}

type SVGFiller interface {
	// FillSVGPath fills an SVG path within the given bounds.
	FillSVGPath(svgData string, viewBox float32, bounds geometry.Rect, color Color)
}

type SVGRenderer interface {
	// RenderSVG renders full SVG XML within the given bounds with color override.
	RenderSVG(svgXML []byte, bounds geometry.Rect, color Color)
}

type DeviceScaler interface {
	SetDeviceScale(scale float32)
}

type TextModeController interface {
	SetTextMode(mode TextMode)
	TextMode() TextMode
}

type StyledTextDrawer interface {
	// DrawStyledText draws text within the given bounding rectangle using
	// the font specified in the TextStyle. The font is resolved from the
	// global font registry using CSS weight matching.
	DrawStyledText(text string, bounds geometry.Rect, style TextStyle)

	// MeasureStyledText returns the width in pixels of the given text
	// when rendered with the specified TextStyle.
	MeasureStyledText(text string, style TextStyle) float32
}