Documentation

Overview

    Package clip provides operations for clipping paint operations. Drawing outside the current clip area is ignored.

    The current clip is initially the infinite set. An Op sets the clip to the intersection of the current clip and the clip area it represents. If you need to reset the current clip to its value before applying an Op, use op.StackOp.

    General clipping areas are constructed with Path. Simpler special cases such as rectangular clip areas also exist as convenient constructors.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Circle

    type Circle struct {
    	Center f32.Point
    	Radius float32
    }

      Circle represents the clip area of a circle.

      func (Circle) Add

      func (c Circle) Add(ops *op.Ops)

        Add the circle clip.

        func (Circle) Op

        func (c Circle) Op(ops *op.Ops) Op

          Op returns the op for the circle.

          func (Circle) Path

          func (c Circle) Path(ops *op.Ops) PathSpec

            Path returns the PathSpec for the circle.

            type Dash

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

              Dash records dashes' lengths and phase for a stroked path.

              func (*Dash) Begin

              func (d *Dash) Begin(ops *op.Ops)

              func (*Dash) Dash

              func (d *Dash) Dash(length float32)

              func (*Dash) End

              func (d *Dash) End() DashSpec

              func (*Dash) Phase

              func (d *Dash) Phase(v float32)

              type DashSpec

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

                DashSpec describes a dashed pattern.

                type Op

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

                  Op represents a clip area. Op intersects the current clip area with itself.

                  func (Op) Add

                  func (p Op) Add(o *op.Ops)

                  type Outline

                  type Outline struct {
                  	Path PathSpec
                  }

                    Outline represents the area inside of a path, according to the non-zero winding rule.

                    func (Outline) Op

                    func (o Outline) Op() Op

                      Op returns a clip operation representing the outline.

                      type Path

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

                        Path constructs a Op clip path described by lines and Bézier curves, where drawing outside the Path is discarded. The inside-ness of a pixel is determines by the non-zero winding rule, similar to the SVG rule of the same name.

                        Path generates no garbage and can be used for dynamic paths; path data is stored directly in the Ops list supplied to Begin.

                        func (*Path) Arc

                        func (p *Path) Arc(f1, f2 f32.Point, angle float32)

                          Arc adds an elliptical arc to the path. The implied ellipse is defined by its focus points f1 and f2. The arc starts in the current point and ends angle radians along the ellipse boundary. The sign of angle determines the direction; positive being counter-clockwise, negative clockwise.

                          func (*Path) Begin

                          func (p *Path) Begin(ops *op.Ops)

                            Begin the path, storing the path data and final Op into ops.

                            func (*Path) Close

                            func (p *Path) Close()

                              Close closes the path contour.

                              func (*Path) Cube

                              func (p *Path) Cube(ctrl0, ctrl1, to f32.Point)

                                Cube records a cubic Bézier from the pen through two control points ending in to.

                                func (*Path) CubeTo

                                func (p *Path) CubeTo(ctrl0, ctrl1, to f32.Point)

                                  CubeTo records a cubic Bézier from the pen through two control points ending in to, with absolute coordinates.

                                  func (*Path) End

                                  func (p *Path) End() PathSpec

                                    End returns a PathSpec ready to use in clipping operations.

                                    func (*Path) Line

                                    func (p *Path) Line(delta f32.Point)

                                      Line moves the pen by the amount specified by delta, recording a line.

                                      func (*Path) LineTo

                                      func (p *Path) LineTo(to f32.Point)

                                        LineTo moves the pen to the absolute point specified, recording a line.

                                        func (*Path) Move

                                        func (p *Path) Move(delta f32.Point)

                                          Move moves the pen by the amount specified by delta.

                                          func (*Path) MoveTo

                                          func (p *Path) MoveTo(to f32.Point)

                                            MoveTo moves the pen to the specified absolute coordinate.

                                            func (*Path) Pos

                                            func (p *Path) Pos() f32.Point

                                              Pos returns the current pen position.

                                              func (*Path) Quad

                                              func (p *Path) Quad(ctrl, to f32.Point)

                                                Quad records a quadratic Bézier from the pen to end with the control point ctrl.

                                                func (*Path) QuadTo

                                                func (p *Path) QuadTo(ctrl, to f32.Point)

                                                  QuadTo records a quadratic Bézier from the pen to end with the control point ctrl, with absolute coordinates.

                                                  type PathSpec

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

                                                  type RRect

                                                  type RRect struct {
                                                  	Rect f32.Rectangle
                                                  	// The corner radii.
                                                  	SE, SW, NW, NE float32
                                                  }

                                                    RRect represents the clip area of a rectangle with rounded corners.

                                                    Specify a square with corner radii equal to half the square size to construct a circular clip area.

                                                    func UniformRRect

                                                    func UniformRRect(rect f32.Rectangle, radius float32) RRect

                                                      UniformRRect returns an RRect with all corner radii set to the provided radius.

                                                      func (RRect) Add

                                                      func (rr RRect) Add(ops *op.Ops)

                                                        Add the rectangle clip.

                                                        func (RRect) Op

                                                        func (rr RRect) Op(ops *op.Ops) Op

                                                          Op returns the op for the rounded rectangle.

                                                          func (RRect) Path

                                                          func (rr RRect) Path(ops *op.Ops) PathSpec

                                                            Path returns the PathSpec for the rounded rectangle.

                                                            type Rect

                                                            type Rect image.Rectangle

                                                              Rect represents the clip area of a pixel-aligned rectangle.

                                                              func (Rect) Add

                                                              func (r Rect) Add(ops *op.Ops)

                                                                Add the clip operation.

                                                                func (Rect) Op

                                                                func (r Rect) Op() Op

                                                                  Op returns the op for the rectangle.

                                                                  type Stroke

                                                                  type Stroke struct {
                                                                  	Path  PathSpec
                                                                  	Style StrokeStyle
                                                                  
                                                                  	// Dashes specify the dashes of the stroke.
                                                                  	// The empty value denotes no dashes.
                                                                  	Dashes DashSpec
                                                                  }

                                                                    Stroke represents a stroked path.

                                                                    func (Stroke) Op

                                                                    func (s Stroke) Op() Op

                                                                      Op returns a clip operation representing the stroke.

                                                                      type StrokeCap

                                                                      type StrokeCap uint8

                                                                        StrokeCap describes the head or tail of a stroked path.

                                                                        const (
                                                                        	// RoundCap caps stroked paths with a round cap, joining the right-hand and
                                                                        	// left-hand sides of a stroked path with a half disc of diameter the
                                                                        	// stroked path's width.
                                                                        	RoundCap StrokeCap = iota
                                                                        
                                                                        	// FlatCap caps stroked paths with a flat cap, joining the right-hand
                                                                        	// and left-hand sides of a stroked path with a straight line.
                                                                        	FlatCap
                                                                        
                                                                        	// SquareCap caps stroked paths with a square cap, joining the right-hand
                                                                        	// and left-hand sides of a stroked path with a half square of length
                                                                        	// the stroked path's width.
                                                                        	SquareCap
                                                                        )

                                                                        type StrokeJoin

                                                                        type StrokeJoin uint8

                                                                          StrokeJoin describes how stroked paths are collated.

                                                                          const (
                                                                          	// RoundJoin joins path segments with a round segment.
                                                                          	RoundJoin StrokeJoin = iota
                                                                          
                                                                          	// BevelJoin joins path segments with sharp bevels.
                                                                          	BevelJoin
                                                                          )

                                                                          type StrokeStyle

                                                                          type StrokeStyle struct {
                                                                          	Width float32 // Width of the stroked path.
                                                                          
                                                                          	// Miter is the limit to apply to a miter joint.
                                                                          	// The zero Miter disables the miter joint; setting Miter to +∞
                                                                          	// unconditionally enables the miter joint.
                                                                          	Miter float32
                                                                          	Cap   StrokeCap  // Cap describes the head or tail of a stroked path.
                                                                          	Join  StrokeJoin // Join describes how stroked paths are collated.
                                                                          }

                                                                            StrokeStyle describes how a path should be stroked.