graphics

type BlendMode int

type Brush interface {
	ApplyTo(size geometry.Size, p *Paint, alpha float32)
	IntrinsicSize() geometry.Size
	// contains filtered or unexported methods
}

type Canvas interface {
	// Save saves a copy of the current transform and clip on the save stack.
	Save()

	// Restore pops the current save stack, restoring the previous transform and clip.
	Restore()

	// SaveLayer saves the current state and creates a new group for subsequent operations.
	// When restored, the layer is composited into the previous layer using the paint's blend mode.
	SaveLayer(bounds geometry.Rect, paint *Paint)

	// Translate shifts the coordinate space by the given delta.
	Translate(dx, dy float32)

	// Scale scales the coordinate space by the given factors.
	Scale(sx, sy float32)

	// Rotate rotates the coordinate space by the given degrees clockwise.
	Rotate(degrees float32)

	// Skew applies an axis-aligned skew transformation.
	Skew(sx, sy float32)

	// Concat multiplies the current transform by the specified matrix.
	Concat(matrix Matrix)

	// ClipRect reduces the clip region to the intersection of the current clip and the given rectangle.
	ClipRect(left, top, right, bottom float32, clipOp ClipOp)

	// ClipPath reduces the clip region to the intersection of the current clip and the given path.
	ClipPath(path Path, clipOp ClipOp)

	// DrawLine draws a line between the given points.
	DrawLine(p1, p2 geometry.Offset, paint *Paint)

	// DrawRect draws a rectangle.
	DrawRect(left, top, right, bottom float32, paint *Paint)

	// DrawRoundRect draws a rounded rectangle.
	DrawRoundRect(left, top, right, bottom, radiusX, radiusY float32, paint *Paint)

	// DrawOval draws an axis-aligned oval that fills the given rectangle.
	DrawOval(left, top, right, bottom float32, paint *Paint)

	// DrawCircle draws a circle at the given center with the given radius.
	DrawCircle(center geometry.Offset, radius float32, paint *Paint)

	// DrawArc draws an arc scaled to fit inside the given rectangle.
	DrawArc(left, top, right, bottom, startAngle, sweepAngle float32, useCenter bool, paint *Paint)

	// DrawPath draws the given path.
	DrawPath(path Path, paint *Paint)

	// DrawImage draws an image at the given offset.
	DrawImage(image ImageBitmap, topLeftOffset geometry.Offset, paint *Paint)

	// DrawImageRect draws a portion of an image into a destination rectangle.
	DrawImageRect(image ImageBitmap, srcOffset IntOffset, srcSize IntSize, dstOffset IntOffset, dstSize IntSize, paint *Paint)

	// DrawPoints draws a sequence of points according to the given PointMode.
	DrawPoints(pointMode PointMode, points []geometry.Offset, paint *Paint)

	// EnableZ enables Z-ordering for 3D-like effects (Android-specific, may be no-op on other platforms).
	EnableZ()

	// DisableZ disables Z-ordering.
	DisableZ()
}

type CanvasDrawScope struct {
	// contains filtered or unexported fields
}

type ClipOp int

type Color uint64

type ColorCopyOption func(*ColorCopyOptions) ColorCopyOptions

type ColorCopyOptions struct {
	Alpha, Red, Green, Blue float32
}

type ColorProducer func() Color

type CompositeShader struct {
	Dst       Shader
	Src       Shader
	BlendMode BlendMode
}

type ContentDrawScope interface {
	DrawScope

	// DrawContent causes child drawing operations to run.
	// If not called, the contents of the layout will not be drawn.
	DrawContent()
}

type DrawArcOption func(*drawArcConfig)

type DrawCircleOption func(*drawCircleConfig)

type DrawContext interface {
	// Size returns the current size of the drawing environment.
	Size() geometry.Size

	// SetSize sets the size of the drawing environment.
	SetSize(size geometry.Size)

	// Canvas returns the target canvas to issue drawing commands.
	Canvas() Canvas

	// SetCanvas sets the target canvas.
	SetCanvas(canvas Canvas)

	// Transform returns the controller for issuing transformations.
	Transform() DrawTransform

	// LayoutDirection returns the layout direction of the layout being drawn.
	LayoutDirection() unit.LayoutDirection

	// SetLayoutDirection sets the layout direction.
	SetLayoutDirection(ld unit.LayoutDirection)

	// Density returns the density used for dp/sp conversions.
	Density() unit.Density

	// SetDensity sets the density.
	SetDensity(d unit.Density)

	// GraphicsLayer returns the current graphics layer, if any.
	// May return nil if not drawing into a graphics layer.
	GraphicsLayer() interface{}

	// SetGraphicsLayer sets the current graphics layer.
	SetGraphicsLayer(layer interface{})
}

type DrawImageOption func(*drawImageConfig)

type DrawLineOption func(*drawLineConfig)

type DrawOvalOption func(*drawOvalConfig)

type DrawPathOption func(*drawPathConfig)

type DrawPointsOption func(*drawPointsConfig)

type DrawRectOption func(*drawRectConfig)

type DrawRoundRectOption func(*drawRoundRectConfig)

type DrawScope interface {
	unit.Density

	// DrawContext returns the underlying draw context.
	DrawContext() DrawContext

	// LayoutDirection returns the layout direction of the layout being drawn.
	LayoutDirection() unit.LayoutDirection

	// Size returns the current size of the drawing environment.
	Size() geometry.Size

	// Center returns the center of the current drawing environment.
	Center() geometry.Offset

	// DrawLine draws a line between the given points using a color.
	DrawLine(color Color, start, end geometry.Offset, opts ...DrawLineOption)

	// DrawLineWithBrush draws a line between the given points using a brush.
	DrawLineWithBrush(brush Brush, start, end geometry.Offset, opts ...DrawLineOption)

	// DrawRect draws a rectangle with the given color.
	DrawRect(color Color, opts ...DrawRectOption)

	// DrawRectWithBrush draws a rectangle with the given brush.
	DrawRectWithBrush(brush Brush, opts ...DrawRectOption)

	// DrawRoundRect draws a rounded rectangle with the given color.
	DrawRoundRect(color Color, opts ...DrawRoundRectOption)

	// DrawRoundRectWithBrush draws a rounded rectangle with the given brush.
	DrawRoundRectWithBrush(brush Brush, opts ...DrawRoundRectOption)

	// DrawCircle draws a circle with the given color.
	DrawCircle(color Color, opts ...DrawCircleOption)

	// DrawCircleWithBrush draws a circle with the given brush.
	DrawCircleWithBrush(brush Brush, opts ...DrawCircleOption)

	// DrawOval draws an oval with the given color.
	DrawOval(color Color, opts ...DrawOvalOption)

	// DrawOvalWithBrush draws an oval with the given brush.
	DrawOvalWithBrush(brush Brush, opts ...DrawOvalOption)

	// DrawArc draws an arc with the given color.
	DrawArc(color Color, startAngle, sweepAngle float32, useCenter bool, opts ...DrawArcOption)

	// DrawArcWithBrush draws an arc with the given brush.
	DrawArcWithBrush(brush Brush, startAngle, sweepAngle float32, useCenter bool, opts ...DrawArcOption)

	// DrawPath draws a path with the given color.
	DrawPath(path Path, color Color, opts ...DrawPathOption)

	// DrawPathWithBrush draws a path with the given brush.
	DrawPathWithBrush(path Path, brush Brush, opts ...DrawPathOption)

	// DrawPoints draws a sequence of points with the given color.
	DrawPoints(points []geometry.Offset, pointMode PointMode, color Color, opts ...DrawPointsOption)

	// DrawPointsWithBrush draws a sequence of points with the given brush.
	DrawPointsWithBrush(points []geometry.Offset, pointMode PointMode, brush Brush, opts ...DrawPointsOption)

	// DrawImage draws an image at the given offset.
	DrawImage(image ImageBitmap, opts ...DrawImageOption)

	// DrawIntoCanvas provides direct access to the underlying canvas.
	DrawIntoCanvas(block func(Canvas))
}

type DrawStyle interface {
	// contains filtered or unexported methods
}

type DrawTransform interface {
	// Size returns the current size of the drawing environment.
	Size() geometry.Size

	// Center returns the center offset of the current transformation.
	Center() geometry.Offset

	// Inset simultaneously translates the coordinate space and modifies the drawing bounds.
	// The width becomes width - (left + right), height becomes height - (top + bottom).
	Inset(left, top, right, bottom float32)

	// ClipRect reduces the clip region to the intersection of the current clip
	// and the given rectangle.
	ClipRect(left, top, right, bottom float32, clipOp ClipOp)

	// ClipPath reduces the clip region to the intersection of the current clip
	// and the given path.
	ClipPath(path Path, clipOp ClipOp)

	// Translate translates the coordinate space by the given delta.
	Translate(left, top float32)

	// Rotate adds a rotation (in degrees clockwise) to the current transform
	// at the given pivot point.
	Rotate(degrees float32, pivot geometry.Offset)

	// Scale adds an axis-aligned scale to the current transform at the given pivot point.
	Scale(scaleX, scaleY float32, pivot geometry.Offset)

	// Transform applies the given transformation matrix to the drawing environment.
	Transform(matrix Matrix)
}

type ImageBitmap interface {
	// Width returns the width of the image in pixels.
	Width() int

	// Height returns the height of the image in pixels.
	Height() int

	// Size returns the size of the image.
	Size() geometry.Size
}

type ImageResource struct {
	ImageOp paint.ImageOp
}

type IntOffset struct {
	X int
	Y int
}

type IntSize struct {
	Width  int
	Height int
}

type LinearGradient struct {
	Colors   []Color
	Stops    []float32
	Start    geometry.Offset
	End      geometry.Offset
	TileMode TileMode
}

type LinearGradientShader struct {
	Colors     []Color
	ColorStops []float32
	From       Offset
	To         Offset
	TileMode   TileMode
}

type Matrix [16]float32

type Offset = geometry.Offset

type Paint struct {
	Alpha       float32
	Color       Color
	Shader      Shader
	BlendMode   BlendMode
	StrokeWidth float32
}

type Path interface {
	// FillType returns the path fill type.
	FillType() PathFillType

	// SetFillType sets the path fill type.
	SetFillType(fillType PathFillType)

	// IsConvex returns true if the path is convex.
	IsConvex() bool

	// IsEmpty returns true if the path is empty (contains no lines or curves).
	IsEmpty() bool

	// MoveTo starts a new subpath at the given coordinate.
	MoveTo(x, y float32)

	// RelativeMoveTo starts a new subpath at the given offset from the current point.
	RelativeMoveTo(dx, dy float32)

	// LineTo adds a straight line segment from the current point to the given point.
	LineTo(x, y float32)

	// RelativeLineTo adds a straight line segment from the current point to the point
	// at the given offset from the current point.
	RelativeLineTo(dx, dy float32)

	// QuadraticTo adds a quadratic bezier segment that curves from the current point
	// to (x2, y2), using (x1, y1) as the control point.
	QuadraticTo(x1, y1, x2, y2 float32)

	// RelativeQuadraticTo adds a quadratic bezier segment using relative coordinates.
	RelativeQuadraticTo(dx1, dy1, dx2, dy2 float32)

	// CubicTo adds a cubic bezier segment that curves from the current point to (x3, y3),
	// using (x1, y1) and (x2, y2) as control points.
	CubicTo(x1, y1, x2, y2, x3, y3 float32)

	// RelativeCubicTo adds a cubic bezier segment using relative coordinates.
	RelativeCubicTo(dx1, dy1, dx2, dy2, dx3, dy3 float32)

	// ArcTo adds an arc segment from the current point.
	ArcTo(rect geometry.Rect, startAngleDegrees, sweepAngleDegrees float32, forceMoveTo bool)

	// AddRect adds a rectangle as a new subpath.
	AddRect(rect geometry.Rect, direction PathDirection)

	// AddOval adds an oval (ellipse) as a new subpath.
	AddOval(oval geometry.Rect, direction PathDirection)

	// AddArc adds an arc segment as a new subpath.
	AddArc(oval geometry.Rect, startAngleDegrees, sweepAngleDegrees float32)

	// AddPath adds another path to this path with an optional offset.
	AddPath(path Path, offset geometry.Offset)

	// Close closes the current subpath.
	Close()

	// Reset clears all subpaths from the path.
	Reset()

	// Rewind clears lines and curves but keeps internal data structure for faster reuse.
	Rewind()

	// Translate translates all segments by the given offset.
	Translate(offset geometry.Offset)

	// GetBounds computes the bounds of the control points of the path.
	GetBounds() geometry.Rect

	// Op performs a boolean operation on two paths.
	Op(path1, path2 Path, operation PathOperation) bool
}

type PathDirection int

type PathFillType int

type PathOperation int

type PointMode int

type RadialGradient struct {
	Colors   []Color
	Stops    []float32
	Center   geometry.Offset
	Radius   float32
	TileMode TileMode
}

type RadialGradientShader struct {
	Colors     []Color
	ColorStops []float32
	Center     Offset
	Radius     float32
	TileMode   TileMode
}

type Shader interface {
	// contains filtered or unexported methods
}

type ShaderBrush interface {
	Brush
	CreateShader(size geometry.Size) Shader
}

type ShaderBrushForTest struct{}

type Shadow struct {
	Color      Color   // Color of the shadow (typically with alpha)
	Offset     Offset  // Offset from the element
	BlurRadius float32 // Blur radius in pixels
}

type ShadowOption func(*Shadow)

type SolidColor struct {
	Value Color
}

type Stroke struct {
	// Width configures the width of the stroke in pixels.
	Width float32

	// Miter is the stroke miter value. Used to control the behavior of miter joins
	// when the joins angle is sharp. A value of 4.0 is the default.
	Miter float32

	// Cap is the treatment applied to the beginning and end of stroked lines and paths.
	Cap StrokeCap

	// Join is the treatment applied where lines and curve segments join on a stroked path.
	Join StrokeJoin

	// PathEffect is an optional effect to apply to the stroke.
	// Currently a placeholder - PathEffect interface needs separate implementation.
	PathEffect interface{}
}

type StrokeCap int

type StrokeJoin int

type SweepGradient struct {
	Center geometry.Offset
	Colors []Color
	Stops  []float32
}

type SweepGradientShader struct {
	Center     Offset
	Colors     []Color
	ColorStops []float32
}

type TileMode int