668 lines
18 KiB
Go
668 lines
18 KiB
Go
package page
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"unicode"
|
|
|
|
"github.com/go-gl/gl/v3.3-core/gl"
|
|
"github.com/go-gl/mathgl/mgl32"
|
|
"github.com/veandco/go-sdl2/sdl"
|
|
"gorm.io/gorm"
|
|
"rhemawavetech.com/rhemawave/internal/colors"
|
|
"rhemawavetech.com/rhemawave/internal/db"
|
|
"rhemawavetech.com/rhemawave/internal/fontManager"
|
|
"rhemawavetech.com/rhemawave/internal/logger"
|
|
"rhemawavetech.com/rhemawave/internal/shaderManager"
|
|
"rhemawavetech.com/rhemawave/internal/sync"
|
|
)
|
|
|
|
// Scrollbar Visuals
|
|
var (
|
|
colorScrollTrack = sdl.Color{R: 255, G: 255, B: 255, A: 30}
|
|
colorScrollThumb = sdl.Color{R: 255, G: 255, B: 255, A: 100}
|
|
)
|
|
|
|
type FlatItem struct {
|
|
Label StringItem
|
|
ID string
|
|
IsCategory bool
|
|
IsSubCategory bool
|
|
Depth int
|
|
Expanded bool
|
|
SearchText string // lowercase name + content, pre-built at load time
|
|
}
|
|
|
|
type ProclamationOptions struct {
|
|
Base
|
|
font *fontManager.FontEntry
|
|
textShader *shaderManager.Shader
|
|
solidShader *shaderManager.Shader
|
|
title StringItem
|
|
prompt StringItem
|
|
|
|
// Browse Tree State
|
|
allItems []*FlatItem
|
|
activeMap map[string]bool
|
|
highlightIndex int
|
|
|
|
// Browse Scrolling State
|
|
scrollOffset int
|
|
maxVisible int
|
|
|
|
// Scrollbar Dimens
|
|
scrollTrackWidth int32
|
|
scrollTrackX int32
|
|
scrollTrackHeight int32
|
|
scrollTrackY int32
|
|
|
|
indentSize float32
|
|
verticalMargin int32
|
|
|
|
// Search State
|
|
isSearchActive bool
|
|
searchQuery string
|
|
searchInput StringItem
|
|
searchItems []*FlatItem // filtered view — pointers into allProclamations
|
|
searchHighlight int
|
|
searchScrollOff int
|
|
|
|
// Full flat proclamation pool (pointers shared with allItems leaves)
|
|
allProclamations []*FlatItem
|
|
}
|
|
|
|
func (p *ProclamationOptions) Init(ctx *PageCtx) error {
|
|
p.verticalMargin = 25
|
|
p.indentSize = 40.0
|
|
p.activeMap = make(map[string]bool)
|
|
p.allItems = []*FlatItem{}
|
|
p.scrollOffset = 0
|
|
p.isSearchActive = false
|
|
p.scrollTrackWidth = 30
|
|
p.scrollTrackX = p.ScreenWidth - p.scrollTrackWidth
|
|
var err error
|
|
|
|
// Syncronize proclamations first
|
|
var allProcs []db.Proclamation
|
|
allProcs, err = sync.SyncProclamations(ctx.DbPtr)
|
|
if err != nil {
|
|
// sync failed, fallback to database
|
|
ctx.DbPtr.Find(&allProcs)
|
|
}
|
|
|
|
sync.SyncFrequencies(ctx.DbPtr)
|
|
|
|
fm := fontManager.Get()
|
|
font, _ := fm.GetFont("Roboto-Regular")
|
|
p.font = font
|
|
|
|
sm := shaderManager.Get()
|
|
p.textShader, _ = sm.Get("text")
|
|
p.solidShader, _ = sm.Get("solid_color")
|
|
|
|
p.Base.Init(ctx)
|
|
|
|
itemScale := float32(32) / float32(ctx.CfgPtr.StandardFontSize)
|
|
p.title, _ = NewStringItem("Proclamation Browser", p.font, colors.White)
|
|
p.title.Scale(float32(64) / float32(ctx.CfgPtr.StandardFontSize))
|
|
|
|
p.prompt, _ = NewStringItem("Type to Search Space to Select Enter to Save Escape to Exit", p.font, colors.White)
|
|
p.prompt.Scale(itemScale * 0.8)
|
|
|
|
// Calculation for visible area
|
|
areaHeight := float32(p.ScreenHeight) - 250
|
|
p.maxVisible = int(areaHeight / 47)
|
|
|
|
// Load current selections
|
|
var selected []db.Proclamation
|
|
ctx.DbPtr.Where("selected = ?", true).Where("id != ?", defaultProclamationID).Find(&selected)
|
|
for _, s := range selected {
|
|
if s.ID == defaultProclamationID {
|
|
logger.Debug("Found default proclamation in selected list: %s", s.ID)
|
|
}
|
|
p.activeMap[s.ID] = true
|
|
}
|
|
|
|
procContentMap := make(map[string]string, len(allProcs))
|
|
for _, pr := range allProcs {
|
|
if pr.ID == defaultProclamationID {
|
|
logger.Debug("Found default proclamation in allProcs list: %s", pr.ID)
|
|
}
|
|
procContentMap[pr.ID] = pr.Content
|
|
}
|
|
p.allProclamations = []*FlatItem{}
|
|
|
|
for _, pr := range allProcs {
|
|
fi := p.createFlatItem(pr.Name, pr.ID, false, 0)
|
|
// Searching the name AND the content is returning too many options
|
|
// I am removing this, for now, to narrow the search results.
|
|
// I think a tag system should be implemented and search based on tags
|
|
// and names, but not necessarily content.
|
|
// fi.SearchText = strings.ToLower(pr.Name + " " + pr.Content)
|
|
fi.SearchText = strings.ToLower(pr.Name)
|
|
p.allProclamations = append(p.allProclamations, fi)
|
|
}
|
|
|
|
// Load Root Categories
|
|
var parentCategories []db.ProclamationCategory
|
|
p.Context.DbPtr.Where("parent_id IS NULL OR parent_id = 0").Find(&parentCategories)
|
|
for _, c := range parentCategories {
|
|
p.allItems = append(p.allItems, p.createFlatItem(c.Name, fmt.Sprint(c.ID), true, 0))
|
|
}
|
|
|
|
p.layout()
|
|
return nil
|
|
}
|
|
|
|
func (p *ProclamationOptions) createFlatItem(name, id string, isCat bool, depth int) *FlatItem {
|
|
text := name
|
|
if isCat && depth == 0 {
|
|
text = "[+] " + name
|
|
}
|
|
itemScale := float32(32) / float32(p.Context.CfgPtr.StandardFontSize)
|
|
lbl, _ := NewStringItem(text, p.font, colors.White)
|
|
lbl.Scale(itemScale)
|
|
return &FlatItem{
|
|
Label: lbl,
|
|
ID: id,
|
|
IsCategory: isCat,
|
|
IsSubCategory: isCat && depth > 0,
|
|
Depth: depth,
|
|
}
|
|
}
|
|
|
|
func (p *ProclamationOptions) layout() {
|
|
p.title.X = p.ScreenCenterX - p.title.W/2
|
|
p.title.Y = 40
|
|
p.prompt.X = p.ScreenCenterX - p.prompt.W/2
|
|
p.prompt.Y = p.ScreenHeight - 60
|
|
|
|
startY := float32(p.ScreenHeight - 150)
|
|
p.scrollTrackY = 130
|
|
p.scrollTrackHeight = int32(startY) - 130 + 50
|
|
|
|
if p.isSearchActive {
|
|
// Position search bar label
|
|
p.searchInput.X = 60
|
|
p.searchInput.Y = 100
|
|
|
|
// Hide all browse items
|
|
for _, item := range p.allItems {
|
|
item.Label.X = -5000
|
|
}
|
|
|
|
// Position filtered search results
|
|
for i, item := range p.searchItems {
|
|
item.Label.X = -5000
|
|
if i >= p.searchScrollOff && i < p.searchScrollOff+p.maxVisible {
|
|
visibleIdx := i - p.searchScrollOff
|
|
item.Label.X = 60
|
|
item.Label.Y = int32(startY - float32(visibleIdx)*47.0)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// Browse mode
|
|
for i, item := range p.allItems {
|
|
item.Label.X = -5000
|
|
if i >= p.scrollOffset && i < p.scrollOffset+p.maxVisible {
|
|
visibleIdx := i - p.scrollOffset
|
|
item.Label.X = int32(60.0 + float32(item.Depth)*p.indentSize)
|
|
item.Label.Y = int32(startY - float32(visibleIdx)*47.0)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *ProclamationOptions) toggleExpansion(index int) {
|
|
item := p.allItems[index]
|
|
if !item.IsCategory || item.IsSubCategory {
|
|
return
|
|
}
|
|
|
|
pureName := item.Label.content[4:]
|
|
gl.DeleteTextures(1, &item.Label.ID)
|
|
|
|
itemScale := float32(32) / float32(p.Context.CfgPtr.StandardFontSize)
|
|
if item.Expanded {
|
|
p.collapse(index)
|
|
item.Label, _ = NewStringItem("[+] "+pureName, p.font, colors.White)
|
|
} else {
|
|
p.expand(index)
|
|
item.Label, _ = NewStringItem("[-] "+pureName, p.font, colors.White)
|
|
}
|
|
item.Label.Scale(itemScale)
|
|
item.Expanded = !item.Expanded
|
|
p.layout()
|
|
}
|
|
|
|
func (p *ProclamationOptions) expand(index int) {
|
|
parent := p.allItems[index]
|
|
parentID, _ := strconv.Atoi(parent.ID)
|
|
var newItems []*FlatItem
|
|
|
|
// Load subcategories
|
|
var cats []db.ProclamationCategory
|
|
p.Context.DbPtr.Where("parent_id = ?", parentID).Find(&cats)
|
|
for _, c := range cats {
|
|
fi := p.createFlatItem(c.Name, fmt.Sprint(c.ID), true, parent.Depth+1)
|
|
fi.Expanded = true
|
|
newItems = append(newItems, fi)
|
|
}
|
|
|
|
// Load proclamations
|
|
var procs []db.Proclamation
|
|
p.Context.DbPtr.Where("category_id = ?", parentID).Where("ID != ?", defaultProclamationID).Find(&procs)
|
|
for _, pr := range procs {
|
|
var fi *FlatItem
|
|
// Reuse existing proclamation from allProclamations if available
|
|
for _, existing := range p.allProclamations {
|
|
if existing.ID == pr.ID {
|
|
fi = existing
|
|
break
|
|
}
|
|
}
|
|
if fi == nil {
|
|
// Safety fallback
|
|
fi = p.createFlatItem(pr.Name, pr.ID, false, parent.Depth+1)
|
|
fi.SearchText = strings.ToLower(pr.Name + " " + pr.Content)
|
|
p.allProclamations = append(p.allProclamations, fi)
|
|
}
|
|
fi.Depth = parent.Depth + 1
|
|
newItems = append(newItems, fi)
|
|
}
|
|
|
|
// Insert new items after parent
|
|
tail := append([]*FlatItem{}, p.allItems[index+1:]...)
|
|
p.allItems = append(p.allItems[:index+1], append(newItems, tail...)...)
|
|
|
|
// Recurse into subcategories
|
|
i := index + 1
|
|
for i < len(p.allItems) && p.allItems[i].Depth > parent.Depth {
|
|
if p.allItems[i].IsCategory && p.allItems[i].Depth > 0 {
|
|
p.expand(i)
|
|
}
|
|
i++
|
|
}
|
|
}
|
|
|
|
func (p *ProclamationOptions) collapse(index int) {
|
|
depth := p.allItems[index].Depth
|
|
i := index + 1
|
|
for i < len(p.allItems) && p.allItems[i].Depth > depth {
|
|
// Do NOT delete textures here — leaves are shared with allProclamations.
|
|
// Only delete textures for category items that aren't in the proclamation pool.
|
|
if p.allItems[i].IsCategory {
|
|
gl.DeleteTextures(1, &p.allItems[i].Label.ID)
|
|
}
|
|
i++
|
|
}
|
|
p.allItems = append(p.allItems[:index+1], p.allItems[i:]...)
|
|
}
|
|
|
|
// matchesWordPrefix returns true if any word in text starts with query (case-insensitive).
|
|
func matchesWordPrefix(text, query string) bool {
|
|
query = strings.ToLower(query)
|
|
text = strings.ToLower(text)
|
|
|
|
// Split text into words (non-alphanumeric boundaries)
|
|
words := strings.FieldsFunc(text, func(r rune) bool {
|
|
return !unicode.IsLetter(r) && !unicode.IsNumber(r)
|
|
})
|
|
|
|
for _, word := range words {
|
|
if strings.HasPrefix(word, query) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (p *ProclamationOptions) buildSearchList() {
|
|
p.searchItems = nil
|
|
if p.searchQuery == "" {
|
|
return
|
|
}
|
|
for _, item := range p.allProclamations {
|
|
if matchesWordPrefix(item.SearchText, p.searchQuery) {
|
|
p.searchItems = append(p.searchItems, item)
|
|
}
|
|
}
|
|
if p.searchHighlight >= len(p.searchItems) {
|
|
p.searchHighlight = 0
|
|
}
|
|
}
|
|
|
|
func (p *ProclamationOptions) rebuildSearchLabel() {
|
|
if p.searchInput.ID != 0 {
|
|
gl.DeleteTextures(1, &p.searchInput.ID)
|
|
p.searchInput.ID = 0
|
|
}
|
|
if p.searchQuery == "" {
|
|
return
|
|
}
|
|
itemScale := float32(32) / float32(p.Context.CfgPtr.StandardFontSize)
|
|
p.searchInput, _ = NewStringItem("Search: "+p.searchQuery, p.font, colors.Yellow)
|
|
p.searchInput.Scale(itemScale * 1.1)
|
|
}
|
|
|
|
func (p *ProclamationOptions) enterSearchMode(firstRune rune) {
|
|
p.searchQuery = string(firstRune)
|
|
p.isSearchActive = true
|
|
p.searchScrollOff = 0
|
|
p.searchHighlight = 0
|
|
p.buildSearchList()
|
|
p.rebuildSearchLabel()
|
|
}
|
|
|
|
func (p *ProclamationOptions) exitSearchMode() {
|
|
p.searchQuery = ""
|
|
p.isSearchActive = false
|
|
p.searchItems = nil
|
|
p.searchHighlight = 0
|
|
p.searchScrollOff = 0
|
|
if p.searchInput.ID != 0 {
|
|
gl.DeleteTextures(1, &p.searchInput.ID)
|
|
p.searchInput.ID = 0
|
|
}
|
|
}
|
|
|
|
func (p *ProclamationOptions) HandleEvent(event *sdl.Event) error {
|
|
switch e := (*event).(type) {
|
|
case *sdl.KeyboardEvent:
|
|
if e.Type != sdl.KEYDOWN {
|
|
return nil
|
|
}
|
|
|
|
sym := e.Keysym.Sym
|
|
|
|
// --- Backspace: always handled specially ---
|
|
if sym == sdl.K_BACKSPACE {
|
|
if p.isSearchActive {
|
|
if len(p.searchQuery) > 0 {
|
|
p.searchQuery = p.searchQuery[:len(p.searchQuery)-1]
|
|
}
|
|
if p.searchQuery == "" {
|
|
p.exitSearchMode()
|
|
} else {
|
|
p.buildSearchList()
|
|
p.rebuildSearchLabel()
|
|
}
|
|
p.layout()
|
|
return nil
|
|
}
|
|
// Browse mode backspace — navigate back
|
|
return nil
|
|
}
|
|
|
|
// --- Escape ---
|
|
if sym == sdl.K_ESCAPE {
|
|
if p.isSearchActive {
|
|
p.exitSearchMode()
|
|
p.layout()
|
|
return nil
|
|
}
|
|
p.Context.NavigateTo(SETTINGS)
|
|
return nil
|
|
}
|
|
|
|
// --- Search mode input handling ---
|
|
if p.isSearchActive {
|
|
switch sym {
|
|
case sdl.K_UP:
|
|
if p.searchHighlight > 0 {
|
|
p.searchHighlight--
|
|
if p.searchHighlight < p.searchScrollOff {
|
|
p.searchScrollOff--
|
|
}
|
|
}
|
|
case sdl.K_DOWN:
|
|
if p.searchHighlight < len(p.searchItems)-1 {
|
|
p.searchHighlight++
|
|
if p.searchHighlight >= p.searchScrollOff+p.maxVisible {
|
|
p.searchScrollOff++
|
|
}
|
|
}
|
|
case sdl.K_PAGEUP:
|
|
p.searchHighlight = p.searchScrollOff
|
|
p.searchScrollOff -= p.maxVisible - 1
|
|
if p.searchScrollOff < 0 {
|
|
p.searchScrollOff = 0
|
|
p.searchHighlight = 0
|
|
}
|
|
case sdl.K_PAGEDOWN:
|
|
bottom := p.searchScrollOff + p.maxVisible - 1
|
|
if bottom >= len(p.searchItems) {
|
|
bottom = len(p.searchItems) - 1
|
|
}
|
|
p.searchScrollOff = bottom
|
|
p.searchHighlight = bottom
|
|
case sdl.K_SPACE:
|
|
if len(p.searchItems) > 0 {
|
|
item := p.searchItems[p.searchHighlight]
|
|
p.activeMap[item.ID] = !p.activeMap[item.ID]
|
|
}
|
|
case sdl.K_RETURN:
|
|
p.acceptChanges()
|
|
default:
|
|
// Append printable characters to search query
|
|
r := rune(sym)
|
|
if r >= 33 && r <= 126 {
|
|
if e.Keysym.Mod&sdl.KMOD_SHIFT != 0 {
|
|
r = unicode.ToUpper(r)
|
|
}
|
|
p.searchQuery += string(r)
|
|
p.buildSearchList()
|
|
p.rebuildSearchLabel()
|
|
}
|
|
}
|
|
p.layout()
|
|
return nil
|
|
}
|
|
|
|
// --- Browse mode ---
|
|
switch sym {
|
|
case sdl.K_UP:
|
|
if p.highlightIndex > 0 {
|
|
p.highlightIndex--
|
|
if p.highlightIndex < p.scrollOffset {
|
|
p.scrollOffset--
|
|
}
|
|
}
|
|
case sdl.K_DOWN:
|
|
if p.highlightIndex < len(p.allItems)-1 {
|
|
p.highlightIndex++
|
|
if p.highlightIndex >= p.scrollOffset+p.maxVisible {
|
|
p.scrollOffset++
|
|
}
|
|
}
|
|
case sdl.K_PAGEUP:
|
|
p.highlightIndex = p.scrollOffset
|
|
p.scrollOffset -= p.maxVisible - 1
|
|
if p.scrollOffset < 0 {
|
|
p.scrollOffset = 0
|
|
p.highlightIndex = 0
|
|
}
|
|
case sdl.K_PAGEDOWN:
|
|
bottomIdx := p.scrollOffset + p.maxVisible - 1
|
|
if bottomIdx >= len(p.allItems) {
|
|
bottomIdx = len(p.allItems) - 1
|
|
}
|
|
p.scrollOffset = bottomIdx
|
|
p.highlightIndex = bottomIdx
|
|
case sdl.K_RETURN:
|
|
p.acceptChanges()
|
|
case sdl.K_SPACE:
|
|
item := p.allItems[p.highlightIndex]
|
|
if !item.IsCategory { // If the item is NOT a Category
|
|
p.activeMap[item.ID] = !p.activeMap[item.ID] // Toggle it from the 'selected' list
|
|
} else if !item.IsSubCategory {
|
|
p.toggleExpansion(p.highlightIndex)
|
|
}
|
|
default:
|
|
// Any printable character enters search mode
|
|
r := rune(sym)
|
|
if r >= 33 && r <= 126 {
|
|
if e.Keysym.Mod&sdl.KMOD_SHIFT != 0 {
|
|
r = unicode.ToUpper(r)
|
|
}
|
|
p.enterSearchMode(r)
|
|
}
|
|
}
|
|
|
|
p.layout()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *ProclamationOptions) acceptChanges() {
|
|
p.Context.DbPtr.Transaction(func(tx *gorm.DB) error {
|
|
tx.Model(&db.Proclamation{}).Where("1 = 1").Update("selected", false)
|
|
var ids []string
|
|
for id, active := range p.activeMap {
|
|
if active {
|
|
ids = append(ids, id)
|
|
}
|
|
}
|
|
if len(ids) > 0 {
|
|
tx.Model(&db.Proclamation{}).Where("id IN ?", ids).Update("selected", true)
|
|
}
|
|
return nil
|
|
})
|
|
p.Context.NavigateTo(SCROLLER)
|
|
}
|
|
|
|
func (p *ProclamationOptions) Render() error {
|
|
p.RenderTexture(p.textShader, p.title.ID, p.title.Position(), p.title.RawDimensions(), p.title.Color)
|
|
p.RenderTexture(p.textShader, p.prompt.ID, p.prompt.Position(), p.prompt.RawDimensions(), p.prompt.Color)
|
|
|
|
if p.isSearchActive {
|
|
// Search bar label
|
|
if p.searchInput.ID != 0 {
|
|
p.RenderTexture(p.textShader, p.searchInput.ID, p.searchInput.Position(), p.searchInput.RawDimensions(), p.searchInput.Color)
|
|
}
|
|
|
|
if len(p.searchItems) == 0 {
|
|
return nil
|
|
}
|
|
|
|
// Highlight box for search results
|
|
if p.searchHighlight >= p.searchScrollOff && p.searchHighlight < p.searchScrollOff+p.maxVisible {
|
|
target := p.searchItems[p.searchHighlight].Label
|
|
p.RenderSolidColorQuad(p.solidShader, target.Position(), target.RawDimensions(), colors.White)
|
|
}
|
|
|
|
for i := p.searchScrollOff; i < p.searchScrollOff+p.maxVisible && i < len(p.searchItems); i++ {
|
|
item := p.searchItems[i]
|
|
if i == p.searchHighlight {
|
|
item.Label.Color = colors.Black
|
|
} else if p.activeMap[item.ID] {
|
|
item.Label.Color = colors.Orange
|
|
} else {
|
|
item.Label.Color = colors.White
|
|
}
|
|
p.RenderTexture(p.textShader, item.Label.ID, item.Label.Position(), item.Label.RawDimensions(), item.Label.Color)
|
|
}
|
|
|
|
p.renderSearchScrollbar()
|
|
return nil
|
|
}
|
|
|
|
// Browse mode
|
|
if len(p.allItems) == 0 {
|
|
return nil
|
|
}
|
|
|
|
if p.highlightIndex >= p.scrollOffset && p.highlightIndex < p.scrollOffset+p.maxVisible {
|
|
target := p.allItems[p.highlightIndex].Label
|
|
p.RenderSolidColorQuad(p.solidShader, target.Position(), target.RawDimensions(), colors.White)
|
|
}
|
|
|
|
for i := p.scrollOffset; i < p.scrollOffset+p.maxVisible && i < len(p.allItems); i++ {
|
|
item := p.allItems[i]
|
|
if i == p.highlightIndex {
|
|
item.Label.Color = colors.Black
|
|
} else if item.IsCategory {
|
|
item.Label.Color = colors.DodgerBlue
|
|
} else if p.activeMap[item.ID] {
|
|
item.Label.Color = colors.Orange
|
|
} else {
|
|
item.Label.Color = colors.White
|
|
}
|
|
p.RenderTexture(p.textShader, item.Label.ID, item.Label.Position(), item.Label.RawDimensions(), item.Label.Color)
|
|
}
|
|
|
|
p.renderScrollbar()
|
|
return nil
|
|
}
|
|
|
|
func (p *ProclamationOptions) renderScrollbar() {
|
|
total := len(p.allItems)
|
|
if total <= p.maxVisible {
|
|
return
|
|
}
|
|
|
|
p.RenderSolidColorQuad(p.solidShader,
|
|
mgl32.Vec2{float32(p.scrollTrackX), float32(p.scrollTrackY)},
|
|
mgl32.Vec2{float32(p.scrollTrackWidth), float32(p.scrollTrackHeight)},
|
|
colorScrollTrack)
|
|
|
|
visibleRatio := float32(p.maxVisible) / float32(total)
|
|
scrollRatio := float32(p.scrollOffset) / float32(total)
|
|
thumbHeight := float32(p.scrollTrackHeight) * visibleRatio
|
|
if thumbHeight < 20 {
|
|
thumbHeight = 20
|
|
}
|
|
thumbY := float32(p.scrollTrackY) + float32(p.scrollTrackHeight)*scrollRatio
|
|
|
|
p.RenderSolidColorQuad(p.solidShader,
|
|
mgl32.Vec2{float32(p.scrollTrackX + 2), thumbY},
|
|
mgl32.Vec2{float32(p.scrollTrackWidth - 4), thumbHeight},
|
|
colorScrollThumb)
|
|
}
|
|
|
|
func (p *ProclamationOptions) renderSearchScrollbar() {
|
|
total := len(p.searchItems)
|
|
if total <= p.maxVisible {
|
|
return
|
|
}
|
|
|
|
p.RenderSolidColorQuad(p.solidShader,
|
|
mgl32.Vec2{float32(p.scrollTrackX), float32(p.scrollTrackY)},
|
|
mgl32.Vec2{float32(p.scrollTrackWidth), float32(p.scrollTrackHeight)},
|
|
colorScrollTrack)
|
|
|
|
visibleRatio := float32(p.maxVisible) / float32(total)
|
|
scrollRatio := float32(p.searchScrollOff) / float32(total)
|
|
thumbHeight := float32(p.scrollTrackHeight) * visibleRatio
|
|
if thumbHeight < 20 {
|
|
thumbHeight = 20
|
|
}
|
|
thumbY := float32(p.scrollTrackY) + float32(p.scrollTrackHeight)*scrollRatio
|
|
|
|
p.RenderSolidColorQuad(p.solidShader,
|
|
mgl32.Vec2{float32(p.scrollTrackX + 2), thumbY},
|
|
mgl32.Vec2{float32(p.scrollTrackWidth - 4), thumbHeight},
|
|
colorScrollThumb)
|
|
}
|
|
|
|
func (p *ProclamationOptions) Destroy() error {
|
|
gl.DeleteTextures(1, &p.title.ID)
|
|
gl.DeleteTextures(1, &p.prompt.ID)
|
|
if p.searchInput.ID != 0 {
|
|
gl.DeleteTextures(1, &p.searchInput.ID)
|
|
}
|
|
// Delete browse category textures
|
|
for _, item := range p.allItems {
|
|
if item.IsCategory {
|
|
gl.DeleteTextures(1, &item.Label.ID)
|
|
}
|
|
}
|
|
// Delete proclamation textures via the pool (single source of truth)
|
|
for _, item := range p.allProclamations {
|
|
gl.DeleteTextures(1, &item.Label.ID)
|
|
}
|
|
return nil
|
|
}
|