Documentation

Overview

Package op implements operations for updating a user interface.

Gio programs use operations, or ops, for describing their user interfaces. There are operations for drawing, defining input handlers, changing window properties as well as operations for controlling the execution of other operations.

Ops represents a list of operations. The most important use for an Ops list is to describe a complete user interface update to a ui/app.Window's Update method.

Drawing a colored square:

import "gioui.org/unit"
import "gioui.org/app"
import "gioui.org/op/paint"

var w app.Window
var e system.FrameEvent
ops := new(op.Ops)
...
ops.Reset()
paint.ColorOp{Color: ...}.Add(ops)
paint.PaintOp{Rect: ...}.Add(ops)
e.Frame(ops)

State

An Ops list can be viewed as a very simple virtual machine: it has an implicit mutable state stack and execution flow can be controlled with macros.

The Save function saves the current state for later restoring:

ops := new(op.Ops)
// Save the current state, in particular the transform.
state := op.Save(ops)
// Apply a transform to subsequent operations.
op.Offset(...).Add(ops)
...
// Restore the previous transform.
state.Load()

You can also use this one-line to save the current state and restore it at the end of a function :

defer op.Save(ops).Load()

The MacroOp records a list of operations to be executed later:

ops := new(op.Ops)
macro := op.Record(ops)
// Record operations by adding them.
op.InvalidateOp{}.Add(ops)
...
// End recording.
call := macro.Stop()

// replay the recorded operations:
call.Add(ops)

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Defer

func Defer(o *Ops, c CallOp)

    Defer executes c after all other operations have completed, including previously deferred operations. Defer saves the current transformation and restores it prior to execution. All other operation state is reset.

    Note that deferred operations are executed in first-in-first-out order, unlike the Go facility of the same name.

    Types

    type CallOp

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

      CallOp invokes the operations recorded by Record.

      func (CallOp) Add

      func (c CallOp) Add(o *Ops)

        Add the recorded list of operations. Add panics if the Ops containing the recording has been reset.

        type InvalidateOp

        type InvalidateOp struct {
        	At time.Time
        }

          InvalidateOp requests a redraw at the given time. Use the zero value to request an immediate redraw.

          func (InvalidateOp) Add

          func (r InvalidateOp) Add(o *Ops)

          type MacroOp

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

            MacroOp records a list of operations for later use.

            func Record

            func Record(o *Ops) MacroOp

              Record a macro of operations.

              func (MacroOp) Stop

              func (m MacroOp) Stop() CallOp

                Stop ends a previously started recording and returns an operation for replaying it.

                type Ops

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

                  Ops holds a list of operations. Operations are stored in serialized form to avoid garbage during construction of the ops list.

                  func (*Ops) Data

                  func (o *Ops) Data() []byte

                    Data is for internal use only.

                    func (*Ops) Refs

                    func (o *Ops) Refs() []interface{}

                      Refs is for internal use only.

                      func (*Ops) Reset

                      func (o *Ops) Reset()

                        Reset the Ops, preparing it for re-use. Reset invalidates any recorded macros.

                        func (*Ops) Version

                        func (o *Ops) Version() int

                          Version is for internal use only.

                          func (*Ops) Write

                          func (o *Ops) Write(n int) []byte

                            Write is for internal use only.

                            func (*Ops) Write1

                            func (o *Ops) Write1(n int, ref1 interface{}) []byte

                              Write1 is for internal use only.

                              func (*Ops) Write2

                              func (o *Ops) Write2(n int, ref1, ref2 interface{}) []byte

                                Write2 is for internal use only.

                                type StateOp

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

                                  StateOp represents a saved operation snapshop to be restored later.

                                  func Save

                                  func Save(o *Ops) StateOp

                                    Save the current operations state.

                                    func (StateOp) Load

                                    func (s StateOp) Load()

                                      Load a previously saved operations state.

                                      type TransformOp

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

                                        TransformOp applies a transform to the current transform. The zero value for TransformOp represents the identity transform.

                                        func Affine

                                        func Affine(a f32.Affine2D) TransformOp

                                          Affine creates a TransformOp representing the transformation a.

                                          func Offset

                                          func Offset(o f32.Point) TransformOp

                                            Offset creates a TransformOp with the offset o.

                                            func (TransformOp) Add

                                            func (t TransformOp) Add(o *Ops)

                                            Source Files

                                            Directories

                                            Path Synopsis
                                            Package clip provides operations for clipping paint operations.
                                            Package clip provides operations for clipping paint operations.
                                            Package paint provides drawing operations for 2D graphics.
                                            Package paint provides drawing operations for 2D graphics.