mirror/sointu
1
0
Fork 0
mirror of https://github.com/vsariola/sointu.git synced 2026-03-31 11:13:00 -04:00
Code Issues Packages Projects Releases Wiki Activity

feat(tracker): enum-style values and menus to choose one option

Browse Source
This commit is contained in:
5684185+vsariola@users.noreply.github.com
2026-01-27 23:26:13 +02:00
parent ca4b87d43d
commit 4bb5df9c87
19 changed files with 645 additions and 306 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
tracker/gioui/keybindings.go
View File

@ -283,6 +283,10 @@ func (t *Tracker) KeyEvent(e key.Event, gtx C) {
t.FocusNext(gtx, false)
case "FocusNextInto":
t.FocusNext(gtx, true)
case "MIDIRefresh":
t.MIDI().Refresh().Do()
case "ToggleMIDIInputtingNotes":
t.MIDI().InputtingNotes().Toggle()
default:
if len(action) > 4 && action[:4] == "Note" {
val, err := strconv.Atoi(string(action[4:]))

438
tracker/gioui/menu.go
View File

@ -5,23 +5,30 @@ import (
"image/color"
"gioui.org/io/event"
"gioui.org/io/key"
"gioui.org/io/pointer"
"gioui.org/layout"
"gioui.org/op"
"gioui.org/op/clip"
"gioui.org/op/paint"
"gioui.org/unit"
"gioui.org/widget"
"github.com/vsariola/sointu/tracker"
)
type (
// MenuState is the part of the menu that needs to be retained between frames.
MenuState struct {
visible bool
tags []bool
hover int
hoverOk bool
list layout.List
scrollBar ScrollBar
tag bool
visible bool
itemTmp []menuItem
}
// MenuStyle is the style for a menu that is stored in the theme.yml.
@ -34,139 +41,267 @@ type (
Height unit.Dp
}
// ActionMenuItem is a menu item that has an icon, text, shortcut and an action.
ActionMenuItem struct {
Icon []byte
Text string
Shortcut string
Action tracker.Action
}
// MenuWidget has a Layout method to display a menu
MenuWidget struct {
Theme *Theme
State *MenuState
Style *MenuStyle
}
// MenuButton displayes a button with text that opens a menu when clicked.
MenuButton struct {
Theme *Theme
Title string
Style *ButtonStyle
Clickable *Clickable
MenuState *MenuState
Width unit.Dp
State *MenuState
Style *MenuStyle
PopupStyle *PopupStyle
}
)
func Menu(th *Theme, state *MenuState) MenuWidget {
return MenuWidget{
Theme: th,
State: state,
Style: &th.Menu.Main,
func Menu(state *MenuState) MenuWidget { return MenuWidget{State: state} }
func (w MenuWidget) WithStyle(style *MenuStyle) MenuWidget { w.Style = style; return w }
func (w MenuWidget) WithPopupStyle(style *PopupStyle) MenuWidget { w.PopupStyle = style; return w }
func (ms *MenuState) Tags(level int, yield TagYieldFunc) bool {
if ms.visible {
return yield(level, &ms.tag)
}
return true
}
func MenuItem(act tracker.Action, text, shortcut string, icon []byte) ActionMenuItem {
return ActionMenuItem{
// MenuChild describes one or more menu items; if MenuChild is an Action or
// Bool, it's one item per child, but Ints are treated as enumerations and
// create one item per different possible values of the int.
type MenuChild struct {
Icon []byte
Text string
Shortcut string
kind menuChildKind
action tracker.Action
bool tracker.Bool
int tracker.Int
widget layout.Widget // these should be passive separators and such
}
type menuChildKind int
const (
menuChildAction menuChildKind = iota
menuChildBool
menuChildInt
menuChildList
menuChildDivider
)
func ActionMenuChild(act tracker.Action, text, shortcut string, icon []byte) MenuChild {
return MenuChild{
Icon: icon,
Text: text,
Shortcut: shortcut,
Action: act,
kind: menuChildAction,
action: act,
}
}
func MenuBtn(th *Theme, ms *MenuState, cl *Clickable, title string) MenuButton {
return MenuButton{
Theme: th,
Title: title,
Clickable: cl,
MenuState: ms,
Style: &th.Button.Menu,
func BoolMenuChild(b tracker.Bool, text, shortcut string, icon []byte) MenuChild {
return MenuChild{
Icon: icon,
Text: text,
Shortcut: shortcut,
kind: menuChildBool,
bool: b,
}
}
func (m *MenuWidget) Layout(gtx C, items ...ActionMenuItem) D {
func IntMenuChild(i tracker.Int, icon []byte) MenuChild {
return MenuChild{
Icon: icon,
kind: menuChildInt,
int: i,
}
}
func DividerMenuChild() MenuChild { return MenuChild{kind: menuChildDivider} }
// Layout the menu with the given items
func (m MenuWidget) Layout(gtx C, children ...MenuChild) D {
t := TrackerFromContext(gtx)
if m.Style == nil {
m.Style = &t.Theme.Menu.Main
}
// unfortunately, there was no way to include items into the MenuWidget
// without causing heap escapes, so they are passed as a parameter to the Layout
m.update(gtx, items...)
popup := Popup(m.Theme, &m.State.visible)
popup.Style = &m.Theme.Popup.Menu
return popup.Layout(gtx, func(gtx C) D {
m.State.itemTmp = m.State.itemTmp[:0]
for i, c := range children {
switch c.kind {
case menuChildAction:
m.State.itemTmp = append(m.State.itemTmp, menuItem{childIndex: i, icon: c.Icon, text: c.Text, shortcut: c.Shortcut, enabled: c.enabled()})
case menuChildBool:
mi := menuItem{childIndex: i, text: c.Text, shortcut: c.Shortcut, enabled: c.enabled()}
if c.bool.Value() {
mi.icon = c.Icon
}
m.State.itemTmp = append(m.State.itemTmp, mi)
case menuChildInt:
for v := c.int.Range().Min; v <= c.int.Range().Max; v++ {
mi := menuItem{childIndex: i, text: c.int.StringOf(v), value: v, enabled: c.enabled()}
if c.int.Value() == v {
mi.icon = c.Icon
}
if v == c.int.Range().Min {
mi.shortcut = c.Shortcut
}
m.State.itemTmp = append(m.State.itemTmp, mi)
}
case menuChildDivider:
m.State.itemTmp = append(m.State.itemTmp, menuItem{childIndex: i, divider: true})
}
}
m.update(gtx, children, m.State.itemTmp)
listItem := func(gtx C, i int) D {
item := m.State.itemTmp[i]
if widget := children[item.childIndex].widget; widget != nil {
return widget(gtx)
}
var icon *widget.Icon
if item.icon != nil {
icon = t.Theme.Icon(item.icon)
}
iconColor := m.Style.Text.Color
iconInset := layout.Inset{Left: unit.Dp(12), Right: unit.Dp(6)}
textLabel := Label(t.Theme, &m.Style.Text, item.text)
shortcutLabel := Label(t.Theme, &m.Style.Shortcut, item.shortcut)
if !item.enabled {
iconColor = m.Style.Disabled
textLabel.Color = m.Style.Disabled
shortcutLabel.Color = m.Style.Disabled
}
shortcutInset := layout.Inset{Left: unit.Dp(12), Right: unit.Dp(12), Bottom: unit.Dp(2), Top: unit.Dp(2)}
fg := func(gtx C) D {
if item.divider {
d := Divider{Thickness: 1, Axis: layout.Horizontal, Margin: 5}
return d.Layout(gtx)
}
return layout.Flex{Axis: layout.Horizontal, Alignment: layout.Middle}.Layout(gtx,
layout.Rigid(func(gtx C) D {
return iconInset.Layout(gtx, func(gtx C) D {
if icon == nil {
return D{}
}
p := gtx.Dp(unit.Dp(m.Style.Text.TextSize))
gtx.Constraints.Min = image.Pt(p, p)
return icon.Layout(gtx, iconColor)
})
}),
layout.Rigid(textLabel.Layout),
layout.Flexed(1, func(gtx C) D { return D{Size: image.Pt(gtx.Constraints.Max.X, 1)} }),
layout.Rigid(func(gtx C) D {
return shortcutInset.Layout(gtx, shortcutLabel.Layout)
}),
)
}
bg := func(gtx C) D {
rect := clip.Rect{Max: image.Pt(gtx.Constraints.Min.X, gtx.Constraints.Min.Y)}
if item.enabled && m.State.hoverOk && m.State.hover == i {
paint.FillShape(gtx.Ops, m.Style.Hover, rect.Op())
}
if item.enabled {
area := rect.Push(gtx.Ops)
event.Op(gtx.Ops, &m.State.tags[i])
area.Pop()
}
return D{Size: rect.Max}
}
return layout.Background{}.Layout(gtx, bg, fg)
}
menuList := func(gtx C) D {
gtx.Constraints.Max.X = gtx.Dp(m.Style.Width)
gtx.Constraints.Max.Y = gtx.Dp(m.Style.Height)
r := clip.Rect(image.Rect(0, 0, gtx.Constraints.Max.X, gtx.Constraints.Max.Y)).Push(gtx.Ops)
event.Op(gtx.Ops, &m.State.tag)
r.Pop()
m.State.list.Axis = layout.Vertical
m.State.scrollBar.Axis = layout.Vertical
return layout.Stack{Alignment: layout.SE}.Layout(gtx,
layout.Expanded(func(gtx C) D { return m.State.list.Layout(gtx, len(m.State.itemTmp), listItem) }),
layout.Expanded(func(gtx C) D {
return m.State.list.Layout(gtx, len(items), func(gtx C, i int) D {
defer op.Offset(image.Point{}).Push(gtx.Ops).Pop()
var macro op.MacroOp
item := &items[i]
if i == m.State.hover-1 && item.Action.Enabled() {
macro = op.Record(gtx.Ops)
}
icon := m.Theme.Icon(item.Icon)
iconColor := m.Style.Text.Color
iconInset := layout.Inset{Left: unit.Dp(12), Right: unit.Dp(6)}
textLabel := Label(m.Theme, &m.Style.Text, item.Text)
shortcutLabel := Label(m.Theme, &m.Style.Shortcut, item.Shortcut)
if !item.Action.Enabled() {
iconColor = m.Style.Disabled
textLabel.Color = m.Style.Disabled
shortcutLabel.Color = m.Style.Disabled
}
shortcutInset := layout.Inset{Left: unit.Dp(12), Right: unit.Dp(12), Bottom: unit.Dp(2), Top: unit.Dp(2)}
dims := layout.Flex{Axis: layout.Horizontal, Alignment: layout.Middle}.Layout(gtx,
layout.Rigid(func(gtx C) D {
return iconInset.Layout(gtx, func(gtx C) D {
p := gtx.Dp(unit.Dp(m.Style.Text.TextSize))
gtx.Constraints.Min = image.Pt(p, p)
return icon.Layout(gtx, iconColor)
})
}),
layout.Rigid(textLabel.Layout),
layout.Flexed(1, func(gtx C) D { return D{Size: image.Pt(gtx.Constraints.Max.X, 1)} }),
layout.Rigid(func(gtx C) D {
return shortcutInset.Layout(gtx, shortcutLabel.Layout)
}),
)
if i == m.State.hover-1 && item.Action.Enabled() {
recording := macro.Stop()
paint.FillShape(gtx.Ops, m.Style.Hover, clip.Rect{
Max: image.Pt(dims.Size.X, dims.Size.Y),
}.Op())
recording.Add(gtx.Ops)
}
if item.Action.Enabled() {
rect := image.Rect(0, 0, dims.Size.X, dims.Size.Y)
area := clip.Rect(rect).Push(gtx.Ops)
event.Op(gtx.Ops, &m.State.tags[i])
area.Pop()
}
return dims
})
}),
layout.Expanded(func(gtx C) D {
return m.State.scrollBar.Layout(gtx, &m.Theme.ScrollBar, len(items), &m.State.list.Position)
return m.State.scrollBar.Layout(gtx, &t.Theme.ScrollBar, len(m.State.itemTmp), &m.State.list.Position)
}),
)
})
}
popup := Popup(t.Theme, &m.State.visible).WithStyle(m.PopupStyle)
return popup.Layout(gtx, menuList)
}
func (m *MenuWidget) update(gtx C, items ...ActionMenuItem) {
for i, item := range items {
type menuItem struct {
childIndex int
value int
icon []byte
text, shortcut string
enabled bool
divider bool
}
func (m *MenuWidget) update(gtx C, children []MenuChild, items []menuItem) {
// handle keyboard events for the menu
for {
ev, ok := gtx.Event(
key.FocusFilter{Target: &m.State.tag},
key.Filter{Focus: &m.State.tag, Name: key.NameUpArrow},
key.Filter{Focus: &m.State.tag, Name: key.NameDownArrow},
key.Filter{Focus: &m.State.tag, Name: key.NameEnter},
key.Filter{Focus: &m.State.tag, Name: key.NameReturn},
)
if !ok {
break
}
switch e := ev.(type) {
case key.Event:
if e.State != key.Press {
continue
}
switch e.Name {
case key.NameUpArrow:
if !m.State.hoverOk {
m.State.hover = 0 // if nothing is selected, select the first item before starting to move backwards
}
for i := 1; i < len(items); i++ {
idx := (m.State.hover - i + len(items)) % len(items)
child := &children[items[idx].childIndex]
if child.enabled() {
m.State.hover = idx
m.State.hoverOk = true
break
}
}
case key.NameDownArrow:
if !m.State.hoverOk {
m.State.hover = len(items) - 1 // if nothing is selected, select the last item before starting to move backwards
}
for i := 1; i < len(items); i++ {
idx := (m.State.hover + i) % len(items)
child := &children[items[idx].childIndex]
if child.enabled() {
m.State.hover = idx
m.State.hoverOk = true
break
}
}
case key.NameEnter, key.NameReturn:
if m.State.hoverOk && m.State.hover >= 0 && m.State.hover < len(items) {
m.activateItem(items[m.State.hover], children)
}
}
case key.FocusEvent:
if !m.State.hoverOk {
m.State.hover = 0
}
m.State.hoverOk = e.Focus
}
}
for i := range items {
// make sure we have a tag for every item
for len(m.State.tags) <= i {
m.State.tags = append(m.State.tags, false)
}
// handle pointer events for this item
for {
ev, ok := gtx.Event(pointer.Filter{
Target: &m.State.tags[i],
Kinds: pointer.Press | pointer.Enter | pointer.Leave,
})
ev, ok := gtx.Event(pointer.Filter{Target: &m.State.tags[i], Kinds: pointer.Press | pointer.Enter | pointer.Leave})
if !ok {
break
}
@ -176,27 +311,112 @@ func (m *MenuWidget) update(gtx C, items ...ActionMenuItem) {
}
switch e.Kind {
case pointer.Press:
item.Action.Do()
m.State.visible = false
m.activateItem(items[i], children)
case pointer.Enter:
m.State.hover = i + 1
m.State.hover = i
m.State.hoverOk = true
if !gtx.Focused(&m.State.tag) {
gtx.Execute(key.FocusCmd{Tag: &m.State.tag})
}
case pointer.Leave:
if m.State.hover == i+1 {
m.State.hover = 0
if m.State.hover == i {
m.State.hoverOk = false
}
}
}
}
}
func (mb MenuButton) Layout(gtx C, items ...ActionMenuItem) D {
func (m *MenuWidget) activateItem(item menuItem, children []MenuChild) {
if item.childIndex < 0 || item.childIndex >= len(children) {
return
}
child := &children[item.childIndex]
if !child.enabled() {
return
}
switch child.kind {
case menuChildAction:
child.action.Do()
case menuChildBool:
child.bool.Toggle()
case menuChildInt:
child.int.SetValue(item.value)
}
m.State.visible = false
}
func (c *MenuChild) enabled() bool {
switch c.kind {
case menuChildAction:
return c.action.Enabled()
case menuChildBool:
return c.bool.Enabled()
case menuChildDivider:
return false // the dividers are passive separators
default:
return true
}
}
// MenuButton displays a button with text that opens a menu when clicked.
type MenuButton struct {
Title string
BtnStyle *ButtonStyle
MenuStyle *MenuStyle
PopupStyle *PopupStyle
Clickable *Clickable
MenuState *MenuState
Width unit.Dp
}
func MenuBtn(ms *MenuState, cl *Clickable, title string) MenuButton {
return MenuButton{MenuState: ms, Clickable: cl, Title: title}
}
func (mb MenuButton) WithBtnStyle(style *ButtonStyle) MenuButton { mb.BtnStyle = style; return mb }
func (mb MenuButton) WithMenuStyle(style *MenuStyle) MenuButton { mb.MenuStyle = style; return mb }
func (mb MenuButton) WithPopupStyle(style *PopupStyle) MenuButton { mb.PopupStyle = style; return mb }
func (mb MenuButton) Layout(gtx C, children ...MenuChild) D {
for mb.Clickable.Clicked(gtx) {
mb.MenuState.visible = true
gtx.Execute(key.FocusCmd{Tag: &mb.MenuState.tag})
}
btn := Btn(mb.Theme, mb.Style, mb.Clickable, mb.Title, "")
t := TrackerFromContext(gtx)
if mb.BtnStyle == nil {
mb.BtnStyle = &t.Theme.Button.Menu
}
if mb.PopupStyle == nil {
mb.PopupStyle = &t.Theme.Popup.Menu
}
btn := Btn(t.Theme, mb.BtnStyle, mb.Clickable, mb.Title, "")
dims := btn.Layout(gtx)
defer op.Offset(image.Pt(0, dims.Size.Y)).Push(gtx.Ops).Pop()
m := Menu(mb.Theme, mb.MenuState)
m.Layout(gtx, items...)
if mb.MenuState.visible {
defer op.Offset(image.Pt(0, dims.Size.Y)).Push(gtx.Ops).Pop()
m := Menu(mb.MenuState).WithPopupStyle(mb.PopupStyle)
m.Layout(gtx, children...)
}
return dims
}
type Divider struct {
Thickness unit.Dp
Axis layout.Axis
Margin unit.Dp
}
func (d *Divider) Layout(gtx C) D {
thicknessPx := max(gtx.Dp(d.Thickness), 1)
if d.Axis == layout.Horizontal {
return layout.Inset{Top: d.Margin, Bottom: d.Margin}.Layout(gtx, func(gtx C) D {
paint.FillShape(gtx.Ops, color.NRGBA{255, 255, 255, 12}, clip.Rect(image.Rect(0, 0, gtx.Constraints.Max.X, thicknessPx)).Op())
return D{Size: image.Pt(gtx.Constraints.Max.X, thicknessPx)}
})
} else {
return layout.Inset{Left: d.Margin, Right: d.Margin}.Layout(gtx, func(gtx C) D {
paint.FillShape(gtx.Ops, color.NRGBA{255, 255, 255, 12}, clip.Rect(image.Rect(0, 0, thicknessPx, gtx.Constraints.Max.X)).Op())
return D{Size: image.Pt(thicknessPx, gtx.Constraints.Max.X)}
})
}
}

6
tracker/gioui/note_editor.go
View File

@ -178,7 +178,6 @@ func (te *NoteEditor) layoutButtons(gtx C, t *Tracker) D {
}
effectBtn := ToggleBtn(t.Track().Effect(), t.Theme, te.EffectBtn, "Hex", "Input notes as hex values")
uniqueBtn := ToggleIconBtn(t.Note().UniquePatterns(), t.Theme, te.UniqueBtn, icons.ToggleStarBorder, icons.ToggleStar, te.uniqueOffTip, te.uniqueOnTip)
midiInBtn := ToggleBtn(t.MIDI().InputtingNotes(), t.Theme, te.TrackMidiInBtn, "MIDI", "Input notes from MIDI keyboard")
return layout.Flex{Axis: layout.Horizontal, Alignment: layout.Middle}.Layout(gtx,
layout.Rigid(func(gtx C) D { return layout.Dimensions{Size: image.Pt(gtx.Dp(unit.Dp(12)), 0)} }),
layout.Rigid(addSemitoneBtn.Layout),
@ -193,7 +192,6 @@ func (te *NoteEditor) layoutButtons(gtx C, t *Tracker) D {
layout.Rigid(layout.Spacer{Width: 4}.Layout),
layout.Rigid(trackVoicesInsetted),
layout.Rigid(splitTrackBtn.Layout),
layout.Rigid(midiInBtn.Layout),
layout.Flexed(1, func(gtx C) D { return layout.Dimensions{Size: gtx.Constraints.Min} }),
layout.Rigid(deleteTrackBtn.Layout),
layout.Rigid(newTrackBtn.Layout))
@ -276,7 +274,6 @@ func (te *NoteEditor) layoutTracks(gtx C, t *Tracker) D {
cursor := te.scrollTable.Table.Cursor()
drawSelection := cursor != te.scrollTable.Table.Cursor2()
selection := te.scrollTable.Table.Range()
hasTrackMidiIn := t.MIDI().InputtingNotes().Value()
patternNoOp := colorOp(gtx, t.Theme.NoteEditor.PatternNo.Color)
uniqueOp := colorOp(gtx, t.Theme.NoteEditor.Unique.Color)
@ -298,9 +295,6 @@ func (te *NoteEditor) layoutTracks(gtx C, t *Tracker) D {
if gtx.Focused(te.scrollTable) {
c = t.Theme.Cursor.Active
}
if hasTrackMidiIn {
c = t.Theme.Cursor.ActiveAlt
}
te.paintColumnCell(gtx, x, t, c)
}

30
tracker/gioui/oscilloscope.go
View File

@ -6,15 +6,17 @@ import (
"gioui.org/layout"
"gioui.org/unit"
"golang.org/x/exp/shiny/materialdesign/icons"
)
type (
OscilloscopeState struct {
onceBtn *Clickable
wrapBtn *Clickable
lengthInBeatsNumber *NumericUpDownState
triggerChannelNumber *NumericUpDownState
plot *Plot
onceBtn *Clickable
wrapBtn *Clickable
triggerBtn *Clickable
lengthInBeatsNumber *NumericUpDownState
triggerMenuState *MenuState
plot *Plot
}
Oscilloscope struct {
@ -25,11 +27,12 @@ type (
func NewOscilloscope() *OscilloscopeState {
return &OscilloscopeState{
plot: NewPlot(plotRange{0, 1}, plotRange{-1, 1}, 0),
onceBtn: new(Clickable),
wrapBtn: new(Clickable),
lengthInBeatsNumber: NewNumericUpDownState(),
triggerChannelNumber: NewNumericUpDownState(),
plot: NewPlot(plotRange{0, 1}, plotRange{-1, 1}, 0),
onceBtn: new(Clickable),
wrapBtn: new(Clickable),
lengthInBeatsNumber: NewNumericUpDownState(),
triggerBtn: new(Clickable),
triggerMenuState: &MenuState{},
}
}
@ -45,7 +48,6 @@ func (s *Oscilloscope) Layout(gtx C) D {
leftSpacer := layout.Spacer{Width: unit.Dp(6), Height: unit.Dp(24)}.Layout
rightSpacer := layout.Spacer{Width: unit.Dp(6)}.Layout
triggerChannel := NumUpDown(t.Scope().TriggerChannel(), s.Theme, s.State.triggerChannelNumber, "Trigger channel")
lengthInBeats := NumUpDown(t.Scope().LengthInBeats(), s.Theme, s.State.lengthInBeatsNumber, "Buffer length in beats")
onceBtn := ToggleBtn(t.Scope().Once(), s.Theme, s.State.onceBtn, "Once", "Trigger once on next event")
@ -107,7 +109,11 @@ func (s *Oscilloscope) Layout(gtx C) D {
layout.Rigid(Label(s.Theme, &s.Theme.SongPanel.RowHeader, "Trigger").Layout),
layout.Flexed(1, func(gtx C) D { return D{Size: gtx.Constraints.Min} }),
layout.Rigid(onceBtn.Layout),
layout.Rigid(triggerChannel.Layout),
layout.Rigid(func(gtx C) D {
triggerBtn := MenuBtn(s.State.triggerMenuState, s.State.triggerBtn, t.Scope().TriggerChannel().String()).
WithBtnStyle(&t.Theme.Button.Text).WithPopupStyle(&t.Theme.Popup.ContextMenu)
return triggerBtn.Layout(gtx, IntMenuChild(t.Scope().TriggerChannel(), icons.NavigationCheck))
}),
layout.Rigid(rightSpacer),
)
}),

2
tracker/gioui/popup.go
View File

@ -38,6 +38,8 @@ func Popup(th *Theme, visible *bool) PopupWidget {
}
}
func (s PopupWidget) WithStyle(style *PopupStyle) PopupWidget { s.Style = style; return s }
func (s PopupWidget) Layout(gtx C, contents layout.Widget) D {
s.update(gtx)

92
tracker/gioui/song_panel.go
View File

@ -41,6 +41,8 @@ type SongPanel struct {
Step *NumericUpDownState
SongLength *NumericUpDownState
weightingMenuState *MenuState
List *layout.List
ScrollBar *ScrollBar
@ -79,6 +81,8 @@ func NewSongPanel(tr *Tracker) *SongPanel {
List: &layout.List{Axis: layout.Vertical},
ScrollBar: &ScrollBar{Axis: layout.Vertical},
weightingMenuState: new(MenuState),
SpectrumState: NewSpectrumState(),
SpectrumScaleBar: &ScaleBar{Axis: layout.Vertical, BarSize: 10, Size: 300},
ScopeScaleBar: &ScaleBar{Axis: layout.Vertical, BarSize: 10, Size: 300},
@ -87,9 +91,6 @@ func NewSongPanel(tr *Tracker) *SongPanel {
}
func (s *SongPanel) Update(gtx C, t *Tracker) {
for s.WeightingTypeBtn.Clicked(gtx) {
t.Model.Detector().Weighting().SetValue((t.Detector().Weighting().Value() + 1) % int(tracker.NumWeightingTypes))
}
for s.OversamplingBtn.Clicked(gtx) {
t.Model.Detector().Oversampling().SetValue(!t.Detector().Oversampling().Value())
}
@ -113,19 +114,8 @@ func (t *SongPanel) layoutSongOptions(gtx C) D {
tr := TrackerFromContext(gtx)
paint.FillShape(gtx.Ops, tr.Theme.SongPanel.Bg, clip.Rect(image.Rect(0, 0, gtx.Constraints.Max.X, gtx.Constraints.Max.Y)).Op())
var weightingTxt string
switch tracker.WeightingType(tr.Model.Detector().Weighting().Value()) {
case tracker.KWeighting:
weightingTxt = "K-weight (LUFS)"
case tracker.AWeighting:
weightingTxt = "A-weight"
case tracker.CWeighting:
weightingTxt = "C-weight"
case tracker.NoWeighting:
weightingTxt = "No weight (RMS)"
}
weightingBtn := Btn(tr.Theme, &tr.Theme.Button.Text, t.WeightingTypeBtn, weightingTxt, "")
weightingBtn := MenuBtn(t.weightingMenuState, t.WeightingTypeBtn, tr.Detector().Weighting().String()).
WithBtnStyle(&tr.Theme.Button.Text).WithPopupStyle(&tr.Theme.Popup.ContextMenu)
oversamplingTxt := "Sample peak"
if tr.Model.Detector().Oversampling().Value() {
@ -236,7 +226,7 @@ func (t *SongPanel) layoutSongOptions(gtx C) D {
}),
layout.Rigid(func(gtx C) D {
gtx.Constraints.Min.X = 0
return weightingBtn.Layout(gtx)
return weightingBtn.Layout(gtx, IntMenuChild(tr.Detector().Weighting(), icons.NavigationCheck))
}),
)
},
@ -465,8 +455,6 @@ type MenuBar struct {
Clickables []Clickable
MenuStates []MenuState
midiMenuItems []ActionMenuItem
panicHint string
PanicBtn *Clickable
}
@ -478,11 +466,6 @@ func NewMenuBar(tr *Tracker) *MenuBar {
PanicBtn: new(Clickable),
panicHint: makeHint("Panic", " (%s)", "PanicToggle"),
}
for input := range tr.MIDI().InputDevices {
ret.midiMenuItems = append(ret.midiMenuItems,
MenuItem(tr.MIDI().Open(input), input, "", icons.ImageControlPoint),
)
}
return ret
}
@ -492,50 +475,65 @@ func (t *MenuBar) Layout(gtx C) D {
gtx.Constraints.Min.Y = gtx.Dp(unit.Dp(36))
flex := layout.Flex{Axis: layout.Horizontal, Alignment: layout.End}
fileBtn := MenuBtn(tr.Theme, &t.MenuStates[0], &t.Clickables[0], "File")
fileBtn := MenuBtn(&t.MenuStates[0], &t.Clickables[0], "File")
fileFC := layout.Rigid(func(gtx C) D {
items := [...]ActionMenuItem{
MenuItem(tr.Song().New(), "New Song", keyActionMap["NewSong"], icons.ContentClear),
MenuItem(tr.Song().Open(), "Open Song", keyActionMap["OpenSong"], icons.FileFolder),
MenuItem(tr.Song().Save(), "Save Song", keyActionMap["SaveSong"], icons.ContentSave),
MenuItem(tr.Song().SaveAs(), "Save Song As...", keyActionMap["SaveSongAs"], icons.ContentSave),
MenuItem(tr.Song().Export(), "Export Wav...", keyActionMap["ExportWav"], icons.ImageAudiotrack),
MenuItem(tr.RequestQuit(), "Quit", keyActionMap["Quit"], icons.ActionExitToApp),
items := [...]MenuChild{
ActionMenuChild(tr.Song().New(), "New Song", keyActionMap["NewSong"], icons.ContentClear),
ActionMenuChild(tr.Song().Open(), "Open Song", keyActionMap["OpenSong"], icons.FileFolder),
ActionMenuChild(tr.Song().Save(), "Save Song", keyActionMap["SaveSong"], icons.ContentSave),
ActionMenuChild(tr.Song().SaveAs(), "Save Song As...", keyActionMap["SaveSongAs"], icons.ContentSave),
DividerMenuChild(),
ActionMenuChild(tr.Song().Export(), "Export Wav...", keyActionMap["ExportWav"], icons.ImageAudiotrack),
DividerMenuChild(),
ActionMenuChild(tr.RequestQuit(), "Quit", keyActionMap["Quit"], icons.ActionExitToApp),
}
if !canQuit {
return fileBtn.Layout(gtx, items[:len(items)-1]...)
return fileBtn.Layout(gtx, items[:len(items)-2]...)
}
return fileBtn.Layout(gtx, items[:]...)
})
editBtn := MenuBtn(tr.Theme, &t.MenuStates[1], &t.Clickables[1], "Edit")
editBtn := MenuBtn(&t.MenuStates[1], &t.Clickables[1], "Edit")
editFC := layout.Rigid(func(gtx C) D {
return editBtn.Layout(gtx,
MenuItem(tr.History().Undo(), "Undo", keyActionMap["Undo"], icons.ContentUndo),
MenuItem(tr.History().Redo(), "Redo", keyActionMap["Redo"], icons.ContentRedo),
MenuItem(tr.Order().RemoveUnusedPatterns(), "Remove unused data", keyActionMap["RemoveUnused"], icons.ImageCrop),
ActionMenuChild(tr.History().Undo(), "Undo", keyActionMap["Undo"], icons.ContentUndo),
ActionMenuChild(tr.History().Redo(), "Redo", keyActionMap["Redo"], icons.ContentRedo),
DividerMenuChild(),
ActionMenuChild(tr.Order().RemoveUnusedPatterns(), "Remove unused data", keyActionMap["RemoveUnused"], icons.ImageCrop),
)
})
midiBtn := MenuBtn(tr.Theme, &t.MenuStates[2], &t.Clickables[2], "MIDI")
midiBtn := MenuBtn(&t.MenuStates[2], &t.Clickables[2], "MIDI")
midiFC := layout.Rigid(func(gtx C) D {
return midiBtn.Layout(gtx, t.midiMenuItems...)
return midiBtn.Layout(gtx,
ActionMenuChild(tr.MIDI().Refresh(), "Refresh port list", keyActionMap["MIDIRefresh"], icons.NavigationRefresh),
BoolMenuChild(tr.MIDI().InputtingNotes(), "Use for note input", keyActionMap["ToggleMIDIInputtingNotes"], icons.NavigationCheck),
DividerMenuChild(),
IntMenuChild(tr.MIDI().Input(), icons.NavigationCheck),
)
})
helpBtn := MenuBtn(tr.Theme, &t.MenuStates[3], &t.Clickables[3], "?")
helpBtn := MenuBtn(&t.MenuStates[3], &t.Clickables[3], "?")
helpFC := layout.Rigid(func(gtx C) D {
return helpBtn.Layout(gtx,
MenuItem(tr.ShowManual(), "Manual", keyActionMap["ShowManual"], icons.AVLibraryBooks),
MenuItem(tr.AskHelp(), "Ask help", keyActionMap["AskHelp"], icons.ActionHelp),
MenuItem(tr.ReportBug(), "Report bug", keyActionMap["ReportBug"], icons.ActionBugReport),
MenuItem(tr.ShowLicense(), "License", keyActionMap["ShowLicense"], icons.ActionCopyright))
ActionMenuChild(tr.ShowManual(), "Manual", keyActionMap["ShowManual"], icons.AVLibraryBooks),
ActionMenuChild(tr.AskHelp(), "Ask help", keyActionMap["AskHelp"], icons.ActionHelp),
ActionMenuChild(tr.ReportBug(), "Report bug", keyActionMap["ReportBug"], icons.ActionBugReport),
DividerMenuChild(),
ActionMenuChild(tr.ShowLicense(), "License", keyActionMap["ShowLicense"], icons.ActionCopyright))
})
panicBtn := ToggleIconBtn(tr.Play().Panicked(), tr.Theme, t.PanicBtn, icons.AlertErrorOutline, icons.AlertError, t.panicHint, t.panicHint)
if tr.Play().Panicked().Value() {
panicBtn.Style = &tr.Theme.IconButton.Error
}
panicFC := layout.Flexed(1, func(gtx C) D { return layout.E.Layout(gtx, panicBtn.Layout) })
if len(t.midiMenuItems) > 0 {
return flex.Layout(gtx, fileFC, editFC, midiFC, helpFC, panicFC)
return flex.Layout(gtx, fileFC, editFC, midiFC, helpFC, panicFC)
}
func (sp *SongPanel) Tags(level int, yield TagYieldFunc) bool {
for i := range sp.MenuBar.MenuStates {
if !sp.MenuBar.MenuStates[i].Tags(level, yield) {
return false
}
}
return flex.Layout(gtx, fileFC, editFC, helpFC, panicFC)
return true
}
type PlayBar struct {

5
tracker/gioui/theme.go
View File

@ -128,8 +128,9 @@ type Theme struct {
Bg color.NRGBA
}
Popup struct {
Menu PopupStyle
Dialog PopupStyle
Menu PopupStyle
Dialog PopupStyle
ContextMenu PopupStyle
}
Split SplitStyle
ScrollBar ScrollBarStyle

4
tracker/gioui/theme.yml
View File

@ -219,6 +219,10 @@ popup:
color: { r: 50, g: 50, b: 51, a: 255 }
cornerradii: { nw: 0, ne: 0, se: 6, sw: 6 }
shadow: { n: 0, s: 2, e: 2, w: 2, color: { r: 0, g: 0, b: 0, a: 192 } }
contextmenu:
color: { r: 50, g: 50, b: 51, a: 255 }
cornerradii: { nw: 6, ne: 6, se: 6, sw: 6 }
shadow: { n: 2, s: 2, e: 2, w: 2, color: { r: 0, g: 0, b: 0, a: 192 } }
dialog:
bg: { r: 0, g: 0, b: 0, a: 224 }
title: { textsize: 16, color: *highemphasis, shadowcolor: *black }

7
tracker/gioui/tracker.go
View File

@ -415,10 +415,11 @@ func (t *Tracker) openUrl(url string) {
}
func (t *Tracker) Tags(curLevel int, yield TagYieldFunc) bool {
ret := t.PatchPanel.Tags(curLevel+1, yield)
curLevel++
ret := t.SongPanel.Tags(curLevel, yield) && t.PatchPanel.Tags(curLevel, yield)
if !t.Play().TrackerHidden().Value() {
ret = ret && t.OrderEditor.Tags(curLevel+1, yield) &&
t.TrackEditor.Tags(curLevel+1, yield)
ret = ret && t.OrderEditor.Tags(curLevel, yield) &&
t.TrackEditor.Tags(curLevel, yield)
}
return ret
}