241 lines
6.6 KiB
Go
241 lines
6.6 KiB
Go
package elements
|
|
|
|
import "image"
|
|
import "git.tebibyte.media/sashakoshka/tomo"
|
|
import "git.tebibyte.media/sashakoshka/tomo/input"
|
|
import "git.tebibyte.media/sashakoshka/tomo/artist"
|
|
import "git.tebibyte.media/sashakoshka/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 artist.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(artist.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 artist.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)
|
|
}
|