objects/scrollbar.go

package objects

import "image"
import "git.tebibyte.media/tomo/tomo"
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)
	
	this.handle.SetRole(tomo.R("objects", "SliderHandle", orient))
	this.SetRole(tomo.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 ContentObject. Closing the returned cookie
// will unlink it.
func (this *Scrollbar) Link (box tomo.ContentObject) 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.GetBox().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 tomo.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.ContentObject
}

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. we are the layout
		// and we shouldn't be adding and removing boxes, so this is
		// really the only good way to hide things.
		// TODO perhaps have a "Hidden" rectangle in the Tomo API?
		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.GetBox().InnerBounds().Dy())
	} else {
		return float64(this.linked.GetBox().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)
	}
}