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 Border

    type Border struct {
    	// Rect is the bounds of the border.
    	Rect f32.Rectangle
    	// Width of the line tracing Rect.
    	Width  float32
    	Dashes DashSpec
    	// The corner radii.
    	SE, SW, NW, NE float32
    }

      Border represents a rectangular border.

      func (Border) Add

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

        Add the border clip.

        func (Border) Op

        func (b Border) Op(ops *op.Ops) Op

          Op returns the clip operation for the border. Its area corresponds to a stroked line that traces the border rectangle, optionally with rounded corners and dashes.

          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.

                            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) 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.

                                                      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 (
                                                                  	// 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 StrokeCap = iota
                                                                  
                                                                  	// 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
                                                                  
                                                                  	// 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
                                                                  )

                                                                  type StrokeJoin

                                                                  type StrokeJoin uint8

                                                                    StrokeJoin describes how stroked paths are collated.

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

                                                                    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.