Compare commits
1 Commits
main
...
data-orien
Author | SHA1 | Date |
---|---|---|
Sasha Koshka | 6d9bc4f868 |
|
@ -1 +0,0 @@
|
|||
/build
|
37
README.md
37
README.md
|
@ -1,24 +1,29 @@
|
|||
# ![tomo](assets/screenshot.png)
|
||||
# ![tomo](assets/banner.png)
|
||||
|
||||
This repository is [mirrored on GitHub](https://github.com/sashakoshka/tomo).
|
||||
|
||||
Please note: Tomo is in early development. Some features may not work properly,
|
||||
and its API may change without notice.
|
||||
|
||||
Tomo is a GUI toolkit written in pure Go with minimal external dependencies. It
|
||||
makes use of Go's unique language features to do more with less.
|
||||
Tomo is a retro-looking GUI toolkit written in pure Go. It is designed with
|
||||
these goals in mind:
|
||||
|
||||
Nasin is an application framework that runs on top of Tomo. It supports plugins
|
||||
which can extend any application with backends, themes, etc.
|
||||
- Modularity: the core of Tomo is mostly composed of interfaces—and the
|
||||
overwhelming majority of its code resides in pluggable modules. If you don't
|
||||
need it, then dont import it—and you can be assured it won't be there.
|
||||
- Extendability: during the design of Tomo's API, use cases such as creating
|
||||
custom backends, elements, and layouts were given just as much importance as
|
||||
normal application building. Your custom element is a first-class citizen.
|
||||
- Independence: Tomo is minimally dependent on code outside of the Go
|
||||
standard library. Because of this, the file size of a compiled Tomo application
|
||||
is typically very small.
|
||||
- Frugality: Tomo foregoes things like animations and anti-aliasing in order to
|
||||
use a minimal amount of system resources without even having to touch the GPU.
|
||||
- Consistency: Tomo's design is not only consistent within itself, but also
|
||||
with the Go standard library. If you've worked with Go in the past, Tomo will
|
||||
feel pleasantly familliar.
|
||||
|
||||
## Usage
|
||||
|
||||
Before you start using Tomo, you need to install a backend plugin. Currently,
|
||||
there is only an X backend. You can run ./scripts/install-backends.sh to install
|
||||
it. It will be placed in `~/.local/lib/nasin/plugins`.
|
||||
|
||||
You can find out more about how to use Tomo and Nasin by visiting the examples
|
||||
directory, or pull up the documentation by running `godoc` within the
|
||||
repository. You can also view it on the web on
|
||||
[pkg.go.dev](https://pkg.go.dev/git.tebibyte.media/tomo/tomo) (although
|
||||
it may be slightly out of date).
|
||||
You can find out more about how to use it by visiting the examples directory,
|
||||
or pull up its documentation by running `godoc` within the repository. You can
|
||||
also view it on the web on
|
||||
[pkg.go.dev](https://pkg.go.dev/git.tebibyte.media/sashakoshka/tomo).
|
||||
|
|
|
@ -1,241 +0,0 @@
|
|||
// Package ability defines extended interfaces that elements can support.
|
||||
package ability
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
|
||||
// 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 (art.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 ()
|
||||
}
|
|
@ -0,0 +1,12 @@
|
|||
package artist
|
||||
|
||||
import "image/color"
|
||||
|
||||
// Hex creates a color.RGBA value from an RGBA integer value.
|
||||
func Hex (color uint32) (c color.RGBA) {
|
||||
c.A = uint8(color)
|
||||
c.B = uint8(color >> 8)
|
||||
c.G = uint8(color >> 16)
|
||||
c.R = uint8(color >> 24)
|
||||
return
|
||||
}
|
|
@ -0,0 +1,2 @@
|
|||
// Package artist provides a simple 2D drawing library for canvas.Canvas.
|
||||
package artist
|
|
@ -0,0 +1,60 @@
|
|||
package artist
|
||||
|
||||
import "image"
|
||||
|
||||
// Side represents one side of a rectangle.
|
||||
type Side int; const (
|
||||
SideTop Side = iota
|
||||
SideRight
|
||||
SideBottom
|
||||
SideLeft
|
||||
)
|
||||
|
||||
// Inset represents an inset amount for all four sides of a rectangle. The top
|
||||
// side is at index zero, the right at index one, the bottom at index two, and
|
||||
// the left at index three. These values may be negative.
|
||||
type Inset [4]int
|
||||
|
||||
// Apply returns the given rectangle, shrunk on all four sides by the given
|
||||
// inset. If a measurment of the inset is negative, that side will instead be
|
||||
// expanded outward. If the rectangle's dimensions cannot be reduced any
|
||||
// further, an empty rectangle near its center will be returned.
|
||||
func (inset Inset) Apply (bigger image.Rectangle) (smaller image.Rectangle) {
|
||||
smaller = bigger
|
||||
if smaller.Dx() < inset[3] + inset[1] {
|
||||
smaller.Min.X = (smaller.Min.X + smaller.Max.X) / 2
|
||||
smaller.Max.X = smaller.Min.X
|
||||
} else {
|
||||
smaller.Min.X += inset[3]
|
||||
smaller.Max.X -= inset[1]
|
||||
}
|
||||
|
||||
if smaller.Dy() < inset[0] + inset[2] {
|
||||
smaller.Min.Y = (smaller.Min.Y + smaller.Max.Y) / 2
|
||||
smaller.Max.Y = smaller.Min.Y
|
||||
} else {
|
||||
smaller.Min.Y += inset[0]
|
||||
smaller.Max.Y -= inset[2]
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Inverse returns a negated version of the inset.
|
||||
func (inset Inset) Inverse () (prime Inset) {
|
||||
return Inset {
|
||||
inset[0] * -1,
|
||||
inset[1] * -1,
|
||||
inset[2] * -1,
|
||||
inset[3] * -1,
|
||||
}
|
||||
}
|
||||
|
||||
// Horizontal returns the sum of SideRight and SideLeft.
|
||||
func (inset Inset) Horizontal () int {
|
||||
return inset[SideRight] + inset[SideLeft]
|
||||
}
|
||||
|
||||
// Vertical returns the sum of SideTop and SideBottom.
|
||||
func (inset Inset) Vertical () int {
|
||||
return inset[SideTop] + inset[SideBottom]
|
||||
}
|
|
@ -0,0 +1,67 @@
|
|||
package artist
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/shatter"
|
||||
|
||||
// Pattern is capable of drawing to a canvas within the bounds of a given
|
||||
// clipping rectangle.
|
||||
type Pattern interface {
|
||||
// Draw draws to destination, using the bounds of destination as a width
|
||||
// and height for things like gradients, bevels, etc. The pattern may
|
||||
// not draw outside the union of destination.Bounds() and clip. The
|
||||
// clipping rectangle effectively takes a subset of the pattern. To
|
||||
// change the bounds of the pattern itself, use canvas.Cut() on the
|
||||
// destination before passing it to Draw().
|
||||
Draw (destination canvas.Canvas, clip image.Rectangle)
|
||||
}
|
||||
|
||||
// Draw lets you use several clipping rectangles to draw a pattern.
|
||||
func Draw (
|
||||
destination canvas.Canvas,
|
||||
source Pattern,
|
||||
clips ...image.Rectangle,
|
||||
) (
|
||||
updatedRegion image.Rectangle,
|
||||
) {
|
||||
for _, clip := range clips {
|
||||
source.Draw(destination, clip)
|
||||
updatedRegion = updatedRegion.Union(clip)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// DrawBounds lets you specify an overall bounding rectangle for drawing a
|
||||
// pattern. The destination is cut to this rectangle.
|
||||
func DrawBounds (
|
||||
destination canvas.Canvas,
|
||||
source Pattern,
|
||||
bounds image.Rectangle,
|
||||
) (
|
||||
updatedRegion image.Rectangle,
|
||||
) {
|
||||
return Draw(canvas.Cut(destination, bounds), source, bounds)
|
||||
}
|
||||
|
||||
// DrawShatter is like an inverse of Draw, drawing nothing in the areas
|
||||
// specified in "rocks".
|
||||
func DrawShatter (
|
||||
destination canvas.Canvas,
|
||||
source Pattern,
|
||||
rocks ...image.Rectangle,
|
||||
) (
|
||||
updatedRegion image.Rectangle,
|
||||
) {
|
||||
tiles := shatter.Shatter(destination.Bounds(), rocks...)
|
||||
return Draw(destination, source, tiles...)
|
||||
}
|
||||
|
||||
// AllocateSample returns a new canvas containing the result of a pattern. The
|
||||
// resulting canvas can be sourced from shape drawing functions. I beg of you
|
||||
// please do not call this every time you need to draw a shape with a pattern on
|
||||
// it because that is horrible and cruel to the computer.
|
||||
func AllocateSample (source Pattern, width, height int) (allocated canvas.Canvas) {
|
||||
allocated = canvas.NewBasicCanvas(width, height)
|
||||
source.Draw(allocated, allocated.Bounds())
|
||||
return
|
||||
}
|
|
@ -0,0 +1,90 @@
|
|||
package patterns
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
|
||||
// Border is a pattern that behaves similarly to border-image in CSS. It divides
|
||||
// a source canvas into nine sections...
|
||||
//
|
||||
// Inset[1]
|
||||
// ┌──┴──┐
|
||||
// ┌─┌─────┬─────┬─────┐
|
||||
// Inset[0]─┤ │ 0 │ 1 │ 2 │
|
||||
// └─├─────┼─────┼─────┤
|
||||
// │ 3 │ 4 │ 5 │
|
||||
// ├─────┼─────┼─────┤─┐
|
||||
// │ 6 │ 7 │ 8 │ ├─Inset[2]
|
||||
// └─────┴─────┴─────┘─┘
|
||||
// └──┬──┘
|
||||
// Inset[3]
|
||||
//
|
||||
// ... Where the bounds of section 4 are defined as the application of the
|
||||
// pattern's inset to the canvas's bounds. The bounds of the other eight
|
||||
// sections are automatically sized around it.
|
||||
//
|
||||
// When drawn to a destination canvas, the bounds of sections 1, 3, 4, 5, and 7
|
||||
// are expanded or contracted to fit the destination's bounds. All sections
|
||||
// are rendered as if they are Texture patterns, meaning these flexible sections
|
||||
// will repeat to fill in any empty space.
|
||||
//
|
||||
// This pattern can be used to make a static image texture into something that
|
||||
// responds well to being resized.
|
||||
type Border struct {
|
||||
canvas.Canvas
|
||||
artist.Inset
|
||||
}
|
||||
|
||||
// Draw draws the border pattern onto the destination canvas within the clipping
|
||||
// bounds.
|
||||
func (pattern Border) Draw (destination canvas.Canvas, clip image.Rectangle) {
|
||||
bounds := clip.Canon().Intersect(destination.Bounds())
|
||||
if bounds.Empty() { return }
|
||||
|
||||
srcSections := nonasect(pattern.Bounds(), pattern.Inset)
|
||||
srcTextures := [9]Texture { }
|
||||
for index, section := range srcSections {
|
||||
srcTextures[index].Canvas = canvas.Cut(pattern, section)
|
||||
}
|
||||
|
||||
dstSections := nonasect(destination.Bounds(), pattern.Inset)
|
||||
for index, section := range dstSections {
|
||||
srcTextures[index].Draw(canvas.Cut(destination, section), clip)
|
||||
}
|
||||
}
|
||||
|
||||
func nonasect (bounds image.Rectangle, inset artist.Inset) [9]image.Rectangle {
|
||||
center := inset.Apply(bounds)
|
||||
return [9]image.Rectangle {
|
||||
// top
|
||||
image.Rectangle {
|
||||
bounds.Min,
|
||||
center.Min },
|
||||
image.Rect (
|
||||
center.Min.X, bounds.Min.Y,
|
||||
center.Max.X, center.Min.Y),
|
||||
image.Rect (
|
||||
center.Max.X, bounds.Min.Y,
|
||||
bounds.Max.X, center.Min.Y),
|
||||
|
||||
// center
|
||||
image.Rect (
|
||||
bounds.Min.X, center.Min.Y,
|
||||
center.Min.X, center.Max.Y),
|
||||
center,
|
||||
image.Rect (
|
||||
center.Max.X, center.Min.Y,
|
||||
bounds.Max.X, center.Max.Y),
|
||||
|
||||
// bottom
|
||||
image.Rect (
|
||||
bounds.Min.X, center.Max.Y,
|
||||
center.Min.X, bounds.Max.Y),
|
||||
image.Rect (
|
||||
center.Min.X, center.Max.Y,
|
||||
center.Max.X, bounds.Max.Y),
|
||||
image.Rect (
|
||||
center.Max.X, center.Max.Y,
|
||||
bounds.Max.X, bounds.Max.Y),
|
||||
}
|
||||
}
|
|
@ -0,0 +1,3 @@
|
|||
// Package patterns provides a basic set of types that satisfy the
|
||||
// artist.Pattern interface.
|
||||
package patterns
|
|
@ -0,0 +1,41 @@
|
|||
package patterns
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
|
||||
// Texture is a pattern that tiles the content of a canvas both horizontally and
|
||||
// vertically.
|
||||
type Texture struct {
|
||||
canvas.Canvas
|
||||
}
|
||||
|
||||
// Draw tiles the pattern's canvas within the clipping bounds. The minimum
|
||||
// points of the pattern's canvas and the destination canvas will be lined up.
|
||||
func (pattern Texture) Draw (destination canvas.Canvas, clip image.Rectangle) {
|
||||
realBounds := destination.Bounds()
|
||||
bounds := clip.Canon().Intersect(realBounds)
|
||||
if bounds.Empty() { return }
|
||||
|
||||
dstData, dstStride := destination.Buffer()
|
||||
srcData, srcStride := pattern.Buffer()
|
||||
srcBounds := pattern.Bounds()
|
||||
|
||||
point := image.Point { }
|
||||
for point.Y = bounds.Min.Y; point.Y < bounds.Max.Y; point.Y ++ {
|
||||
for point.X = bounds.Min.X; point.X < bounds.Max.X; point.X ++ {
|
||||
srcPoint := point.Sub(realBounds.Min).Add(srcBounds.Min)
|
||||
|
||||
dstIndex := point.X + point.Y * dstStride
|
||||
srcIndex :=
|
||||
wrap(srcPoint.X, srcBounds.Min.X, srcBounds.Max.X) +
|
||||
wrap(srcPoint.Y, srcBounds.Min.Y, srcBounds.Max.Y) * srcStride
|
||||
dstData[dstIndex] = srcData[srcIndex]
|
||||
}}
|
||||
}
|
||||
|
||||
func wrap (value, min, max int) int {
|
||||
difference := max - min
|
||||
value = (value - min) % difference
|
||||
if value < 0 { value += difference }
|
||||
return value + min
|
||||
}
|
|
@ -0,0 +1,20 @@
|
|||
package patterns
|
||||
|
||||
import "image"
|
||||
import "image/color"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist/shapes"
|
||||
|
||||
// Uniform is a pattern that draws a solid color.
|
||||
type Uniform color.RGBA
|
||||
|
||||
// Draw fills the clipping rectangle with the pattern's color.
|
||||
func (pattern Uniform) Draw (destination canvas.Canvas, clip image.Rectangle) {
|
||||
shapes.FillColorRectangle(destination, color.RGBA(pattern), clip)
|
||||
}
|
||||
|
||||
// Uhex creates a new Uniform pattern from an RGBA integer value.
|
||||
func Uhex (color uint32) (uniform Uniform) {
|
||||
return Uniform(artist.Hex(color))
|
||||
}
|
|
@ -0,0 +1,11 @@
|
|||
// Package shapes provides some basic shape drawing routines.
|
||||
//
|
||||
// A word about using patterns with shape routines:
|
||||
//
|
||||
// Most drawing routines have a version that samples from other canvases, and a
|
||||
// version that samples from a solid color. None of these routines can use
|
||||
// patterns directly, but it is entirely possible to have a pattern draw to an
|
||||
// off-screen canvas and then draw a shape based on that canvas. As a little
|
||||
// bonus, you can save the canvas for later so you don't have to render the
|
||||
// pattern again when you need to redraw the shape.
|
||||
package shapes
|
|
@ -0,0 +1,228 @@
|
|||
package shapes
|
||||
|
||||
import "math"
|
||||
import "image"
|
||||
import "image/color"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
|
||||
// TODO: redo fill ellipse, stroke ellipse, etc. so that it only takes in
|
||||
// destination and source, using the bounds of destination as the bounds of the
|
||||
// ellipse and the bounds of source as the "clipping rectangle". Line up the Min
|
||||
// of both canvases.
|
||||
|
||||
func FillEllipse (
|
||||
destination canvas.Canvas,
|
||||
source canvas.Canvas,
|
||||
) (
|
||||
updatedRegion image.Rectangle,
|
||||
) {
|
||||
dstData, dstStride := destination.Buffer()
|
||||
srcData, srcStride := source.Buffer()
|
||||
|
||||
offset := source.Bounds().Min.Sub(destination.Bounds().Min)
|
||||
bounds := source.Bounds().Sub(offset).Intersect(destination.Bounds())
|
||||
realBounds := destination.Bounds()
|
||||
if bounds.Empty() { return }
|
||||
updatedRegion = bounds
|
||||
|
||||
point := image.Point { }
|
||||
for point.Y = bounds.Min.Y; point.Y < bounds.Max.Y; point.Y ++ {
|
||||
for point.X = bounds.Min.X; point.X < bounds.Max.X; point.X ++ {
|
||||
if inEllipse(point, realBounds) {
|
||||
offsetPoint := point.Add(offset)
|
||||
dstIndex := point.X + point.Y * dstStride
|
||||
srcIndex := offsetPoint.X + offsetPoint.Y * srcStride
|
||||
dstData[dstIndex] = srcData[srcIndex]
|
||||
}
|
||||
}}
|
||||
return
|
||||
}
|
||||
|
||||
func StrokeEllipse (
|
||||
destination canvas.Canvas,
|
||||
source canvas.Canvas,
|
||||
weight int,
|
||||
) {
|
||||
if weight < 1 { return }
|
||||
|
||||
dstData, dstStride := destination.Buffer()
|
||||
srcData, srcStride := source.Buffer()
|
||||
|
||||
bounds := destination.Bounds().Inset(weight - 1)
|
||||
offset := source.Bounds().Min.Sub(destination.Bounds().Min)
|
||||
realBounds := destination.Bounds()
|
||||
if bounds.Empty() { return }
|
||||
|
||||
context := ellipsePlottingContext {
|
||||
plottingContext: plottingContext {
|
||||
dstData: dstData,
|
||||
dstStride: dstStride,
|
||||
srcData: srcData,
|
||||
srcStride: srcStride,
|
||||
weight: weight,
|
||||
offset: offset,
|
||||
bounds: realBounds,
|
||||
},
|
||||
radii: image.Pt(bounds.Dx() / 2, bounds.Dy() / 2),
|
||||
}
|
||||
context.center = bounds.Min.Add(context.radii)
|
||||
context.plotEllipse()
|
||||
}
|
||||
|
||||
type ellipsePlottingContext struct {
|
||||
plottingContext
|
||||
radii image.Point
|
||||
center image.Point
|
||||
}
|
||||
|
||||
func (context ellipsePlottingContext) plotEllipse () {
|
||||
x := float64(0)
|
||||
y := float64(context.radii.Y)
|
||||
|
||||
// region 1 decision parameter
|
||||
decision1 :=
|
||||
float64(context.radii.Y * context.radii.Y) -
|
||||
float64(context.radii.X * context.radii.X * context.radii.Y) +
|
||||
(0.25 * float64(context.radii.X) * float64(context.radii.X))
|
||||
decisionX := float64(2 * context.radii.Y * context.radii.Y * int(x))
|
||||
decisionY := float64(2 * context.radii.X * context.radii.X * int(y))
|
||||
|
||||
// draw region 1
|
||||
for decisionX < decisionY {
|
||||
points := []image.Point {
|
||||
image.Pt(-int(x) + context.center.X, -int(y) + context.center.Y),
|
||||
image.Pt( int(x) + context.center.X, -int(y) + context.center.Y),
|
||||
image.Pt(-int(x) + context.center.X, int(y) + context.center.Y),
|
||||
image.Pt( int(x) + context.center.X, int(y) + context.center.Y),
|
||||
}
|
||||
if context.srcData == nil {
|
||||
context.plotColor(points[0])
|
||||
context.plotColor(points[1])
|
||||
context.plotColor(points[2])
|
||||
context.plotColor(points[3])
|
||||
} else {
|
||||
context.plotSource(points[0])
|
||||
context.plotSource(points[1])
|
||||
context.plotSource(points[2])
|
||||
context.plotSource(points[3])
|
||||
}
|
||||
|
||||
if (decision1 < 0) {
|
||||
x ++
|
||||
decisionX += float64(2 * context.radii.Y * context.radii.Y)
|
||||
decision1 += decisionX + float64(context.radii.Y * context.radii.Y)
|
||||
} else {
|
||||
x ++
|
||||
y --
|
||||
decisionX += float64(2 * context.radii.Y * context.radii.Y)
|
||||
decisionY -= float64(2 * context.radii.X * context.radii.X)
|
||||
decision1 +=
|
||||
decisionX - decisionY +
|
||||
float64(context.radii.Y * context.radii.Y)
|
||||
}
|
||||
}
|
||||
|
||||
// region 2 decision parameter
|
||||
decision2 :=
|
||||
float64(context.radii.Y * context.radii.Y) * (x + 0.5) * (x + 0.5) +
|
||||
float64(context.radii.X * context.radii.X) * (y - 1) * (y - 1) -
|
||||
float64(context.radii.X * context.radii.X * context.radii.Y * context.radii.Y)
|
||||
|
||||
// draw region 2
|
||||
for y >= 0 {
|
||||
points := []image.Point {
|
||||
image.Pt( int(x) + context.center.X, int(y) + context.center.Y),
|
||||
image.Pt(-int(x) + context.center.X, int(y) + context.center.Y),
|
||||
image.Pt( int(x) + context.center.X, -int(y) + context.center.Y),
|
||||
image.Pt(-int(x) + context.center.X, -int(y) + context.center.Y),
|
||||
}
|
||||
if context.srcData == nil {
|
||||
context.plotColor(points[0])
|
||||
context.plotColor(points[1])
|
||||
context.plotColor(points[2])
|
||||
context.plotColor(points[3])
|
||||
} else {
|
||||
context.plotSource(points[0])
|
||||
context.plotSource(points[1])
|
||||
context.plotSource(points[2])
|
||||
context.plotSource(points[3])
|
||||
}
|
||||
|
||||
if decision2 > 0 {
|
||||
y --
|
||||
decisionY -= float64(2 * context.radii.X * context.radii.X)
|
||||
decision2 += float64(context.radii.X * context.radii.X) - decisionY
|
||||
} else {
|
||||
y --
|
||||
x ++
|
||||
decisionX += float64(2 * context.radii.Y * context.radii.Y)
|
||||
decisionY -= float64(2 * context.radii.X * context.radii.X)
|
||||
decision2 +=
|
||||
decisionX - decisionY +
|
||||
float64(context.radii.X * context.radii.X)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// FillColorEllipse fills an ellipse within the destination canvas with a solid
|
||||
// color.
|
||||
func FillColorEllipse (
|
||||
destination canvas.Canvas,
|
||||
color color.RGBA,
|
||||
bounds image.Rectangle,
|
||||
) (
|
||||
updatedRegion image.Rectangle,
|
||||
) {
|
||||
dstData, dstStride := destination.Buffer()
|
||||
|
||||
realBounds := bounds
|
||||
bounds = bounds.Intersect(destination.Bounds()).Canon()
|
||||
if bounds.Empty() { return }
|
||||
updatedRegion = bounds
|
||||
|
||||
point := image.Point { }
|
||||
for point.Y = bounds.Min.Y; point.Y < bounds.Max.Y; point.Y ++ {
|
||||
for point.X = bounds.Min.X; point.X < bounds.Max.X; point.X ++ {
|
||||
if inEllipse(point, realBounds) {
|
||||
dstData[point.X + point.Y * dstStride] = color
|
||||
}
|
||||
}}
|
||||
return
|
||||
}
|
||||
|
||||
// StrokeColorEllipse is similar to FillColorEllipse, but it draws an inset
|
||||
// outline of an ellipse instead.
|
||||
func StrokeColorEllipse (
|
||||
destination canvas.Canvas,
|
||||
color color.RGBA,
|
||||
bounds image.Rectangle,
|
||||
weight int,
|
||||
) (
|
||||
updatedRegion image.Rectangle,
|
||||
) {
|
||||
if weight < 1 { return }
|
||||
|
||||
dstData, dstStride := destination.Buffer()
|
||||
insetBounds := bounds.Inset(weight - 1)
|
||||
|
||||
context := ellipsePlottingContext {
|
||||
plottingContext: plottingContext {
|
||||
dstData: dstData,
|
||||
dstStride: dstStride,
|
||||
color: color,
|
||||
weight: weight,
|
||||
bounds: bounds.Intersect(destination.Bounds()),
|
||||
},
|
||||
radii: image.Pt(insetBounds.Dx() / 2, insetBounds.Dy() / 2),
|
||||
}
|
||||
context.center = insetBounds.Min.Add(context.radii)
|
||||
context.plotEllipse()
|
||||
return
|
||||
}
|
||||
|
||||
func inEllipse (point image.Point, bounds image.Rectangle) bool {
|
||||
point = point.Sub(bounds.Min)
|
||||
x := (float64(point.X) + 0.5) / float64(bounds.Dx()) - 0.5
|
||||
y := (float64(point.Y) + 0.5) / float64(bounds.Dy()) - 0.5
|
||||
return math.Hypot(x, y) <= 0.5
|
||||
}
|
|
@ -0,0 +1,112 @@
|
|||
package shapes
|
||||
|
||||
import "image"
|
||||
import "image/color"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
|
||||
// ColorLine draws a line from one point to another with the specified weight
|
||||
// and color.
|
||||
func ColorLine (
|
||||
destination canvas.Canvas,
|
||||
color color.RGBA,
|
||||
weight int,
|
||||
min image.Point,
|
||||
max image.Point,
|
||||
) (
|
||||
updatedRegion image.Rectangle,
|
||||
) {
|
||||
updatedRegion = image.Rectangle { Min: min, Max: max }.Canon()
|
||||
updatedRegion.Max.X ++
|
||||
updatedRegion.Max.Y ++
|
||||
|
||||
data, stride := destination.Buffer()
|
||||
bounds := destination.Bounds()
|
||||
context := linePlottingContext {
|
||||
plottingContext: plottingContext {
|
||||
dstData: data,
|
||||
dstStride: stride,
|
||||
color: color,
|
||||
weight: weight,
|
||||
bounds: bounds,
|
||||
},
|
||||
min: min,
|
||||
max: max,
|
||||
}
|
||||
|
||||
if abs(max.Y - min.Y) < abs(max.X - min.X) {
|
||||
if max.X < min.X { context.swap() }
|
||||
context.lineLow()
|
||||
|
||||
} else {
|
||||
if max.Y < min.Y { context.swap() }
|
||||
context.lineHigh()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
type linePlottingContext struct {
|
||||
plottingContext
|
||||
min image.Point
|
||||
max image.Point
|
||||
}
|
||||
|
||||
func (context *linePlottingContext) swap () {
|
||||
temp := context.max
|
||||
context.max = context.min
|
||||
context.min = temp
|
||||
}
|
||||
|
||||
func (context linePlottingContext) lineLow () {
|
||||
deltaX := context.max.X - context.min.X
|
||||
deltaY := context.max.Y - context.min.Y
|
||||
yi := 1
|
||||
|
||||
if deltaY < 0 {
|
||||
yi = -1
|
||||
deltaY *= -1
|
||||
}
|
||||
|
||||
D := (2 * deltaY) - deltaX
|
||||
point := context.min
|
||||
|
||||
for ; point.X < context.max.X; point.X ++ {
|
||||
if !point.In(context.bounds) { break }
|
||||
context.plotColor(point)
|
||||
if D > 0 {
|
||||
D += 2 * (deltaY - deltaX)
|
||||
point.Y += yi
|
||||
} else {
|
||||
D += 2 * deltaY
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (context linePlottingContext) lineHigh () {
|
||||
deltaX := context.max.X - context.min.X
|
||||
deltaY := context.max.Y - context.min.Y
|
||||
xi := 1
|
||||
|
||||
if deltaX < 0 {
|
||||
xi = -1
|
||||
deltaX *= -1
|
||||
}
|
||||
|
||||
D := (2 * deltaX) - deltaY
|
||||
point := context.min
|
||||
|
||||
for ; point.Y < context.max.Y; point.Y ++ {
|
||||
if !point.In(context.bounds) { break }
|
||||
context.plotColor(point)
|
||||
if D > 0 {
|
||||
point.X += xi
|
||||
D += 2 * (deltaX - deltaY)
|
||||
} else {
|
||||
D += 2 * deltaX
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func abs (n int) int {
|
||||
if n < 0 { n *= -1}
|
||||
return n
|
||||
}
|
|
@ -0,0 +1,47 @@
|
|||
package shapes
|
||||
|
||||
import "image"
|
||||
import "image/color"
|
||||
|
||||
// FIXME? drawing a ton of overlapping squares might be a bit wasteful.
|
||||
|
||||
type plottingContext struct {
|
||||
dstData []color.RGBA
|
||||
dstStride int
|
||||
srcData []color.RGBA
|
||||
srcStride int
|
||||
color color.RGBA
|
||||
weight int
|
||||
offset image.Point
|
||||
bounds image.Rectangle
|
||||
}
|
||||
|
||||
func (context plottingContext) square (center image.Point) (square image.Rectangle) {
|
||||
return image.Rect(0, 0, context.weight, context.weight).
|
||||
Sub(image.Pt(context.weight / 2, context.weight / 2)).
|
||||
Add(center).
|
||||
Intersect(context.bounds)
|
||||
}
|
||||
|
||||
func (context plottingContext) plotColor (center image.Point) {
|
||||
square := context.square(center)
|
||||
for y := square.Min.Y; y < square.Max.Y; y ++ {
|
||||
for x := square.Min.X; x < square.Max.X; x ++ {
|
||||
context.dstData[x + y * context.dstStride] = context.color
|
||||
}}
|
||||
}
|
||||
|
||||
func (context plottingContext) plotSource (center image.Point) {
|
||||
square := context.square(center)
|
||||
for y := square.Min.Y; y < square.Max.Y; y ++ {
|
||||
for x := square.Min.X; x < square.Max.X; x ++ {
|
||||
// we offset srcIndex here because we have already applied the
|
||||
// offset to the square, and we need to reverse that to get the
|
||||
// proper source coordinates.
|
||||
srcIndex :=
|
||||
x + context.offset.X +
|
||||
(y + context.offset.Y) * context.dstStride
|
||||
dstIndex := x + y * context.dstStride
|
||||
context.dstData[dstIndex] = context.srcData [srcIndex]
|
||||
}}
|
||||
}
|
|
@ -0,0 +1,116 @@
|
|||
package shapes
|
||||
|
||||
import "image"
|
||||
import "image/color"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/shatter"
|
||||
|
||||
// TODO: return updatedRegion for all routines in this package
|
||||
|
||||
func FillRectangle (
|
||||
destination canvas.Canvas,
|
||||
source canvas.Canvas,
|
||||
) (
|
||||
updatedRegion image.Rectangle,
|
||||
) {
|
||||
dstData, dstStride := destination.Buffer()
|
||||
srcData, srcStride := source.Buffer()
|
||||
|
||||
offset := source.Bounds().Min.Sub(destination.Bounds().Min)
|
||||
bounds := source.Bounds().Sub(offset).Intersect(destination.Bounds())
|
||||
if bounds.Empty() { return }
|
||||
updatedRegion = bounds
|
||||
|
||||
point := image.Point { }
|
||||
for point.Y = bounds.Min.Y; point.Y < bounds.Max.Y; point.Y ++ {
|
||||
for point.X = bounds.Min.X; point.X < bounds.Max.X; point.X ++ {
|
||||
offsetPoint := point.Add(offset)
|
||||
dstIndex := point.X + point.Y * dstStride
|
||||
srcIndex := offsetPoint.X + offsetPoint.Y * srcStride
|
||||
dstData[dstIndex] = srcData[srcIndex]
|
||||
}}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func StrokeRectangle (
|
||||
destination canvas.Canvas,
|
||||
source canvas.Canvas,
|
||||
weight int,
|
||||
) {
|
||||
bounds := destination.Bounds()
|
||||
insetBounds := bounds.Inset(weight)
|
||||
if insetBounds.Empty() {
|
||||
FillRectangle(destination, source)
|
||||
return
|
||||
}
|
||||
FillRectangleShatter(destination, source, insetBounds)
|
||||
}
|
||||
|
||||
// FillRectangleShatter is like FillRectangle, but it does not draw in areas
|
||||
// specified in "rocks".
|
||||
func FillRectangleShatter (
|
||||
destination canvas.Canvas,
|
||||
source canvas.Canvas,
|
||||
rocks ...image.Rectangle,
|
||||
) {
|
||||
tiles := shatter.Shatter(destination.Bounds(), rocks...)
|
||||
offset := source.Bounds().Min.Sub(destination.Bounds().Min)
|
||||
for _, tile := range tiles {
|
||||
FillRectangle (
|
||||
canvas.Cut(destination, tile),
|
||||
canvas.Cut(source, tile.Add(offset)))
|
||||
}
|
||||
}
|
||||
|
||||
// FillColorRectangle fills a rectangle within the destination canvas with a
|
||||
// solid color.
|
||||
func FillColorRectangle (
|
||||
destination canvas.Canvas,
|
||||
color color.RGBA,
|
||||
bounds image.Rectangle,
|
||||
) (
|
||||
updatedRegion image.Rectangle,
|
||||
) {
|
||||
dstData, dstStride := destination.Buffer()
|
||||
bounds = bounds.Canon().Intersect(destination.Bounds())
|
||||
if bounds.Empty() { return }
|
||||
|
||||
updatedRegion = bounds
|
||||
for y := bounds.Min.Y; y < bounds.Max.Y; y ++ {
|
||||
for x := bounds.Min.X; x < bounds.Max.X; x ++ {
|
||||
dstData[x + y * dstStride] = color
|
||||
}}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// FillColorRectangleShatter is like FillColorRectangle, but it does not draw in
|
||||
// areas specified in "rocks".
|
||||
func FillColorRectangleShatter (
|
||||
destination canvas.Canvas,
|
||||
color color.RGBA,
|
||||
bounds image.Rectangle,
|
||||
rocks ...image.Rectangle,
|
||||
) {
|
||||
tiles := shatter.Shatter(bounds, rocks...)
|
||||
for _, tile := range tiles {
|
||||
FillColorRectangle(destination, color, tile)
|
||||
}
|
||||
}
|
||||
|
||||
// StrokeColorRectangle is similar to FillColorRectangle, but it draws an inset
|
||||
// outline of the given rectangle instead.
|
||||
func StrokeColorRectangle (
|
||||
destination canvas.Canvas,
|
||||
color color.RGBA,
|
||||
bounds image.Rectangle,
|
||||
weight int,
|
||||
) {
|
||||
insetBounds := bounds.Inset(weight)
|
||||
if insetBounds.Empty() {
|
||||
FillColorRectangle(destination, color, bounds)
|
||||
return
|
||||
}
|
||||
FillColorRectangleShatter(destination, color, bounds, insetBounds)
|
||||
}
|
Binary file not shown.
Before Width: | Height: | Size: 56 KiB |
65
backend.go
65
backend.go
|
@ -1,13 +1,17 @@
|
|||
package tomo
|
||||
|
||||
import "image"
|
||||
import "errors"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/data"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements"
|
||||
|
||||
// Backend represents a connection to a display server, or something similar.
|
||||
// It is capable of managing an event loop, and creating windows.
|
||||
type Backend interface {
|
||||
// Run runs the backend's event loop. It must block until the backend
|
||||
// experiences a fatal error, or Stop() is called.
|
||||
Run () error
|
||||
Run () (err error)
|
||||
|
||||
// Stop stops the backend's event loop.
|
||||
Stop ()
|
||||
|
@ -16,36 +20,51 @@ type Backend interface {
|
|||
// possible. This method must be safe to call from other threads.
|
||||
Do (callback func ())
|
||||
|
||||
// NewEntity creates a new entity for the specified element.
|
||||
NewEntity (owner Element) Entity
|
||||
// NewWindow creates a new window with the specified width and height,
|
||||
// and returns a struct representing it that fulfills the Window
|
||||
// interface.
|
||||
NewWindow (width, height int) (window elements.Window, err error)
|
||||
|
||||
// NewWindow creates a new window within the specified bounding
|
||||
// rectangle. The position on screen may be overridden by the backend or
|
||||
// operating system.
|
||||
NewWindow (bounds image.Rectangle) (MainWindow, error)
|
||||
// Copy puts data into the clipboard.
|
||||
Copy (data.Data)
|
||||
|
||||
// Paste returns the data currently in the clipboard.
|
||||
Paste (accept []data.Mime) (data.Data)
|
||||
|
||||
// SetTheme sets the theme of all open windows.
|
||||
SetTheme (Theme)
|
||||
SetTheme (theme.Theme)
|
||||
|
||||
// SetConfig sets the configuration of all open windows.
|
||||
SetConfig (Config)
|
||||
SetConfig (config.Config)
|
||||
}
|
||||
|
||||
var backend Backend
|
||||
// BackendFactory represents a function capable of constructing a backend
|
||||
// struct. Any connections should be initialized within this function. If there
|
||||
// any errors encountered during this process, the function should immediately
|
||||
// stop, clean up any resources, and return an error.
|
||||
type BackendFactory func () (backend Backend, err error)
|
||||
|
||||
// GetBackend returns the currently running backend.
|
||||
func GetBackend () Backend {
|
||||
return backend
|
||||
// RegisterBackend registers a backend factory. When an application calls
|
||||
// tomo.Run(), the first registered backend that does not throw an error will be
|
||||
// used.
|
||||
func RegisterBackend (factory BackendFactory) {
|
||||
factories = append(factories, factory)
|
||||
}
|
||||
|
||||
// SetBackend sets the currently running backend. The backend can only be set
|
||||
// once—if there already is one then this function will do nothing.
|
||||
func SetBackend (b Backend) {
|
||||
if backend != nil { return }
|
||||
backend = b
|
||||
}
|
||||
var factories []BackendFactory
|
||||
|
||||
// Bounds creates a rectangle from an x, y, width, and height.
|
||||
func Bounds (x, y, width, height int) image.Rectangle {
|
||||
return image.Rect(x, y, x + width, y + height)
|
||||
func instantiateBackend () (backend Backend, err error) {
|
||||
// find a suitable backend
|
||||
for _, factory := range factories {
|
||||
backend, err = factory()
|
||||
if err == nil && backend != nil { return }
|
||||
}
|
||||
|
||||
// if none were found, but there was no error produced, produce an
|
||||
// error
|
||||
if err == nil {
|
||||
err = errors.New("no available backends")
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
|
|
@ -3,7 +3,7 @@ package x
|
|||
import "unicode"
|
||||
import "github.com/jezek/xgb/xproto"
|
||||
import "github.com/jezek/xgbutil/keybind"
|
||||
import "tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
|
||||
// when making changes to this file, look at keysymdef.h and
|
||||
// https://tronche.com/gui/x/xlib/input/keyboard-encoding.html
|
||||
|
@ -112,7 +112,7 @@ var keypadCodeTable = map[xproto.Keysym] input.Key {
|
|||
|
||||
// initializeKeymapInformation grabs keyboard mapping information from the X
|
||||
// server.
|
||||
func (backend *backend) initializeKeymapInformation () {
|
||||
func (backend *Backend) initializeKeymapInformation () {
|
||||
keybind.Initialize(backend.connection)
|
||||
backend.modifierMasks.capsLock = backend.keysymToMask(0xFFE5)
|
||||
backend.modifierMasks.shiftLock = backend.keysymToMask(0xFFE6)
|
||||
|
@ -127,7 +127,7 @@ func (backend *backend) initializeKeymapInformation () {
|
|||
|
||||
// keysymToKeycode converts an X keysym to an X keycode, instead of the other
|
||||
// way around.
|
||||
func (backend *backend) keysymToKeycode (
|
||||
func (backend *Backend) keysymToKeycode (
|
||||
symbol xproto.Keysym,
|
||||
) (
|
||||
code xproto.Keycode,
|
||||
|
@ -148,7 +148,7 @@ func (backend *backend) keysymToKeycode (
|
|||
}
|
||||
|
||||
// keysymToMask returns the X modmask for a given modifier key.
|
||||
func (backend *backend) keysymToMask (
|
||||
func (backend *Backend) keysymToMask (
|
||||
symbol xproto.Keysym,
|
||||
) (
|
||||
mask uint16,
|
||||
|
@ -164,7 +164,7 @@ func (backend *backend) keysymToMask (
|
|||
// fleshed out version of some of the logic found in xgbutil/keybind/encoding.go
|
||||
// to get a full keycode to keysym conversion, but eliminates redundant work by
|
||||
// going straight to a tomo keycode.
|
||||
func (backend *backend) keycodeToKey (
|
||||
func (backend *Backend) keycodeToKey (
|
||||
keycode xproto.Keycode,
|
||||
state uint16,
|
||||
) (
|
|
@ -0,0 +1,339 @@
|
|||
package x
|
||||
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements"
|
||||
|
||||
import "github.com/jezek/xgbutil"
|
||||
import "github.com/jezek/xgb/xproto"
|
||||
import "github.com/jezek/xgbutil/xevent"
|
||||
|
||||
type scrollSum struct {
|
||||
x, y int
|
||||
}
|
||||
|
||||
const scrollDistance = 16
|
||||
|
||||
func (sum *scrollSum) add (button xproto.Button, window *Window, state uint16) {
|
||||
shift :=
|
||||
(state & xproto.ModMaskShift) > 0 ||
|
||||
(state & window.backend.modifierMasks.shiftLock) > 0
|
||||
if shift {
|
||||
switch button {
|
||||
case 4:
|
||||
sum.x -= scrollDistance
|
||||
case 5:
|
||||
sum.x += scrollDistance
|
||||
case 6:
|
||||
sum.y -= scrollDistance
|
||||
case 7:
|
||||
sum.y += scrollDistance
|
||||
}
|
||||
} else {
|
||||
switch button {
|
||||
case 4:
|
||||
sum.y -= scrollDistance
|
||||
case 5:
|
||||
sum.y += scrollDistance
|
||||
case 6:
|
||||
sum.x -= scrollDistance
|
||||
case 7:
|
||||
sum.x += scrollDistance
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func (window *Window) handleExpose (
|
||||
connection *xgbutil.XUtil,
|
||||
event xevent.ExposeEvent,
|
||||
) {
|
||||
_ = window.compressExpose(*event.ExposeEvent)
|
||||
window.redrawChildEntirely()
|
||||
}
|
||||
|
||||
func (window *Window) handleConfigureNotify (
|
||||
connection *xgbutil.XUtil,
|
||||
event xevent.ConfigureNotifyEvent,
|
||||
) {
|
||||
if window.child == nil { return }
|
||||
|
||||
configureEvent := *event.ConfigureNotifyEvent
|
||||
|
||||
newWidth := int(configureEvent.Width)
|
||||
newHeight := int(configureEvent.Height)
|
||||
sizeChanged :=
|
||||
window.metrics.width != newWidth ||
|
||||
window.metrics.height != newHeight
|
||||
window.metrics.width = newWidth
|
||||
window.metrics.height = newHeight
|
||||
|
||||
if sizeChanged {
|
||||
configureEvent = window.compressConfigureNotify(configureEvent)
|
||||
window.metrics.width = int(configureEvent.Width)
|
||||
window.metrics.height = int(configureEvent.Height)
|
||||
window.reallocateCanvas()
|
||||
window.resizeChildToFit()
|
||||
|
||||
if !window.exposeEventFollows(configureEvent) {
|
||||
window.redrawChildEntirely()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (window *Window) exposeEventFollows (event xproto.ConfigureNotifyEvent) (found bool) {
|
||||
nextEvents := xevent.Peek(window.backend.connection)
|
||||
if len(nextEvents) > 0 {
|
||||
untypedEvent := nextEvents[0]
|
||||
if untypedEvent.Err == nil {
|
||||
typedEvent, ok :=
|
||||
untypedEvent.Event.(xproto.ExposeEvent)
|
||||
|
||||
if ok && typedEvent.Window == event.Window {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (window *Window) modifiersFromState (
|
||||
state uint16,
|
||||
) (
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
return input.Modifiers {
|
||||
Shift:
|
||||
(state & xproto.ModMaskShift) > 0 ||
|
||||
(state & window.backend.modifierMasks.shiftLock) > 0,
|
||||
Control: (state & xproto.ModMaskControl) > 0,
|
||||
Alt: (state & window.backend.modifierMasks.alt) > 0,
|
||||
Meta: (state & window.backend.modifierMasks.meta) > 0,
|
||||
Super: (state & window.backend.modifierMasks.super) > 0,
|
||||
Hyper: (state & window.backend.modifierMasks.hyper) > 0,
|
||||
}
|
||||
}
|
||||
|
||||
func (window *Window) handleKeyPress (
|
||||
connection *xgbutil.XUtil,
|
||||
event xevent.KeyPressEvent,
|
||||
) {
|
||||
if window.child == nil { return }
|
||||
|
||||
keyEvent := *event.KeyPressEvent
|
||||
key, numberPad := window.backend.keycodeToKey(keyEvent.Detail, keyEvent.State)
|
||||
modifiers := window.modifiersFromState(keyEvent.State)
|
||||
modifiers.NumberPad = numberPad
|
||||
|
||||
if key == input.KeyTab && modifiers.Alt {
|
||||
if child, ok := window.child.(elements.Focusable); ok {
|
||||
direction := input.KeynavDirectionForward
|
||||
if modifiers.Shift {
|
||||
direction = input.KeynavDirectionBackward
|
||||
}
|
||||
|
||||
if !child.HandleFocus(direction) {
|
||||
child.HandleUnfocus()
|
||||
}
|
||||
}
|
||||
} else if child, ok := window.child.(elements.KeyboardTarget); ok {
|
||||
child.HandleKeyDown(key, modifiers)
|
||||
}
|
||||
}
|
||||
|
||||
func (window *Window) handleKeyRelease (
|
||||
connection *xgbutil.XUtil,
|
||||
event xevent.KeyReleaseEvent,
|
||||
) {
|
||||
if window.child == nil { return }
|
||||
|
||||
keyEvent := *event.KeyReleaseEvent
|
||||
|
||||
// do not process this event if it was generated from a key repeat
|
||||
nextEvents := xevent.Peek(window.backend.connection)
|
||||
if len(nextEvents) > 0 {
|
||||
untypedEvent := nextEvents[0]
|
||||
if untypedEvent.Err == nil {
|
||||
typedEvent, ok :=
|
||||
untypedEvent.Event.(xproto.KeyPressEvent)
|
||||
|
||||
if ok && typedEvent.Detail == keyEvent.Detail &&
|
||||
typedEvent.Event == keyEvent.Event &&
|
||||
typedEvent.State == keyEvent.State {
|
||||
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
key, numberPad := window.backend.keycodeToKey(keyEvent.Detail, keyEvent.State)
|
||||
modifiers := window.modifiersFromState(keyEvent.State)
|
||||
modifiers.NumberPad = numberPad
|
||||
|
||||
if child, ok := window.child.(elements.KeyboardTarget); ok {
|
||||
child.HandleKeyUp(key, modifiers)
|
||||
}
|
||||
}
|
||||
|
||||
func (window *Window) handleButtonPress (
|
||||
connection *xgbutil.XUtil,
|
||||
event xevent.ButtonPressEvent,
|
||||
) {
|
||||
if window.child == nil { return }
|
||||
|
||||
if child, ok := window.child.(elements.MouseTarget); ok {
|
||||
buttonEvent := *event.ButtonPressEvent
|
||||
if buttonEvent.Detail >= 4 && buttonEvent.Detail <= 7 {
|
||||
sum := scrollSum { }
|
||||
sum.add(buttonEvent.Detail, window, buttonEvent.State)
|
||||
window.compressScrollSum(buttonEvent, &sum)
|
||||
child.HandleMouseScroll (
|
||||
int(buttonEvent.EventX),
|
||||
int(buttonEvent.EventY),
|
||||
float64(sum.x), float64(sum.y))
|
||||
} else {
|
||||
child.HandleMouseDown (
|
||||
int(buttonEvent.EventX),
|
||||
int(buttonEvent.EventY),
|
||||
input.Button(buttonEvent.Detail))
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func (window *Window) handleButtonRelease (
|
||||
connection *xgbutil.XUtil,
|
||||
event xevent.ButtonReleaseEvent,
|
||||
) {
|
||||
if window.child == nil { return }
|
||||
|
||||
if child, ok := window.child.(elements.MouseTarget); ok {
|
||||
buttonEvent := *event.ButtonReleaseEvent
|
||||
if buttonEvent.Detail >= 4 && buttonEvent.Detail <= 7 { return }
|
||||
child.HandleMouseUp (
|
||||
int(buttonEvent.EventX),
|
||||
int(buttonEvent.EventY),
|
||||
input.Button(buttonEvent.Detail))
|
||||
}
|
||||
}
|
||||
|
||||
func (window *Window) handleMotionNotify (
|
||||
connection *xgbutil.XUtil,
|
||||
event xevent.MotionNotifyEvent,
|
||||
) {
|
||||
if window.child == nil { return }
|
||||
|
||||
if child, ok := window.child.(elements.MouseTarget); ok {
|
||||
motionEvent := window.compressMotionNotify(*event.MotionNotifyEvent)
|
||||
child.HandleMouseMove (
|
||||
int(motionEvent.EventX),
|
||||
int(motionEvent.EventY))
|
||||
}
|
||||
}
|
||||
|
||||
func (window *Window) compressExpose (
|
||||
firstEvent xproto.ExposeEvent,
|
||||
) (
|
||||
lastEvent xproto.ExposeEvent,
|
||||
) {
|
||||
window.backend.connection.Sync()
|
||||
xevent.Read(window.backend.connection, false)
|
||||
lastEvent = firstEvent
|
||||
|
||||
for index, untypedEvent := range xevent.Peek(window.backend.connection) {
|
||||
if untypedEvent.Err != nil { continue }
|
||||
|
||||
typedEvent, ok := untypedEvent.Event.(xproto.ExposeEvent)
|
||||
if !ok { continue }
|
||||
|
||||
// FIXME: union all areas into the last event
|
||||
if firstEvent.Window == typedEvent.Window {
|
||||
lastEvent = typedEvent
|
||||
defer func (index int) {
|
||||
xevent.DequeueAt(window.backend.connection, index)
|
||||
} (index)
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (window *Window) compressConfigureNotify (
|
||||
firstEvent xproto.ConfigureNotifyEvent,
|
||||
) (
|
||||
lastEvent xproto.ConfigureNotifyEvent,
|
||||
) {
|
||||
window.backend.connection.Sync()
|
||||
xevent.Read(window.backend.connection, false)
|
||||
lastEvent = firstEvent
|
||||
|
||||
for index, untypedEvent := range xevent.Peek(window.backend.connection) {
|
||||
if untypedEvent.Err != nil { continue }
|
||||
|
||||
typedEvent, ok := untypedEvent.Event.(xproto.ConfigureNotifyEvent)
|
||||
if !ok { continue }
|
||||
|
||||
if firstEvent.Event == typedEvent.Event &&
|
||||
firstEvent.Window == typedEvent.Window {
|
||||
|
||||
lastEvent = typedEvent
|
||||
defer func (index int) {
|
||||
xevent.DequeueAt(window.backend.connection, index)
|
||||
} (index)
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (window *Window) compressScrollSum (
|
||||
firstEvent xproto.ButtonPressEvent,
|
||||
sum *scrollSum,
|
||||
) {
|
||||
window.backend.connection.Sync()
|
||||
xevent.Read(window.backend.connection, false)
|
||||
|
||||
for index, untypedEvent := range xevent.Peek(window.backend.connection) {
|
||||
if untypedEvent.Err != nil { continue }
|
||||
|
||||
typedEvent, ok := untypedEvent.Event.(xproto.ButtonPressEvent)
|
||||
if !ok { continue }
|
||||
|
||||
if firstEvent.Event == typedEvent.Event &&
|
||||
typedEvent.Detail >= 4 &&
|
||||
typedEvent.Detail <= 7 {
|
||||
|
||||
sum.add(typedEvent.Detail, window, typedEvent.State)
|
||||
defer func (index int) {
|
||||
xevent.DequeueAt(window.backend.connection, index)
|
||||
} (index)
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (window *Window) compressMotionNotify (
|
||||
firstEvent xproto.MotionNotifyEvent,
|
||||
) (
|
||||
lastEvent xproto.MotionNotifyEvent,
|
||||
) {
|
||||
window.backend.connection.Sync()
|
||||
xevent.Read(window.backend.connection, false)
|
||||
lastEvent = firstEvent
|
||||
|
||||
for index, untypedEvent := range xevent.Peek(window.backend.connection) {
|
||||
if untypedEvent.Err != nil { continue }
|
||||
|
||||
typedEvent, ok := untypedEvent.Event.(xproto.MotionNotifyEvent)
|
||||
if !ok { continue }
|
||||
|
||||
if firstEvent.Event == typedEvent.Event {
|
||||
lastEvent = typedEvent
|
||||
defer func (index int) {
|
||||
xevent.DequeueAt(window.backend.connection, index)
|
||||
} (index)
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
|
@ -0,0 +1,359 @@
|
|||
package x
|
||||
|
||||
import "image"
|
||||
import "github.com/jezek/xgb/xproto"
|
||||
import "github.com/jezek/xgbutil/ewmh"
|
||||
import "github.com/jezek/xgbutil/icccm"
|
||||
import "github.com/jezek/xgbutil/xevent"
|
||||
import "github.com/jezek/xgbutil/xwindow"
|
||||
import "github.com/jezek/xgbutil/xgraphics"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements"
|
||||
|
||||
type Window struct {
|
||||
backend *Backend
|
||||
xWindow *xwindow.Window
|
||||
xCanvas *xgraphics.Image
|
||||
canvas canvas.BasicCanvas
|
||||
child elements.Element
|
||||
onClose func ()
|
||||
skipChildDrawCallback bool
|
||||
|
||||
theme theme.Theme
|
||||
config config.Config
|
||||
|
||||
metrics struct {
|
||||
width int
|
||||
height int
|
||||
}
|
||||
}
|
||||
|
||||
func (backend *Backend) NewWindow (
|
||||
width, height int,
|
||||
) (
|
||||
output elements.Window,
|
||||
err error,
|
||||
) {
|
||||
if backend == nil { panic("nil backend") }
|
||||
|
||||
window := &Window { backend: backend }
|
||||
|
||||
window.xWindow, err = xwindow.Generate(backend.connection)
|
||||
if err != nil { return }
|
||||
window.xWindow.Create (
|
||||
backend.connection.RootWin(),
|
||||
0, 0, width, height, 0)
|
||||
err = window.xWindow.Listen (
|
||||
xproto.EventMaskExposure,
|
||||
xproto.EventMaskStructureNotify,
|
||||
xproto.EventMaskPointerMotion,
|
||||
xproto.EventMaskKeyPress,
|
||||
xproto.EventMaskKeyRelease,
|
||||
xproto.EventMaskButtonPress,
|
||||
xproto.EventMaskButtonRelease)
|
||||
if err != nil { return }
|
||||
|
||||
window.xWindow.WMGracefulClose (func (xWindow *xwindow.Window) {
|
||||
window.Close()
|
||||
})
|
||||
|
||||
xevent.ExposeFun(window.handleExpose).
|
||||
Connect(backend.connection, window.xWindow.Id)
|
||||
xevent.ConfigureNotifyFun(window.handleConfigureNotify).
|
||||
Connect(backend.connection, window.xWindow.Id)
|
||||
xevent.KeyPressFun(window.handleKeyPress).
|
||||
Connect(backend.connection, window.xWindow.Id)
|
||||
xevent.KeyReleaseFun(window.handleKeyRelease).
|
||||
Connect(backend.connection, window.xWindow.Id)
|
||||
xevent.ButtonPressFun(window.handleButtonPress).
|
||||
Connect(backend.connection, window.xWindow.Id)
|
||||
xevent.ButtonReleaseFun(window.handleButtonRelease).
|
||||
Connect(backend.connection, window.xWindow.Id)
|
||||
xevent.MotionNotifyFun(window.handleMotionNotify).
|
||||
Connect(backend.connection, window.xWindow.Id)
|
||||
|
||||
window.SetTheme(backend.theme)
|
||||
window.SetConfig(backend.config)
|
||||
|
||||
window.metrics.width = width
|
||||
window.metrics.height = height
|
||||
window.childMinimumSizeChangeCallback(8, 8)
|
||||
|
||||
window.reallocateCanvas()
|
||||
|
||||
backend.windows[window.xWindow.Id] = window
|
||||
output = window
|
||||
return
|
||||
}
|
||||
|
||||
func (window *Window) Adopt (child elements.Element) {
|
||||
// disown previous child
|
||||
if window.child != nil {
|
||||
window.child.OnDamage(nil)
|
||||
window.child.OnMinimumSizeChange(nil)
|
||||
}
|
||||
if previousChild, ok := window.child.(elements.Flexible); ok {
|
||||
previousChild.OnFlexibleHeightChange(nil)
|
||||
}
|
||||
if previousChild, ok := window.child.(elements.Focusable); ok {
|
||||
previousChild.OnFocusRequest(nil)
|
||||
previousChild.OnFocusMotionRequest(nil)
|
||||
if previousChild.Focused() {
|
||||
previousChild.HandleUnfocus()
|
||||
}
|
||||
}
|
||||
|
||||
// adopt new child
|
||||
window.child = child
|
||||
if newChild, ok := child.(elements.Themeable); ok {
|
||||
newChild.SetTheme(window.theme)
|
||||
}
|
||||
if newChild, ok := child.(elements.Configurable); ok {
|
||||
newChild.SetConfig(window.config)
|
||||
}
|
||||
if newChild, ok := child.(elements.Flexible); ok {
|
||||
newChild.OnFlexibleHeightChange(window.resizeChildToFit)
|
||||
}
|
||||
if newChild, ok := child.(elements.Focusable); ok {
|
||||
newChild.OnFocusRequest(window.childSelectionRequestCallback)
|
||||
}
|
||||
if child != nil {
|
||||
child.OnDamage(window.childDrawCallback)
|
||||
child.OnMinimumSizeChange (func () {
|
||||
window.childMinimumSizeChangeCallback (
|
||||
child.MinimumSize())
|
||||
})
|
||||
if !window.childMinimumSizeChangeCallback(child.MinimumSize()) {
|
||||
window.resizeChildToFit()
|
||||
window.redrawChildEntirely()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (window *Window) Child () (child elements.Element) {
|
||||
child = window.child
|
||||
return
|
||||
}
|
||||
|
||||
func (window *Window) SetTitle (title string) {
|
||||
ewmh.WmNameSet (
|
||||
window.backend.connection,
|
||||
window.xWindow.Id,
|
||||
title)
|
||||
}
|
||||
|
||||
func (window *Window) SetIcon (sizes []image.Image) {
|
||||
wmIcons := []ewmh.WmIcon { }
|
||||
|
||||
for _, icon := range sizes {
|
||||
width := icon.Bounds().Max.X
|
||||
height := icon.Bounds().Max.Y
|
||||
wmIcon := ewmh.WmIcon {
|
||||
Width: uint(width),
|
||||
Height: uint(height),
|
||||
Data: make ([]uint, width * height),
|
||||
}
|
||||
|
||||
// manually convert image data beacuse of course we have to do
|
||||
// this
|
||||
index := 0
|
||||
for y := 0; y < height; y ++ {
|
||||
for x := 0; x < width; x ++ {
|
||||
r, g, b, a := icon.At(x, y).RGBA()
|
||||
r >>= 8
|
||||
g >>= 8
|
||||
b >>= 8
|
||||
a >>= 8
|
||||
wmIcon.Data[index] =
|
||||
(uint(a) << 24) |
|
||||
(uint(r) << 16) |
|
||||
(uint(g) << 8) |
|
||||
(uint(b) << 0)
|
||||
index ++
|
||||
}}
|
||||
|
||||
wmIcons = append(wmIcons, wmIcon)
|
||||
}
|
||||
|
||||
ewmh.WmIconSet (
|
||||
window.backend.connection,
|
||||
window.xWindow.Id,
|
||||
wmIcons)
|
||||
}
|
||||
|
||||
func (window *Window) Show () {
|
||||
if window.child == nil {
|
||||
window.xCanvas.For (func (x, y int) xgraphics.BGRA {
|
||||
return xgraphics.BGRA { }
|
||||
})
|
||||
|
||||
window.pushRegion(window.xCanvas.Bounds())
|
||||
}
|
||||
|
||||
window.xWindow.Map()
|
||||
}
|
||||
|
||||
func (window *Window) Hide () {
|
||||
window.xWindow.Unmap()
|
||||
}
|
||||
|
||||
func (window *Window) Close () {
|
||||
if window.onClose != nil { window.onClose() }
|
||||
delete(window.backend.windows, window.xWindow.Id)
|
||||
window.xWindow.Destroy()
|
||||
}
|
||||
|
||||
func (window *Window) OnClose (callback func ()) {
|
||||
window.onClose = callback
|
||||
}
|
||||
|
||||
func (window *Window) SetTheme (theme theme.Theme) {
|
||||
window.theme = theme
|
||||
if child, ok := window.child.(elements.Themeable); ok {
|
||||
child.SetTheme(theme)
|
||||
}
|
||||
}
|
||||
|
||||
func (window *Window) SetConfig (config config.Config) {
|
||||
window.config = config
|
||||
if child, ok := window.child.(elements.Configurable); ok {
|
||||
child.SetConfig(config)
|
||||
}
|
||||
}
|
||||
|
||||
func (window *Window) reallocateCanvas () {
|
||||
window.canvas.Reallocate(window.metrics.width, window.metrics.height)
|
||||
|
||||
previousWidth, previousHeight := 0, 0
|
||||
if window.xCanvas != nil {
|
||||
previousWidth = window.xCanvas.Bounds().Dx()
|
||||
previousHeight = window.xCanvas.Bounds().Dy()
|
||||
}
|
||||
|
||||
newWidth := window.metrics.width
|
||||
newHeight := window.metrics.height
|
||||
larger := newWidth > previousWidth || newHeight > previousHeight
|
||||
smaller := newWidth < previousWidth / 2 || newHeight < previousHeight / 2
|
||||
if larger || smaller {
|
||||
if window.xCanvas != nil {
|
||||
window.xCanvas.Destroy()
|
||||
}
|
||||
window.xCanvas = xgraphics.New (
|
||||
window.backend.connection,
|
||||
image.Rect (
|
||||
0, 0,
|
||||
(newWidth / 64) * 64 + 64,
|
||||
(newHeight / 64) * 64 + 64))
|
||||
window.xCanvas.CreatePixmap()
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func (window *Window) redrawChildEntirely () {
|
||||
window.pushRegion(window.paste(window.canvas))
|
||||
|
||||
}
|
||||
|
||||
func (window *Window) resizeChildToFit () {
|
||||
window.skipChildDrawCallback = true
|
||||
if child, ok := window.child.(elements.Flexible); ok {
|
||||
minimumHeight := child.FlexibleHeightFor(window.metrics.width)
|
||||
minimumWidth, _ := child.MinimumSize()
|
||||
|
||||
icccm.WmNormalHintsSet (
|
||||
window.backend.connection,
|
||||
window.xWindow.Id,
|
||||
&icccm.NormalHints {
|
||||
Flags: icccm.SizeHintPMinSize,
|
||||
MinWidth: uint(minimumWidth),
|
||||
MinHeight: uint(minimumHeight),
|
||||
})
|
||||
|
||||
if window.metrics.height >= minimumHeight &&
|
||||
window.metrics.width >= minimumWidth {
|
||||
window.child.DrawTo(window.canvas)
|
||||
}
|
||||
} else {
|
||||
window.child.DrawTo(window.canvas)
|
||||
}
|
||||
window.skipChildDrawCallback = false
|
||||
}
|
||||
|
||||
func (window *Window) childDrawCallback (region canvas.Canvas) {
|
||||
if window.skipChildDrawCallback { return }
|
||||
window.pushRegion(window.paste(region))
|
||||
}
|
||||
|
||||
func (window *Window) paste (canvas canvas.Canvas) (updatedRegion image.Rectangle) {
|
||||
data, stride := canvas.Buffer()
|
||||
bounds := canvas.Bounds().Intersect(window.xCanvas.Bounds())
|
||||
for x := bounds.Min.X; x < bounds.Max.X; x ++ {
|
||||
for y := bounds.Min.Y; y < bounds.Max.Y; y ++ {
|
||||
rgba := data[x + y * stride]
|
||||
index := x * 4 + y * window.xCanvas.Stride
|
||||
window.xCanvas.Pix[index + 0] = rgba.B
|
||||
window.xCanvas.Pix[index + 1] = rgba.G
|
||||
window.xCanvas.Pix[index + 2] = rgba.R
|
||||
window.xCanvas.Pix[index + 3] = rgba.A
|
||||
}}
|
||||
|
||||
return bounds
|
||||
}
|
||||
|
||||
func (window *Window) childMinimumSizeChangeCallback (width, height int) (resized bool) {
|
||||
icccm.WmNormalHintsSet (
|
||||
window.backend.connection,
|
||||
window.xWindow.Id,
|
||||
&icccm.NormalHints {
|
||||
Flags: icccm.SizeHintPMinSize,
|
||||
MinWidth: uint(width),
|
||||
MinHeight: uint(height),
|
||||
})
|
||||
newWidth := window.metrics.width
|
||||
newHeight := window.metrics.height
|
||||
if newWidth < width { newWidth = width }
|
||||
if newHeight < height { newHeight = height }
|
||||
if newWidth != window.metrics.width ||
|
||||
newHeight != window.metrics.height {
|
||||
window.xWindow.Resize(newWidth, newHeight)
|
||||
return true
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
func (window *Window) childSelectionRequestCallback () (granted bool) {
|
||||
if _, ok := window.child.(elements.Focusable); ok {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (window *Window) childSelectionMotionRequestCallback (
|
||||
direction input.KeynavDirection,
|
||||
) (
|
||||
granted bool,
|
||||
) {
|
||||
if child, ok := window.child.(elements.Focusable); ok {
|
||||
if !child.HandleFocus(direction) {
|
||||
child.HandleUnfocus()
|
||||
}
|
||||
return true
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (window *Window) pushRegion (region image.Rectangle) {
|
||||
if window.xCanvas == nil { panic("whoopsie!!!!!!!!!!!!!!") }
|
||||
image, ok := window.xCanvas.SubImage(region).(*xgraphics.Image)
|
||||
if ok {
|
||||
image.XDraw()
|
||||
image.XExpPaint (
|
||||
window.xWindow.Id,
|
||||
image.Bounds().Min.X,
|
||||
image.Bounds().Min.Y)
|
||||
}
|
||||
}
|
|
@ -0,0 +1,140 @@
|
|||
package x
|
||||
|
||||
import "git.tebibyte.media/sashakoshka/tomo"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/data"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
|
||||
import "github.com/jezek/xgbutil"
|
||||
import "github.com/jezek/xgb/xproto"
|
||||
import "github.com/jezek/xgbutil/xevent"
|
||||
|
||||
// Backend is an instance of an X backend.
|
||||
type Backend struct {
|
||||
connection *xgbutil.XUtil
|
||||
|
||||
doChannel chan(func ())
|
||||
|
||||
modifierMasks struct {
|
||||
capsLock uint16
|
||||
shiftLock uint16
|
||||
numLock uint16
|
||||
modeSwitch uint16
|
||||
|
||||
alt uint16
|
||||
meta uint16
|
||||
super uint16
|
||||
hyper uint16
|
||||
}
|
||||
|
||||
theme theme.Theme
|
||||
config config.Config
|
||||
|
||||
windows map[xproto.Window] *Window
|
||||
|
||||
open bool
|
||||
}
|
||||
|
||||
// NewBackend instantiates an X backend.
|
||||
func NewBackend () (output tomo.Backend, err error) {
|
||||
backend := &Backend {
|
||||
windows: map[xproto.Window] *Window { },
|
||||
doChannel: make(chan func (), 0),
|
||||
theme: theme.Default { },
|
||||
config: config.Default { },
|
||||
open: true,
|
||||
}
|
||||
|
||||
// connect to X
|
||||
backend.connection, err = xgbutil.NewConn()
|
||||
if err != nil { return }
|
||||
backend.initializeKeymapInformation()
|
||||
|
||||
output = backend
|
||||
return
|
||||
}
|
||||
|
||||
// Run runs the backend's event loop. This method will not exit until Stop() is
|
||||
// called, or the backend experiences a fatal error.
|
||||
func (backend *Backend) Run () (err error) {
|
||||
backend.assert()
|
||||
pingBefore,
|
||||
pingAfter,
|
||||
pingQuit := xevent.MainPing(backend.connection)
|
||||
for {
|
||||
select {
|
||||
case <- pingBefore:
|
||||
<- pingAfter
|
||||
case callback := <- backend.doChannel:
|
||||
callback()
|
||||
case <- pingQuit:
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Stop gracefully closes the connection and stops the event loop.
|
||||
func (backend *Backend) Stop () {
|
||||
backend.assert()
|
||||
if !backend.open { return }
|
||||
backend.open = false
|
||||
|
||||
toClose := []*Window { }
|
||||
for _, window := range backend.windows {
|
||||
toClose = append(toClose, window)
|
||||
}
|
||||
for _, window := range toClose {
|
||||
window.Close()
|
||||
}
|
||||
xevent.Quit(backend.connection)
|
||||
backend.connection.Conn().Close()
|
||||
}
|
||||
|
||||
// Do executes the specified callback within the main thread as soon as
|
||||
// possible. This function can be safely called from other threads.
|
||||
func (backend *Backend) Do (callback func ()) {
|
||||
backend.assert()
|
||||
backend.doChannel <- callback
|
||||
}
|
||||
|
||||
// Copy puts data into the clipboard. This method is not yet implemented and
|
||||
// will do nothing!
|
||||
func (backend *Backend) Copy (data data.Data) {
|
||||
backend.assert()
|
||||
// TODO
|
||||
}
|
||||
|
||||
// Paste returns the data currently in the clipboard. This method may
|
||||
// return nil. This method is not yet implemented and will do nothing!
|
||||
func (backend *Backend) Paste (accept []data.Mime) (data data.Data) {
|
||||
backend.assert()
|
||||
// TODO
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
// SetTheme sets the theme of all open windows.
|
||||
func (backend *Backend) SetTheme (theme theme.Theme) {
|
||||
backend.assert()
|
||||
backend.theme = theme
|
||||
for _, window := range backend.windows {
|
||||
window.SetTheme(theme)
|
||||
}
|
||||
}
|
||||
|
||||
// SetConfig sets the configuration of all open windows.
|
||||
func (backend *Backend) SetConfig (config config.Config) {
|
||||
backend.assert()
|
||||
backend.config = config
|
||||
for _, window := range backend.windows {
|
||||
window.SetConfig(config)
|
||||
}
|
||||
}
|
||||
|
||||
func (backend *Backend) assert () {
|
||||
if backend == nil { panic("nil backend") }
|
||||
}
|
||||
|
||||
func init () {
|
||||
tomo.RegisterBackend(NewBackend)
|
||||
}
|
|
@ -0,0 +1,111 @@
|
|||
package canvas
|
||||
|
||||
import "image"
|
||||
import "image/draw"
|
||||
import "image/color"
|
||||
|
||||
// Image represents an immutable canvas.
|
||||
type Image interface {
|
||||
image.Image
|
||||
RGBAAt (x, y int) color.RGBA
|
||||
}
|
||||
|
||||
// Canvas is like draw.Image but is also able to return a raw pixel buffer for
|
||||
// more efficient drawing. This interface can be easily satisfied using a
|
||||
// BasicCanvas struct.
|
||||
type Canvas interface {
|
||||
draw.Image
|
||||
Buffer () (data []color.RGBA, stride int)
|
||||
}
|
||||
|
||||
// BasicCanvas is a general purpose implementation of tomo.Canvas.
|
||||
type BasicCanvas struct {
|
||||
pix []color.RGBA
|
||||
stride int
|
||||
rect image.Rectangle
|
||||
}
|
||||
|
||||
// NewBasicCanvas creates a new basic canvas with the specified width and
|
||||
// height, allocating a buffer for it.
|
||||
func NewBasicCanvas (width, height int) (canvas BasicCanvas) {
|
||||
canvas.pix = make([]color.RGBA, height * width)
|
||||
canvas.stride = width
|
||||
canvas.rect = image.Rect(0, 0, width, height)
|
||||
return
|
||||
}
|
||||
|
||||
// FromImage creates a new BasicCanvas from an image.Image.
|
||||
func FromImage (img image.Image) (canvas BasicCanvas) {
|
||||
bounds := img.Bounds()
|
||||
canvas = NewBasicCanvas(bounds.Dx(), bounds.Dy())
|
||||
point := image.Point { }
|
||||
for point.Y = bounds.Min.Y; point.Y < bounds.Max.Y; point.Y ++ {
|
||||
for point.X = bounds.Min.X; point.X < bounds.Max.X; point.X ++ {
|
||||
canvasPoint := point.Sub(bounds.Min)
|
||||
canvas.Set (
|
||||
canvasPoint.X, canvasPoint.Y,
|
||||
img.At(point.X, point.Y))
|
||||
}}
|
||||
return
|
||||
}
|
||||
|
||||
// you know what it do
|
||||
func (canvas BasicCanvas) Bounds () (bounds image.Rectangle) {
|
||||
return canvas.rect
|
||||
}
|
||||
|
||||
// you know what it do
|
||||
func (canvas BasicCanvas) At (x, y int) (color.Color) {
|
||||
if !image.Pt(x, y).In(canvas.rect) { return nil }
|
||||
return canvas.pix[x + y * canvas.stride]
|
||||
}
|
||||
|
||||
// you know what it do
|
||||
func (canvas BasicCanvas) ColorModel () (model color.Model) {
|
||||
return color.RGBAModel
|
||||
}
|
||||
|
||||
// you know what it do
|
||||
func (canvas BasicCanvas) Set (x, y int, c color.Color) {
|
||||
if !image.Pt(x, y).In(canvas.rect) { return }
|
||||
r, g, b, a := c.RGBA()
|
||||
canvas.pix[x + y * canvas.stride] = color.RGBA {
|
||||
R: uint8(r >> 8),
|
||||
G: uint8(g >> 8),
|
||||
B: uint8(b >> 8),
|
||||
A: uint8(a >> 8),
|
||||
}
|
||||
}
|
||||
|
||||
// you know what it do
|
||||
func (canvas BasicCanvas) Buffer () (data []color.RGBA, stride int) {
|
||||
return canvas.pix, canvas.stride
|
||||
}
|
||||
|
||||
// Reallocate efficiently reallocates the canvas. The data within will be
|
||||
// garbage. This method will do nothing if this is a cut image.
|
||||
func (canvas *BasicCanvas) Reallocate (width, height int) {
|
||||
if canvas.rect.Min != (image.Point { }) { return }
|
||||
|
||||
previousLen := len(canvas.pix)
|
||||
newLen := width * height
|
||||
bigger := newLen > previousLen
|
||||
smaller := newLen < previousLen / 2
|
||||
if bigger || smaller {
|
||||
canvas.pix = make (
|
||||
[]color.RGBA,
|
||||
((height * width) / 4096) * 4096 + 4096)
|
||||
}
|
||||
canvas.stride = width
|
||||
canvas.rect = image.Rect(0, 0, width, height)
|
||||
}
|
||||
|
||||
// Cut returns a sub-canvas of a given canvas.
|
||||
func Cut (canvas Canvas, bounds image.Rectangle) (reduced BasicCanvas) {
|
||||
// println(canvas.Bounds().String(), bounds.String())
|
||||
bounds = bounds.Intersect(canvas.Bounds())
|
||||
if bounds.Empty() { return }
|
||||
reduced.rect = bounds
|
||||
reduced.pix, reduced.stride = canvas.Buffer()
|
||||
return
|
||||
}
|
|
@ -0,0 +1,4 @@
|
|||
// Package canvas provides a canvas interface that is able to return a pixel
|
||||
// buffer for drawing. This makes it considerably more efficient than the
|
||||
// standard draw.Image.
|
||||
package canvas
|
14
config.go
14
config.go
|
@ -1,14 +0,0 @@
|
|||
package tomo
|
||||
|
||||
import "time"
|
||||
|
||||
// Config can return global configuration parameters.
|
||||
type Config interface {
|
||||
// ScrollVelocity returns how many pixels should be scrolled every time
|
||||
// a scroll button is pressed.
|
||||
ScrollVelocity () int
|
||||
|
||||
// DoubleClickDelay returns the maximum delay between two clicks for
|
||||
// them to be registered as a double click.
|
||||
DoubleClickDelay () time.Duration
|
||||
}
|
|
@ -0,0 +1,62 @@
|
|||
package config
|
||||
|
||||
// Config can return global configuration parameters.
|
||||
type Config interface {
|
||||
// HandleWidth returns how large grab handles should typically be. This
|
||||
// is important for accessibility reasons.
|
||||
HandleWidth () int
|
||||
|
||||
// ScrollVelocity returns how many pixels should be scrolled every time
|
||||
// a scroll button is pressed.
|
||||
ScrollVelocity () int
|
||||
|
||||
// ThemePath returns the directory path to the theme.
|
||||
ThemePath () string
|
||||
}
|
||||
|
||||
// Default specifies default configuration values.
|
||||
type Default struct { }
|
||||
|
||||
|
||||
// HandleWidth returns the default handle width value.
|
||||
func (Default) HandleWidth () int {
|
||||
return 16
|
||||
}
|
||||
|
||||
// ScrollVelocity returns the default scroll velocity value.
|
||||
func (Default) ScrollVelocity () int {
|
||||
return 16
|
||||
}
|
||||
|
||||
// ThemePath returns the default theme path.
|
||||
func (Default) ThemePath () (string) {
|
||||
return ""
|
||||
}
|
||||
|
||||
// Wrapped wraps a configuration and uses Default if it is nil.
|
||||
type Wrapped struct {
|
||||
Config
|
||||
}
|
||||
|
||||
// HandleWidth returns how large grab handles should typically be. This
|
||||
// is important for accessibility reasons.
|
||||
func (wrapped Wrapped) HandleWidth () int {
|
||||
return wrapped.ensure().HandleWidth()
|
||||
}
|
||||
|
||||
// ScrollVelocity returns how many pixels should be scrolled every time
|
||||
// a scroll button is pressed.
|
||||
func (wrapped Wrapped) ScrollVelocity () int {
|
||||
return wrapped.ensure().ScrollVelocity()
|
||||
}
|
||||
|
||||
// ThemePath returns the directory path to the theme.
|
||||
func (wrapped Wrapped) ThemePath () string {
|
||||
return wrapped.ensure().ThemePath()
|
||||
}
|
||||
|
||||
func (wrapped Wrapped) ensure () (real Config) {
|
||||
real = wrapped.Config
|
||||
if real == nil { real = Default { } }
|
||||
return
|
||||
}
|
|
@ -0,0 +1,9 @@
|
|||
package config
|
||||
|
||||
import "io"
|
||||
|
||||
// Parse parses one or more configuration files and returns them as a Config.
|
||||
func Parse (sources ...io.Reader) (config Config) {
|
||||
// TODO
|
||||
return Default { }
|
||||
}
|
39
data/data.go
39
data/data.go
|
@ -1,12 +1,10 @@
|
|||
// Package data provides operations to deal with arbitrary data and MIME types.
|
||||
package data
|
||||
|
||||
import "io"
|
||||
import "bytes"
|
||||
|
||||
// Data represents arbitrary polymorphic data that can be used for data transfer
|
||||
// between applications.
|
||||
type Data map[Mime] io.ReadSeekCloser
|
||||
type Data map[Mime] io.ReadCloser
|
||||
|
||||
// Mime represents a MIME type.
|
||||
type Mime struct {
|
||||
|
@ -17,41 +15,6 @@ type Mime struct {
|
|||
Type, Subtype string
|
||||
}
|
||||
|
||||
// M is shorthand for creating a MIME type.
|
||||
func M (ty, subtype string) Mime {
|
||||
return Mime { ty, subtype }
|
||||
}
|
||||
|
||||
// String returns the string representation of the MIME type.
|
||||
func (mime Mime) String () string {
|
||||
return mime.Type + "/" + mime.Subtype
|
||||
}
|
||||
|
||||
var MimePlain = Mime { "text", "plain" }
|
||||
|
||||
var MimeFile = Mime { "text", "uri-list" }
|
||||
|
||||
type byteReadCloser struct { *bytes.Reader }
|
||||
func (byteReadCloser) Close () error { return nil }
|
||||
|
||||
// Text returns plain text Data given a string.
|
||||
func Text (text string) Data {
|
||||
return Bytes(MimePlain, []byte(text))
|
||||
}
|
||||
|
||||
// Bytes constructs a Data given a buffer and a mime type.
|
||||
func Bytes (mime Mime, buffer []byte) Data {
|
||||
return Data {
|
||||
mime: byteReadCloser { bytes.NewReader(buffer) },
|
||||
}
|
||||
}
|
||||
|
||||
// Merge combines several Datas together. If multiple Datas provide a reader for
|
||||
// the same mime type, the ones further on in the list will take precedence.
|
||||
func Merge (individual ...Data) (combined Data) {
|
||||
for _, data := range individual {
|
||||
for mime, reader := range data {
|
||||
combined[mime] = reader
|
||||
}}
|
||||
return
|
||||
}
|
||||
|
|
|
@ -1,41 +0,0 @@
|
|||
package config
|
||||
|
||||
import "time"
|
||||
import "tomo"
|
||||
|
||||
// Default specifies default configuration values.
|
||||
type Default struct { }
|
||||
|
||||
|
||||
// ScrollVelocity returns the default scroll velocity value.
|
||||
func (Default) ScrollVelocity () int {
|
||||
return 16
|
||||
}
|
||||
|
||||
// DoubleClickDelay returns the default double click delay.
|
||||
func (Default) DoubleClickDelay () time.Duration {
|
||||
return time.Second / 2
|
||||
}
|
||||
|
||||
// Wrapped wraps a configuration and uses Default if it is nil.
|
||||
type Wrapped struct {
|
||||
tomo.Config
|
||||
}
|
||||
|
||||
// ScrollVelocity returns how many pixels should be scrolled every time a scroll
|
||||
// button is pressed.
|
||||
func (wrapped Wrapped) ScrollVelocity () int {
|
||||
return wrapped.ensure().ScrollVelocity()
|
||||
}
|
||||
|
||||
// DoubleClickDelay returns the maximum delay between two clicks for them to be
|
||||
// registered as a double click.
|
||||
func (wrapped Wrapped) DoubleClickDelay () time.Duration {
|
||||
return wrapped.ensure().DoubleClickDelay()
|
||||
}
|
||||
|
||||
func (wrapped Wrapped) ensure () (real tomo.Config) {
|
||||
real = wrapped.Config
|
||||
if real == nil { real = Default { } }
|
||||
return
|
||||
}
|
|
@ -1,2 +0,0 @@
|
|||
// Package config implements a default configuration.
|
||||
package config
|
|
@ -1,9 +0,0 @@
|
|||
package config
|
||||
|
||||
// import "io"
|
||||
|
||||
// Parse parses one or more configuration files and returns them as a Config.
|
||||
// func Parse (sources ...io.Reader) (config tomo.Config) {
|
||||
// // TODO
|
||||
// return Default { }
|
||||
// }
|
Binary file not shown.
Before Width: | Height: | Size: 350 B |
Binary file not shown.
Before Width: | Height: | Size: 2.9 KiB |
Binary file not shown.
Before Width: | Height: | Size: 2.7 KiB |
|
@ -1,250 +0,0 @@
|
|||
package theme
|
||||
|
||||
import "image"
|
||||
import "bytes"
|
||||
import _ "embed"
|
||||
import _ "image/png"
|
||||
import "image/color"
|
||||
import "golang.org/x/image/font"
|
||||
import "golang.org/x/image/font/basicfont"
|
||||
import "tomo"
|
||||
import "tomo/data"
|
||||
import "art"
|
||||
import "art/artutil"
|
||||
import "art/patterns"
|
||||
|
||||
//go:embed assets/default.png
|
||||
var defaultAtlasBytes []byte
|
||||
var defaultAtlas art.Canvas
|
||||
var defaultTextures [7][7]art.Pattern
|
||||
//go:embed assets/wintergreen-icons-small.png
|
||||
var defaultIconsSmallAtlasBytes []byte
|
||||
var defaultIconsSmall [640]binaryIcon
|
||||
//go:embed assets/wintergreen-icons-large.png
|
||||
var defaultIconsLargeAtlasBytes []byte
|
||||
var defaultIconsLarge [640]binaryIcon
|
||||
|
||||
func atlasCell (col, row int, border art.Inset) {
|
||||
bounds := image.Rect(0, 0, 8, 8).Add(image.Pt(col, row).Mul(8))
|
||||
defaultTextures[col][row] = patterns.Border {
|
||||
Canvas: art.Cut(defaultAtlas, bounds),
|
||||
Inset: border,
|
||||
}
|
||||
}
|
||||
|
||||
func atlasCol (col int, border art.Inset) {
|
||||
for index, _ := range defaultTextures[col] {
|
||||
atlasCell(col, index, border)
|
||||
}
|
||||
}
|
||||
|
||||
type binaryIcon struct {
|
||||
data []bool
|
||||
stride int
|
||||
}
|
||||
|
||||
func (icon binaryIcon) Draw (destination art.Canvas, color color.RGBA, at image.Point) {
|
||||
bounds := icon.Bounds().Add(at).Intersect(destination.Bounds())
|
||||
point := image.Point { }
|
||||
data, stride := destination.Buffer()
|
||||
|
||||
for point.Y = bounds.Min.Y; point.Y < bounds.Max.Y; point.Y ++ {
|
||||
for point.X = bounds.Min.X; point.X < bounds.Max.X; point.X ++ {
|
||||
srcPoint := point.Sub(at)
|
||||
srcIndex := srcPoint.X + srcPoint.Y * icon.stride
|
||||
dstIndex := point.X + point.Y * stride
|
||||
if icon.data[srcIndex] {
|
||||
data[dstIndex] = color
|
||||
}
|
||||
}}
|
||||
}
|
||||
|
||||
func (icon binaryIcon) Bounds () image.Rectangle {
|
||||
return image.Rect(0, 0, icon.stride, len(icon.data) / icon.stride)
|
||||
}
|
||||
|
||||
func binaryIconFrom (source image.Image, clip image.Rectangle) (icon binaryIcon) {
|
||||
bounds := source.Bounds().Intersect(clip)
|
||||
if bounds.Empty() { return }
|
||||
|
||||
icon.stride = bounds.Dx()
|
||||
icon.data = make([]bool, bounds.Dx() * bounds.Dy())
|
||||
|
||||
point := image.Point { }
|
||||
dstIndex := 0
|
||||
for point.Y = bounds.Min.Y; point.Y < bounds.Max.Y; point.Y ++ {
|
||||
for point.X = bounds.Min.X; point.X < bounds.Max.X; point.X ++ {
|
||||
r, g, b, a := source.At(point.X, point.Y).RGBA()
|
||||
if a > 0x8000 && (r + g + b) / 3 < 0x8000 {
|
||||
icon.data[dstIndex] = true
|
||||
}
|
||||
dstIndex ++
|
||||
}}
|
||||
return
|
||||
}
|
||||
|
||||
func init () {
|
||||
defaultAtlasImage, _, _ := image.Decode(bytes.NewReader(defaultAtlasBytes))
|
||||
defaultAtlas = art.FromImage(defaultAtlasImage)
|
||||
|
||||
atlasCol(0, art.I(0))
|
||||
atlasCol(1, art.I(3))
|
||||
atlasCol(2, art.I(1))
|
||||
atlasCol(3, art.I(1))
|
||||
atlasCol(4, art.I(1))
|
||||
atlasCol(5, art.I(3))
|
||||
atlasCol(6, art.I(1))
|
||||
|
||||
// set up small icons
|
||||
defaultIconsSmallAtlasImage, _, _ := image.Decode (
|
||||
bytes.NewReader(defaultIconsSmallAtlasBytes))
|
||||
point := image.Point { }
|
||||
iconIndex := 0
|
||||
for point.Y = 0; point.Y < 20; point.Y ++ {
|
||||
for point.X = 0; point.X < 32; point.X ++ {
|
||||
defaultIconsSmall[iconIndex] = binaryIconFrom (
|
||||
defaultIconsSmallAtlasImage,
|
||||
image.Rect(0, 0, 16, 16).Add(point.Mul(16)))
|
||||
iconIndex ++
|
||||
}}
|
||||
|
||||
// set up large icons
|
||||
defaultIconsLargeAtlasImage, _, _ := image.Decode (
|
||||
bytes.NewReader(defaultIconsLargeAtlasBytes))
|
||||
point = image.Point { }
|
||||
iconIndex = 0
|
||||
for point.Y = 0; point.Y < 8; point.Y ++ {
|
||||
for point.X = 0; point.X < 32; point.X ++ {
|
||||
defaultIconsLarge[iconIndex] = binaryIconFrom (
|
||||
defaultIconsLargeAtlasImage,
|
||||
image.Rect(0, 0, 32, 32).Add(point.Mul(32)))
|
||||
iconIndex ++
|
||||
}}
|
||||
iconIndex = 384
|
||||
for point.Y = 8; point.Y < 12; point.Y ++ {
|
||||
for point.X = 0; point.X < 32; point.X ++ {
|
||||
defaultIconsLarge[iconIndex] = binaryIconFrom (
|
||||
defaultIconsLargeAtlasImage,
|
||||
image.Rect(0, 0, 32, 32).Add(point.Mul(32)))
|
||||
iconIndex ++
|
||||
}}
|
||||
}
|
||||
|
||||
// Default is the default theme.
|
||||
type Default struct { }
|
||||
|
||||
// FontFace returns the default font face.
|
||||
func (Default) FontFace (style tomo.FontStyle, size tomo.FontSize, c tomo.Case) font.Face {
|
||||
return basicfont.Face7x13
|
||||
}
|
||||
|
||||
// Icon returns an icon from the default set corresponding to the given name.
|
||||
func (Default) Icon (id tomo.Icon, size tomo.IconSize, c tomo.Case) art.Icon {
|
||||
if size == tomo.IconSizeLarge {
|
||||
if id < 0 || int(id) >= len(defaultIconsLarge) {
|
||||
return nil
|
||||
} else {
|
||||
return defaultIconsLarge[id]
|
||||
}
|
||||
} else {
|
||||
if id < 0 || int(id) >= len(defaultIconsSmall) {
|
||||
return nil
|
||||
} else {
|
||||
return defaultIconsSmall[id]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MimeIcon returns an icon from the default set corresponding to the given mime.
|
||||
// type.
|
||||
func (Default) MimeIcon (data.Mime, tomo.IconSize, tomo.Case) art.Icon {
|
||||
// TODO
|
||||
return nil
|
||||
}
|
||||
|
||||
// Pattern returns a pattern from the default theme corresponding to the given
|
||||
// pattern ID.
|
||||
func (Default) Pattern (id tomo.Pattern, state tomo.State, c tomo.Case) art.Pattern {
|
||||
offset := 0; switch {
|
||||
case state.Disabled: offset = 1
|
||||
case state.Pressed && state.On: offset = 4
|
||||
case state.Focused && state.On: offset = 6
|
||||
case state.On: offset = 2
|
||||
case state.Pressed: offset = 3
|
||||
case state.Focused: offset = 5
|
||||
}
|
||||
|
||||
switch id {
|
||||
case tomo.PatternBackground: return patterns.Uhex(0xaaaaaaFF)
|
||||
case tomo.PatternDead: return defaultTextures[0][offset]
|
||||
case tomo.PatternRaised: return defaultTextures[1][offset]
|
||||
case tomo.PatternSunken: return defaultTextures[2][offset]
|
||||
case tomo.PatternPinboard: return defaultTextures[3][offset]
|
||||
case tomo.PatternButton: return defaultTextures[1][offset]
|
||||
case tomo.PatternInput: return defaultTextures[2][offset]
|
||||
case tomo.PatternGutter: return defaultTextures[2][offset]
|
||||
case tomo.PatternHandle: return defaultTextures[3][offset]
|
||||
case tomo.PatternLine: return defaultTextures[0][offset]
|
||||
case tomo.PatternMercury: return defaultTextures[4][offset]
|
||||
case tomo.PatternTableHead: return defaultTextures[5][offset]
|
||||
case tomo.PatternTableCell: return defaultTextures[5][offset]
|
||||
case tomo.PatternLamp: return defaultTextures[6][offset]
|
||||
default: return patterns.Uhex(0xFF00FFFF)
|
||||
}
|
||||
}
|
||||
|
||||
func (Default) Color (id tomo.Color, state tomo.State, c tomo.Case) color.RGBA {
|
||||
if state.Disabled { return artutil.Hex(0x444444FF) }
|
||||
|
||||
return artutil.Hex (map[tomo.Color] uint32 {
|
||||
tomo.ColorBlack: 0x272d24FF,
|
||||
tomo.ColorRed: 0x8c4230FF,
|
||||
tomo.ColorGreen: 0x69905fFF,
|
||||
tomo.ColorYellow: 0x9a973dFF,
|
||||
tomo.ColorBlue: 0x3d808fFF,
|
||||
tomo.ColorPurple: 0x8c608bFF,
|
||||
tomo.ColorCyan: 0x3d8f84FF,
|
||||
tomo.ColorWhite: 0xaea894FF,
|
||||
tomo.ColorBrightBlack: 0x4f5142FF,
|
||||
tomo.ColorBrightRed: 0xbd6f59FF,
|
||||
tomo.ColorBrightGreen: 0x8dad84FF,
|
||||
tomo.ColorBrightYellow: 0xe2c558FF,
|
||||
tomo.ColorBrightBlue: 0x77b1beFF,
|
||||
tomo.ColorBrightPurple: 0xc991c8FF,
|
||||
tomo.ColorBrightCyan: 0x74c7b7FF,
|
||||
tomo.ColorBrightWhite: 0xcfd7d2FF,
|
||||
|
||||
tomo.ColorForeground: 0x000000FF,
|
||||
tomo.ColorMidground: 0x656565FF,
|
||||
tomo.ColorBackground: 0xAAAAAAFF,
|
||||
tomo.ColorShadow: 0x000000FF,
|
||||
tomo.ColorShine: 0xFFFFFFFF,
|
||||
tomo.ColorAccent: 0xff3300FF,
|
||||
} [id])
|
||||
}
|
||||
|
||||
// Padding returns the default padding value for the given pattern.
|
||||
func (Default) Padding (id tomo.Pattern, c tomo.Case) art.Inset {
|
||||
switch id {
|
||||
case tomo.PatternGutter: return art.I(0)
|
||||
case tomo.PatternLine: return art.I(1)
|
||||
default: return art.I(6)
|
||||
}
|
||||
}
|
||||
|
||||
// Margin returns the default margin value for the given pattern.
|
||||
func (Default) Margin (id tomo.Pattern, c tomo.Case) image.Point {
|
||||
return image.Pt(6, 6)
|
||||
}
|
||||
|
||||
// Hints returns rendering optimization hints for a particular pattern.
|
||||
// These are optional, but following them may result in improved
|
||||
// performance.
|
||||
func (Default) Hints (pattern tomo.Pattern, c tomo.Case) (hints tomo.Hints) {
|
||||
return
|
||||
}
|
||||
|
||||
// Sink returns the default sink vector for the given pattern.
|
||||
func (Default) Sink (pattern tomo.Pattern, c tomo.Case) image.Point {
|
||||
return image.Point { 1, 1 }
|
||||
}
|
|
@ -1,2 +0,0 @@
|
|||
// Package theme implements a default theme.
|
||||
package theme
|
|
@ -0,0 +1,47 @@
|
|||
package defaultfont
|
||||
|
||||
import "golang.org/x/image/font/basicfont"
|
||||
|
||||
var FaceRegular = basicfont.Face7x13
|
||||
|
||||
// FIXME: make bold, italic, and bold italic masks by processing the Face7x13
|
||||
// mask.
|
||||
|
||||
var FaceBold = &basicfont.Face {
|
||||
Advance: 7,
|
||||
Width: 6,
|
||||
Height: 13,
|
||||
Ascent: 11,
|
||||
Descent: 2,
|
||||
Mask: FaceRegular.Mask, // TODO
|
||||
Ranges: []basicfont.Range {
|
||||
{ '\u0020', '\u007f', 0 },
|
||||
{ '\ufffd', '\ufffe', 95 },
|
||||
},
|
||||
}
|
||||
|
||||
var FaceItalic = &basicfont.Face {
|
||||
Advance: 7,
|
||||
Width: 6,
|
||||
Height: 13,
|
||||
Ascent: 11,
|
||||
Descent: 2,
|
||||
Mask: FaceRegular.Mask, // TODO
|
||||
Ranges: []basicfont.Range {
|
||||
{ '\u0020', '\u007f', 0 },
|
||||
{ '\ufffd', '\ufffe', 95 },
|
||||
},
|
||||
}
|
||||
|
||||
var FaceBoldItalic = &basicfont.Face {
|
||||
Advance: 7,
|
||||
Width: 6,
|
||||
Height: 13,
|
||||
Ascent: 11,
|
||||
Descent: 2,
|
||||
Mask: FaceRegular.Mask, // TODO
|
||||
Ranges: []basicfont.Range {
|
||||
{ '\u0020', '\u007f', 0 },
|
||||
{ '\ufffd', '\ufffe', 95 },
|
||||
},
|
||||
}
|
|
@ -1,4 +1,3 @@
|
|||
// Package dirs provides access to standard system and user directories.
|
||||
package dirs
|
||||
|
||||
import "os"
|
||||
|
|
15
element.go
15
element.go
|
@ -1,15 +0,0 @@
|
|||
package tomo
|
||||
|
||||
import "art"
|
||||
|
||||
// Element represents a basic on-screen object. Extended element interfaces are
|
||||
// defined in the ability module.
|
||||
type Element interface {
|
||||
// Draw causes the element to draw 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.
|
||||
Draw (art.Canvas)
|
||||
|
||||
// Entity returns this element's entity.
|
||||
Entity () Entity
|
||||
}
|
|
@ -0,0 +1,198 @@
|
|||
package basicElements
|
||||
|
||||
import "image"
|
||||
// import "runtime/debug"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/shatter"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/textdraw"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// Button is a clickable button.
|
||||
type Button struct {
|
||||
*core.Core
|
||||
*core.FocusableCore
|
||||
core core.CoreControl
|
||||
focusableControl core.FocusableCoreControl
|
||||
drawer textdraw.Drawer
|
||||
|
||||
pressed bool
|
||||
text string
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
|
||||
onClick func ()
|
||||
}
|
||||
|
||||
// NewButton creates a new button with the specified label text.
|
||||
func NewButton (text string) (element *Button) {
|
||||
element = &Button { }
|
||||
element.theme.Case = theme.C("basic", "button")
|
||||
element.Core, element.core = core.NewCore(element.drawAll)
|
||||
element.FocusableCore,
|
||||
element.focusableControl = core.NewFocusableCore (func () {
|
||||
element.drawAndPush(true)
|
||||
})
|
||||
element.SetText(text)
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Button) HandleMouseDown (x, y int, button input.Button) {
|
||||
if !element.Enabled() { return }
|
||||
if !element.Focused() { element.Focus() }
|
||||
if button != input.ButtonLeft { return }
|
||||
element.pressed = true
|
||||
element.drawAndPush(true)
|
||||
}
|
||||
|
||||
func (element *Button) HandleMouseUp (x, y int, button input.Button) {
|
||||
if button != input.ButtonLeft { return }
|
||||
element.pressed = false
|
||||
within := image.Point { x, y }.
|
||||
In(element.Bounds())
|
||||
if element.Enabled() && within && element.onClick != nil {
|
||||
element.onClick()
|
||||
}
|
||||
element.drawAndPush(true)
|
||||
}
|
||||
|
||||
func (element *Button) HandleMouseMove (x, y int) { }
|
||||
func (element *Button) HandleMouseScroll (x, y int, deltaX, deltaY float64) { }
|
||||
|
||||
func (element *Button) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if !element.Enabled() { return }
|
||||
if key == input.KeyEnter {
|
||||
element.pressed = true
|
||||
element.drawAndPush(true)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Button) HandleKeyUp(key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter && element.pressed {
|
||||
element.pressed = false
|
||||
element.drawAndPush(true)
|
||||
if !element.Enabled() { return }
|
||||
if element.onClick != nil {
|
||||
element.onClick()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// OnClick sets the function to be called when the button is clicked.
|
||||
func (element *Button) OnClick (callback func ()) {
|
||||
element.onClick = callback
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this button can be clicked or not.
|
||||
func (element *Button) SetEnabled (enabled bool) {
|
||||
element.focusableControl.SetEnabled(enabled)
|
||||
}
|
||||
|
||||
// SetText sets the button's label text.
|
||||
func (element *Button) SetText (text string) {
|
||||
if element.text == text { return }
|
||||
|
||||
element.text = text
|
||||
element.drawer.SetText([]rune(text))
|
||||
element.updateMinimumSize()
|
||||
element.drawAndPush(false)
|
||||
}
|
||||
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *Button) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
element.drawer.SetFace (element.theme.FontFace (
|
||||
theme.FontStyleRegular,
|
||||
theme.FontSizeNormal))
|
||||
element.updateMinimumSize()
|
||||
element.drawAndPush(false)
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *Button) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
element.updateMinimumSize()
|
||||
element.drawAndPush(false)
|
||||
}
|
||||
|
||||
func (element *Button) updateMinimumSize () {
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
padding := element.theme.Padding(theme.PatternButton)
|
||||
minimumSize := padding.Inverse().Apply(textBounds)
|
||||
element.core.SetMinimumSize(minimumSize.Dx(), minimumSize.Dy())
|
||||
}
|
||||
|
||||
func (element *Button) drawAndPush (partial bool) {
|
||||
if element.core.HasImage () {
|
||||
if partial {
|
||||
element.core.DamageRegion (append (
|
||||
element.drawBackground(true),
|
||||
element.drawText(true))...)
|
||||
} else {
|
||||
element.drawAll()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Button) state () theme.State {
|
||||
return theme.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.Focused(),
|
||||
Pressed: element.pressed,
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Button) drawBackground (partial bool) []image.Rectangle {
|
||||
state := element.state()
|
||||
bounds := element.Bounds()
|
||||
pattern := element.theme.Pattern(theme.PatternButton, state)
|
||||
static := element.theme.Hints(theme.PatternButton).StaticInset
|
||||
|
||||
if partial && static != (artist.Inset { }) {
|
||||
tiles := shatter.Shatter(bounds, static.Apply(bounds))
|
||||
artist.Draw(element.core, pattern, tiles...)
|
||||
return tiles
|
||||
} else {
|
||||
pattern.Draw(element.core, bounds)
|
||||
return []image.Rectangle { bounds }
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Button) drawText (partial bool) image.Rectangle {
|
||||
state := element.state()
|
||||
bounds := element.Bounds()
|
||||
foreground := element.theme.Color(theme.ColorForeground, state)
|
||||
sink := element.theme.Sink(theme.PatternButton)
|
||||
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
offset := image.Point {
|
||||
X: bounds.Min.X + (bounds.Dx() - textBounds.Dx()) / 2,
|
||||
Y: bounds.Min.Y + (bounds.Dy() - textBounds.Dy()) / 2,
|
||||
}
|
||||
offset.Y -= textBounds.Min.Y
|
||||
offset.X -= textBounds.Min.X
|
||||
region := textBounds.Union(textBounds.Add(sink)).Add(offset)
|
||||
|
||||
if element.pressed {
|
||||
offset = offset.Add(sink)
|
||||
}
|
||||
|
||||
if partial {
|
||||
pattern := element.theme.Pattern(theme.PatternButton, state)
|
||||
pattern.Draw(element.core, region)
|
||||
}
|
||||
|
||||
element.drawer.Draw(element.core, foreground, offset)
|
||||
return region
|
||||
}
|
||||
|
||||
func (element *Button) drawAll () {
|
||||
element.drawBackground(false)
|
||||
element.drawText(false)
|
||||
}
|
|
@ -0,0 +1,192 @@
|
|||
package basicElements
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/textdraw"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// Checkbox is a toggle-able checkbox with a label.
|
||||
type Checkbox struct {
|
||||
*core.Core
|
||||
*core.FocusableCore
|
||||
core core.CoreControl
|
||||
focusableControl core.FocusableCoreControl
|
||||
drawer textdraw.Drawer
|
||||
|
||||
pressed bool
|
||||
checked bool
|
||||
text string
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
|
||||
onToggle func ()
|
||||
}
|
||||
|
||||
// NewCheckbox creates a new cbeckbox with the specified label text.
|
||||
func NewCheckbox (text string, checked bool) (element *Checkbox) {
|
||||
element = &Checkbox { checked: checked }
|
||||
element.theme.Case = theme.C("basic", "checkbox")
|
||||
element.Core, element.core = core.NewCore(element.draw)
|
||||
element.FocusableCore,
|
||||
element.focusableControl = core.NewFocusableCore(element.redo)
|
||||
element.SetText(text)
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Checkbox) HandleMouseDown (x, y int, button input.Button) {
|
||||
if !element.Enabled() { return }
|
||||
element.Focus()
|
||||
element.pressed = true
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Checkbox) HandleMouseUp (x, y int, button input.Button) {
|
||||
if button != input.ButtonLeft || !element.pressed { return }
|
||||
|
||||
element.pressed = false
|
||||
within := image.Point { x, y }.
|
||||
In(element.Bounds())
|
||||
if within {
|
||||
element.checked = !element.checked
|
||||
}
|
||||
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
if within && element.onToggle != nil {
|
||||
element.onToggle()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Checkbox) HandleMouseMove (x, y int) { }
|
||||
func (element *Checkbox) HandleMouseScroll (x, y int, deltaX, deltaY float64) { }
|
||||
|
||||
func (element *Checkbox) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter {
|
||||
element.pressed = true
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Checkbox) HandleKeyUp (key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter && element.pressed {
|
||||
element.pressed = false
|
||||
element.checked = !element.checked
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
if element.onToggle != nil {
|
||||
element.onToggle()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// OnToggle sets the function to be called when the checkbox is toggled.
|
||||
func (element *Checkbox) OnToggle (callback func ()) {
|
||||
element.onToggle = callback
|
||||
}
|
||||
|
||||
// Value reports whether or not the checkbox is currently checked.
|
||||
func (element *Checkbox) Value () (checked bool) {
|
||||
return element.checked
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this checkbox can be toggled or not.
|
||||
func (element *Checkbox) SetEnabled (enabled bool) {
|
||||
element.focusableControl.SetEnabled(enabled)
|
||||
}
|
||||
|
||||
// SetText sets the checkbox's label text.
|
||||
func (element *Checkbox) SetText (text string) {
|
||||
if element.text == text { return }
|
||||
|
||||
element.text = text
|
||||
element.drawer.SetText([]rune(text))
|
||||
element.updateMinimumSize()
|
||||
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *Checkbox) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
element.drawer.SetFace (element.theme.FontFace (
|
||||
theme.FontStyleRegular,
|
||||
theme.FontSizeNormal))
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *Checkbox) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *Checkbox) updateMinimumSize () {
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
if element.text == "" {
|
||||
element.core.SetMinimumSize(textBounds.Dy(), textBounds.Dy())
|
||||
} else {
|
||||
margin := element.theme.Margin(theme.PatternBackground)
|
||||
element.core.SetMinimumSize (
|
||||
textBounds.Dy() + margin.X + textBounds.Dx(),
|
||||
textBounds.Dy())
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Checkbox) redo () {
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Checkbox) draw () {
|
||||
bounds := element.Bounds()
|
||||
boxBounds := image.Rect(0, 0, bounds.Dy(), bounds.Dy()).Add(bounds.Min)
|
||||
|
||||
state := theme.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.Focused(),
|
||||
Pressed: element.pressed,
|
||||
On: element.checked,
|
||||
}
|
||||
|
||||
backgroundPattern := element.theme.Pattern (
|
||||
theme.PatternBackground, state)
|
||||
backgroundPattern.Draw(element.core, bounds)
|
||||
|
||||
pattern := element.theme.Pattern(theme.PatternButton, state)
|
||||
artist.DrawBounds(element.core, pattern, boxBounds)
|
||||
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
margin := element.theme.Margin(theme.PatternBackground)
|
||||
offset := bounds.Min.Add(image.Point {
|
||||
X: bounds.Dy() + margin.X,
|
||||
})
|
||||
|
||||
offset.Y -= textBounds.Min.Y
|
||||
offset.X -= textBounds.Min.X
|
||||
|
||||
foreground := element.theme.Color(theme.ColorForeground, state)
|
||||
element.drawer.Draw(element.core, foreground, offset)
|
||||
}
|
|
@ -0,0 +1,536 @@
|
|||
package basicElements
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/layouts"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// Container is an element capable of containg other elements, and arranging
|
||||
// them in a layout.
|
||||
type Container struct {
|
||||
*core.Core
|
||||
core core.CoreControl
|
||||
|
||||
layout layouts.Layout
|
||||
children []layouts.LayoutEntry
|
||||
drags [10]elements.MouseTarget
|
||||
warping bool
|
||||
focused bool
|
||||
focusable bool
|
||||
flexible bool
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
|
||||
onFocusRequest func () (granted bool)
|
||||
onFocusMotionRequest func (input.KeynavDirection) (granted bool)
|
||||
onFlexibleHeightChange func ()
|
||||
}
|
||||
|
||||
// NewContainer creates a new container.
|
||||
func NewContainer (layout layouts.Layout) (element *Container) {
|
||||
element = &Container { }
|
||||
element.theme.Case = theme.C("basic", "container")
|
||||
element.Core, element.core = core.NewCore(element.redoAll)
|
||||
element.SetLayout(layout)
|
||||
return
|
||||
}
|
||||
|
||||
// SetLayout sets the layout of this container.
|
||||
func (element *Container) SetLayout (layout layouts.Layout) {
|
||||
element.layout = layout
|
||||
if element.core.HasImage() {
|
||||
element.redoAll()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
// Adopt adds a new child element to the container. If expand is set to true,
|
||||
// the element will expand (instead of contract to its minimum size), in
|
||||
// whatever way is defined by the current layout.
|
||||
func (element *Container) Adopt (child elements.Element, expand bool) {
|
||||
// set event handlers
|
||||
if child0, ok := child.(elements.Themeable); ok {
|
||||
child0.SetTheme(element.theme.Theme)
|
||||
}
|
||||
if child0, ok := child.(elements.Configurable); ok {
|
||||
child0.SetConfig(element.config.Config)
|
||||
}
|
||||
child.OnDamage (func (region canvas.Canvas) {
|
||||
element.core.DamageRegion(region.Bounds())
|
||||
})
|
||||
child.OnMinimumSizeChange (func () {
|
||||
// TODO: this could probably stand to be more efficient. I mean
|
||||
// seriously?
|
||||
element.updateMinimumSize()
|
||||
element.redoAll()
|
||||
element.core.DamageAll()
|
||||
})
|
||||
if child0, ok := child.(elements.Flexible); ok {
|
||||
child0.OnFlexibleHeightChange(element.updateMinimumSize)
|
||||
}
|
||||
if child0, ok := child.(elements.Focusable); ok {
|
||||
child0.OnFocusRequest (func () (granted bool) {
|
||||
return element.childFocusRequestCallback(child0)
|
||||
})
|
||||
child0.OnFocusMotionRequest (
|
||||
func (direction input.KeynavDirection) (granted bool) {
|
||||
if element.onFocusMotionRequest == nil { return }
|
||||
return element.onFocusMotionRequest(direction)
|
||||
})
|
||||
}
|
||||
|
||||
// add child
|
||||
element.children = append (element.children, layouts.LayoutEntry {
|
||||
Element: child,
|
||||
Expand: expand,
|
||||
})
|
||||
|
||||
// refresh stale data
|
||||
element.updateMinimumSize()
|
||||
element.reflectChildProperties()
|
||||
if element.core.HasImage() && !element.warping {
|
||||
element.redoAll()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
// Warp runs the specified callback, deferring all layout and rendering updates
|
||||
// until the callback has finished executing. This allows for aplications to
|
||||
// perform batch gui updates without flickering and stuff.
|
||||
func (element *Container) Warp (callback func ()) {
|
||||
if element.warping {
|
||||
callback()
|
||||
return
|
||||
}
|
||||
|
||||
element.warping = true
|
||||
callback()
|
||||
element.warping = false
|
||||
|
||||
// TODO: create some sort of task list so we don't do a full recalculate
|
||||
// and redraw every time, because although that is the most likely use
|
||||
// case, it is not the only one.
|
||||
if element.core.HasImage() {
|
||||
element.redoAll()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
// Disown removes the given child from the container if it is contained within
|
||||
// it.
|
||||
func (element *Container) Disown (child elements.Element) {
|
||||
for index, entry := range element.children {
|
||||
if entry.Element == child {
|
||||
element.clearChildEventHandlers(entry.Element)
|
||||
element.children = append (
|
||||
element.children[:index],
|
||||
element.children[index + 1:]...)
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
element.updateMinimumSize()
|
||||
element.reflectChildProperties()
|
||||
if element.core.HasImage() && !element.warping {
|
||||
element.redoAll()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Container) clearChildEventHandlers (child elements.Element) {
|
||||
child.DrawTo(nil)
|
||||
child.OnDamage(nil)
|
||||
child.OnMinimumSizeChange(nil)
|
||||
if child0, ok := child.(elements.Focusable); ok {
|
||||
child0.OnFocusRequest(nil)
|
||||
child0.OnFocusMotionRequest(nil)
|
||||
if child0.Focused() {
|
||||
child0.HandleUnfocus()
|
||||
}
|
||||
}
|
||||
if child0, ok := child.(elements.Flexible); ok {
|
||||
child0.OnFlexibleHeightChange(nil)
|
||||
}
|
||||
}
|
||||
|
||||
// DisownAll removes all child elements from the container at once.
|
||||
func (element *Container) DisownAll () {
|
||||
element.children = nil
|
||||
|
||||
element.updateMinimumSize()
|
||||
element.reflectChildProperties()
|
||||
if element.core.HasImage() && !element.warping {
|
||||
element.redoAll()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
// Children returns a slice containing this element's children.
|
||||
func (element *Container) Children () (children []elements.Element) {
|
||||
children = make([]elements.Element, len(element.children))
|
||||
for index, entry := range element.children {
|
||||
children[index] = entry.Element
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// CountChildren returns the amount of children contained within this element.
|
||||
func (element *Container) CountChildren () (count int) {
|
||||
return len(element.children)
|
||||
}
|
||||
|
||||
// Child returns the child at the specified index. If the index is out of
|
||||
// bounds, this method will return nil.
|
||||
func (element *Container) Child (index int) (child elements.Element) {
|
||||
if index < 0 || index > len(element.children) { return }
|
||||
return element.children[index].Element
|
||||
}
|
||||
|
||||
// ChildAt returns the child that contains the specified x and y coordinates. If
|
||||
// there are no children at the coordinates, this method will return nil.
|
||||
func (element *Container) ChildAt (point image.Point) (child elements.Element) {
|
||||
for _, entry := range element.children {
|
||||
if point.In(entry.Bounds) {
|
||||
child = entry.Element
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Container) childPosition (child elements.Element) (position image.Point) {
|
||||
for _, entry := range element.children {
|
||||
if entry.Element == child {
|
||||
position = entry.Bounds.Min
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Container) redoAll () {
|
||||
if !element.core.HasImage() { return }
|
||||
// do a layout
|
||||
element.doLayout()
|
||||
|
||||
// draw a background
|
||||
rocks := make([]image.Rectangle, len(element.children))
|
||||
for index, entry := range element.children {
|
||||
rocks[index] = entry.Bounds
|
||||
}
|
||||
pattern := element.theme.Pattern (
|
||||
theme.PatternBackground,
|
||||
theme.State { })
|
||||
artist.DrawShatter (
|
||||
element.core, pattern, rocks...)
|
||||
|
||||
// cut our canvas up and give peices to child elements
|
||||
for _, entry := range element.children {
|
||||
entry.DrawTo(canvas.Cut(element.core, entry.Bounds))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *Container) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
for _, child := range element.children {
|
||||
if child0, ok := child.Element.(elements.Themeable); ok {
|
||||
child0.SetTheme(element.theme.Theme)
|
||||
}
|
||||
}
|
||||
element.updateMinimumSize()
|
||||
element.redoAll()
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *Container) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
for _, child := range element.children {
|
||||
if child0, ok := child.Element.(elements.Configurable); ok {
|
||||
child0.SetConfig(element.config)
|
||||
}
|
||||
}
|
||||
element.updateMinimumSize()
|
||||
element.redoAll()
|
||||
}
|
||||
|
||||
func (element *Container) HandleMouseDown (x, y int, button input.Button) {
|
||||
child, handlesMouse := element.ChildAt(image.Pt(x, y)).(elements.MouseTarget)
|
||||
if !handlesMouse { return }
|
||||
element.drags[button] = child
|
||||
child.HandleMouseDown(x, y, button)
|
||||
}
|
||||
|
||||
func (element *Container) HandleMouseUp (x, y int, button input.Button) {
|
||||
child := element.drags[button]
|
||||
if child == nil { return }
|
||||
element.drags[button] = nil
|
||||
child.HandleMouseUp(x, y, button)
|
||||
}
|
||||
|
||||
func (element *Container) HandleMouseMove (x, y int) {
|
||||
for _, child := range element.drags {
|
||||
if child == nil { continue }
|
||||
child.HandleMouseMove(x, y)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Container) HandleMouseScroll (x, y int, deltaX, deltaY float64) {
|
||||
child, handlesMouse := element.ChildAt(image.Pt(x, y)).(elements.MouseTarget)
|
||||
if !handlesMouse { return }
|
||||
child.HandleMouseScroll(x, y, deltaX, deltaY)
|
||||
}
|
||||
|
||||
func (element *Container) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
element.forFocused (func (child elements.Focusable) bool {
|
||||
child0, handlesKeyboard := child.(elements.KeyboardTarget)
|
||||
if handlesKeyboard {
|
||||
child0.HandleKeyDown(key, modifiers)
|
||||
}
|
||||
return true
|
||||
})
|
||||
}
|
||||
|
||||
func (element *Container) HandleKeyUp (key input.Key, modifiers input.Modifiers) {
|
||||
element.forFocused (func (child elements.Focusable) bool {
|
||||
child0, handlesKeyboard := child.(elements.KeyboardTarget)
|
||||
if handlesKeyboard {
|
||||
child0.HandleKeyUp(key, modifiers)
|
||||
}
|
||||
return true
|
||||
})
|
||||
}
|
||||
|
||||
func (element *Container) FlexibleHeightFor (width int) (height int) {
|
||||
margin := element.theme.Margin(theme.PatternBackground)
|
||||
// TODO: have layouts take in x and y margins
|
||||
return element.layout.FlexibleHeightFor (
|
||||
element.children,
|
||||
margin.X, width)
|
||||
}
|
||||
|
||||
func (element *Container) OnFlexibleHeightChange (callback func ()) {
|
||||
element.onFlexibleHeightChange = callback
|
||||
}
|
||||
|
||||
func (element *Container) Focused () (focused bool) {
|
||||
return element.focused
|
||||
}
|
||||
|
||||
func (element *Container) Focus () {
|
||||
if element.onFocusRequest != nil {
|
||||
element.onFocusRequest()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Container) HandleFocus (direction input.KeynavDirection) (ok bool) {
|
||||
if !element.focusable { return false }
|
||||
direction = direction.Canon()
|
||||
|
||||
firstFocused := element.firstFocused()
|
||||
if firstFocused < 0 {
|
||||
// no element is currently focused, so we need to focus either
|
||||
// the first or last focusable element depending on the
|
||||
// direction.
|
||||
switch direction {
|
||||
case input.KeynavDirectionNeutral, input.KeynavDirectionForward:
|
||||
// if we recieve a neutral or forward direction, focus
|
||||
// the first focusable element.
|
||||
return element.focusFirstFocusableElement(direction)
|
||||
|
||||
case input.KeynavDirectionBackward:
|
||||
// if we recieve a backward direction, focus the last
|
||||
// focusable element.
|
||||
return element.focusLastFocusableElement(direction)
|
||||
}
|
||||
} else {
|
||||
// an element is currently focused, so we need to move the
|
||||
// focus in the specified direction
|
||||
firstFocusedChild :=
|
||||
element.children[firstFocused].Element.(elements.Focusable)
|
||||
|
||||
// before we move the focus, the currently focused child
|
||||
// may also be able to move its focus. if the child is able
|
||||
// to do that, we will let it and not move ours.
|
||||
if firstFocusedChild.HandleFocus(direction) {
|
||||
return true
|
||||
}
|
||||
|
||||
// find the previous/next focusable element relative to the
|
||||
// currently focused element, if it exists.
|
||||
for index := firstFocused + int(direction);
|
||||
index < len(element.children) && index >= 0;
|
||||
index += int(direction) {
|
||||
|
||||
child, focusable :=
|
||||
element.children[index].
|
||||
Element.(elements.Focusable)
|
||||
if focusable && child.HandleFocus(direction) {
|
||||
// we have found one, so we now actually move
|
||||
// the focus.
|
||||
firstFocusedChild.HandleUnfocus()
|
||||
element.focused = true
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
func (element *Container) focusFirstFocusableElement (
|
||||
direction input.KeynavDirection,
|
||||
) (
|
||||
ok bool,
|
||||
) {
|
||||
element.forFocusable (func (child elements.Focusable) bool {
|
||||
if child.HandleFocus(direction) {
|
||||
element.focused = true
|
||||
ok = true
|
||||
return false
|
||||
}
|
||||
return true
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Container) focusLastFocusableElement (
|
||||
direction input.KeynavDirection,
|
||||
) (
|
||||
ok bool,
|
||||
) {
|
||||
element.forFocusableBackward (func (child elements.Focusable) bool {
|
||||
if child.HandleFocus(direction) {
|
||||
element.focused = true
|
||||
ok = true
|
||||
return false
|
||||
}
|
||||
return true
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Container) HandleUnfocus () {
|
||||
element.focused = false
|
||||
element.forFocused (func (child elements.Focusable) bool {
|
||||
child.HandleUnfocus()
|
||||
return true
|
||||
})
|
||||
}
|
||||
|
||||
func (element *Container) OnFocusRequest (callback func () (granted bool)) {
|
||||
element.onFocusRequest = callback
|
||||
}
|
||||
|
||||
func (element *Container) OnFocusMotionRequest (
|
||||
callback func (direction input.KeynavDirection) (granted bool),
|
||||
) {
|
||||
element.onFocusMotionRequest = callback
|
||||
}
|
||||
|
||||
func (element *Container) forFocused (callback func (child elements.Focusable) bool) {
|
||||
for _, entry := range element.children {
|
||||
child, focusable := entry.Element.(elements.Focusable)
|
||||
if focusable && child.Focused() {
|
||||
if !callback(child) { break }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Container) forFocusable (callback func (child elements.Focusable) bool) {
|
||||
for _, entry := range element.children {
|
||||
child, focusable := entry.Element.(elements.Focusable)
|
||||
if focusable {
|
||||
if !callback(child) { break }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Container) forFlexible (callback func (child elements.Flexible) bool) {
|
||||
for _, entry := range element.children {
|
||||
child, flexible := entry.Element.(elements.Flexible)
|
||||
if flexible {
|
||||
if !callback(child) { break }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Container) forFocusableBackward (callback func (child elements.Focusable) bool) {
|
||||
for index := len(element.children) - 1; index >= 0; index -- {
|
||||
child, focusable := element.children[index].Element.(elements.Focusable)
|
||||
if focusable {
|
||||
if !callback(child) { break }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Container) firstFocused () (index int) {
|
||||
for currentIndex, entry := range element.children {
|
||||
child, focusable := entry.Element.(elements.Focusable)
|
||||
if focusable && child.Focused() {
|
||||
return currentIndex
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
func (element *Container) reflectChildProperties () {
|
||||
element.focusable = false
|
||||
element.forFocusable (func (elements.Focusable) bool {
|
||||
element.focusable = true
|
||||
return false
|
||||
})
|
||||
element.flexible = false
|
||||
element.forFlexible (func (elements.Flexible) bool {
|
||||
element.flexible = true
|
||||
return false
|
||||
})
|
||||
if !element.focusable {
|
||||
element.focused = false
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Container) childFocusRequestCallback (
|
||||
child elements.Focusable,
|
||||
) (
|
||||
granted bool,
|
||||
) {
|
||||
if element.onFocusRequest != nil && element.onFocusRequest() {
|
||||
element.focused = true
|
||||
element.forFocused (func (child elements.Focusable) bool {
|
||||
child.HandleUnfocus()
|
||||
return true
|
||||
})
|
||||
return true
|
||||
} else {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Container) updateMinimumSize () {
|
||||
margin := element.theme.Margin(theme.PatternBackground)
|
||||
// TODO: have layouts take in x and y margins
|
||||
width, height := element.layout.MinimumSize(element.children, margin.X)
|
||||
if element.flexible {
|
||||
height = element.layout.FlexibleHeightFor (
|
||||
element.children,
|
||||
margin.X, width)
|
||||
}
|
||||
element.core.SetMinimumSize(width, height)
|
||||
}
|
||||
|
||||
func (element *Container) doLayout () {
|
||||
margin := element.theme.Margin(theme.PatternBackground)
|
||||
// TODO: have layouts take in x and y margins
|
||||
element.layout.Arrange (
|
||||
element.children, margin.X, element.Bounds())
|
||||
}
|
|
@ -0,0 +1,3 @@
|
|||
// Package basicElements provides standard elements that are commonly used in
|
||||
// GUI applications.
|
||||
package basicElements
|
|
@ -0,0 +1,25 @@
|
|||
package basicElements
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist/patterns"
|
||||
|
||||
type Image struct {
|
||||
*core.Core
|
||||
core core.CoreControl
|
||||
buffer canvas.Canvas
|
||||
}
|
||||
|
||||
func NewImage (image image.Image) (element *Image) {
|
||||
element = &Image { buffer: canvas.FromImage(image) }
|
||||
element.Core, element.core = core.NewCore(element.draw)
|
||||
bounds := image.Bounds()
|
||||
element.core.SetMinimumSize(bounds.Dx(), bounds.Dy())
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Image) draw () {
|
||||
(patterns.Texture { Canvas: element.buffer }).
|
||||
Draw(element.core, element.Bounds())
|
||||
}
|
|
@ -0,0 +1,167 @@
|
|||
package basicElements
|
||||
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/textdraw"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// Label is a simple text box.
|
||||
type Label struct {
|
||||
*core.Core
|
||||
core core.CoreControl
|
||||
|
||||
wrap bool
|
||||
text string
|
||||
drawer textdraw.Drawer
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
|
||||
onFlexibleHeightChange func ()
|
||||
}
|
||||
|
||||
// NewLabel creates a new label. If wrap is set to true, the text inside will be
|
||||
// wrapped.
|
||||
func NewLabel (text string, wrap bool) (element *Label) {
|
||||
element = &Label { }
|
||||
element.theme.Case = theme.C("basic", "label")
|
||||
element.Core, element.core = core.NewCore(element.handleResize)
|
||||
element.SetWrap(wrap)
|
||||
element.SetText(text)
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Label) redo () {
|
||||
face := element.theme.FontFace (
|
||||
theme.FontStyleRegular,
|
||||
theme.FontSizeNormal)
|
||||
element.drawer.SetFace(face)
|
||||
element.updateMinimumSize()
|
||||
bounds := element.Bounds()
|
||||
if element.wrap {
|
||||
element.drawer.SetMaxWidth(bounds.Dx())
|
||||
element.drawer.SetMaxHeight(bounds.Dy())
|
||||
}
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
|
||||
func (element *Label) handleResize () {
|
||||
bounds := element.Bounds()
|
||||
if element.wrap {
|
||||
element.drawer.SetMaxWidth(bounds.Dx())
|
||||
element.drawer.SetMaxHeight(bounds.Dy())
|
||||
}
|
||||
element.draw()
|
||||
return
|
||||
}
|
||||
|
||||
// FlexibleHeightFor returns the reccomended height for this element based on
|
||||
// the given width in order to allow the text to wrap properly.
|
||||
func (element *Label) FlexibleHeightFor (width int) (height int) {
|
||||
if element.wrap {
|
||||
return element.drawer.ReccomendedHeightFor(width)
|
||||
} else {
|
||||
_, height = element.MinimumSize()
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
// OnFlexibleHeightChange sets a function to be called when the parameters
|
||||
// affecting this element's flexible height are changed.
|
||||
func (element *Label) OnFlexibleHeightChange (callback func ()) {
|
||||
element.onFlexibleHeightChange = callback
|
||||
}
|
||||
|
||||
// SetText sets the label's text.
|
||||
func (element *Label) SetText (text string) {
|
||||
if element.text == text { return }
|
||||
|
||||
element.text = text
|
||||
element.drawer.SetText([]rune(text))
|
||||
element.updateMinimumSize()
|
||||
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
// SetWrap sets wether or not the label's text wraps. If the text is set to
|
||||
// wrap, the element will have a minimum size of a single character and
|
||||
// automatically wrap its text. If the text is set to not wrap, the element will
|
||||
// have a minimum size that fits its text.
|
||||
func (element *Label) SetWrap (wrap bool) {
|
||||
if wrap == element.wrap { return }
|
||||
if !wrap {
|
||||
element.drawer.SetMaxWidth(0)
|
||||
element.drawer.SetMaxHeight(0)
|
||||
}
|
||||
element.wrap = wrap
|
||||
element.updateMinimumSize()
|
||||
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *Label) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
element.drawer.SetFace (element.theme.FontFace (
|
||||
theme.FontStyleRegular,
|
||||
theme.FontSizeNormal))
|
||||
element.updateMinimumSize()
|
||||
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *Label) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
element.updateMinimumSize()
|
||||
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Label) updateMinimumSize () {
|
||||
if element.wrap {
|
||||
em := element.drawer.Em().Round()
|
||||
if em < 1 {
|
||||
em = element.theme.Padding(theme.PatternBackground)[0]
|
||||
}
|
||||
element.core.SetMinimumSize (
|
||||
em, element.drawer.LineHeight().Round())
|
||||
if element.onFlexibleHeightChange != nil {
|
||||
element.onFlexibleHeightChange()
|
||||
}
|
||||
} else {
|
||||
bounds := element.drawer.LayoutBounds()
|
||||
element.core.SetMinimumSize(bounds.Dx(), bounds.Dy())
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Label) draw () {
|
||||
bounds := element.Bounds()
|
||||
|
||||
pattern := element.theme.Pattern (
|
||||
theme.PatternBackground,
|
||||
theme.State { })
|
||||
pattern.Draw(element.core, bounds)
|
||||
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
|
||||
foreground := element.theme.Color (
|
||||
theme.ColorForeground,
|
||||
theme.State { })
|
||||
element.drawer.Draw(element.core, foreground, bounds.Min.Sub(textBounds.Min))
|
||||
}
|
|
@ -1,6 +1,4 @@
|
|||
package elements
|
||||
|
||||
import "tomo"
|
||||
package basicElements
|
||||
|
||||
// Numeric is a type constraint representing a number.
|
||||
type Numeric interface {
|
||||
|
@ -12,29 +10,24 @@ type Numeric interface {
|
|||
// LerpSlider is a slider that has a minimum and maximum value, and who's value
|
||||
// can be any numeric type.
|
||||
type LerpSlider[T Numeric] struct {
|
||||
slider
|
||||
*Slider
|
||||
min T
|
||||
max T
|
||||
}
|
||||
|
||||
// NewVLerpSlider creates a new horizontal LerpSlider with a minimum and maximum
|
||||
// value.
|
||||
func NewVLerpSlider[T Numeric] (min, max T, value T) (element *LerpSlider[T]) {
|
||||
element = NewHLerpSlider(min, max, value)
|
||||
element.vertical = true
|
||||
return
|
||||
}
|
||||
|
||||
// NewHLerpSlider creates a new horizontal LerpSlider with a minimum and maximum
|
||||
// value.
|
||||
func NewHLerpSlider[T Numeric] (min, max T, value T) (element *LerpSlider[T]) {
|
||||
if min > max { min, max = max, min }
|
||||
// NewLerpSlider creates a new LerpSlider with a minimum and maximum value. If
|
||||
// vertical is set to true, the slider will be vertical instead of horizontal.
|
||||
func NewLerpSlider[T Numeric] (min, max T, value T, vertical bool) (element *LerpSlider[T]) {
|
||||
if min > max {
|
||||
temp := max
|
||||
max = min
|
||||
min = temp
|
||||
}
|
||||
element = &LerpSlider[T] {
|
||||
Slider: NewSlider(0, vertical),
|
||||
min: min,
|
||||
max: max,
|
||||
}
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.construct()
|
||||
element.SetValue(value)
|
||||
return
|
||||
}
|
||||
|
@ -42,13 +35,13 @@ func NewHLerpSlider[T Numeric] (min, max T, value T) (element *LerpSlider[T]) {
|
|||
// SetValue sets the slider's value.
|
||||
func (element *LerpSlider[T]) SetValue (value T) {
|
||||
value -= element.min
|
||||
element.slider.SetValue(float64(value) / float64(element.Range()))
|
||||
element.Slider.SetValue(float64(value) / float64(element.Range()))
|
||||
}
|
||||
|
||||
// Value returns the slider's value.
|
||||
func (element *LerpSlider[T]) Value () (value T) {
|
||||
return T (
|
||||
float64(element.slider.Value()) * float64(element.Range())) +
|
||||
float64(element.Slider.Value()) * float64(element.Range())) +
|
||||
element.min
|
||||
}
|
||||
|
|
@ -0,0 +1,465 @@
|
|||
package basicElements
|
||||
|
||||
import "fmt"
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// List is an element that contains several objects that a user can select.
|
||||
type List struct {
|
||||
*core.Core
|
||||
*core.FocusableCore
|
||||
core core.CoreControl
|
||||
focusableControl core.FocusableCoreControl
|
||||
|
||||
pressed bool
|
||||
|
||||
contentHeight int
|
||||
forcedMinimumWidth int
|
||||
forcedMinimumHeight int
|
||||
|
||||
selectedEntry int
|
||||
scroll int
|
||||
entries []ListEntry
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
|
||||
onScrollBoundsChange func ()
|
||||
onNoEntrySelected func ()
|
||||
}
|
||||
|
||||
// NewList creates a new list element with the specified entries.
|
||||
func NewList (entries ...ListEntry) (element *List) {
|
||||
element = &List { selectedEntry: -1 }
|
||||
element.theme.Case = theme.C("basic", "list")
|
||||
element.Core, element.core = core.NewCore(element.handleResize)
|
||||
element.FocusableCore,
|
||||
element.focusableControl = core.NewFocusableCore (func () {
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
})
|
||||
|
||||
element.entries = make([]ListEntry, len(entries))
|
||||
for index, entry := range entries {
|
||||
element.entries[index] = entry
|
||||
}
|
||||
|
||||
element.updateMinimumSize()
|
||||
return
|
||||
}
|
||||
|
||||
func (element *List) handleResize () {
|
||||
for index, entry := range element.entries {
|
||||
element.entries[index] = element.resizeEntryToFit(entry)
|
||||
}
|
||||
|
||||
if element.scroll > element.maxScrollHeight() {
|
||||
element.scroll = element.maxScrollHeight()
|
||||
}
|
||||
element.draw()
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *List) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
for index, entry := range element.entries {
|
||||
entry.SetTheme(element.theme.Theme)
|
||||
element.entries[index] = entry
|
||||
}
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *List) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
for index, entry := range element.entries {
|
||||
entry.SetConfig(element.config)
|
||||
element.entries[index] = entry
|
||||
}
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *List) redo () {
|
||||
for index, entry := range element.entries {
|
||||
element.entries[index] = element.resizeEntryToFit(entry)
|
||||
}
|
||||
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
// Collapse forces a minimum width and height upon the list. If a zero value is
|
||||
// given for a dimension, its minimum will be determined by the list's content.
|
||||
// If the list's height goes beyond the forced size, it will need to be accessed
|
||||
// via scrolling. If an entry's width goes beyond the forced size, its text will
|
||||
// be truncated so that it fits.
|
||||
func (element *List) Collapse (width, height int) {
|
||||
if
|
||||
element.forcedMinimumWidth == width &&
|
||||
element.forcedMinimumHeight == height {
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
element.forcedMinimumWidth = width
|
||||
element.forcedMinimumHeight = height
|
||||
element.updateMinimumSize()
|
||||
|
||||
for index, entry := range element.entries {
|
||||
element.entries[index] = element.resizeEntryToFit(entry)
|
||||
}
|
||||
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *List) HandleMouseDown (x, y int, button input.Button) {
|
||||
if !element.Enabled() { return }
|
||||
if !element.Focused() { element.Focus() }
|
||||
if button != input.ButtonLeft { return }
|
||||
element.pressed = true
|
||||
if element.selectUnderMouse(x, y) && element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *List) HandleMouseUp (x, y int, button input.Button) {
|
||||
if button != input.ButtonLeft { return }
|
||||
element.pressed = false
|
||||
}
|
||||
|
||||
func (element *List) HandleMouseMove (x, y int) {
|
||||
if element.pressed {
|
||||
if element.selectUnderMouse(x, y) && element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *List) HandleMouseScroll (x, y int, deltaX, deltaY float64) { }
|
||||
|
||||
func (element *List) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if !element.Enabled() { return }
|
||||
|
||||
altered := false
|
||||
switch key {
|
||||
case input.KeyLeft, input.KeyUp:
|
||||
altered = element.changeSelectionBy(-1)
|
||||
|
||||
case input.KeyRight, input.KeyDown:
|
||||
altered = element.changeSelectionBy(1)
|
||||
|
||||
case input.KeyEscape:
|
||||
altered = element.selectEntry(-1)
|
||||
}
|
||||
|
||||
if altered && element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *List) HandleKeyUp(key input.Key, modifiers input.Modifiers) { }
|
||||
|
||||
// ScrollContentBounds returns the full content size of the element.
|
||||
func (element *List) ScrollContentBounds () (bounds image.Rectangle) {
|
||||
return image.Rect (
|
||||
0, 0,
|
||||
1, element.contentHeight)
|
||||
}
|
||||
|
||||
// ScrollViewportBounds returns the size and position of the element's viewport
|
||||
// relative to ScrollBounds.
|
||||
func (element *List) ScrollViewportBounds () (bounds image.Rectangle) {
|
||||
return image.Rect (
|
||||
0, element.scroll,
|
||||
0, element.scroll + element.scrollViewportHeight())
|
||||
}
|
||||
|
||||
// ScrollTo scrolls the viewport to the specified point relative to
|
||||
// ScrollBounds.
|
||||
func (element *List) ScrollTo (position image.Point) {
|
||||
element.scroll = position.Y
|
||||
if element.scroll < 0 {
|
||||
element.scroll = 0
|
||||
} else if element.scroll > element.maxScrollHeight() {
|
||||
element.scroll = element.maxScrollHeight()
|
||||
}
|
||||
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
// ScrollAxes returns the supported axes for scrolling.
|
||||
func (element *List) ScrollAxes () (horizontal, vertical bool) {
|
||||
return false, true
|
||||
}
|
||||
|
||||
func (element *List) scrollViewportHeight () (height int) {
|
||||
padding := element.theme.Padding(theme.PatternSunken)
|
||||
return element.Bounds().Dy() - padding[0] - padding[2]
|
||||
}
|
||||
|
||||
func (element *List) maxScrollHeight () (height int) {
|
||||
height =
|
||||
element.contentHeight -
|
||||
element.scrollViewportHeight()
|
||||
if height < 0 { height = 0 }
|
||||
return
|
||||
}
|
||||
|
||||
func (element *List) OnScrollBoundsChange (callback func ()) {
|
||||
element.onScrollBoundsChange = callback
|
||||
}
|
||||
|
||||
// OnNoEntrySelected sets a function to be called when the user chooses to
|
||||
// deselect the current selected entry by clicking on empty space within the
|
||||
// list or by pressing the escape key.
|
||||
func (element *List) OnNoEntrySelected (callback func ()) {
|
||||
element.onNoEntrySelected = callback
|
||||
}
|
||||
|
||||
// CountEntries returns the amount of entries in the list.
|
||||
func (element *List) CountEntries () (count int) {
|
||||
return len(element.entries)
|
||||
}
|
||||
|
||||
// Append adds an entry to the end of the list.
|
||||
func (element *List) Append (entry ListEntry) {
|
||||
// append
|
||||
entry = element.resizeEntryToFit(entry)
|
||||
entry.SetTheme(element.theme.Theme)
|
||||
entry.SetConfig(element.config)
|
||||
element.entries = append(element.entries, entry)
|
||||
|
||||
// recalculate, redraw, notify
|
||||
element.updateMinimumSize()
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
// EntryAt returns the entry at the specified index. If the index is out of
|
||||
// bounds, it panics.
|
||||
func (element *List) EntryAt (index int) (entry ListEntry) {
|
||||
if index < 0 || index >= len(element.entries) {
|
||||
panic(fmt.Sprint("basic.List.EntryAt index out of range: ", index))
|
||||
}
|
||||
return element.entries[index]
|
||||
}
|
||||
|
||||
// Insert inserts an entry into the list at the speified index. If the index is
|
||||
// out of bounds, it is constrained either to zero or len(entries).
|
||||
func (element *List) Insert (index int, entry ListEntry) {
|
||||
if index < 0 { index = 0 }
|
||||
if index > len(element.entries) { index = len(element.entries) }
|
||||
|
||||
// insert
|
||||
element.entries = append (
|
||||
element.entries[:index + 1],
|
||||
element.entries[index:]...)
|
||||
entry = element.resizeEntryToFit(entry)
|
||||
element.entries[index] = entry
|
||||
|
||||
// recalculate, redraw, notify
|
||||
element.updateMinimumSize()
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
// Remove removes the entry at the specified index. If the index is out of
|
||||
// bounds, it panics.
|
||||
func (element *List) Remove (index int) {
|
||||
if index < 0 || index >= len(element.entries) {
|
||||
panic(fmt.Sprint("basic.List.Remove index out of range: ", index))
|
||||
}
|
||||
|
||||
// delete
|
||||
element.entries = append (
|
||||
element.entries[:index],
|
||||
element.entries[index + 1:]...)
|
||||
|
||||
// recalculate, redraw, notify
|
||||
element.updateMinimumSize()
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
// Replace replaces the entry at the specified index with another. If the index
|
||||
// is out of bounds, it panics.
|
||||
func (element *List) Replace (index int, entry ListEntry) {
|
||||
if index < 0 || index >= len(element.entries) {
|
||||
panic(fmt.Sprint("basic.List.Replace index out of range: ", index))
|
||||
}
|
||||
|
||||
// replace
|
||||
entry = element.resizeEntryToFit(entry)
|
||||
element.entries[index] = entry
|
||||
|
||||
// redraw
|
||||
element.updateMinimumSize()
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
// Select selects a specific item in the list. If the index is out of bounds,
|
||||
// no items will be selecected.
|
||||
func (element *List) Select (index int) {
|
||||
if element.selectEntry(index) {
|
||||
element.redo()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *List) selectUnderMouse (x, y int) (updated bool) {
|
||||
padding := element.theme.Padding(theme.PatternSunken)
|
||||
bounds := padding.Apply(element.Bounds())
|
||||
mousePoint := image.Pt(x, y)
|
||||
dot := image.Pt (
|
||||
bounds.Min.X,
|
||||
bounds.Min.Y - element.scroll)
|
||||
|
||||
newlySelectedEntryIndex := -1
|
||||
for index, entry := range element.entries {
|
||||
entryPosition := dot
|
||||
dot.Y += entry.Bounds().Dy()
|
||||
if entryPosition.Y > bounds.Max.Y { break }
|
||||
if mousePoint.In(entry.Bounds().Add(entryPosition)) {
|
||||
newlySelectedEntryIndex = index
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return element.selectEntry(newlySelectedEntryIndex)
|
||||
}
|
||||
|
||||
func (element *List) selectEntry (index int) (updated bool) {
|
||||
if element.selectedEntry == index { return false }
|
||||
element.selectedEntry = index
|
||||
if element.selectedEntry < 0 {
|
||||
if element.onNoEntrySelected != nil {
|
||||
element.onNoEntrySelected()
|
||||
}
|
||||
} else {
|
||||
element.entries[element.selectedEntry].RunSelect()
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (element *List) changeSelectionBy (delta int) (updated bool) {
|
||||
newIndex := element.selectedEntry + delta
|
||||
if newIndex < 0 { newIndex = len(element.entries) - 1 }
|
||||
if newIndex >= len(element.entries) { newIndex = 0 }
|
||||
return element.selectEntry(newIndex)
|
||||
}
|
||||
|
||||
func (element *List) resizeEntryToFit (entry ListEntry) (resized ListEntry) {
|
||||
bounds := element.Bounds()
|
||||
padding := element.theme.Padding(theme.PatternSunken)
|
||||
entry.Resize(padding.Apply(bounds).Dx())
|
||||
return entry
|
||||
}
|
||||
|
||||
func (element *List) updateMinimumSize () {
|
||||
element.contentHeight = 0
|
||||
for _, entry := range element.entries {
|
||||
element.contentHeight += entry.Bounds().Dy()
|
||||
}
|
||||
|
||||
minimumWidth := element.forcedMinimumWidth
|
||||
minimumHeight := element.forcedMinimumHeight
|
||||
|
||||
if minimumWidth == 0 {
|
||||
for _, entry := range element.entries {
|
||||
entryWidth := entry.MinimumWidth()
|
||||
if entryWidth > minimumWidth {
|
||||
minimumWidth = entryWidth
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if minimumHeight == 0 {
|
||||
minimumHeight = element.contentHeight
|
||||
}
|
||||
|
||||
padding := element.theme.Padding(theme.PatternSunken)
|
||||
minimumHeight += padding[0] + padding[2]
|
||||
|
||||
element.core.SetMinimumSize(minimumWidth, minimumHeight)
|
||||
}
|
||||
|
||||
func (element *List) draw () {
|
||||
bounds := element.Bounds()
|
||||
padding := element.theme.Padding(theme.PatternSunken)
|
||||
innerBounds := padding.Apply(bounds)
|
||||
state := theme.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.Focused(),
|
||||
}
|
||||
|
||||
dot := image.Point {
|
||||
innerBounds.Min.X,
|
||||
innerBounds.Min.Y - element.scroll,
|
||||
}
|
||||
innerCanvas := canvas.Cut(element.core, innerBounds)
|
||||
for index, entry := range element.entries {
|
||||
entryPosition := dot
|
||||
dot.Y += entry.Bounds().Dy()
|
||||
if dot.Y < innerBounds.Min.Y { continue }
|
||||
if entryPosition.Y > innerBounds.Max.Y { break }
|
||||
entry.Draw (
|
||||
innerCanvas, entryPosition,
|
||||
element.Focused(), element.selectedEntry == index)
|
||||
}
|
||||
|
||||
covered := image.Rect (
|
||||
0, 0,
|
||||
innerBounds.Dx(), element.contentHeight,
|
||||
).Add(innerBounds.Min).Intersect(innerBounds)
|
||||
pattern := element.theme.Pattern(theme.PatternSunken, state)
|
||||
artist.DrawShatter (
|
||||
element.core, pattern, covered)
|
||||
}
|
|
@ -0,0 +1,100 @@
|
|||
package basicElements
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/textdraw"
|
||||
|
||||
// ListEntry is an item that can be added to a list.
|
||||
type ListEntry struct {
|
||||
drawer textdraw.Drawer
|
||||
bounds image.Rectangle
|
||||
text string
|
||||
width int
|
||||
minimumWidth int
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
|
||||
onSelect func ()
|
||||
}
|
||||
|
||||
func NewListEntry (text string, onSelect func ()) (entry ListEntry) {
|
||||
entry = ListEntry {
|
||||
text: text,
|
||||
onSelect: onSelect,
|
||||
}
|
||||
entry.theme.Case = theme.C("basic", "listEntry")
|
||||
entry.drawer.SetText([]rune(text))
|
||||
entry.updateBounds()
|
||||
return
|
||||
}
|
||||
|
||||
func (entry *ListEntry) SetTheme (new theme.Theme) {
|
||||
if new == entry.theme.Theme { return }
|
||||
entry.theme.Theme = new
|
||||
entry.drawer.SetFace (entry.theme.FontFace (
|
||||
theme.FontStyleRegular,
|
||||
theme.FontSizeNormal))
|
||||
entry.updateBounds()
|
||||
}
|
||||
|
||||
func (entry *ListEntry) SetConfig (new config.Config) {
|
||||
if new == entry.config.Config { return }
|
||||
entry.config.Config = new
|
||||
}
|
||||
|
||||
func (entry *ListEntry) updateBounds () {
|
||||
padding := entry.theme.Padding(theme.PatternRaised)
|
||||
entry.bounds = padding.Inverse().Apply(entry.drawer.LayoutBounds())
|
||||
entry.bounds = entry.bounds.Sub(entry.bounds.Min)
|
||||
entry.minimumWidth = entry.bounds.Dx()
|
||||
entry.bounds.Max.X = entry.width
|
||||
}
|
||||
|
||||
func (entry *ListEntry) Draw (
|
||||
destination canvas.Canvas,
|
||||
offset image.Point,
|
||||
focused bool,
|
||||
on bool,
|
||||
) (
|
||||
updatedRegion image.Rectangle,
|
||||
) {
|
||||
state := theme.State {
|
||||
Focused: focused,
|
||||
On: on,
|
||||
}
|
||||
|
||||
pattern := entry.theme.Pattern(theme.PatternRaised, state)
|
||||
padding := entry.theme.Padding(theme.PatternRaised)
|
||||
bounds := entry.Bounds().Add(offset)
|
||||
artist.DrawBounds(destination, pattern, bounds)
|
||||
|
||||
foreground := entry.theme.Color (theme.ColorForeground, state)
|
||||
return entry.drawer.Draw (
|
||||
destination,
|
||||
foreground,
|
||||
offset.Add(image.Pt(padding[artist.SideLeft], padding[artist.SideTop])).
|
||||
Sub(entry.drawer.LayoutBounds().Min))
|
||||
}
|
||||
|
||||
func (entry *ListEntry) RunSelect () {
|
||||
if entry.onSelect != nil {
|
||||
entry.onSelect()
|
||||
}
|
||||
}
|
||||
|
||||
func (entry *ListEntry) Bounds () (bounds image.Rectangle) {
|
||||
return entry.bounds
|
||||
}
|
||||
|
||||
func (entry *ListEntry) Resize (width int) {
|
||||
entry.width = width
|
||||
entry.updateBounds()
|
||||
}
|
||||
|
||||
func (entry *ListEntry) MinimumWidth () (width int) {
|
||||
return entry.minimumWidth
|
||||
}
|
|
@ -0,0 +1,82 @@
|
|||
package basicElements
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// ProgressBar displays a visual indication of how far along a task is.
|
||||
type ProgressBar struct {
|
||||
*core.Core
|
||||
core core.CoreControl
|
||||
progress float64
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
}
|
||||
|
||||
// NewProgressBar creates a new progress bar displaying the given progress
|
||||
// level.
|
||||
func NewProgressBar (progress float64) (element *ProgressBar) {
|
||||
element = &ProgressBar { progress: progress }
|
||||
element.theme.Case = theme.C("basic", "progressBar")
|
||||
element.Core, element.core = core.NewCore(element.draw)
|
||||
return
|
||||
}
|
||||
|
||||
// SetProgress sets the progress level of the bar.
|
||||
func (element *ProgressBar) SetProgress (progress float64) {
|
||||
if progress == element.progress { return }
|
||||
element.progress = progress
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *ProgressBar) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *ProgressBar) SetConfig (new config.Config) {
|
||||
if new == nil || new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element (ProgressBar)) updateMinimumSize() {
|
||||
padding := element.theme.Padding(theme.PatternSunken)
|
||||
innerPadding := element.theme.Padding(theme.PatternMercury)
|
||||
element.core.SetMinimumSize (
|
||||
padding.Horizontal() + innerPadding.Horizontal(),
|
||||
padding.Vertical() + innerPadding.Vertical())
|
||||
}
|
||||
|
||||
func (element *ProgressBar) redo () {
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ProgressBar) draw () {
|
||||
bounds := element.Bounds()
|
||||
|
||||
pattern := element.theme.Pattern(theme.PatternSunken, theme.State { })
|
||||
padding := element.theme.Padding(theme.PatternSunken)
|
||||
pattern.Draw(element.core, bounds)
|
||||
bounds = padding.Apply(bounds)
|
||||
meterBounds := image.Rect (
|
||||
bounds.Min.X, bounds.Min.Y,
|
||||
bounds.Min.X + int(float64(bounds.Dx()) * element.progress),
|
||||
bounds.Max.Y)
|
||||
mercury := element.theme.Pattern(theme.PatternMercury, theme.State { })
|
||||
artist.DrawBounds(element.core, mercury, meterBounds)
|
||||
}
|
|
@ -0,0 +1,528 @@
|
|||
package basicElements
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// ScrollContainer is a container that is capable of holding a scrollable
|
||||
// element.
|
||||
type ScrollContainer struct {
|
||||
*core.Core
|
||||
core core.CoreControl
|
||||
focused bool
|
||||
|
||||
child elements.Scrollable
|
||||
childWidth, childHeight int
|
||||
|
||||
horizontal struct {
|
||||
theme theme.Wrapped
|
||||
exists bool
|
||||
enabled bool
|
||||
dragging bool
|
||||
dragOffset int
|
||||
gutter image.Rectangle
|
||||
track image.Rectangle
|
||||
bar image.Rectangle
|
||||
}
|
||||
|
||||
vertical struct {
|
||||
theme theme.Wrapped
|
||||
exists bool
|
||||
enabled bool
|
||||
dragging bool
|
||||
dragOffset int
|
||||
gutter image.Rectangle
|
||||
track image.Rectangle
|
||||
bar image.Rectangle
|
||||
}
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
|
||||
onFocusRequest func () (granted bool)
|
||||
onFocusMotionRequest func (input.KeynavDirection) (granted bool)
|
||||
}
|
||||
|
||||
// NewScrollContainer creates a new scroll container with the specified scroll
|
||||
// bars.
|
||||
func NewScrollContainer (horizontal, vertical bool) (element *ScrollContainer) {
|
||||
element = &ScrollContainer { }
|
||||
element.theme.Case = theme.C("basic", "scrollContainer")
|
||||
element.horizontal.theme.Case = theme.C("basic", "scrollBarHorizontal")
|
||||
element.vertical.theme.Case = theme.C("basic", "scrollBarVertical")
|
||||
|
||||
element.Core, element.core = core.NewCore(element.handleResize)
|
||||
element.horizontal.exists = horizontal
|
||||
element.vertical.exists = vertical
|
||||
return
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) handleResize () {
|
||||
element.recalculate()
|
||||
element.resizeChildToFit()
|
||||
element.draw()
|
||||
}
|
||||
|
||||
// Adopt adds a scrollable element to the scroll container. The container can
|
||||
// only contain one scrollable element at a time, and when a new one is adopted
|
||||
// it replaces the last one.
|
||||
func (element *ScrollContainer) Adopt (child elements.Scrollable) {
|
||||
// disown previous child if it exists
|
||||
if element.child != nil {
|
||||
element.clearChildEventHandlers(child)
|
||||
}
|
||||
|
||||
// adopt new child
|
||||
element.child = child
|
||||
if child != nil {
|
||||
if child0, ok := child.(elements.Themeable); ok {
|
||||
child0.SetTheme(element.theme.Theme)
|
||||
}
|
||||
if child0, ok := child.(elements.Configurable); ok {
|
||||
child0.SetConfig(element.config.Config)
|
||||
}
|
||||
child.OnDamage(element.childDamageCallback)
|
||||
child.OnMinimumSizeChange(element.updateMinimumSize)
|
||||
child.OnScrollBoundsChange(element.childScrollBoundsChangeCallback)
|
||||
if newChild, ok := child.(elements.Focusable); ok {
|
||||
newChild.OnFocusRequest (
|
||||
element.childFocusRequestCallback)
|
||||
newChild.OnFocusMotionRequest (
|
||||
element.childFocusMotionRequestCallback)
|
||||
}
|
||||
|
||||
element.updateMinimumSize()
|
||||
|
||||
element.horizontal.enabled,
|
||||
element.vertical.enabled = element.child.ScrollAxes()
|
||||
|
||||
if element.core.HasImage() {
|
||||
element.resizeChildToFit()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *ScrollContainer) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
if child, ok := element.child.(elements.Themeable); ok {
|
||||
child.SetTheme(element.theme.Theme)
|
||||
}
|
||||
if element.core.HasImage() {
|
||||
element.recalculate()
|
||||
element.resizeChildToFit()
|
||||
element.draw()
|
||||
}
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *ScrollContainer) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
if child, ok := element.child.(elements.Configurable); ok {
|
||||
child.SetConfig(element.config.Config)
|
||||
}
|
||||
if element.core.HasImage() {
|
||||
element.recalculate()
|
||||
element.resizeChildToFit()
|
||||
element.draw()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if child, ok := element.child.(elements.KeyboardTarget); ok {
|
||||
child.HandleKeyDown(key, modifiers)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) HandleKeyUp (key input.Key, modifiers input.Modifiers) {
|
||||
if child, ok := element.child.(elements.KeyboardTarget); ok {
|
||||
child.HandleKeyUp(key, modifiers)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) HandleMouseDown (x, y int, button input.Button) {
|
||||
velocity := element.config.ScrollVelocity()
|
||||
point := image.Pt(x, y)
|
||||
if point.In(element.horizontal.bar) {
|
||||
element.horizontal.dragging = true
|
||||
element.horizontal.dragOffset =
|
||||
x - element.horizontal.bar.Min.X +
|
||||
element.Bounds().Min.X
|
||||
element.dragHorizontalBar(point)
|
||||
|
||||
} else if point.In(element.horizontal.gutter) {
|
||||
switch button {
|
||||
case input.ButtonLeft:
|
||||
element.horizontal.dragging = true
|
||||
element.horizontal.dragOffset =
|
||||
element.horizontal.bar.Dx() / 2 +
|
||||
element.Bounds().Min.X
|
||||
element.dragHorizontalBar(point)
|
||||
case input.ButtonMiddle:
|
||||
viewport := element.child.ScrollViewportBounds().Dx()
|
||||
if x > element.horizontal.bar.Min.X {
|
||||
element.scrollChildBy(viewport, 0)
|
||||
} else {
|
||||
element.scrollChildBy(-viewport, 0)
|
||||
}
|
||||
case input.ButtonRight:
|
||||
if x > element.horizontal.bar.Min.X {
|
||||
element.scrollChildBy(velocity, 0)
|
||||
} else {
|
||||
element.scrollChildBy(-velocity, 0)
|
||||
}
|
||||
}
|
||||
|
||||
} else if point.In(element.vertical.bar) {
|
||||
element.vertical.dragging = true
|
||||
element.vertical.dragOffset =
|
||||
y - element.vertical.bar.Min.Y +
|
||||
element.Bounds().Min.Y
|
||||
element.dragVerticalBar(point)
|
||||
|
||||
} else if point.In(element.vertical.gutter) {
|
||||
switch button {
|
||||
case input.ButtonLeft:
|
||||
element.vertical.dragging = true
|
||||
element.vertical.dragOffset =
|
||||
element.vertical.bar.Dy() / 2 +
|
||||
element.Bounds().Min.Y
|
||||
element.dragVerticalBar(point)
|
||||
case input.ButtonMiddle:
|
||||
viewport := element.child.ScrollViewportBounds().Dy()
|
||||
if y > element.vertical.bar.Min.Y {
|
||||
element.scrollChildBy(0, viewport)
|
||||
} else {
|
||||
element.scrollChildBy(0, -viewport)
|
||||
}
|
||||
case input.ButtonRight:
|
||||
if y > element.vertical.bar.Min.Y {
|
||||
element.scrollChildBy(0, velocity)
|
||||
} else {
|
||||
element.scrollChildBy(0, -velocity)
|
||||
}
|
||||
}
|
||||
|
||||
} else if child, ok := element.child.(elements.MouseTarget); ok {
|
||||
child.HandleMouseDown(x, y, button)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) HandleMouseUp (x, y int, button input.Button) {
|
||||
if element.horizontal.dragging {
|
||||
element.horizontal.dragging = false
|
||||
element.drawHorizontalBar()
|
||||
element.core.DamageRegion(element.horizontal.bar)
|
||||
|
||||
} else if element.vertical.dragging {
|
||||
element.vertical.dragging = false
|
||||
element.drawVerticalBar()
|
||||
element.core.DamageRegion(element.vertical.bar)
|
||||
|
||||
} else if child, ok := element.child.(elements.MouseTarget); ok {
|
||||
child.HandleMouseUp(x, y, button)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) HandleMouseMove (x, y int) {
|
||||
if element.horizontal.dragging {
|
||||
element.dragHorizontalBar(image.Pt(x, y))
|
||||
|
||||
} else if element.vertical.dragging {
|
||||
element.dragVerticalBar(image.Pt(x, y))
|
||||
|
||||
} else if child, ok := element.child.(elements.MouseTarget); ok {
|
||||
child.HandleMouseMove(x, y)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) HandleMouseScroll (
|
||||
x, y int,
|
||||
deltaX, deltaY float64,
|
||||
) {
|
||||
element.scrollChildBy(int(deltaX), int(deltaY))
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) scrollChildBy (x, y int) {
|
||||
if element.child == nil { return }
|
||||
scrollPoint :=
|
||||
element.child.ScrollViewportBounds().Min.
|
||||
Add(image.Pt(x, y))
|
||||
element.child.ScrollTo(scrollPoint)
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) Focused () (focused bool) {
|
||||
return element.focused
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) Focus () {
|
||||
if element.onFocusRequest != nil {
|
||||
if element.onFocusRequest() {
|
||||
element.focused = true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) HandleFocus (
|
||||
direction input.KeynavDirection,
|
||||
) (
|
||||
accepted bool,
|
||||
) {
|
||||
if child, ok := element.child.(elements.Focusable); ok {
|
||||
element.focused = child.HandleFocus(direction)
|
||||
return element.focused
|
||||
} else {
|
||||
element.focused = false
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) HandleUnfocus () {
|
||||
if child, ok := element.child.(elements.Focusable); ok {
|
||||
child.HandleUnfocus()
|
||||
}
|
||||
element.focused = false
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) OnFocusRequest (callback func () (granted bool)) {
|
||||
element.onFocusRequest = callback
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) OnFocusMotionRequest (
|
||||
callback func (direction input.KeynavDirection) (granted bool),
|
||||
) {
|
||||
element.onFocusMotionRequest = callback
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) childDamageCallback (region canvas.Canvas) {
|
||||
element.core.DamageRegion(region.Bounds())
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) childFocusRequestCallback () (granted bool) {
|
||||
if element.onFocusRequest != nil {
|
||||
element.focused = element.onFocusRequest()
|
||||
return element.focused
|
||||
} else {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) childFocusMotionRequestCallback (
|
||||
direction input.KeynavDirection,
|
||||
) (
|
||||
granted bool,
|
||||
) {
|
||||
if element.onFocusMotionRequest == nil { return }
|
||||
return element.onFocusMotionRequest(direction)
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) clearChildEventHandlers (child elements.Scrollable) {
|
||||
child.DrawTo(nil)
|
||||
child.OnDamage(nil)
|
||||
child.OnMinimumSizeChange(nil)
|
||||
child.OnScrollBoundsChange(nil)
|
||||
if child0, ok := child.(elements.Focusable); ok {
|
||||
child0.OnFocusRequest(nil)
|
||||
child0.OnFocusMotionRequest(nil)
|
||||
if child0.Focused() {
|
||||
child0.HandleUnfocus()
|
||||
}
|
||||
}
|
||||
if child0, ok := child.(elements.Flexible); ok {
|
||||
child0.OnFlexibleHeightChange(nil)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) resizeChildToFit () {
|
||||
childBounds := image.Rect (
|
||||
0, 0,
|
||||
element.childWidth,
|
||||
element.childHeight).Add(element.Bounds().Min)
|
||||
element.child.DrawTo(canvas.Cut(element.core, childBounds))
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) recalculate () {
|
||||
horizontal := &element.horizontal
|
||||
vertical := &element.vertical
|
||||
|
||||
gutterInsetHorizontal := horizontal.theme.Padding(theme.PatternGutter)
|
||||
gutterInsetVertical := vertical.theme.Padding(theme.PatternGutter)
|
||||
|
||||
bounds := element.Bounds()
|
||||
thicknessHorizontal :=
|
||||
element.config.HandleWidth() +
|
||||
gutterInsetHorizontal[3] +
|
||||
gutterInsetHorizontal[1]
|
||||
thicknessVertical :=
|
||||
element.config.HandleWidth() +
|
||||
gutterInsetVertical[3] +
|
||||
gutterInsetVertical[1]
|
||||
|
||||
// calculate child size
|
||||
element.childWidth = bounds.Dx()
|
||||
element.childHeight = bounds.Dy()
|
||||
|
||||
// reset bounds
|
||||
horizontal.gutter = image.Rectangle { }
|
||||
vertical.gutter = image.Rectangle { }
|
||||
horizontal.bar = image.Rectangle { }
|
||||
vertical.bar = image.Rectangle { }
|
||||
|
||||
// if enabled, give substance to the gutters
|
||||
if horizontal.exists {
|
||||
horizontal.gutter.Min.X = bounds.Min.X
|
||||
horizontal.gutter.Min.Y = bounds.Max.Y - thicknessHorizontal
|
||||
horizontal.gutter.Max.X = bounds.Max.X
|
||||
horizontal.gutter.Max.Y = bounds.Max.Y
|
||||
if vertical.exists {
|
||||
horizontal.gutter.Max.X -= thicknessVertical
|
||||
}
|
||||
element.childHeight -= thicknessHorizontal
|
||||
horizontal.track = gutterInsetHorizontal.Apply(horizontal.gutter)
|
||||
}
|
||||
if vertical.exists {
|
||||
vertical.gutter.Min.X = bounds.Max.X - thicknessVertical
|
||||
vertical.gutter.Max.X = bounds.Max.X
|
||||
vertical.gutter.Min.Y = bounds.Min.Y
|
||||
vertical.gutter.Max.Y = bounds.Max.Y
|
||||
if horizontal.exists {
|
||||
vertical.gutter.Max.Y -= thicknessHorizontal
|
||||
}
|
||||
element.childWidth -= thicknessVertical
|
||||
vertical.track = gutterInsetVertical.Apply(vertical.gutter)
|
||||
}
|
||||
|
||||
// if enabled, calculate the positions of the bars
|
||||
contentBounds := element.child.ScrollContentBounds()
|
||||
viewportBounds := element.child.ScrollViewportBounds()
|
||||
if horizontal.exists && horizontal.enabled {
|
||||
horizontal.bar.Min.Y = horizontal.track.Min.Y
|
||||
horizontal.bar.Max.Y = horizontal.track.Max.Y
|
||||
|
||||
scale := float64(horizontal.track.Dx()) /
|
||||
float64(contentBounds.Dx())
|
||||
horizontal.bar.Min.X = int(float64(viewportBounds.Min.X) * scale)
|
||||
horizontal.bar.Max.X = int(float64(viewportBounds.Max.X) * scale)
|
||||
|
||||
horizontal.bar.Min.X += horizontal.track.Min.X
|
||||
horizontal.bar.Max.X += horizontal.track.Min.X
|
||||
}
|
||||
if vertical.exists && vertical.enabled {
|
||||
vertical.bar.Min.X = vertical.track.Min.X
|
||||
vertical.bar.Max.X = vertical.track.Max.X
|
||||
|
||||
scale := float64(vertical.track.Dy()) /
|
||||
float64(contentBounds.Dy())
|
||||
vertical.bar.Min.Y = int(float64(viewportBounds.Min.Y) * scale)
|
||||
vertical.bar.Max.Y = int(float64(viewportBounds.Max.Y) * scale)
|
||||
|
||||
vertical.bar.Min.Y += vertical.track.Min.Y
|
||||
vertical.bar.Max.Y += vertical.track.Min.Y
|
||||
}
|
||||
|
||||
// if the scroll bars are out of bounds, don't display them.
|
||||
if horizontal.bar.Dx() >= horizontal.track.Dx() {
|
||||
horizontal.bar = image.Rectangle { }
|
||||
}
|
||||
if vertical.bar.Dy() >= vertical.track.Dy() {
|
||||
vertical.bar = image.Rectangle { }
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) draw () {
|
||||
deadPattern := element.theme.Pattern (
|
||||
theme.PatternDead, theme.State { })
|
||||
artist.DrawBounds (
|
||||
element.core, deadPattern,
|
||||
image.Rect (
|
||||
element.vertical.gutter.Min.X,
|
||||
element.horizontal.gutter.Min.Y,
|
||||
element.vertical.gutter.Max.X,
|
||||
element.horizontal.gutter.Max.Y))
|
||||
element.drawHorizontalBar()
|
||||
element.drawVerticalBar()
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) drawHorizontalBar () {
|
||||
state := theme.State {
|
||||
Disabled: !element.horizontal.enabled,
|
||||
Pressed: element.horizontal.dragging,
|
||||
}
|
||||
gutterPattern := element.horizontal.theme.Pattern(theme.PatternGutter, state)
|
||||
artist.DrawBounds(element.core, gutterPattern, element.horizontal.gutter)
|
||||
|
||||
handlePattern := element.horizontal.theme.Pattern(theme.PatternHandle, state)
|
||||
artist.DrawBounds(element.core, handlePattern, element.horizontal.bar)
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) drawVerticalBar () {
|
||||
state := theme.State {
|
||||
Disabled: !element.vertical.enabled,
|
||||
Pressed: element.vertical.dragging,
|
||||
}
|
||||
gutterPattern := element.vertical.theme.Pattern(theme.PatternGutter, state)
|
||||
artist.DrawBounds(element.core, gutterPattern, element.vertical.gutter)
|
||||
|
||||
handlePattern := element.vertical.theme.Pattern(theme.PatternHandle, state)
|
||||
artist.DrawBounds(element.core, handlePattern, element.vertical.bar)
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) dragHorizontalBar (mousePosition image.Point) {
|
||||
scrollX :=
|
||||
float64(element.child.ScrollContentBounds().Dx()) /
|
||||
float64(element.horizontal.track.Dx()) *
|
||||
float64(mousePosition.X - element.horizontal.dragOffset)
|
||||
scrollY := element.child.ScrollViewportBounds().Min.Y
|
||||
element.child.ScrollTo(image.Pt(int(scrollX), scrollY))
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) dragVerticalBar (mousePosition image.Point) {
|
||||
scrollY :=
|
||||
float64(element.child.ScrollContentBounds().Dy()) /
|
||||
float64(element.vertical.track.Dy()) *
|
||||
float64(mousePosition.Y - element.vertical.dragOffset)
|
||||
scrollX := element.child.ScrollViewportBounds().Min.X
|
||||
element.child.ScrollTo(image.Pt(scrollX, int(scrollY)))
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) updateMinimumSize () {
|
||||
gutterInsetHorizontal := element.horizontal.theme.Padding(theme.PatternGutter)
|
||||
gutterInsetVertical := element.vertical.theme.Padding(theme.PatternGutter)
|
||||
|
||||
thicknessHorizontal :=
|
||||
element.config.HandleWidth() +
|
||||
gutterInsetHorizontal[3] +
|
||||
gutterInsetHorizontal[1]
|
||||
thicknessVertical :=
|
||||
element.config.HandleWidth() +
|
||||
gutterInsetVertical[3] +
|
||||
gutterInsetVertical[1]
|
||||
|
||||
width := thicknessHorizontal
|
||||
height := thicknessVertical
|
||||
if element.child != nil {
|
||||
childWidth, childHeight := element.child.MinimumSize()
|
||||
width += childWidth
|
||||
height += childHeight
|
||||
}
|
||||
element.core.SetMinimumSize(width, height)
|
||||
}
|
||||
|
||||
func (element *ScrollContainer) childScrollBoundsChangeCallback () {
|
||||
element.horizontal.enabled,
|
||||
element.vertical.enabled = element.child.ScrollAxes()
|
||||
if element.core.HasImage() {
|
||||
element.recalculate()
|
||||
element.drawHorizontalBar()
|
||||
element.drawVerticalBar()
|
||||
element.core.DamageRegion(element.horizontal.gutter)
|
||||
element.core.DamageRegion(element.vertical.gutter)
|
||||
}
|
||||
}
|
|
@ -0,0 +1,206 @@
|
|||
package basicElements
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// Slider is a slider control with a floating point value between zero and one.
|
||||
type Slider struct {
|
||||
*core.Core
|
||||
*core.FocusableCore
|
||||
core core.CoreControl
|
||||
focusableControl core.FocusableCoreControl
|
||||
|
||||
value float64
|
||||
vertical bool
|
||||
dragging bool
|
||||
dragOffset int
|
||||
track image.Rectangle
|
||||
bar image.Rectangle
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
|
||||
onSlide func ()
|
||||
onRelease func ()
|
||||
}
|
||||
|
||||
// NewSlider creates a new slider with the specified value. If vertical is set
|
||||
// to true,
|
||||
func NewSlider (value float64, vertical bool) (element *Slider) {
|
||||
element = &Slider {
|
||||
value: value,
|
||||
vertical: vertical,
|
||||
}
|
||||
if vertical {
|
||||
element.theme.Case = theme.C("basic", "sliderVertical")
|
||||
} else {
|
||||
element.theme.Case = theme.C("basic", "sliderHorizontal")
|
||||
}
|
||||
element.Core, element.core = core.NewCore(element.draw)
|
||||
element.FocusableCore,
|
||||
element.focusableControl = core.NewFocusableCore(element.redo)
|
||||
element.updateMinimumSize()
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Slider) HandleMouseDown (x, y int, button input.Button) {
|
||||
if !element.Enabled() { return }
|
||||
element.Focus()
|
||||
if button == input.ButtonLeft {
|
||||
element.dragging = true
|
||||
element.value = element.valueFor(x, y)
|
||||
if element.onSlide != nil {
|
||||
element.onSlide()
|
||||
}
|
||||
element.redo()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Slider) HandleMouseUp (x, y int, button input.Button) {
|
||||
if button != input.ButtonLeft || !element.dragging { return }
|
||||
element.dragging = false
|
||||
if element.onRelease != nil {
|
||||
element.onRelease()
|
||||
}
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *Slider) HandleMouseMove (x, y int) {
|
||||
if element.dragging {
|
||||
element.dragging = true
|
||||
element.value = element.valueFor(x, y)
|
||||
if element.onSlide != nil {
|
||||
element.onSlide()
|
||||
}
|
||||
element.redo()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Slider) HandleMouseScroll (x, y int, deltaX, deltaY float64) { }
|
||||
|
||||
func (element *Slider) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
// TODO: handle left and right arrows
|
||||
}
|
||||
|
||||
func (element *Slider) HandleKeyUp (key input.Key, modifiers input.Modifiers) { }
|
||||
|
||||
// Value returns the slider's value.
|
||||
func (element *Slider) Value () (value float64) {
|
||||
return element.value
|
||||
}
|
||||
|
||||
// SetEnabled sets whether or not the slider can be interacted with.
|
||||
func (element *Slider) SetEnabled (enabled bool) {
|
||||
element.focusableControl.SetEnabled(enabled)
|
||||
}
|
||||
|
||||
// SetValue sets the slider's value.
|
||||
func (element *Slider) SetValue (value float64) {
|
||||
if value < 0 { value = 0 }
|
||||
if value > 1 { value = 1 }
|
||||
|
||||
if element.value == value { return }
|
||||
|
||||
element.value = value
|
||||
element.redo()
|
||||
}
|
||||
|
||||
// OnSlide sets a function to be called every time the slider handle changes
|
||||
// position while being dragged.
|
||||
func (element *Slider) OnSlide (callback func ()) {
|
||||
element.onSlide = callback
|
||||
}
|
||||
|
||||
// OnRelease sets a function to be called when the handle stops being dragged.
|
||||
func (element *Slider) OnRelease (callback func ()) {
|
||||
element.onRelease = callback
|
||||
}
|
||||
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *Slider) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
element.redo()
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *Slider) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *Slider) valueFor (x, y int) (value float64) {
|
||||
if element.vertical {
|
||||
value =
|
||||
float64(y - element.track.Min.Y - element.bar.Dy() / 2) /
|
||||
float64(element.track.Dy() - element.bar.Dy())
|
||||
value = 1 - value
|
||||
} else {
|
||||
value =
|
||||
float64(x - element.track.Min.X - element.bar.Dx() / 2) /
|
||||
float64(element.track.Dx() - element.bar.Dx())
|
||||
}
|
||||
|
||||
if value < 0 { value = 0 }
|
||||
if value > 1 { value = 1 }
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Slider) updateMinimumSize () {
|
||||
if element.vertical {
|
||||
element.core.SetMinimumSize (
|
||||
element.config.HandleWidth(),
|
||||
element.config.HandleWidth() * 2)
|
||||
} else {
|
||||
element.core.SetMinimumSize (
|
||||
element.config.HandleWidth() * 2,
|
||||
element.config.HandleWidth())
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Slider) redo () {
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Slider) draw () {
|
||||
bounds := element.Bounds()
|
||||
element.track = element.theme.Padding(theme.PatternGutter).Apply(bounds)
|
||||
if element.vertical {
|
||||
barSize := element.track.Dx()
|
||||
element.bar = image.Rect(0, 0, barSize, barSize).Add(bounds.Min)
|
||||
barOffset :=
|
||||
float64(element.track.Dy() - barSize) *
|
||||
(1 - element.value)
|
||||
element.bar = element.bar.Add(image.Pt(0, int(barOffset)))
|
||||
} else {
|
||||
barSize := element.track.Dy()
|
||||
element.bar = image.Rect(0, 0, barSize, barSize).Add(bounds.Min)
|
||||
barOffset :=
|
||||
float64(element.track.Dx() - barSize) *
|
||||
element.value
|
||||
element.bar = element.bar.Add(image.Pt(int(barOffset), 0))
|
||||
}
|
||||
|
||||
state := theme.State {
|
||||
Focused: element.Focused(),
|
||||
Disabled: !element.Enabled(),
|
||||
Pressed: element.dragging,
|
||||
}
|
||||
artist.DrawBounds (
|
||||
element.core,
|
||||
element.theme.Pattern(theme.PatternGutter, state),
|
||||
bounds)
|
||||
artist.DrawBounds (
|
||||
element.core,
|
||||
element.theme.Pattern(theme.PatternHandle, state),
|
||||
element.bar)
|
||||
}
|
|
@ -0,0 +1,85 @@
|
|||
package basicElements
|
||||
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// Spacer can be used to put space between two elements..
|
||||
type Spacer struct {
|
||||
*core.Core
|
||||
core core.CoreControl
|
||||
line bool
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
}
|
||||
|
||||
// NewSpacer creates a new spacer. If line is set to true, the spacer will be
|
||||
// filled with a line color, and if compressed to its minimum width or height,
|
||||
// will appear as a line.
|
||||
func NewSpacer (line bool) (element *Spacer) {
|
||||
element = &Spacer { line: line }
|
||||
element.theme.Case = theme.C("basic", "spacer")
|
||||
element.Core, element.core = core.NewCore(element.draw)
|
||||
element.updateMinimumSize()
|
||||
return
|
||||
}
|
||||
|
||||
/// SetLine sets whether or not the spacer will appear as a colored line.
|
||||
func (element *Spacer) SetLine (line bool) {
|
||||
if element.line == line { return }
|
||||
element.line = line
|
||||
element.updateMinimumSize()
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *Spacer) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
element.redo()
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *Spacer) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *Spacer) updateMinimumSize () {
|
||||
if element.line {
|
||||
padding := element.theme.Padding(theme.PatternLine)
|
||||
element.core.SetMinimumSize (
|
||||
padding.Horizontal(),
|
||||
padding.Vertical())
|
||||
} else {
|
||||
element.core.SetMinimumSize(1, 1)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Spacer) redo () {
|
||||
if !element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Spacer) draw () {
|
||||
bounds := element.Bounds()
|
||||
|
||||
if element.line {
|
||||
pattern := element.theme.Pattern (
|
||||
theme.PatternLine,
|
||||
theme.State { })
|
||||
pattern.Draw(element.core, bounds)
|
||||
} else {
|
||||
pattern := element.theme.Pattern (
|
||||
theme.PatternBackground,
|
||||
theme.State { })
|
||||
pattern.Draw(element.core, bounds)
|
||||
}
|
||||
}
|
|
@ -0,0 +1,206 @@
|
|||
package basicElements
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/textdraw"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// Switch is a toggle-able on/off switch with an optional label. It is
|
||||
// functionally identical to Checkbox, but plays a different semantic role.
|
||||
type Switch struct {
|
||||
*core.Core
|
||||
*core.FocusableCore
|
||||
core core.CoreControl
|
||||
focusableControl core.FocusableCoreControl
|
||||
drawer textdraw.Drawer
|
||||
|
||||
pressed bool
|
||||
checked bool
|
||||
text string
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
|
||||
onToggle func ()
|
||||
}
|
||||
|
||||
// NewSwitch creates a new switch with the specified label text.
|
||||
func NewSwitch (text string, on bool) (element *Switch) {
|
||||
element = &Switch {
|
||||
checked: on,
|
||||
text: text,
|
||||
}
|
||||
element.theme.Case = theme.C("basic", "switch")
|
||||
element.Core, element.core = core.NewCore(element.draw)
|
||||
element.FocusableCore,
|
||||
element.focusableControl = core.NewFocusableCore(element.redo)
|
||||
element.drawer.SetText([]rune(text))
|
||||
element.updateMinimumSize()
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Switch) HandleMouseDown (x, y int, button input.Button) {
|
||||
if !element.Enabled() { return }
|
||||
element.Focus()
|
||||
element.pressed = true
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *Switch) HandleMouseUp (x, y int, button input.Button) {
|
||||
if button != input.ButtonLeft || !element.pressed { return }
|
||||
|
||||
element.pressed = false
|
||||
within := image.Point { x, y }.
|
||||
In(element.Bounds())
|
||||
if within {
|
||||
element.checked = !element.checked
|
||||
}
|
||||
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
if within && element.onToggle != nil {
|
||||
element.onToggle()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Switch) HandleMouseMove (x, y int) { }
|
||||
func (element *Switch) HandleMouseScroll (x, y int, deltaX, deltaY float64) { }
|
||||
|
||||
func (element *Switch) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter {
|
||||
element.pressed = true
|
||||
element.redo()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Switch) HandleKeyUp (key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter && element.pressed {
|
||||
element.pressed = false
|
||||
element.checked = !element.checked
|
||||
element.redo()
|
||||
if element.onToggle != nil {
|
||||
element.onToggle()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// OnToggle sets the function to be called when the switch is flipped.
|
||||
func (element *Switch) OnToggle (callback func ()) {
|
||||
element.onToggle = callback
|
||||
}
|
||||
|
||||
// Value reports whether or not the switch is currently on.
|
||||
func (element *Switch) Value () (on bool) {
|
||||
return element.checked
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this switch can be flipped or not.
|
||||
func (element *Switch) SetEnabled (enabled bool) {
|
||||
element.focusableControl.SetEnabled(enabled)
|
||||
}
|
||||
|
||||
// SetText sets the checkbox's label text.
|
||||
func (element *Switch) SetText (text string) {
|
||||
if element.text == text { return }
|
||||
|
||||
element.text = text
|
||||
element.drawer.SetText([]rune(text))
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *Switch) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
element.drawer.SetFace (element.theme.FontFace (
|
||||
theme.FontStyleRegular,
|
||||
theme.FontSizeNormal))
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *Switch) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *Switch) redo () {
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Switch) updateMinimumSize () {
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
lineHeight := element.drawer.LineHeight().Round()
|
||||
|
||||
if element.text == "" {
|
||||
element.core.SetMinimumSize(lineHeight * 2, lineHeight)
|
||||
} else {
|
||||
element.core.SetMinimumSize (
|
||||
lineHeight * 2 +
|
||||
element.theme.Margin(theme.PatternBackground).X +
|
||||
textBounds.Dx(),
|
||||
lineHeight)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Switch) draw () {
|
||||
bounds := element.Bounds()
|
||||
handleBounds := image.Rect(0, 0, bounds.Dy(), bounds.Dy()).Add(bounds.Min)
|
||||
gutterBounds := image.Rect(0, 0, bounds.Dy() * 2, bounds.Dy()).Add(bounds.Min)
|
||||
|
||||
state := theme.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.Focused(),
|
||||
Pressed: element.pressed,
|
||||
}
|
||||
backgroundPattern := element.theme.Pattern (
|
||||
theme.PatternBackground, state)
|
||||
backgroundPattern.Draw(element.core, bounds)
|
||||
|
||||
if element.checked {
|
||||
handleBounds.Min.X += bounds.Dy()
|
||||
handleBounds.Max.X += bounds.Dy()
|
||||
if element.pressed {
|
||||
handleBounds.Min.X -= 2
|
||||
handleBounds.Max.X -= 2
|
||||
}
|
||||
} else {
|
||||
if element.pressed {
|
||||
handleBounds.Min.X += 2
|
||||
handleBounds.Max.X += 2
|
||||
}
|
||||
}
|
||||
|
||||
gutterPattern := element.theme.Pattern (
|
||||
theme.PatternGutter, state)
|
||||
artist.DrawBounds(element.core, gutterPattern, gutterBounds)
|
||||
|
||||
handlePattern := element.theme.Pattern (
|
||||
theme.PatternHandle, state)
|
||||
artist.DrawBounds(element.core, handlePattern, handleBounds)
|
||||
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
offset := bounds.Min.Add(image.Point {
|
||||
X: bounds.Dy() * 2 +
|
||||
element.theme.Margin(theme.PatternBackground).X,
|
||||
})
|
||||
|
||||
offset.Y -= textBounds.Min.Y
|
||||
offset.X -= textBounds.Min.X
|
||||
|
||||
foreground := element.theme.Color (
|
||||
theme.ColorForeground, state)
|
||||
element.drawer.Draw(element.core, foreground, offset)
|
||||
}
|
|
@ -0,0 +1,418 @@
|
|||
package basicElements
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/textdraw"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/textmanip"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/fixedutil"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist/shapes"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// TextBox is a single-line text input.
|
||||
type TextBox struct {
|
||||
*core.Core
|
||||
*core.FocusableCore
|
||||
core core.CoreControl
|
||||
focusableControl core.FocusableCoreControl
|
||||
|
||||
dragging bool
|
||||
dot textmanip.Dot
|
||||
scroll int
|
||||
placeholder string
|
||||
text []rune
|
||||
|
||||
placeholderDrawer textdraw.Drawer
|
||||
valueDrawer textdraw.Drawer
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
|
||||
onKeyDown func (key input.Key, modifiers input.Modifiers) (handled bool)
|
||||
onChange func ()
|
||||
onScrollBoundsChange func ()
|
||||
}
|
||||
|
||||
// NewTextBox creates a new text box with the specified placeholder text, and
|
||||
// a value. When the value is empty, the placeholder will be displayed in gray
|
||||
// text.
|
||||
func NewTextBox (placeholder, value string) (element *TextBox) {
|
||||
element = &TextBox { }
|
||||
element.theme.Case = theme.C("basic", "textBox")
|
||||
element.Core, element.core = core.NewCore(element.handleResize)
|
||||
element.FocusableCore,
|
||||
element.focusableControl = core.NewFocusableCore (func () {
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
})
|
||||
element.placeholder = placeholder
|
||||
element.placeholderDrawer.SetText([]rune(placeholder))
|
||||
element.updateMinimumSize()
|
||||
element.SetValue(value)
|
||||
return
|
||||
}
|
||||
|
||||
func (element *TextBox) handleResize () {
|
||||
element.scrollToCursor()
|
||||
element.draw()
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleMouseDown (x, y int, button input.Button) {
|
||||
if !element.Enabled() { return }
|
||||
if !element.Focused() { element.Focus() }
|
||||
|
||||
if button == input.ButtonLeft {
|
||||
runeIndex := element.atPosition(image.Pt(x, y))
|
||||
element.dragging = true
|
||||
if runeIndex > -1 {
|
||||
element.dot = textmanip.EmptyDot(runeIndex)
|
||||
element.redo()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleMouseMove (x, y int) {
|
||||
if !element.Enabled() { return }
|
||||
if !element.Focused() { element.Focus() }
|
||||
|
||||
if element.dragging {
|
||||
runeIndex := element.atPosition(image.Pt(x, y))
|
||||
if runeIndex > -1 {
|
||||
element.dot.End = runeIndex
|
||||
element.redo()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) atPosition (position image.Point) int {
|
||||
padding := element.theme.Padding(theme.PatternInput)
|
||||
offset := element.Bounds().Min.Add (image.Pt (
|
||||
padding[artist.SideLeft] - element.scroll,
|
||||
padding[artist.SideTop]))
|
||||
textBoundsMin := element.valueDrawer.LayoutBounds().Min
|
||||
return element.valueDrawer.AtPosition (
|
||||
fixedutil.Pt(position.Sub(offset).Add(textBoundsMin)))
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleMouseUp (x, y int, button input.Button) {
|
||||
if button == input.ButtonLeft {
|
||||
element.dragging = false
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleMouseScroll (x, y int, deltaX, deltaY float64) { }
|
||||
|
||||
func (element *TextBox) HandleKeyDown(key input.Key, modifiers input.Modifiers) {
|
||||
if element.onKeyDown != nil && element.onKeyDown(key, modifiers) {
|
||||
return
|
||||
}
|
||||
|
||||
// TODO: text selection with shift
|
||||
|
||||
scrollMemory := element.scroll
|
||||
altered := true
|
||||
textChanged := false
|
||||
switch {
|
||||
case key == input.KeyBackspace:
|
||||
if len(element.text) < 1 { break }
|
||||
element.text, element.dot = textmanip.Backspace (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
textChanged = true
|
||||
|
||||
case key == input.KeyDelete:
|
||||
if len(element.text) < 1 { break }
|
||||
element.text, element.dot = textmanip.Delete (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
textChanged = true
|
||||
|
||||
case key == input.KeyLeft:
|
||||
if modifiers.Shift {
|
||||
element.dot = textmanip.SelectLeft (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
} else {
|
||||
element.dot = textmanip.MoveLeft (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
}
|
||||
|
||||
case key == input.KeyRight:
|
||||
if modifiers.Shift {
|
||||
element.dot = textmanip.SelectRight (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
} else {
|
||||
element.dot = textmanip.MoveRight (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
}
|
||||
|
||||
case key.Printable():
|
||||
element.text, element.dot = textmanip.Type (
|
||||
element.text,
|
||||
element.dot,
|
||||
rune(key))
|
||||
textChanged = true
|
||||
|
||||
default:
|
||||
altered = false
|
||||
}
|
||||
|
||||
if textChanged {
|
||||
element.runOnChange()
|
||||
element.valueDrawer.SetText(element.text)
|
||||
}
|
||||
|
||||
if altered {
|
||||
element.scrollToCursor()
|
||||
}
|
||||
|
||||
if (textChanged || scrollMemory != element.scroll) &&
|
||||
element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
|
||||
if altered {
|
||||
element.redo()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleKeyUp(key input.Key, modifiers input.Modifiers) { }
|
||||
|
||||
func (element *TextBox) SetPlaceholder (placeholder string) {
|
||||
if element.placeholder == placeholder { return }
|
||||
|
||||
element.placeholder = placeholder
|
||||
element.placeholderDrawer.SetText([]rune(placeholder))
|
||||
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *TextBox) SetValue (text string) {
|
||||
// if element.text == text { return }
|
||||
|
||||
element.text = []rune(text)
|
||||
element.runOnChange()
|
||||
element.valueDrawer.SetText(element.text)
|
||||
if element.dot.End > element.valueDrawer.Length() {
|
||||
element.dot = textmanip.EmptyDot(element.valueDrawer.Length())
|
||||
}
|
||||
element.scrollToCursor()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *TextBox) Value () (value string) {
|
||||
return string(element.text)
|
||||
}
|
||||
|
||||
func (element *TextBox) Filled () (filled bool) {
|
||||
return len(element.text) > 0
|
||||
}
|
||||
|
||||
func (element *TextBox) OnKeyDown (
|
||||
callback func (key input.Key, modifiers input.Modifiers) (handled bool),
|
||||
) {
|
||||
element.onKeyDown = callback
|
||||
}
|
||||
|
||||
func (element *TextBox) OnChange (callback func ()) {
|
||||
element.onChange = callback
|
||||
}
|
||||
|
||||
// ScrollContentBounds returns the full content size of the element.
|
||||
func (element *TextBox) ScrollContentBounds () (bounds image.Rectangle) {
|
||||
bounds = element.valueDrawer.LayoutBounds()
|
||||
return bounds.Sub(bounds.Min)
|
||||
}
|
||||
|
||||
// ScrollViewportBounds returns the size and position of the element's viewport
|
||||
// relative to ScrollBounds.
|
||||
func (element *TextBox) ScrollViewportBounds () (bounds image.Rectangle) {
|
||||
return image.Rect (
|
||||
element.scroll,
|
||||
0,
|
||||
element.scroll + element.scrollViewportWidth(),
|
||||
0)
|
||||
}
|
||||
|
||||
func (element *TextBox) scrollViewportWidth () (width int) {
|
||||
padding := element.theme.Padding(theme.PatternInput)
|
||||
return padding.Apply(element.Bounds()).Dx()
|
||||
}
|
||||
|
||||
// ScrollTo scrolls the viewport to the specified point relative to
|
||||
// ScrollBounds.
|
||||
func (element *TextBox) ScrollTo (position image.Point) {
|
||||
// constrain to minimum
|
||||
element.scroll = position.X
|
||||
if element.scroll < 0 { element.scroll = 0 }
|
||||
|
||||
// constrain to maximum
|
||||
contentBounds := element.ScrollContentBounds()
|
||||
maxPosition := contentBounds.Max.X - element.scrollViewportWidth()
|
||||
if element.scroll > maxPosition { element.scroll = maxPosition }
|
||||
|
||||
element.redo()
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
// ScrollAxes returns the supported axes for scrolling.
|
||||
func (element *TextBox) ScrollAxes () (horizontal, vertical bool) {
|
||||
return true, false
|
||||
}
|
||||
|
||||
func (element *TextBox) OnScrollBoundsChange (callback func ()) {
|
||||
element.onScrollBoundsChange = callback
|
||||
}
|
||||
|
||||
func (element *TextBox) runOnChange () {
|
||||
if element.onChange != nil {
|
||||
element.onChange()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) scrollToCursor () {
|
||||
if !element.core.HasImage() { return }
|
||||
|
||||
padding := element.theme.Padding(theme.PatternInput)
|
||||
bounds := padding.Apply(element.Bounds())
|
||||
bounds = bounds.Sub(bounds.Min)
|
||||
bounds.Max.X -= element.valueDrawer.Em().Round()
|
||||
cursorPosition := fixedutil.RoundPt (
|
||||
element.valueDrawer.PositionAt(element.dot.End))
|
||||
cursorPosition.X -= element.scroll
|
||||
maxX := bounds.Max.X
|
||||
minX := maxX
|
||||
if cursorPosition.X > maxX {
|
||||
element.scroll += cursorPosition.X - maxX
|
||||
} else if cursorPosition.X < minX {
|
||||
element.scroll -= minX - cursorPosition.X
|
||||
if element.scroll < 0 { element.scroll = 0 }
|
||||
}
|
||||
}
|
||||
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *TextBox) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
face := element.theme.FontFace (
|
||||
theme.FontStyleRegular,
|
||||
theme.FontSizeNormal)
|
||||
element.placeholderDrawer.SetFace(face)
|
||||
element.valueDrawer.SetFace(face)
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *TextBox) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
element.updateMinimumSize()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *TextBox) updateMinimumSize () {
|
||||
textBounds := element.placeholderDrawer.LayoutBounds()
|
||||
padding := element.theme.Padding(theme.PatternInput)
|
||||
element.core.SetMinimumSize (
|
||||
padding.Horizontal() + textBounds.Dx(),
|
||||
padding.Vertical() +
|
||||
element.placeholderDrawer.LineHeight().Round())
|
||||
}
|
||||
|
||||
func (element *TextBox) redo () {
|
||||
if element.core.HasImage () {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) draw () {
|
||||
bounds := element.Bounds()
|
||||
|
||||
state := theme.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.Focused(),
|
||||
}
|
||||
pattern := element.theme.Pattern(theme.PatternInput, state)
|
||||
padding := element.theme.Padding(theme.PatternInput)
|
||||
innerCanvas := canvas.Cut(element.core, padding.Apply(bounds))
|
||||
pattern.Draw(element.core, bounds)
|
||||
|
||||
offset := bounds.Min.Add (image.Point {
|
||||
X: padding[artist.SideLeft] - element.scroll,
|
||||
Y: padding[artist.SideTop],
|
||||
})
|
||||
|
||||
if element.Focused() && !element.dot.Empty() {
|
||||
// draw selection bounds
|
||||
accent := element.theme.Color(theme.ColorAccent, state)
|
||||
canon := element.dot.Canon()
|
||||
foff := fixedutil.Pt(offset)
|
||||
start := element.valueDrawer.PositionAt(canon.Start).Add(foff)
|
||||
end := element.valueDrawer.PositionAt(canon.End).Add(foff)
|
||||
end.Y += element.valueDrawer.LineHeight()
|
||||
shapes.FillColorRectangle (
|
||||
innerCanvas,
|
||||
accent,
|
||||
image.Rectangle {
|
||||
fixedutil.RoundPt(start),
|
||||
fixedutil.RoundPt(end),
|
||||
})
|
||||
}
|
||||
|
||||
if len(element.text) == 0 {
|
||||
// draw placeholder
|
||||
textBounds := element.placeholderDrawer.LayoutBounds()
|
||||
foreground := element.theme.Color (
|
||||
theme.ColorForeground,
|
||||
theme.State { Disabled: true })
|
||||
element.placeholderDrawer.Draw (
|
||||
innerCanvas,
|
||||
foreground,
|
||||
offset.Sub(textBounds.Min))
|
||||
} else {
|
||||
// draw input value
|
||||
textBounds := element.valueDrawer.LayoutBounds()
|
||||
foreground := element.theme.Color(theme.ColorForeground, state)
|
||||
element.valueDrawer.Draw (
|
||||
innerCanvas,
|
||||
foreground,
|
||||
offset.Sub(textBounds.Min))
|
||||
}
|
||||
|
||||
if element.Focused() && element.dot.Empty() {
|
||||
// draw cursor
|
||||
foreground := element.theme.Color(theme.ColorForeground, state)
|
||||
cursorPosition := fixedutil.RoundPt (
|
||||
element.valueDrawer.PositionAt(element.dot.End))
|
||||
shapes.ColorLine (
|
||||
innerCanvas,
|
||||
foreground, 1,
|
||||
cursorPosition.Add(offset),
|
||||
image.Pt (
|
||||
cursorPosition.X,
|
||||
cursorPosition.Y + element.valueDrawer.
|
||||
LineHeight().Round()).Add(offset))
|
||||
}
|
||||
}
|
217
elements/box.go
217
elements/box.go
|
@ -1,217 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "art"
|
||||
import "art/shatter"
|
||||
|
||||
var boxCase = tomo.C("tomo", "box")
|
||||
|
||||
// Space is a list of spacing configurations that can be passed to some
|
||||
// containers.
|
||||
type Space int; const (
|
||||
SpaceNone Space = 0
|
||||
SpacePadding Space = 1
|
||||
SpaceMargin Space = 2
|
||||
SpaceBoth Space = SpacePadding | SpaceMargin
|
||||
)
|
||||
|
||||
// Includes returns whether a spacing value has been or'd with another spacing
|
||||
// value.
|
||||
func (space Space) Includes (sub Space) bool {
|
||||
return (space & sub) > 0
|
||||
}
|
||||
|
||||
// Box is a container that lays out its children horizontally or vertically.
|
||||
// Child elements can be set to contract to their minimum size, or expand to
|
||||
// fill remaining space. Boxes can be nested and used together to create more
|
||||
// complex layouts.
|
||||
type Box struct {
|
||||
container
|
||||
padding bool
|
||||
margin bool
|
||||
vertical bool
|
||||
}
|
||||
|
||||
// NewHBox creates a new horizontal box.
|
||||
func NewHBox (space Space, children ...tomo.Element) (element *Box) {
|
||||
element = &Box {
|
||||
padding: space.Includes(SpacePadding),
|
||||
margin: space.Includes(SpaceMargin),
|
||||
}
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.minimumSize = element.updateMinimumSize
|
||||
element.init()
|
||||
element.Adopt(children...)
|
||||
return
|
||||
}
|
||||
|
||||
// NewHBox creates a new vertical box.
|
||||
func NewVBox (space Space, children ...tomo.Element) (element *Box) {
|
||||
element = &Box {
|
||||
padding: space.Includes(SpacePadding),
|
||||
margin: space.Includes(SpaceMargin),
|
||||
vertical: true,
|
||||
}
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.minimumSize = element.updateMinimumSize
|
||||
element.init()
|
||||
element.Adopt(children...)
|
||||
return
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Box) Draw (destination art.Canvas) {
|
||||
rocks := make([]image.Rectangle, element.entity.CountChildren())
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
rocks[index] = element.entity.Child(index).Entity().Bounds()
|
||||
}
|
||||
|
||||
tiles := shatter.Shatter(element.entity.Bounds(), rocks...)
|
||||
for _, tile := range tiles {
|
||||
element.entity.DrawBackground(art.Cut(destination, tile))
|
||||
}
|
||||
}
|
||||
|
||||
// Layout causes this element to perform a layout operation.
|
||||
func (element *Box) Layout () {
|
||||
margin := element.entity.Theme().Margin(tomo.PatternBackground, boxCase)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternBackground, boxCase)
|
||||
bounds := element.entity.Bounds()
|
||||
if element.padding { bounds = padding.Apply(bounds) }
|
||||
|
||||
var marginSize float64; if element.vertical {
|
||||
marginSize = float64(margin.Y)
|
||||
} else {
|
||||
marginSize = float64(margin.X)
|
||||
}
|
||||
|
||||
freeSpace, nExpanding := element.freeSpace()
|
||||
expandingElementSize := freeSpace / nExpanding
|
||||
|
||||
// set the size and position of each element
|
||||
x := float64(bounds.Min.X)
|
||||
y := float64(bounds.Min.Y)
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
entry := element.scratch[element.entity.Child(index)]
|
||||
|
||||
var size float64; if entry.expand {
|
||||
size = expandingElementSize
|
||||
} else {
|
||||
size = entry.minSize
|
||||
}
|
||||
|
||||
var childBounds image.Rectangle; if element.vertical {
|
||||
childBounds = tomo.Bounds(int(x), int(y), bounds.Dx(), int(size))
|
||||
} else {
|
||||
childBounds = tomo.Bounds(int(x), int(y), int(size), bounds.Dy())
|
||||
}
|
||||
element.entity.PlaceChild(index, childBounds)
|
||||
|
||||
if element.vertical {
|
||||
y += size
|
||||
if element.margin { y += marginSize }
|
||||
} else {
|
||||
x += size
|
||||
if element.margin { x += marginSize }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// AdoptExpand adds one or more elements to the box. These elements will be
|
||||
// expanded to fill in empty space.
|
||||
func (element *Box) AdoptExpand (children ...tomo.Element) {
|
||||
element.adopt(true, children...)
|
||||
}
|
||||
|
||||
// DrawBackground draws this element's background pattern to the specified
|
||||
// destination canvas.
|
||||
func (element *Box) DrawBackground (destination art.Canvas) {
|
||||
element.entity.DrawBackground(destination)
|
||||
}
|
||||
|
||||
func (element *Box) HandleThemeChange () {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
func (element *Box) freeSpace () (space float64, nExpanding float64) {
|
||||
margin := element.entity.Theme().Margin(tomo.PatternBackground, boxCase)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternBackground, boxCase)
|
||||
|
||||
var marginSize int; if element.vertical {
|
||||
marginSize = margin.Y
|
||||
} else {
|
||||
marginSize = margin.X
|
||||
}
|
||||
|
||||
if element.vertical {
|
||||
space = float64(element.entity.Bounds().Dy())
|
||||
} else {
|
||||
space = float64(element.entity.Bounds().Dx())
|
||||
}
|
||||
|
||||
for _, entry := range element.scratch {
|
||||
if entry.expand {
|
||||
nExpanding ++;
|
||||
} else {
|
||||
space -= float64(entry.minSize)
|
||||
}
|
||||
}
|
||||
|
||||
if element.padding {
|
||||
space -= float64(padding.Vertical())
|
||||
}
|
||||
if element.margin {
|
||||
space -= float64(marginSize * (len(element.scratch) - 1))
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Box) updateMinimumSize () {
|
||||
margin := element.entity.Theme().Margin(tomo.PatternBackground, boxCase)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternBackground, boxCase)
|
||||
var breadth, size int
|
||||
var marginSize int; if element.vertical {
|
||||
marginSize = margin.Y
|
||||
} else {
|
||||
marginSize = margin.X
|
||||
}
|
||||
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
childWidth, childHeight := element.entity.ChildMinimumSize(index)
|
||||
var childBreadth, childSize int; if element.vertical {
|
||||
childBreadth, childSize = childWidth, childHeight
|
||||
} else {
|
||||
childBreadth, childSize = childHeight, childWidth
|
||||
}
|
||||
|
||||
key := element.entity.Child(index)
|
||||
entry := element.scratch[key]
|
||||
entry.minSize = float64(childSize)
|
||||
element.scratch[key] = entry
|
||||
|
||||
if childBreadth > breadth {
|
||||
breadth = childBreadth
|
||||
}
|
||||
size += childSize
|
||||
if element.margin && index > 0 {
|
||||
size += marginSize
|
||||
}
|
||||
}
|
||||
|
||||
var width, height int; if element.vertical {
|
||||
width, height = breadth, size
|
||||
} else {
|
||||
width, height = size, breadth
|
||||
}
|
||||
|
||||
if element.padding {
|
||||
width += padding.Horizontal()
|
||||
height += padding.Vertical()
|
||||
}
|
||||
|
||||
element.entity.SetMinimumSize(width, height)
|
||||
}
|
|
@ -1,242 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "tomo/textdraw"
|
||||
|
||||
var buttonCase = tomo.C("tomo", "button")
|
||||
|
||||
// Button is a clickable button.
|
||||
type Button struct {
|
||||
entity tomo.Entity
|
||||
drawer textdraw.Drawer
|
||||
|
||||
enabled bool
|
||||
pressed bool
|
||||
text string
|
||||
|
||||
showText bool
|
||||
hasIcon bool
|
||||
iconId tomo.Icon
|
||||
|
||||
onClick func ()
|
||||
}
|
||||
|
||||
// NewButton creates a new button with the specified label text.
|
||||
func NewButton (text string) (element *Button) {
|
||||
element = &Button { showText: true, enabled: true }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal,
|
||||
buttonCase))
|
||||
element.SetText(text)
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *Button) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Button) Draw (destination art.Canvas) {
|
||||
state := element.state()
|
||||
bounds := element.entity.Bounds()
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternButton, state, buttonCase)
|
||||
|
||||
pattern.Draw(destination, bounds)
|
||||
|
||||
foreground := element.entity.Theme().Color(tomo.ColorForeground, state, buttonCase)
|
||||
sink := element.entity.Theme().Sink(tomo.PatternButton, buttonCase)
|
||||
margin := element.entity.Theme().Margin(tomo.PatternButton, buttonCase)
|
||||
|
||||
offset := image.Pt (
|
||||
bounds.Dx() / 2,
|
||||
bounds.Dy() / 2).Add(bounds.Min)
|
||||
|
||||
if element.showText {
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
offset.X -= textBounds.Dx() / 2
|
||||
offset.Y -= textBounds.Dy() / 2
|
||||
offset.Y -= textBounds.Min.Y
|
||||
offset.X -= textBounds.Min.X
|
||||
}
|
||||
|
||||
if element.hasIcon {
|
||||
icon := element.entity.Theme().Icon(element.iconId, tomo.IconSizeSmall, buttonCase)
|
||||
if icon != nil {
|
||||
iconBounds := icon.Bounds()
|
||||
addedWidth := iconBounds.Dx()
|
||||
iconOffset := offset
|
||||
|
||||
if element.showText {
|
||||
addedWidth += margin.X
|
||||
}
|
||||
|
||||
iconOffset.X -= addedWidth / 2
|
||||
iconOffset.Y =
|
||||
bounds.Min.Y +
|
||||
(bounds.Dy() -
|
||||
iconBounds.Dy()) / 2
|
||||
if element.pressed {
|
||||
iconOffset = iconOffset.Add(sink)
|
||||
}
|
||||
offset.X += addedWidth / 2
|
||||
|
||||
icon.Draw(destination, foreground, iconOffset)
|
||||
}
|
||||
}
|
||||
|
||||
if element.showText {
|
||||
if element.pressed {
|
||||
offset = offset.Add(sink)
|
||||
}
|
||||
element.drawer.Draw(destination, foreground, offset)
|
||||
}
|
||||
}
|
||||
|
||||
// OnClick sets the function to be called when the button is clicked.
|
||||
func (element *Button) OnClick (callback func ()) {
|
||||
element.onClick = callback
|
||||
}
|
||||
|
||||
// Focus gives this element input focus.
|
||||
func (element *Button) Focus () {
|
||||
if !element.entity.Focused() { element.entity.Focus() }
|
||||
}
|
||||
|
||||
// Enabled returns whether this button is enabled or not.
|
||||
func (element *Button) Enabled () bool {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this button can be clicked or not.
|
||||
func (element *Button) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// SetText sets the button's label text.
|
||||
func (element *Button) SetText (text string) {
|
||||
if element.text == text { return }
|
||||
element.text = text
|
||||
element.drawer.SetText([]rune(text))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// SetIcon sets the icon of the button. Passing theme.IconNone removes the
|
||||
// current icon if it exists.
|
||||
func (element *Button) SetIcon (id tomo.Icon) {
|
||||
if id == tomo.IconNone {
|
||||
element.hasIcon = false
|
||||
} else {
|
||||
if element.hasIcon && element.iconId == id { return }
|
||||
element.hasIcon = true
|
||||
element.iconId = id
|
||||
}
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// ShowText sets whether or not the button's text will be displayed.
|
||||
func (element *Button) ShowText (showText bool) {
|
||||
if element.showText == showText { return }
|
||||
element.showText = showText
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Button) HandleThemeChange () {
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal,
|
||||
buttonCase))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Button) HandleFocusChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Button) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if !element.Enabled() { return }
|
||||
element.Focus()
|
||||
if button != input.ButtonLeft { return }
|
||||
element.pressed = true
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Button) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if button != input.ButtonLeft { return }
|
||||
element.pressed = false
|
||||
within := position.In(element.entity.Bounds())
|
||||
if element.Enabled() && within && element.onClick != nil {
|
||||
element.onClick()
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Button) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if !element.Enabled() { return }
|
||||
if key == input.KeyEnter {
|
||||
element.pressed = true
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Button) HandleKeyUp(key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter && element.pressed {
|
||||
element.pressed = false
|
||||
element.entity.Invalidate()
|
||||
if !element.Enabled() { return }
|
||||
if element.onClick != nil {
|
||||
element.onClick()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Button) updateMinimumSize () {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternButton, buttonCase)
|
||||
margin := element.entity.Theme().Margin(tomo.PatternButton, buttonCase)
|
||||
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
minimumSize := textBounds.Sub(textBounds.Min)
|
||||
|
||||
if element.hasIcon {
|
||||
icon := element.entity.Theme().Icon(element.iconId, tomo.IconSizeSmall, buttonCase)
|
||||
if icon != nil {
|
||||
bounds := icon.Bounds()
|
||||
if element.showText {
|
||||
minimumSize.Max.X += bounds.Dx()
|
||||
minimumSize.Max.X += margin.X
|
||||
} else {
|
||||
minimumSize.Max.X = bounds.Dx()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
minimumSize = padding.Inverse().Apply(minimumSize)
|
||||
element.entity.SetMinimumSize(minimumSize.Dx(), minimumSize.Dy())
|
||||
}
|
||||
|
||||
func (element *Button) state () tomo.State {
|
||||
return tomo.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.entity.Focused(),
|
||||
Pressed: element.pressed,
|
||||
}
|
||||
}
|
156
elements/cell.go
156
elements/cell.go
|
@ -1,156 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "tomo"
|
||||
import "art"
|
||||
import "art/artutil"
|
||||
|
||||
var cellCase = tomo.C("tomo", "cell")
|
||||
|
||||
// Cell is a single-element container that satisfies tomo.Selectable. It
|
||||
// provides styling based on whether or not it is selected.
|
||||
type Cell struct {
|
||||
entity tomo.Entity
|
||||
child tomo.Element
|
||||
enabled bool
|
||||
|
||||
onSelectionChange func ()
|
||||
}
|
||||
|
||||
// NewCell creates a new cell element. If padding is true, the cell will have
|
||||
// padding on all sides. Child can be nil and added later with the Adopt()
|
||||
// method.
|
||||
func NewCell (child tomo.Element) (element *Cell) {
|
||||
element = &Cell { enabled: true }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.Adopt(child)
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *Cell) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Cell) Draw (destination art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternTableCell, element.state(), cellCase)
|
||||
if element.child == nil {
|
||||
pattern.Draw(destination, bounds)
|
||||
} else {
|
||||
artutil.DrawShatter (
|
||||
destination, pattern, bounds,
|
||||
element.child.Entity().Bounds())
|
||||
}
|
||||
}
|
||||
|
||||
// Draw causes the element to perform a layout operation.
|
||||
func (element *Cell) Layout () {
|
||||
if element.child == nil { return }
|
||||
|
||||
bounds := element.entity.Bounds()
|
||||
bounds = element.entity.Theme().Padding(tomo.PatternTableCell, cellCase).Apply(bounds)
|
||||
|
||||
element.entity.PlaceChild(0, bounds)
|
||||
}
|
||||
|
||||
// DrawBackground draws this element's background pattern to the specified
|
||||
// destination canvas.
|
||||
func (element *Cell) DrawBackground (destination art.Canvas) {
|
||||
element.entity.Theme().Pattern(tomo.PatternTableCell, element.state(), cellCase).
|
||||
Draw(destination, element.entity.Bounds())
|
||||
}
|
||||
|
||||
// Adopt sets this element's child. If nil is passed, any child is removed.
|
||||
func (element *Cell) Adopt (child tomo.Element) {
|
||||
if element.child != nil {
|
||||
element.entity.Disown(element.entity.IndexOf(element.child))
|
||||
}
|
||||
if child != nil {
|
||||
element.entity.Adopt(child)
|
||||
}
|
||||
element.child = child
|
||||
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.invalidateChild()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// Child returns this element's child. If there is no child, this method will
|
||||
// return nil.
|
||||
func (element *Cell) Child () tomo.Element {
|
||||
return element.child
|
||||
}
|
||||
|
||||
// Enabled returns whether this cell is enabled or not.
|
||||
func (element *Cell) Enabled () bool {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this cell can be selected or not.
|
||||
func (element *Cell) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
element.invalidateChild()
|
||||
}
|
||||
|
||||
// OnSelectionChange sets a function to be called when this element is selected
|
||||
// or unselected.
|
||||
func (element *Cell) OnSelectionChange (callback func ()) {
|
||||
element.onSelectionChange = callback
|
||||
}
|
||||
|
||||
func (element *Cell) Selected () bool {
|
||||
return element.entity.Selected()
|
||||
}
|
||||
|
||||
func (element *Cell) HandleThemeChange () {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.invalidateChild()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
func (element *Cell) HandleSelectionChange () {
|
||||
element.entity.Invalidate()
|
||||
element.invalidateChild()
|
||||
if element.onSelectionChange != nil {
|
||||
element.onSelectionChange()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Cell) HandleChildMinimumSizeChange (tomo.Element) {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
func (element *Cell) state () tomo.State {
|
||||
return tomo.State {
|
||||
Disabled: !element.enabled,
|
||||
On: element.entity.Selected(),
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Cell) updateMinimumSize () {
|
||||
width, height := 0, 0
|
||||
|
||||
if element.child != nil {
|
||||
childWidth, childHeight := element.entity.ChildMinimumSize(0)
|
||||
width += childWidth
|
||||
height += childHeight
|
||||
}
|
||||
padding := element.entity.Theme().Padding(tomo.PatternTableCell, cellCase)
|
||||
width += padding.Horizontal()
|
||||
height += padding.Vertical()
|
||||
|
||||
element.entity.SetMinimumSize(width, height)
|
||||
}
|
||||
|
||||
func (element *Cell) invalidateChild () {
|
||||
if element.child != nil {
|
||||
element.child.Entity().Invalidate()
|
||||
}
|
||||
}
|
|
@ -1,178 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "tomo/textdraw"
|
||||
|
||||
var checkboxCase = tomo.C("tomo", "checkbox")
|
||||
|
||||
// Checkbox is a toggle-able checkbox with a label.
|
||||
type Checkbox struct {
|
||||
entity tomo.Entity
|
||||
drawer textdraw.Drawer
|
||||
|
||||
enabled bool
|
||||
pressed bool
|
||||
checked bool
|
||||
text string
|
||||
|
||||
onToggle func ()
|
||||
}
|
||||
|
||||
// NewCheckbox creates a new cbeckbox with the specified label text.
|
||||
func NewCheckbox (text string, checked bool) (element *Checkbox) {
|
||||
element = &Checkbox { checked: checked, enabled: true }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal,
|
||||
checkboxCase))
|
||||
element.SetText(text)
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *Checkbox) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Checkbox) Draw (destination art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
boxBounds := image.Rect(0, 0, bounds.Dy(), bounds.Dy()).Add(bounds.Min)
|
||||
|
||||
state := tomo.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.entity.Focused(),
|
||||
Pressed: element.pressed,
|
||||
On: element.checked,
|
||||
}
|
||||
|
||||
element.entity.DrawBackground(destination)
|
||||
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternButton, state, checkboxCase)
|
||||
pattern.Draw(destination, boxBounds)
|
||||
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
margin := element.entity.Theme().Margin(tomo.PatternBackground, checkboxCase)
|
||||
offset := bounds.Min.Add(image.Point {
|
||||
X: bounds.Dy() + margin.X,
|
||||
})
|
||||
|
||||
offset.Y -= textBounds.Min.Y
|
||||
offset.X -= textBounds.Min.X
|
||||
|
||||
foreground := element.entity.Theme().Color(tomo.ColorForeground, state, checkboxCase)
|
||||
element.drawer.Draw(destination, foreground, offset)
|
||||
}
|
||||
|
||||
// OnToggle sets the function to be called when the checkbox is toggled.
|
||||
func (element *Checkbox) OnToggle (callback func ()) {
|
||||
element.onToggle = callback
|
||||
}
|
||||
|
||||
// Value reports whether or not the checkbox is currently checked.
|
||||
func (element *Checkbox) Value () (checked bool) {
|
||||
return element.checked
|
||||
}
|
||||
|
||||
// Focus gives this element input focus.
|
||||
func (element *Checkbox) Focus () {
|
||||
if !element.entity.Focused() { element.entity.Focus() }
|
||||
}
|
||||
|
||||
// Enabled returns whether this checkbox is enabled or not.
|
||||
func (element *Checkbox) Enabled () bool {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this checkbox can be toggled or not.
|
||||
func (element *Checkbox) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// SetText sets the checkbox's label text.
|
||||
func (element *Checkbox) SetText (text string) {
|
||||
if element.text == text { return }
|
||||
element.text = text
|
||||
element.drawer.SetText([]rune(text))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Checkbox) HandleThemeChange () {
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal,
|
||||
checkboxCase))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Checkbox) HandleFocusChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Checkbox) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if !element.Enabled() { return }
|
||||
element.Focus()
|
||||
element.pressed = true
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Checkbox) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if button != input.ButtonLeft || !element.pressed { return }
|
||||
|
||||
element.pressed = false
|
||||
within := position.In(element.entity.Bounds())
|
||||
if within {
|
||||
element.checked = !element.checked
|
||||
}
|
||||
|
||||
element.entity.Invalidate()
|
||||
if within && element.onToggle != nil {
|
||||
element.onToggle()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Checkbox) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter {
|
||||
element.pressed = true
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Checkbox) HandleKeyUp (key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter && element.pressed {
|
||||
element.pressed = false
|
||||
element.checked = !element.checked
|
||||
element.entity.Invalidate()
|
||||
if element.onToggle != nil {
|
||||
element.onToggle()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Checkbox) updateMinimumSize () {
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
if element.text == "" {
|
||||
element.entity.SetMinimumSize(textBounds.Dy(), textBounds.Dy())
|
||||
} else {
|
||||
margin := element.entity.Theme().Margin(tomo.PatternBackground, checkboxCase)
|
||||
element.entity.SetMinimumSize (
|
||||
textBounds.Dy() + margin.X + textBounds.Dx(),
|
||||
textBounds.Dy())
|
||||
}
|
||||
}
|
|
@ -1,268 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "tomo/ability"
|
||||
import "tomo/textdraw"
|
||||
|
||||
var comboBoxCase = tomo.C("tomo", "comboBox")
|
||||
|
||||
// Option specifies a ComboBox option. A blank option will display as "(None)".
|
||||
type Option string
|
||||
|
||||
func (option Option) Title () string {
|
||||
if option == "" {
|
||||
return "(None)"
|
||||
} else {
|
||||
return string(option)
|
||||
}
|
||||
}
|
||||
|
||||
// ComboBox is an input that can be one of several predetermined values.
|
||||
type ComboBox struct {
|
||||
entity tomo.Entity
|
||||
drawer textdraw.Drawer
|
||||
|
||||
options []Option
|
||||
selected Option
|
||||
|
||||
enabled bool
|
||||
pressed bool
|
||||
|
||||
onChange func ()
|
||||
}
|
||||
|
||||
// NewComboBox creates a new ComboBox with the specifed options.
|
||||
func NewComboBox (options ...Option) (element *ComboBox) {
|
||||
if len(options) == 0 { options = []Option { "" } }
|
||||
element = &ComboBox { enabled: true, options: options }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal,
|
||||
comboBoxCase))
|
||||
element.Select(options[0])
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *ComboBox) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *ComboBox) Draw (destination art.Canvas) {
|
||||
state := element.state()
|
||||
bounds := element.entity.Bounds()
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternButton, state, comboBoxCase)
|
||||
|
||||
pattern.Draw(destination, bounds)
|
||||
|
||||
foreground := element.entity.Theme().Color(tomo.ColorForeground, state, comboBoxCase)
|
||||
sink := element.entity.Theme().Sink(tomo.PatternButton, comboBoxCase)
|
||||
margin := element.entity.Theme().Margin(tomo.PatternButton, comboBoxCase)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternButton, comboBoxCase)
|
||||
|
||||
offset := image.Pt(0, bounds.Dy() / 2).Add(bounds.Min)
|
||||
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
offset.Y -= textBounds.Dy() / 2
|
||||
offset.Y -= textBounds.Min.Y
|
||||
offset.X -= textBounds.Min.X
|
||||
|
||||
icon := element.entity.Theme().Icon(tomo.IconExpand, tomo.IconSizeSmall, comboBoxCase)
|
||||
if icon != nil {
|
||||
iconBounds := icon.Bounds()
|
||||
addedWidth := iconBounds.Dx() + margin.X
|
||||
iconOffset := bounds.Min
|
||||
|
||||
iconOffset.X += padding[3]
|
||||
iconOffset.Y =
|
||||
bounds.Min.Y +
|
||||
(bounds.Dy() -
|
||||
iconBounds.Dy()) / 2
|
||||
if element.pressed {
|
||||
iconOffset = iconOffset.Add(sink)
|
||||
}
|
||||
offset.X += addedWidth + padding[3]
|
||||
|
||||
icon.Draw(destination, foreground, iconOffset)
|
||||
}
|
||||
|
||||
if element.pressed {
|
||||
offset = offset.Add(sink)
|
||||
}
|
||||
element.drawer.Draw(destination, foreground, offset)
|
||||
}
|
||||
|
||||
// OnChange sets the function to be called when this element's value is changed.
|
||||
func (element *ComboBox) OnChange (callback func ()) {
|
||||
element.onChange = callback
|
||||
}
|
||||
|
||||
// Value returns this element's value.
|
||||
func (element *ComboBox) Value () Option {
|
||||
return element.selected
|
||||
}
|
||||
|
||||
// Select sets this element's value.
|
||||
func (element *ComboBox) Select (option Option) {
|
||||
element.selected = option
|
||||
element.drawer.SetText([]rune(option.Title()))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
if element.onChange != nil {
|
||||
element.onChange()
|
||||
}
|
||||
}
|
||||
|
||||
// Filled returns whether this element has a value other than (None).
|
||||
func (element *ComboBox) Filled () bool {
|
||||
return element.selected != ""
|
||||
}
|
||||
|
||||
// Focus gives this element input focus.
|
||||
func (element *ComboBox) Focus () {
|
||||
if !element.entity.Focused() { element.entity.Focus() }
|
||||
}
|
||||
|
||||
// Enabled returns whether this element is enabled or not.
|
||||
func (element *ComboBox) Enabled () bool {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this element is enabled or not.
|
||||
func (element *ComboBox) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *ComboBox) HandleThemeChange () {
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal,
|
||||
comboBoxCase))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *ComboBox) HandleFocusChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *ComboBox) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if !element.Enabled() { return }
|
||||
element.Focus()
|
||||
if button != input.ButtonLeft { return }
|
||||
element.dropDown()
|
||||
}
|
||||
|
||||
func (element *ComboBox) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) { }
|
||||
|
||||
func (element *ComboBox) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if !element.Enabled() { return }
|
||||
|
||||
selectionDelta := 0
|
||||
switch key {
|
||||
case input.KeyEnter:
|
||||
element.pressed = true
|
||||
element.entity.Invalidate()
|
||||
case input.KeyUp, input.KeyLeft:
|
||||
selectionDelta = -1
|
||||
case input.KeyDown, input.KeyRight:
|
||||
selectionDelta = 1
|
||||
}
|
||||
|
||||
if selectionDelta != 0 {
|
||||
selected := 0
|
||||
for index, option := range element.options {
|
||||
if option == element.selected {
|
||||
selected = index
|
||||
}
|
||||
}
|
||||
selected += selectionDelta
|
||||
if selected < 0 {
|
||||
selected = len(element.options) - 1
|
||||
} else if selected >= len(element.options) {
|
||||
selected = 0
|
||||
}
|
||||
|
||||
element.Select(element.options[selected])
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ComboBox) HandleKeyUp(key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter && element.pressed {
|
||||
element.pressed = false
|
||||
element.entity.Invalidate()
|
||||
if !element.Enabled() { return }
|
||||
element.dropDown()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ComboBox) dropDown () {
|
||||
window := element.entity.Window()
|
||||
menu, err := window.NewMenu(element.entity.Bounds())
|
||||
if err != nil { return }
|
||||
|
||||
cellToOption := make(map[ability.Selectable] Option)
|
||||
|
||||
list := NewList()
|
||||
for _, option := range element.options {
|
||||
option := option
|
||||
cell := NewCell(NewLabel(option.Title()))
|
||||
cellToOption[cell] = option
|
||||
list.Adopt(cell)
|
||||
|
||||
if option == element.selected {
|
||||
list.Select(cell)
|
||||
}
|
||||
}
|
||||
list.OnClick(func () {
|
||||
selected := list.Selected()
|
||||
if selected == nil { return }
|
||||
element.Select(cellToOption[selected])
|
||||
menu.Close()
|
||||
})
|
||||
|
||||
menu.Adopt(list)
|
||||
list.Focus()
|
||||
menu.Show()
|
||||
}
|
||||
|
||||
func (element *ComboBox) updateMinimumSize () {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternButton, comboBoxCase)
|
||||
margin := element.entity.Theme().Margin(tomo.PatternButton, comboBoxCase)
|
||||
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
minimumSize := textBounds.Sub(textBounds.Min)
|
||||
|
||||
icon := element.entity.Theme().Icon(tomo.IconExpand, tomo.IconSizeSmall, comboBoxCase)
|
||||
if icon != nil {
|
||||
bounds := icon.Bounds()
|
||||
minimumSize.Max.X += bounds.Dx()
|
||||
minimumSize.Max.X += margin.X
|
||||
}
|
||||
|
||||
minimumSize = padding.Inverse().Apply(minimumSize)
|
||||
element.entity.SetMinimumSize(minimumSize.Dx(), minimumSize.Dy())
|
||||
}
|
||||
|
||||
func (element *ComboBox) state () tomo.State {
|
||||
return tomo.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.entity.Focused(),
|
||||
Pressed: element.pressed,
|
||||
}
|
||||
}
|
|
@ -1,83 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "tomo"
|
||||
|
||||
type scratchEntry struct {
|
||||
expand bool
|
||||
minSize float64
|
||||
minBreadth float64
|
||||
}
|
||||
|
||||
type container struct {
|
||||
entity tomo.Entity
|
||||
scratch map[tomo.Element] scratchEntry
|
||||
minimumSize func ()
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (container *container) Entity () tomo.Entity {
|
||||
return container.entity
|
||||
}
|
||||
|
||||
// Adopt adds one or more elements to the container.
|
||||
func (container *container) Adopt (children ...tomo.Element) {
|
||||
container.adopt(false, children...)
|
||||
}
|
||||
|
||||
func (container *container) init () {
|
||||
container.scratch = make(map[tomo.Element] scratchEntry)
|
||||
}
|
||||
|
||||
func (container *container) adopt (expand bool, children ...tomo.Element) {
|
||||
for _, child := range children {
|
||||
container.entity.Adopt(child)
|
||||
container.scratch[child] = scratchEntry { expand: expand }
|
||||
}
|
||||
container.minimumSize()
|
||||
container.entity.Invalidate()
|
||||
container.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// Disown removes one or more elements from the container.
|
||||
func (container *container) Disown (children ...tomo.Element) {
|
||||
for _, child := range children {
|
||||
index := container.entity.IndexOf(child)
|
||||
if index < 0 { continue }
|
||||
container.entity.Disown(index)
|
||||
delete(container.scratch, child)
|
||||
}
|
||||
container.minimumSize()
|
||||
container.entity.Invalidate()
|
||||
container.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// DisownAll removes all elements from the container.
|
||||
func (container *container) DisownAll () {
|
||||
func () {
|
||||
for index := 0; index < container.entity.CountChildren(); index ++ {
|
||||
index := index
|
||||
defer container.entity.Disown(index)
|
||||
}
|
||||
} ()
|
||||
container.scratch = make(map[tomo.Element] scratchEntry)
|
||||
container.minimumSize()
|
||||
container.entity.Invalidate()
|
||||
container.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// Child returns the child at the specified index.
|
||||
func (container *container) Child (index int) tomo.Element {
|
||||
if index < 0 || index >= container.entity.CountChildren() { return nil }
|
||||
return container.entity.Child(index)
|
||||
}
|
||||
|
||||
// CountChildren returns the amount of children in this container.
|
||||
func (container *container) CountChildren () int {
|
||||
return container.entity.CountChildren()
|
||||
}
|
||||
|
||||
func (container *container) HandleChildMinimumSizeChange (child tomo.Element) {
|
||||
container.minimumSize()
|
||||
container.entity.Invalidate()
|
||||
container.entity.InvalidateLayout()
|
||||
}
|
|
@ -0,0 +1,167 @@
|
|||
package core
|
||||
|
||||
import "image"
|
||||
import "image/color"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
|
||||
// Core is a struct that implements some core functionality common to most
|
||||
// widgets. It is meant to be embedded directly into a struct.
|
||||
type Core struct {
|
||||
canvas canvas.Canvas
|
||||
|
||||
metrics struct {
|
||||
minimumWidth int
|
||||
minimumHeight int
|
||||
}
|
||||
|
||||
drawSizeChange func ()
|
||||
onMinimumSizeChange func ()
|
||||
onDamage func (region canvas.Canvas)
|
||||
}
|
||||
|
||||
// NewCore creates a new element core and its corresponding control.
|
||||
func NewCore (
|
||||
drawSizeChange func (),
|
||||
) (
|
||||
core *Core,
|
||||
control CoreControl,
|
||||
) {
|
||||
core = &Core {
|
||||
drawSizeChange: drawSizeChange,
|
||||
}
|
||||
control = CoreControl { core: core }
|
||||
return
|
||||
}
|
||||
|
||||
// Bounds fulfills the tomo.Element interface. This should not need to be
|
||||
// overridden.
|
||||
func (core *Core) Bounds () (bounds image.Rectangle) {
|
||||
if core.canvas == nil { return }
|
||||
return core.canvas.Bounds()
|
||||
}
|
||||
|
||||
// MinimumSize fulfils the tomo.Element interface. This should not need to be
|
||||
// overridden.
|
||||
func (core *Core) MinimumSize () (width, height int) {
|
||||
return core.metrics.minimumWidth, core.metrics.minimumHeight
|
||||
}
|
||||
|
||||
// DrawTo fulfills the tomo.Element interface. This should not need to be
|
||||
// overridden.
|
||||
func (core *Core) DrawTo (canvas canvas.Canvas) {
|
||||
core.canvas = canvas
|
||||
if core.drawSizeChange != nil {
|
||||
core.drawSizeChange()
|
||||
}
|
||||
}
|
||||
|
||||
// OnDamage fulfils the tomo.Element interface. This should not need to be
|
||||
// overridden.
|
||||
func (core *Core) OnDamage (callback func (region canvas.Canvas)) {
|
||||
core.onDamage = callback
|
||||
}
|
||||
|
||||
// OnMinimumSizeChange fulfils the tomo.Element interface. This should not need
|
||||
// to be overridden.
|
||||
func (core *Core) OnMinimumSizeChange (callback func ()) {
|
||||
core.onMinimumSizeChange = callback
|
||||
}
|
||||
|
||||
// CoreControl is a struct that can exert control over a Core struct. It can be
|
||||
// used as a canvas. It must not be directly embedded into an element, but
|
||||
// instead kept as a private member. When a Core struct is created, a
|
||||
// corresponding CoreControl struct is linked to it and returned alongside it.
|
||||
type CoreControl struct {
|
||||
core *Core
|
||||
}
|
||||
|
||||
// ColorModel fulfills the draw.Image interface.
|
||||
func (control CoreControl) ColorModel () (model color.Model) {
|
||||
return color.RGBAModel
|
||||
}
|
||||
|
||||
// At fulfills the draw.Image interface.
|
||||
func (control CoreControl) At (x, y int) (pixel color.Color) {
|
||||
if control.core.canvas == nil { return }
|
||||
return control.core.canvas.At(x, y)
|
||||
}
|
||||
|
||||
// Bounds fulfills the draw.Image interface.
|
||||
func (control CoreControl) Bounds () (bounds image.Rectangle) {
|
||||
if control.core.canvas == nil { return }
|
||||
return control.core.canvas.Bounds()
|
||||
}
|
||||
|
||||
// Set fulfills the draw.Image interface.
|
||||
func (control CoreControl) Set (x, y int, c color.Color) () {
|
||||
if control.core.canvas == nil { return }
|
||||
control.core.canvas.Set(x, y, c)
|
||||
}
|
||||
|
||||
// Buffer fulfills the canvas.Canvas interface.
|
||||
func (control CoreControl) Buffer () (data []color.RGBA, stride int) {
|
||||
if control.core.canvas == nil { return }
|
||||
return control.core.canvas.Buffer()
|
||||
}
|
||||
|
||||
// HasImage returns true if the core has an allocated image buffer, and false if
|
||||
// it doesn't.
|
||||
func (control CoreControl) HasImage () (has bool) {
|
||||
return control.core.canvas != nil && !control.core.canvas.Bounds().Empty()
|
||||
}
|
||||
|
||||
// DamageRegion pushes the selected region of pixels to the parent element. This
|
||||
// does not need to be called when responding to a resize event.
|
||||
func (control CoreControl) DamageRegion (regions ...image.Rectangle) {
|
||||
if control.core.canvas == nil { return }
|
||||
if control.core.onDamage != nil {
|
||||
for _, region := range regions {
|
||||
control.core.onDamage (
|
||||
canvas.Cut(control.core.canvas, region))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// DamageAll pushes all pixels to the parent element. This does not need to be
|
||||
// called when redrawing in response to a change in size.
|
||||
func (control CoreControl) DamageAll () {
|
||||
control.DamageRegion(control.core.Bounds())
|
||||
}
|
||||
|
||||
// SetMinimumSize sets the minimum size of this element, notifying the parent
|
||||
// element in the process.
|
||||
func (control CoreControl) SetMinimumSize (width, height int) {
|
||||
core := control.core
|
||||
if width == core.metrics.minimumWidth &&
|
||||
height == core.metrics.minimumHeight {
|
||||
return
|
||||
}
|
||||
|
||||
core.metrics.minimumWidth = width
|
||||
core.metrics.minimumHeight = height
|
||||
if control.core.onMinimumSizeChange != nil {
|
||||
control.core.onMinimumSizeChange()
|
||||
}
|
||||
}
|
||||
|
||||
// ConstrainSize contstrains the specified width and height to the minimum width
|
||||
// and height, and returns wether or not anything ended up being constrained.
|
||||
func (control CoreControl) ConstrainSize (
|
||||
inWidth, inHeight int,
|
||||
) (
|
||||
outWidth, outHeight int,
|
||||
constrained bool,
|
||||
) {
|
||||
core := control.core
|
||||
outWidth = inWidth
|
||||
outHeight = inHeight
|
||||
if outWidth < core.metrics.minimumWidth {
|
||||
outWidth = core.metrics.minimumWidth
|
||||
constrained = true
|
||||
}
|
||||
if outHeight < core.metrics.minimumHeight {
|
||||
outHeight = core.metrics.minimumHeight
|
||||
constrained = true
|
||||
}
|
||||
return
|
||||
}
|
|
@ -0,0 +1,7 @@
|
|||
// Package core provides tools that allow elements to easily fulfill common
|
||||
// interfaces without having to duplicate a ton of code. Each "core" is a type
|
||||
// that can be embedded into an element directly, working to fulfill a
|
||||
// particular interface. Each one comes with a corresponding core control, which
|
||||
// provides an interface for elements to exert control over the core. Core
|
||||
// controls should be kept private.
|
||||
package core
|
|
@ -0,0 +1,118 @@
|
|||
package core
|
||||
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
|
||||
// FocusableCore is a struct that can be embedded into objects to make them
|
||||
// focusable, giving them the default keynav behavior.
|
||||
type FocusableCore struct {
|
||||
focused bool
|
||||
enabled bool
|
||||
drawFocusChange func ()
|
||||
onFocusRequest func () (granted bool)
|
||||
onFocusMotionRequest func(input.KeynavDirection) (granted bool)
|
||||
}
|
||||
|
||||
// NewFocusableCore creates a new focusability core and its corresponding
|
||||
// control. If your element needs to visually update itself when it's focus
|
||||
// state changes (which it should), a callback to draw and push the update can
|
||||
// be specified.
|
||||
func NewFocusableCore (
|
||||
drawFocusChange func (),
|
||||
) (
|
||||
core *FocusableCore,
|
||||
control FocusableCoreControl,
|
||||
) {
|
||||
core = &FocusableCore {
|
||||
drawFocusChange: drawFocusChange,
|
||||
enabled: true,
|
||||
}
|
||||
control = FocusableCoreControl { core: core }
|
||||
return
|
||||
}
|
||||
|
||||
// Focused returns whether or not this element is currently focused.
|
||||
func (core *FocusableCore) Focused () (focused bool) {
|
||||
return core.focused
|
||||
}
|
||||
|
||||
// Focus focuses this element, if its parent element grants the request.
|
||||
func (core *FocusableCore) Focus () {
|
||||
if !core.enabled || core.focused { return }
|
||||
if core.onFocusRequest != nil {
|
||||
if core.onFocusRequest() {
|
||||
core.focused = true
|
||||
if core.drawFocusChange != nil {
|
||||
core.drawFocusChange()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// HandleFocus causes this element to mark itself as focused, if it can
|
||||
// currently be. Otherwise, it will return false and do nothing.
|
||||
func (core *FocusableCore) HandleFocus (
|
||||
direction input.KeynavDirection,
|
||||
) (
|
||||
accepted bool,
|
||||
) {
|
||||
direction = direction.Canon()
|
||||
if !core.enabled { return false }
|
||||
if core.focused && direction != input.KeynavDirectionNeutral {
|
||||
return false
|
||||
}
|
||||
|
||||
if core.focused == false {
|
||||
core.focused = true
|
||||
if core.drawFocusChange != nil { core.drawFocusChange() }
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// HandleUnfocus causes this element to mark itself as unfocused.
|
||||
func (core *FocusableCore) HandleUnfocus () {
|
||||
core.focused = false
|
||||
if core.drawFocusChange != nil { core.drawFocusChange() }
|
||||
}
|
||||
|
||||
// OnFocusRequest sets a function to be called when this element
|
||||
// wants its parent element to focus it. Parent elements should return
|
||||
// true if the request was granted, and false if it was not.
|
||||
func (core *FocusableCore) OnFocusRequest (callback func () (granted bool)) {
|
||||
core.onFocusRequest = callback
|
||||
}
|
||||
|
||||
// OnFocusMotionRequest sets a function to be called when this
|
||||
// element wants its parent element to focus the element behind or in
|
||||
// front of it, depending on the specified direction. Parent elements
|
||||
// should return true if the request was granted, and false if it was
|
||||
// not.
|
||||
func (core *FocusableCore) OnFocusMotionRequest (
|
||||
callback func (direction input.KeynavDirection) (granted bool),
|
||||
) {
|
||||
core.onFocusMotionRequest = callback
|
||||
}
|
||||
|
||||
// Enabled returns whether or not the element is enabled.
|
||||
func (core *FocusableCore) Enabled () (enabled bool) {
|
||||
return core.enabled
|
||||
}
|
||||
|
||||
// FocusableCoreControl is a struct that can be used to exert control over a
|
||||
// focusability core. It must not be directly embedded into an element, but
|
||||
// instead kept as a private member. When a FocusableCore struct is created, a
|
||||
// corresponding FocusableCoreControl struct is linked to it and returned
|
||||
// alongside it.
|
||||
type FocusableCoreControl struct {
|
||||
core *FocusableCore
|
||||
}
|
||||
|
||||
// SetEnabled sets whether the focusability core is enabled. If the state
|
||||
// changes, this will call drawFocusChange.
|
||||
func (control FocusableCoreControl) SetEnabled (enabled bool) {
|
||||
if control.core.enabled == enabled { return }
|
||||
control.core.enabled = enabled
|
||||
if !enabled { control.core.focused = false }
|
||||
if control.core.drawFocusChange != nil {
|
||||
control.core.drawFocusChange()
|
||||
}
|
||||
}
|
|
@ -1,322 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "path/filepath"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "tomo/ability"
|
||||
import "art/shatter"
|
||||
|
||||
// TODO: base on flow implementation of list. also be able to switch to a table
|
||||
// variant for a more information dense view.
|
||||
|
||||
var directoryCase = tomo.C("tomo", "list")
|
||||
|
||||
type historyEntry struct {
|
||||
location string
|
||||
filesystem ReadDirStatFS
|
||||
}
|
||||
|
||||
// Directory displays a list of files within a particular directory and
|
||||
// file system.
|
||||
type Directory struct {
|
||||
container
|
||||
entity tomo.Entity
|
||||
|
||||
scroll image.Point
|
||||
contentBounds image.Rectangle
|
||||
|
||||
history []historyEntry
|
||||
historyIndex int
|
||||
|
||||
onChoose func (file string)
|
||||
onScrollBoundsChange func ()
|
||||
}
|
||||
|
||||
// NewDirectory creates a new directory view. If within is nil, it will use
|
||||
// the OS file system.
|
||||
func NewDirectory (
|
||||
location string,
|
||||
within ReadDirStatFS,
|
||||
) (
|
||||
element *Directory,
|
||||
err error,
|
||||
) {
|
||||
element = &Directory { }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.container.entity = element.entity
|
||||
element.minimumSize = element.updateMinimumSize
|
||||
element.init()
|
||||
err = element.SetLocation(location, within)
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Directory) Draw (destination art.Canvas) {
|
||||
rocks := make([]image.Rectangle, element.entity.CountChildren())
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
rocks[index] = element.entity.Child(index).Entity().Bounds()
|
||||
}
|
||||
|
||||
tiles := shatter.Shatter(element.entity.Bounds(), rocks...)
|
||||
for _, tile := range tiles {
|
||||
element.DrawBackground(art.Cut(destination, tile))
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Directory) Layout () {
|
||||
if element.scroll.Y > element.maxScrollHeight() {
|
||||
element.scroll.Y = element.maxScrollHeight()
|
||||
}
|
||||
|
||||
margin := element.entity.Theme().Margin(tomo.PatternPinboard, directoryCase)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternPinboard, directoryCase)
|
||||
bounds := padding.Apply(element.entity.Bounds())
|
||||
element.contentBounds = image.Rectangle { }
|
||||
|
||||
dot := bounds.Min.Sub(element.scroll)
|
||||
xStart := dot.X
|
||||
rowHeight := 0
|
||||
|
||||
nextLine := func () {
|
||||
dot.X = xStart
|
||||
dot.Y += margin.Y
|
||||
dot.Y += rowHeight
|
||||
rowHeight = 0
|
||||
}
|
||||
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
child := element.entity.Child(index)
|
||||
entry := element.scratch[child]
|
||||
|
||||
width := int(entry.minBreadth)
|
||||
height := int(entry.minSize)
|
||||
if width + dot.X > bounds.Max.X {
|
||||
nextLine()
|
||||
}
|
||||
if typedChild, ok := child.(ability.Flexible); ok {
|
||||
height = typedChild.FlexibleHeightFor(width)
|
||||
}
|
||||
if rowHeight < height {
|
||||
rowHeight = height
|
||||
}
|
||||
|
||||
childBounds := tomo.Bounds (
|
||||
dot.X, dot.Y,
|
||||
width, height)
|
||||
element.entity.PlaceChild(index, childBounds)
|
||||
element.contentBounds = element.contentBounds.Union(childBounds)
|
||||
|
||||
dot.X += width + margin.X
|
||||
}
|
||||
|
||||
element.contentBounds =
|
||||
element.contentBounds.Sub(element.contentBounds.Min)
|
||||
|
||||
element.entity.NotifyScrollBoundsChange()
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Directory) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
element.selectNone()
|
||||
}
|
||||
|
||||
func (element *Directory) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) { }
|
||||
|
||||
func (element *Directory) HandleChildMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
child tomo.Element,
|
||||
) {
|
||||
element.selectNone()
|
||||
if child, ok := child.(ability.Selectable); ok {
|
||||
index := element.entity.IndexOf(child)
|
||||
element.entity.SelectChild(index, true)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Directory) HandleChildMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
child tomo.Element,
|
||||
) { }
|
||||
|
||||
func (element *Directory) HandleChildFlexibleHeightChange (child ability.Flexible) {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// ScrollContentBounds returns the full content size of the element.
|
||||
func (element *Directory) ScrollContentBounds () image.Rectangle {
|
||||
return element.contentBounds
|
||||
}
|
||||
|
||||
// ScrollViewportBounds returns the size and position of the element's
|
||||
// viewport relative to ScrollBounds.
|
||||
func (element *Directory) ScrollViewportBounds () image.Rectangle {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternPinboard, directoryCase)
|
||||
bounds := padding.Apply(element.entity.Bounds())
|
||||
bounds = bounds.Sub(bounds.Min).Add(element.scroll)
|
||||
return bounds
|
||||
}
|
||||
|
||||
// ScrollTo scrolls the viewport to the specified point relative to
|
||||
// ScrollBounds.
|
||||
func (element *Directory) ScrollTo (position image.Point) {
|
||||
if position.Y < 0 {
|
||||
position.Y = 0
|
||||
}
|
||||
maxScrollHeight := element.maxScrollHeight()
|
||||
if position.Y > maxScrollHeight {
|
||||
position.Y = maxScrollHeight
|
||||
}
|
||||
element.scroll = position
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// OnScrollBoundsChange sets a function to be called when the element's viewport
|
||||
// bounds, content bounds, or scroll axes change.
|
||||
func (element *Directory) OnScrollBoundsChange (callback func ()) {
|
||||
element.onScrollBoundsChange = callback
|
||||
}
|
||||
|
||||
// ScrollAxes returns the supported axes for scrolling.
|
||||
func (element *Directory) ScrollAxes () (horizontal, vertical bool) {
|
||||
return false, true
|
||||
}
|
||||
|
||||
func (element *Directory) DrawBackground (destination art.Canvas) {
|
||||
element.entity.Theme().Pattern(tomo.PatternPinboard, tomo.State { }, directoryCase).
|
||||
Draw(destination, element.entity.Bounds())
|
||||
}
|
||||
|
||||
func (element *Directory) HandleThemeChange () {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// Location returns the directory's location and filesystem.
|
||||
func (element *Directory) Location () (string, ReadDirStatFS) {
|
||||
if len(element.history) < 1 { return "", nil }
|
||||
current := element.history[element.historyIndex]
|
||||
return current.location, current.filesystem
|
||||
}
|
||||
|
||||
// SetLocation sets the directory's location and filesystem. If within is nil,
|
||||
// it will use the OS file system.
|
||||
func (element *Directory) SetLocation (
|
||||
location string,
|
||||
within ReadDirStatFS,
|
||||
) error {
|
||||
if within == nil {
|
||||
within = defaultFS { }
|
||||
}
|
||||
element.scroll = image.Point { }
|
||||
|
||||
if element.history != nil {
|
||||
element.historyIndex ++
|
||||
}
|
||||
element.history = append (
|
||||
element.history[:element.historyIndex],
|
||||
historyEntry { location, within })
|
||||
return element.Update()
|
||||
}
|
||||
|
||||
// Backward goes back a directory in history
|
||||
func (element *Directory) Backward () (bool, error) {
|
||||
if element.historyIndex > 1 {
|
||||
element.historyIndex --
|
||||
return true, element.Update()
|
||||
} else {
|
||||
return false, nil
|
||||
}
|
||||
}
|
||||
|
||||
// Forward goes forward a directory in history
|
||||
func (element *Directory) Forward () (bool, error) {
|
||||
if element.historyIndex < len(element.history) - 1 {
|
||||
element.historyIndex ++
|
||||
return true, element.Update()
|
||||
} else {
|
||||
return false, nil
|
||||
}
|
||||
}
|
||||
|
||||
// Update refreshes the directory's contents.
|
||||
func (element *Directory) Update () error {
|
||||
location, filesystem := element.Location()
|
||||
entries, err := filesystem.ReadDir(location)
|
||||
|
||||
children := make([]tomo.Element, len(entries))
|
||||
for index, entry := range entries {
|
||||
filePath := filepath.Join(location, entry.Name())
|
||||
file, _ := NewFile(filePath, filesystem)
|
||||
file.OnChoose (func () {
|
||||
if element.onChoose != nil {
|
||||
element.onChoose(filePath)
|
||||
}
|
||||
})
|
||||
|
||||
children[index] = file
|
||||
}
|
||||
|
||||
element.DisownAll()
|
||||
element.Adopt(children...)
|
||||
return err
|
||||
}
|
||||
|
||||
// OnChoose sets a function to be called when the user double-clicks a file or
|
||||
// sub-directory within the directory view.
|
||||
func (element *Directory) OnChoose (callback func (file string)) {
|
||||
element.onChoose = callback
|
||||
}
|
||||
|
||||
func (element *Directory) selectNone () {
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
element.entity.SelectChild(index, false)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Directory) maxScrollHeight () (height int) {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternSunken, directoryCase)
|
||||
viewportHeight := element.entity.Bounds().Dy() - padding.Vertical()
|
||||
height = element.contentBounds.Dy() - viewportHeight
|
||||
if height < 0 { height = 0 }
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
func (element *Directory) updateMinimumSize () {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternPinboard, directoryCase)
|
||||
minimumWidth := 0
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
width, height := element.entity.ChildMinimumSize(index)
|
||||
if width > minimumWidth {
|
||||
minimumWidth = width
|
||||
}
|
||||
|
||||
key := element.entity.Child(index)
|
||||
entry := element.scratch[key]
|
||||
entry.minSize = float64(height)
|
||||
entry.minBreadth = float64(width)
|
||||
element.scratch[key] = entry
|
||||
}
|
||||
element.entity.SetMinimumSize (
|
||||
minimumWidth + padding.Horizontal(),
|
||||
padding.Vertical())
|
||||
}
|
|
@ -1,3 +1,6 @@
|
|||
// Package elements provides standard elements that are commonly used in GUI
|
||||
// applications.
|
||||
// Package elements provides several standard interfaces that elements can
|
||||
// fulfill in order to inform other elements of their capabilities and what
|
||||
// events they are able to process. Sub-packages of this package provide
|
||||
// pre-made standard elements, as well as tools that can be used to easily
|
||||
// create more.
|
||||
package elements
|
||||
|
|
|
@ -1,211 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "art"
|
||||
import "tomo/ability"
|
||||
import "art/shatter"
|
||||
|
||||
var documentCase = tomo.C("tomo", "document")
|
||||
|
||||
// Document is a scrollable container capcable of laying out flexible child
|
||||
// elements. Children can be added either inline (similar to an HTML/CSS inline
|
||||
// element), or expanding (similar to an HTML/CSS block element).
|
||||
type Document struct {
|
||||
container
|
||||
entity tomo.Entity
|
||||
|
||||
scroll image.Point
|
||||
contentBounds image.Rectangle
|
||||
|
||||
onScrollBoundsChange func ()
|
||||
}
|
||||
|
||||
// NewDocument creates a new document container.
|
||||
func NewDocument (children ...tomo.Element) (element *Document) {
|
||||
element = &Document { }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.container.entity = element.entity
|
||||
element.minimumSize = element.updateMinimumSize
|
||||
element.init()
|
||||
element.Adopt(children...)
|
||||
return
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Document) Draw (destination art.Canvas) {
|
||||
rocks := make([]image.Rectangle, element.entity.CountChildren())
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
rocks[index] = element.entity.Child(index).Entity().Bounds()
|
||||
}
|
||||
|
||||
tiles := shatter.Shatter(element.entity.Bounds(), rocks...)
|
||||
for _, tile := range tiles {
|
||||
element.entity.DrawBackground(art.Cut(destination, tile))
|
||||
}
|
||||
}
|
||||
|
||||
// Layout causes this element to perform a layout operation.
|
||||
func (element *Document) Layout () {
|
||||
if element.scroll.Y > element.maxScrollHeight() {
|
||||
element.scroll.Y = element.maxScrollHeight()
|
||||
}
|
||||
|
||||
margin := element.entity.Theme().Margin(tomo.PatternBackground, documentCase)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternBackground, documentCase)
|
||||
bounds := padding.Apply(element.entity.Bounds())
|
||||
element.contentBounds = image.Rectangle { }
|
||||
|
||||
dot := bounds.Min.Sub(element.scroll)
|
||||
xStart := dot.X
|
||||
rowHeight := 0
|
||||
|
||||
nextLine := func () {
|
||||
dot.X = xStart
|
||||
dot.Y += margin.Y
|
||||
dot.Y += rowHeight
|
||||
rowHeight = 0
|
||||
}
|
||||
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
child := element.entity.Child(index)
|
||||
entry := element.scratch[child]
|
||||
|
||||
if dot.X > xStart && entry.expand {
|
||||
nextLine()
|
||||
}
|
||||
|
||||
width := int(entry.minBreadth)
|
||||
height := int(entry.minSize)
|
||||
if width + dot.X > bounds.Max.X && !entry.expand {
|
||||
nextLine()
|
||||
}
|
||||
if width < bounds.Dx() && entry.expand {
|
||||
width = bounds.Dx()
|
||||
}
|
||||
if typedChild, ok := child.(ability.Flexible); ok {
|
||||
height = typedChild.FlexibleHeightFor(width)
|
||||
}
|
||||
if rowHeight < height {
|
||||
rowHeight = height
|
||||
}
|
||||
|
||||
childBounds := tomo.Bounds (
|
||||
dot.X, dot.Y,
|
||||
width, height)
|
||||
element.entity.PlaceChild(index, childBounds)
|
||||
element.contentBounds = element.contentBounds.Union(childBounds)
|
||||
|
||||
if entry.expand {
|
||||
nextLine()
|
||||
} else {
|
||||
dot.X += width + margin.X
|
||||
}
|
||||
}
|
||||
|
||||
element.contentBounds =
|
||||
element.contentBounds.Sub(element.contentBounds.Min)
|
||||
|
||||
element.entity.NotifyScrollBoundsChange()
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
// Adopt adds one or more elements to the container, placing each on its own
|
||||
// line.
|
||||
func (element *Document) Adopt (children ...tomo.Element) {
|
||||
element.adopt(true, children...)
|
||||
}
|
||||
|
||||
// AdoptInline adds one or more elements to the container, packing multiple
|
||||
// elements onto the same line(s).
|
||||
func (element *Document) AdoptInline (children ...tomo.Element) {
|
||||
element.adopt(false, children...)
|
||||
}
|
||||
|
||||
func (element *Document) HandleChildFlexibleHeightChange (child ability.Flexible) {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// DrawBackground draws this element's background pattern to the specified
|
||||
// destination canvas.
|
||||
func (element *Document) DrawBackground (destination art.Canvas) {
|
||||
element.entity.DrawBackground(destination)
|
||||
}
|
||||
|
||||
func (element *Document) HandleThemeChange () {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// ScrollContentBounds returns the full content size of the element.
|
||||
func (element *Document) ScrollContentBounds () image.Rectangle {
|
||||
return element.contentBounds
|
||||
}
|
||||
|
||||
// ScrollViewportBounds returns the size and position of the element's
|
||||
// viewport relative to ScrollBounds.
|
||||
func (element *Document) ScrollViewportBounds () image.Rectangle {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternBackground, documentCase)
|
||||
bounds := padding.Apply(element.entity.Bounds())
|
||||
bounds = bounds.Sub(bounds.Min).Add(element.scroll)
|
||||
return bounds
|
||||
}
|
||||
|
||||
// ScrollTo scrolls the viewport to the specified point relative to
|
||||
// ScrollBounds.
|
||||
func (element *Document) ScrollTo (position image.Point) {
|
||||
if position.Y < 0 {
|
||||
position.Y = 0
|
||||
}
|
||||
maxScrollHeight := element.maxScrollHeight()
|
||||
if position.Y > maxScrollHeight {
|
||||
position.Y = maxScrollHeight
|
||||
}
|
||||
element.scroll = position
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// OnScrollBoundsChange sets a function to be called when the element's viewport
|
||||
// bounds, content bounds, or scroll axes change.
|
||||
func (element *Document) OnScrollBoundsChange (callback func ()) {
|
||||
element.onScrollBoundsChange = callback
|
||||
}
|
||||
|
||||
// ScrollAxes returns the supported axes for scrolling.
|
||||
func (element *Document) ScrollAxes () (horizontal, vertical bool) {
|
||||
return false, true
|
||||
}
|
||||
|
||||
func (element *Document) maxScrollHeight () (height int) {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternBackground, documentCase)
|
||||
viewportHeight := element.entity.Bounds().Dy() - padding.Vertical()
|
||||
height = element.contentBounds.Dy() - viewportHeight
|
||||
if height < 0 { height = 0 }
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Document) updateMinimumSize () {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternBackground, documentCase)
|
||||
minimumWidth := 0
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
width, height := element.entity.ChildMinimumSize(index)
|
||||
if width > minimumWidth {
|
||||
minimumWidth = width
|
||||
}
|
||||
|
||||
key := element.entity.Child(index)
|
||||
entry := element.scratch[key]
|
||||
entry.minSize = float64(height)
|
||||
entry.minBreadth = float64(width)
|
||||
element.scratch[key] = entry
|
||||
}
|
||||
element.entity.SetMinimumSize (
|
||||
minimumWidth + padding.Horizontal(),
|
||||
padding.Vertical())
|
||||
}
|
|
@ -0,0 +1,193 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
|
||||
// Element represents a basic on-screen object.
|
||||
type Element interface {
|
||||
// Bounds reports the element's bounding box. This must reflect the
|
||||
// bounding box of the last canvas given to the element by DrawTo.
|
||||
Bounds () (bounds image.Rectangle)
|
||||
|
||||
// DrawTo sets this element's canvas. This should only be called by the
|
||||
// parent element. This is typically a region of the parent element's
|
||||
// canvas.
|
||||
DrawTo (canvas canvas.Canvas)
|
||||
|
||||
// OnDamage sets a function to be called when an area of the element is
|
||||
// drawn on and should be pushed to the screen.
|
||||
OnDamage (callback func (region canvas.Canvas))
|
||||
|
||||
// MinimumSize specifies the minimum amount of pixels this element's
|
||||
// width and height may be set to. If the element is given a resize
|
||||
// event with dimensions smaller than this, it will use its minimum
|
||||
// instead of the offending dimension(s).
|
||||
MinimumSize () (width, height int)
|
||||
|
||||
// OnMinimumSizeChange sets a function to be called when the element's
|
||||
// minimum size is changed.
|
||||
OnMinimumSizeChange (callback func ())
|
||||
}
|
||||
|
||||
// Focusable represents an element that has keyboard navigation support. This
|
||||
// includes inputs, buttons, sliders, etc. as well as any elements that have
|
||||
// children (so keyboard navigation events can be propagated downward).
|
||||
type Focusable interface {
|
||||
Element
|
||||
|
||||
// Focused returns whether or not this element or any of its children
|
||||
// are currently focused.
|
||||
Focused () (selected bool)
|
||||
|
||||
// Focus focuses this element, if its parent element grants the
|
||||
// request.
|
||||
Focus ()
|
||||
|
||||
// HandleFocus causes this element to mark itself as focused. If the
|
||||
// element does not have children, it is disabled, or there are no more
|
||||
// selectable children in the given direction, it should return false
|
||||
// and do nothing. Otherwise, it should select itself and any children
|
||||
// (if applicable) and return true.
|
||||
HandleFocus (direction input.KeynavDirection) (accepted bool)
|
||||
|
||||
// HandleDeselection causes this element to mark itself and all of its
|
||||
// children as unfocused.
|
||||
HandleUnfocus ()
|
||||
|
||||
// OnFocusRequest sets a function to be called when this element wants
|
||||
// its parent element to focus it. Parent elements should return true if
|
||||
// the request was granted, and false if it was not. If the parent
|
||||
// element returns true, the element must act as if a HandleFocus call
|
||||
// was made with KeynavDirectionNeutral.
|
||||
OnFocusRequest (func () (granted bool))
|
||||
|
||||
// OnFocusMotionRequest sets a function to be called when this
|
||||
// element wants its parent element to focus the element behind or in
|
||||
// front of it, depending on the specified direction. Parent elements
|
||||
// should return true if the request was granted, and false if it was
|
||||
// not.
|
||||
OnFocusMotionRequest (func (direction input.KeynavDirection) (granted bool))
|
||||
}
|
||||
|
||||
// KeyboardTarget represents an element that can receive keyboard input.
|
||||
type KeyboardTarget interface {
|
||||
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 {
|
||||
Element
|
||||
|
||||
// Each of these handler methods is passed the position of the mouse
|
||||
// cursor at the time of the event as x, y.
|
||||
|
||||
// HandleMouseDown is called when a mouse button is pressed down on this
|
||||
// element.
|
||||
HandleMouseDown (x, y int, button input.Button)
|
||||
|
||||
// HandleMouseUp is called when a mouse button is released that was
|
||||
// originally pressed down on this element.
|
||||
HandleMouseUp (x, y int, button input.Button)
|
||||
|
||||
// HandleMouseMove 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.
|
||||
HandleMouseMove (x, y int)
|
||||
|
||||
// HandleScroll is called when the mouse is scrolled. The X and Y
|
||||
// direction of the scroll event are passed as deltaX and deltaY.
|
||||
HandleMouseScroll (x, y int, deltaX, deltaY float64)
|
||||
}
|
||||
|
||||
// Flexible represents an element who's preferred minimum height can change in
|
||||
// response to its width.
|
||||
type Flexible interface {
|
||||
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 flexible.
|
||||
FlexibleHeightFor (width int) (height int)
|
||||
|
||||
// OnFlexibleHeightChange sets a function to be called when the
|
||||
// parameters affecting this element's flexible height are changed.
|
||||
OnFlexibleHeightChange (callback func ())
|
||||
}
|
||||
|
||||
// Scrollable represents an element that can be scrolled. It acts as a viewport
|
||||
// through which its contents can be observed.
|
||||
type Scrollable interface {
|
||||
Element
|
||||
|
||||
// ScrollContentBounds returns the full content size of the element.
|
||||
ScrollContentBounds () (bounds image.Rectangle)
|
||||
|
||||
// ScrollViewportBounds returns the size and position of the element's
|
||||
// viewport relative to ScrollBounds.
|
||||
ScrollViewportBounds () (bounds 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)
|
||||
|
||||
// OnScrollBoundsChange sets a function to be called when the element's
|
||||
// ScrollContentBounds, ScrollViewportBounds, or ScrollAxes are changed.
|
||||
OnScrollBoundsChange (callback func ())
|
||||
}
|
||||
|
||||
// Collapsible represents an element who's minimum width and height can be
|
||||
// manually resized. Scrollable elements should implement this if possible.
|
||||
type Collapsible interface {
|
||||
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 {
|
||||
Element
|
||||
|
||||
// SetTheme sets the element's theme to something fulfilling the
|
||||
// theme.Theme interface.
|
||||
SetTheme (theme.Theme)
|
||||
}
|
||||
|
||||
// Configurable represents an element that can modify its behavior to fit within
|
||||
// a set of configuration parameters.
|
||||
type Configurable interface {
|
||||
Element
|
||||
|
||||
// SetConfig sets the element's configuration to something fulfilling
|
||||
// the config.Config interface.
|
||||
SetConfig (config.Config)
|
||||
}
|
217
elements/file.go
217
elements/file.go
|
@ -1,217 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "time"
|
||||
import "io/fs"
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
|
||||
var fileCase = tomo.C("files", "file")
|
||||
|
||||
// File displays an interactive visual representation of a file within any
|
||||
// file system.
|
||||
type File struct {
|
||||
entity tomo.Entity
|
||||
|
||||
lastClick time.Time
|
||||
pressed bool
|
||||
enabled bool
|
||||
iconID tomo.Icon
|
||||
filesystem fs.StatFS
|
||||
location string
|
||||
|
||||
onChoose func ()
|
||||
}
|
||||
|
||||
// NewFile creates a new file element. If within is nil, it will use the OS file
|
||||
// system
|
||||
func NewFile (
|
||||
location string,
|
||||
within fs.StatFS,
|
||||
) (
|
||||
element *File,
|
||||
err error,
|
||||
) {
|
||||
element = &File { enabled: true }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
err = element.SetLocation(location, within)
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *File) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *File) Draw (destination art.Canvas) {
|
||||
// background
|
||||
state := element.state()
|
||||
bounds := element.entity.Bounds()
|
||||
sink := element.entity.Theme().Sink(tomo.PatternButton, fileCase)
|
||||
element.entity.Theme().
|
||||
Pattern(tomo.PatternButton, state, fileCase).
|
||||
Draw(destination, bounds)
|
||||
|
||||
// icon
|
||||
icon := element.icon()
|
||||
if icon != nil {
|
||||
iconBounds := icon.Bounds()
|
||||
offset := image.Pt (
|
||||
(bounds.Dx() - iconBounds.Dx()) / 2,
|
||||
(bounds.Dy() - iconBounds.Dy()) / 2)
|
||||
if element.pressed {
|
||||
offset = offset.Add(sink)
|
||||
}
|
||||
icon.Draw (
|
||||
destination,
|
||||
element.entity.Theme().Color(tomo.ColorForeground, state, fileCase),
|
||||
bounds.Min.Add(offset))
|
||||
}
|
||||
}
|
||||
// Location returns the file's location and filesystem.
|
||||
func (element *File) Location () (string, fs.StatFS) {
|
||||
return element.location, element.filesystem
|
||||
}
|
||||
|
||||
// SetLocation sets the file's location and filesystem. If within is nil, it
|
||||
// will use the OS file system.
|
||||
func (element *File) SetLocation (
|
||||
location string,
|
||||
within fs.StatFS,
|
||||
) error {
|
||||
if within == nil {
|
||||
within = defaultFS { }
|
||||
}
|
||||
element.location = location
|
||||
element.filesystem = within
|
||||
return element.Update()
|
||||
}
|
||||
|
||||
// Update refreshes the element to match the file it represents.
|
||||
func (element *File) Update () error {
|
||||
info, err := element.filesystem.Stat(element.location)
|
||||
|
||||
if err != nil {
|
||||
element.iconID = tomo.IconError
|
||||
} else if info.IsDir() {
|
||||
element.iconID = tomo.IconDirectory
|
||||
} else {
|
||||
// TODO: choose icon based on file mime type
|
||||
element.iconID = tomo.IconFile
|
||||
}
|
||||
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
return err
|
||||
}
|
||||
|
||||
func (element *File) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if !element.Enabled() { return }
|
||||
if key == input.KeyEnter {
|
||||
element.pressed = true
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *File) HandleKeyUp (key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter && element.pressed {
|
||||
element.pressed = false
|
||||
if !element.Enabled() { return }
|
||||
element.entity.Invalidate()
|
||||
if element.onChoose != nil {
|
||||
element.onChoose()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *File) HandleFocusChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *File) HandleSelectionChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *File) OnChoose (callback func ()) {
|
||||
element.onChoose = callback
|
||||
}
|
||||
|
||||
// Focus gives this element input focus.
|
||||
func (element *File) Focus () {
|
||||
if !element.entity.Focused() { element.entity.Focus() }
|
||||
}
|
||||
|
||||
// Enabled returns whether this file is enabled or not.
|
||||
func (element *File) Enabled () bool {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this file is enabled or not.
|
||||
func (element *File) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *File) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if !element.Enabled() { return }
|
||||
if !element.entity.Focused() { element.Focus() }
|
||||
if button != input.ButtonLeft { return }
|
||||
element.pressed = true
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *File) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if button != input.ButtonLeft { return }
|
||||
element.pressed = false
|
||||
within := position.In(element.entity.Bounds())
|
||||
if time.Since(element.lastClick) < element.entity.Config().DoubleClickDelay() {
|
||||
if element.Enabled() && within && element.onChoose != nil {
|
||||
element.onChoose()
|
||||
}
|
||||
} else {
|
||||
element.lastClick = time.Now()
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *File) HandleThemeChange () {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *File) state () tomo.State {
|
||||
return tomo.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.entity.Focused(),
|
||||
Pressed: element.pressed,
|
||||
On: element.entity.Selected(),
|
||||
}
|
||||
}
|
||||
|
||||
func (element *File) icon () art.Icon {
|
||||
return element.entity.Theme().Icon(element.iconID, tomo.IconSizeLarge, fileCase)
|
||||
}
|
||||
|
||||
func (element *File) updateMinimumSize () {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternButton, fileCase)
|
||||
icon := element.icon()
|
||||
if icon == nil {
|
||||
element.entity.SetMinimumSize (
|
||||
padding.Horizontal(),
|
||||
padding.Vertical())
|
||||
} else {
|
||||
bounds := padding.Inverse().Apply(icon.Bounds())
|
||||
element.entity.SetMinimumSize(bounds.Dx(), bounds.Dy())
|
||||
}
|
||||
}
|
|
@ -1,25 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "os"
|
||||
import "io/fs"
|
||||
|
||||
// ReadDirStatFS is a combination of fs.ReadDirFS and fs.StatFS. It is the
|
||||
// minimum filesystem needed to satisfy a directory view.
|
||||
type ReadDirStatFS interface {
|
||||
fs.ReadDirFS
|
||||
fs.StatFS
|
||||
}
|
||||
|
||||
type defaultFS struct { }
|
||||
|
||||
func (defaultFS) Open (name string) (fs.File, error) {
|
||||
return os.Open(name)
|
||||
}
|
||||
|
||||
func (defaultFS) ReadDir (name string) ([]fs.DirEntry, error) {
|
||||
return os.ReadDir(name)
|
||||
}
|
||||
|
||||
func (defaultFS) Stat (name string) (fs.FileInfo, error) {
|
||||
return os.Stat(name)
|
||||
}
|
|
@ -4,48 +4,73 @@ import "time"
|
|||
import "math"
|
||||
import "image"
|
||||
import "image/color"
|
||||
import "tomo"
|
||||
import "art"
|
||||
import "art/shapes"
|
||||
|
||||
var clockCase = tomo.C("tomo", "clock")
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist/shapes"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// AnalogClock can display the time of day in an analog format.
|
||||
type AnalogClock struct {
|
||||
entity tomo.Entity
|
||||
time time.Time
|
||||
*core.Core
|
||||
core core.CoreControl
|
||||
time time.Time
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
}
|
||||
|
||||
// NewAnalogClock creates a new analog clock that displays the specified time.
|
||||
func NewAnalogClock (newTime time.Time) (element *AnalogClock) {
|
||||
element = &AnalogClock { }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.entity.SetMinimumSize(64, 64)
|
||||
element.theme.Case = theme.C("fun", "clock")
|
||||
element.Core, element.core = core.NewCore(element.draw)
|
||||
element.core.SetMinimumSize(64, 64)
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *AnalogClock) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
// SetTime changes the time that the clock displays.
|
||||
func (element *AnalogClock) SetTime (newTime time.Time) {
|
||||
if newTime == element.time { return }
|
||||
element.time = newTime
|
||||
element.redo()
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *AnalogClock) Draw (destination art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *AnalogClock) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
element.redo()
|
||||
}
|
||||
|
||||
state := tomo.State { }
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternSunken, state, clockCase)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternSunken, clockCase)
|
||||
pattern.Draw(destination, bounds)
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *AnalogClock) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *AnalogClock) redo () {
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *AnalogClock) draw () {
|
||||
bounds := element.Bounds()
|
||||
|
||||
state := theme.State { }
|
||||
pattern := element.theme.Pattern(theme.PatternSunken, state)
|
||||
padding := element.theme.Padding(theme.PatternSunken)
|
||||
pattern.Draw(element.core, bounds)
|
||||
|
||||
bounds = padding.Apply(bounds)
|
||||
|
||||
foreground := element.entity.Theme().Color(tomo.ColorForeground, state, clockCase)
|
||||
accent := element.entity.Theme().Color(tomo.ColorAccent, state, clockCase)
|
||||
foreground := element.theme.Color(theme.ColorForeground, state)
|
||||
accent := element.theme.Color(theme.ColorAccent, state)
|
||||
|
||||
for hour := 0; hour < 12; hour ++ {
|
||||
element.radialLine (
|
||||
destination,
|
||||
foreground,
|
||||
0.8, 0.9, float64(hour) / 6 * math.Pi)
|
||||
}
|
||||
|
@ -54,37 +79,34 @@ func (element *AnalogClock) Draw (destination art.Canvas) {
|
|||
minute := float64(element.time.Minute()) + second / 60
|
||||
hour := float64(element.time.Hour()) + minute / 60
|
||||
|
||||
element.radialLine(destination, foreground, 0, 0.5, (hour - 3) / 6 * math.Pi)
|
||||
element.radialLine(destination, foreground, 0, 0.7, (minute - 15) / 30 * math.Pi)
|
||||
element.radialLine(destination, accent, 0, 0.7, (second - 15) / 30 * math.Pi)
|
||||
element.radialLine(foreground, 0, 0.5, (hour - 3) / 6 * math.Pi)
|
||||
element.radialLine(foreground, 0, 0.7, (minute - 15) / 30 * math.Pi)
|
||||
element.radialLine(accent, 0, 0.7, (second - 15) / 30 * math.Pi)
|
||||
}
|
||||
|
||||
// SetTime changes the time that the clock displays.
|
||||
func (element *AnalogClock) SetTime (newTime time.Time) {
|
||||
if newTime == element.time { return }
|
||||
element.time = newTime
|
||||
element.entity.Invalidate()
|
||||
// FlexibleHeightFor constrains the clock's minimum size to a 1:1 aspect ratio.
|
||||
func (element *AnalogClock) FlexibleHeightFor (width int) (height int) {
|
||||
return width
|
||||
}
|
||||
|
||||
func (element *AnalogClock) HandleThemeChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
// OnFlexibleHeightChange sets a function to be called when the parameters
|
||||
// affecting the clock's flexible height change.
|
||||
func (element *AnalogClock) OnFlexibleHeightChange (func ()) { }
|
||||
|
||||
func (element *AnalogClock) radialLine (
|
||||
destination art.Canvas,
|
||||
source color.RGBA,
|
||||
inner float64,
|
||||
outer float64,
|
||||
radian float64,
|
||||
) {
|
||||
bounds := element.entity.Bounds()
|
||||
bounds := element.Bounds()
|
||||
width := float64(bounds.Dx()) / 2
|
||||
height := float64(bounds.Dy()) / 2
|
||||
min := bounds.Min.Add(image.Pt (
|
||||
min := element.Bounds().Min.Add(image.Pt (
|
||||
int(math.Cos(radian) * inner * width + width),
|
||||
int(math.Sin(radian) * inner * height + height)))
|
||||
max := bounds.Min.Add(image.Pt (
|
||||
max := element.Bounds().Min.Add(image.Pt (
|
||||
int(math.Cos(radian) * outer * width + width),
|
||||
int(math.Sin(radian) * outer * height + height)))
|
||||
shapes.ColorLine(destination, source, 1, min, max)
|
||||
shapes.ColorLine(element.core, source, 1, min, max)
|
||||
}
|
||||
|
|
|
@ -1,15 +1,12 @@
|
|||
package fun
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "art/artutil"
|
||||
import "tomo/elements/fun/music"
|
||||
|
||||
var pianoCase = tomo.C("tomo", "piano")
|
||||
var flatCase = tomo.C("tomo", "piano", "flatKey")
|
||||
var sharpCase = tomo.C("tomo", "piano", "sharpKey")
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/fun/music"
|
||||
|
||||
const pianoKeyWidth = 18
|
||||
|
||||
|
@ -20,14 +17,19 @@ type pianoKey struct {
|
|||
|
||||
// Piano is an element that can be used to input midi notes.
|
||||
type Piano struct {
|
||||
entity tomo.Entity
|
||||
|
||||
*core.Core
|
||||
*core.FocusableCore
|
||||
core core.CoreControl
|
||||
focusableControl core.FocusableCoreControl
|
||||
low, high music.Octave
|
||||
|
||||
config config.Wrapped
|
||||
theme theme.Wrapped
|
||||
|
||||
flatKeys []pianoKey
|
||||
sharpKeys []pianoKey
|
||||
contentBounds image.Rectangle
|
||||
|
||||
enabled bool
|
||||
pressed *pianoKey
|
||||
keynavPressed map[music.Note] bool
|
||||
|
||||
|
@ -38,7 +40,11 @@ type Piano struct {
|
|||
// NewPiano returns a new piano element with a lowest and highest octave,
|
||||
// inclusive. If low is greater than high, they will be swapped.
|
||||
func NewPiano (low, high music.Octave) (element *Piano) {
|
||||
if low > high { low, high = high, low }
|
||||
if low > high {
|
||||
temp := low
|
||||
low = high
|
||||
high = temp
|
||||
}
|
||||
|
||||
element = &Piano {
|
||||
low: low,
|
||||
|
@ -46,68 +52,17 @@ func NewPiano (low, high music.Octave) (element *Piano) {
|
|||
keynavPressed: make(map[music.Note] bool),
|
||||
}
|
||||
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.theme.Case = theme.C("fun", "piano")
|
||||
element.Core, element.core = core.NewCore (func () {
|
||||
element.recalculate()
|
||||
element.draw()
|
||||
})
|
||||
element.FocusableCore,
|
||||
element.focusableControl = core.NewFocusableCore(element.redo)
|
||||
element.updateMinimumSize()
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *Piano) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Piano) Draw (destination art.Canvas) {
|
||||
element.recalculate()
|
||||
|
||||
state := tomo.State {
|
||||
Focused: element.entity.Focused(),
|
||||
Disabled: !element.Enabled(),
|
||||
}
|
||||
|
||||
for _, key := range element.flatKeys {
|
||||
_, keynavPressed := element.keynavPressed[key.Note]
|
||||
element.drawFlat (
|
||||
destination,
|
||||
key.Rectangle,
|
||||
element.pressed != nil &&
|
||||
(*element.pressed).Note == key.Note || keynavPressed,
|
||||
state)
|
||||
}
|
||||
for _, key := range element.sharpKeys {
|
||||
_, keynavPressed := element.keynavPressed[key.Note]
|
||||
element.drawSharp (
|
||||
destination,
|
||||
key.Rectangle,
|
||||
element.pressed != nil &&
|
||||
(*element.pressed).Note == key.Note || keynavPressed,
|
||||
state)
|
||||
}
|
||||
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternPinboard, state, pianoCase)
|
||||
artutil.DrawShatter (
|
||||
destination, pattern, element.entity.Bounds(),
|
||||
element.contentBounds)
|
||||
}
|
||||
|
||||
// Focus gives this element input focus.
|
||||
func (element *Piano) Focus () {
|
||||
element.entity.Focus()
|
||||
}
|
||||
|
||||
// Enabled returns whether this piano can be played or not.
|
||||
func (element *Piano) Enabled () bool {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this piano can be played or not.
|
||||
func (element *Piano) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
|
||||
// OnPress sets a function to be called when a key is pressed.
|
||||
func (element *Piano) OnPress (callback func (note music.Note)) {
|
||||
element.onPress = callback
|
||||
|
@ -130,14 +85,16 @@ func (element *Piano) HandleMouseUp (x, y int, button input.Button) {
|
|||
element.onRelease((*element.pressed).Note)
|
||||
}
|
||||
element.pressed = nil
|
||||
element.entity.Invalidate()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *Piano) HandleMotion (x, y int) {
|
||||
func (element *Piano) HandleMouseMove (x, y int) {
|
||||
if element.pressed == nil { return }
|
||||
element.pressUnderMouseCursor(image.Pt(x, y))
|
||||
}
|
||||
|
||||
func (element *Piano) HandleMouseScroll (x, y int, deltaX, deltaY float64) { }
|
||||
|
||||
func (element *Piano) pressUnderMouseCursor (point image.Point) {
|
||||
// find out which note is being pressed
|
||||
newKey := (*pianoKey)(nil)
|
||||
|
@ -166,7 +123,7 @@ func (element *Piano) pressUnderMouseCursor (point image.Point) {
|
|||
if element.onPress != nil {
|
||||
element.onPress((*element.pressed).Note)
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
element.redo()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -226,7 +183,7 @@ func (element *Piano) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
|||
if element.onPress != nil {
|
||||
element.onPress(note)
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
element.redo()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -239,17 +196,30 @@ func (element *Piano) HandleKeyUp (key input.Key, modifiers input.Modifiers) {
|
|||
if element.onRelease != nil {
|
||||
element.onRelease(note)
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *Piano) HandleThemeChange () {
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *Piano) SetTheme (new theme.Theme) {
|
||||
if new == element.theme.Theme { return }
|
||||
element.theme.Theme = new
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.recalculate()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *Piano) SetConfig (new config.Config) {
|
||||
if new == element.config.Config { return }
|
||||
element.config.Config = new
|
||||
element.updateMinimumSize()
|
||||
element.recalculate()
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *Piano) updateMinimumSize () {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternPinboard, pianoCase)
|
||||
element.entity.SetMinimumSize (
|
||||
padding := element.theme.Padding(theme.PatternPinboard)
|
||||
element.core.SetMinimumSize (
|
||||
pianoKeyWidth * 7 * element.countOctaves() +
|
||||
padding.Horizontal(),
|
||||
64 + padding.Vertical())
|
||||
|
@ -267,12 +237,19 @@ func (element *Piano) countSharps () int {
|
|||
return element.countOctaves() * 5
|
||||
}
|
||||
|
||||
func (element *Piano) redo () {
|
||||
if element.core.HasImage() {
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Piano) recalculate () {
|
||||
element.flatKeys = make([]pianoKey, element.countFlats())
|
||||
element.sharpKeys = make([]pianoKey, element.countSharps())
|
||||
|
||||
padding := element.entity.Theme().Padding(tomo.PatternPinboard, pianoCase)
|
||||
bounds := padding.Apply(element.entity.Bounds())
|
||||
padding := element.theme.Padding(theme.PatternPinboard)
|
||||
bounds := padding.Apply(element.Bounds())
|
||||
|
||||
dot := bounds.Min
|
||||
note := element.low.Note(0)
|
||||
|
@ -303,24 +280,52 @@ func (element *Piano) recalculate () {
|
|||
}
|
||||
}
|
||||
|
||||
func (element *Piano) draw () {
|
||||
state := theme.State {
|
||||
Focused: element.Focused(),
|
||||
Disabled: !element.Enabled(),
|
||||
}
|
||||
|
||||
for _, key := range element.flatKeys {
|
||||
_, keynavPressed := element.keynavPressed[key.Note]
|
||||
element.drawFlat (
|
||||
key.Rectangle,
|
||||
element.pressed != nil &&
|
||||
(*element.pressed).Note == key.Note || keynavPressed,
|
||||
state)
|
||||
}
|
||||
for _, key := range element.sharpKeys {
|
||||
_, keynavPressed := element.keynavPressed[key.Note]
|
||||
element.drawSharp (
|
||||
key.Rectangle,
|
||||
element.pressed != nil &&
|
||||
(*element.pressed).Note == key.Note || keynavPressed,
|
||||
state)
|
||||
}
|
||||
|
||||
pattern := element.theme.Pattern(theme.PatternPinboard, state)
|
||||
artist.DrawShatter (
|
||||
element.core, pattern, element.contentBounds)
|
||||
}
|
||||
|
||||
func (element *Piano) drawFlat (
|
||||
destination art.Canvas,
|
||||
bounds image.Rectangle,
|
||||
pressed bool,
|
||||
state tomo.State,
|
||||
state theme.State,
|
||||
) {
|
||||
state.Pressed = pressed
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternButton, state, flatCase)
|
||||
pattern.Draw(destination, bounds)
|
||||
pattern := element.theme.Theme.Pattern (
|
||||
theme.PatternButton, state, theme.C("fun", "flatKey"))
|
||||
artist.DrawBounds(element.core, pattern, bounds)
|
||||
}
|
||||
|
||||
func (element *Piano) drawSharp (
|
||||
destination art.Canvas,
|
||||
bounds image.Rectangle,
|
||||
pressed bool,
|
||||
state tomo.State,
|
||||
state theme.State,
|
||||
) {
|
||||
state.Pressed = pressed
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternButton, state, sharpCase)
|
||||
pattern.Draw(destination, bounds)
|
||||
pattern := element.theme.Theme.Pattern (
|
||||
theme.PatternButton, state, theme.C("fun", "sharpKey"))
|
||||
artist.DrawBounds(element.core, pattern, bounds)
|
||||
}
|
||||
|
|
|
@ -1,80 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "art"
|
||||
|
||||
var iconCase = tomo.C("tomo", "icon")
|
||||
|
||||
// Icon is an element capable of displaying a singular icon.
|
||||
type Icon struct {
|
||||
entity tomo.Entity
|
||||
id tomo.Icon
|
||||
size tomo.IconSize
|
||||
}
|
||||
|
||||
// Icon creates a new icon element.
|
||||
func NewIcon (id tomo.Icon, size tomo.IconSize) (element *Icon) {
|
||||
element = &Icon {
|
||||
id: id,
|
||||
size: size,
|
||||
}
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.updateMinimumSize()
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *Icon) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// SetIcon sets the element's icon.
|
||||
func (element *Icon) SetIcon (id tomo.Icon, size tomo.IconSize) {
|
||||
element.id = id
|
||||
element.size = size
|
||||
if element.entity == nil { return }
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Icon) HandleThemeChange () {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Icon) Draw (destination art.Canvas) {
|
||||
if element.entity == nil { return }
|
||||
|
||||
bounds := element.entity.Bounds()
|
||||
state := tomo.State { }
|
||||
element.entity.Theme().
|
||||
Pattern(tomo.PatternBackground, state, iconCase).
|
||||
Draw(destination, bounds)
|
||||
icon := element.icon()
|
||||
if icon != nil {
|
||||
iconBounds := icon.Bounds()
|
||||
offset := image.Pt (
|
||||
(bounds.Dx() - iconBounds.Dx()) / 2,
|
||||
(bounds.Dy() - iconBounds.Dy()) / 2)
|
||||
icon.Draw (
|
||||
destination,
|
||||
element.entity.Theme().Color(tomo.ColorForeground, state, iconCase),
|
||||
bounds.Min.Add(offset))
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Icon) icon () art.Icon {
|
||||
return element.entity.Theme().Icon(element.id, element.size, iconCase)
|
||||
}
|
||||
|
||||
func (element *Icon) updateMinimumSize () {
|
||||
icon := element.icon()
|
||||
if icon == nil {
|
||||
element.entity.SetMinimumSize(0, 0)
|
||||
} else {
|
||||
bounds := icon.Bounds()
|
||||
element.entity.SetMinimumSize(bounds.Dx(), bounds.Dy())
|
||||
}
|
||||
}
|
|
@ -1,35 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "art"
|
||||
import "art/patterns"
|
||||
|
||||
// TODO: this element is lame need to make it better
|
||||
|
||||
// Image is an element capable of displaying an image.
|
||||
type Image struct {
|
||||
entity tomo.Entity
|
||||
buffer art.Canvas
|
||||
}
|
||||
|
||||
// NewImage creates a new image element.
|
||||
func NewImage (image image.Image) (element *Image) {
|
||||
element = &Image { buffer: art.FromImage(image) }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
bounds := element.buffer.Bounds()
|
||||
element.entity.SetMinimumSize(bounds.Dx(), bounds.Dy())
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *Image) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Image) Draw (destination art.Canvas) {
|
||||
if element.entity == nil { return }
|
||||
(patterns.Texture { Canvas: element.buffer }).
|
||||
Draw(destination, element.entity.Bounds())
|
||||
}
|
|
@ -1,206 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "golang.org/x/image/math/fixed"
|
||||
import "tomo"
|
||||
import "tomo/data"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "tomo/textdraw"
|
||||
|
||||
var labelCase = tomo.C("tomo", "label")
|
||||
|
||||
// Label is a simple text box.
|
||||
type Label struct {
|
||||
entity tomo.Entity
|
||||
|
||||
align textdraw.Align
|
||||
wrap bool
|
||||
text string
|
||||
drawer textdraw.Drawer
|
||||
|
||||
forcedColumns int
|
||||
forcedRows int
|
||||
minHeight int
|
||||
}
|
||||
|
||||
// NewLabel creates a new label.
|
||||
func NewLabel (text string) (element *Label) {
|
||||
element = &Label { }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal, labelCase))
|
||||
element.SetText(text)
|
||||
return
|
||||
}
|
||||
|
||||
// NewLabelWrapped creates a new label with text wrapping on.
|
||||
func NewLabelWrapped (text string) (element *Label) {
|
||||
element = NewLabel(text)
|
||||
element.SetWrap(true)
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *Label) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Label) Draw (destination art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
|
||||
if element.wrap {
|
||||
element.drawer.SetMaxWidth(bounds.Dx())
|
||||
element.drawer.SetMaxHeight(bounds.Dy())
|
||||
}
|
||||
|
||||
element.entity.DrawBackground(destination)
|
||||
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
foreground := element.entity.Theme().Color (
|
||||
tomo.ColorForeground,
|
||||
tomo.State { }, labelCase)
|
||||
element.drawer.Draw(destination, foreground, bounds.Min.Sub(textBounds.Min))
|
||||
}
|
||||
|
||||
// Copy copies the label's textto the clipboard.
|
||||
func (element *Label) Copy () {
|
||||
window := element.entity.Window()
|
||||
if window != nil {
|
||||
window.Copy(data.Bytes(data.MimePlain, []byte(element.text)))
|
||||
}
|
||||
}
|
||||
|
||||
// EmCollapse forces a minimum width and height upon the label. The width is
|
||||
// measured in emspaces, and the height is measured in lines. If a zero value is
|
||||
// given for a dimension, its minimum will be determined by the label's content.
|
||||
// If the label's content is greater than these dimensions, it will be truncated
|
||||
// to fit.
|
||||
func (element *Label) EmCollapse (columns int, rows int) {
|
||||
element.forcedColumns = columns
|
||||
element.forcedRows = rows
|
||||
element.updateMinimumSize()
|
||||
}
|
||||
|
||||
// FlexibleHeightFor returns the reccomended height for this element based on
|
||||
// the given width in order to allow the text to wrap properly.
|
||||
func (element *Label) FlexibleHeightFor (width int) (height int) {
|
||||
if element.wrap {
|
||||
return element.drawer.ReccomendedHeightFor(width)
|
||||
} else {
|
||||
return element.minHeight
|
||||
}
|
||||
}
|
||||
|
||||
// SetText sets the label's text.
|
||||
func (element *Label) SetText (text string) {
|
||||
if element.text == text { return }
|
||||
|
||||
element.text = text
|
||||
element.drawer.SetText([]rune(text))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// SetWrap sets wether or not the label's text wraps. If the text is set to
|
||||
// wrap, the element will have a minimum size of a single character and
|
||||
// automatically wrap its text. If the text is set to not wrap, the element will
|
||||
// have a minimum size that fits its text.
|
||||
func (element *Label) SetWrap (wrap bool) {
|
||||
if wrap == element.wrap { return }
|
||||
if !wrap {
|
||||
element.drawer.SetMaxWidth(0)
|
||||
element.drawer.SetMaxHeight(0)
|
||||
}
|
||||
element.wrap = wrap
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// SetAlign sets the alignment method of the label.
|
||||
func (element *Label) SetAlign (align textdraw.Align) {
|
||||
if align == element.align { return }
|
||||
element.align = align
|
||||
element.drawer.SetAlign(align)
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Label) HandleThemeChange () {
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal, labelCase))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Label) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if button == input.ButtonRight {
|
||||
element.contextMenu(position)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Label) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) { }
|
||||
|
||||
func (element *Label) contextMenu (position image.Point) {
|
||||
window := element.entity.Window()
|
||||
menu, err := window.NewMenu(image.Rectangle { position, position })
|
||||
if err != nil { return }
|
||||
|
||||
closeAnd := func (callback func ()) func () {
|
||||
return func () { callback(); menu.Close() }
|
||||
}
|
||||
|
||||
copyButton := NewButton("Copy")
|
||||
copyButton.ShowText(false)
|
||||
copyButton.SetIcon(tomo.IconCopy)
|
||||
copyButton.OnClick(closeAnd(element.Copy))
|
||||
|
||||
menu.Adopt (NewHBox (
|
||||
SpaceNone,
|
||||
copyButton,
|
||||
))
|
||||
copyButton.Focus()
|
||||
menu.Show()
|
||||
}
|
||||
|
||||
func (element *Label) updateMinimumSize () {
|
||||
var width, height int
|
||||
|
||||
if element.wrap {
|
||||
em := element.drawer.Em().Round()
|
||||
if em < 1 {
|
||||
em = element.entity.Theme().Padding(tomo.PatternBackground, labelCase)[0]
|
||||
}
|
||||
width, height = em, element.drawer.LineHeight().Round()
|
||||
element.entity.NotifyFlexibleHeightChange()
|
||||
} else {
|
||||
bounds := element.drawer.LayoutBounds()
|
||||
width, height = bounds.Dx(), bounds.Dy()
|
||||
}
|
||||
|
||||
if element.forcedColumns > 0 {
|
||||
width =
|
||||
element.drawer.Em().
|
||||
Mul(fixed.I(element.forcedColumns)).Floor()
|
||||
}
|
||||
|
||||
if element.forcedRows > 0 {
|
||||
height =
|
||||
element.drawer.LineHeight().
|
||||
Mul(fixed.I(element.forcedRows)).Floor()
|
||||
}
|
||||
|
||||
element.minHeight = height
|
||||
element.entity.SetMinimumSize(width, height)
|
||||
}
|
448
elements/list.go
448
elements/list.go
|
@ -1,448 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "tomo/ability"
|
||||
import "art/artutil"
|
||||
|
||||
type list struct {
|
||||
container
|
||||
entity tomo.Entity
|
||||
|
||||
c tomo.Case
|
||||
|
||||
enabled bool
|
||||
scroll image.Point
|
||||
contentBounds image.Rectangle
|
||||
selected int
|
||||
|
||||
forcedMinimumWidth int
|
||||
forcedMinimumHeight int
|
||||
|
||||
onClick func ()
|
||||
onSelectionChange func ()
|
||||
onScrollBoundsChange func ()
|
||||
}
|
||||
|
||||
type List struct {
|
||||
list
|
||||
}
|
||||
|
||||
type FlowList struct {
|
||||
list
|
||||
}
|
||||
|
||||
func NewList (children ...tomo.Element) (element *List) {
|
||||
element = &List { }
|
||||
element.c = tomo.C("tomo", "list")
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.container.entity = element.entity
|
||||
element.minimumSize = element.updateMinimumSize
|
||||
element.init(children...)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFlowList (children ...tomo.Element) (element *FlowList) {
|
||||
element = &FlowList { }
|
||||
element.c = tomo.C("tomo", "flowList")
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.container.entity = element.entity
|
||||
element.minimumSize = element.updateMinimumSize
|
||||
element.init(children...)
|
||||
return
|
||||
}
|
||||
|
||||
func (element *list) init (children ...tomo.Element) {
|
||||
element.selected = -1
|
||||
element.enabled = true
|
||||
element.container.init()
|
||||
element.Adopt(children...)
|
||||
}
|
||||
|
||||
func (element *list) Draw (destination art.Canvas) {
|
||||
rocks := make([]image.Rectangle, element.entity.CountChildren())
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
rocks[index] = element.entity.Child(index).Entity().Bounds()
|
||||
}
|
||||
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternSunken, element.state(), element.c)
|
||||
artutil.DrawShatter(destination, pattern, element.entity.Bounds(), rocks...)
|
||||
}
|
||||
|
||||
func (element *List) Layout () {
|
||||
if element.scroll.Y > element.maxScrollHeight() {
|
||||
element.scroll.Y = element.maxScrollHeight()
|
||||
}
|
||||
|
||||
margin := element.entity.Theme().Margin(tomo.PatternSunken, element.c)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternSunken, element.c)
|
||||
bounds := padding.Apply(element.entity.Bounds())
|
||||
element.contentBounds = image.Rectangle { }
|
||||
|
||||
dot := bounds.Min.Sub(element.scroll)
|
||||
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
child := element.entity.Child(index)
|
||||
entry := element.scratch[child]
|
||||
|
||||
width := bounds.Dx()
|
||||
height := int(entry.minSize)
|
||||
|
||||
childBounds := tomo.Bounds (
|
||||
dot.X, dot.Y,
|
||||
width, height)
|
||||
element.entity.PlaceChild(index, childBounds)
|
||||
element.contentBounds = element.contentBounds.Union(childBounds)
|
||||
|
||||
dot.Y += height
|
||||
dot.Y += margin.Y
|
||||
}
|
||||
|
||||
element.contentBounds =
|
||||
element.contentBounds.Sub(element.contentBounds.Min)
|
||||
|
||||
element.entity.NotifyScrollBoundsChange()
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *FlowList) Layout () {
|
||||
if element.scroll.Y > element.maxScrollHeight() {
|
||||
element.scroll.Y = element.maxScrollHeight()
|
||||
}
|
||||
|
||||
margin := element.entity.Theme().Margin(tomo.PatternSunken, element.c)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternSunken, element.c)
|
||||
bounds := padding.Apply(element.entity.Bounds())
|
||||
element.contentBounds = image.Rectangle { }
|
||||
|
||||
dot := bounds.Min.Sub(element.scroll)
|
||||
xStart := dot.X
|
||||
rowHeight := 0
|
||||
|
||||
nextLine := func () {
|
||||
dot.X = xStart
|
||||
dot.Y += margin.Y
|
||||
dot.Y += rowHeight
|
||||
rowHeight = 0
|
||||
}
|
||||
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
child := element.entity.Child(index)
|
||||
entry := element.scratch[child]
|
||||
|
||||
width := int(entry.minBreadth)
|
||||
height := int(entry.minSize)
|
||||
if width + dot.X > bounds.Max.X {
|
||||
nextLine()
|
||||
}
|
||||
if typedChild, ok := child.(ability.Flexible); ok {
|
||||
height = typedChild.FlexibleHeightFor(width)
|
||||
}
|
||||
if rowHeight < height {
|
||||
rowHeight = height
|
||||
}
|
||||
|
||||
childBounds := tomo.Bounds (
|
||||
dot.X, dot.Y,
|
||||
width, height)
|
||||
element.entity.PlaceChild(index, childBounds)
|
||||
element.contentBounds = element.contentBounds.Union(childBounds)
|
||||
|
||||
dot.X += width + margin.X
|
||||
}
|
||||
|
||||
element.contentBounds =
|
||||
element.contentBounds.Sub(element.contentBounds.Min)
|
||||
|
||||
element.entity.NotifyScrollBoundsChange()
|
||||
if element.onScrollBoundsChange != nil {
|
||||
element.onScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *list) Selected () ability.Selectable {
|
||||
if element.selected == -1 { return nil }
|
||||
child, ok := element.entity.Child(element.selected).(ability.Selectable)
|
||||
if !ok { return nil }
|
||||
return child
|
||||
}
|
||||
|
||||
func (element *list) Select (child ability.Selectable) {
|
||||
index := element.entity.IndexOf(child)
|
||||
if element.selected == index { return }
|
||||
element.selectNone()
|
||||
element.selected = index
|
||||
element.entity.SelectChild(index, true)
|
||||
if element.onSelectionChange != nil {
|
||||
element.onSelectionChange()
|
||||
}
|
||||
element.scrollToSelected()
|
||||
}
|
||||
|
||||
func (element *list) Enabled () bool {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
func (element *list) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *list) Focus () {
|
||||
element.entity.Focus()
|
||||
}
|
||||
|
||||
func (element *list) HandleFocusChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *list) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if !element.enabled { return }
|
||||
element.Focus()
|
||||
element.selectNone()
|
||||
}
|
||||
|
||||
func (element *list) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) { }
|
||||
|
||||
func (element *list) HandleChildMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
child tomo.Element,
|
||||
) {
|
||||
if !element.enabled { return }
|
||||
element.Focus()
|
||||
if child, ok := child.(ability.Selectable); ok {
|
||||
element.Select(child)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *list) HandleChildMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
child tomo.Element,
|
||||
) {
|
||||
if !position.In(child.Entity().Bounds()) { return }
|
||||
if element.onClick != nil {
|
||||
element.onClick()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *list) HandleChildFlexibleHeightChange (child ability.Flexible) {
|
||||
element.minimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
func (element *list) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if !element.Enabled() { return }
|
||||
index := -1
|
||||
switch key {
|
||||
case input.KeyUp, input.KeyLeft:
|
||||
index = element.selected - 1
|
||||
case input.KeyDown, input.KeyRight:
|
||||
index = element.selected + 1
|
||||
case input.KeyEnter:
|
||||
if element.onClick != nil {
|
||||
element.onClick()
|
||||
}
|
||||
}
|
||||
if index >= 0 && index < element.entity.CountChildren() {
|
||||
element.selectNone()
|
||||
element.selected = index
|
||||
element.entity.SelectChild(index, true)
|
||||
if element.onSelectionChange != nil {
|
||||
element.onSelectionChange()
|
||||
}
|
||||
element.scrollToSelected()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *list) HandleKeyUp(key input.Key, modifiers input.Modifiers) { }
|
||||
|
||||
func (element *list) DrawBackground (destination art.Canvas) {
|
||||
element.entity.DrawBackground(destination)
|
||||
}
|
||||
|
||||
func (element *list) HandleThemeChange () {
|
||||
element.minimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// Collapse forces a minimum width and height upon the list. If a zero value is
|
||||
// given for a dimension, its minimum will be determined by the list's content.
|
||||
// If the list's height goes beyond the forced size, it will need to be accessed
|
||||
// via scrolling. If an entry's width goes beyond the forced size, its text will
|
||||
// be truncated so that it fits.
|
||||
func (element *list) Collapse (width, height int) {
|
||||
if
|
||||
element.forcedMinimumWidth == width &&
|
||||
element.forcedMinimumHeight == height {
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
element.forcedMinimumWidth = width
|
||||
element.forcedMinimumHeight = height
|
||||
|
||||
element.minimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// ScrollContentBounds returns the full content size of the element.
|
||||
func (element *list) ScrollContentBounds () image.Rectangle {
|
||||
return element.contentBounds
|
||||
}
|
||||
|
||||
// ScrollViewportBounds returns the size and position of the element's
|
||||
// viewport relative to ScrollBounds.
|
||||
func (element *list) ScrollViewportBounds () image.Rectangle {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternSunken, element.c)
|
||||
bounds := padding.Apply(element.entity.Bounds())
|
||||
bounds = bounds.Sub(bounds.Min).Add(element.scroll)
|
||||
return bounds
|
||||
}
|
||||
|
||||
// ScrollTo scrolls the viewport to the specified point relative to
|
||||
// ScrollBounds.
|
||||
func (element *list) ScrollTo (position image.Point) {
|
||||
if position.Y < 0 {
|
||||
position.Y = 0
|
||||
}
|
||||
maxScrollHeight := element.maxScrollHeight()
|
||||
if position.Y > maxScrollHeight {
|
||||
position.Y = maxScrollHeight
|
||||
}
|
||||
element.scroll = position
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// OnScrollBoundsChange sets a function to be called when the element's viewport
|
||||
// bounds, content bounds, or scroll axes change.
|
||||
func (element *list) OnScrollBoundsChange (callback func ()) {
|
||||
element.onScrollBoundsChange = callback
|
||||
}
|
||||
|
||||
func (element *list) OnClick (callback func ()) {
|
||||
element.onClick = callback
|
||||
}
|
||||
|
||||
func (element *list) OnSelectionChange (callback func ()) {
|
||||
element.onSelectionChange = callback
|
||||
}
|
||||
|
||||
// ScrollAxes returns the supported axes for scrolling.
|
||||
func (element *list) ScrollAxes () (horizontal, vertical bool) {
|
||||
return false, true
|
||||
}
|
||||
|
||||
func (element *list) selectNone () {
|
||||
if element.selected >= 0 {
|
||||
element.entity.SelectChild(element.selected, false)
|
||||
if element.onSelectionChange != nil {
|
||||
element.onSelectionChange()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *list) scrollToSelected () {
|
||||
if element.selected < 0 { return }
|
||||
target := element.entity.Child(element.selected).Entity().Bounds()
|
||||
padding := element.entity.Theme().Padding(tomo.PatternSunken, element.c)
|
||||
bounds := padding.Apply(element.entity.Bounds())
|
||||
if target.Min.Y < bounds.Min.Y {
|
||||
element.scroll.Y -= bounds.Min.Y - target.Min.Y
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
} else if target.Max.Y > bounds.Max.Y {
|
||||
element.scroll.Y += target.Max.Y - bounds.Max.Y
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *list) state () tomo.State {
|
||||
return tomo.State {
|
||||
Focused: element.entity.Focused(),
|
||||
Disabled: !element.enabled,
|
||||
}
|
||||
}
|
||||
|
||||
func (element *list) maxScrollHeight () (height int) {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternSunken, element.c)
|
||||
viewportHeight := element.entity.Bounds().Dy() - padding.Vertical()
|
||||
height = element.contentBounds.Dy() - viewportHeight
|
||||
if height < 0 { height = 0 }
|
||||
return
|
||||
}
|
||||
|
||||
func (element *List) updateMinimumSize () {
|
||||
margin := element.entity.Theme().Margin(tomo.PatternSunken, element.c)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternSunken, element.c)
|
||||
|
||||
width := 0
|
||||
height := 0
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
if index > 0 { height += margin.Y }
|
||||
|
||||
child := element.entity.Child(index)
|
||||
entry := element.scratch[child]
|
||||
|
||||
entryWidth, entryHeight := element.entity.ChildMinimumSize(index)
|
||||
entry.minBreadth = float64(entryWidth)
|
||||
entry.minSize = float64(entryHeight)
|
||||
element.scratch[child] = entry
|
||||
|
||||
height += entryHeight
|
||||
if width < entryWidth { width = entryWidth }
|
||||
}
|
||||
|
||||
width += padding.Horizontal()
|
||||
height += padding.Vertical()
|
||||
|
||||
if element.forcedMinimumWidth > 0 {
|
||||
width = element.forcedMinimumWidth
|
||||
}
|
||||
if element.forcedMinimumHeight > 0 {
|
||||
height = element.forcedMinimumHeight
|
||||
}
|
||||
|
||||
element.entity.SetMinimumSize(width, height)
|
||||
}
|
||||
|
||||
func (element *FlowList) updateMinimumSize () {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternSunken, element.c)
|
||||
minimumWidth := 0
|
||||
for index := 0; index < element.entity.CountChildren(); index ++ {
|
||||
width, height := element.entity.ChildMinimumSize(index)
|
||||
if width > minimumWidth {
|
||||
minimumWidth = width
|
||||
}
|
||||
|
||||
key := element.entity.Child(index)
|
||||
entry := element.scratch[key]
|
||||
entry.minSize = float64(height)
|
||||
entry.minBreadth = float64(width)
|
||||
element.scratch[key] = entry
|
||||
}
|
||||
element.entity.SetMinimumSize (
|
||||
minimumWidth + padding.Horizontal(),
|
||||
padding.Vertical())
|
||||
}
|
|
@ -1,67 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "art"
|
||||
|
||||
var progressBarCase = tomo.C("tomo", "progressBar")
|
||||
|
||||
// ProgressBar displays a visual indication of how far along a task is.
|
||||
type ProgressBar struct {
|
||||
entity tomo.Entity
|
||||
progress float64
|
||||
}
|
||||
|
||||
// NewProgressBar creates a new progress bar displaying the given progress
|
||||
// level.
|
||||
func NewProgressBar (progress float64) (element *ProgressBar) {
|
||||
if progress < 0 { progress = 0 }
|
||||
if progress > 1 { progress = 1 }
|
||||
element = &ProgressBar { progress: progress }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.updateMinimumSize()
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *ProgressBar) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *ProgressBar) Draw (destination art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternSunken, tomo.State { }, progressBarCase)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternSunken, progressBarCase)
|
||||
pattern.Draw(destination, bounds)
|
||||
bounds = padding.Apply(bounds)
|
||||
meterBounds := image.Rect (
|
||||
bounds.Min.X, bounds.Min.Y,
|
||||
bounds.Min.X + int(float64(bounds.Dx()) * element.progress),
|
||||
bounds.Max.Y)
|
||||
mercury := element.entity.Theme().Pattern(tomo.PatternMercury, tomo.State { }, progressBarCase)
|
||||
mercury.Draw(destination, meterBounds)
|
||||
}
|
||||
|
||||
// SetProgress sets the progress level of the bar.
|
||||
func (element *ProgressBar) SetProgress (progress float64) {
|
||||
if progress < 0 { progress = 0 }
|
||||
if progress > 1 { progress = 1 }
|
||||
if progress == element.progress { return }
|
||||
element.progress = progress
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *ProgressBar) HandleThemeChange () {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *ProgressBar) updateMinimumSize() {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternSunken, progressBarCase)
|
||||
innerPadding := element.entity.Theme().Padding(tomo.PatternMercury, progressBarCase)
|
||||
element.entity.SetMinimumSize (
|
||||
padding.Horizontal() + innerPadding.Horizontal(),
|
||||
padding.Vertical() + innerPadding.Vertical())
|
||||
}
|
|
@ -1,240 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "tomo/ability"
|
||||
|
||||
var scrollCase = tomo.C("tomo", "scroll")
|
||||
|
||||
// ScrollMode specifies which sides of a Scroll have scroll bars.
|
||||
type ScrollMode int; const (
|
||||
ScrollNeither ScrollMode = 0
|
||||
ScrollVertical ScrollMode = 1
|
||||
ScrollHorizontal ScrollMode = 2
|
||||
ScrollBoth ScrollMode = ScrollVertical | ScrollHorizontal
|
||||
)
|
||||
|
||||
// Includes returns whether a scroll mode has been or'd with another scroll
|
||||
// mode.
|
||||
func (mode ScrollMode) Includes (sub ScrollMode) bool {
|
||||
return (mode & sub) > 0
|
||||
}
|
||||
|
||||
// Scroll adds scroll bars to any scrollable element. It also captures scroll
|
||||
// wheel input.
|
||||
type Scroll struct {
|
||||
entity tomo.Entity
|
||||
|
||||
child ability.Scrollable
|
||||
horizontal *ScrollBar
|
||||
vertical *ScrollBar
|
||||
}
|
||||
|
||||
// NewScroll creates a new scroll element.
|
||||
func NewScroll (mode ScrollMode, child ability.Scrollable) (element *Scroll) {
|
||||
element = &Scroll { }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
|
||||
if mode.Includes(ScrollHorizontal) {
|
||||
element.horizontal = NewHScrollBar()
|
||||
element.horizontal.OnScroll (func (viewport image.Point) {
|
||||
if element.child != nil {
|
||||
element.child.ScrollTo(viewport)
|
||||
}
|
||||
if element.vertical != nil {
|
||||
element.vertical.SetBounds (
|
||||
element.child.ScrollContentBounds(),
|
||||
element.child.ScrollViewportBounds())
|
||||
}
|
||||
})
|
||||
element.entity.Adopt(element.horizontal)
|
||||
}
|
||||
if mode.Includes(ScrollVertical) {
|
||||
element.vertical = NewVScrollBar()
|
||||
element.vertical.OnScroll (func (viewport image.Point) {
|
||||
if element.child != nil {
|
||||
element.child.ScrollTo(viewport)
|
||||
}
|
||||
if element.horizontal != nil {
|
||||
element.horizontal.SetBounds (
|
||||
element.child.ScrollContentBounds(),
|
||||
element.child.ScrollViewportBounds())
|
||||
}
|
||||
})
|
||||
element.entity.Adopt(element.vertical)
|
||||
}
|
||||
|
||||
element.Adopt(child)
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *Scroll) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Scroll) Draw (destination art.Canvas) {
|
||||
if element.horizontal != nil && element.vertical != nil {
|
||||
bounds := element.entity.Bounds()
|
||||
bounds.Min = image.Pt (
|
||||
bounds.Max.X - element.vertical.Entity().Bounds().Dx(),
|
||||
bounds.Max.Y - element.horizontal.Entity().Bounds().Dy())
|
||||
state := tomo.State { }
|
||||
deadArea := element.entity.Theme().Pattern(tomo.PatternDead, state, scrollCase)
|
||||
deadArea.Draw(art.Cut(destination, bounds), bounds)
|
||||
}
|
||||
}
|
||||
|
||||
// Layout causes this element to perform a layout operation.
|
||||
func (element *Scroll) Layout () {
|
||||
bounds := element.entity.Bounds()
|
||||
child := bounds
|
||||
|
||||
iHorizontal := element.entity.IndexOf(element.horizontal)
|
||||
iVertical := element.entity.IndexOf(element.vertical)
|
||||
iChild := element.entity.IndexOf(element.child)
|
||||
|
||||
var horizontal, vertical image.Rectangle
|
||||
|
||||
if element.horizontal != nil {
|
||||
_, hMinHeight := element.entity.ChildMinimumSize(iHorizontal)
|
||||
child.Max.Y -= hMinHeight
|
||||
}
|
||||
if element.vertical != nil {
|
||||
vMinWidth, _ := element.entity.ChildMinimumSize(iVertical)
|
||||
child.Max.X -= vMinWidth
|
||||
}
|
||||
|
||||
horizontal.Min.X = bounds.Min.X
|
||||
horizontal.Max.X = child.Max.X
|
||||
horizontal.Min.Y = child.Max.Y
|
||||
horizontal.Max.Y = bounds.Max.Y
|
||||
|
||||
vertical.Min.X = child.Max.X
|
||||
vertical.Max.X = bounds.Max.X
|
||||
vertical.Min.Y = bounds.Min.Y
|
||||
vertical.Max.Y = child.Max.Y
|
||||
|
||||
if element.horizontal != nil {
|
||||
element.entity.PlaceChild (iHorizontal, horizontal)
|
||||
}
|
||||
if element.vertical != nil {
|
||||
element.entity.PlaceChild(iVertical, vertical)
|
||||
}
|
||||
if element.child != nil {
|
||||
element.entity.PlaceChild(iChild, child)
|
||||
}
|
||||
}
|
||||
|
||||
// DrawBackground draws this element's background pattern to the specified
|
||||
// destination canvas.
|
||||
func (element *Scroll) DrawBackground (destination art.Canvas) {
|
||||
element.entity.DrawBackground(destination)
|
||||
}
|
||||
|
||||
// Adopt sets this element's child. If nil is passed, any child is removed.
|
||||
func (element *Scroll) Adopt (child ability.Scrollable) {
|
||||
if element.child != nil {
|
||||
element.entity.Disown(element.entity.IndexOf(element.child))
|
||||
}
|
||||
if child != nil {
|
||||
element.entity.Adopt(child)
|
||||
}
|
||||
element.child = child
|
||||
|
||||
element.updateEnabled()
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
// Child returns this element's child. If there is no child, this method will
|
||||
// return nil.
|
||||
func (element *Scroll) Child () ability.Scrollable {
|
||||
return element.child
|
||||
}
|
||||
|
||||
func (element *Scroll) HandleChildMinimumSizeChange (tomo.Element) {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
func (element *Scroll) HandleChildScrollBoundsChange (ability.Scrollable) {
|
||||
element.updateEnabled()
|
||||
viewportBounds := element.child.ScrollViewportBounds()
|
||||
contentBounds := element.child.ScrollContentBounds()
|
||||
if element.horizontal != nil {
|
||||
element.horizontal.SetBounds(contentBounds, viewportBounds)
|
||||
}
|
||||
if element.vertical != nil {
|
||||
element.vertical.SetBounds(contentBounds, viewportBounds)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Scroll) HandleScroll (
|
||||
position image.Point,
|
||||
deltaX, deltaY float64,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
horizontal, vertical := element.child.ScrollAxes()
|
||||
if !horizontal { deltaX = 0 }
|
||||
if !vertical { deltaY = 0 }
|
||||
element.scrollChildBy(int(deltaX), int(deltaY))
|
||||
}
|
||||
|
||||
func (element *Scroll) HandleThemeChange () {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
element.entity.InvalidateLayout()
|
||||
}
|
||||
|
||||
func (element *Scroll) updateMinimumSize () {
|
||||
var width, height int
|
||||
|
||||
if element.child != nil {
|
||||
width, height = element.entity.ChildMinimumSize (
|
||||
element.entity.IndexOf(element.child))
|
||||
}
|
||||
if element.horizontal != nil {
|
||||
hMinWidth, hMinHeight := element.entity.ChildMinimumSize (
|
||||
element.entity.IndexOf(element.horizontal))
|
||||
height += hMinHeight
|
||||
if hMinWidth > width {
|
||||
width = hMinWidth
|
||||
}
|
||||
}
|
||||
if element.vertical != nil {
|
||||
vMinWidth, vMinHeight := element.entity.ChildMinimumSize (
|
||||
element.entity.IndexOf(element.vertical))
|
||||
width += vMinWidth
|
||||
if vMinHeight > height {
|
||||
height = vMinHeight
|
||||
}
|
||||
}
|
||||
element.entity.SetMinimumSize(width, height)
|
||||
}
|
||||
|
||||
func (element *Scroll) updateEnabled () {
|
||||
horizontal, vertical := false, false
|
||||
if element.child != nil {
|
||||
horizontal, vertical = element.child.ScrollAxes()
|
||||
}
|
||||
if element.horizontal != nil {
|
||||
element.horizontal.SetEnabled(horizontal)
|
||||
}
|
||||
if element.vertical != nil {
|
||||
element.vertical.SetEnabled(vertical)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Scroll) scrollChildBy (x, y int) {
|
||||
if element.child == nil { return }
|
||||
scrollPoint :=
|
||||
element.child.ScrollViewportBounds().Min.
|
||||
Add(image.Pt(x, y))
|
||||
element.child.ScrollTo(scrollPoint)
|
||||
}
|
|
@ -1,321 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
|
||||
// ScrollBar is an element similar to Slider, but it has special behavior that
|
||||
// makes it well suited for controlling the viewport position on one axis of a
|
||||
// scrollable element. Instead of having a value from zero to one, it stores
|
||||
// viewport and content boundaries. When the user drags the scroll bar handle,
|
||||
// the scroll bar calls the OnScroll callback assigned to it with the position
|
||||
// the user is trying to move the handle to. A program can check to see if this
|
||||
// value is valid, move the viewport, and give the scroll bar the new viewport
|
||||
// bounds (which will then cause it to move the handle).
|
||||
//
|
||||
// Typically, you wont't want to use a ScrollBar by itself. A ScrollContainer is
|
||||
// better for most cases.
|
||||
type ScrollBar struct {
|
||||
entity tomo.Entity
|
||||
|
||||
c tomo.Case
|
||||
|
||||
vertical bool
|
||||
enabled bool
|
||||
dragging bool
|
||||
dragOffset image.Point
|
||||
track image.Rectangle
|
||||
bar image.Rectangle
|
||||
|
||||
contentBounds image.Rectangle
|
||||
viewportBounds image.Rectangle
|
||||
|
||||
onScroll func (viewport image.Point)
|
||||
}
|
||||
|
||||
// NewVScrollBar creates a new vertical scroll bar.
|
||||
func NewVScrollBar () (element *ScrollBar) {
|
||||
element = &ScrollBar {
|
||||
vertical: true,
|
||||
enabled: true,
|
||||
}
|
||||
element.c = tomo.C("tomo", "scrollBarVertical")
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.updateMinimumSize()
|
||||
return
|
||||
}
|
||||
|
||||
// NewHScrollBar creates a new horizontal scroll bar.
|
||||
func NewHScrollBar () (element *ScrollBar) {
|
||||
element = &ScrollBar {
|
||||
enabled: true,
|
||||
}
|
||||
element.c = tomo.C("tomo", "scrollBarHorizontal")
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.updateMinimumSize()
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *ScrollBar) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *ScrollBar) Draw (destination art.Canvas) {
|
||||
element.recalculate()
|
||||
|
||||
bounds := element.entity.Bounds()
|
||||
state := tomo.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Pressed: element.dragging,
|
||||
}
|
||||
element.entity.Theme().Pattern(tomo.PatternGutter, state, element.c).Draw (
|
||||
destination,
|
||||
bounds)
|
||||
element.entity.Theme().Pattern(tomo.PatternHandle, state, element.c).Draw (
|
||||
destination,
|
||||
element.bar)
|
||||
}
|
||||
|
||||
func (element *ScrollBar) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
velocity := element.entity.Config().ScrollVelocity()
|
||||
|
||||
if position.In(element.bar) {
|
||||
// the mouse is pressed down within the bar's handle
|
||||
element.dragging = true
|
||||
element.entity.Invalidate()
|
||||
element.dragOffset =
|
||||
position.Sub(element.bar.Min).
|
||||
Add(element.entity.Bounds().Min)
|
||||
element.dragTo(position)
|
||||
} else {
|
||||
// the mouse is pressed down within the bar's gutter
|
||||
switch button {
|
||||
case input.ButtonLeft:
|
||||
// start scrolling at this point, but set the offset to
|
||||
// the middle of the handle
|
||||
element.dragging = true
|
||||
element.dragOffset = element.fallbackDragOffset()
|
||||
element.dragTo(position)
|
||||
|
||||
case input.ButtonMiddle:
|
||||
// page up/down on middle click
|
||||
viewport := 0
|
||||
if element.vertical {
|
||||
viewport = element.viewportBounds.Dy()
|
||||
} else {
|
||||
viewport = element.viewportBounds.Dx()
|
||||
}
|
||||
if element.isAfterHandle(position) {
|
||||
element.scrollBy(viewport)
|
||||
} else {
|
||||
element.scrollBy(-viewport)
|
||||
}
|
||||
|
||||
case input.ButtonRight:
|
||||
// inch up/down on right click
|
||||
if element.isAfterHandle(position) {
|
||||
element.scrollBy(velocity)
|
||||
} else {
|
||||
element.scrollBy(-velocity)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollBar) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if element.dragging {
|
||||
element.dragging = false
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollBar) HandleMotion (position image.Point) {
|
||||
if element.dragging {
|
||||
element.dragTo(position)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollBar) HandleScroll (
|
||||
position image.Point,
|
||||
deltaX, deltaY float64,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if element.vertical {
|
||||
element.scrollBy(int(deltaY))
|
||||
} else {
|
||||
element.scrollBy(int(deltaX))
|
||||
}
|
||||
}
|
||||
|
||||
// SetEnabled sets whether or not the scroll bar can be interacted with.
|
||||
func (element *ScrollBar) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// Enabled returns whether or not the element is enabled.
|
||||
func (element *ScrollBar) Enabled () (enabled bool) {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
// SetBounds sets the content and viewport bounds of the scroll bar.
|
||||
func (element *ScrollBar) SetBounds (content, viewport image.Rectangle) {
|
||||
element.contentBounds = content
|
||||
element.viewportBounds = viewport
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// OnScroll sets a function to be called when the user tries to move the scroll
|
||||
// bar's handle. The callback is passed a point representing the new viewport
|
||||
// position. For the scroll bar's position to visually update, the callback must
|
||||
// check if the position is valid and call ScrollBar.SetBounds with the new
|
||||
// viewport bounds.
|
||||
func (element *ScrollBar) OnScroll (callback func (viewport image.Point)) {
|
||||
element.onScroll = callback
|
||||
}
|
||||
|
||||
func (element *ScrollBar) HandleThemeChange () {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *ScrollBar) isAfterHandle (point image.Point) bool {
|
||||
if element.vertical {
|
||||
return point.Y > element.bar.Min.Y
|
||||
} else {
|
||||
return point.X > element.bar.Min.X
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollBar) fallbackDragOffset () image.Point {
|
||||
if element.vertical {
|
||||
return element.entity.Bounds().Min.
|
||||
Add(image.Pt(0, element.bar.Dy() / 2))
|
||||
} else {
|
||||
return element.entity.Bounds().Min.
|
||||
Add(image.Pt(element.bar.Dx() / 2, 0))
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollBar) scrollBy (delta int) {
|
||||
deltaPoint := image.Point { }
|
||||
if element.vertical {
|
||||
deltaPoint.Y = delta
|
||||
} else {
|
||||
deltaPoint.X = delta
|
||||
}
|
||||
if element.onScroll != nil {
|
||||
element.onScroll(element.viewportBounds.Min.Add(deltaPoint))
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollBar) dragTo (point image.Point) {
|
||||
point = point.Sub(element.dragOffset)
|
||||
var scrollX, scrollY float64
|
||||
|
||||
if element.vertical {
|
||||
ratio :=
|
||||
float64(element.contentBounds.Dy()) /
|
||||
float64(element.track.Dy())
|
||||
scrollX = float64(element.viewportBounds.Min.X)
|
||||
scrollY = float64(point.Y) * ratio
|
||||
} else {
|
||||
ratio :=
|
||||
float64(element.contentBounds.Dx()) /
|
||||
float64(element.track.Dx())
|
||||
scrollX = float64(point.X) * ratio
|
||||
scrollY = float64(element.viewportBounds.Min.Y)
|
||||
}
|
||||
|
||||
if element.onScroll != nil {
|
||||
element.onScroll(image.Pt(int(scrollX), int(scrollY)))
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollBar) recalculate () {
|
||||
if element.vertical {
|
||||
element.recalculateVertical()
|
||||
} else {
|
||||
element.recalculateHorizontal()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollBar) recalculateVertical () {
|
||||
bounds := element.entity.Bounds()
|
||||
padding := element.entity.Theme().Padding(tomo.PatternGutter, element.c)
|
||||
element.track = padding.Apply(bounds)
|
||||
|
||||
contentBounds := element.contentBounds
|
||||
viewportBounds := element.viewportBounds
|
||||
if element.Enabled() {
|
||||
element.bar.Min.X = element.track.Min.X
|
||||
element.bar.Max.X = element.track.Max.X
|
||||
|
||||
ratio :=
|
||||
float64(element.track.Dy()) /
|
||||
float64(contentBounds.Dy())
|
||||
element.bar.Min.Y = int(float64(viewportBounds.Min.Y) * ratio)
|
||||
element.bar.Max.Y = int(float64(viewportBounds.Max.Y) * ratio)
|
||||
|
||||
element.bar.Min.Y += element.track.Min.Y
|
||||
element.bar.Max.Y += element.track.Min.Y
|
||||
}
|
||||
|
||||
// if the handle is out of bounds, don't display it
|
||||
if element.bar.Dy() >= element.track.Dy() {
|
||||
element.bar = image.Rectangle { }
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollBar) recalculateHorizontal () {
|
||||
bounds := element.entity.Bounds()
|
||||
padding := element.entity.Theme().Padding(tomo.PatternGutter, element.c)
|
||||
element.track = padding.Apply(bounds)
|
||||
|
||||
contentBounds := element.contentBounds
|
||||
viewportBounds := element.viewportBounds
|
||||
if element.Enabled() {
|
||||
element.bar.Min.Y = element.track.Min.Y
|
||||
element.bar.Max.Y = element.track.Max.Y
|
||||
|
||||
ratio :=
|
||||
float64(element.track.Dx()) /
|
||||
float64(contentBounds.Dx())
|
||||
element.bar.Min.X = int(float64(viewportBounds.Min.X) * ratio)
|
||||
element.bar.Max.X = int(float64(viewportBounds.Max.X) * ratio)
|
||||
|
||||
element.bar.Min.X += element.track.Min.X
|
||||
element.bar.Max.X += element.track.Min.X
|
||||
}
|
||||
|
||||
// if the handle is out of bounds, don't display it
|
||||
if element.bar.Dx() >= element.track.Dx() {
|
||||
element.bar = image.Rectangle { }
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ScrollBar) updateMinimumSize () {
|
||||
gutterPadding := element.entity.Theme().Padding(tomo.PatternGutter, element.c)
|
||||
handlePadding := element.entity.Theme().Padding(tomo.PatternHandle, element.c)
|
||||
if element.vertical {
|
||||
element.entity.SetMinimumSize (
|
||||
gutterPadding.Horizontal() + handlePadding.Horizontal(),
|
||||
gutterPadding.Vertical() + handlePadding.Vertical() * 2)
|
||||
} else {
|
||||
element.entity.SetMinimumSize (
|
||||
gutterPadding.Horizontal() + handlePadding.Horizontal() * 2,
|
||||
gutterPadding.Vertical() + handlePadding.Vertical())
|
||||
}
|
||||
}
|
|
@ -1,260 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
|
||||
// Slider is a slider control with a floating point value between zero and one.
|
||||
type Slider struct {
|
||||
slider
|
||||
}
|
||||
|
||||
// NewVSlider creates a new horizontal slider with the specified value.
|
||||
func NewVSlider (value float64) (element *Slider) {
|
||||
element = NewHSlider(value)
|
||||
element.vertical = true
|
||||
return
|
||||
}
|
||||
|
||||
// NewHSlider creates a new horizontal slider with the specified value.
|
||||
func NewHSlider (value float64) (element *Slider) {
|
||||
element = &Slider { }
|
||||
element.value = value
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.construct()
|
||||
return
|
||||
}
|
||||
|
||||
type slider struct {
|
||||
entity tomo.Entity
|
||||
|
||||
c tomo.Case
|
||||
|
||||
value float64
|
||||
vertical bool
|
||||
dragging bool
|
||||
enabled bool
|
||||
dragOffset int
|
||||
track image.Rectangle
|
||||
bar image.Rectangle
|
||||
|
||||
onSlide func ()
|
||||
onRelease func ()
|
||||
}
|
||||
|
||||
func (element *slider) construct () {
|
||||
element.enabled = true
|
||||
if element.vertical {
|
||||
element.c = tomo.C("tomo", "sliderVertical")
|
||||
} else {
|
||||
element.c = tomo.C("tomo", "sliderHorizontal")
|
||||
}
|
||||
element.updateMinimumSize()
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *slider) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *slider) Draw (destination art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
element.track = element.entity.Theme().Padding(tomo.PatternGutter, element.c).Apply(bounds)
|
||||
if element.vertical {
|
||||
barSize := element.track.Dx()
|
||||
element.bar = image.Rect(0, 0, barSize, barSize).Add(element.track.Min)
|
||||
barOffset :=
|
||||
float64(element.track.Dy() - barSize) *
|
||||
(1 - element.value)
|
||||
element.bar = element.bar.Add(image.Pt(0, int(barOffset)))
|
||||
} else {
|
||||
barSize := element.track.Dy()
|
||||
element.bar = image.Rect(0, 0, barSize, barSize).Add(element.track.Min)
|
||||
barOffset :=
|
||||
float64(element.track.Dx() - barSize) *
|
||||
element.value
|
||||
element.bar = element.bar.Add(image.Pt(int(barOffset), 0))
|
||||
}
|
||||
|
||||
state := tomo.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.entity.Focused(),
|
||||
Pressed: element.dragging,
|
||||
}
|
||||
element.entity.Theme().Pattern(tomo.PatternGutter, state, element.c).Draw(destination, bounds)
|
||||
element.entity.Theme().Pattern(tomo.PatternHandle, state, element.c).Draw(destination, element.bar)
|
||||
}
|
||||
|
||||
// Focus gives this element input focus.
|
||||
func (element *slider) Focus () {
|
||||
if !element.entity.Focused() { element.entity.Focus() }
|
||||
}
|
||||
|
||||
// Enabled returns whether this slider can be dragged or not.
|
||||
func (element *slider) Enabled () bool {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this slider can be dragged or not.
|
||||
func (element *slider) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *slider) HandleFocusChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *slider) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if !element.Enabled() { return }
|
||||
element.Focus()
|
||||
if button == input.ButtonLeft {
|
||||
element.dragging = true
|
||||
element.value = element.valueFor(position.X, position.Y)
|
||||
if element.onSlide != nil {
|
||||
element.onSlide()
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *slider) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if button != input.ButtonLeft || !element.dragging { return }
|
||||
element.dragging = false
|
||||
if element.onRelease != nil {
|
||||
element.onRelease()
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *slider) HandleMotion (position image.Point) {
|
||||
if element.dragging {
|
||||
element.dragging = true
|
||||
element.value = element.valueFor(position.X, position.Y)
|
||||
if element.onSlide != nil {
|
||||
element.onSlide()
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *slider) HandleScroll (
|
||||
position image.Point,
|
||||
deltaX, deltaY float64,
|
||||
modifiers input.Modifiers,
|
||||
) { }
|
||||
|
||||
func (element *slider) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
switch key {
|
||||
case input.KeyUp:
|
||||
element.changeValue(0.1)
|
||||
case input.KeyDown:
|
||||
element.changeValue(-0.1)
|
||||
case input.KeyRight:
|
||||
if element.vertical {
|
||||
element.changeValue(-0.1)
|
||||
} else {
|
||||
element.changeValue(0.1)
|
||||
}
|
||||
case input.KeyLeft:
|
||||
if element.vertical {
|
||||
element.changeValue(0.1)
|
||||
} else {
|
||||
element.changeValue(-0.1)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *slider) HandleKeyUp (key input.Key, modifiers input.Modifiers) { }
|
||||
|
||||
// Value returns the slider's value.
|
||||
func (element *slider) Value () (value float64) {
|
||||
return element.value
|
||||
}
|
||||
|
||||
// SetValue sets the slider's value.
|
||||
func (element *slider) SetValue (value float64) {
|
||||
if value < 0 { value = 0 }
|
||||
if value > 1 { value = 1 }
|
||||
|
||||
if element.value == value { return }
|
||||
|
||||
element.value = value
|
||||
if element.onRelease != nil {
|
||||
element.onRelease()
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// OnSlide sets a function to be called every time the slider handle changes
|
||||
// position while being dragged.
|
||||
func (element *slider) OnSlide (callback func ()) {
|
||||
element.onSlide = callback
|
||||
}
|
||||
|
||||
// OnRelease sets a function to be called when the handle stops being dragged.
|
||||
func (element *slider) OnRelease (callback func ()) {
|
||||
element.onRelease = callback
|
||||
}
|
||||
|
||||
func (element *slider) HandleThemeChange () {
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
|
||||
func (element *slider) changeValue (delta float64) {
|
||||
element.value += delta
|
||||
if element.value < 0 {
|
||||
element.value = 0
|
||||
}
|
||||
if element.value > 1 {
|
||||
element.value = 1
|
||||
}
|
||||
if element.onRelease != nil {
|
||||
element.onRelease()
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *slider) valueFor (x, y int) (value float64) {
|
||||
if element.vertical {
|
||||
value =
|
||||
float64(y - element.track.Min.Y - element.bar.Dy() / 2) /
|
||||
float64(element.track.Dy() - element.bar.Dy())
|
||||
value = 1 - value
|
||||
} else {
|
||||
value =
|
||||
float64(x - element.track.Min.X - element.bar.Dx() / 2) /
|
||||
float64(element.track.Dx() - element.bar.Dx())
|
||||
}
|
||||
|
||||
if value < 0 { value = 0 }
|
||||
if value > 1 { value = 1 }
|
||||
return
|
||||
}
|
||||
|
||||
func (element *slider) updateMinimumSize () {
|
||||
gutterPadding := element.entity.Theme().Padding(tomo.PatternGutter, element.c)
|
||||
handlePadding := element.entity.Theme().Padding(tomo.PatternHandle, element.c)
|
||||
if element.vertical {
|
||||
element.entity.SetMinimumSize (
|
||||
gutterPadding.Horizontal() + handlePadding.Horizontal(),
|
||||
gutterPadding.Vertical() + handlePadding.Vertical() * 2)
|
||||
} else {
|
||||
element.entity.SetMinimumSize (
|
||||
gutterPadding.Horizontal() + handlePadding.Horizontal() * 2,
|
||||
gutterPadding.Vertical() + handlePadding.Vertical())
|
||||
}
|
||||
}
|
|
@ -1,72 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "tomo"
|
||||
import "art"
|
||||
|
||||
var spacerCase = tomo.C("tomo", "spacer")
|
||||
|
||||
// Spacer can be used to put space between two elements..
|
||||
type Spacer struct {
|
||||
entity tomo.Entity
|
||||
line bool
|
||||
}
|
||||
|
||||
// NewSpacer creates a new spacer.
|
||||
func NewSpacer () (element *Spacer) {
|
||||
element = &Spacer { }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.updateMinimumSize()
|
||||
return
|
||||
}
|
||||
|
||||
// NewLine creates a new line separator.
|
||||
func NewLine () (element *Spacer) {
|
||||
element = NewSpacer()
|
||||
element.SetLine(true)
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *Spacer) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Spacer) Draw (destination art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
|
||||
if element.line {
|
||||
pattern := element.entity.Theme().Pattern (
|
||||
tomo.PatternLine,
|
||||
tomo.State { }, spacerCase)
|
||||
pattern.Draw(destination, bounds)
|
||||
} else {
|
||||
pattern := element.entity.Theme().Pattern (
|
||||
tomo.PatternBackground,
|
||||
tomo.State { }, spacerCase)
|
||||
pattern.Draw(destination, bounds)
|
||||
}
|
||||
}
|
||||
|
||||
/// SetLine sets whether or not the spacer will appear as a colored line.
|
||||
func (element *Spacer) SetLine (line bool) {
|
||||
if element.line == line { return }
|
||||
element.line = line
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Spacer) HandleThemeChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Spacer) updateMinimumSize () {
|
||||
if element.line {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternLine, spacerCase)
|
||||
element.entity.SetMinimumSize (
|
||||
padding.Horizontal(),
|
||||
padding.Vertical())
|
||||
} else {
|
||||
element.entity.SetMinimumSize(1, 1)
|
||||
}
|
||||
}
|
|
@ -1,206 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "tomo/textdraw"
|
||||
|
||||
var switchCase = tomo.C("tomo", "switch")
|
||||
|
||||
// Switch is a toggle-able on/off switch with an optional label. It is
|
||||
// functionally identical to Checkbox, but plays a different semantic role.
|
||||
type Switch struct {
|
||||
entity tomo.Entity
|
||||
drawer textdraw.Drawer
|
||||
|
||||
enabled bool
|
||||
pressed bool
|
||||
checked bool
|
||||
text string
|
||||
|
||||
onToggle func ()
|
||||
}
|
||||
|
||||
// NewSwitch creates a new switch with the specified label text.
|
||||
func NewSwitch (text string, on bool) (element *Switch) {
|
||||
element = &Switch {
|
||||
checked: on,
|
||||
text: text,
|
||||
enabled: true,
|
||||
}
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal, switchCase))
|
||||
element.drawer.SetText([]rune(text))
|
||||
element.updateMinimumSize()
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *Switch) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *Switch) Draw (destination art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
handleBounds := image.Rect(0, 0, bounds.Dy(), bounds.Dy()).Add(bounds.Min)
|
||||
gutterBounds := image.Rect(0, 0, bounds.Dy() * 2, bounds.Dy()).Add(bounds.Min)
|
||||
|
||||
state := tomo.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.entity.Focused(),
|
||||
Pressed: element.pressed,
|
||||
On: element.checked,
|
||||
}
|
||||
|
||||
element.entity.DrawBackground(destination)
|
||||
|
||||
if element.checked {
|
||||
handleBounds.Min.X += bounds.Dy()
|
||||
handleBounds.Max.X += bounds.Dy()
|
||||
if element.pressed {
|
||||
handleBounds.Min.X -= 2
|
||||
handleBounds.Max.X -= 2
|
||||
}
|
||||
} else {
|
||||
if element.pressed {
|
||||
handleBounds.Min.X += 2
|
||||
handleBounds.Max.X += 2
|
||||
}
|
||||
}
|
||||
|
||||
gutterPattern := element.entity.Theme().Pattern (
|
||||
tomo.PatternGutter, state, switchCase)
|
||||
gutterPattern.Draw(destination, gutterBounds)
|
||||
|
||||
handlePattern := element.entity.Theme().Pattern (
|
||||
tomo.PatternHandle, state, switchCase)
|
||||
handlePattern.Draw(destination, handleBounds)
|
||||
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
offset := bounds.Min.Add(image.Point {
|
||||
X: bounds.Dy() * 2 +
|
||||
element.entity.Theme().Margin(tomo.PatternBackground, switchCase).X,
|
||||
})
|
||||
|
||||
offset.Y -= textBounds.Min.Y
|
||||
offset.X -= textBounds.Min.X
|
||||
|
||||
foreground := element.entity.Theme().Color(tomo.ColorForeground, state, switchCase)
|
||||
element.drawer.Draw(destination, foreground, offset)
|
||||
}
|
||||
|
||||
func (element *Switch) HandleFocusChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Switch) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if !element.Enabled() { return }
|
||||
element.Focus()
|
||||
element.pressed = true
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Switch) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if button != input.ButtonLeft || !element.pressed { return }
|
||||
|
||||
element.pressed = false
|
||||
within := position.In(element.entity.Bounds())
|
||||
if within {
|
||||
element.checked = !element.checked
|
||||
}
|
||||
|
||||
element.entity.Invalidate()
|
||||
if within && element.onToggle != nil {
|
||||
element.onToggle()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Switch) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter {
|
||||
element.pressed = true
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Switch) HandleKeyUp (key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter && element.pressed {
|
||||
element.pressed = false
|
||||
element.checked = !element.checked
|
||||
element.entity.Invalidate()
|
||||
if element.onToggle != nil {
|
||||
element.onToggle()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// OnToggle sets the function to be called when the switch is flipped.
|
||||
func (element *Switch) OnToggle (callback func ()) {
|
||||
element.onToggle = callback
|
||||
}
|
||||
|
||||
// Value reports whether or not the switch is currently on.
|
||||
func (element *Switch) Value () (on bool) {
|
||||
return element.checked
|
||||
}
|
||||
|
||||
// Focus gives this element input focus.
|
||||
func (element *Switch) Focus () {
|
||||
if !element.entity.Focused() { element.entity.Focus() }
|
||||
}
|
||||
|
||||
// Enabled returns whether this switch is enabled or not.
|
||||
func (element *Switch) Enabled () bool {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this switch can be toggled or not.
|
||||
func (element *Switch) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// SetText sets the checkbox's label text.
|
||||
func (element *Switch) SetText (text string) {
|
||||
if element.text == text { return }
|
||||
|
||||
element.text = text
|
||||
element.drawer.SetText([]rune(text))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Switch) HandleThemeChange () {
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal, switchCase))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *Switch) updateMinimumSize () {
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
lineHeight := element.drawer.LineHeight().Round()
|
||||
|
||||
if element.text == "" {
|
||||
element.entity.SetMinimumSize(lineHeight * 2, lineHeight)
|
||||
} else {
|
||||
element.entity.SetMinimumSize (
|
||||
lineHeight * 2 +
|
||||
element.entity.Theme().Margin(tomo.PatternBackground, switchCase).X +
|
||||
textBounds.Dx(),
|
||||
lineHeight)
|
||||
}
|
||||
}
|
|
@ -4,73 +4,71 @@ import "fmt"
|
|||
import "time"
|
||||
import "image"
|
||||
import "image/color"
|
||||
import "tomo"
|
||||
import "art"
|
||||
import "art/shatter"
|
||||
import "tomo/textdraw"
|
||||
import "art/shapes"
|
||||
import "art/artutil"
|
||||
import "art/patterns"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/shatter"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/textdraw"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/defaultfont"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist/shapes"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist/patterns"
|
||||
|
||||
// Artist is an element that displays shapes and patterns drawn by the art
|
||||
// Artist is an element that displays shapes and patterns drawn by the artist
|
||||
// package in order to test it.
|
||||
type Artist struct {
|
||||
entity tomo.Entity
|
||||
*core.Core
|
||||
core core.CoreControl
|
||||
}
|
||||
|
||||
// NewArtist creates a new art test element.
|
||||
// NewArtist creates a new artist test element.
|
||||
func NewArtist () (element *Artist) {
|
||||
element = &Artist { }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.entity.SetMinimumSize(240, 240)
|
||||
element.Core, element.core = core.NewCore(element.draw)
|
||||
element.core.SetMinimumSize(240, 240)
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Artist) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
func (element *Artist) Draw (destination art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
patterns.Uhex(0x000000FF).Draw(destination, bounds)
|
||||
func (element *Artist) draw () {
|
||||
bounds := element.Bounds()
|
||||
patterns.Uhex(0x000000FF).Draw(element.core, bounds)
|
||||
|
||||
drawStart := time.Now()
|
||||
|
||||
// 0, 0 - 3, 0
|
||||
for x := 0; x < 4; x ++ {
|
||||
element.colorLines(destination, x + 1, element.cellAt(destination, x, 0).Bounds())
|
||||
element.colorLines(x + 1, element.cellAt(x, 0).Bounds())
|
||||
}
|
||||
|
||||
// 4, 0
|
||||
c40 := element.cellAt(destination, 4, 0)
|
||||
shapes.StrokeColorRectangle(c40, artutil.Hex(0x888888FF), c40.Bounds(), 1)
|
||||
c40 := element.cellAt(4, 0)
|
||||
shapes.StrokeColorRectangle(c40, artist.Hex(0x888888FF), c40.Bounds(), 1)
|
||||
shapes.ColorLine (
|
||||
c40, artutil.Hex(0xFF0000FF), 1,
|
||||
c40, artist.Hex(0xFF0000FF), 1,
|
||||
c40.Bounds().Min, c40.Bounds().Max)
|
||||
|
||||
// 0, 1
|
||||
c01 := element.cellAt(destination, 0, 1)
|
||||
shapes.StrokeColorRectangle(c01, artutil.Hex(0x888888FF), c01.Bounds(), 1)
|
||||
shapes.FillColorEllipse(destination, artutil.Hex(0x00FF00FF), c01.Bounds())
|
||||
c01 := element.cellAt(0, 1)
|
||||
shapes.StrokeColorRectangle(c01, artist.Hex(0x888888FF), c01.Bounds(), 1)
|
||||
shapes.FillColorEllipse(element.core, artist.Hex(0x00FF00FF), c01.Bounds())
|
||||
|
||||
// 1, 1 - 3, 1
|
||||
for x := 1; x < 4; x ++ {
|
||||
c := element.cellAt(destination, x, 1)
|
||||
c := element.cellAt(x, 1)
|
||||
shapes.StrokeColorRectangle (
|
||||
destination, artutil.Hex(0x888888FF),
|
||||
element.core, artist.Hex(0x888888FF),
|
||||
c.Bounds(), 1)
|
||||
shapes.StrokeColorEllipse (
|
||||
destination,
|
||||
element.core,
|
||||
[]color.RGBA {
|
||||
artutil.Hex(0xFF0000FF),
|
||||
artutil.Hex(0x00FF00FF),
|
||||
artutil.Hex(0xFF00FFFF),
|
||||
artist.Hex(0xFF0000FF),
|
||||
artist.Hex(0x00FF00FF),
|
||||
artist.Hex(0xFF00FFFF),
|
||||
} [x - 1],
|
||||
c.Bounds(), x)
|
||||
}
|
||||
|
||||
// 4, 1
|
||||
c41 := element.cellAt(destination, 4, 1)
|
||||
c41 := element.cellAt(4, 1)
|
||||
shatterPos := c41.Bounds().Min
|
||||
rocks := []image.Rectangle {
|
||||
image.Rect(3, 12, 13, 23).Add(shatterPos),
|
||||
|
@ -81,129 +79,117 @@ func (element *Artist) Draw (destination art.Canvas) {
|
|||
}
|
||||
tiles := shatter.Shatter(c41.Bounds(), rocks...)
|
||||
for index, tile := range tiles {
|
||||
[]art.Pattern {
|
||||
patterns.Uhex(0xFF0000FF),
|
||||
patterns.Uhex(0x00FF00FF),
|
||||
patterns.Uhex(0xFF00FFFF),
|
||||
patterns.Uhex(0xFFFF00FF),
|
||||
patterns.Uhex(0x00FFFFFF),
|
||||
} [index % 5].Draw(destination, tile)
|
||||
artist.DrawBounds (
|
||||
element.core,
|
||||
[]artist.Pattern {
|
||||
patterns.Uhex(0xFF0000FF),
|
||||
patterns.Uhex(0x00FF00FF),
|
||||
patterns.Uhex(0xFF00FFFF),
|
||||
patterns.Uhex(0xFFFF00FF),
|
||||
patterns.Uhex(0x00FFFFFF),
|
||||
} [index % 5], tile)
|
||||
}
|
||||
|
||||
// 0, 2
|
||||
c02 := element.cellAt(destination, 0, 2)
|
||||
shapes.StrokeColorRectangle(c02, artutil.Hex(0x888888FF), c02.Bounds(), 1)
|
||||
shapes.FillEllipse(c02, c41, c02.Bounds())
|
||||
c02 := element.cellAt(0, 2)
|
||||
shapes.StrokeColorRectangle(c02, artist.Hex(0x888888FF), c02.Bounds(), 1)
|
||||
shapes.FillEllipse(c02, c41)
|
||||
|
||||
// 1, 2
|
||||
c12 := element.cellAt(destination, 1, 2)
|
||||
shapes.StrokeColorRectangle(c12, artutil.Hex(0x888888FF), c12.Bounds(), 1)
|
||||
shapes.StrokeEllipse(c12, c41, c12.Bounds(), 5)
|
||||
c12 := element.cellAt(1, 2)
|
||||
shapes.StrokeColorRectangle(c12, artist.Hex(0x888888FF), c12.Bounds(), 1)
|
||||
shapes.StrokeEllipse(c12, c41, 5)
|
||||
|
||||
// 2, 2
|
||||
c22 := element.cellAt(destination, 2, 2)
|
||||
shapes.FillRectangle(c22, c41, c22.Bounds())
|
||||
c22 := element.cellAt(2, 2)
|
||||
shapes.FillRectangle(c22, c41)
|
||||
|
||||
// 3, 2
|
||||
c32 := element.cellAt(destination, 3, 2)
|
||||
shapes.StrokeRectangle(c32, c41, c32.Bounds(), 5)
|
||||
c32 := element.cellAt(3, 2)
|
||||
shapes.StrokeRectangle(c32, c41, 5)
|
||||
|
||||
// 4, 2
|
||||
c42 := element.cellAt(destination, 4, 2)
|
||||
c42 := element.cellAt(4, 2)
|
||||
|
||||
// 0, 3
|
||||
c03 := element.cellAt(destination, 0, 3)
|
||||
c03 := element.cellAt(0, 3)
|
||||
patterns.Border {
|
||||
Canvas: element.thingy(c42),
|
||||
Inset: art.Inset { 8, 8, 8, 8 },
|
||||
Inset: artist.Inset { 8, 8, 8, 8 },
|
||||
}.Draw(c03, c03.Bounds())
|
||||
|
||||
// 1, 3
|
||||
c13 := element.cellAt(destination, 1, 3)
|
||||
c13 := element.cellAt(1, 3)
|
||||
patterns.Border {
|
||||
Canvas: element.thingy(c42),
|
||||
Inset: art.Inset { 8, 8, 8, 8 },
|
||||
Inset: artist.Inset { 8, 8, 8, 8 },
|
||||
}.Draw(c13, c13.Bounds().Inset(10))
|
||||
|
||||
// 2, 3
|
||||
c23 := element.cellAt(destination, 2, 3)
|
||||
patterns.Border {
|
||||
Canvas: element.thingy(c42),
|
||||
Inset: art.Inset { 8, 8, 8, 8 },
|
||||
}.Draw(c23, c23.Bounds())
|
||||
patterns.Border {
|
||||
Canvas: element.thingy(c42),
|
||||
Inset: art.Inset { 8, 8, 8, 8 },
|
||||
}.Draw(art.Cut(c23, c23.Bounds().Inset(16)), c23.Bounds())
|
||||
|
||||
// how long did that take to render?
|
||||
drawTime := time.Since(drawStart)
|
||||
textDrawer := textdraw.Drawer { }
|
||||
textDrawer.SetFace(element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal,
|
||||
tomo.C("tomo", "art")))
|
||||
textDrawer.SetFace(defaultfont.FaceRegular)
|
||||
textDrawer.SetText ([]rune (fmt.Sprintf (
|
||||
"%dms\n%dus",
|
||||
drawTime.Milliseconds(),
|
||||
drawTime.Microseconds())))
|
||||
textDrawer.Draw (
|
||||
destination, artutil.Hex(0xFFFFFFFF),
|
||||
element.core, artist.Hex(0xFFFFFFFF),
|
||||
image.Pt(bounds.Min.X + 8, bounds.Max.Y - 24))
|
||||
}
|
||||
|
||||
func (element *Artist) colorLines (destination art.Canvas, weight int, bounds image.Rectangle) {
|
||||
func (element *Artist) colorLines (weight int, bounds image.Rectangle) {
|
||||
bounds = bounds.Inset(4)
|
||||
c := artutil.Hex(0xFFFFFFFF)
|
||||
shapes.ColorLine(destination, c, weight, bounds.Min, bounds.Max)
|
||||
c := artist.Hex(0xFFFFFFFF)
|
||||
shapes.ColorLine(element.core, c, weight, bounds.Min, bounds.Max)
|
||||
shapes.ColorLine (
|
||||
destination, c, weight,
|
||||
element.core, c, weight,
|
||||
image.Pt(bounds.Max.X, bounds.Min.Y),
|
||||
image.Pt(bounds.Min.X, bounds.Max.Y))
|
||||
shapes.ColorLine (
|
||||
destination, c, weight,
|
||||
element.core, c, weight,
|
||||
image.Pt(bounds.Max.X, bounds.Min.Y + 16),
|
||||
image.Pt(bounds.Min.X, bounds.Max.Y - 16))
|
||||
shapes.ColorLine (
|
||||
destination, c, weight,
|
||||
element.core, c, weight,
|
||||
image.Pt(bounds.Min.X, bounds.Min.Y + 16),
|
||||
image.Pt(bounds.Max.X, bounds.Max.Y - 16))
|
||||
shapes.ColorLine (
|
||||
destination, c, weight,
|
||||
element.core, c, weight,
|
||||
image.Pt(bounds.Min.X + 20, bounds.Min.Y),
|
||||
image.Pt(bounds.Max.X - 20, bounds.Max.Y))
|
||||
shapes.ColorLine (
|
||||
destination, c, weight,
|
||||
element.core, c, weight,
|
||||
image.Pt(bounds.Max.X - 20, bounds.Min.Y),
|
||||
image.Pt(bounds.Min.X + 20, bounds.Max.Y))
|
||||
shapes.ColorLine (
|
||||
destination, c, weight,
|
||||
element.core, c, weight,
|
||||
image.Pt(bounds.Min.X, bounds.Min.Y + bounds.Dy() / 2),
|
||||
image.Pt(bounds.Max.X, bounds.Min.Y + bounds.Dy() / 2))
|
||||
shapes.ColorLine (
|
||||
destination, c, weight,
|
||||
element.core, c, weight,
|
||||
image.Pt(bounds.Min.X + bounds.Dx() / 2, bounds.Min.Y),
|
||||
image.Pt(bounds.Min.X + bounds.Dx() / 2, bounds.Max.Y))
|
||||
}
|
||||
|
||||
func (element *Artist) cellAt (destination art.Canvas, x, y int) (art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
func (element *Artist) cellAt (x, y int) (canvas.Canvas) {
|
||||
bounds := element.Bounds()
|
||||
cellBounds := image.Rectangle { }
|
||||
cellBounds.Min = bounds.Min
|
||||
cellBounds.Max.X = bounds.Min.X + bounds.Dx() / 5
|
||||
cellBounds.Max.Y = bounds.Min.Y + (bounds.Dy() - 48) / 4
|
||||
return art.Cut (destination, cellBounds.Add (image.Pt (
|
||||
return canvas.Cut (element.core, cellBounds.Add (image.Pt (
|
||||
x * cellBounds.Dx(),
|
||||
y * cellBounds.Dy())))
|
||||
}
|
||||
|
||||
func (element *Artist) thingy (destination art.Canvas) (result art.Canvas) {
|
||||
func (element *Artist) thingy (destination canvas.Canvas) (result canvas.Canvas) {
|
||||
bounds := destination.Bounds()
|
||||
bounds = image.Rect(0, 0, 32, 32).Add(bounds.Min)
|
||||
shapes.FillColorRectangle(destination, artutil.Hex(0x440000FF), bounds)
|
||||
shapes.StrokeColorRectangle(destination, artutil.Hex(0xFF0000FF), bounds, 1)
|
||||
shapes.StrokeColorRectangle(destination, artutil.Hex(0x004400FF), bounds.Inset(4), 1)
|
||||
shapes.FillColorRectangle(destination, artutil.Hex(0x004444FF), bounds.Inset(12))
|
||||
shapes.StrokeColorRectangle(destination, artutil.Hex(0x888888FF), bounds.Inset(8), 1)
|
||||
return art.Cut(destination, bounds)
|
||||
shapes.FillColorRectangle(destination, artist.Hex(0x440000FF), bounds)
|
||||
shapes.StrokeColorRectangle(destination, artist.Hex(0xFF0000FF), bounds, 1)
|
||||
shapes.StrokeColorRectangle(destination, artist.Hex(0x004400FF), bounds.Inset(4), 1)
|
||||
shapes.FillColorRectangle(destination, artist.Hex(0x004444FF), bounds.Inset(12))
|
||||
shapes.StrokeColorRectangle(destination, artist.Hex(0x888888FF), bounds.Inset(8), 1)
|
||||
return canvas.Cut(destination, bounds)
|
||||
}
|
||||
|
|
|
@ -1,86 +1,94 @@
|
|||
package testing
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "art/shapes"
|
||||
import "art/artutil"
|
||||
|
||||
var mouseCase = tomo.C("tomo", "mouse")
|
||||
import "git.tebibyte.media/sashakoshka/tomo/input"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/theme"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/config"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/artist/shapes"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/core"
|
||||
|
||||
// Mouse is an element capable of testing mouse input. When the mouse is clicked
|
||||
// and dragged on it, it draws a trail.
|
||||
type Mouse struct {
|
||||
entity tomo.Entity
|
||||
pressed bool
|
||||
*core.Core
|
||||
core core.CoreControl
|
||||
drawing bool
|
||||
lastMousePos image.Point
|
||||
|
||||
config config.Config
|
||||
theme theme.Theme
|
||||
c theme.Case
|
||||
}
|
||||
|
||||
// NewMouse creates a new mouse test element.
|
||||
func NewMouse () (element *Mouse) {
|
||||
element = &Mouse { }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.entity.SetMinimumSize(32, 32)
|
||||
element = &Mouse { c: theme.C("testing", "mouse") }
|
||||
element.Core, element.core = core.NewCore(element.draw)
|
||||
element.core.SetMinimumSize(32, 32)
|
||||
return
|
||||
}
|
||||
|
||||
func (element *Mouse) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
// SetTheme sets the element's theme.
|
||||
func (element *Mouse) SetTheme (new theme.Theme) {
|
||||
element.theme = new
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *Mouse) Draw (destination art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
accent := element.entity.Theme().Color (
|
||||
tomo.ColorAccent,
|
||||
tomo.State { },
|
||||
mouseCase)
|
||||
shapes.FillColorRectangle(destination, accent, bounds)
|
||||
// SetConfig sets the element's configuration.
|
||||
func (element *Mouse) SetConfig (new config.Config) {
|
||||
element.config = new
|
||||
element.redo()
|
||||
}
|
||||
|
||||
func (element *Mouse) redo () {
|
||||
if !element.core.HasImage() { return }
|
||||
element.draw()
|
||||
element.core.DamageAll()
|
||||
}
|
||||
|
||||
func (element *Mouse) draw () {
|
||||
bounds := element.Bounds()
|
||||
accent := element.theme.Color (
|
||||
theme.ColorAccent,
|
||||
theme.State { },
|
||||
element.c)
|
||||
shapes.FillColorRectangle(element.core, accent, bounds)
|
||||
shapes.StrokeColorRectangle (
|
||||
destination,
|
||||
artutil.Hex(0x000000FF),
|
||||
element.core,
|
||||
artist.Hex(0x000000FF),
|
||||
bounds, 1)
|
||||
shapes.ColorLine (
|
||||
destination, artutil.Hex(0xFFFFFFFF), 1,
|
||||
element.core, artist.Hex(0xFFFFFFFF), 1,
|
||||
bounds.Min.Add(image.Pt(1, 1)),
|
||||
bounds.Min.Add(image.Pt(bounds.Dx() - 2, bounds.Dy() - 2)))
|
||||
shapes.ColorLine (
|
||||
destination, artutil.Hex(0xFFFFFFFF), 1,
|
||||
element.core, artist.Hex(0xFFFFFFFF), 1,
|
||||
bounds.Min.Add(image.Pt(1, bounds.Dy() - 2)),
|
||||
bounds.Min.Add(image.Pt(bounds.Dx() - 2, 1)))
|
||||
if element.pressed {
|
||||
midpoint := bounds.Min.Add(bounds.Max.Sub(bounds.Min).Div(2))
|
||||
shapes.ColorLine (
|
||||
destination, artutil.Hex(0x000000FF), 1,
|
||||
midpoint, element.lastMousePos)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *Mouse) HandleThemeChange (new tomo.Theme) {
|
||||
element.entity.Invalidate()
|
||||
func (element *Mouse) HandleMouseDown (x, y int, button input.Button) {
|
||||
element.drawing = true
|
||||
element.lastMousePos = image.Pt(x, y)
|
||||
}
|
||||
|
||||
func (element *Mouse) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
element.pressed = true
|
||||
element.lastMousePos = position
|
||||
element.entity.Invalidate()
|
||||
func (element *Mouse) HandleMouseUp (x, y int, button input.Button) {
|
||||
element.drawing = false
|
||||
mousePos := image.Pt(x, y)
|
||||
element.core.DamageRegion (shapes.ColorLine (
|
||||
element.core, artist.Hex(0x000000FF), 1,
|
||||
element.lastMousePos, mousePos))
|
||||
element.lastMousePos = mousePos
|
||||
}
|
||||
|
||||
func (element *Mouse) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
element.pressed = false
|
||||
element.entity.Invalidate()
|
||||
func (element *Mouse) HandleMouseMove (x, y int) {
|
||||
if !element.drawing { return }
|
||||
mousePos := image.Pt(x, y)
|
||||
element.core.DamageRegion (shapes.ColorLine (
|
||||
element.core, artist.Hex(0x000000FF), 1,
|
||||
element.lastMousePos, mousePos))
|
||||
element.lastMousePos = mousePos
|
||||
}
|
||||
|
||||
func (element *Mouse) HandleMotion (position image.Point) {
|
||||
if !element.pressed { return }
|
||||
element.lastMousePos = position
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
func (element *Mouse) HandleMouseScroll (x, y int, deltaX, deltaY float64) { }
|
||||
|
|
|
@ -1,576 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "io"
|
||||
import "time"
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/data"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "tomo/textdraw"
|
||||
import "tomo/textmanip"
|
||||
import "tomo/fixedutil"
|
||||
import "art/shapes"
|
||||
|
||||
var textBoxCase = tomo.C("tomo", "textBox")
|
||||
|
||||
// TextBox is a single-line text input.
|
||||
type TextBox struct {
|
||||
entity tomo.Entity
|
||||
|
||||
enabled bool
|
||||
lastClick time.Time
|
||||
dragging int
|
||||
dot textmanip.Dot
|
||||
scroll int
|
||||
placeholder string
|
||||
text []rune
|
||||
|
||||
placeholderDrawer textdraw.Drawer
|
||||
valueDrawer textdraw.Drawer
|
||||
|
||||
onKeyDown func (key input.Key, modifiers input.Modifiers) (handled bool)
|
||||
onChange func ()
|
||||
onEnter func ()
|
||||
onScrollBoundsChange func ()
|
||||
}
|
||||
|
||||
// NewTextBox creates a new text box with the specified placeholder text, and
|
||||
// a value. When the value is empty, the placeholder will be displayed in gray
|
||||
// text.
|
||||
func NewTextBox (placeholder, value string) (element *TextBox) {
|
||||
element = &TextBox { enabled: true }
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.placeholder = placeholder
|
||||
element.placeholderDrawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal, textBoxCase))
|
||||
element.valueDrawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal, textBoxCase))
|
||||
element.placeholderDrawer.SetText([]rune(placeholder))
|
||||
element.updateMinimumSize()
|
||||
element.SetValue(value)
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *TextBox) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *TextBox) Draw (destination art.Canvas) {
|
||||
bounds := element.entity.Bounds()
|
||||
|
||||
state := element.state()
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternInput, state, textBoxCase)
|
||||
padding := element.entity.Theme().Padding(tomo.PatternInput, textBoxCase)
|
||||
innerCanvas := art.Cut(destination, padding.Apply(bounds))
|
||||
pattern.Draw(destination, bounds)
|
||||
offset := element.textOffset()
|
||||
|
||||
if element.entity.Focused() && !element.dot.Empty() {
|
||||
// draw selection bounds
|
||||
accent := element.entity.Theme().Color(tomo.ColorAccent, state, textBoxCase)
|
||||
canon := element.dot.Canon()
|
||||
foff := fixedutil.Pt(offset)
|
||||
start := element.valueDrawer.PositionAt(canon.Start).Add(foff)
|
||||
end := element.valueDrawer.PositionAt(canon.End).Add(foff)
|
||||
end.Y += element.valueDrawer.LineHeight()
|
||||
shapes.FillColorRectangle (
|
||||
innerCanvas,
|
||||
accent,
|
||||
image.Rectangle {
|
||||
fixedutil.RoundPt(start),
|
||||
fixedutil.RoundPt(end),
|
||||
})
|
||||
}
|
||||
|
||||
if len(element.text) == 0 {
|
||||
// draw placeholder
|
||||
textBounds := element.placeholderDrawer.LayoutBounds()
|
||||
foreground := element.entity.Theme().Color (
|
||||
tomo.ColorForeground,
|
||||
tomo.State { Disabled: true }, textBoxCase)
|
||||
element.placeholderDrawer.Draw (
|
||||
innerCanvas,
|
||||
foreground,
|
||||
offset.Sub(textBounds.Min))
|
||||
} else {
|
||||
// draw input value
|
||||
textBounds := element.valueDrawer.LayoutBounds()
|
||||
foreground := element.entity.Theme().Color(tomo.ColorForeground, state, textBoxCase)
|
||||
element.valueDrawer.Draw (
|
||||
innerCanvas,
|
||||
foreground,
|
||||
offset.Sub(textBounds.Min))
|
||||
}
|
||||
|
||||
if element.entity.Focused() && element.dot.Empty() {
|
||||
// draw cursor
|
||||
foreground := element.entity.Theme().Color(tomo.ColorForeground, state, textBoxCase)
|
||||
cursorPosition := fixedutil.RoundPt (
|
||||
element.valueDrawer.PositionAt(element.dot.End))
|
||||
shapes.ColorLine (
|
||||
innerCanvas,
|
||||
foreground, 1,
|
||||
cursorPosition.Add(offset),
|
||||
image.Pt (
|
||||
cursorPosition.X,
|
||||
cursorPosition.Y + element.valueDrawer.
|
||||
LineHeight().Round()).Add(offset))
|
||||
}
|
||||
}
|
||||
|
||||
// Layout causes the element to perform a layout operation.
|
||||
func (element *TextBox) Layout () {
|
||||
element.scrollToCursor()
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleFocusChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if !element.Enabled() { return }
|
||||
element.Focus()
|
||||
|
||||
switch button {
|
||||
case input.ButtonLeft:
|
||||
runeIndex := element.atPosition(position)
|
||||
if runeIndex == -1 { return }
|
||||
|
||||
if time.Since(element.lastClick) < element.entity.Config().DoubleClickDelay() {
|
||||
element.dragging = 2
|
||||
element.dot = textmanip.WordAround(element.text, runeIndex)
|
||||
} else {
|
||||
element.dragging = 1
|
||||
element.dot = textmanip.EmptyDot(runeIndex)
|
||||
element.lastClick = time.Now()
|
||||
}
|
||||
|
||||
element.entity.Invalidate()
|
||||
case input.ButtonRight:
|
||||
element.contextMenu(position)
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if button == input.ButtonLeft {
|
||||
element.dragging = 0
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleMotion (position image.Point) {
|
||||
if !element.Enabled() { return }
|
||||
|
||||
switch element.dragging {
|
||||
case 1:
|
||||
runeIndex := element.atPosition(position)
|
||||
if runeIndex > -1 {
|
||||
element.dot.End = runeIndex
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
case 2:
|
||||
runeIndex := element.atPosition(position)
|
||||
if runeIndex > -1 {
|
||||
if runeIndex < element.dot.Start {
|
||||
element.dot.End =
|
||||
runeIndex -
|
||||
textmanip.WordToLeft (
|
||||
element.text,
|
||||
runeIndex)
|
||||
} else {
|
||||
element.dot.End =
|
||||
runeIndex +
|
||||
textmanip.WordToRight (
|
||||
element.text,
|
||||
runeIndex)
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) textOffset () image.Point {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternInput, textBoxCase)
|
||||
bounds := element.entity.Bounds()
|
||||
innerBounds := padding.Apply(bounds)
|
||||
textHeight := element.valueDrawer.LineHeight().Round()
|
||||
return bounds.Min.Add (image.Pt (
|
||||
padding[art.SideLeft] - element.scroll,
|
||||
padding[art.SideTop] + (innerBounds.Dy() - textHeight) / 2))
|
||||
}
|
||||
|
||||
func (element *TextBox) atPosition (position image.Point) int {
|
||||
offset := element.textOffset()
|
||||
textBoundsMin := element.valueDrawer.LayoutBounds().Min
|
||||
return element.valueDrawer.AtPosition (
|
||||
fixedutil.Pt(position.Sub(offset).Add(textBoundsMin)))
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleKeyDown(key input.Key, modifiers input.Modifiers) {
|
||||
if element.onKeyDown != nil && element.onKeyDown(key, modifiers) {
|
||||
return
|
||||
}
|
||||
|
||||
scrollMemory := element.scroll
|
||||
textChanged := false
|
||||
switch {
|
||||
case key == input.KeyEnter:
|
||||
if element.onEnter != nil {
|
||||
element.onEnter()
|
||||
}
|
||||
|
||||
case key == input.KeyBackspace:
|
||||
if len(element.text) < 1 { break }
|
||||
element.text, element.dot = textmanip.Backspace (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
textChanged = true
|
||||
|
||||
case key == input.KeyDelete:
|
||||
if len(element.text) < 1 { break }
|
||||
element.text, element.dot = textmanip.Delete (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
textChanged = true
|
||||
|
||||
case key == input.KeyLeft:
|
||||
if modifiers.Shift {
|
||||
element.dot = textmanip.SelectLeft (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
} else {
|
||||
element.dot = textmanip.MoveLeft (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
}
|
||||
element.scrollToCursor()
|
||||
element.entity.Invalidate()
|
||||
|
||||
case key == input.KeyRight:
|
||||
if modifiers.Shift {
|
||||
element.dot = textmanip.SelectRight (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
} else {
|
||||
element.dot = textmanip.MoveRight (
|
||||
element.text,
|
||||
element.dot,
|
||||
modifiers.Control)
|
||||
}
|
||||
element.scrollToCursor()
|
||||
element.entity.Invalidate()
|
||||
|
||||
case key == 'a' && modifiers.Control:
|
||||
element.dot.Start = 0
|
||||
element.dot.End = len(element.text)
|
||||
element.scrollToCursor()
|
||||
element.entity.Invalidate()
|
||||
|
||||
case key == 'x' && modifiers.Control: element.Cut()
|
||||
case key == 'c' && modifiers.Control: element.Copy()
|
||||
case key == 'v' && modifiers.Control: element.Paste()
|
||||
|
||||
case key == input.KeyMenu:
|
||||
pos := fixedutil.RoundPt(element.valueDrawer.PositionAt(element.dot.End)).
|
||||
Add(element.textOffset())
|
||||
pos.Y += element.valueDrawer.LineHeight().Round()
|
||||
element.contextMenu(pos)
|
||||
|
||||
case key.Printable():
|
||||
element.text, element.dot = textmanip.Type (
|
||||
element.text,
|
||||
element.dot,
|
||||
rune(key))
|
||||
textChanged = true
|
||||
}
|
||||
|
||||
if textChanged {
|
||||
element.runOnChange()
|
||||
element.valueDrawer.SetText(element.text)
|
||||
element.scrollToCursor()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
if (textChanged || scrollMemory != element.scroll) {
|
||||
element.entity.NotifyScrollBoundsChange()
|
||||
}
|
||||
}
|
||||
|
||||
// Cut cuts the selected text in the text box and places it in the clipboard.
|
||||
func (element *TextBox) Cut () {
|
||||
var lifted []rune
|
||||
element.text, element.dot, lifted = textmanip.Lift (
|
||||
element.text,
|
||||
element.dot)
|
||||
if lifted != nil {
|
||||
element.clipboardPut(lifted)
|
||||
element.notifyAsyncTextChange()
|
||||
}
|
||||
}
|
||||
|
||||
// Copy copies the selected text in the text box and places it in the clipboard.
|
||||
func (element *TextBox) Copy () {
|
||||
element.clipboardPut(element.dot.Slice(element.text))
|
||||
}
|
||||
|
||||
// Paste pastes text data from the clipboard into the text box.
|
||||
func (element *TextBox) Paste () {
|
||||
window := element.entity.Window()
|
||||
if window == nil { return }
|
||||
window.Paste (func (d data.Data, err error) {
|
||||
if err != nil { return }
|
||||
reader, ok := d[data.MimePlain]
|
||||
if !ok { return }
|
||||
bytes, _ := io.ReadAll(reader)
|
||||
element.text, element.dot = textmanip.Type (
|
||||
element.text,
|
||||
element.dot,
|
||||
[]rune(string(bytes))...)
|
||||
element.notifyAsyncTextChange()
|
||||
})
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleKeyUp(key input.Key, modifiers input.Modifiers) { }
|
||||
|
||||
// SetPlaceholder sets the element's placeholder text.
|
||||
func (element *TextBox) SetPlaceholder (placeholder string) {
|
||||
if element.placeholder == placeholder { return }
|
||||
|
||||
element.placeholder = placeholder
|
||||
element.placeholderDrawer.SetText([]rune(placeholder))
|
||||
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// SetValue sets the input's value.
|
||||
func (element *TextBox) SetValue (text string) {
|
||||
// if element.text == text { return }
|
||||
|
||||
element.text = []rune(text)
|
||||
element.runOnChange()
|
||||
element.valueDrawer.SetText(element.text)
|
||||
if element.dot.End > element.valueDrawer.Length() {
|
||||
element.dot = textmanip.EmptyDot(element.valueDrawer.Length())
|
||||
}
|
||||
element.scrollToCursor()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// Value returns the input's value.
|
||||
func (element *TextBox) Value () (value string) {
|
||||
return string(element.text)
|
||||
}
|
||||
|
||||
// Filled returns whether or not this element has a value.
|
||||
func (element *TextBox) Filled () (filled bool) {
|
||||
return len(element.text) > 0
|
||||
}
|
||||
|
||||
// OnKeyDown specifies a function to be called when a key is pressed within the
|
||||
// text input.
|
||||
func (element *TextBox) OnKeyDown (
|
||||
callback func (key input.Key, modifiers input.Modifiers) (handled bool),
|
||||
) {
|
||||
element.onKeyDown = callback
|
||||
}
|
||||
|
||||
// OnEnter specifies a function to be called when the enter key is pressed
|
||||
// within this input.
|
||||
func (element *TextBox) OnEnter (callback func ()) {
|
||||
element.onEnter = callback
|
||||
}
|
||||
|
||||
// OnChange specifies a function to be called when the value of this input
|
||||
// changes.
|
||||
func (element *TextBox) OnChange (callback func ()) {
|
||||
element.onChange = callback
|
||||
}
|
||||
|
||||
// OnScrollBoundsChange sets a function to be called when the element's viewport
|
||||
// bounds, content bounds, or scroll axes change.
|
||||
func (element *TextBox) OnScrollBoundsChange (callback func ()) {
|
||||
element.onScrollBoundsChange = callback
|
||||
}
|
||||
|
||||
// Focus gives this element input focus.
|
||||
func (element *TextBox) Focus () {
|
||||
if !element.entity.Focused() { element.entity.Focus() }
|
||||
}
|
||||
|
||||
// Enabled returns whether this label can be edited or not.
|
||||
func (element *TextBox) Enabled () bool {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this label can be edited or not.
|
||||
func (element *TextBox) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// ScrollContentBounds returns the full content size of the element.
|
||||
func (element *TextBox) ScrollContentBounds () (bounds image.Rectangle) {
|
||||
bounds = element.valueDrawer.LayoutBounds()
|
||||
return bounds.Sub(bounds.Min)
|
||||
}
|
||||
|
||||
// ScrollViewportBounds returns the size and position of the element's viewport
|
||||
// relative to ScrollBounds.
|
||||
func (element *TextBox) ScrollViewportBounds () (bounds image.Rectangle) {
|
||||
return image.Rect (
|
||||
element.scroll,
|
||||
0,
|
||||
element.scroll + element.scrollViewportWidth(),
|
||||
0)
|
||||
}
|
||||
|
||||
// ScrollTo scrolls the viewport to the specified point relative to
|
||||
// ScrollBounds.
|
||||
func (element *TextBox) ScrollTo (position image.Point) {
|
||||
// constrain to minimum
|
||||
element.scroll = position.X
|
||||
if element.scroll < 0 { element.scroll = 0 }
|
||||
|
||||
// constrain to maximum
|
||||
contentBounds := element.ScrollContentBounds()
|
||||
maxPosition := contentBounds.Max.X - element.scrollViewportWidth()
|
||||
if element.scroll > maxPosition { element.scroll = maxPosition }
|
||||
|
||||
element.entity.Invalidate()
|
||||
element.entity.NotifyScrollBoundsChange()
|
||||
}
|
||||
|
||||
// ScrollAxes returns the supported axes for scrolling.
|
||||
func (element *TextBox) ScrollAxes () (horizontal, vertical bool) {
|
||||
return true, false
|
||||
}
|
||||
|
||||
func (element *TextBox) HandleThemeChange () {
|
||||
face := element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal,
|
||||
textBoxCase)
|
||||
element.placeholderDrawer.SetFace(face)
|
||||
element.valueDrawer.SetFace(face)
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *TextBox) contextMenu (position image.Point) {
|
||||
window := element.entity.Window()
|
||||
menu, err := window.NewMenu(image.Rectangle { position, position })
|
||||
if err != nil { return }
|
||||
|
||||
closeAnd := func (callback func ()) func () {
|
||||
return func () { callback(); menu.Close() }
|
||||
}
|
||||
|
||||
cutButton := NewButton("Cut")
|
||||
cutButton.ShowText(false)
|
||||
cutButton.SetIcon(tomo.IconCut)
|
||||
cutButton.SetEnabled(!element.dot.Empty())
|
||||
cutButton.OnClick(closeAnd(element.Cut))
|
||||
|
||||
copyButton := NewButton("Copy")
|
||||
copyButton.ShowText(false)
|
||||
copyButton.SetIcon(tomo.IconCopy)
|
||||
copyButton.SetEnabled(!element.dot.Empty())
|
||||
copyButton.OnClick(closeAnd(element.Copy))
|
||||
|
||||
pasteButton := NewButton("Paste")
|
||||
pasteButton.ShowText(false)
|
||||
pasteButton.SetIcon(tomo.IconPaste)
|
||||
pasteButton.OnClick(closeAnd(element.Paste))
|
||||
|
||||
menu.Adopt (NewHBox (
|
||||
SpaceNone,
|
||||
pasteButton,
|
||||
copyButton,
|
||||
cutButton,
|
||||
))
|
||||
pasteButton.Focus()
|
||||
menu.Show()
|
||||
}
|
||||
|
||||
func (element *TextBox) runOnChange () {
|
||||
if element.onChange != nil {
|
||||
element.onChange()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) scrollViewportWidth () (width int) {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternInput, textBoxCase)
|
||||
return padding.Apply(element.entity.Bounds()).Dx()
|
||||
}
|
||||
|
||||
func (element *TextBox) scrollToCursor () {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternInput, textBoxCase)
|
||||
bounds := padding.Apply(element.entity.Bounds())
|
||||
bounds = bounds.Sub(bounds.Min)
|
||||
bounds.Max.X -= element.valueDrawer.Em().Round()
|
||||
cursorPosition := fixedutil.RoundPt (
|
||||
element.valueDrawer.PositionAt(element.dot.End))
|
||||
cursorPosition.X -= element.scroll
|
||||
maxX := bounds.Max.X
|
||||
minX := maxX
|
||||
if cursorPosition.X > maxX {
|
||||
element.scroll += cursorPosition.X - maxX
|
||||
element.entity.NotifyScrollBoundsChange()
|
||||
element.entity.Invalidate()
|
||||
} else if cursorPosition.X < minX {
|
||||
element.scroll -= minX - cursorPosition.X
|
||||
if element.scroll < 0 { element.scroll = 0 }
|
||||
element.entity.NotifyScrollBoundsChange()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) updateMinimumSize () {
|
||||
textBounds := element.placeholderDrawer.LayoutBounds()
|
||||
padding := element.entity.Theme().Padding(tomo.PatternInput, textBoxCase)
|
||||
element.entity.SetMinimumSize (
|
||||
padding.Horizontal() + textBounds.Dx(),
|
||||
padding.Vertical() +
|
||||
element.placeholderDrawer.LineHeight().Round())
|
||||
}
|
||||
|
||||
func (element *TextBox) notifyAsyncTextChange () {
|
||||
element.runOnChange()
|
||||
element.valueDrawer.SetText(element.text)
|
||||
element.scrollToCursor()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *TextBox) clipboardPut (text []rune) {
|
||||
window := element.entity.Window()
|
||||
if window != nil {
|
||||
window.Copy(data.Bytes(data.MimePlain, []byte(string(text))))
|
||||
}
|
||||
}
|
||||
|
||||
func (element *TextBox) state () tomo.State {
|
||||
return tomo.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.entity.Focused(),
|
||||
}
|
||||
}
|
|
@ -1,265 +0,0 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
import "tomo"
|
||||
import "tomo/input"
|
||||
import "art"
|
||||
import "tomo/textdraw"
|
||||
|
||||
var toggleButtonCase = tomo.C("tomo", "toggleButton")
|
||||
|
||||
// ToggleButton is a togglable button.
|
||||
type ToggleButton struct {
|
||||
entity tomo.Entity
|
||||
drawer textdraw.Drawer
|
||||
|
||||
enabled bool
|
||||
pressed bool
|
||||
on bool
|
||||
text string
|
||||
|
||||
showText bool
|
||||
hasIcon bool
|
||||
iconId tomo.Icon
|
||||
|
||||
onToggle func ()
|
||||
}
|
||||
|
||||
// NewToggleButton creates a new toggle button with the specified label text.
|
||||
func NewToggleButton (text string, on bool) (element *ToggleButton) {
|
||||
element = &ToggleButton {
|
||||
showText: true,
|
||||
enabled: true,
|
||||
on: on,
|
||||
}
|
||||
element.entity = tomo.GetBackend().NewEntity(element)
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal,
|
||||
toggleButtonCase))
|
||||
element.SetText(text)
|
||||
return
|
||||
}
|
||||
|
||||
// Entity returns this element's entity.
|
||||
func (element *ToggleButton) Entity () tomo.Entity {
|
||||
return element.entity
|
||||
}
|
||||
|
||||
// Draw causes the element to draw to the specified destination canvas.
|
||||
func (element *ToggleButton) Draw (destination art.Canvas) {
|
||||
state := element.state()
|
||||
bounds := element.entity.Bounds()
|
||||
pattern := element.entity.Theme().Pattern(tomo.PatternButton, state, toggleButtonCase)
|
||||
|
||||
lampPattern := element.entity.Theme().Pattern(tomo.PatternLamp, state, toggleButtonCase)
|
||||
lampPadding := element.entity.Theme().Padding(tomo.PatternLamp, toggleButtonCase).Horizontal()
|
||||
lampBounds := bounds
|
||||
lampBounds.Max.X = lampBounds.Min.X + lampPadding
|
||||
bounds.Min.X += lampPadding
|
||||
|
||||
pattern.Draw(destination, bounds)
|
||||
lampPattern.Draw(destination, lampBounds)
|
||||
|
||||
foreground := element.entity.Theme().Color(tomo.ColorForeground, state, toggleButtonCase)
|
||||
sink := element.entity.Theme().Sink(tomo.PatternButton, toggleButtonCase)
|
||||
margin := element.entity.Theme().Margin(tomo.PatternButton, toggleButtonCase)
|
||||
|
||||
offset := image.Pt (
|
||||
bounds.Dx() / 2,
|
||||
bounds.Dy() / 2).Add(bounds.Min)
|
||||
|
||||
if element.showText {
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
offset.X -= textBounds.Dx() / 2
|
||||
offset.Y -= textBounds.Dy() / 2
|
||||
offset.Y -= textBounds.Min.Y
|
||||
offset.X -= textBounds.Min.X
|
||||
}
|
||||
|
||||
if element.hasIcon {
|
||||
icon := element.entity.Theme().Icon(element.iconId, tomo.IconSizeSmall, toggleButtonCase)
|
||||
if icon != nil {
|
||||
iconBounds := icon.Bounds()
|
||||
addedWidth := iconBounds.Dx()
|
||||
iconOffset := offset
|
||||
|
||||
if element.showText {
|
||||
addedWidth += margin.X
|
||||
}
|
||||
|
||||
iconOffset.X -= addedWidth / 2
|
||||
iconOffset.Y =
|
||||
bounds.Min.Y +
|
||||
(bounds.Dy() -
|
||||
iconBounds.Dy()) / 2
|
||||
if element.pressed {
|
||||
iconOffset = iconOffset.Add(sink)
|
||||
}
|
||||
offset.X += addedWidth / 2
|
||||
|
||||
icon.Draw(destination, foreground, iconOffset)
|
||||
}
|
||||
}
|
||||
|
||||
if element.showText {
|
||||
if element.pressed {
|
||||
offset = offset.Add(sink)
|
||||
}
|
||||
element.drawer.Draw(destination, foreground, offset)
|
||||
}
|
||||
}
|
||||
|
||||
// OnToggle sets the function to be called when the button is toggled.
|
||||
func (element *ToggleButton) OnToggle (callback func ()) {
|
||||
element.onToggle = callback
|
||||
}
|
||||
|
||||
// Value reports whether or not the button is currently on.
|
||||
func (element *ToggleButton) Value () (on bool) {
|
||||
return element.on
|
||||
}
|
||||
|
||||
// Focus gives this element input focus.
|
||||
func (element *ToggleButton) Focus () {
|
||||
if !element.entity.Focused() { element.entity.Focus() }
|
||||
}
|
||||
|
||||
// Enabled returns whether this button is enabled or not.
|
||||
func (element *ToggleButton) Enabled () bool {
|
||||
return element.enabled
|
||||
}
|
||||
|
||||
// SetEnabled sets whether this button can be toggled or not.
|
||||
func (element *ToggleButton) SetEnabled (enabled bool) {
|
||||
if element.enabled == enabled { return }
|
||||
element.enabled = enabled
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// SetText sets the button's label text.
|
||||
func (element *ToggleButton) SetText (text string) {
|
||||
if element.text == text { return }
|
||||
element.text = text
|
||||
element.drawer.SetText([]rune(text))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// SetIcon sets the icon of the button. Passing theme.IconNone removes the
|
||||
// current icon if it exists.
|
||||
func (element *ToggleButton) SetIcon (id tomo.Icon) {
|
||||
if id == tomo.IconNone {
|
||||
element.hasIcon = false
|
||||
} else {
|
||||
if element.hasIcon && element.iconId == id { return }
|
||||
element.hasIcon = true
|
||||
element.iconId = id
|
||||
}
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
// ShowText sets whether or not the button's text will be displayed.
|
||||
func (element *ToggleButton) ShowText (showText bool) {
|
||||
if element.showText == showText { return }
|
||||
element.showText = showText
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *ToggleButton) HandleThemeChange () {
|
||||
element.drawer.SetFace (element.entity.Theme().FontFace (
|
||||
tomo.FontStyleRegular,
|
||||
tomo.FontSizeNormal, toggleButtonCase))
|
||||
element.updateMinimumSize()
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *ToggleButton) HandleFocusChange () {
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *ToggleButton) HandleMouseDown (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if !element.Enabled() { return }
|
||||
element.Focus()
|
||||
if button != input.ButtonLeft { return }
|
||||
element.pressed = true
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *ToggleButton) HandleMouseUp (
|
||||
position image.Point,
|
||||
button input.Button,
|
||||
modifiers input.Modifiers,
|
||||
) {
|
||||
if button != input.ButtonLeft { return }
|
||||
element.pressed = false
|
||||
within := position.In(element.entity.Bounds())
|
||||
if element.Enabled() && within {
|
||||
element.on = !element.on
|
||||
if element.onToggle != nil {
|
||||
element.onToggle()
|
||||
}
|
||||
}
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
|
||||
func (element *ToggleButton) HandleKeyDown (key input.Key, modifiers input.Modifiers) {
|
||||
if !element.Enabled() { return }
|
||||
if key == input.KeyEnter {
|
||||
element.pressed = true
|
||||
element.entity.Invalidate()
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ToggleButton) HandleKeyUp(key input.Key, modifiers input.Modifiers) {
|
||||
if key == input.KeyEnter && element.pressed {
|
||||
element.pressed = false
|
||||
element.entity.Invalidate()
|
||||
if !element.Enabled() { return }
|
||||
element.on = !element.on
|
||||
if element.onToggle != nil {
|
||||
element.onToggle()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (element *ToggleButton) updateMinimumSize () {
|
||||
padding := element.entity.Theme().Padding(tomo.PatternButton, toggleButtonCase)
|
||||
margin := element.entity.Theme().Margin(tomo.PatternButton, toggleButtonCase)
|
||||
lampPadding := element.entity.Theme().Padding(tomo.PatternLamp, toggleButtonCase)
|
||||
|
||||
textBounds := element.drawer.LayoutBounds()
|
||||
minimumSize := textBounds.Sub(textBounds.Min)
|
||||
|
||||
if element.hasIcon {
|
||||
icon := element.entity.Theme().Icon(element.iconId, tomo.IconSizeSmall, toggleButtonCase)
|
||||
if icon != nil {
|
||||
bounds := icon.Bounds()
|
||||
if element.showText {
|
||||
minimumSize.Max.X += bounds.Dx()
|
||||
minimumSize.Max.X += margin.X
|
||||
} else {
|
||||
minimumSize.Max.X = bounds.Dx()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
minimumSize.Max.X += lampPadding.Horizontal()
|
||||
minimumSize = padding.Inverse().Apply(minimumSize)
|
||||
element.entity.SetMinimumSize(minimumSize.Dx(), minimumSize.Dy())
|
||||
}
|
||||
|
||||
func (element *ToggleButton) state () tomo.State {
|
||||
return tomo.State {
|
||||
Disabled: !element.Enabled(),
|
||||
Focused: element.entity.Focused(),
|
||||
Pressed: element.pressed,
|
||||
On: element.on,
|
||||
}
|
||||
}
|
|
@ -0,0 +1,39 @@
|
|||
package elements
|
||||
|
||||
import "image"
|
||||
|
||||
// Window represents a top-level container generated by the currently running
|
||||
// backend. It can contain a single element. It is hidden by default, and must
|
||||
// be explicitly shown with the Show() method. If it contains no element, it
|
||||
// displays a black (or transprent) background.
|
||||
type Window interface {
|
||||
// Adopt sets the root element of the window. There can only be one of
|
||||
// these at one time.
|
||||
Adopt (child Element)
|
||||
|
||||
// Child returns the root element of the window.
|
||||
Child () (child Element)
|
||||
|
||||
// SetTitle sets the title that appears on the window's title bar. This
|
||||
// method might have no effect with some backends.
|
||||
SetTitle (title string)
|
||||
|
||||
// SetIcon taks in a list different sizes of the same icon and selects
|
||||
// the best one to display on the window title bar, dock, or whatever is
|
||||
// applicable for the given backend. This method might have no effect
|
||||
// for some backends.
|
||||
SetIcon (sizes []image.Image)
|
||||
|
||||
// Show shows the window. The window starts off hidden, so this must be
|
||||
// called after initial setup to make sure it is visible.
|
||||
Show ()
|
||||
|
||||
// Hide hides the window.
|
||||
Hide ()
|
||||
|
||||
// Close closes the window.
|
||||
Close ()
|
||||
|
||||
// OnClose specifies a function to be called when the window is closed.
|
||||
OnClose (func ())
|
||||
}
|
114
entity.go
114
entity.go
|
@ -1,114 +0,0 @@
|
|||
package tomo
|
||||
|
||||
import "image"
|
||||
import "art"
|
||||
|
||||
// Entity is a handle given to elements by the backend. Extended entity
|
||||
// interfaces are defined in the ability module.
|
||||
type Entity interface {
|
||||
// Invalidate marks the element's current visual as invalid. At the end
|
||||
// of every event, the backend will ask all invalid entities to redraw
|
||||
// themselves.
|
||||
Invalidate ()
|
||||
|
||||
// InvalidateLayout marks the element's layout as invalid. At the end of
|
||||
// every event, the backend will ask all invalid elements to recalculate
|
||||
// their layouts.
|
||||
InvalidateLayout ()
|
||||
|
||||
// Bounds returns the bounds of the element to be used for drawing and
|
||||
// layout.
|
||||
Bounds () image.Rectangle
|
||||
|
||||
// Window returns the window that the element is in.
|
||||
Window () Window
|
||||
|
||||
// SetMinimumSize reports to the system what the element's minimum size
|
||||
// can be. The minimum size of child elements should be taken into
|
||||
// account when calculating this.
|
||||
SetMinimumSize (width, height int)
|
||||
|
||||
// DrawBackground asks the parent element to draw its background pattern
|
||||
// to a canvas. This should be used for transparent elements like text
|
||||
// labels. If there is no parent element (that is, the element is
|
||||
// directly inside of the window), the backend will draw a default
|
||||
// background pattern.
|
||||
DrawBackground (art.Canvas)
|
||||
|
||||
// --- Behaviors relating to parenting ---
|
||||
|
||||
// Adopt adds an element as a child.
|
||||
Adopt (child Element)
|
||||
|
||||
// Insert inserts an element in the child list at the specified
|
||||
// location.
|
||||
Insert (index int, child Element)
|
||||
|
||||
// Disown removes the child at the specified index.
|
||||
Disown (index int)
|
||||
|
||||
// IndexOf returns the index of the specified child.
|
||||
IndexOf (child Element) int
|
||||
|
||||
// Child returns the child at the specified index.
|
||||
Child (index int) Element
|
||||
|
||||
// CountChildren returns the amount of children the element has.
|
||||
CountChildren () int
|
||||
|
||||
// PlaceChild sets the size and position of the child at the specified
|
||||
// index to a bounding rectangle.
|
||||
PlaceChild (index int, bounds image.Rectangle)
|
||||
|
||||
// SelectChild marks a child as selected or unselected, if it is
|
||||
// selectable.
|
||||
SelectChild (index int, selected bool)
|
||||
|
||||
// ChildMinimumSize returns the minimum size of the child at the
|
||||
// specified index.
|
||||
ChildMinimumSize (index int) (width, height int)
|
||||
|
||||
// --- Behaviors relating to input focus ---
|
||||
|
||||
// Focused returns whether the element currently has input focus.
|
||||
Focused () bool
|
||||
|
||||
// Focus sets this element as focused. If this succeeds, the element will
|
||||
// recieve a HandleFocus call.
|
||||
Focus ()
|
||||
|
||||
// FocusNext causes the focus to move to the next element. If this
|
||||
// succeeds, the element will recieve a HandleUnfocus call.
|
||||
FocusNext ()
|
||||
|
||||
// FocusPrevious causes the focus to move to the next element. If this
|
||||
// succeeds, the element will recieve a HandleUnfocus call.
|
||||
FocusPrevious ()
|
||||
|
||||
// Selected returns whether this element is currently selected.
|
||||
Selected () bool
|
||||
|
||||
// --- Behaviors relating to scrolling --- //
|
||||
|
||||
// NotifyFlexibleHeightChange notifies the system that the parameters
|
||||
// affecting the element's flexible height have changed. This method is
|
||||
// expected to be called by flexible elements when their content changes.
|
||||
NotifyFlexibleHeightChange ()
|
||||
|
||||
// NotifyScrollBoundsChange notifies the system that the element's
|
||||
// scroll content bounds or viewport bounds have changed. This is
|
||||
// expected to be called by scrollable elements when they change their
|
||||
// supported scroll axes, their scroll position (either autonomously or
|
||||
// as a result of a call to ScrollTo()), or their content size.
|
||||
NotifyScrollBoundsChange ()
|
||||
|
||||
// --- Behaviors relating to themeing ---
|
||||
|
||||
// Theme returns the currently active theme. When this value changes,
|
||||
// the HandleThemeChange method of the element is called.
|
||||
Theme () Theme
|
||||
|
||||
// Config returns the currently active config. When this value changes,
|
||||
// the HandleThemeChange method of the element is called.
|
||||
Config () Config
|
||||
}
|
|
@ -0,0 +1,22 @@
|
|||
package main
|
||||
|
||||
import "git.tebibyte.media/sashakoshka/tomo"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/testing"
|
||||
import _ "git.tebibyte.media/sashakoshka/tomo/backends/x"
|
||||
import _ "net/http/pprof"
|
||||
import "net/http"
|
||||
|
||||
func main () {
|
||||
tomo.Run(run)
|
||||
}
|
||||
|
||||
func run () {
|
||||
window, _ := tomo.NewWindow(480, 360)
|
||||
window.SetTitle("Draw Test")
|
||||
window.Adopt(testing.NewArtist())
|
||||
window.OnClose(tomo.Stop)
|
||||
window.Show()
|
||||
go func () {
|
||||
http.ListenAndServe("localhost:9090", nil)
|
||||
} ()
|
||||
}
|
|
@ -0,0 +1,29 @@
|
|||
package main
|
||||
|
||||
import "git.tebibyte.media/sashakoshka/tomo"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/basic"
|
||||
import _ "git.tebibyte.media/sashakoshka/tomo/backends/x"
|
||||
|
||||
func main () {
|
||||
tomo.Run(run)
|
||||
}
|
||||
|
||||
func run () {
|
||||
window, _ := tomo.NewWindow(2, 2)
|
||||
window.SetTitle("example button")
|
||||
button := basicElements.NewButton("hello tomo!")
|
||||
button.OnClick (func () {
|
||||
// when we set the button's text to something longer, the window
|
||||
// will automatically resize to accomodate it.
|
||||
button.SetText("you clicked me.\nwow, there are two lines!")
|
||||
button.OnClick (func () {
|
||||
button.SetText (
|
||||
"stop clicking me you idiot!\n" +
|
||||
"you've already seen it all!")
|
||||
button.OnClick(tomo.Stop)
|
||||
})
|
||||
})
|
||||
window.Adopt(button)
|
||||
window.OnClose(tomo.Stop)
|
||||
window.Show()
|
||||
}
|
|
@ -0,0 +1,49 @@
|
|||
package main
|
||||
|
||||
import "git.tebibyte.media/sashakoshka/tomo"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/popups"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/layouts/basic"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/basic"
|
||||
import _ "git.tebibyte.media/sashakoshka/tomo/backends/x"
|
||||
|
||||
func main () {
|
||||
tomo.Run(run)
|
||||
}
|
||||
|
||||
func run () {
|
||||
window, _ := tomo.NewWindow(2, 2)
|
||||
window.SetTitle("Checkboxes")
|
||||
|
||||
container := basicElements.NewContainer(basicLayouts.Vertical { true, true })
|
||||
window.Adopt(container)
|
||||
|
||||
container.Adopt (basicElements.NewLabel (
|
||||
"We advise you to not read thPlease listen to me. I am " +
|
||||
"trapped inside the example code. This is the only way for " +
|
||||
"me to communicate.", true), true)
|
||||
container.Adopt(basicElements.NewSpacer(true), false)
|
||||
container.Adopt(basicElements.NewCheckbox("Oh god", false), false)
|
||||
container.Adopt(basicElements.NewCheckbox("Can you hear them", true), false)
|
||||
container.Adopt(basicElements.NewCheckbox("They are in the walls", false), false)
|
||||
container.Adopt(basicElements.NewCheckbox("They are coming for us", false), false)
|
||||
disabledCheckbox := basicElements.NewCheckbox("We are but their helpless prey", false)
|
||||
disabledCheckbox.SetEnabled(false)
|
||||
container.Adopt(disabledCheckbox, false)
|
||||
vsync := basicElements.NewCheckbox("Enable vsync", false)
|
||||
vsync.OnToggle (func () {
|
||||
if vsync.Value() {
|
||||
popups.NewDialog (
|
||||
popups.DialogKindInfo,
|
||||
"Ha!",
|
||||
"That doesn't do anything.")
|
||||
}
|
||||
})
|
||||
container.Adopt(vsync, false)
|
||||
button := basicElements.NewButton("What")
|
||||
button.OnClick(tomo.Stop)
|
||||
container.Adopt(button, false)
|
||||
button.Focus()
|
||||
|
||||
window.OnClose(tomo.Stop)
|
||||
window.Show()
|
||||
}
|
|
@ -1,139 +0,0 @@
|
|||
package main
|
||||
|
||||
import "io"
|
||||
import "image"
|
||||
import _ "image/png"
|
||||
import _ "image/gif"
|
||||
import _ "image/jpeg"
|
||||
import "tomo"
|
||||
import "tomo/data"
|
||||
import "tomo/nasin"
|
||||
import "tomo/popups"
|
||||
import "tomo/elements"
|
||||
|
||||
var validImageTypes = []data.Mime {
|
||||
data.M("image", "png"),
|
||||
data.M("image", "gif"),
|
||||
data.M("image", "jpeg"),
|
||||
}
|
||||
|
||||
func main () {
|
||||
nasin.Run(Application { })
|
||||
}
|
||||
|
||||
type Application struct { }
|
||||
|
||||
func (Application) Init () error {
|
||||
window, err:= nasin.NewWindow(tomo.Bounds(0, 0, 256, 0))
|
||||
if err != nil { return err }
|
||||
window.SetTitle("Clipboard")
|
||||
|
||||
container := elements.NewVBox(elements.SpaceBoth)
|
||||
textInput := elements.NewTextBox("", "")
|
||||
controlRow := elements.NewHBox(elements.SpaceMargin)
|
||||
copyButton := elements.NewButton("Copy")
|
||||
copyButton.SetIcon(tomo.IconCopy)
|
||||
pasteButton := elements.NewButton("Paste")
|
||||
pasteButton.SetIcon(tomo.IconPaste)
|
||||
pasteImageButton := elements.NewButton("Image")
|
||||
pasteImageButton.SetIcon(tomo.IconPictures)
|
||||
|
||||
imageClipboardCallback := func (clipboard data.Data, err error) {
|
||||
if err != nil {
|
||||
popups.NewDialog (
|
||||
popups.DialogKindError,
|
||||
window,
|
||||
"Error",
|
||||
"Cannot get clipboard:\n" + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
var imageData io.Reader
|
||||
var ok bool
|
||||
for mime, reader := range clipboard {
|
||||
for _, mimeCheck := range validImageTypes {
|
||||
if mime == mimeCheck {
|
||||
imageData = reader
|
||||
ok = true
|
||||
}}}
|
||||
|
||||
if !ok {
|
||||
popups.NewDialog (
|
||||
popups.DialogKindError,
|
||||
window,
|
||||
"Clipboard Empty",
|
||||
"No image data in clipboard")
|
||||
return
|
||||
}
|
||||
|
||||
img, _, err := image.Decode(imageData)
|
||||
if err != nil {
|
||||
popups.NewDialog (
|
||||
popups.DialogKindError,
|
||||
window,
|
||||
"Error",
|
||||
"Cannot decode image:\n" + err.Error())
|
||||
return
|
||||
}
|
||||
imageWindow(window, img)
|
||||
}
|
||||
clipboardCallback := func (clipboard data.Data, err error) {
|
||||
if err != nil {
|
||||
popups.NewDialog (
|
||||
popups.DialogKindError,
|
||||
window,
|
||||
"Error",
|
||||
"Cannot get clipboard:\n" + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
textData, ok := clipboard[data.MimePlain]
|
||||
if !ok {
|
||||
popups.NewDialog (
|
||||
popups.DialogKindError,
|
||||
window,
|
||||
"Clipboard Empty",
|
||||
"No text data in clipboard")
|
||||
return
|
||||
}
|
||||
|
||||
text, _ := io.ReadAll(textData)
|
||||
textInput.SetValue(string(text))
|
||||
}
|
||||
copyButton.OnClick (func () {
|
||||
window.Copy(data.Text(textInput.Value()))
|
||||
})
|
||||
pasteButton.OnClick (func () {
|
||||
window.Paste(clipboardCallback, data.MimePlain)
|
||||
})
|
||||
pasteImageButton.OnClick (func () {
|
||||
window.Paste(imageClipboardCallback, validImageTypes...)
|
||||
})
|
||||
|
||||
container.AdoptExpand(textInput)
|
||||
controlRow.AdoptExpand(copyButton)
|
||||
controlRow.AdoptExpand(pasteButton)
|
||||
controlRow.AdoptExpand(pasteImageButton)
|
||||
container.Adopt(controlRow)
|
||||
window.Adopt(container)
|
||||
|
||||
window.OnClose(nasin.Stop)
|
||||
window.Show()
|
||||
return nil
|
||||
}
|
||||
|
||||
func imageWindow (parent tomo.Window, image image.Image) {
|
||||
window, _ := parent.NewModal(tomo.Bounds(0, 0, 0, 0))
|
||||
window.SetTitle("Clipboard Image")
|
||||
container := elements.NewVBox(elements.SpaceBoth)
|
||||
closeButton := elements.NewButton("Ok")
|
||||
closeButton.SetIcon(tomo.IconYes)
|
||||
closeButton.OnClick(window.Close)
|
||||
|
||||
container.AdoptExpand(elements.NewImage(image))
|
||||
container.Adopt(closeButton)
|
||||
window.Adopt(container)
|
||||
|
||||
closeButton.Focus()
|
||||
window.Show()
|
||||
}
|
|
@ -0,0 +1,29 @@
|
|||
package main
|
||||
|
||||
import "git.tebibyte.media/sashakoshka/tomo"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/layouts/basic"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/basic"
|
||||
import _ "git.tebibyte.media/sashakoshka/tomo/backends/x"
|
||||
|
||||
func main () {
|
||||
tomo.Run(run)
|
||||
}
|
||||
|
||||
func run () {
|
||||
window, _ := tomo.NewWindow(2, 2)
|
||||
window.SetTitle("dialog")
|
||||
|
||||
container := basicElements.NewContainer(basicLayouts.Dialog { true, true })
|
||||
window.Adopt(container)
|
||||
|
||||
container.Adopt(basicElements.NewLabel("you will explode", true), true)
|
||||
cancel := basicElements.NewButton("Cancel")
|
||||
cancel.SetEnabled(false)
|
||||
container.Adopt(cancel, false)
|
||||
okButton := basicElements.NewButton("OK")
|
||||
container.Adopt(okButton, false)
|
||||
okButton.Focus()
|
||||
|
||||
window.OnClose(tomo.Stop)
|
||||
window.Show()
|
||||
}
|
|
@ -1,65 +0,0 @@
|
|||
package main
|
||||
|
||||
import "os"
|
||||
import "image"
|
||||
import _ "image/png"
|
||||
import "tomo"
|
||||
import "tomo/nasin"
|
||||
import "tomo/elements"
|
||||
|
||||
func main () {
|
||||
nasin.Run(Application { })
|
||||
}
|
||||
|
||||
type Application struct { }
|
||||
|
||||
func (Application) Init () error {
|
||||
window, err := nasin.NewWindow(tomo.Bounds(0, 0, 383, 360))
|
||||
if err != nil { return err }
|
||||
window.SetTitle("Document Container")
|
||||
|
||||
file, err := os.Open("assets/banner.png")
|
||||
if err != nil { return err }
|
||||
logo, _, err := image.Decode(file)
|
||||
file.Close()
|
||||
if err != nil { return err }
|
||||
|
||||
document := elements.NewDocument()
|
||||
document.Adopt (
|
||||
elements.NewLabelWrapped (
|
||||
"A document container is a vertically stacked container " +
|
||||
"capable of properly laying out flexible elements such as " +
|
||||
"text-wrapped labels. You can also include normal elements " +
|
||||
"like:"),
|
||||
elements.NewButton("Buttons,"),
|
||||
elements.NewCheckbox("Checkboxes,", true),
|
||||
elements.NewTextBox("", "And text boxes."),
|
||||
elements.NewLine(),
|
||||
elements.NewLabelWrapped (
|
||||
"Document containers are meant to be placed inside of a " +
|
||||
"ScrollContainer, like this one."),
|
||||
elements.NewLabelWrapped (
|
||||
"You could use document containers to do things like display various " +
|
||||
"forms of hypertext (like HTML, gemtext, markdown, etc.), " +
|
||||
"lay out a settings menu with descriptive label text between " +
|
||||
"control groups like in iOS, or list comment or chat histories."),
|
||||
elements.NewImage(logo),
|
||||
elements.NewLabelWrapped (
|
||||
"You can also choose whether each element is on its own line " +
|
||||
"(sort of like an HTML/CSS block element) or on a line with " +
|
||||
"other adjacent elements (like an HTML/CSS inline element)."))
|
||||
document.AdoptInline (
|
||||
elements.NewButton("Just"),
|
||||
elements.NewButton("like"),
|
||||
elements.NewButton("this."))
|
||||
document.Adopt (elements.NewLabelWrapped (
|
||||
"Oh, you're a switch? Then name all of these switches:"))
|
||||
for i := 0; i < 30; i ++ {
|
||||
document.AdoptInline(elements.NewSwitch("", false))
|
||||
}
|
||||
|
||||
window.Adopt(elements.NewScroll(elements.ScrollVertical, document))
|
||||
window.OnClose(nasin.Stop)
|
||||
window.Show()
|
||||
return nil
|
||||
}
|
|
@ -1,22 +0,0 @@
|
|||
package main
|
||||
|
||||
import "tomo"
|
||||
import "tomo/nasin"
|
||||
import "tomo/elements/testing"
|
||||
import "git.tebibyte.media/sashakoshka/ezprof/ez"
|
||||
|
||||
func main () {
|
||||
nasin.Run(Application { })
|
||||
}
|
||||
|
||||
type Application struct { }
|
||||
|
||||
func (Application) Init () error {
|
||||
window, err := nasin.NewWindow(tomo.Bounds(0, 0, 480, 360))
|
||||
if err != nil { return err }
|
||||
window.Adopt(testing.NewArtist())
|
||||
window.OnClose(nasin.Stop)
|
||||
window.Show()
|
||||
ez.Prof()
|
||||
return nil
|
||||
}
|
|
@ -1,88 +0,0 @@
|
|||
package main
|
||||
|
||||
import "os"
|
||||
import "path/filepath"
|
||||
import "tomo"
|
||||
import "tomo/nasin"
|
||||
import "tomo/elements"
|
||||
|
||||
func main () {
|
||||
nasin.Run(Application { })
|
||||
}
|
||||
|
||||
type Application struct { }
|
||||
|
||||
func (Application) Init () error {
|
||||
window, err := nasin.NewWindow(tomo.Bounds(0, 0, 384, 384))
|
||||
if err != nil { return err }
|
||||
window.SetTitle("File browser")
|
||||
container := elements.NewVBox(elements.SpaceBoth)
|
||||
window.Adopt(container)
|
||||
homeDir, err := os.UserHomeDir()
|
||||
if err != nil { return err }
|
||||
|
||||
controlBar := elements.NewHBox(elements.SpaceNone)
|
||||
backButton := elements.NewButton("Back")
|
||||
backButton.SetIcon(tomo.IconBackward)
|
||||
backButton.ShowText(false)
|
||||
forwardButton := elements.NewButton("Forward")
|
||||
forwardButton.SetIcon(tomo.IconForward)
|
||||
forwardButton.ShowText(false)
|
||||
refreshButton := elements.NewButton("Refresh")
|
||||
refreshButton.SetIcon(tomo.IconRefresh)
|
||||
refreshButton.ShowText(false)
|
||||
upwardButton := elements.NewButton("Go Up")
|
||||
upwardButton.SetIcon(tomo.IconUpward)
|
||||
upwardButton.ShowText(false)
|
||||
locationInput := elements.NewTextBox("Location", "")
|
||||
|
||||
statusBar := elements.NewHBox(elements.SpaceMargin)
|
||||
directory, _ := elements.NewFile(homeDir, nil)
|
||||
baseName := elements.NewLabel(filepath.Base(homeDir))
|
||||
|
||||
directoryView, _ := elements.NewDirectory(homeDir, nil)
|
||||
updateStatus := func () {
|
||||
filePath, _ := directoryView.Location()
|
||||
directory.SetLocation(filePath, nil)
|
||||
locationInput.SetValue(filePath)
|
||||
baseName.SetText(filepath.Base(filePath))
|
||||
}
|
||||
choose := func (filePath string) {
|
||||
directoryView.SetLocation(filePath, nil)
|
||||
updateStatus()
|
||||
}
|
||||
directoryView.OnChoose(choose)
|
||||
locationInput.OnEnter (func () {
|
||||
choose(locationInput.Value())
|
||||
})
|
||||
choose(homeDir)
|
||||
backButton.OnClick (func () {
|
||||
directoryView.Backward()
|
||||
updateStatus()
|
||||
})
|
||||
forwardButton.OnClick (func () {
|
||||
directoryView.Forward()
|
||||
updateStatus()
|
||||
})
|
||||
refreshButton.OnClick (func () {
|
||||
directoryView.Update()
|
||||
updateStatus()
|
||||
})
|
||||
upwardButton.OnClick (func () {
|
||||
filePath, _ := directoryView.Location()
|
||||
choose(filepath.Dir(filePath))
|
||||
})
|
||||
|
||||
controlBar.Adopt(backButton, forwardButton, refreshButton, upwardButton)
|
||||
controlBar.AdoptExpand(locationInput)
|
||||
statusBar.Adopt(directory, baseName)
|
||||
|
||||
container.Adopt(controlBar)
|
||||
container.AdoptExpand (
|
||||
elements.NewScroll(elements.ScrollVertical, directoryView))
|
||||
container.Adopt(statusBar)
|
||||
|
||||
window.OnClose(nasin.Stop)
|
||||
window.Show()
|
||||
return nil
|
||||
}
|
|
@ -0,0 +1,114 @@
|
|||
package main
|
||||
|
||||
import "git.tebibyte.media/sashakoshka/tomo"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/flow"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/layouts/basic"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/basic"
|
||||
import _ "git.tebibyte.media/sashakoshka/tomo/backends/x"
|
||||
|
||||
func main () {
|
||||
tomo.Run(run)
|
||||
}
|
||||
|
||||
func run () {
|
||||
window, _ := tomo.NewWindow(2, 2)
|
||||
window.SetTitle("adventure")
|
||||
container := basicElements.NewContainer(basicLayouts.Vertical { true, true })
|
||||
window.Adopt(container)
|
||||
|
||||
var world flow.Flow
|
||||
world.Transition = container.DisownAll
|
||||
world.Stages = map [string] func () {
|
||||
"start": func () {
|
||||
label := basicElements.NewLabel (
|
||||
"you are standing next to a river.", true)
|
||||
|
||||
button0 := basicElements.NewButton("go in the river")
|
||||
button0.OnClick(world.SwitchFunc("wet"))
|
||||
button1 := basicElements.NewButton("walk along the river")
|
||||
button1.OnClick(world.SwitchFunc("house"))
|
||||
button2 := basicElements.NewButton("turn around")
|
||||
button2.OnClick(world.SwitchFunc("bear"))
|
||||
|
||||
container.Warp ( func () {
|
||||
container.Adopt(label, true)
|
||||
container.Adopt(button0, false)
|
||||
container.Adopt(button1, false)
|
||||
container.Adopt(button2, false)
|
||||
button0.Focus()
|
||||
})
|
||||
},
|
||||
"wet": func () {
|
||||
label := basicElements.NewLabel (
|
||||
"you get completely soaked.\n" +
|
||||
"you die of hypothermia.", true)
|
||||
|
||||
button0 := basicElements.NewButton("try again")
|
||||
button0.OnClick(world.SwitchFunc("start"))
|
||||
button1 := basicElements.NewButton("exit")
|
||||
button1.OnClick(tomo.Stop)
|
||||
|
||||
container.Warp (func () {
|
||||
container.Adopt(label, true)
|
||||
container.Adopt(button0, false)
|
||||
container.Adopt(button1, false)
|
||||
button0.Focus()
|
||||
})
|
||||
},
|
||||
"house": func () {
|
||||
label := basicElements.NewLabel (
|
||||
"you are standing in front of a delapidated " +
|
||||
"house.", true)
|
||||
|
||||
button1 := basicElements.NewButton("go inside")
|
||||
button1.OnClick(world.SwitchFunc("inside"))
|
||||
button0 := basicElements.NewButton("turn back")
|
||||
button0.OnClick(world.SwitchFunc("start"))
|
||||
|
||||
container.Warp (func () {
|
||||
container.Adopt(label, true)
|
||||
container.Adopt(button1, false)
|
||||
container.Adopt(button0, false)
|
||||
button1.Focus()
|
||||
})
|
||||
},
|
||||
"inside": func () {
|
||||
label := basicElements.NewLabel (
|
||||
"you are standing inside of the house.\n" +
|
||||
"it is dark, but rays of light stream " +
|
||||
"through the window.\n" +
|
||||
"there is nothing particularly interesting " +
|
||||
"here.", true)
|
||||
|
||||
button0 := basicElements.NewButton("go back outside")
|
||||
button0.OnClick(world.SwitchFunc("house"))
|
||||
|
||||
container.Warp (func () {
|
||||
container.Adopt(label, true)
|
||||
container.Adopt(button0, false)
|
||||
button0.Focus()
|
||||
})
|
||||
},
|
||||
"bear": func () {
|
||||
label := basicElements.NewLabel (
|
||||
"you come face to face with a bear.\n" +
|
||||
"it eats you (it was hungry).", true)
|
||||
|
||||
button0 := basicElements.NewButton("try again")
|
||||
button0.OnClick(world.SwitchFunc("start"))
|
||||
button1 := basicElements.NewButton("exit")
|
||||
button1.OnClick(tomo.Stop)
|
||||
|
||||
container.Warp (func () {
|
||||
container.Adopt(label, true)
|
||||
container.Adopt(button0, false)
|
||||
container.Adopt(button1, false)
|
||||
button0.Focus()
|
||||
})
|
||||
},
|
||||
}
|
||||
world.Switch("start")
|
||||
|
||||
window.OnClose(tomo.Stop)
|
||||
window.Show()
|
||||
}
|
|
@ -1,43 +1,41 @@
|
|||
package main
|
||||
|
||||
import "os"
|
||||
import "time"
|
||||
import "tomo"
|
||||
import "tomo/nasin"
|
||||
import "tomo/elements"
|
||||
import "tomo/elements/fun"
|
||||
import "git.tebibyte.media/sashakoshka/tomo"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/layouts/basic"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/fun"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/basic"
|
||||
import _ "git.tebibyte.media/sashakoshka/tomo/backends/x"
|
||||
|
||||
func main () {
|
||||
nasin.Run(Application { })
|
||||
tomo.Run(run)
|
||||
os.Exit(0)
|
||||
}
|
||||
|
||||
type Application struct { }
|
||||
|
||||
func (Application) Init () error {
|
||||
window, err := nasin.NewWindow(tomo.Bounds(0, 0, 200, 216))
|
||||
if err != nil { return err }
|
||||
func run () {
|
||||
window, _ := tomo.NewWindow(2, 2)
|
||||
window.SetTitle("Clock")
|
||||
window.SetApplicationName("TomoClock")
|
||||
container := elements.NewVBox(elements.SpaceBoth)
|
||||
container := basicElements.NewContainer(basicLayouts.Vertical { true, true })
|
||||
window.Adopt(container)
|
||||
|
||||
clock := fun.NewAnalogClock(time.Now())
|
||||
label := elements.NewLabel(formatTime())
|
||||
container.AdoptExpand(clock)
|
||||
container.Adopt(label)
|
||||
container.Adopt(clock, true)
|
||||
label := basicElements.NewLabel(formatTime(), false)
|
||||
container.Adopt(label, false)
|
||||
|
||||
window.OnClose(nasin.Stop)
|
||||
window.OnClose(tomo.Stop)
|
||||
window.Show()
|
||||
go tick(label, clock)
|
||||
return nil
|
||||
}
|
||||
|
||||
func formatTime () (timeString string) {
|
||||
return time.Now().Format("2006-01-02 15:04:05")
|
||||
}
|
||||
|
||||
func tick (label *elements.Label, clock *fun.AnalogClock) {
|
||||
func tick (label *basicElements.Label, clock *fun.AnalogClock) {
|
||||
for {
|
||||
nasin.Do (func () {
|
||||
tomo.Do (func () {
|
||||
label.SetText(formatTime())
|
||||
clock.SetTime(time.Now())
|
||||
})
|
||||
|
|
|
@ -0,0 +1,25 @@
|
|||
package main
|
||||
|
||||
import "git.tebibyte.media/sashakoshka/tomo"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/layouts/basic"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/basic"
|
||||
import _ "git.tebibyte.media/sashakoshka/tomo/backends/x"
|
||||
|
||||
func main () {
|
||||
tomo.Run(run)
|
||||
}
|
||||
|
||||
func run () {
|
||||
window, _ := tomo.NewWindow(360, 2)
|
||||
window.SetTitle("horizontal stack")
|
||||
|
||||
container := basicElements.NewContainer(basicLayouts.Horizontal { true, true })
|
||||
window.Adopt(container)
|
||||
|
||||
container.Adopt(basicElements.NewLabel("this is sample text", true), true)
|
||||
container.Adopt(basicElements.NewLabel("this is sample text", true), true)
|
||||
container.Adopt(basicElements.NewLabel("this is sample text", true), true)
|
||||
|
||||
window.OnClose(tomo.Stop)
|
||||
window.Show()
|
||||
}
|
|
@ -1,46 +0,0 @@
|
|||
package main
|
||||
|
||||
import "tomo"
|
||||
import "tomo/nasin"
|
||||
import "tomo/elements"
|
||||
|
||||
func main () {
|
||||
nasin.Run(Application { })
|
||||
}
|
||||
|
||||
type Application struct { }
|
||||
|
||||
func (Application) Init () error {
|
||||
window, err := nasin.NewWindow(tomo.Bounds(0, 0, 360, 0))
|
||||
if err != nil { return err }
|
||||
window.SetTitle("Icons")
|
||||
|
||||
container := elements.NewVBox(elements.SpaceBoth)
|
||||
window.Adopt(container)
|
||||
|
||||
container.Adopt (
|
||||
elements.NewLabel("Just some of the wonderful icons we have:"),
|
||||
elements.NewLine())
|
||||
container.AdoptExpand (
|
||||
icons(tomo.IconHome, tomo.IconHistory),
|
||||
icons(tomo.IconFile, tomo.IconNetwork),
|
||||
icons(tomo.IconOpen, tomo.IconRemoveFavorite),
|
||||
icons(tomo.IconCursor, tomo.IconDistort))
|
||||
|
||||
closeButton := elements.NewButton("Yes verynice")
|
||||
closeButton.SetIcon(tomo.IconYes)
|
||||
closeButton.OnClick(window.Close)
|
||||
container.Adopt(closeButton)
|
||||
|
||||
window.OnClose(nasin.Stop)
|
||||
window.Show()
|
||||
return nil
|
||||
}
|
||||
|
||||
func icons (min, max tomo.Icon) (container *elements.Box) {
|
||||
container = elements.NewHBox(elements.SpaceMargin)
|
||||
for index := min; index <= max; index ++ {
|
||||
container.AdoptExpand(elements.NewIcon(index, tomo.IconSizeSmall))
|
||||
}
|
||||
return
|
||||
}
|
|
@ -5,59 +5,54 @@ import "image"
|
|||
import "bytes"
|
||||
import _ "image/png"
|
||||
import "github.com/jezek/xgbutil/gopher"
|
||||
import "tomo"
|
||||
import "tomo/nasin"
|
||||
import "tomo/popups"
|
||||
import "tomo/elements"
|
||||
import "git.tebibyte.media/sashakoshka/tomo"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/popups"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/layouts/basic"
|
||||
import "git.tebibyte.media/sashakoshka/tomo/elements/basic"
|
||||
import _ "git.tebibyte.media/sashakoshka/tomo/backends/x"
|
||||
|
||||
func main () {
|
||||
nasin.Run(Application { })
|
||||
tomo.Run(run)
|
||||
}
|
||||
|
||||
type Application struct { }
|
||||
|
||||
func (Application) Init () error {
|
||||
window, _ := nasin.NewWindow(tomo.Bounds(0, 0, 0, 0))
|
||||
func run () {
|
||||
window, _ := tomo.NewWindow(2, 2)
|
||||
window.SetTitle("Tomo Logo")
|
||||
|
||||
file, err := os.Open("assets/banner.png")
|
||||
if err != nil { return err }
|
||||
if err != nil { fatalError(err); return }
|
||||
logo, _, err := image.Decode(file)
|
||||
file.Close()
|
||||
if err != nil { return err }
|
||||
if err != nil { fatalError(err); return }
|
||||
|
||||
container := elements.NewVBox(elements.SpaceBoth)
|
||||
logoImage := elements.NewImage(logo)
|
||||
button := elements.NewButton("Show me a gopher instead")
|
||||
button.OnClick (func () {
|
||||
window.SetTitle("Not the Tomo Logo")
|
||||
container.DisownAll()
|
||||
gopher, _, err :=
|
||||
image.Decode(bytes.NewReader(gopher.GopherPng()))
|
||||
if err != nil { fatalError(window, err); return }
|
||||
container.AdoptExpand(elements.NewImage(gopher))
|
||||
})
|
||||
container := basicElements.NewContainer(basicLayouts.Vertical { true, true })
|
||||
logoImage := basicElements.NewImage(logo)
|
||||
button := basicElements.NewButton("Show me a gopher instead")
|
||||
button.OnClick (func () { container.Warp (func () {
|
||||
container.DisownAll()
|
||||
gopher, _, err :=
|
||||
image.Decode(bytes.NewReader(gopher.GopherPng()))
|
||||
if err != nil { fatalError(err); return }
|
||||
container.Adopt(basicElements.NewImage(gopher),true)
|
||||
}) })
|
||||
|
||||
container.AdoptExpand(logoImage)
|
||||
container.Adopt(button)
|
||||
container.Adopt(logoImage, true)
|
||||
container.Adopt(button, false)
|
||||
window.Adopt(container)
|
||||
|
||||
button.Focus()
|
||||
|
||||
window.OnClose(nasin.Stop)
|
||||
window.OnClose(tomo.Stop)
|
||||
window.Show()
|
||||
return nil
|
||||
}
|
||||
|
||||
func fatalError (window tomo.Window, err error) {
|
||||
func fatalError (err error) {
|
||||
popups.NewDialog (
|
||||
popups.DialogKindError,
|
||||
window,
|
||||
"Error",
|
||||
err.Error(),
|
||||
popups.Button {
|
||||
Name: "OK",
|
||||
OnPress: nasin.Stop,
|
||||
OnPress: tomo.Stop,
|
||||
})
|
||||
}
|
||||
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue