365 lines
9.1 KiB
Go
365 lines
9.1 KiB
Go
package objects
|
|
|
|
import "image"
|
|
import "git.tebibyte.media/tomo/tomo"
|
|
import "git.tebibyte.media/tomo/tomo/theme"
|
|
import "git.tebibyte.media/tomo/tomo/input"
|
|
import "git.tebibyte.media/tomo/tomo/event"
|
|
|
|
// Scrollbar is a special type of slider that can control the scroll of any
|
|
// overflowing ContainerBox.
|
|
type Scrollbar struct {
|
|
tomo.ContainerBox
|
|
handle *SliderHandle
|
|
layout scrollbarLayout
|
|
dragging bool
|
|
dragOffset image.Point
|
|
|
|
linkCookie event.Cookie
|
|
|
|
on struct {
|
|
valueChange event.FuncBroadcaster
|
|
}
|
|
}
|
|
|
|
func newScrollbar (orient string) *Scrollbar {
|
|
this := &Scrollbar {
|
|
ContainerBox: tomo.NewContainerBox(),
|
|
handle: &SliderHandle {
|
|
Box: tomo.NewBox(),
|
|
},
|
|
layout: scrollbarLayout {
|
|
vertical: orient == "vertical",
|
|
},
|
|
}
|
|
|
|
this.Add(this.handle)
|
|
this.SetFocusable(true)
|
|
|
|
this.CaptureDND(true)
|
|
this.CaptureMouse(true)
|
|
this.CaptureScroll(true)
|
|
this.CaptureKeyboard(true)
|
|
|
|
this.OnKeyDown(this.handleKeyDown)
|
|
this.OnMouseDown(this.handleMouseDown)
|
|
this.OnMouseUp(this.handleMouseUp)
|
|
this.OnMouseMove(this.handleMouseMove)
|
|
this.OnScroll(this.handleScroll)
|
|
theme.Apply(this.handle, theme.R("objects", "SliderHandle", orient))
|
|
theme.Apply(this, theme.R("objects", "Slider", orient))
|
|
return this
|
|
}
|
|
|
|
// NewVerticalScrollbar creates a new vertical scrollbar.
|
|
func NewVerticalScrollbar () *Scrollbar {
|
|
return newScrollbar("vertical")
|
|
}
|
|
|
|
// NewHorizontalScrollbar creates a new horizontal scrollbar.
|
|
func NewHorizontalScrollbar () *Scrollbar {
|
|
return newScrollbar("horizontal")
|
|
}
|
|
|
|
// Link assigns this scrollbar to a ContentBox. Closing the returned cookie will
|
|
// unlink it.
|
|
func (this *Scrollbar) Link (box tomo.ContentBox) event.Cookie {
|
|
this.layout.linked = box
|
|
this.linkCookie = this.newLinkCookie (
|
|
box.OnContentBoundsChange(this.handleLinkedContentBoundsChange))
|
|
this.SetLayout(this.layout)
|
|
return this.linkCookie
|
|
}
|
|
|
|
func (this *Scrollbar) handleLinkedContentBoundsChange () {
|
|
if this.layout.linked == nil { return }
|
|
previousValue := this.layout.value
|
|
trackLength := this.layout.contentLength() - this.layout.viewportLength()
|
|
if trackLength == 0 {
|
|
this.layout.value = 0
|
|
} else {
|
|
this.layout.value = this.layout.contentPos() / trackLength
|
|
}
|
|
this.SetLayout(this.layout)
|
|
if this.layout.value != previousValue {
|
|
this.on.valueChange.Broadcast()
|
|
}
|
|
}
|
|
|
|
// SetValue sets the value of the scrollbar between 0 and 1, where 0 is scrolled
|
|
// all the way to the left/top, and 1 is scrolled all the way to the
|
|
// right/bottom.
|
|
func (this *Scrollbar) SetValue (value float64) {
|
|
if this.layout.linked == nil { return }
|
|
if value > 1 { value = 1 }
|
|
if value < 0 { value = 0 }
|
|
|
|
trackLength := this.layout.contentLength() - this.layout.viewportLength()
|
|
position := trackLength * value
|
|
point := this.layout.linked.ContentBounds().Min
|
|
if this.layout.vertical {
|
|
point.Y = -int(position)
|
|
} else {
|
|
point.X = -int(position)
|
|
}
|
|
this.layout.linked.ScrollTo(point)
|
|
|
|
}
|
|
|
|
// Value returns the value of the scrollbar between 0 and 1 where 0 is scrolled
|
|
// all the way to the left/top, and 1 is scrolled all the way to the
|
|
// right/bottom.
|
|
func (this *Scrollbar) Value () float64 {
|
|
if this.layout.linked == nil { return 0 }
|
|
return this.layout.value
|
|
}
|
|
|
|
// OnValueChange specifies a function to be called when the position of the
|
|
// scrollbar changes.
|
|
func (this *Scrollbar) OnValueChange (callback func ()) event.Cookie {
|
|
return this.on.valueChange.Connect(callback)
|
|
}
|
|
|
|
func (this *Scrollbar) handleKeyDown (key input.Key, numpad bool) {
|
|
var increment float64; if this.layout.vertical {
|
|
increment = -0.05
|
|
} else {
|
|
increment = 0.05
|
|
}
|
|
|
|
switch key {
|
|
case input.KeyUp, input.KeyLeft:
|
|
if this.Modifiers().Alt {
|
|
this.SetValue(0)
|
|
} else {
|
|
this.SetValue(this.Value() - increment)
|
|
}
|
|
case input.KeyDown, input.KeyRight:
|
|
if this.Modifiers().Alt {
|
|
this.SetValue(1)
|
|
} else {
|
|
this.SetValue(this.Value() + increment)
|
|
}
|
|
case input.KeyHome:
|
|
this.SetValue(0)
|
|
case input.KeyEnd:
|
|
this.SetValue(1)
|
|
}
|
|
}
|
|
|
|
func (this *Scrollbar) handleMouseDown (button input.Button) {
|
|
pointer := this.MousePosition()
|
|
handle := this.handle.Bounds()
|
|
|
|
within := pointer.In(handle)
|
|
var above bool; if this.layout.vertical {
|
|
above = pointer.Y < handle.Min.Y + handle.Dy() / 2
|
|
} else {
|
|
above = pointer.X < handle.Min.X + handle.Dx() / 2
|
|
}
|
|
|
|
switch button {
|
|
case input.ButtonLeft:
|
|
if within {
|
|
this.dragging = true
|
|
this.dragOffset =
|
|
pointer.Sub(this.handle.Bounds().Min).
|
|
Add(this.InnerBounds().Min)
|
|
this.drag()
|
|
} else {
|
|
this.dragOffset = this.fallbackDragOffset()
|
|
this.dragging = true
|
|
this.drag()
|
|
}
|
|
case input.ButtonMiddle:
|
|
if above {
|
|
this.scrollBy(this.pageSize())
|
|
} else {
|
|
this.scrollBy(-this.pageSize())
|
|
}
|
|
case input.ButtonRight:
|
|
if above {
|
|
this.scrollBy(this.stepSize())
|
|
} else {
|
|
this.scrollBy(-this.stepSize())
|
|
}
|
|
}
|
|
}
|
|
|
|
func (this *Scrollbar) handleMouseUp (button input.Button) {
|
|
if button != input.ButtonLeft || !this.dragging { return }
|
|
this.dragging = false
|
|
}
|
|
|
|
func (this *Scrollbar) handleMouseMove () {
|
|
if !this.dragging { return }
|
|
this.drag()
|
|
}
|
|
|
|
func (this *Scrollbar) handleScroll (x, y float64) {
|
|
if this.layout.linked == nil { return }
|
|
this.layout.linked.ScrollTo (
|
|
this.layout.linked.ContentBounds().Min.
|
|
Sub(image.Pt(int(x), int(y))))
|
|
}
|
|
|
|
func (this *Scrollbar) drag () {
|
|
pointer := this.MousePosition().Sub(this.dragOffset)
|
|
gutter := this.InnerBounds()
|
|
handle := this.handle.Bounds()
|
|
|
|
if this.layout.vertical {
|
|
this.SetValue (
|
|
float64(pointer.Y) /
|
|
float64(gutter.Dy() - handle.Dy()))
|
|
} else {
|
|
this.SetValue (
|
|
float64(pointer.X) /
|
|
float64(gutter.Dx() - handle.Dx()))
|
|
}
|
|
}
|
|
|
|
func (this *Scrollbar) fallbackDragOffset () image.Point {
|
|
if this.layout.vertical {
|
|
return this.InnerBounds().Min.
|
|
Add(image.Pt(0, this.handle.Bounds().Dy() / 2))
|
|
} else {
|
|
return this.InnerBounds().Min.
|
|
Add(image.Pt(this.handle.Bounds().Dx() / 2, 0))
|
|
}
|
|
}
|
|
|
|
func (this *Scrollbar) pageSize () int {
|
|
if this.layout.linked == nil { return 0 }
|
|
viewport := this.layout.linked.InnerBounds()
|
|
if this.layout.vertical {
|
|
return viewport.Dy()
|
|
} else {
|
|
return viewport.Dx()
|
|
}
|
|
}
|
|
|
|
func (this *Scrollbar) stepSize () int {
|
|
// FIXME: this should not be hardcoded, need to get base font metrics
|
|
// from theme somehow. should be (emspace, lineheight)
|
|
return 16
|
|
}
|
|
|
|
func (this *Scrollbar) scrollBy (distance int) {
|
|
if this.layout.linked == nil { return }
|
|
var vector image.Point; if this.layout.vertical {
|
|
vector.Y = distance
|
|
} else {
|
|
vector.X = distance
|
|
}
|
|
this.layout.linked.ScrollTo (
|
|
this.layout.linked.ContentBounds().Min.
|
|
Add(vector))
|
|
}
|
|
|
|
type scrollbarCookie struct {
|
|
owner *Scrollbar
|
|
subCookies []event.Cookie
|
|
}
|
|
|
|
func (this *Scrollbar) newLinkCookie (subCookies ...event.Cookie) *scrollbarCookie {
|
|
return &scrollbarCookie {
|
|
owner: this,
|
|
subCookies: subCookies,
|
|
}
|
|
}
|
|
|
|
func (this *scrollbarCookie) Close () {
|
|
for _, cookie := range this.subCookies {
|
|
cookie.Close()
|
|
}
|
|
this.owner.layout.linked = nil
|
|
this.owner.SetLayout(this.owner.layout)
|
|
}
|
|
|
|
type scrollbarLayout struct {
|
|
vertical bool
|
|
value float64
|
|
linked tomo.ContentBox
|
|
}
|
|
|
|
func (scrollbarLayout) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
|
|
if len(boxes) != 1 { return image.Pt(0, 0) }
|
|
return boxes[0].MinimumSize()
|
|
}
|
|
|
|
func (this scrollbarLayout) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
|
|
if len(boxes) != 1 { return }
|
|
handle := image.Rectangle { Max: boxes[0].MinimumSize() }
|
|
gutter := hints.Bounds
|
|
|
|
var gutterLength float64;
|
|
var handleMin float64;
|
|
if this.vertical {
|
|
gutterLength = float64(gutter.Dy())
|
|
handleMin = float64(handle.Dy())
|
|
} else {
|
|
gutterLength = float64(gutter.Dx())
|
|
handleMin = float64(handle.Dx())
|
|
}
|
|
|
|
// calculate handle length
|
|
handleLength := gutterLength * this.viewportContentRatio()
|
|
if handleLength < handleMin { handleLength = handleMin }
|
|
if handleLength >= gutterLength {
|
|
// just hide the handle if it isn't needed.
|
|
// TODO: we need a way to hide and show boxes, this is janky as
|
|
// fuck
|
|
boxes[0].SetBounds(image.Rect(-16, -16, 0, 0))
|
|
return
|
|
}
|
|
if this.vertical {
|
|
handle.Max.Y = int(handleLength)
|
|
} else {
|
|
handle.Max.X = int(handleLength)
|
|
}
|
|
|
|
// calculate handle position
|
|
handlePosition := (gutterLength - handleLength) * this.value
|
|
var handleOffset image.Point
|
|
if this.vertical {
|
|
handleOffset = image.Pt(0, int(handlePosition))
|
|
} else {
|
|
handleOffset = image.Pt(int(handlePosition), 0)
|
|
}
|
|
handle = handle.Sub(handleOffset).Add(gutter.Min)
|
|
|
|
// place handle
|
|
boxes[0].SetBounds(handle)
|
|
|
|
}
|
|
|
|
func (this scrollbarLayout) viewportContentRatio () float64 {
|
|
if this.linked == nil { return 0 }
|
|
return this.viewportLength() / this.contentLength()
|
|
}
|
|
|
|
func (this scrollbarLayout) viewportLength () float64 {
|
|
if this.vertical {
|
|
return float64(this.linked.InnerBounds().Dy())
|
|
} else {
|
|
return float64(this.linked.InnerBounds().Dx())
|
|
}
|
|
}
|
|
|
|
func (this scrollbarLayout) contentLength () float64 {
|
|
if this.vertical {
|
|
return float64(this.linked.ContentBounds().Dy())
|
|
} else {
|
|
return float64(this.linked.ContentBounds().Dx())
|
|
}
|
|
}
|
|
|
|
func (this scrollbarLayout) contentPos () float64 {
|
|
if this.vertical {
|
|
return float64(this.linked.ContentBounds().Min.Y)
|
|
} else {
|
|
return float64(this.linked.ContentBounds().Min.X)
|
|
}
|
|
}
|