1080 lines
25 KiB
Go
1080 lines
25 KiB
Go
package pages
|
|
|
|
import (
|
|
"fmt"
|
|
"log/slog"
|
|
"strings"
|
|
"tasksquire/common"
|
|
"time"
|
|
|
|
"tasksquire/taskwarrior"
|
|
|
|
"github.com/charmbracelet/bubbles/key"
|
|
"github.com/charmbracelet/bubbles/list"
|
|
"github.com/charmbracelet/bubbles/textarea"
|
|
"github.com/charmbracelet/bubbles/viewport"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/huh"
|
|
"github.com/charmbracelet/lipgloss"
|
|
)
|
|
|
|
type mode int
|
|
|
|
const (
|
|
modeNormal mode = iota
|
|
modeInsert
|
|
)
|
|
|
|
type TaskEditorPage struct {
|
|
common *common.Common
|
|
task taskwarrior.Task
|
|
|
|
colWidth int
|
|
colHeight int
|
|
|
|
mode mode
|
|
|
|
columnCursor int
|
|
|
|
area int
|
|
areaPicker *areaPicker
|
|
areas []area
|
|
}
|
|
|
|
func NewTaskEditorPage(com *common.Common, task taskwarrior.Task) *TaskEditorPage {
|
|
p := TaskEditorPage{
|
|
common: com,
|
|
task: task,
|
|
}
|
|
|
|
if p.task.Project == "" {
|
|
p.task.Project = "(none)"
|
|
}
|
|
|
|
tagOptions := p.common.TW.GetTags()
|
|
|
|
p.areas = []area{
|
|
NewTaskEdit(p.common, &p.task),
|
|
NewTagEdit(p.common, &p.task.Tags, tagOptions),
|
|
NewTimeEdit(p.common, &p.task.Due, &p.task.Scheduled, &p.task.Wait, &p.task.Until),
|
|
NewDetailsEdit(p.common, &p.task),
|
|
}
|
|
|
|
// p.areaList = NewAreaList(common, areaItems)
|
|
// p.selectedArea = areaTask
|
|
// p.columns = append([]tea.Model{p.areaList}, p.areas[p.selectedArea]...)
|
|
|
|
p.areaPicker = NewAreaPicker(com, []string{"Task", "Tags", "Dates"})
|
|
|
|
p.columnCursor = 1
|
|
if p.task.Uuid == "" {
|
|
p.mode = modeInsert
|
|
} else {
|
|
p.mode = modeNormal
|
|
}
|
|
|
|
p.SetSize(com.Width(), com.Height())
|
|
|
|
return &p
|
|
}
|
|
|
|
func (p *TaskEditorPage) SetSize(width, height int) {
|
|
p.common.SetSize(width, height)
|
|
|
|
if width >= 70 {
|
|
p.colWidth = 70 - p.common.Styles.ColumnFocused.GetVerticalFrameSize()
|
|
} else {
|
|
p.colWidth = width - p.common.Styles.ColumnFocused.GetVerticalFrameSize()
|
|
}
|
|
|
|
if height >= 40 {
|
|
p.colHeight = 40 - p.common.Styles.ColumnFocused.GetVerticalFrameSize()
|
|
} else {
|
|
p.colHeight = height - p.common.Styles.ColumnFocused.GetVerticalFrameSize()
|
|
}
|
|
}
|
|
|
|
func (p *TaskEditorPage) Init() tea.Cmd {
|
|
return nil
|
|
}
|
|
|
|
func (p *TaskEditorPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.WindowSizeMsg:
|
|
p.SetSize(msg.Width, msg.Height)
|
|
case changeAreaMsg:
|
|
p.area = int(msg)
|
|
case changeModeMsg:
|
|
p.mode = mode(msg)
|
|
case prevColumnMsg:
|
|
p.columnCursor--
|
|
if p.columnCursor < 0 {
|
|
p.columnCursor = len(p.areas) - 1
|
|
}
|
|
case nextColumnMsg:
|
|
p.columnCursor++
|
|
if p.columnCursor > len(p.areas)-1 {
|
|
p.columnCursor = 0
|
|
}
|
|
case prevAreaMsg:
|
|
p.area--
|
|
if p.area < 0 {
|
|
p.area = len(p.areas) - 1
|
|
}
|
|
p.areas[p.area].SetCursor(-1)
|
|
case nextAreaMsg:
|
|
p.area++
|
|
if p.area > len(p.areas)-1 {
|
|
p.area = 0
|
|
}
|
|
p.areas[p.area].SetCursor(0)
|
|
}
|
|
|
|
switch p.mode {
|
|
case modeNormal:
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
switch {
|
|
case key.Matches(msg, p.common.Keymap.Back):
|
|
model, err := p.common.PopPage()
|
|
if err != nil {
|
|
slog.Error("page stack empty")
|
|
return nil, tea.Quit
|
|
}
|
|
return model, BackCmd
|
|
case key.Matches(msg, p.common.Keymap.Insert):
|
|
return p, changeMode(modeInsert)
|
|
case key.Matches(msg, p.common.Keymap.Ok):
|
|
model, err := p.common.PopPage()
|
|
if err != nil {
|
|
slog.Error("page stack empty")
|
|
return nil, tea.Quit
|
|
}
|
|
return model, p.updateTasksCmd
|
|
case key.Matches(msg, p.common.Keymap.Left):
|
|
return p, prevColumn()
|
|
case key.Matches(msg, p.common.Keymap.Right):
|
|
return p, nextColumn()
|
|
case key.Matches(msg, p.common.Keymap.Up):
|
|
if p.columnCursor == 0 {
|
|
picker, cmd := p.areaPicker.Update(msg)
|
|
p.areaPicker = picker.(*areaPicker)
|
|
return p, cmd
|
|
} else {
|
|
model, cmd := p.areas[p.area].Update(prevFieldMsg{})
|
|
p.areas[p.area] = model.(area)
|
|
return p, cmd
|
|
}
|
|
case key.Matches(msg, p.common.Keymap.Down):
|
|
if p.columnCursor == 0 {
|
|
picker, cmd := p.areaPicker.Update(msg)
|
|
p.areaPicker = picker.(*areaPicker)
|
|
return p, cmd
|
|
} else {
|
|
model, cmd := p.areas[p.area].Update(nextFieldMsg{})
|
|
p.areas[p.area] = model.(area)
|
|
return p, cmd
|
|
}
|
|
}
|
|
}
|
|
|
|
// var cmd tea.Cmd
|
|
// if p.columnCursor == 0 {
|
|
// p., cmd = p.areaList.Update(msg)
|
|
// p.selectedArea = p.areaList.(areaList).Area()
|
|
// cmds = append(cmds, cmd)
|
|
// } else {
|
|
// p.areas[p.selectedArea][p.columnCursor-1], cmd = p.areas[p.selectedArea][p.columnCursor-1].Update(msg)
|
|
// cmds = append(cmds, cmd)
|
|
// }
|
|
case modeInsert:
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
switch {
|
|
case key.Matches(msg, p.common.Keymap.Back):
|
|
return p, changeMode(modeNormal)
|
|
case key.Matches(msg, p.common.Keymap.Prev):
|
|
if p.columnCursor == 0 {
|
|
picker, cmd := p.areaPicker.Update(msg)
|
|
p.areaPicker = picker.(*areaPicker)
|
|
return p, cmd
|
|
} else {
|
|
model, cmd := p.areas[p.area].Update(prevFieldMsg{})
|
|
p.areas[p.area] = model.(area)
|
|
return p, cmd
|
|
}
|
|
case key.Matches(msg, p.common.Keymap.Next):
|
|
if p.columnCursor == 0 {
|
|
picker, cmd := p.areaPicker.Update(msg)
|
|
p.areaPicker = picker.(*areaPicker)
|
|
return p, cmd
|
|
} else {
|
|
model, cmd := p.areas[p.area].Update(nextFieldMsg{})
|
|
p.areas[p.area] = model.(area)
|
|
return p, cmd
|
|
}
|
|
case key.Matches(msg, p.common.Keymap.Ok):
|
|
model, cmd := p.areas[p.area].Update(msg)
|
|
if p.area != 3 {
|
|
p.areas[p.area] = model.(area)
|
|
return p, tea.Batch(cmd, nextField())
|
|
}
|
|
return p, cmd
|
|
}
|
|
}
|
|
|
|
if p.columnCursor == 0 {
|
|
picker, cmd := p.areaPicker.Update(msg)
|
|
p.areaPicker = picker.(*areaPicker)
|
|
return p, cmd
|
|
} else {
|
|
model, cmd := p.areas[p.area].Update(msg)
|
|
p.areas[p.area] = model.(area)
|
|
return p, cmd
|
|
}
|
|
}
|
|
return p, nil
|
|
}
|
|
|
|
func (p *TaskEditorPage) View() string {
|
|
var focusedStyle, blurredStyle lipgloss.Style
|
|
if p.mode == modeInsert {
|
|
focusedStyle = p.common.Styles.ColumnInsert.Width(p.colWidth).Height(p.colHeight)
|
|
} else {
|
|
focusedStyle = p.common.Styles.ColumnFocused.Width(p.colWidth).Height(p.colHeight)
|
|
}
|
|
blurredStyle = p.common.Styles.ColumnBlurred.Width(p.colWidth).Height(p.colHeight)
|
|
// var picker, area string
|
|
var area string
|
|
if p.columnCursor == 0 {
|
|
// picker = focusedStyle.Render(p.areaPicker.View())
|
|
area = blurredStyle.Render(p.areas[p.area].View())
|
|
} else {
|
|
// picker = blurredStyle.Render(p.areaPicker.View())
|
|
area = focusedStyle.Render(p.areas[p.area].View())
|
|
|
|
}
|
|
|
|
if p.task.Uuid != "" {
|
|
area = lipgloss.JoinHorizontal(
|
|
lipgloss.Top,
|
|
area,
|
|
p.common.Styles.ColumnFocused.Render(p.common.TW.GetInformation(&p.task)),
|
|
)
|
|
|
|
}
|
|
|
|
// return lipgloss.Place(p.common.Width(), p.common.Height(), lipgloss.Center, lipgloss.Center, lipgloss.JoinHorizontal(
|
|
// lipgloss.Center,
|
|
// picker,
|
|
// area,
|
|
// ))
|
|
return lipgloss.Place(p.common.Width(), p.common.Height(), lipgloss.Center, lipgloss.Center, area)
|
|
}
|
|
|
|
type area interface {
|
|
tea.Model
|
|
SetCursor(c int)
|
|
}
|
|
|
|
type areaPicker struct {
|
|
common *common.Common
|
|
list list.Model
|
|
}
|
|
|
|
type item string
|
|
|
|
func (i item) Title() string { return string(i) }
|
|
func (i item) Description() string { return "test" }
|
|
func (i item) FilterValue() string { return "" }
|
|
|
|
func NewAreaPicker(common *common.Common, items []string) *areaPicker {
|
|
listItems := make([]list.Item, len(items))
|
|
for i, itm := range items {
|
|
listItems[i] = item(itm)
|
|
}
|
|
|
|
list := list.New(listItems, list.DefaultDelegate{}, 20, 50)
|
|
list.SetFilteringEnabled(false)
|
|
list.SetShowStatusBar(false)
|
|
list.SetShowHelp(false)
|
|
list.SetShowPagination(false)
|
|
list.SetShowTitle(false)
|
|
|
|
return &areaPicker{
|
|
common: common,
|
|
list: list,
|
|
}
|
|
}
|
|
|
|
func (a *areaPicker) Area() int {
|
|
// switch a.list.SelectedItem() {
|
|
// case item("Task"):
|
|
// return areaTask
|
|
// case item("Tags"):
|
|
// return areaTags
|
|
// case item("Dates"):
|
|
// return areaTime
|
|
// default:
|
|
// return areaTask
|
|
// }
|
|
return 0
|
|
}
|
|
|
|
func (a *areaPicker) Init() tea.Cmd {
|
|
return nil
|
|
}
|
|
|
|
func (a *areaPicker) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
var cmds []tea.Cmd
|
|
var cmd tea.Cmd
|
|
cursor := a.list.Cursor()
|
|
// switch msg.(type) {
|
|
// case nextFieldMsg:
|
|
// a.list, cmd = a.list.Update(a.list.KeyMap.CursorDown)
|
|
// case prevFieldMsg:
|
|
// a.list, cmd = a.list.Update(a.list.KeyMap.CursorUp)
|
|
// }
|
|
a.list, cmd = a.list.Update(msg)
|
|
cmds = append(cmds, cmd)
|
|
if cursor != a.list.Cursor() {
|
|
cmds = append(cmds, changeArea(a.Area()))
|
|
}
|
|
|
|
return a, tea.Batch(cmds...)
|
|
}
|
|
|
|
func (a *areaPicker) View() string {
|
|
return a.list.View()
|
|
}
|
|
|
|
type taskEdit struct {
|
|
common *common.Common
|
|
fields []huh.Field
|
|
cursor int
|
|
|
|
newProjectName *string
|
|
newAnnotation *string
|
|
udaValues map[string]*string
|
|
}
|
|
|
|
func NewTaskEdit(com *common.Common, task *taskwarrior.Task) *taskEdit {
|
|
newProject := ""
|
|
projectOptions := append([]string{"(none)"}, com.TW.GetProjects()...)
|
|
if task.Project == "" {
|
|
task.Project = "(none)"
|
|
}
|
|
|
|
defaultKeymap := huh.NewDefaultKeyMap()
|
|
|
|
fields := []huh.Field{
|
|
huh.NewInput().
|
|
Title("Task").
|
|
Value(&task.Description).
|
|
Validate(func(desc string) error {
|
|
if desc == "" {
|
|
return fmt.Errorf("task description is required")
|
|
}
|
|
return nil
|
|
}).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(com.Styles.Form),
|
|
|
|
huh.NewSelect[string]().
|
|
Options(huh.NewOptions(projectOptions...)...).
|
|
Title("Project").
|
|
Value(&task.Project).
|
|
WithKeyMap(defaultKeymap).
|
|
WithTheme(com.Styles.Form),
|
|
|
|
huh.NewInput().
|
|
Title("New Project").
|
|
Value(&newProject).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(com.Styles.Form),
|
|
}
|
|
|
|
udaValues := make(map[string]*string)
|
|
for _, uda := range com.Udas {
|
|
switch uda.Type {
|
|
case taskwarrior.UdaTypeNumeric:
|
|
val := ""
|
|
udaValues[uda.Name] = &val
|
|
fields = append(fields, huh.NewInput().
|
|
Title(uda.Label).
|
|
Value(udaValues[uda.Name]).
|
|
Validate(taskwarrior.ValidateNumeric).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(com.Styles.Form))
|
|
case taskwarrior.UdaTypeString:
|
|
if len(uda.Values) > 0 {
|
|
var val string
|
|
values := make([]string, len(uda.Values))
|
|
for i, v := range uda.Values {
|
|
values[i] = v
|
|
if v == "" {
|
|
values[i] = "(none)"
|
|
}
|
|
if v == uda.Default {
|
|
val = values[i]
|
|
}
|
|
}
|
|
if val == "" {
|
|
val = values[0]
|
|
}
|
|
if v, ok := task.Udas[uda.Name]; ok {
|
|
//TODO: handle uda types correctly
|
|
val = v.(string)
|
|
}
|
|
udaValues[uda.Name] = &val
|
|
|
|
fields = append(fields, huh.NewSelect[string]().
|
|
Options(huh.NewOptions(values...)...).
|
|
Title(uda.Label).
|
|
Value(udaValues[uda.Name]).
|
|
WithKeyMap(defaultKeymap).
|
|
WithTheme(com.Styles.Form))
|
|
} else {
|
|
val := ""
|
|
udaValues[uda.Name] = &val
|
|
fields = append(fields, huh.NewInput().
|
|
Title(uda.Label).
|
|
Value(udaValues[uda.Name]).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(com.Styles.Form))
|
|
}
|
|
case taskwarrior.UdaTypeDate:
|
|
val := ""
|
|
udaValues[uda.Name] = &val
|
|
fields = append(fields, huh.NewInput().
|
|
Title(uda.Label).
|
|
Value(udaValues[uda.Name]).
|
|
Validate(taskwarrior.ValidateDate).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(com.Styles.Form))
|
|
case taskwarrior.UdaTypeDuration:
|
|
val := ""
|
|
udaValues[uda.Name] = &val
|
|
fields = append(fields, huh.NewInput().
|
|
Title(uda.Label).
|
|
Value(udaValues[uda.Name]).
|
|
Validate(taskwarrior.ValidateDuration).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(com.Styles.Form))
|
|
}
|
|
}
|
|
|
|
newAnnotation := ""
|
|
fields = append(fields, huh.NewInput().
|
|
Title("New Annotation").
|
|
Value(&newAnnotation).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(com.Styles.Form))
|
|
|
|
t := taskEdit{
|
|
common: com,
|
|
fields: fields,
|
|
|
|
udaValues: udaValues,
|
|
|
|
newProjectName: &newProject,
|
|
newAnnotation: &newAnnotation,
|
|
}
|
|
|
|
t.fields[0].Focus()
|
|
|
|
return &t
|
|
}
|
|
|
|
func (t *taskEdit) SetCursor(c int) {
|
|
t.fields[t.cursor].Blur()
|
|
if c < 0 {
|
|
t.cursor = len(t.fields) - 1
|
|
} else {
|
|
t.cursor = c
|
|
}
|
|
t.fields[t.cursor].Focus()
|
|
}
|
|
|
|
func (t *taskEdit) Init() tea.Cmd {
|
|
return nil
|
|
}
|
|
|
|
func (t *taskEdit) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg.(type) {
|
|
case nextFieldMsg:
|
|
if t.cursor == len(t.fields)-1 {
|
|
t.fields[t.cursor].Blur()
|
|
return t, nextArea()
|
|
}
|
|
t.fields[t.cursor].Blur()
|
|
t.cursor++
|
|
t.fields[t.cursor].Focus()
|
|
case prevFieldMsg:
|
|
if t.cursor == 0 {
|
|
t.fields[t.cursor].Blur()
|
|
return t, prevArea()
|
|
}
|
|
t.fields[t.cursor].Blur()
|
|
t.cursor--
|
|
t.fields[t.cursor].Focus()
|
|
default:
|
|
field, cmd := t.fields[t.cursor].Update(msg)
|
|
t.fields[t.cursor] = field.(huh.Field)
|
|
return t, cmd
|
|
}
|
|
|
|
return t, nil
|
|
}
|
|
|
|
func (t *taskEdit) View() string {
|
|
views := make([]string, len(t.fields))
|
|
for i, field := range t.fields {
|
|
views[i] = field.View()
|
|
if i < len(t.fields)-1 {
|
|
views[i] += "\n"
|
|
}
|
|
}
|
|
return lipgloss.JoinVertical(
|
|
lipgloss.Left,
|
|
views...,
|
|
)
|
|
}
|
|
|
|
type tagEdit struct {
|
|
common *common.Common
|
|
fields []huh.Field
|
|
|
|
cursor int
|
|
|
|
newTagsValue *string
|
|
}
|
|
|
|
func NewTagEdit(common *common.Common, selected *[]string, options []string) *tagEdit {
|
|
newTags := ""
|
|
|
|
defaultKeymap := huh.NewDefaultKeyMap()
|
|
|
|
t := tagEdit{
|
|
common: common,
|
|
fields: []huh.Field{
|
|
huh.NewMultiSelect[string]().
|
|
Options(huh.NewOptions(options...)...).
|
|
// Key("tags").
|
|
Title("Tags").
|
|
Value(selected).
|
|
Filterable(true).
|
|
WithKeyMap(defaultKeymap).
|
|
WithTheme(common.Styles.Form),
|
|
huh.NewInput().
|
|
Title("New Tags").
|
|
Value(&newTags).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(common.Styles.Form),
|
|
},
|
|
newTagsValue: &newTags,
|
|
}
|
|
|
|
return &t
|
|
}
|
|
|
|
func (t *tagEdit) SetCursor(c int) {
|
|
t.fields[t.cursor].Blur()
|
|
if c < 0 {
|
|
t.cursor = len(t.fields) - 1
|
|
} else {
|
|
t.cursor = c
|
|
}
|
|
t.fields[t.cursor].Focus()
|
|
}
|
|
|
|
func (t *tagEdit) Init() tea.Cmd {
|
|
return nil
|
|
}
|
|
|
|
func (t *tagEdit) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg.(type) {
|
|
case nextFieldMsg:
|
|
if t.cursor == len(t.fields)-1 {
|
|
t.fields[t.cursor].Blur()
|
|
return t, nextArea()
|
|
}
|
|
t.fields[t.cursor].Blur()
|
|
t.cursor++
|
|
t.fields[t.cursor].Focus()
|
|
case prevFieldMsg:
|
|
if t.cursor == 0 {
|
|
t.fields[t.cursor].Blur()
|
|
return t, prevArea()
|
|
}
|
|
t.fields[t.cursor].Blur()
|
|
t.cursor--
|
|
t.fields[t.cursor].Focus()
|
|
default:
|
|
field, cmd := t.fields[t.cursor].Update(msg)
|
|
t.fields[t.cursor] = field.(huh.Field)
|
|
return t, cmd
|
|
}
|
|
return t, nil
|
|
}
|
|
|
|
func (t tagEdit) View() string {
|
|
views := make([]string, len(t.fields))
|
|
for i, field := range t.fields {
|
|
views[i] = field.View()
|
|
}
|
|
return lipgloss.JoinVertical(
|
|
lipgloss.Left,
|
|
views...,
|
|
)
|
|
}
|
|
|
|
type timeEdit struct {
|
|
common *common.Common
|
|
fields []huh.Field
|
|
|
|
cursor int
|
|
}
|
|
|
|
func NewTimeEdit(common *common.Common, due *string, scheduled *string, wait *string, until *string) *timeEdit {
|
|
// defaultKeymap := huh.NewDefaultKeyMap()
|
|
t := timeEdit{
|
|
common: common,
|
|
fields: []huh.Field{
|
|
huh.NewInput().
|
|
Title("Due").
|
|
Value(due).
|
|
Validate(taskwarrior.ValidateDate).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(common.Styles.Form),
|
|
huh.NewInput().
|
|
Title("Scheduled").
|
|
Value(scheduled).
|
|
Validate(taskwarrior.ValidateDate).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(common.Styles.Form),
|
|
huh.NewInput().
|
|
Title("Wait").
|
|
Value(wait).
|
|
Validate(taskwarrior.ValidateDate).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(common.Styles.Form),
|
|
huh.NewInput().
|
|
Title("Until").
|
|
Value(until).
|
|
Validate(taskwarrior.ValidateDate).
|
|
Inline(true).
|
|
Prompt(": ").
|
|
WithTheme(common.Styles.Form),
|
|
},
|
|
}
|
|
|
|
return &t
|
|
}
|
|
|
|
func (t *timeEdit) SetCursor(c int) {
|
|
t.fields[t.cursor].Blur()
|
|
if c < 0 {
|
|
t.cursor = len(t.fields) - 1
|
|
} else {
|
|
t.cursor = c
|
|
}
|
|
t.fields[t.cursor].Focus()
|
|
}
|
|
|
|
func (t *timeEdit) Init() tea.Cmd {
|
|
return nil
|
|
}
|
|
|
|
func (t *timeEdit) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg.(type) {
|
|
case nextFieldMsg:
|
|
if t.cursor == len(t.fields)-1 {
|
|
t.fields[t.cursor].Blur()
|
|
return t, nextArea()
|
|
}
|
|
t.fields[t.cursor].Blur()
|
|
t.cursor++
|
|
t.fields[t.cursor].Focus()
|
|
case prevFieldMsg:
|
|
if t.cursor == 0 {
|
|
t.fields[t.cursor].Blur()
|
|
return t, prevArea()
|
|
}
|
|
t.fields[t.cursor].Blur()
|
|
t.cursor--
|
|
t.fields[t.cursor].Focus()
|
|
default:
|
|
field, cmd := t.fields[t.cursor].Update(msg)
|
|
t.fields[t.cursor] = field.(huh.Field)
|
|
return t, cmd
|
|
}
|
|
return t, nil
|
|
}
|
|
|
|
func (t *timeEdit) View() string {
|
|
views := make([]string, len(t.fields))
|
|
for i, field := range t.fields {
|
|
views[i] = field.View()
|
|
}
|
|
return lipgloss.JoinVertical(
|
|
lipgloss.Left,
|
|
views...,
|
|
)
|
|
}
|
|
|
|
type detailsEdit struct {
|
|
com *common.Common
|
|
vp viewport.Model
|
|
ta textarea.Model
|
|
details string
|
|
// renderer *glamour.TermRenderer
|
|
}
|
|
|
|
func NewDetailsEdit(com *common.Common, task *taskwarrior.Task) *detailsEdit {
|
|
// renderer, err := glamour.NewTermRenderer(
|
|
// // glamour.WithStandardStyle("light"),
|
|
// glamour.WithAutoStyle(),
|
|
// glamour.WithWordWrap(40),
|
|
// )
|
|
// if err != nil {
|
|
// slog.Error(err.Error())
|
|
// return nil
|
|
// }
|
|
|
|
vp := viewport.New(40, 30)
|
|
ta := textarea.New()
|
|
ta.SetWidth(40)
|
|
ta.SetHeight(30)
|
|
ta.ShowLineNumbers = false
|
|
ta.Focus()
|
|
if task.Udas["details"] != nil {
|
|
ta.SetValue(task.Udas["details"].(string))
|
|
}
|
|
d := detailsEdit{
|
|
com: com,
|
|
// renderer: renderer,
|
|
vp: vp,
|
|
ta: ta,
|
|
}
|
|
|
|
return &d
|
|
}
|
|
|
|
func (d *detailsEdit) SetCursor(c int) {
|
|
}
|
|
|
|
func (d *detailsEdit) Init() tea.Cmd {
|
|
return textarea.Blink
|
|
}
|
|
|
|
func (d *detailsEdit) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg.(type) {
|
|
case nextFieldMsg:
|
|
return d, nextArea()
|
|
case prevFieldMsg:
|
|
return d, prevArea()
|
|
default:
|
|
var vpCmd, taCmd tea.Cmd
|
|
d.vp, vpCmd = d.vp.Update(msg)
|
|
d.ta, taCmd = d.ta.Update(msg)
|
|
return d, tea.Batch(vpCmd, taCmd)
|
|
}
|
|
}
|
|
|
|
func (d *detailsEdit) View() string {
|
|
return d.ta.View()
|
|
// dtls := `
|
|
// # Cool Details!
|
|
// ## Things I need
|
|
// - [ ] A thing
|
|
// - [x] Done thing
|
|
|
|
// ## People
|
|
// - pe1
|
|
// - pe2
|
|
// `
|
|
|
|
// details, err := d.renderer.Render(dtls)
|
|
// if err != nil {
|
|
// slog.Error(err.Error())
|
|
// return "Could not parse markdown"
|
|
// }
|
|
|
|
// d.vp.SetContent(details)
|
|
// return d.vp.View()
|
|
}
|
|
|
|
// func (p *TaskEditorPage) SetSize(width, height int) {
|
|
// p.common.SetSize(width, height)
|
|
// }
|
|
|
|
// func (p *TaskEditorPage) Init() tea.Cmd {
|
|
// // return p.form.Init()
|
|
// return nil
|
|
// }
|
|
|
|
// func (p *TaskEditorPage) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
// var cmds []tea.Cmd
|
|
|
|
// switch msg := msg.(type) {
|
|
// case SwitchModeMsg:
|
|
// switch mode(msg) {
|
|
// case modeNormal:
|
|
// p.mode = modeNormal
|
|
// case modeInsert:
|
|
// p.mode = modeInsert
|
|
// }
|
|
// case changeAreaMsg:
|
|
// p.selectedArea = area(msg)
|
|
// p.columns = append([]tea.Model{p.areaList}, p.areas[p.selectedArea]...)
|
|
// case nextColumnMsg:
|
|
// p.columnCursor++
|
|
// if p.columnCursor > len(p.columns)-1 {
|
|
// p.columnCursor = 0
|
|
// }
|
|
// case prevColumnMsg:
|
|
// p.columnCursor--
|
|
// if p.columnCursor < 0 {
|
|
// p.columnCursor = len(p.columns) - 1
|
|
// }
|
|
// }
|
|
|
|
// switch p.mode {
|
|
// case modeNormal:
|
|
// switch msg := msg.(type) {
|
|
// case tea.KeyMsg:
|
|
// switch {
|
|
// case key.Matches(msg, p.common.Keymap.Back):
|
|
// model, err := p.common.PopPage()
|
|
// if err != nil {
|
|
// slog.Error("page stack empty")
|
|
// return nil, tea.Quit
|
|
// }
|
|
// return model, BackCmd
|
|
// case key.Matches(msg, p.common.Keymap.Insert):
|
|
// return p, p.switchModeCmd(modeInsert)
|
|
// // case key.Matches(msg, p.common.Keymap.Ok):
|
|
// // p.form.State = huh.StateCompleted
|
|
// case key.Matches(msg, p.common.Keymap.Left):
|
|
// return p, prevColumn()
|
|
// case key.Matches(msg, p.common.Keymap.Right):
|
|
// return p, nextColumn()
|
|
// }
|
|
// }
|
|
// case modeInsert:
|
|
// switch msg := msg.(type) {
|
|
// case tea.KeyMsg:
|
|
// switch {
|
|
// case key.Matches(msg, p.common.Keymap.Back):
|
|
// return p, p.switchModeCmd(modeNormal)
|
|
// }
|
|
// }
|
|
|
|
// var cmd tea.Cmd
|
|
// if p.columnCursor == 0 {
|
|
// p.areaList, cmd = p.areaList.Update(msg)
|
|
// p.selectedArea = p.areaList.(areaList).Area()
|
|
// cmds = append(cmds, cmd)
|
|
// } else {
|
|
// p.areas[p.selectedArea][p.columnCursor-1], cmd = p.areas[p.selectedArea][p.columnCursor-1].Update(msg)
|
|
// cmds = append(cmds, cmd)
|
|
// }
|
|
|
|
// }
|
|
|
|
// var cmd tea.Cmd
|
|
// if p.columnCursor == 0 {
|
|
// p.areaList, cmd = p.areaList.Update(msg)
|
|
// p.selectedArea = p.areaList.(areaList).Area()
|
|
// cmds = append(cmds, cmd)
|
|
// } else {
|
|
// p.areas[p.selectedArea][p.columnCursor-1], cmd = p.areas[p.selectedArea][p.columnCursor-1].Update(msg)
|
|
// cmds = append(cmds, cmd)
|
|
// }
|
|
|
|
// p.statusline, cmd = p.statusline.Update(msg)
|
|
// cmds = append(cmds, cmd)
|
|
|
|
// // if p.form.State == huh.StateCompleted {
|
|
// // cmds = append(cmds, p.updateTasksCmd)
|
|
// // model, err := p.common.PopPage()
|
|
// // if err != nil {
|
|
// // slog.Error("page stack empty")
|
|
// // return nil, tea.Quit
|
|
// // }
|
|
// // return model, tea.Batch(cmds...)
|
|
// // }
|
|
|
|
// return p, tea.Batch(cmds...)
|
|
// }
|
|
|
|
// func (p *TaskEditorPage) View() string {
|
|
// columns := make([]string, len(p.columns))
|
|
// for i, c := range p.columns {
|
|
// columns[i] = c.View()
|
|
// }
|
|
|
|
// return lipgloss.JoinVertical(
|
|
// lipgloss.Left,
|
|
// lipgloss.JoinHorizontal(
|
|
// lipgloss.Top,
|
|
// // lipgloss.Place(p.common.Width(), p.common.Height()-1, 0.5, 0.5, p.form.View(), lipgloss.WithWhitespaceBackground(p.common.Styles.Warning.GetForeground())),
|
|
// // lipgloss.Place(p.common.Width(), p.common.Height()-1, 0.5, 0.5, p.form.View(), lipgloss.WithWhitespaceChars(" . ")),
|
|
// columns...,
|
|
// ),
|
|
// p.statusline.View(),
|
|
// )
|
|
// }
|
|
|
|
func (p *TaskEditorPage) updateTasksCmd() tea.Msg {
|
|
if p.task.Project == "(none)" {
|
|
p.task.Project = ""
|
|
}
|
|
|
|
for _, uda := range p.common.Udas {
|
|
if val, ok := p.areas[0].(*taskEdit).udaValues[uda.Name]; ok {
|
|
if *val == "(none)" {
|
|
*val = ""
|
|
}
|
|
p.task.Udas[uda.Name] = *val
|
|
}
|
|
}
|
|
|
|
if *(p.areas[0].(*taskEdit).newProjectName) != "" {
|
|
p.task.Project = *p.areas[0].(*taskEdit).newProjectName
|
|
}
|
|
|
|
if *(p.areas[1].(*tagEdit).newTagsValue) != "" {
|
|
newTags := strings.Split(*p.areas[1].(*tagEdit).newTagsValue, " ")
|
|
if len(newTags) > 0 {
|
|
p.task.Tags = append(p.task.Tags, newTags...)
|
|
}
|
|
}
|
|
|
|
if *(p.areas[0].(*taskEdit).newAnnotation) != "" {
|
|
p.task.Annotations = append(p.task.Annotations, taskwarrior.Annotation{
|
|
Entry: time.Now().Format("20060102T150405Z"),
|
|
Description: *(p.areas[0].(*taskEdit).newAnnotation),
|
|
})
|
|
|
|
// p.common.TW.AddTaskAnnotation(p.task.Uuid, *p.areas[0].(*taskEdit).newAnnotation)
|
|
}
|
|
|
|
if _, ok := p.task.Udas["details"]; ok || p.areas[3].(*detailsEdit).ta.Value() != "" {
|
|
p.task.Udas["details"] = p.areas[3].(*detailsEdit).ta.Value()
|
|
}
|
|
|
|
p.common.TW.ImportTask(&p.task)
|
|
return UpdatedTasksMsg{}
|
|
}
|
|
|
|
// type StatusLine struct {
|
|
// common *common.Common
|
|
// mode mode
|
|
// input textinput.Model
|
|
// }
|
|
|
|
// func NewStatusLine(common *common.Common, mode mode) *StatusLine {
|
|
// input := textinput.New()
|
|
// input.Placeholder = ""
|
|
// input.Prompt = ""
|
|
// input.Blur()
|
|
|
|
// return &StatusLine{
|
|
// input: textinput.New(),
|
|
// common: common,
|
|
// mode: mode,
|
|
// }
|
|
// }
|
|
|
|
// func (s *StatusLine) Init() tea.Cmd {
|
|
// s.input.Blur()
|
|
// return nil
|
|
// }
|
|
|
|
// func (s *StatusLine) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
// var cmd tea.Cmd
|
|
|
|
// switch msg := msg.(type) {
|
|
// case SwitchModeMsg:
|
|
// s.mode = mode(msg)
|
|
// switch s.mode {
|
|
// case modeNormal:
|
|
// s.input.Blur()
|
|
// case modeInsert:
|
|
// s.input.Focus()
|
|
// }
|
|
// case tea.KeyMsg:
|
|
// switch {
|
|
// case key.Matches(msg, s.common.Keymap.Back):
|
|
// s.input.Blur()
|
|
// case key.Matches(msg, s.common.Keymap.Input):
|
|
// s.input.Focus()
|
|
// }
|
|
// }
|
|
|
|
// s.input, cmd = s.input.Update(msg)
|
|
// return s, cmd
|
|
// }
|
|
|
|
// func (s *StatusLine) View() string {
|
|
// var mode string
|
|
// switch s.mode {
|
|
// case modeNormal:
|
|
// mode = s.common.Styles.Base.Render("NORMAL")
|
|
// case modeInsert:
|
|
// mode = s.common.Styles.Active.Inline(true).Reverse(true).Render("INSERT")
|
|
// }
|
|
// return lipgloss.JoinHorizontal(lipgloss.Left, mode, s.input.View())
|
|
// }
|
|
|
|
// // TODO: move this to taskwarrior; add missing date formats
|
|
|
|
// type itemDelegate struct{}
|
|
|
|
// func (d itemDelegate) Height() int { return 1 }
|
|
// func (d itemDelegate) Spacing() int { return 0 }
|
|
// func (d itemDelegate) Update(_ tea.Msg, _ *list.Model) tea.Cmd { return nil }
|
|
// func (d itemDelegate) Render(w io.Writer, m list.Model, index int, listItem list.Item) {
|
|
// i, ok := listItem.(item)
|
|
// if !ok {
|
|
// return
|
|
// }
|
|
|
|
// str := fmt.Sprintf("%s", i)
|
|
|
|
// fn := itemStyle.Render
|
|
// if index == m.Index() {
|
|
// fn = func(s ...string) string {
|
|
// return selectedItemStyle.Render("> " + strings.Join(s, " "))
|
|
// }
|
|
// }
|
|
|
|
// fmt.Fprint(w, fn(str))
|
|
// }
|
|
|
|
// var (
|
|
// titleStyle = lipgloss.NewStyle().MarginLeft(2)
|
|
// itemStyle = lipgloss.NewStyle().PaddingLeft(4)
|
|
// selectedItemStyle = lipgloss.NewStyle().PaddingLeft(2).Foreground(lipgloss.Color("170"))
|
|
// paginationStyle = list.DefaultStyles().PaginationStyle.PaddingLeft(4)
|
|
// helpStyle = list.DefaultStyles().HelpStyle.PaddingLeft(4).PaddingBottom(1)
|
|
// quitTextStyle = lipgloss.NewStyle().Margin(1, 0, 2, 4)
|
|
// )
|
|
|
|
// type item string
|
|
|
|
// func (i item) FilterValue() string { return "" }
|