mirror of
https://github.com/vsariola/sointu.git
synced 2025-07-20 14:04:34 -04:00
501 lines
18 KiB
Go
501 lines
18 KiB
Go
package gioui
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"image"
|
|
"image/color"
|
|
"io"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"gioui.org/io/clipboard"
|
|
"gioui.org/io/event"
|
|
"gioui.org/io/key"
|
|
"gioui.org/layout"
|
|
"gioui.org/op"
|
|
"gioui.org/op/clip"
|
|
"gioui.org/text"
|
|
"gioui.org/unit"
|
|
"github.com/vsariola/sointu"
|
|
"github.com/vsariola/sointu/tracker"
|
|
"golang.org/x/exp/shiny/materialdesign/icons"
|
|
)
|
|
|
|
type (
|
|
PatchPanel struct {
|
|
instrList InstrumentList
|
|
tools InstrumentTools
|
|
unitList UnitList
|
|
unitEditor UnitEditor
|
|
}
|
|
|
|
InstrumentList struct {
|
|
instrumentDragList *DragList
|
|
nameEditor *Editor
|
|
|
|
octave *NumericUpDownState
|
|
enlargeBtn *Clickable
|
|
linkInstrTrackBtn *Clickable
|
|
newInstrumentBtn *Clickable
|
|
|
|
octaveHint string
|
|
linkDisabledHint string
|
|
linkEnabledHint string
|
|
enlargeHint, shrinkHint string
|
|
addInstrumentHint string
|
|
}
|
|
|
|
InstrumentTools struct {
|
|
Voices *NumericUpDownState
|
|
splitInstrumentBtn *Clickable
|
|
commentExpandBtn *Clickable
|
|
commentEditor *Editor
|
|
soloBtn *Clickable
|
|
muteBtn *Clickable
|
|
presetMenuBtn *Clickable
|
|
presetMenu MenuState
|
|
presetMenuItems []ActionMenuItem
|
|
saveInstrumentBtn *Clickable
|
|
loadInstrumentBtn *Clickable
|
|
copyInstrumentBtn *Clickable
|
|
deleteInstrumentBtn *Clickable
|
|
|
|
commentExpanded tracker.Bool
|
|
|
|
muteHint, unmuteHint string
|
|
soloHint, unsoloHint string
|
|
expandCommentHint string
|
|
collapseCommentHint string
|
|
splitInstrumentHint string
|
|
deleteInstrumentHint string
|
|
}
|
|
|
|
UnitList struct {
|
|
dragList *DragList
|
|
searchEditor *Editor
|
|
addUnitBtn *Clickable
|
|
addUnitAction tracker.Action
|
|
}
|
|
)
|
|
|
|
// PatchPanel methods
|
|
|
|
func NewPatchPanel(model *tracker.Model) *PatchPanel {
|
|
return &PatchPanel{
|
|
instrList: MakeInstrList(model),
|
|
tools: MakeInstrumentTools(model),
|
|
unitList: MakeUnitList(model),
|
|
unitEditor: *NewUnitEditor(model),
|
|
}
|
|
}
|
|
|
|
func (pp *PatchPanel) Layout(gtx C) D {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
|
|
layout.Rigid(pp.instrList.Layout),
|
|
layout.Rigid(pp.tools.Layout),
|
|
layout.Flexed(1, func(gtx C) D {
|
|
return layout.Flex{Axis: layout.Horizontal}.Layout(gtx,
|
|
layout.Rigid(pp.unitList.Layout),
|
|
layout.Flexed(1, pp.unitEditor.Layout),
|
|
)
|
|
}))
|
|
}
|
|
|
|
func (pp *PatchPanel) Tags(level int, yield TagYieldFunc) bool {
|
|
return pp.instrList.Tags(level, yield) &&
|
|
pp.tools.Tags(level, yield) &&
|
|
pp.unitList.Tags(level, yield) &&
|
|
pp.unitEditor.Tags(level, yield)
|
|
}
|
|
|
|
// TreeFocused returns true if any of the tags in the patch panel is focused
|
|
func (pp *PatchPanel) TreeFocused(gtx C) bool {
|
|
return !pp.Tags(0, func(_ int, tag event.Tag) bool {
|
|
return !gtx.Focused(tag)
|
|
})
|
|
}
|
|
|
|
// InstrumentTools methods
|
|
|
|
func MakeInstrumentTools(m *tracker.Model) InstrumentTools {
|
|
ret := InstrumentTools{
|
|
Voices: NewNumericUpDownState(),
|
|
deleteInstrumentBtn: new(Clickable),
|
|
splitInstrumentBtn: new(Clickable),
|
|
copyInstrumentBtn: new(Clickable),
|
|
saveInstrumentBtn: new(Clickable),
|
|
loadInstrumentBtn: new(Clickable),
|
|
commentExpandBtn: new(Clickable),
|
|
presetMenuBtn: new(Clickable),
|
|
soloBtn: new(Clickable),
|
|
muteBtn: new(Clickable),
|
|
presetMenuItems: []ActionMenuItem{},
|
|
commentEditor: NewEditor(false, false, text.Start),
|
|
commentExpanded: m.CommentExpanded(),
|
|
expandCommentHint: makeHint("Expand comment", " (%s)", "CommentExpandedToggle"),
|
|
collapseCommentHint: makeHint("Collapse comment", " (%s)", "CommentExpandedToggle"),
|
|
deleteInstrumentHint: makeHint("Delete\ninstrument", "\n(%s)", "DeleteInstrument"),
|
|
muteHint: makeHint("Mute", " (%s)", "MuteToggle"),
|
|
unmuteHint: makeHint("Unmute", " (%s)", "MuteToggle"),
|
|
soloHint: makeHint("Solo", " (%s)", "SoloToggle"),
|
|
unsoloHint: makeHint("Unsolo", " (%s)", "SoloToggle"),
|
|
splitInstrumentHint: makeHint("Split instrument", " (%s)", "SplitInstrument"),
|
|
}
|
|
for index, name := range m.IterateInstrumentPresets {
|
|
ret.presetMenuItems = append(ret.presetMenuItems, MenuItem(m.LoadPreset(index), name, "", icons.ImageAudiotrack))
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (it *InstrumentTools) Layout(gtx C) D {
|
|
t := TrackerFromContext(gtx)
|
|
it.update(gtx, t)
|
|
voicesLabel := Label(t.Theme, &t.Theme.InstrumentEditor.Voices, "Voices")
|
|
splitInstrumentBtn := ActionIconBtn(t.SplitInstrument(), t.Theme, it.splitInstrumentBtn, icons.CommunicationCallSplit, it.splitInstrumentHint)
|
|
commentExpandedBtn := ToggleIconBtn(t.CommentExpanded(), t.Theme, it.commentExpandBtn, icons.NavigationExpandMore, icons.NavigationExpandLess, it.expandCommentHint, it.collapseCommentHint)
|
|
soloBtn := ToggleIconBtn(t.Solo(), t.Theme, it.soloBtn, icons.SocialGroup, icons.SocialPerson, it.soloHint, it.unsoloHint)
|
|
muteBtn := ToggleIconBtn(t.Mute(), t.Theme, it.muteBtn, icons.AVVolumeUp, icons.AVVolumeOff, it.muteHint, it.unmuteHint)
|
|
saveInstrumentBtn := IconBtn(t.Theme, &t.Theme.IconButton.Enabled, it.saveInstrumentBtn, icons.ContentSave, "Save instrument")
|
|
loadInstrumentBtn := IconBtn(t.Theme, &t.Theme.IconButton.Enabled, it.loadInstrumentBtn, icons.FileFolderOpen, "Load instrument")
|
|
copyInstrumentBtn := IconBtn(t.Theme, &t.Theme.IconButton.Enabled, it.copyInstrumentBtn, icons.ContentContentCopy, "Copy instrument")
|
|
deleteInstrumentBtn := ActionIconBtn(t.DeleteInstrument(), t.Theme, it.deleteInstrumentBtn, icons.ActionDelete, it.deleteInstrumentHint)
|
|
instrumentVoices := NumUpDown(t.Model.InstrumentVoices(), t.Theme, it.Voices, "Number of voices for this instrument")
|
|
btns := func(gtx C) D {
|
|
return layout.Flex{Axis: layout.Horizontal, Alignment: layout.Middle}.Layout(gtx,
|
|
layout.Rigid(layout.Spacer{Width: 6}.Layout),
|
|
layout.Rigid(voicesLabel.Layout),
|
|
layout.Rigid(layout.Spacer{Width: 4}.Layout),
|
|
layout.Rigid(instrumentVoices.Layout),
|
|
layout.Rigid(splitInstrumentBtn.Layout),
|
|
layout.Flexed(1, func(gtx C) D { return layout.Dimensions{Size: gtx.Constraints.Min} }),
|
|
layout.Rigid(commentExpandedBtn.Layout),
|
|
layout.Rigid(soloBtn.Layout),
|
|
layout.Rigid(muteBtn.Layout),
|
|
layout.Rigid(func(gtx C) D {
|
|
presetBtn := IconBtn(t.Theme, &t.Theme.IconButton.Enabled, it.presetMenuBtn, icons.NavigationMenu, "Load preset")
|
|
dims := presetBtn.Layout(gtx)
|
|
op.Offset(image.Pt(0, dims.Size.Y)).Add(gtx.Ops)
|
|
m := Menu(t.Theme, &it.presetMenu)
|
|
m.Style = &t.Theme.Menu.Preset
|
|
m.Layout(gtx, it.presetMenuItems...)
|
|
return dims
|
|
}),
|
|
layout.Rigid(saveInstrumentBtn.Layout),
|
|
layout.Rigid(loadInstrumentBtn.Layout),
|
|
layout.Rigid(copyInstrumentBtn.Layout),
|
|
layout.Rigid(deleteInstrumentBtn.Layout),
|
|
)
|
|
}
|
|
comment := func(gtx C) D {
|
|
defer clip.Rect(image.Rect(0, 0, gtx.Constraints.Max.X, gtx.Constraints.Max.Y)).Push(gtx.Ops).Pop()
|
|
ret := layout.UniformInset(unit.Dp(6)).Layout(gtx, func(gtx C) D {
|
|
return it.commentEditor.Layout(gtx, t.InstrumentComment(), t.Theme, &t.Theme.InstrumentEditor.InstrumentComment, "Comment")
|
|
})
|
|
return ret
|
|
}
|
|
return Surface{Gray: 37, Focus: t.PatchPanel.TreeFocused(gtx)}.Layout(gtx, func(gtx C) D {
|
|
if t.CommentExpanded().Value() {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(gtx, layout.Rigid(btns), layout.Rigid(comment))
|
|
}
|
|
return btns(gtx)
|
|
})
|
|
}
|
|
|
|
func (it *InstrumentTools) update(gtx C, tr *Tracker) {
|
|
for it.copyInstrumentBtn.Clicked(gtx) {
|
|
if contents, ok := tr.Instruments().List().CopyElements(); ok {
|
|
gtx.Execute(clipboard.WriteCmd{Type: "application/text", Data: io.NopCloser(bytes.NewReader(contents))})
|
|
tr.Alerts().Add("Instrument copied to clipboard", tracker.Info)
|
|
}
|
|
}
|
|
for it.saveInstrumentBtn.Clicked(gtx) {
|
|
writer, err := tr.Explorer.CreateFile(tr.InstrumentName().Value() + ".yml")
|
|
if err != nil {
|
|
continue
|
|
}
|
|
tr.SaveInstrument(writer)
|
|
}
|
|
for it.loadInstrumentBtn.Clicked(gtx) {
|
|
reader, err := tr.Explorer.ChooseFile(".yml", ".json", ".4ki", ".4kp")
|
|
if err != nil {
|
|
continue
|
|
}
|
|
tr.LoadInstrument(reader)
|
|
}
|
|
for it.presetMenuBtn.Clicked(gtx) {
|
|
it.presetMenu.visible = true
|
|
}
|
|
for it.commentEditor.Update(gtx, tr.InstrumentComment()) != EditorEventNone {
|
|
tr.PatchPanel.instrList.instrumentDragList.Focus()
|
|
}
|
|
}
|
|
|
|
func (it *InstrumentTools) Tags(level int, yield TagYieldFunc) bool {
|
|
if it.commentExpanded.Value() {
|
|
return yield(level+1, &it.commentEditor.widgetEditor)
|
|
}
|
|
return true
|
|
}
|
|
|
|
// InstrumentList methods
|
|
|
|
func MakeInstrList(model *tracker.Model) InstrumentList {
|
|
return InstrumentList{
|
|
instrumentDragList: NewDragList(model.Instruments().List(), layout.Horizontal),
|
|
nameEditor: NewEditor(true, true, text.Middle),
|
|
octave: NewNumericUpDownState(),
|
|
enlargeBtn: new(Clickable),
|
|
linkInstrTrackBtn: new(Clickable),
|
|
newInstrumentBtn: new(Clickable),
|
|
octaveHint: makeHint("Octave down", " (%s)", "OctaveNumberInputSubtract") + makeHint(" or up", " (%s)", "OctaveNumberInputAdd"),
|
|
linkDisabledHint: makeHint("Instrument-Track\nlinking disabled", "\n(%s)", "LinkInstrTrackToggle"),
|
|
linkEnabledHint: makeHint("Instrument-Track\nlinking enabled", "\n(%s)", "LinkInstrTrackToggle"),
|
|
enlargeHint: makeHint("Enlarge", " (%s)", "InstrEnlargedToggle"),
|
|
shrinkHint: makeHint("Shrink", " (%s)", "InstrEnlargedToggle"),
|
|
addInstrumentHint: makeHint("Add\ninstrument", "\n(%s)", "AddInstrument"),
|
|
}
|
|
}
|
|
|
|
func (il *InstrumentList) Layout(gtx C) D {
|
|
t := TrackerFromContext(gtx)
|
|
il.update(gtx, t)
|
|
octave := NumUpDown(t.Model.Octave(), t.Theme, t.OctaveNumberInput, "Octave")
|
|
linkInstrTrackBtn := ToggleIconBtn(t.Model.LinkInstrTrack(), t.Theme, il.linkInstrTrackBtn, icons.NotificationSyncDisabled, icons.NotificationSync, il.linkDisabledHint, il.linkEnabledHint)
|
|
instrEnlargedBtn := ToggleIconBtn(t.Model.InstrEnlarged(), t.Theme, il.enlargeBtn, icons.NavigationFullscreen, icons.NavigationFullscreenExit, il.enlargeHint, il.shrinkHint)
|
|
addInstrumentBtn := ActionIconBtn(t.Model.AddInstrument(), t.Theme, il.newInstrumentBtn, icons.ContentAdd, il.addInstrumentHint)
|
|
return layout.Flex{Axis: layout.Horizontal, Alignment: layout.Middle}.Layout(
|
|
gtx,
|
|
layout.Flexed(1, il.actualLayout),
|
|
layout.Rigid(layout.Spacer{Width: 10}.Layout),
|
|
layout.Rigid(Label(t.Theme, &t.Theme.InstrumentEditor.Octave, "Octave").Layout),
|
|
layout.Rigid(layout.Spacer{Width: 4}.Layout),
|
|
layout.Rigid(octave.Layout),
|
|
layout.Rigid(linkInstrTrackBtn.Layout),
|
|
layout.Rigid(instrEnlargedBtn.Layout),
|
|
layout.Rigid(addInstrumentBtn.Layout),
|
|
)
|
|
}
|
|
|
|
func (il *InstrumentList) actualLayout(gtx C) D {
|
|
t := TrackerFromContext(gtx)
|
|
gtx.Constraints.Max.Y = gtx.Dp(36)
|
|
gtx.Constraints.Min.Y = gtx.Dp(36)
|
|
element := func(gtx C, i int) D {
|
|
grabhandle := Label(t.Theme, &t.Theme.InstrumentEditor.InstrumentList.Number, strconv.Itoa(i+1))
|
|
label := func(gtx C) D {
|
|
name, level, mute, ok := (*tracker.Instruments)(t.Model).Item(i)
|
|
if !ok {
|
|
labelStyle := Label(t.Theme, &t.Theme.InstrumentEditor.InstrumentList.Number, "")
|
|
return layout.Center.Layout(gtx, labelStyle.Layout)
|
|
}
|
|
s := t.Theme.InstrumentEditor.InstrumentList.NameMuted
|
|
if !mute {
|
|
s = t.Theme.InstrumentEditor.InstrumentList.Name
|
|
k := byte(255 - level*127)
|
|
s.Color = color.NRGBA{R: 255, G: k, B: 255, A: 255}
|
|
}
|
|
if i == il.instrumentDragList.TrackerList.Selected() {
|
|
for il.nameEditor.Update(gtx, t.InstrumentName()) != EditorEventNone {
|
|
il.instrumentDragList.Focus()
|
|
}
|
|
return layout.Center.Layout(gtx, func(gtx C) D {
|
|
defer clip.Rect(image.Rect(0, 0, gtx.Constraints.Max.X, gtx.Constraints.Max.Y)).Push(gtx.Ops).Pop()
|
|
return il.nameEditor.Layout(gtx, t.InstrumentName(), t.Theme, &s, "Instr")
|
|
})
|
|
}
|
|
if name == "" {
|
|
name = "Instr"
|
|
}
|
|
l := s.AsLabelStyle()
|
|
return layout.Center.Layout(gtx, Label(t.Theme, &l, name).Layout)
|
|
}
|
|
return layout.Center.Layout(gtx, func(gtx C) D {
|
|
return layout.Inset{Left: unit.Dp(6), Right: unit.Dp(6)}.Layout(gtx, func(gtx C) D {
|
|
return layout.Flex{Axis: layout.Vertical, Alignment: layout.Middle}.Layout(gtx,
|
|
layout.Rigid(grabhandle.Layout),
|
|
layout.Rigid(label),
|
|
)
|
|
})
|
|
})
|
|
}
|
|
instrumentList := FilledDragList(t.Theme, il.instrumentDragList)
|
|
instrumentList.ScrollBar = t.Theme.InstrumentEditor.InstrumentList.ScrollBar
|
|
defer clip.Rect(image.Rect(0, 0, gtx.Constraints.Max.X, gtx.Constraints.Max.Y)).Push(gtx.Ops).Pop()
|
|
dims := instrumentList.Layout(gtx, element, nil)
|
|
gtx.Constraints = layout.Exact(dims.Size)
|
|
instrumentList.LayoutScrollBar(gtx)
|
|
return dims
|
|
}
|
|
|
|
func (il *InstrumentList) update(gtx C, t *Tracker) {
|
|
for {
|
|
event, ok := gtx.Event(
|
|
key.Filter{Focus: il.instrumentDragList, Name: key.NameDownArrow},
|
|
key.Filter{Focus: il.instrumentDragList, Name: key.NameReturn},
|
|
key.Filter{Focus: il.instrumentDragList, Name: key.NameEnter},
|
|
)
|
|
if !ok {
|
|
break
|
|
}
|
|
if e, ok := event.(key.Event); ok && e.State == key.Press {
|
|
switch e.Name {
|
|
case key.NameDownArrow:
|
|
t.PatchPanel.unitList.dragList.Focus()
|
|
case key.NameReturn, key.NameEnter:
|
|
il.nameEditor.Focus()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (il *InstrumentList) Tags(level int, yield TagYieldFunc) bool {
|
|
return yield(level, il.instrumentDragList)
|
|
}
|
|
|
|
// UnitList methods
|
|
|
|
func MakeUnitList(m *tracker.Model) UnitList {
|
|
ret := UnitList{
|
|
dragList: NewDragList(m.Units().List(), layout.Vertical),
|
|
addUnitBtn: new(Clickable),
|
|
searchEditor: NewEditor(true, true, text.Start),
|
|
}
|
|
ret.addUnitAction = tracker.MakeEnabledAction(tracker.DoFunc(func() {
|
|
m.AddUnit(false).Do()
|
|
ret.searchEditor.Focus()
|
|
}))
|
|
return ret
|
|
}
|
|
|
|
func (ul *UnitList) Layout(gtx C) D {
|
|
t := TrackerFromContext(gtx)
|
|
ul.update(gtx, t)
|
|
var units [256]tracker.UnitListItem
|
|
for i, item := range (*tracker.Units)(t.Model).Iterate {
|
|
if i >= 256 {
|
|
break
|
|
}
|
|
units[i] = item
|
|
}
|
|
count := min(ul.dragList.TrackerList.Count(), 256)
|
|
element := func(gtx C, i int) D {
|
|
gtx.Constraints.Max.Y = gtx.Dp(20)
|
|
gtx.Constraints.Min.Y = gtx.Constraints.Max.Y
|
|
if i < 0 || i > 255 {
|
|
return layout.Dimensions{Size: gtx.Constraints.Min}
|
|
}
|
|
u := units[i]
|
|
editorStyle := t.Theme.InstrumentEditor.UnitList.Name
|
|
if u.Disabled {
|
|
editorStyle = t.Theme.InstrumentEditor.UnitList.NameDisabled
|
|
}
|
|
stackText := strconv.FormatInt(int64(u.StackAfter), 10)
|
|
if u.StackNeed > u.StackBefore {
|
|
editorStyle.Color = t.Theme.InstrumentEditor.UnitList.Error
|
|
(*tracker.Alerts)(t.Model).AddNamed("UnitNeedsInputs", fmt.Sprintf("%v needs at least %v input signals, got %v", u.Type, u.StackNeed, u.StackBefore), tracker.Error)
|
|
} else if i == count-1 && u.StackAfter != 0 {
|
|
editorStyle.Color = t.Theme.InstrumentEditor.UnitList.Warning
|
|
(*tracker.Alerts)(t.Model).AddNamed("InstrumentLeavesSignals", fmt.Sprintf("Instrument leaves %v signal(s) on the stack", u.StackAfter), tracker.Warning)
|
|
}
|
|
stackLabel := Label(t.Theme, &t.Theme.InstrumentEditor.UnitList.Stack, stackText)
|
|
rightMargin := layout.Inset{Right: unit.Dp(10)}
|
|
return layout.Flex{Axis: layout.Horizontal}.Layout(gtx,
|
|
layout.Rigid(func(gtx C) D {
|
|
if i == ul.dragList.TrackerList.Selected() {
|
|
defer clip.Rect(image.Rect(0, 0, gtx.Constraints.Max.X, gtx.Constraints.Max.Y)).Push(gtx.Ops).Pop()
|
|
str := t.Model.UnitSearch()
|
|
for ev := ul.searchEditor.Update(gtx, str); ev != EditorEventNone; ev = ul.searchEditor.Update(gtx, str) {
|
|
if ev == EditorEventSubmit {
|
|
if str.Value() != "" {
|
|
for _, n := range sointu.UnitNames {
|
|
if strings.HasPrefix(n, str.Value()) {
|
|
t.Units().SetSelectedType(n)
|
|
break
|
|
}
|
|
}
|
|
} else {
|
|
t.Units().SetSelectedType("")
|
|
}
|
|
}
|
|
ul.dragList.Focus()
|
|
t.UnitSearching().SetValue(false)
|
|
}
|
|
return ul.searchEditor.Layout(gtx, str, t.Theme, &editorStyle, "---")
|
|
} else {
|
|
text := u.Type
|
|
if text == "" {
|
|
text = "---"
|
|
}
|
|
l := editorStyle.AsLabelStyle()
|
|
return Label(t.Theme, &l, text).Layout(gtx)
|
|
}
|
|
}),
|
|
layout.Flexed(1, func(gtx C) D {
|
|
unitNameLabel := Label(t.Theme, &t.Theme.InstrumentEditor.UnitList.Comment, u.Comment)
|
|
inset := layout.Inset{Left: unit.Dp(5)}
|
|
return inset.Layout(gtx, unitNameLabel.Layout)
|
|
}),
|
|
layout.Rigid(func(gtx C) D {
|
|
return rightMargin.Layout(gtx, stackLabel.Layout)
|
|
}),
|
|
)
|
|
}
|
|
defer op.Offset(image.Point{}).Push(gtx.Ops).Pop()
|
|
unitList := FilledDragList(t.Theme, ul.dragList)
|
|
return Surface{Gray: 30, Focus: t.PatchPanel.TreeFocused(gtx)}.Layout(gtx, func(gtx C) D {
|
|
return layout.Stack{Alignment: layout.SE}.Layout(gtx,
|
|
layout.Expanded(func(gtx C) D {
|
|
defer clip.Rect(image.Rect(0, 0, gtx.Constraints.Max.X, gtx.Constraints.Max.Y)).Push(gtx.Ops).Pop()
|
|
gtx.Constraints = layout.Exact(image.Pt(gtx.Dp(140), gtx.Constraints.Max.Y))
|
|
dims := unitList.Layout(gtx, element, nil)
|
|
unitList.LayoutScrollBar(gtx)
|
|
return dims
|
|
}),
|
|
layout.Stacked(func(gtx C) D {
|
|
margin := layout.Inset{Right: unit.Dp(20), Bottom: unit.Dp(1)}
|
|
addUnitBtn := IconBtn(t.Theme, &t.Theme.IconButton.Emphasis, ul.addUnitBtn, icons.ContentAdd, "Add unit (Enter)")
|
|
return margin.Layout(gtx, addUnitBtn.Layout)
|
|
}),
|
|
)
|
|
})
|
|
}
|
|
|
|
func (ul *UnitList) update(gtx C, t *Tracker) {
|
|
for ul.addUnitBtn.Clicked(gtx) {
|
|
ul.addUnitAction.Do()
|
|
}
|
|
for {
|
|
event, ok := gtx.Event(
|
|
key.Filter{Focus: ul.dragList, Name: key.NameRightArrow},
|
|
key.Filter{Focus: ul.dragList, Name: key.NameEnter, Optional: key.ModCtrl},
|
|
key.Filter{Focus: ul.dragList, Name: key.NameReturn, Optional: key.ModCtrl},
|
|
key.Filter{Focus: ul.dragList, Name: key.NameDeleteBackward},
|
|
key.Filter{Focus: ul.dragList, Name: key.NameEscape},
|
|
)
|
|
if !ok {
|
|
break
|
|
}
|
|
if e, ok := event.(key.Event); ok && e.State == key.Press {
|
|
switch e.Name {
|
|
case key.NameEscape:
|
|
t.PatchPanel.instrList.instrumentDragList.Focus()
|
|
case key.NameRightArrow:
|
|
t.PatchPanel.unitEditor.sliderList.Focus()
|
|
case key.NameDeleteBackward:
|
|
t.Units().SetSelectedType("")
|
|
t.UnitSearching().SetValue(true)
|
|
ul.searchEditor.Focus()
|
|
case key.NameEnter, key.NameReturn:
|
|
t.Model.AddUnit(e.Modifiers.Contain(key.ModCtrl)).Do()
|
|
t.UnitSearching().SetValue(true)
|
|
ul.searchEditor.Focus()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ul *UnitList) Tags(curLevel int, yield TagYieldFunc) bool {
|
|
return yield(curLevel, ul.dragList)
|
|
}
|