key

type Caret ¶

type Caret struct {
	// Pos is the intersection point of the caret and its baseline.
	Pos f32.Point
	// Ascent is the length of the caret above its baseline.
	Ascent float32
	// Descent is the length of the caret below its baseline.
	Descent float32
}

Caret represents the position of a caret.

type EditEvent ¶

type EditEvent struct {
	// Range specifies the range to replace with Text.
	Range Range
	Text  string
}

An EditEvent requests an edit by an input method.

func (EditEvent) ImplementsEvent()

type Event ¶

type Event struct {
	// Name of the key. For letters, the upper case form is used, via
	// unicode.ToUpper. The shift modifier is taken into account, all other
	// modifiers are ignored. For example, the "shift-1" and "ctrl-shift-1"
	// combinations both give the Name "!" with the US keyboard layout.
	Name string
	// Modifiers is the set of active modifiers when the key was pressed.
	Modifiers Modifiers
	// State is the state of the key when the event was fired.
	State State
}

An Event is generated when a key is pressed. For text input use EditEvent.

func (Event) ImplementsEvent()

func (e Event) String() string

type FocusEvent ¶

type FocusEvent struct {
	Focus bool
}

A FocusEvent is generated when a handler gains or loses focus.

func (FocusEvent) ImplementsEvent()

type FocusOp ¶

type FocusOp struct {
	// Tag is the new focus. The focus is cleared if Tag is nil, or if Tag
	// has no InputOp in the same frame.
	Tag event.Tag
}

FocusOp sets or clears the keyboard focus. It replaces any previous FocusOp in the same frame.

func (h FocusOp) Add(o *op.Ops)

type InputHint ¶

type InputHint uint8

InputHint changes the on-screen-keyboard type. That hints the type of data that might be entered by the user.

const (
	// HintAny hints that any input is expected.
	HintAny InputHint = iota
	// HintText hints that text input is expected. It may activate auto-correction and suggestions.
	HintText
	// HintNumeric hints that numeric input is expected. It may activate shortcuts for 0-9, "." and ",".
	HintNumeric
	// HintEmail hints that email input is expected. It may activate shortcuts for common email characters, such as "@" and ".com".
	HintEmail
	// HintURL hints that URL input is expected. It may activate shortcuts for common URL fragments such as "/" and ".com".
	HintURL
	// HintTelephone hints that telephone number input is expected. It may activate shortcuts for 0-9, "#" and "*".
	HintTelephone
	// HintPassword hints that password input is expected. It may disable autocorrection and enable password autofill.
	HintPassword
)

type InputOp ¶

type InputOp struct {
	Tag event.Tag
	// Hint describes the type of text expected by Tag.
	Hint InputHint
	// Keys is the set of keys Tag can handle. That is, Tag will only
	// receive an Event if its key and modifiers are accepted by Keys.Contains.
	// As a special case, the topmost (first added) InputOp handler receives all
	// unhandled events.
	Keys Set
}

InputOp declares a handler ready for key events. Key events are in general only delivered to the focused key handler.

func (h InputOp) Add(o *op.Ops)

type Modifiers ¶

type Modifiers uint32

Modifiers

const (
	// ModCtrl is the ctrl modifier key.
	ModCtrl Modifiers = 1 << iota
	// ModCommand is the command modifier key
	// found on Apple keyboards.
	ModCommand
	// ModShift is the shift modifier key.
	ModShift
	// ModAlt is the alt modifier key, or the option
	// key on Apple keyboards.
	ModAlt
	// ModSuper is the "logo" modifier key, often
	// represented by a Windows logo.
	ModSuper
)

func (m Modifiers) Contain(m2 Modifiers) bool

func (m Modifiers) String() string

type Range ¶

type Range struct {
	Start int
	End   int
}

Range represents a range of text, such as an editor's selection. Start and End are in runes.

type SelectionEvent ¶

type SelectionEvent Range

SelectionEvent is generated when an input method changes the selection.

func (SelectionEvent) ImplementsEvent()

type SelectionOp ¶

type SelectionOp struct {
	Tag event.Tag
	Range
	Caret
}

SelectionOp updates the selection for an input handler.

func (s SelectionOp) Add(o *op.Ops)

type Set ¶

type Set string

Set is an expression that describes a set of key combinations, in the form "<modifiers>-<keyset>|...". Modifiers are separated by dashes, optional modifiers are enclosed by parentheses. A key set is either a literal key name or a list of key names separated by commas and enclosed in brackets.

The "Short" modifier matches the shortcut modifier (ModShortcut) and "ShortAlt" matches the alternative modifier (ModShortcutAlt).

Examples:

• A|B matches the A and B keys
• [A,B] also matches the A and B keys
• Shift-A matches A key if shift is pressed, and no other modifier.
• Shift-(Ctrl)-A matches A if shift is pressed, and optionally ctrl.

func (k Set) Contains(name string, mods Modifiers) bool

type Snippet ¶

type Snippet struct {
	Range
	Text string
}

Snippet represents a snippet of text content used for communicating between an editor and an input method.

type SnippetEvent ¶

type SnippetEvent Range

SnippetEvent is generated when the snippet range is updated by an input method.

func (SnippetEvent) ImplementsEvent()

type SnippetOp ¶

type SnippetOp struct {
	Tag event.Tag
	Snippet
}

SnippetOp updates the content snippet for an input handler.

func (s SnippetOp) Add(o *op.Ops)

type SoftKeyboardOp ¶

type SoftKeyboardOp struct {
	Show bool
}

SoftKeyboardOp shows or hide the on-screen keyboard, if available. It replaces any previous SoftKeyboardOp.

func (h SoftKeyboardOp) Add(o *op.Ops)

type State ¶

type State uint8

State is the state of a key during an event.

const (
	// Press is the state of a pressed key.
	Press State = iota
	// Release is the state of a key that has been released.
	//
	// Note: release events are only implemented on the following platforms:
	// macOS, Linux, Windows, WebAssembly.
	Release
)

func (s State) String() string