tomo/objects
tomo/objects
1
0
Fork 0
Code Issues 4 Pull Requests Packages Projects Releases 27 Wiki Activity

Update code for layouts, objects

Browse Source
This commit is contained in:
Sasha Koshka 2024-07-21 11:48:28 -04:00
parent 9077015db6
commit 6ca6771fc6
26 changed files with 447 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
button.go
View File

@ -28,17 +28,16 @@ func NewButton (text string) *Button {
ContainerBox: tomo.NewContainerBox(),
label: NewLabel(text),
}
box.SetRole(tomo.R("objects", "Button", ""))
box.label.SetAlign(tomo.AlignMiddle, tomo.AlignMiddle)
box.SetRole(tomo.R("objects", "Button"))
box.label.SetAttr(tomo.AAlign(tomo.AlignMiddle, tomo.AlignMiddle))
box.SetLayout(buttonLayout)
box.SetText(text)
box.CaptureDND(true)
box.CaptureMouse(true)
box.CaptureScroll(true)
box.CaptureKeyboard(true)
box.CatchDND(true)
box.CatchMouse(true)
box.OnMouseUp(box.handleMouseUp)
box.OnButtonDown(box.handleButtonDown)
box.OnButtonUp(box.handleButtonUp)
box.OnKeyUp(box.handleKeyUp)
box.SetFocusable(true)
return box
@ -89,14 +88,19 @@ func (this *Button) applyLayout () {
}
}
func (this *Button) handleKeyUp (key input.Key, numberPad bool) {
func (this *Button) handleKeyUp (catch func (), key input.Key, numberPad bool) {
if key != input.KeyEnter && key != input.Key(' ') { return }
this.on.click.Broadcast()
}
func (this *Button) handleMouseUp (button input.Button) {
func (this *Button) handleButtonDown (catch func (), button input.Button) {
catch()
}
func (this *Button) handleButtonUp (catch func (), button input.Button) {
catch()
if button != input.ButtonLeft { return }
if this.MousePosition().In(this.Bounds()) {
if this.Window().MousePosition().In(this.Bounds()) {
this.on.click.Broadcast()
}
}

20
calendar.go
View File

@ -26,7 +26,7 @@ func NewCalendar (tm time.Time) *Calendar {
ContainerBox: tomo.NewContainerBox(),
time: tm,
}
calendar.SetRole(tomo.R("objects", "Calendar", ""))
calendar.SetRole(tomo.R("objects", "Calendar"))
calendar.SetLayout(layouts.ContractVertical)
prevButton := NewButton("")
@ -42,10 +42,10 @@ func NewCalendar (tm time.Time) *Calendar {
calendar.on.valueChange.Broadcast()
})
calendar.monthLabel = NewLabel("")
calendar.monthLabel.SetAlign(tomo.AlignMiddle, tomo.AlignMiddle)
calendar.monthLabel.SetAttr(tomo.AAlign(tomo.AlignMiddle, tomo.AlignMiddle))
calendar.grid = tomo.NewContainerBox()
calendar.grid.SetRole(tomo.R("objects", "CalendarGrid", ""))
calendar.grid.SetRole(tomo.R("objects", "CalendarGrid"))
calendar.grid.SetLayout(layouts.NewGrid (
true, true, true, true, true, true, true)())
calendar.Add(NewInnerContainer (
@ -54,7 +54,6 @@ func NewCalendar (tm time.Time) *Calendar {
calendar.Add(calendar.grid)
calendar.OnScroll(calendar.handleScroll)
calendar.CaptureScroll(true)
calendar.refresh()
return calendar
@ -98,9 +97,9 @@ func (this *Calendar) refresh () {
this.grid.Clear()
for _, day := range weekdayAbbreviations {
dayLabel := tomo.NewTextBox()
dayLabel.SetRole(tomo.R("objects", "CalendarWeekdayHeader", ""))
dayLabel.SetRole(tomo.R("objects", "CalendarWeekdayHeader"))
dayLabel.SetText(day)
dayLabel.SetAlign(tomo.AlignMiddle, tomo.AlignMiddle)
dayLabel.SetAttr(tomo.AAlign(tomo.AlignMiddle, tomo.AlignMiddle))
this.grid.Add(dayLabel)
}
@ -116,9 +115,11 @@ func (this *Calendar) refresh () {
day := tomo.NewTextBox()
day.SetText(fmt.Sprint(dayIter))
if weekday == 1 || weekday == 0 {
day.SetRole(tomo.R("objects", "CalendarDay", "weekend"))
day.SetRole(tomo.R("objects", "CalendarDay"))
day.SetTag("weekend", true)
} else {
day.SetRole(tomo.R("objects", "CalendarDay", "weekday"))
day.SetRole(tomo.R("objects", "CalendarDay"))
day.SetTag("weekday", true)
}
this.grid.Add(day)
} else {
@ -127,7 +128,8 @@ func (this *Calendar) refresh () {
}
}
func (this *Calendar) handleScroll (x, y float64) {
func (this *Calendar) handleScroll (catch func (), x, y float64) {
catch()
if y < 0 {
this.prevMonth()
} else {

24
checkbox.go
View File

@ -18,10 +18,11 @@ func NewCheckbox (value bool) *Checkbox {
box := &Checkbox {
Box: tomo.NewBox(),
}
box.SetRole(tomo.R("objects", "Checkbox", ""))
box.SetRole(tomo.R("objects", "Checkbox"))
box.SetValue(value)
box.OnMouseUp(box.handleMouseUp)
box.OnButtonDown(box.handleButtonDown)
box.OnButtonUp(box.handleButtonUp)
box.OnKeyUp(box.handleKeyUp)
box.SetFocusable(true)
return box
@ -35,11 +36,9 @@ func (this *Checkbox) Value () bool {
// SetValue sets the value of the checkbox.
func (this *Checkbox) SetValue (value bool) {
this.value = value
if this.value {
this.SetTextureCenter(tomo.IconCheckboxChecked.Texture(tomo.IconSizeSmall))
} else {
this.SetTextureCenter(tomo.IconCheckboxUnchecked.Texture(tomo.IconSizeSmall))
}
// the theme shall decide what checked and unchecked states look like
this.SetTag("checked", value)
this.SetTag("unchecked", !value)
}
// Toggle toggles the value of the checkbox between true and false.
@ -53,14 +52,19 @@ func (this *Checkbox) OnValueChange (callback func ()) event.Cookie {
return this.on.valueChange.Connect(callback)
}
func (this *Checkbox) handleKeyUp (key input.Key, numberPad bool) {
func (this *Checkbox) handleKeyUp (catch func (), key input.Key, numberPad bool) {
if key != input.KeyEnter && key != input.Key(' ') { return }
this.Toggle()
}
func (this *Checkbox) handleMouseUp (button input.Button) {
func (this *Checkbox) handleButtonDown (catch func (), button input.Button) {
catch()
}
func (this *Checkbox) handleButtonUp (catch func (), button input.Button) {
catch()
if button != input.ButtonLeft { return }
if this.MousePosition().In(this.Bounds()) {
if this.Window().MousePosition().In(this.Bounds()) {
this.Toggle()
}
}

14
colorpicker.go
View File

@ -28,7 +28,7 @@ func NewColorPicker (value color.Color) *ColorPicker {
picker := &ColorPicker {
ContainerBox: tomo.NewContainerBox(),
}
picker.SetRole(tomo.R("objects", "ColorPicker", ""))
picker.SetRole(tomo.R("objects", "ColorPicker"))
picker.SetLayout(layouts.Row { true, false, false })
picker.pickerMap = newColorPickerMap(picker)
picker.Add(picker.pickerMap)
@ -90,20 +90,20 @@ func newColorPickerMap (parent *ColorPicker) *colorPickerMap {
parent: parent,
}
picker.SetDrawer(picker)
picker.SetRole(tomo.R("objects", "ColorPickerMap", ""))
picker.OnMouseUp(picker.handleMouseUp)
picker.OnMouseDown(picker.handleMouseDown)
picker.SetRole(tomo.R("objects", "ColorPickerMap"))
picker.OnButtonUp(picker.handleButtonUp)
picker.OnButtonDown(picker.handleButtonDown)
picker.OnMouseMove(picker.handleMouseMove)
return picker
}
func (this *colorPickerMap) handleMouseDown (button input.Button) {
func (this *colorPickerMap) handleButtonDown (catch func (), button input.Button) {
if button != input.ButtonLeft { return }
this.dragging = true
this.drag()
}
func (this *colorPickerMap) handleMouseUp (button input.Button) {
func (this *colorPickerMap) handleButtonUp (catch func (), button input.Button) {
if button != input.ButtonLeft || !this.dragging { return }
this.dragging = false
}
@ -114,7 +114,7 @@ func (this *colorPickerMap) handleMouseMove () {
}
func (this *colorPickerMap) drag () {
pointer := this.MousePosition()
pointer := this.Window().MousePosition()
bounds := this.InnerBounds()
this.parent.value.S = float64(pointer.X - bounds.Min.X) / float64(bounds.Dx())
this.parent.value.V = 1 - float64(pointer.Y - bounds.Min.Y) / float64(bounds.Dy())

9
container.go
View File

@ -27,7 +27,8 @@ func newContainer (layout tomo.Layout, children ...tomo.Object) *Container {
// window, tab pane, etc.
func NewOuterContainer (layout tomo.Layout, children ...tomo.Object) *Container {
this := newContainer(layout, children...)
this.SetRole(tomo.R("objects", "Container", "outer"))
this.SetRole(tomo.R("objects", "Container"))
this.SetTag("outer", true)
return this
}
@ -35,14 +36,16 @@ func NewOuterContainer (layout tomo.Layout, children ...tomo.Object) *Container
// around it. It is meant to be used as a root container for a ScrollContainer.
func NewSunkenContainer (layout tomo.Layout, children ...tomo.Object) *Container {
this := newContainer(layout, children...)
this.SetRole(tomo.R("objects", "Container", "sunken"))
this.SetRole(tomo.R("objects", "Container"))
this.SetTag("sunken", true)
return this
}
// NewInnerContainer creates a new container that has no padding around it.
func NewInnerContainer (layout tomo.Layout, children ...tomo.Object) *Container {
this := newContainer(layout, children...)
this.SetRole(tomo.R("objects", "Container", "inner"))
this.SetRole(tomo.R("objects", "Container"))
this.SetTag("inner", true)
return this
}

4
dialog.go
View File

@ -55,7 +55,7 @@ func NewDialog (kind DialogKind, parent tomo.Window, title, message string, opti
dialog.SetTitle(title)
icon := NewIcon(iconId, tomo.IconSizeLarge)
messageText := NewLabel(message)
messageText.SetAlign(tomo.AlignStart, tomo.AlignMiddle)
messageText.SetAttr(tomo.AAlign(tomo.AlignStart, tomo.AlignMiddle))
for _, option := range options {
if option, ok := option.(clickable); ok {
@ -63,7 +63,7 @@ func NewDialog (kind DialogKind, parent tomo.Window, title, message string, opti
}
}
dialog.controlRow = NewInnerContainer(layouts.ContractHorizontal, options...)
dialog.controlRow.SetAlign(tomo.AlignEnd, tomo.AlignEnd)
messageText.SetAttr(tomo.AAlign(tomo.AlignEnd, tomo.AlignEnd))
dialog.SetRoot(NewOuterContainer (
layouts.Column { true, false },

3
heading.go
View File

@ -15,7 +15,8 @@ func NewHeading (level int, text string) *Heading {
if level < 0 { level = 0 }
if level > 2 { level = 2 }
this := &Heading { TextBox: tomo.NewTextBox() }
this.SetRole(tomo.R("objects", "Heading", fmt.Sprint(level)))
this.SetRole(tomo.R("objects", "Heading"))
this.SetTag(fmt.Sprint(level), true)
this.SetText(text)
return this
}

29
icon.go
View File

@ -1,6 +1,5 @@
package objects
import "image"
import "git.tebibyte.media/tomo/tomo"
import "git.tebibyte.media/tomo/tomo/data"
import "git.tebibyte.media/tomo/tomo/canvas"
@ -10,13 +9,22 @@ type Icon struct {
tomo.Box
}
func iconSizeString (size tomo.IconSize) string {
switch size {
case tomo.IconSizeLarge: return "large"
case tomo.IconSizeMedium: return "medium"
default: return "small"
}
}
// NewIcon creates a new icon from an icon ID.
func NewIcon (id tomo.Icon, size tomo.IconSize) *Icon {
this := &Icon {
Box: tomo.NewBox(),
}
this.SetRole(tomo.R("objects", "Icon", size.String()))
this.SetTexture(id.Texture(size))
this.SetRole(tomo.R("objects", "Icon"))
this.SetTag(iconSizeString(size), true)
this.setTexture(id.Texture(size))
return this
}
@ -25,17 +33,20 @@ func NewMimeIcon (mime data.Mime, size tomo.IconSize) *Icon {
this := &Icon {
Box: tomo.NewBox(),
}
this.SetRole(tomo.R("objects", "Icon", size.String()))
this.SetTexture(tomo.MimeIcon(mime, size))
this.SetRole(tomo.R("objects", "Icon"))
this.SetTag(iconSizeString(size), true)
this.setTexture(tomo.MimeIcon(mime, size))
return this
}
func (this *Icon) SetTexture (texture canvas.Texture) {
this.Box.SetTextureCenter(texture)
func (this *Icon) setTexture (texture canvas.Texture) {
this.SetAttr(tomo.ATexture(texture))
this.SetAttr(tomo.ATextureMode(tomo.TextureModeCenter))
if texture == nil {
this.SetMinimumSize(image.Pt(0, 0))
this.SetAttr(tomo.AMinimumSize(0, 0))
} else {
bounds := texture.Bounds()
this.SetMinimumSize(bounds.Max.Sub(bounds.Min))
this.SetAttr(tomo.AttrMinimumSize(bounds.Max.Sub(bounds.Min)))
}
}

4
label.go
View File

@ -10,8 +10,8 @@ type Label struct {
// NewLabel creates a new text label.
func NewLabel (text string) *Label {
this := &Label { TextBox: tomo.NewTextBox() }
this.SetRole(tomo.R("objects", "Label", ""))
this.SetRole(tomo.R("objects", "Label"))
this.SetText(text)
this.SetAlign(tomo.AlignStart, tomo.AlignMiddle)
this.SetAttr(tomo.AAlign(tomo.AlignStart, tomo.AlignMiddle))
return this
}

17
labelcheckbox.go
View File

@ -20,14 +20,14 @@ func NewLabelCheckbox (value bool, text string) *LabelCheckbox {
checkbox: NewCheckbox(value),
label: NewLabel(text),
}
box.SetRole(tomo.R("objects", "LabelCheckbox", ""))
box.label.SetAlign(tomo.AlignStart, tomo.AlignMiddle)
box.SetRole(tomo.R("objects", "LabelCheckbox"))
box.label.SetAttr(tomo.AAlign(tomo.AlignStart, tomo.AlignMiddle))
box.Add(box.checkbox)
box.Add(box.label)
box.SetLayout(layouts.Row { false, true })
box.OnMouseUp(box.handleMouseUp)
box.label.OnMouseUp(box.handleMouseUp)
box.OnButtonDown(box.handleButtonDown)
box.OnButtonUp(box.handleButtonUp)
return box
}
@ -52,9 +52,14 @@ func (this *LabelCheckbox) OnValueChange (callback func ()) event.Cookie {
return this.checkbox.OnValueChange(callback)
}
func (this *LabelCheckbox) handleMouseUp (button input.Button) {
func (this *LabelCheckbox) handleButtonDown (capture func (), button input.Button) {
capture()
}
func (this *LabelCheckbox) handleButtonUp (capture func (), button input.Button) {
capture()
if button != input.ButtonLeft { return }
if this.MousePosition().In(this.Bounds()) {
if this.Window().MousePosition().In(this.Bounds()) {
this.checkbox.SetFocused(true)
this.checkbox.Toggle()
}

17
labelswatch.go
View File

@ -21,15 +21,15 @@ func NewLabelSwatch (value color.Color, text string) *LabelSwatch {
swatch: NewSwatch(value),
label: NewLabel(text),
}
box.SetRole(tomo.R("objects", "LabelSwatch", ""))
box.SetRole(tomo.R("objects", "LabelSwatch"))
box.swatch.label = text
box.label.SetAlign(tomo.AlignStart, tomo.AlignMiddle)
box.label.SetAttr(tomo.AAlign(tomo.AlignStart, tomo.AlignMiddle))
box.Add(box.swatch)
box.Add(box.label)
box.SetLayout(layouts.Row { false, true })
box.OnMouseUp(box.handleMouseUp)
box.label.OnMouseUp(box.handleMouseUp)
box.OnButtonDown(box.handleButtonDown)
box.OnButtonUp(box.handleButtonUp)
return box
}
@ -60,9 +60,14 @@ func (this *LabelSwatch) OnConfirm (callback func ()) event.Cookie {
return this.swatch.OnConfirm(callback)
}
func (this *LabelSwatch) handleMouseUp (button input.Button) {
func (this *LabelSwatch) handleButtonDown (catch func (), button input.Button) {
catch()
}
func (this *LabelSwatch) handleButtonUp (catch func (), button input.Button) {
catch()
if button != input.ButtonLeft { return }
if this.MousePosition().In(this.Bounds()) {
if this.Window().MousePosition().In(this.Bounds()) {
this.swatch.SetFocused(true)
this.swatch.Choose()
}

8
layouts/contract.go
View File

@ -15,19 +15,19 @@ const ContractVertical Contract = true
// ContractHorizontal is a horizontal contracted layout.
const ContractHorizontal Contract = false
func (contract Contract) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
func (contract Contract) MinimumSize (hints tomo.LayoutHints, boxes tomo.BoxQuerier) image.Point {
return contract.fallback().MinimumSize(hints, boxes)
}
func (contract Contract) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
func (contract Contract) Arrange (hints tomo.LayoutHints, boxes tomo.BoxArranger) {
contract.fallback().Arrange(hints, boxes)
}
func (contract Contract) RecommendedHeight (hints tomo.LayoutHints, boxes []tomo.Box, width int) int {
func (contract Contract) RecommendedHeight (hints tomo.LayoutHints, boxes tomo.BoxQuerier, width int) int {
return contract.fallback().RecommendedHeight(hints, boxes, width)
}
func (contract Contract) RecommendedWidth (hints tomo.LayoutHints, boxes []tomo.Box, height int) int {
func (contract Contract) RecommendedWidth (hints tomo.LayoutHints, boxes tomo.BoxQuerier, height int) int {
return contract.fallback().RecommendedWidth(hints, boxes, height)
}

25
layouts/flow.go
View File

@ -17,21 +17,21 @@ const FlowVertical Flow = true
// FlowHorizontal is a horizontal flow layout.
const FlowHorizontal Flow = false
func (flow Flow) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
func (flow Flow) MinimumSize (hints tomo.LayoutHints, boxes tomo.BoxQuerier) image.Point {
// TODO: write down somewhere that layout minimums aren't taken into
// account when the respective direction is overflowed
return flow.fallback().MinimumSize(hints, boxes)
}
func (flow Flow) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
func (flow Flow) Arrange (hints tomo.LayoutHints, boxes tomo.BoxArranger) {
if flow.v() && !hints.OverflowY || flow.h() && !hints.OverflowX {
flow.fallback().Arrange(hints, boxes)
}
// find a minor size value that will fit all boxes
minorSize := 0
for _, box := range boxes {
boxSize := flow.minor(box.MinimumSize())
for index := 0; index < boxes.Len(); index ++ {
boxSize := flow.minor(boxes.MinimumSize(index))
if boxSize > minorSize { minorSize = boxSize }
}
if minorSize == 0 { return }
@ -43,17 +43,16 @@ func (flow Flow) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
// arrange
point := hints.Bounds.Min
index := 0
for index < len(boxes) {
for index < boxes.Len() {
// get a slice of boxes for this major step
stepIndexEnd := index + minorSteps
if stepIndexEnd > len(boxes) { stepIndexEnd = len(boxes) }
step := boxes[index:stepIndexEnd]
if stepIndexEnd > boxes.Len() { stepIndexEnd = boxes.Len() }
index += minorSteps
// find a major size that will fit all boxes on this major step
majorSize := 0
for _, box := range step {
boxSize := flow.major(box.MinimumSize())
for index := index; index < stepIndexEnd; index ++ {
boxSize := flow.major(boxes.MinimumSize(index))
if boxSize > majorSize { majorSize = boxSize }
}
if majorSize == 0 { continue }
@ -62,9 +61,9 @@ func (flow Flow) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
var size image.Point
size = flow.incrMajor(size, majorSize)
size = flow.incrMinor(size, minorSize)
for _, box := range step {
for index := index; index < stepIndexEnd; index ++ {
bounds := image.Rectangle { Min: point, Max: point.Add(size) }
box.SetBounds(bounds)
boxes.SetBounds(index, bounds)
point = flow.incrMinor(point, minorSize + flow.minor(hints.Gap))
}
@ -125,12 +124,12 @@ func (flow Flow) fallback () tomo.Layout {
return Contract(flow)
}
func (flow Flow) RecommendedHeight (hints tomo.LayoutHints, boxes []tomo.Box, width int) int {
func (flow Flow) RecommendedHeight (hints tomo.LayoutHints, boxes tomo.BoxQuerier, width int) int {
// TODO
return 0
}
func (flow Flow) RecommendedWidth (hints tomo.LayoutHints, boxes []tomo.Box, height int) int {
func (flow Flow) RecommendedWidth (hints tomo.LayoutHints, boxes tomo.BoxQuerier, height int) int {
// TODO
return 0
}

22
layouts/grid.go
View File

@ -32,7 +32,7 @@ func NewGrid (columns ...bool) func (rows ...bool) *Grid {
}
}
func (this *Grid) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
func (this *Grid) MinimumSize (hints tomo.LayoutHints, boxes tomo.BoxQuerier) image.Point {
cols, rows := this.minimums(boxes)
size := image.Pt (
(len(cols) - 1) * hints.Gap.X,
@ -42,7 +42,7 @@ func (this *Grid) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.P
return size
}
func (this *Grid) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
func (this *Grid) Arrange (hints tomo.LayoutHints, boxes tomo.BoxArranger) {
xExpand := func (index int) bool {
return this.xExpand[index]
}
@ -56,9 +56,9 @@ func (this *Grid) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
expand(hints, rows, hints.Bounds.Dy(), yExpand)
position := hints.Bounds.Min
for index, box := range boxes {
for index := 0; index < boxes.Len(); index ++ {
col, row := index % len(cols), index / len(cols)
box.SetBounds(image.Rectangle {
boxes.SetBounds(index, image.Rectangle {
Min: position,
Max: position.Add(image.Pt(cols[col], rows[row])),
})
@ -71,13 +71,13 @@ func (this *Grid) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
}
}
func (this *Grid) minimums (boxes []tomo.Box) ([]int, []int) {
func (this *Grid) minimums (boxes tomo.BoxQuerier) ([]int, []int) {
nCols, nRows := this.dimensions(boxes)
cols, rows := make([]int, nCols), make([]int, nRows)
for index, box := range boxes {
for index := 0; index < boxes.Len(); index ++ {
col, row := index % len(cols), index / len(cols)
minimum := box.MinimumSize()
minimum := boxes.MinimumSize(index)
if cols[col] < minimum.X {
cols[col] = minimum.X
}
@ -89,8 +89,8 @@ func (this *Grid) minimums (boxes []tomo.Box) ([]int, []int) {
return cols, rows
}
func (this *Grid) dimensions (boxes []tomo.Box) (int, int) {
return len(this.xExpand), ceilDiv(len(boxes), len(this.xExpand))
func (this *Grid) dimensions (boxes tomo.BoxQuerier) (int, int) {
return len(this.xExpand), ceilDiv(boxes.Len(), len(this.xExpand))
}
func expand (hints tomo.LayoutHints, sizes []int, space int, expands func (int) bool) {
@ -116,10 +116,10 @@ func ceilDiv (x, y int) int {
return int(math.Ceil(float64(x) / float64(y)))
}
func (this *Grid) RecommendedHeight (hints tomo.LayoutHints, boxes []tomo.Box, width int) int {
func (this *Grid) RecommendedHeight (hints tomo.LayoutHints, boxes tomo.BoxQuerier, width int) int {
return this.MinimumSize(hints, boxes).Y
}
func (this *Grid) RecommendedWidth (hints tomo.LayoutHints, boxes []tomo.Box, height int) int {
func (this *Grid) RecommendedWidth (hints tomo.LayoutHints, boxes tomo.BoxQuerier, height int) int {
return this.MinimumSize(hints, boxes).X
}

134
layouts/rowcol.go
View File

@ -13,33 +13,33 @@ type Row []bool
// value will expand, and others will contract.
type Column []bool
func (column Column) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
func (column Column) MinimumSize (hints tomo.LayoutHints, boxes tomo.BoxQuerier) image.Point {
dot := image.Point { }
for _, box := range boxes {
minimum := box.MinimumSize()
for index := 0; index < boxes.Len(); index ++ {
minimum := boxes.MinimumSize(index)
dot.Y += minimum.Y
if dot.X < minimum.X {
dot.X = minimum.X
}
}
dot.Y += hints.Gap.Y * (len(boxes) - 1)
dot.Y += hints.Gap.Y * (boxes.Len() - 1)
return dot
}
func (row Row) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
func (row Row) MinimumSize (hints tomo.LayoutHints, boxes tomo.BoxQuerier) image.Point {
dot := image.Point { }
for _, box := range boxes {
minimum := box.MinimumSize()
for index := 0; index < boxes.Len(); index ++ {
minimum := boxes.MinimumSize(index)
dot.X += minimum.X
if dot.Y < minimum.Y {
dot.Y = minimum.Y
}
}
dot.X += hints.Gap.X * (len(boxes) - 1)
dot.X += hints.Gap.X * (boxes.Len() - 1)
return dot
}
func (column Column) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
func (column Column) Arrange (hints tomo.LayoutHints, boxes tomo.BoxArranger) {
expands := func (index int) bool {
if index >= len(column) { return false }
return column[index]
@ -48,13 +48,14 @@ func (column Column) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
// determine expanding box size
expandingSize := 0.0
if !hints.OverflowY {
gaps := len(boxes) - 1
gaps := boxes.Len() - 1
freeSpace := float64(hints.Bounds.Dy() - hints.Gap.Y * gaps)
nExpanding := 0; for index, box := range boxes {
nExpanding := 0;
for index := 0; index < boxes.Len(); index ++ {
if expands(index) {
nExpanding ++
} else {
freeSpace -= float64(box.MinimumSize().Y)
freeSpace -= float64(boxes.MinimumSize(index).Y)
}
}
expandingSize = freeSpace / float64(nExpanding)
@ -63,8 +64,8 @@ func (column Column) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
// determine width
width := 0
if hints.OverflowX {
for _, box := range boxes {
minimum := box.MinimumSize()
for index := 0; index < boxes.Len(); index ++ {
minimum := boxes.MinimumSize(index)
if width < minimum.X { width = minimum.X }
}
} else {
@ -73,44 +74,43 @@ func (column Column) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
// arrange
dot := hints.Bounds.Min
for index, box := range boxes {
bounds := make([]image.Rectangle, boxes.Len())
for index := 0; index < boxes.Len(); index ++ {
if index > 0 { dot.Y += hints.Gap.Y }
// determine height
height := box.MinimumSize().Y
height := boxes.MinimumSize(index).Y
if hints.OverflowY {
if box, ok := box.(tomo.ContentBox); ok {
height = box.RecommendedHeight(width)
}
height = boxes.RecommendedHeight(index, width)
} else {
if expands(index) {
height = int(expandingSize)
}
}
// set bounds
box.SetBounds(image.Rectangle {
// store bounds of this box
bounds[index] = image.Rectangle {
Min: dot,
Max: dot.Add(image.Pt(width, height)),
})
}
dot.Y += height
}
// align
height := dot.Y - hints.Bounds.Min.Y
offset := 0
switch hints.AlignY {
case tomo.AlignMiddle:
offset = (hints.Bounds.Dy() - height) / 2
case tomo.AlignEnd:
offset = hints.Bounds.Dy() - height
}
for _, box := range boxes {
box.SetBounds(box.Bounds().Add(image.Pt(0, offset)))
for index := 0; index < boxes.Len(); index ++ {
boxes.SetBounds(index, bounds[index].Add(image.Pt(0, offset)))
}
}
func (row Row) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
func (row Row) Arrange (hints tomo.LayoutHints, boxes tomo.BoxArranger) {
expands := func (index int) bool {
if index >= len(row) { return false }
return row[index]
@ -119,13 +119,14 @@ func (row Row) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
// determine expanding box size
expandingSize := 0.0
if !hints.OverflowY {
gaps := len(boxes) - 1
gaps := boxes.Len() - 1
freeSpace := float64(hints.Bounds.Dx() - hints.Gap.X * gaps)
nExpanding := 0; for index, box := range boxes {
nExpanding := 0;
for index := 0; index < boxes.Len(); index ++ {
if expands(index) {
nExpanding ++
} else {
freeSpace -= float64(box.MinimumSize().X)
freeSpace -= float64(boxes.MinimumSize(index).X)
}
}
expandingSize = freeSpace / float64(nExpanding)
@ -134,8 +135,8 @@ func (row Row) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
// determine height
height := 0
if hints.OverflowY {
for _, box := range boxes {
minimum := box.MinimumSize()
for index := 0; index < boxes.Len(); index ++ {
minimum := boxes.MinimumSize(index)
if height < minimum.Y { height = minimum.Y }
}
} else {
@ -144,95 +145,76 @@ func (row Row) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
// arrange
dot := hints.Bounds.Min
for index, box := range boxes {
bounds := make([]image.Rectangle, boxes.Len())
for index := 0; index < boxes.Len(); index ++ {
if index > 0 { dot.X += hints.Gap.X }
// determine width
width := box.MinimumSize().X
width := boxes.MinimumSize(index).X
if hints.OverflowY {
if box, ok := box.(tomo.ContentBox); ok {
width = box.RecommendedHeight(height)
}
width = boxes.RecommendedHeight(index, height)
} else {
if expands(index) {
width = int(expandingSize)
}
}
// set bounds
box.SetBounds(image.Rectangle {
// store bounds
bounds[index] = image.Rectangle {
Min: dot,
Max: dot.Add(image.Pt(width, height)),
})
}
dot.X += width
}
// align
width := dot.X - hints.Bounds.Min.X
offset := 0
switch hints.AlignX {
case tomo.AlignMiddle:
offset = (hints.Bounds.Dx() - width) / 2
case tomo.AlignEnd:
offset = hints.Bounds.Dx() - width
}
for _, box := range boxes {
box.SetBounds(box.Bounds().Add(image.Pt(offset, 0)))
for index := 0; index < boxes.Len(); index ++ {
boxes.SetBounds(index, bounds[index].Add(image.Pt(offset, 0)))
}
}
func (column Column) RecommendedHeight (hints tomo.LayoutHints, boxes []tomo.Box, width int) int {
func (column Column) RecommendedHeight (hints tomo.LayoutHints, boxes tomo.BoxQuerier, width int) int {
height := 0
for _, box := range boxes {
if box, ok := box.(tomo.ContentBox); ok {
height += box.RecommendedHeight(width)
} else {
height += box.MinimumSize().Y
for index := 0; index < boxes.Len(); index ++ {
height += boxes.RecommendedHeight(index, width)
}
}
height += hints.Gap.Y * (len(boxes) - 1)
height += hints.Gap.Y * (boxes.Len() - 1)
return height
}
func (row Row) RecommendedHeight (hints tomo.LayoutHints, boxes []tomo.Box, width int) int {
func (row Row) RecommendedHeight (hints tomo.LayoutHints, boxes tomo.BoxQuerier, width int) int {
height := 0
for _, box := range boxes {
minimum := box.MinimumSize()
boxHeight := 0
if box, ok := box.(tomo.ContentBox); ok {
boxHeight = box.RecommendedHeight(minimum.X)
} else {
boxHeight = minimum.Y
}
for index := 0; index < boxes.Len(); index ++ {
minimum := boxes.MinimumSize(index)
boxHeight := boxes.RecommendedHeight(index, minimum.X)
if boxHeight > height { height = boxHeight }
}
return height
}
func (column Column) RecommendedWidth (hints tomo.LayoutHints, boxes []tomo.Box, height int) int {
func (column Column) RecommendedWidth (hints tomo.LayoutHints, boxes tomo.BoxQuerier, height int) int {
width := 0
for _, box := range boxes {
minimum := box.MinimumSize()
boxWidth := 0
if box, ok := box.(tomo.ContentBox); ok {
boxWidth = box.RecommendedHeight(minimum.Y)
} else {
boxWidth = minimum.X
}
for index := 0; index < boxes.Len(); index ++ {
minimum := boxes.MinimumSize(index)
boxWidth := boxes.RecommendedWidth(index, minimum.Y)
if boxWidth > width { width = boxWidth }
}
return width
}
func (row Row) RecommendedWidth (hints tomo.LayoutHints, boxes []tomo.Box, height int) int {
func (row Row) RecommendedWidth (hints tomo.LayoutHints, boxes tomo.BoxQuerier, height int) int {
width := 0
for _, box := range boxes {
if box, ok := box.(tomo.ContentBox); ok {
width += box.RecommendedWidth(height)
} else {
width += box.MinimumSize().X
for index := 0; index < boxes.Len(); index ++ {
width += boxes.RecommendedWidth(index, height)
}
}
width += hints.Gap.X * (len(boxes) - 1)
width += hints.Gap.X * (boxes.Len() - 1)
return width
}

11
menu.go
View File

@ -40,15 +40,15 @@ func NewMenu (anchor tomo.Object, items ...tomo.Object) (*Menu, error) {
if !menu.torn {
menu.tearLine = tomo.NewBox()
menu.tearLine.SetRole(tomo.R("objects", "TearLine", ""))
menu.tearLine.SetRole(tomo.R("objects", "TearLine"))
menu.tearLine.SetFocusable(true)
menu.tearLine.OnKeyUp(func (key input.Key, numberPad bool) {
menu.tearLine.OnKeyUp(func (catch func (), key input.Key, numberPad bool) {
if key != input.KeyEnter && key != input.Key(' ') { return }
menu.TearOff()
})
menu.tearLine.OnMouseUp(func (button input.Button) {
menu.tearLine.OnButtonUp(func (catch func (), button input.Button) {
if button != input.ButtonLeft { return }
if menu.tearLine.MousePosition().In(menu.tearLine.Bounds()) {
if menu.tearLine.Window().MousePosition().In(menu.tearLine.Bounds()) {
menu.TearOff()
}
})
@ -65,7 +65,8 @@ func NewMenu (anchor tomo.Object, items ...tomo.Object) (*Menu, error) {
})
}
}
menu.rootContainer.SetRole(tomo.R("objects", "Container", "menu"))
menu.rootContainer.SetRole(tomo.R("objects", "Container"))
menu.rootContainer.SetTag("menu", true)
menu.Window.SetRoot(menu.rootContainer)
return menu, nil

24
menuitem.go
View File

@ -25,19 +25,18 @@ func NewMenuItem (text string) *MenuItem {
label: NewLabel(text),
icon: NewIcon("", tomo.IconSizeSmall),
}
box.SetRole(tomo.R("objects", "MenuItem", ""))
box.label.SetAlign(tomo.AlignStart, tomo.AlignMiddle)
box.SetRole(tomo.R("objects", "MenuItem"))
box.label.SetAttr(tomo.AAlign(tomo.AlignStart, tomo.AlignMiddle))
box.SetLayout(layouts.Row { false, true })
box.Add(box.icon)
box.Add(box.label)
box.CaptureDND(true)
box.CaptureMouse(true)
box.CaptureScroll(true)
box.CaptureKeyboard(true)
box.CatchDND(true)
box.CatchMouse(true)
box.OnMouseUp(box.handleMouseUp)
box.OnButtonDown(box.handleButtonDown)
box.OnButtonUp(box.handleButtonUp)
box.OnKeyUp(box.handleKeyUp)
box.SetFocusable(true)
return box
@ -60,14 +59,19 @@ func (this *MenuItem) OnClick (callback func ()) event.Cookie {
return this.on.click.Connect(callback)
}
func (this *MenuItem) handleKeyUp (key input.Key, numberPad bool) {
func (this *MenuItem) handleKeyUp (catch func(), key input.Key, numberPad bool) {
if key != input.KeyEnter && key != input.Key(' ') { return }
this.on.click.Broadcast()
}
func (this *MenuItem) handleMouseUp (button input.Button) {
func (this *MenuItem) handleButtonDown (catch func(), button input.Button) {
catch()
}
func (this *MenuItem) handleButtonUp (catch func(), button input.Button) {
catch()
if button != input.ButtonLeft { return }
if this.MousePosition().In(this.Bounds()) {
if this.Window().MousePosition().In(this.Bounds()) {
this.on.click.Broadcast()
}
}

29
numberinput.go
View File

@ -28,7 +28,7 @@ func NewNumberInput (value float64) *NumberInput {
increment: NewButton(""),
decrement: NewButton(""),
}
box.SetRole(tomo.R("objects", "NumberInput", ""))
box.SetRole(tomo.R("objects", "NumberInput"))
box.Add(box.input)
box.Add(box.decrement)
box.Add(box.increment)
@ -38,10 +38,8 @@ func NewNumberInput (value float64) *NumberInput {
box.SetValue(value)
box.CaptureScroll(true)
box.CaptureKeyboard(true)
box.OnScroll(box.handleScroll)
box.OnKeyUp(box.handleKeyUp)
box.OnKeyDown(box.handleKeyDown)
box.input.OnConfirm(box.handleConfirm)
box.input.OnValueChange(box.on.valueChange.Broadcast)
@ -78,19 +76,28 @@ func (this *NumberInput) shift (by int) {
this.on.valueChange.Broadcast()
}
func (this *NumberInput) handleKeyDown (key input.Key, numpad bool) {
func (this *NumberInput) handleKeyDown (catch func (), key input.Key, numpad bool) {
switch key {
case input.KeyUp: this.shift(1)
case input.KeyDown: this.shift(-1)
default: this.input.handleKeyDown(key, numpad)
case input.KeyUp:
this.shift(1)
catch()
case input.KeyDown:
this.shift(-1)
catch()
}
}
func (this *NumberInput) handleScroll (x, y float64) {
func (this *NumberInput) handleKeyUp (catch func (), key input.Key, numpad bool) {
switch key {
case input.KeyUp: catch()
case input.KeyDown: catch()
}
}
func (this *NumberInput) handleScroll (catch func (), x, y float64) {
if x == 0 {
catch()
this.shift(-int(math.Round(y)))
} else {
this.input.handleScroll(x, y)
}
}

107
scrollbar.go
View File

@ -35,19 +35,20 @@ func newScrollbar (orient string) *Scrollbar {
this.Add(this.handle)
this.SetFocusable(true)
this.CaptureDND(true)
this.CaptureMouse(true)
this.CaptureScroll(true)
this.CaptureKeyboard(true)
this.CatchDND(true)
this.CatchMouse(true)
this.OnKeyUp(this.handleKeyUp)
this.OnKeyDown(this.handleKeyDown)
this.OnMouseDown(this.handleMouseDown)
this.OnMouseUp(this.handleMouseUp)
this.OnButtonDown(this.handleButtonDown)
this.OnButtonUp(this.handleButtonUp)
this.OnMouseMove(this.handleMouseMove)
this.OnScroll(this.handleScroll)
this.handle.SetRole(tomo.R("objects", "SliderHandle", orient))
this.SetRole(tomo.R("objects", "Slider", orient))
this.handle.SetRole(tomo.R("objects", "SliderHandle"))
this.handle.SetTag(orient, true)
this.SetRole(tomo.R("objects", "Slider"))
this.SetTag(orient, true)
return this
}
@ -120,22 +121,48 @@ func (this *Scrollbar) OnValueChange (callback func ()) event.Cookie {
return this.on.valueChange.Connect(callback)
}
func (this *Scrollbar) handleKeyDown (key input.Key, numpad bool) {
// PageSize returns the scroll distance of a page.
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()
}
}
// StepSize returns the scroll distance of a step.
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) handleKeyUp (catch func (), key input.Key, numpad bool) {
catch()
}
func (this *Scrollbar) handleKeyDown (catch func (), key input.Key, numpad bool) {
catch()
var increment float64; if this.layout.vertical {
increment = -0.05
} else {
increment = 0.05
}
modifiers := this.Window().Modifiers()
switch key {
case input.KeyUp, input.KeyLeft:
if this.Modifiers().Alt {
if modifiers.Alt {
this.SetValue(0)
} else {
this.SetValue(this.Value() - increment)
}
case input.KeyDown, input.KeyRight:
if this.Modifiers().Alt {
if modifiers.Alt {
this.SetValue(1)
} else {
this.SetValue(this.Value() + increment)
@ -147,8 +174,10 @@ func (this *Scrollbar) handleKeyDown (key input.Key, numpad bool) {
}
}
func (this *Scrollbar) handleMouseDown (button input.Button) {
pointer := this.MousePosition()
func (this *Scrollbar) handleButtonDown (catch func (), button input.Button) {
catch()
pointer := this.Window().MousePosition()
handle := this.handle.Bounds()
within := pointer.In(handle)
@ -173,20 +202,21 @@ func (this *Scrollbar) handleMouseDown (button input.Button) {
}
case input.ButtonMiddle:
if above {
this.scrollBy(this.pageSize())
this.scrollBy(this.PageSize())
} else {
this.scrollBy(-this.pageSize())
this.scrollBy(-this.PageSize())
}
case input.ButtonRight:
if above {
this.scrollBy(this.stepSize())
this.scrollBy(this.StepSize())
} else {
this.scrollBy(-this.stepSize())
this.scrollBy(-this.StepSize())
}
}
}
func (this *Scrollbar) handleMouseUp (button input.Button) {
func (this *Scrollbar) handleButtonUp (catch func (), button input.Button) {
catch()
if button != input.ButtonLeft || !this.dragging { return }
this.dragging = false
}
@ -196,7 +226,8 @@ func (this *Scrollbar) handleMouseMove () {
this.drag()
}
func (this *Scrollbar) handleScroll (x, y float64) {
func (this *Scrollbar) handleScroll (catch func(), x, y float64) {
catch()
if this.layout.linked == nil { return }
this.layout.linked.ScrollTo (
this.layout.linked.ContentBounds().Min.
@ -204,7 +235,7 @@ func (this *Scrollbar) handleScroll (x, y float64) {
}
func (this *Scrollbar) drag () {
pointer := this.MousePosition().Sub(this.dragOffset)
pointer := this.Window().MousePosition().Sub(this.dragOffset)
gutter := this.InnerBounds()
handle := this.handle.Bounds()
@ -229,22 +260,6 @@ func (this *Scrollbar) fallbackDragOffset () image.Point {
}
}
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 {
@ -283,14 +298,14 @@ type scrollbarLayout struct {
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 (scrollbarLayout) MinimumSize (hints tomo.LayoutHints, boxes tomo.BoxQuerier) image.Point {
if boxes.Len() != 1 { return image.Pt(0, 0) }
return boxes.MinimumSize(0)
}
func (this scrollbarLayout) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
if len(boxes) != 1 { return }
handle := image.Rectangle { Max: boxes[0].MinimumSize() }
func (this scrollbarLayout) Arrange (hints tomo.LayoutHints, boxes tomo.BoxArranger) {
if boxes.Len() != 1 { return }
handle := image.Rectangle { Max: boxes.MinimumSize(0) }
gutter := hints.Bounds
var gutterLength float64;
@ -311,7 +326,7 @@ func (this scrollbarLayout) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
// 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))
boxes.SetBounds(0, image.Rect(-32, -32, -16, -16))
return
}
if this.vertical {
@ -331,15 +346,15 @@ func (this scrollbarLayout) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
handle = handle.Sub(handleOffset).Add(gutter.Min)
// place handle
boxes[0].SetBounds(handle)
boxes.SetBounds(0, handle)
}
func (this scrollbarLayout) RecommendedHeight (hints tomo.LayoutHints, boxes []tomo.Box, width int) int {
func (this scrollbarLayout) RecommendedHeight (hints tomo.LayoutHints, boxes tomo.BoxQuerier, width int) int {
return this.MinimumSize(hints, boxes).X
}
func (this scrollbarLayout) RecommendedWidth (hints tomo.LayoutHints, boxes []tomo.Box, height int) int {
func (this scrollbarLayout) RecommendedWidth (hints tomo.LayoutHints, boxes tomo.BoxQuerier, height int) int {
return this.MinimumSize(hints, boxes).Y
}

179
scrollcontainer.go
View File

@ -2,7 +2,9 @@ package objects
import "image"
import "git.tebibyte.media/tomo/tomo"
import "git.tebibyte.media/tomo/tomo/input"
import "git.tebibyte.media/tomo/tomo/event"
import "git.tebibyte.media/tomo/objects/layouts"
// ScrollSide determines which Scrollbars are active in a ScrollContainer.
type ScrollSide int; const (
@ -38,7 +40,10 @@ func (sides ScrollSide) String () string {
// ScrollContainer couples a ContentBox with one or two Scrollbars.
type ScrollContainer struct {
tomo.ContainerBox
layout *scrollContainerLayout
root tomo.ContentObject
horizontal *Scrollbar
vertical *Scrollbar
horizontalCookie event.Cookie
verticalCookie event.Cookie
@ -52,22 +57,23 @@ type ScrollContainer struct {
func NewScrollContainer (sides ScrollSide) *ScrollContainer {
this := &ScrollContainer {
ContainerBox: tomo.NewContainerBox(),
layout: &scrollContainerLayout { },
}
if sides.Vertical() {
this.layout.vertical = NewVerticalScrollbar()
this.layout.vertical.OnValueChange(this.handleValueChange)
this.Add(this.layout.vertical)
this.vertical = NewVerticalScrollbar()
this.vertical.OnValueChange(this.handleValueChange)
this.Add(this.vertical)
}
if sides.Horizontal() {
this.layout.horizontal = NewHorizontalScrollbar()
this.layout.horizontal.OnValueChange(this.handleValueChange)
this.Add(this.layout.horizontal)
this.horizontal = NewHorizontalScrollbar()
this.horizontal.OnValueChange(this.handleValueChange)
this.Add(this.horizontal)
}
this.CaptureScroll(true)
this.OnScroll(this.handleScroll)
this.SetRole(tomo.R("objects", "ScrollContainer", sides.String()))
this.SetLayout(this.layout)
this.OnKeyDown(this.handleKeyDown)
this.OnKeyUp(this.handleKeyUp)
this.SetRole(tomo.R("objects", "ScrollContainer"))
this.SetTag(sides.String(), true)
this.SetLayout(layouts.NewGrid(true, false)(true, false))
return this
}
@ -75,9 +81,9 @@ func NewScrollContainer (sides ScrollSide) *ScrollContainer {
// a time, and setting it will remove and unlink the current child if there is
// one.
func (this *ScrollContainer) SetRoot (root tomo.ContentObject) {
if this.layout.root != nil {
if this.root != nil {
// remove root and close cookies
this.Remove(this.layout.root)
this.Remove(this.root)
if this.horizontalCookie != nil {
this.horizontalCookie.Close()
this.horizontalCookie = nil
@ -87,24 +93,24 @@ func (this *ScrollContainer) SetRoot (root tomo.ContentObject) {
this.verticalCookie = nil
}
}
this.layout.root = root
this.root = root
if root != nil {
// insert root at the beginning (for keynav)
switch {
case this.layout.vertical != nil:
this.Insert(root, this.layout.vertical)
case this.layout.horizontal != nil:
this.Insert(root, this.layout.horizontal)
case this.vertical != nil:
this.Insert(root, this.vertical)
case this.horizontal != nil:
this.Insert(root, this.horizontal)
default:
this.Add(root)
}
// link root and remember cookies
if this.layout.horizontal != nil {
this.horizontalCookie = this.layout.horizontal.Link(root)
if this.horizontal != nil {
this.horizontalCookie = this.horizontal.Link(root)
}
if this.layout.vertical != nil {
this.verticalCookie = this.layout.vertical.Link(root)
if this.vertical != nil {
this.verticalCookie = this.vertical.Link(root)
}
}
}
@ -112,11 +118,11 @@ func (this *ScrollContainer) SetRoot (root tomo.ContentObject) {
// Value returns the horizontal and vertical scrollbar values where 0 is all the
// way to the left/top, and 1 is all the way to the right/bottom.
func (this *ScrollContainer) Value () (x, y float64) {
if this.layout.horizontal != nil {
x = this.layout.horizontal.Value()
if this.horizontal != nil {
x = this.horizontal.Value()
}
if this.layout.vertical != nil {
y = this.layout.vertical.Value()
if this.vertical != nil {
y = this.vertical.Value()
}
return x, y
}
@ -124,11 +130,11 @@ func (this *ScrollContainer) Value () (x, y float64) {
// SetValue sets the horizontal and vertical scrollbar values where 0 is all the
// way to the left/top, and 1 is all the way to the right/bottom.
func (this *ScrollContainer) SetValue (x, y float64) {
if this.layout.horizontal != nil {
this.layout.horizontal.SetValue(x)
if this.horizontal != nil {
this.horizontal.SetValue(x)
}
if this.layout.vertical != nil {
this.layout.vertical.SetValue(y)
if this.vertical != nil {
this.vertical.SetValue(y)
}
}
@ -138,77 +144,74 @@ func (this *ScrollContainer) OnValueChange (callback func ()) event.Cookie {
return this.on.valueChange.Connect(callback)
}
// PageSize returns the scroll distance of a page.
func (this *ScrollContainer) PageSize () image.Point {
page := image.Point { }
if this.horizontal != nil {
page.X = this.horizontal.PageSize()
}
if this.vertical != nil {
page.Y = this.vertical.PageSize()
}
return page
}
// StepSize returns the scroll distance of a step.
func (this *ScrollContainer) StepSize () image.Point {
page := image.Point { }
if this.horizontal != nil {
page.X = this.horizontal.StepSize()
}
if this.vertical != nil {
page.Y = this.vertical.StepSize()
}
return page
}
func (this *ScrollContainer) handleValueChange () {
this.on.valueChange.Broadcast()
}
func (this *ScrollContainer) handleScroll (x, y float64) {
if this.layout.root == nil { return }
this.layout.root.ScrollTo (
this.layout.root.ContentBounds().Min.
Sub(image.Pt(int(x), int(y))))
func (this *ScrollContainer) handleScroll (catch func (), x, y float64) {
catch()
if this.root == nil { return }
this.scrollBy(image.Pt(int(x), int(y)))
}
// TODO: remove this and replace it with something from the layouts package
type scrollContainerLayout struct {
root tomo.ContentObject
horizontal *Scrollbar
vertical *Scrollbar
func (this *ScrollContainer) scrollBy (vector image.Point) {
if this.root == nil { return }
this.root.ScrollTo (
this.root.ContentBounds().Min.
Sub(vector))
}
func (this *scrollContainerLayout) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
var minimum image.Point; if this.root != nil {
minimum = this.root.GetBox().MinimumSize()
func (this *ScrollContainer) handleKeyDown (catch func (), key input.Key, numpad bool) {
modifiers := this.Window().Modifiers()
vector := image.Point { }
switch key {
case input.KeyPageUp:
catch()
if modifiers.Shift {
vector.X -= this.PageSize().X
} else {
vector.Y -= this.PageSize().Y
}
if this.horizontal != nil {
minimum.Y += this.horizontal.MinimumSize().Y
case input.KeyPageDown:
catch()
if modifiers.Shift {
vector.X += this.PageSize().X
} else {
vector.Y += this.PageSize().Y
}
if this.vertical != nil {
minimum.X += this.vertical.MinimumSize().X
minimum.Y = max(minimum.Y, this.vertical.MinimumSize().Y)
}
if this.horizontal != nil {
minimum.X = max(minimum.X, this.horizontal.MinimumSize().X)
}
return minimum
}
func (this *scrollContainerLayout) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
rootBounds := hints.Bounds
if this.horizontal != nil {
rootBounds.Max.Y -= this.horizontal.MinimumSize().Y
}
if this.vertical != nil {
rootBounds.Max.X -= this.vertical.MinimumSize().X
}
if this.root != nil {
this.root.GetBox().SetBounds(rootBounds)
}
if this.horizontal != nil {
this.horizontal.SetBounds(image.Rect (
hints.Bounds.Min.X,
rootBounds.Max.Y,
rootBounds.Max.X,
hints.Bounds.Max.Y))
}
if this.vertical != nil {
this.vertical.SetBounds(image.Rect (
rootBounds.Max.X,
hints.Bounds.Min.Y,
hints.Bounds.Max.X,
rootBounds.Max.Y))
if vector != (image.Point { }) {
this.scrollBy(vector)
}
}
func (this *scrollContainerLayout) RecommendedHeight (hints tomo.LayoutHints, boxes []tomo.Box, width int) int {
return this.MinimumSize(hints, boxes).X
func (this *ScrollContainer) handleKeyUp (catch func (), key input.Key, numpad bool) {
switch key {
case input.KeyPageUp: catch()
case input.KeyPageDown: catch()
}
func (this *scrollContainerLayout) RecommendedWidth (hints tomo.LayoutHints, boxes []tomo.Box, height int) int {
return this.MinimumSize(hints, boxes).Y
}
func max (x, y int) int {
if x > y { return x }
return y
}

2
separator.go
View File

@ -12,6 +12,6 @@ func NewSeparator () *Separator {
this := &Separator {
Box: tomo.NewBox(),
}
this.SetRole(tomo.R("objects", "Separator", ""))
this.SetRole(tomo.R("objects", "Separator"))
return this
}

76
slider.go
View File

@ -43,20 +43,21 @@ func newSlider (orient string, value float64) *Slider {
this.Add(this.handle)
this.SetFocusable(true)
this.CaptureDND(true)
this.CaptureMouse(true)
this.CaptureScroll(true)
this.CaptureKeyboard(true)
this.CatchDND(true)
this.CatchMouse(true)
this.SetValue(value)
this.OnKeyUp(this.handleKeyUp)
this.OnKeyDown(this.handleKeyDown)
this.OnMouseDown(this.handleMouseDown)
this.OnMouseUp(this.handleMouseUp)
this.OnButtonDown(this.handleButtonDown)
this.OnButtonUp(this.handleButtonUp)
this.OnMouseMove(this.handleMouseMove)
this.OnScroll(this.handleScroll)
this.handle.SetRole(tomo.R("objects", "SliderHandle", orient))
this.SetRole(tomo.R("objects", "Slider", orient))
this.handle.SetRole(tomo.R("objects", "SliderHandle"))
this.handle.SetTag(orient, true)
this.SetRole(tomo.R("objects", "Slider"))
this.SetTag(orient, true)
return this
}
@ -96,7 +97,9 @@ func (this *Slider) OnConfirm (callback func ()) event.Cookie {
return this.on.confirm.Connect(callback)
}
func (this *Slider) handleKeyDown (key input.Key, numpad bool) {
func (this *Slider) handleKeyDown (catch func (), key input.Key, numpad bool) {
catch()
var increment float64; if this.layout.vertical {
increment = -0.05
} else {
@ -105,14 +108,14 @@ func (this *Slider) handleKeyDown (key input.Key, numpad bool) {
switch key {
case input.KeyUp, input.KeyLeft:
if this.Modifiers().Alt {
if this.Window().Modifiers().Alt {
this.SetValue(0)
} else {
this.SetValue(this.Value() - increment)
}
this.on.valueChange.Broadcast()
case input.KeyDown, input.KeyRight:
if this.Modifiers().Alt {
if this.Window().Modifiers().Alt {
this.SetValue(1)
} else {
this.SetValue(this.Value() + increment)
@ -127,8 +130,14 @@ func (this *Slider) handleKeyDown (key input.Key, numpad bool) {
}
}
func (this *Slider) handleMouseDown (button input.Button) {
pointer := this.MousePosition()
func (this *Slider) handleKeyUp (catch func (), key input.Key, numpad bool) {
catch()
}
func (this *Slider) handleButtonDown (catch func (), button input.Button) {
catch()
pointer := this.Window().MousePosition()
handle := this.handle.Bounds()
within := pointer.In(handle)
@ -174,7 +183,8 @@ func (this *Slider) handleMouseDown (button input.Button) {
}
}
func (this *Slider) handleMouseUp (button input.Button) {
func (this *Slider) handleButtonUp (catch func (), button input.Button) {
catch()
if button != input.ButtonLeft || !this.dragging { return }
this.dragging = false
this.on.confirm.Broadcast()
@ -185,7 +195,7 @@ func (this *Slider) handleMouseMove () {
this.drag()
}
func (this *Slider) handleScroll (x, y float64) {
func (this *Slider) handleScroll (catch func (), x, y float64) {
delta := (x + y) * 0.005
this.SetValue(this.Value() + delta)
this.on.valueChange.Broadcast()
@ -193,7 +203,7 @@ func (this *Slider) handleScroll (x, y float64) {
}
func (this *Slider) drag () {
pointer := this.MousePosition().Sub(this.dragOffset)
pointer := this.Window().MousePosition().Sub(this.dragOffset)
gutter := this.InnerBounds()
handle := this.handle.Bounds()
@ -225,39 +235,37 @@ type sliderLayout struct {
value float64
}
func (sliderLayout) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
if len(boxes) != 1 { return image.Pt(0, 0) }
return boxes[0].MinimumSize()
func (sliderLayout) MinimumSize (hints tomo.LayoutHints, boxes tomo.BoxQuerier) image.Point {
if boxes.Len() != 1 { return image.Pt(0, 0) }
return boxes.MinimumSize(0)
}
func (this sliderLayout) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
if len(boxes) != 1 { return }
handle := image.Rectangle { Max: boxes[0].MinimumSize() }
func (this sliderLayout) Arrange (hints tomo.LayoutHints, boxes tomo.BoxArranger) {
if boxes.Len() != 1 { return }
handle := image.Rectangle { Max: boxes.MinimumSize(0) }
gutter := hints.Bounds
if this.vertical {
height := gutter.Dy() - handle.Dy()
offset := int(float64(height) * (1 - this.value))
handle.Max.X = gutter.Dx()
boxes[0].SetBounds (
handle.
Add(image.Pt(0, offset)).
Add(gutter.Min))
boxes.SetBounds (
0,
handle.Add(image.Pt(0, offset)).Add(gutter.Min))
} else {
width := gutter.Dx() - handle.Dx()
offset := int(float64(width) * this.value)
handle.Max.Y = gutter.Dy()
boxes[0].SetBounds (
handle.
Add(image.Pt(offset, 0)).
Add(gutter.Min))
boxes.SetBounds (
0,
handle.Add(image.Pt(offset, 0)).Add(gutter.Min))
}
}
func (this sliderLayout) RecommendedHeight (tomo.LayoutHints, []tomo.Box, int) int {
return 0
func (this sliderLayout) RecommendedHeight (hints tomo.LayoutHints, boxes tomo.BoxQuerier, width int) int {
return this.MinimumSize(hints, boxes).X
}
func (this sliderLayout) RecommendedWidth (tomo.LayoutHints, []tomo.Box, int) int {
return 0
func (this sliderLayout) RecommendedWidth (hints tomo.LayoutHints, boxes tomo.BoxQuerier, height int) int {
return this.MinimumSize(hints, boxes).Y
}

12
swatch.go
View File

@ -26,11 +26,11 @@ func NewSwatch (value color.Color) *Swatch {
swatch := &Swatch {
CanvasBox: tomo.NewCanvasBox(),
}
swatch.SetRole(tomo.R("objects", "Swatch", ""))
swatch.SetRole(tomo.R("objects", "Swatch"))
swatch.SetDrawer(swatch)
swatch.SetValue(value)
swatch.OnMouseUp(swatch.handleMouseUp)
swatch.OnButtonUp(swatch.handleButtonUp)
swatch.OnKeyUp(swatch.handleKeyUp)
swatch.SetFocusable(true)
return swatch
@ -114,7 +114,7 @@ func (this *Swatch) Choose () {
layouts.ContractHorizontal,
cancelButton,
okButton)
controlRow.SetAlign(tomo.AlignEnd, tomo.AlignMiddle)
controlRow.SetAttr(tomo.AAlign(tomo.AlignEnd, tomo.AlignMiddle))
window.SetRoot(NewOuterContainer (
layouts.Column { true, false },
colorPicker,
@ -155,14 +155,14 @@ func (this *Swatch) userSetValue (value color.Color) {
this.on.valueChange.Broadcast()
}
func (this *Swatch) handleKeyUp (key input.Key, numberPad bool) {
func (this *Swatch) handleKeyUp (catch func (), key input.Key, numberPad bool) {
if key != input.KeyEnter && key != input.Key(' ') { return }
this.Choose()
}
func (this *Swatch) handleMouseUp (button input.Button) {
func (this *Swatch) handleButtonUp (catch func (), button input.Button) {
if button != input.ButtonLeft { return }
if this.MousePosition().In(this.Bounds()) {
if this.Window().MousePosition().In(this.Bounds()) {
this.Choose()
}
}

20
tabbedcontainer.go
View File

@ -18,17 +18,19 @@ func NewTabbedContainer () *TabbedContainer {
container := &TabbedContainer {
ContainerBox: tomo.NewContainerBox(),
}
container.SetRole(tomo.R("objects", "TabbedContainer", ""))
container.SetRole(tomo.R("objects", "TabbedContainer"))
container.SetLayout(layouts.Column { false, true } )
container.tabsRow = tomo.NewContainerBox()
container.tabsRow.SetRole(tomo.R("objects", "TabRow", ""))
container.tabsRow.SetRole(tomo.R("objects", "TabRow"))
container.Add(container.tabsRow)
container.leftSpacer = tomo.NewBox()
container.leftSpacer.SetRole(tomo.R("objects", "TabSpacer", "left"))
container.leftSpacer.SetRole(tomo.R("objects", "TabSpacer"))
container.leftSpacer.SetTag("left", true)
container.rightSpacer = tomo.NewBox()
container.rightSpacer.SetRole(tomo.R("objects", "TabSpacer", "right"))
container.rightSpacer.SetRole(tomo.R("objects", "TabSpacer"))
container.rightSpacer.SetTag("left", true)
container.ClearTabs()
container.setTabRowLayout()
@ -55,9 +57,9 @@ func (this *TabbedContainer) AddTab (name string, root tomo.Object) {
name: name,
root: root,
}
tab.SetRole(tomo.R("objects", "Tab", ""))
tab.SetRole(tomo.R("objects", "Tab"))
tab.SetText(name)
tab.OnMouseDown(func (button input.Button) {
tab.OnButtonDown(func (catch func (), button input.Button) {
if button != input.ButtonLeft { return }
this.Activate(name)
})
@ -118,9 +120,11 @@ type tab struct {
func (this *tab) setActive (active bool) {
if active {
this.SetRole(tomo.R("objects", "Tab", "active"))
this.SetRole(tomo.R("objects", "Tab"))
this.SetTag("active", false)
} else {
this.SetRole(tomo.R("objects", "Tab", ""))
this.SetRole(tomo.R("objects", "Tab"))
this.SetTag("active", true)
}
}

10
textinput.go
View File

@ -19,8 +19,8 @@ type TextInput struct {
// NewTextInput creates a new text input containing the specified text.
func NewTextInput (text string) *TextInput {
this := &TextInput { TextBox: tomo.NewTextBox() }
this.SetRole(tomo.R("objects", "TextInput", ""))
this.SetAlign(tomo.AlignStart, tomo.AlignMiddle)
this.SetRole(tomo.R("objects", "TextInput"))
this.SetAttr(tomo.AAlign(tomo.AlignStart, tomo.AlignMiddle))
this.SetText(text)
this.SetFocusable(true)
this.SetSelectable(true)
@ -53,9 +53,9 @@ func (this *TextInput) OnValueChange (callback func ()) event.Cookie {
return this.on.valueChange.Connect(callback)
}
func (this *TextInput) handleKeyDown (key input.Key, numpad bool) {
func (this *TextInput) handleKeyDown (catch func (), key input.Key, numpad bool) {
dot := this.Dot()
modifiers := this.Modifiers()
modifiers := this.Window().Modifiers()
word := modifiers.Control
sel := modifiers.Shift
changed := false
@ -113,6 +113,6 @@ func (this *TextInput) Type (char rune) {
this.SetText(string(this.text))
}
func (this *TextInput) handleScroll (x, y float64) {
func (this *TextInput) handleScroll (catch func (), x, y float64) {
this.ScrollTo(this.ContentBounds().Min.Add(image.Pt(int(x), int(y))))
}

4
textview.go
View File

@ -11,7 +11,7 @@ type TextView struct {
// NewTextView creates a new text view.
func NewTextView (text string) *TextView {
this := &TextView { TextBox: tomo.NewTextBox() }
this.SetRole(tomo.R("objects", "TextView", ""))
this.SetRole(tomo.R("objects", "TextView"))
this.SetFocusable(true)
this.SetSelectable(true)
this.SetText(text)
@ -21,6 +21,6 @@ func NewTextView (text string) *TextView {
return this
}
func (this *TextView) handleScroll (x, y float64) {
func (this *TextView) handleScroll (catch func (), x, y float64) {
this.ScrollTo(this.ContentBounds().Min.Add(image.Pt(int(x), int(y))))
}