package basic import "fmt" import "image" import "git.tebibyte.media/sashakoshka/tomo" import "git.tebibyte.media/sashakoshka/tomo/theme" 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 core.CoreControl enabled bool selected bool pressed bool contentHeight int forcedMinimumWidth int forcedMinimumHeight int selectedEntry int scroll int entries []ListEntry onSelectionRequest func () (granted bool) onSelectedEntryChange func (index int) onSelectionMotionRequest func (tomo.SelectionDirection) (granted bool) onScrollBoundsChange func () } // NewList creates a new list element with the specified entries. func NewList (entries ...ListEntry) (element *List) { element = &List { enabled: true, selectedEntry: -1 } element.Core, element.core = core.NewCore(element) element.entries = make([]ListEntry, len(entries)) for index, entry := range entries { element.entries[index] = entry } element.updateMinimumSize() return } // Resize changes the element's size. func (element *List) Resize (width, height int) { element.core.AllocateCanvas(width, height) for index, entry := range element.entries { element.entries[index] = element.resizeEntryToFit(entry) } element.draw() if element.onScrollBoundsChange != nil { element.onScrollBoundsChange() } } // TODO: handle keyboard and mouse events // 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) { element.forcedMinimumWidth = width element.forcedMinimumHeight = height element.updateMinimumSize() } func (element *List) HandleMouseDown (x, y int, button tomo.Button) { if !element.enabled { return } if !element.selected { element.Select() } if button != tomo.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 tomo.Button) { if button != tomo.ButtonLeft { return } element.pressed = false // if element.core.HasImage() { // element.draw() // element.core.DamageAll() // } // // within := image.Point { x, y }. // In(element.Bounds()) // // if !element.enabled { return } // if within && element.onClick != nil { // element.onClick() // } } 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 tomo.Key, modifiers tomo.Modifiers) { if !element.enabled { return } // TODO } func (element *List) HandleKeyUp(key tomo.Key, modifiers tomo.Modifiers) { } func (element *List) Selected () (selected bool) { return element.selected } func (element *List) Select () { if !element.enabled { return } if element.onSelectionRequest != nil { element.onSelectionRequest() } } func (element *List) HandleSelection ( direction tomo.SelectionDirection, ) ( accepted bool, ) { direction = direction.Canon() if !element.enabled { return false } if element.selected && direction != tomo.SelectionDirectionNeutral { return false } element.selected = true if element.core.HasImage() { element.draw() element.core.DamageAll() } return true } func (element *List) HandleDeselection () { element.selected = false if element.core.HasImage() { element.draw() element.core.DamageAll() } } func (element *List) OnSelectionRequest (callback func () (granted bool)) { element.onSelectionRequest = callback } func (element *List) OnSelectionMotionRequest ( callback func (direction tomo.SelectionDirection) (granted bool), ) { element.onSelectionMotionRequest = callback } // OnSelectedEntryChange sets the function to be called when the user selects an // entry in this list. func (element *List) OnSelectedEntryChange (callback func (index int)) { element.onSelectedEntryChange = callback } // 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) { return element.Bounds().Dy() - theme.Padding() } 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 } // SetEnabled sets whether this list can be interacted with or not. func (element *List) SetEnabled (enabled bool) { if element.enabled == enabled { return } element.enabled = enabled if element.core.HasImage () { element.draw() element.core.DamageAll() } } // 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.Collapse(element.forcedMinimumWidth) 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.Collapse(element.forcedMinimumWidth) 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.Collapse(element.forcedMinimumWidth) element.entries[index] = entry // redraw element.updateMinimumSize() if element.core.HasImage() { element.draw() element.core.DamageAll() } if element.onScrollBoundsChange != nil { element.onScrollBoundsChange() } } func (element *List) selectUnderMouse (x, y int) (updated bool) { bounds := element.Bounds() mousePoint := image.Pt(x, y) dot := image.Pt ( bounds.Min.X + theme.Padding() / 2, bounds.Min.Y - element.scroll + theme.Padding() / 2) 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 } } if element.selectedEntry == newlySelectedEntryIndex { return false } element.selectedEntry = newlySelectedEntryIndex if element.onSelectedEntryChange != nil { element.onSelectedEntryChange(element.selectedEntry) } if element.selectedEntry >= 0 { element.entries[element.selectedEntry].RunSelect() } return true } func (element *List) resizeEntryToFit (entry ListEntry) (resized ListEntry) { entry.Collapse(element.forcedMinimumWidth) 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 { minimumWidth = theme.Padding() for _, entry := range element.entries { entryWidth := entry.Bounds().Dx() if entryWidth > minimumWidth { minimumWidth = entryWidth } } } if minimumHeight == 0 { minimumHeight = element.contentHeight + theme.Padding() } element.core.SetMinimumSize(minimumWidth, minimumHeight) } func (element *List) draw () { bounds := element.Bounds() artist.FillRectangle ( element, theme.ListPattern(), bounds) dot := image.Point { bounds.Min.X, bounds.Min.Y - element.scroll + theme.Padding() / 2, } for index, entry := range element.entries { entryPosition := dot dot.Y += entry.Bounds().Dy() if dot.Y < bounds.Min.Y { continue } if entryPosition.Y > bounds.Max.Y { break } if element.selectedEntry == index { artist.FillRectangle ( element, theme.ListEntryPattern(true), entry.Bounds().Add(entryPosition)) } entry.Draw ( element, entryPosition, element.selectedEntry == index && element.selected) } }