242 lines
7.7 KiB
Go
242 lines
7.7 KiB
Go
// Package ability defines extended interfaces that elements can support.
|
|
package ability
|
|
|
|
import "image"
|
|
import "git.tebibyte.media/sashakoshka/tomo"
|
|
import "git.tebibyte.media/sashakoshka/tomo/input"
|
|
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
|
|
|
// Layoutable represents an element that needs to perform layout calculations
|
|
// before it can draw itself.
|
|
type Layoutable interface {
|
|
tomo.Element
|
|
|
|
// Layout causes this element to perform a layout operation.
|
|
Layout ()
|
|
}
|
|
|
|
// Container represents an element capable of containing child elements.
|
|
type Container interface {
|
|
tomo.Element
|
|
Layoutable
|
|
|
|
// DrawBackground causes the element to draw its background pattern to
|
|
// the specified canvas. The bounds of this canvas specify the area that
|
|
// is actually drawn to, while the Entity bounds specify the actual area
|
|
// of the element.
|
|
DrawBackground (artist.Canvas)
|
|
|
|
// HandleChildMinimumSizeChange is called when a child's minimum size is
|
|
// changed.
|
|
HandleChildMinimumSizeChange (child tomo.Element)
|
|
}
|
|
|
|
// Enableable represents an element that can be enabled and disabled. Disabled
|
|
// elements typically appear greyed out.
|
|
type Enableable interface {
|
|
tomo.Element
|
|
|
|
// Enabled returns whether or not the element is enabled.
|
|
Enabled () bool
|
|
|
|
// SetEnabled sets whether or not the element is enabled.
|
|
SetEnabled (bool)
|
|
}
|
|
|
|
// Focusable represents an element that has keyboard navigation support.
|
|
type Focusable interface {
|
|
tomo.Element
|
|
Enableable
|
|
|
|
// HandleFocusChange is called when the element is focused or unfocused.
|
|
HandleFocusChange ()
|
|
}
|
|
|
|
// Selectable represents an element that can be selected. This includes things
|
|
// like list items, files, etc. The difference between this and Focusable is
|
|
// that multiple Selectable elements may be selected at the same time, whereas
|
|
// only one Focusable element may be focused at the same time. Containers who's
|
|
// purpose is to contain selectable elements can determine when to select them
|
|
// by implementing MouseTargetContainer and listening for HandleChildMouseDown
|
|
// events.
|
|
type Selectable interface {
|
|
tomo.Element
|
|
Enableable
|
|
|
|
// HandleSelectionChange is called when the element is selected or
|
|
// deselected.
|
|
HandleSelectionChange ()
|
|
}
|
|
|
|
// KeyboardTarget represents an element that can receive keyboard input.
|
|
type KeyboardTarget interface {
|
|
tomo.Element
|
|
|
|
// HandleKeyDown is called when a key is pressed down or repeated while
|
|
// this element has keyboard focus. It is important to note that not
|
|
// every key down event is guaranteed to be paired with exactly one key
|
|
// up event. This is the reason a list of modifier keys held down at the
|
|
// time of the key press is given.
|
|
HandleKeyDown (key input.Key, modifiers input.Modifiers)
|
|
|
|
// HandleKeyUp is called when a key is released while this element has
|
|
// keyboard focus.
|
|
HandleKeyUp (key input.Key, modifiers input.Modifiers)
|
|
}
|
|
|
|
// MouseTarget represents an element that can receive mouse events.
|
|
type MouseTarget interface {
|
|
tomo.Element
|
|
|
|
// HandleMouseDown is called when a mouse button is pressed down on this
|
|
// element.
|
|
HandleMouseDown (
|
|
position image.Point,
|
|
button input.Button,
|
|
modifiers input.Modifiers)
|
|
|
|
// HandleMouseUp is called when a mouse button is released that was
|
|
// originally pressed down on this element.
|
|
HandleMouseUp (
|
|
position image.Point,
|
|
button input.Button,
|
|
modifiers input.Modifiers)
|
|
}
|
|
|
|
// MouseTargetContainer represents an element that wants to know when one
|
|
// of its children is clicked. Children do not have to implement MouseTarget for
|
|
// a container satisfying MouseTargetContainer to be notified that they have
|
|
// been clicked.
|
|
type MouseTargetContainer interface {
|
|
Container
|
|
|
|
// HandleMouseDown is called when a mouse button is pressed down on a
|
|
// child element.
|
|
HandleChildMouseDown (
|
|
position image.Point,
|
|
button input.Button,
|
|
modifiers input.Modifiers,
|
|
child tomo.Element)
|
|
|
|
// HandleMouseUp is called when a mouse button is released that was
|
|
// originally pressed down on a child element.
|
|
HandleChildMouseUp (
|
|
position image.Point,
|
|
button input.Button,
|
|
modifiers input.Modifiers,
|
|
child tomo.Element)
|
|
}
|
|
|
|
// MotionTarget represents an element that can receive mouse motion events.
|
|
type MotionTarget interface {
|
|
tomo.Element
|
|
|
|
// HandleMotion is called when the mouse is moved over this element,
|
|
// or the mouse is moving while being held down and originally pressed
|
|
// down on this element.
|
|
HandleMotion (position image.Point)
|
|
}
|
|
|
|
// ScrollTarget represents an element that can receive mouse scroll events.
|
|
type ScrollTarget interface {
|
|
tomo.Element
|
|
|
|
// HandleScroll is called when the mouse is scrolled. The X and Y
|
|
// direction of the scroll event are passed as deltaX and deltaY.
|
|
HandleScroll (
|
|
position image.Point,
|
|
deltaX, deltaY float64,
|
|
modifiers input.Modifiers)
|
|
}
|
|
|
|
// Flexible represents an element who's preferred minimum height can change in
|
|
// response to its width.
|
|
type Flexible interface {
|
|
tomo.Element
|
|
|
|
// FlexibleHeightFor returns what the element's minimum height would be
|
|
// if resized to a specified width. This does not actually alter the
|
|
// state of the element in any way, but it may perform significant work,
|
|
// so it should be called sparingly.
|
|
//
|
|
// It is reccomended that parent containers check for this interface and
|
|
// take this method's value into account in order to support things like
|
|
// flow layouts and text wrapping, but it is not absolutely necessary.
|
|
// The element's MinimumSize method will still return the absolute
|
|
// minimum size that the element may be resized to.
|
|
//
|
|
// It is important to note that if a parent container checks for
|
|
// flexible chilren, it itself will likely need to be either scrollable
|
|
// or flexible.
|
|
FlexibleHeightFor (width int) int
|
|
}
|
|
|
|
// FlexibleContainer represents an element that is capable of containing
|
|
// flexible children.
|
|
type FlexibleContainer interface {
|
|
Container
|
|
|
|
// HandleChildFlexibleHeightChange is called when the parameters
|
|
// affecting a child's flexible height are changed.
|
|
HandleChildFlexibleHeightChange (child Flexible)
|
|
}
|
|
|
|
// Scrollable represents an element that can be scrolled. It acts as a viewport
|
|
// through which its contents can be observed.
|
|
type Scrollable interface {
|
|
tomo.Element
|
|
|
|
// ScrollContentBounds returns the full content size of the element.
|
|
ScrollContentBounds () image.Rectangle
|
|
|
|
// ScrollViewportBounds returns the size and position of the element's
|
|
// viewport relative to ScrollBounds.
|
|
ScrollViewportBounds () image.Rectangle
|
|
|
|
// ScrollTo scrolls the viewport to the specified point relative to
|
|
// ScrollBounds.
|
|
ScrollTo (position image.Point)
|
|
|
|
// ScrollAxes returns the supported axes for scrolling.
|
|
ScrollAxes () (horizontal, vertical bool)
|
|
}
|
|
|
|
// ScrollableContainer represents an element that is capable of containing
|
|
// scrollable children.
|
|
type ScrollableContainer interface {
|
|
Container
|
|
|
|
// HandleChildScrollBoundsChange is called when the content bounds,
|
|
// viewport bounds, or scroll axes of a child are changed.
|
|
HandleChildScrollBoundsChange (child Scrollable)
|
|
}
|
|
|
|
// Collapsible represents an element who's minimum width and height can be
|
|
// manually resized. Scrollable elements should implement this if possible.
|
|
type Collapsible interface {
|
|
tomo.Element
|
|
|
|
// Collapse collapses the element's minimum width and height. A value of
|
|
// zero for either means that the element's normal value is used.
|
|
Collapse (width, height int)
|
|
}
|
|
|
|
// Themeable represents an element that can modify its appearance to fit within
|
|
// a theme.
|
|
type Themeable interface {
|
|
tomo.Element
|
|
|
|
// HandleThemeChange is called whenever the theme is changed.
|
|
HandleThemeChange ()
|
|
}
|
|
|
|
// Configurable represents an element that can modify its behavior to fit within
|
|
// a set of configuration parameters.
|
|
type Configurable interface {
|
|
tomo.Element
|
|
|
|
// HandleConfigChange is called whenever configuration parameters are
|
|
// changed.
|
|
HandleConfigChange ()
|
|
}
|