625 lines
16 KiB
Go
625 lines
16 KiB
Go
package table
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/charmbracelet/bubbles/key"
|
|
"github.com/charmbracelet/bubbles/viewport"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
"github.com/mattn/go-runewidth"
|
|
|
|
"tasksquire/common"
|
|
"tasksquire/taskwarrior"
|
|
)
|
|
|
|
// Model defines a state for the table widget.
|
|
type Model struct {
|
|
common *common.Common
|
|
KeyMap KeyMap
|
|
|
|
cols []Column
|
|
rows taskwarrior.Tasks
|
|
rowStyles []lipgloss.Style
|
|
cursor int
|
|
focus bool
|
|
styles common.TableStyle
|
|
styleFunc StyleFunc
|
|
|
|
viewport viewport.Model
|
|
start int
|
|
end int
|
|
}
|
|
|
|
// Row represents one line in the table.
|
|
type Row *taskwarrior.Task
|
|
|
|
// Column defines the table structure.
|
|
type Column struct {
|
|
Title string
|
|
Name string
|
|
Width int
|
|
MaxWidth int
|
|
ContentWidth int
|
|
}
|
|
|
|
// KeyMap defines keybindings. It satisfies to the help.KeyMap interface, which
|
|
// is used to render the menu.
|
|
type KeyMap struct {
|
|
LineUp key.Binding
|
|
LineDown key.Binding
|
|
PageUp key.Binding
|
|
PageDown key.Binding
|
|
HalfPageUp key.Binding
|
|
HalfPageDown key.Binding
|
|
GotoTop key.Binding
|
|
GotoBottom key.Binding
|
|
}
|
|
|
|
// ShortHelp implements the KeyMap interface.
|
|
func (km KeyMap) ShortHelp() []key.Binding {
|
|
return []key.Binding{km.LineUp, km.LineDown}
|
|
}
|
|
|
|
// FullHelp implements the KeyMap interface.
|
|
func (km KeyMap) FullHelp() [][]key.Binding {
|
|
return [][]key.Binding{
|
|
{km.LineUp, km.LineDown, km.GotoTop, km.GotoBottom},
|
|
{km.PageUp, km.PageDown, km.HalfPageUp, km.HalfPageDown},
|
|
}
|
|
}
|
|
|
|
// DefaultKeyMap returns a default set of keybindings.
|
|
func DefaultKeyMap() KeyMap {
|
|
const spacebar = " "
|
|
return KeyMap{
|
|
LineUp: key.NewBinding(
|
|
key.WithKeys("up", "k"),
|
|
key.WithHelp("↑/k", "up"),
|
|
),
|
|
LineDown: key.NewBinding(
|
|
key.WithKeys("down", "j"),
|
|
key.WithHelp("↓/j", "down"),
|
|
),
|
|
PageUp: key.NewBinding(
|
|
key.WithKeys("b", "pgup"),
|
|
key.WithHelp("b/pgup", "page up"),
|
|
),
|
|
PageDown: key.NewBinding(
|
|
key.WithKeys("f", "pgdown", spacebar),
|
|
key.WithHelp("f/pgdn", "page down"),
|
|
),
|
|
HalfPageUp: key.NewBinding(
|
|
key.WithKeys("u", "ctrl+u"),
|
|
key.WithHelp("u", "½ page up"),
|
|
),
|
|
HalfPageDown: key.NewBinding(
|
|
key.WithKeys("d", "ctrl+d"),
|
|
key.WithHelp("d", "½ page down"),
|
|
),
|
|
GotoTop: key.NewBinding(
|
|
key.WithKeys("home", "g"),
|
|
key.WithHelp("g/home", "go to start"),
|
|
),
|
|
GotoBottom: key.NewBinding(
|
|
key.WithKeys("end", "G"),
|
|
key.WithHelp("G/end", "go to end"),
|
|
),
|
|
}
|
|
}
|
|
|
|
// SetStyles sets the table styles.
|
|
func (m *Model) SetStyles(s common.TableStyle) {
|
|
m.styles = s
|
|
m.UpdateViewport()
|
|
}
|
|
|
|
// Option is used to set options in New. For example:
|
|
//
|
|
// table := New(WithColumns([]Column{{Title: "ID", Width: 10}}))
|
|
type Option func(*Model)
|
|
|
|
// New creates a new model for the table widget.
|
|
func New(com *common.Common, opts ...Option) Model {
|
|
m := Model{
|
|
common: com,
|
|
cursor: 0,
|
|
viewport: viewport.New(0, 20),
|
|
|
|
KeyMap: DefaultKeyMap(),
|
|
}
|
|
|
|
for _, opt := range opts {
|
|
opt(&m)
|
|
}
|
|
|
|
m.cols = m.parseColumns(m.cols)
|
|
m.rowStyles = m.parseRowStyles(m.rows)
|
|
|
|
m.UpdateViewport()
|
|
|
|
return m
|
|
}
|
|
|
|
// TODO: dynamically read rule.precedence.color
|
|
func (m *Model) parseRowStyles(rows taskwarrior.Tasks) []lipgloss.Style {
|
|
styles := make([]lipgloss.Style, len(rows))
|
|
if len(rows) == 0 {
|
|
return styles
|
|
}
|
|
taskstyle:
|
|
for i, task := range rows {
|
|
if task.Status == "deleted" {
|
|
if c, ok := m.common.Styles.Colors["deleted"]; ok && c != nil {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue
|
|
}
|
|
}
|
|
if task.Status == "completed" {
|
|
if c, ok := m.common.Styles.Colors["completed"]; ok && c != nil {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue
|
|
}
|
|
}
|
|
if task.Status == "pending" && task.Start != "" {
|
|
if c, ok := m.common.Styles.Colors["active"]; ok && c != nil {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue
|
|
}
|
|
}
|
|
// TODO: implement keyword
|
|
// TODO: implement tag
|
|
if task.HasTag("next") {
|
|
if c, ok := m.common.Styles.Colors["tag.next"]; ok && c != nil {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue
|
|
}
|
|
}
|
|
// TODO: implement project
|
|
if !task.GetDate("due").IsZero() && task.GetDate("due").Before(time.Now()) {
|
|
if c, ok := m.common.Styles.Colors["overdue"]; ok && c != nil {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue
|
|
}
|
|
}
|
|
if task.Scheduled != "" {
|
|
if c, ok := m.common.Styles.Colors["scheduled"]; ok && c != nil {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue
|
|
}
|
|
}
|
|
if !task.GetDate("due").IsZero() && task.GetDate("due").Truncate(24*time.Hour).Equal(time.Now().Truncate(24*time.Hour)) {
|
|
if c, ok := m.common.Styles.Colors["due.today"]; ok && c != nil {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue
|
|
}
|
|
}
|
|
if task.Due != "" {
|
|
if c, ok := m.common.Styles.Colors["due"]; ok && c != nil {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue
|
|
}
|
|
}
|
|
if len(task.Depends) > 0 {
|
|
if c, ok := m.common.Styles.Colors["blocked"]; ok && c != nil {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue
|
|
}
|
|
}
|
|
// TODO implement blocking
|
|
if task.Recur != "" {
|
|
if c, ok := m.common.Styles.Colors["recurring"]; ok && c != nil {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue
|
|
}
|
|
}
|
|
// TODO: make styles optional and discard if empty
|
|
if len(task.Tags) > 0 {
|
|
if c, ok := m.common.Styles.Colors["tagged"]; ok && c != nil {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue
|
|
}
|
|
}
|
|
if len(m.common.Udas) > 0 {
|
|
for _, uda := range m.common.Udas {
|
|
if u, ok := task.Udas[uda.Name]; ok {
|
|
if c, ok := m.common.Styles.Colors[fmt.Sprintf("uda.%s.%s", uda.Name, u)]; ok {
|
|
styles[i] = c.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
continue taskstyle
|
|
}
|
|
}
|
|
}
|
|
}
|
|
styles[i] = m.common.Styles.Base.Inherit(m.styles.Cell).Margin(m.styles.Cell.GetMargin()).Padding(m.styles.Cell.GetPadding())
|
|
}
|
|
return styles
|
|
}
|
|
|
|
func (m *Model) parseColumns(cols []Column) []Column {
|
|
if len(cols) == 0 {
|
|
return cols
|
|
}
|
|
|
|
for i, col := range cols {
|
|
for _, task := range m.rows {
|
|
col.ContentWidth = max(col.ContentWidth, lipgloss.Width(task.GetString(col.Name)))
|
|
}
|
|
cols[i] = col
|
|
}
|
|
|
|
combinedSize := 0
|
|
nonZeroWidths := 0
|
|
descIndex := -1
|
|
for i, col := range cols {
|
|
if col.ContentWidth > 0 {
|
|
col.Width = max(col.ContentWidth, lipgloss.Width(col.Title))
|
|
nonZeroWidths++
|
|
}
|
|
|
|
if !strings.Contains(col.Name, "description") {
|
|
combinedSize += col.Width
|
|
} else {
|
|
descIndex = i
|
|
}
|
|
|
|
cols[i] = col
|
|
}
|
|
|
|
if descIndex >= 0 {
|
|
cols[descIndex].Width = m.Width() - combinedSize - nonZeroWidths
|
|
}
|
|
|
|
return cols
|
|
}
|
|
|
|
// WithColumns sets the table columns (headers).
|
|
func WithColumns(cols []Column) Option {
|
|
return func(m *Model) {
|
|
m.cols = cols
|
|
}
|
|
}
|
|
|
|
func WithReport(report *taskwarrior.Report) Option {
|
|
return func(m *Model) {
|
|
columns := make([]Column, len(report.Columns))
|
|
for i, col := range report.Columns {
|
|
columns[i] = Column{
|
|
Title: report.Labels[i],
|
|
Name: col,
|
|
Width: 0,
|
|
}
|
|
}
|
|
m.cols = columns
|
|
}
|
|
}
|
|
|
|
// WithRows sets the table rows (data).
|
|
func WithRows(rows taskwarrior.Tasks) Option {
|
|
return func(m *Model) {
|
|
m.rows = rows
|
|
}
|
|
}
|
|
|
|
// WithRows sets the table rows (data).
|
|
func WithTasks(rows taskwarrior.Tasks) Option {
|
|
return func(m *Model) {
|
|
m.rows = rows
|
|
}
|
|
}
|
|
|
|
// WithHeight sets the height of the table.
|
|
func WithHeight(h int) Option {
|
|
return func(m *Model) {
|
|
m.viewport.Height = h - lipgloss.Height(m.headersView())
|
|
}
|
|
}
|
|
|
|
// WithWidth sets the width of the table.
|
|
func WithWidth(w int) Option {
|
|
return func(m *Model) {
|
|
m.viewport.Width = w
|
|
}
|
|
}
|
|
|
|
// WithFocused sets the focus state of the table.
|
|
func WithFocused(f bool) Option {
|
|
return func(m *Model) {
|
|
m.focus = f
|
|
}
|
|
}
|
|
|
|
// WithStyles sets the table styles.
|
|
func WithStyles(s common.TableStyle) Option {
|
|
return func(m *Model) {
|
|
m.styles = s
|
|
}
|
|
}
|
|
|
|
// WithStyleFunc sets the table style func which can determine a cell style per column, row, and selected state.
|
|
func WithStyleFunc(f StyleFunc) Option {
|
|
return func(m *Model) {
|
|
m.styleFunc = f
|
|
}
|
|
}
|
|
|
|
// WithKeyMap sets the key map.
|
|
func WithKeyMap(km KeyMap) Option {
|
|
return func(m *Model) {
|
|
m.KeyMap = km
|
|
}
|
|
}
|
|
|
|
// Update is the Bubble Tea update loop.
|
|
func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
|
|
if !m.focus {
|
|
return m, nil
|
|
}
|
|
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
switch {
|
|
case key.Matches(msg, m.KeyMap.LineUp):
|
|
m.MoveUp(1)
|
|
case key.Matches(msg, m.KeyMap.LineDown):
|
|
m.MoveDown(1)
|
|
case key.Matches(msg, m.KeyMap.PageUp):
|
|
m.MoveUp(m.viewport.Height)
|
|
case key.Matches(msg, m.KeyMap.PageDown):
|
|
m.MoveDown(m.viewport.Height)
|
|
case key.Matches(msg, m.KeyMap.HalfPageUp):
|
|
m.MoveUp(m.viewport.Height / 2)
|
|
case key.Matches(msg, m.KeyMap.HalfPageDown):
|
|
m.MoveDown(m.viewport.Height / 2)
|
|
case key.Matches(msg, m.KeyMap.LineDown):
|
|
m.MoveDown(1)
|
|
case key.Matches(msg, m.KeyMap.GotoTop):
|
|
m.GotoTop()
|
|
case key.Matches(msg, m.KeyMap.GotoBottom):
|
|
m.GotoBottom()
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
// Focused returns the focus state of the table.
|
|
func (m Model) Focused() bool {
|
|
return m.focus
|
|
}
|
|
|
|
// Focus focuses the table, allowing the user to move around the rows and
|
|
// interact.
|
|
func (m *Model) Focus() {
|
|
m.focus = true
|
|
m.UpdateViewport()
|
|
}
|
|
|
|
// Blur blurs the table, preventing selection or movement.
|
|
func (m *Model) Blur() {
|
|
m.focus = false
|
|
m.UpdateViewport()
|
|
}
|
|
|
|
// View renders the component.
|
|
func (m Model) View() string {
|
|
return m.headersView() + "\n" + m.viewport.View()
|
|
}
|
|
|
|
// UpdateViewport updates the list content based on the previously defined
|
|
// columns and rows.
|
|
func (m *Model) UpdateViewport() {
|
|
renderedRows := make([]string, 0, len(m.rows))
|
|
|
|
// Render only rows from: m.cursor-m.viewport.Height to: m.cursor+m.viewport.Height
|
|
// Constant runtime, independent of number of rows in a table.
|
|
// Limits the number of renderedRows to a maximum of 2*m.viewport.Height
|
|
if m.cursor >= 0 {
|
|
m.start = clamp(m.cursor-m.viewport.Height, 0, m.cursor)
|
|
} else {
|
|
m.start = 0
|
|
}
|
|
m.end = clamp(m.cursor+m.viewport.Height, m.cursor, len(m.rows))
|
|
for i := m.start; i < m.end; i++ {
|
|
renderedRows = append(renderedRows, m.renderRow(i))
|
|
}
|
|
|
|
m.viewport.SetContent(
|
|
lipgloss.JoinVertical(lipgloss.Left, renderedRows...),
|
|
)
|
|
}
|
|
|
|
// SelectedRow returns the selected row.
|
|
// You can cast it to your own implementation.
|
|
func (m Model) SelectedRow() Row {
|
|
if m.cursor < 0 || m.cursor >= len(m.rows) {
|
|
return nil
|
|
}
|
|
|
|
return m.rows[m.cursor]
|
|
}
|
|
|
|
// Rows returns the current rows.
|
|
func (m Model) Rows() taskwarrior.Tasks {
|
|
return m.rows
|
|
}
|
|
|
|
// Columns returns the current columns.
|
|
func (m Model) Columns() []Column {
|
|
return m.cols
|
|
}
|
|
|
|
// SetRows sets a new rows state.
|
|
func (m *Model) SetRows(r taskwarrior.Tasks) {
|
|
m.rows = r
|
|
m.UpdateViewport()
|
|
}
|
|
|
|
// SetColumns sets a new columns state.
|
|
func (m *Model) SetColumns(c []Column) {
|
|
m.cols = c
|
|
m.UpdateViewport()
|
|
}
|
|
|
|
// SetWidth sets the width of the viewport of the table.
|
|
func (m *Model) SetWidth(w int) {
|
|
m.viewport.Width = w
|
|
m.UpdateViewport()
|
|
}
|
|
|
|
// SetHeight sets the height of the viewport of the table.
|
|
func (m *Model) SetHeight(h int) {
|
|
m.viewport.Height = h - lipgloss.Height(m.headersView())
|
|
m.UpdateViewport()
|
|
}
|
|
|
|
// Height returns the viewport height of the table.
|
|
func (m Model) Height() int {
|
|
return m.viewport.Height
|
|
}
|
|
|
|
// Width returns the viewport width of the table.
|
|
func (m Model) Width() int {
|
|
return m.viewport.Width
|
|
}
|
|
|
|
// Cursor returns the index of the selected row.
|
|
func (m Model) Cursor() int {
|
|
return m.cursor
|
|
}
|
|
|
|
// SetCursor sets the cursor position in the table.
|
|
func (m *Model) SetCursor(n int) {
|
|
m.cursor = clamp(n, 0, len(m.rows)-1)
|
|
m.UpdateViewport()
|
|
}
|
|
|
|
// MoveUp moves the selection up by any number of rows.
|
|
// It can not go above the first row.
|
|
func (m *Model) MoveUp(n int) {
|
|
m.cursor = clamp(m.cursor-n, 0, len(m.rows)-1)
|
|
switch {
|
|
case m.start == 0:
|
|
m.viewport.SetYOffset(clamp(m.viewport.YOffset, 0, m.cursor))
|
|
case m.start < m.viewport.Height:
|
|
m.viewport.YOffset = (clamp(clamp(m.viewport.YOffset+n, 0, m.cursor), 0, m.viewport.Height))
|
|
case m.viewport.YOffset >= 1:
|
|
m.viewport.YOffset = clamp(m.viewport.YOffset+n, 1, m.viewport.Height)
|
|
}
|
|
m.UpdateViewport()
|
|
}
|
|
|
|
// MoveDown moves the selection down by any number of rows.
|
|
// It can not go below the last row.
|
|
func (m *Model) MoveDown(n int) {
|
|
m.cursor = clamp(m.cursor+n, 0, len(m.rows)-1)
|
|
m.UpdateViewport()
|
|
|
|
switch {
|
|
case m.end == len(m.rows) && m.viewport.YOffset > 0:
|
|
m.viewport.SetYOffset(clamp(m.viewport.YOffset-n, 1, m.viewport.Height))
|
|
case m.cursor > (m.end-m.start)/2 && m.viewport.YOffset > 0:
|
|
m.viewport.SetYOffset(clamp(m.viewport.YOffset-n, 1, m.cursor))
|
|
case m.viewport.YOffset > 1:
|
|
case m.cursor > m.viewport.YOffset+m.viewport.Height-1:
|
|
m.viewport.SetYOffset(clamp(m.viewport.YOffset+1, 0, 1))
|
|
}
|
|
}
|
|
|
|
// GotoTop moves the selection to the first row.
|
|
func (m *Model) GotoTop() {
|
|
m.MoveUp(m.cursor)
|
|
}
|
|
|
|
// GotoBottom moves the selection to the last row.
|
|
func (m *Model) GotoBottom() {
|
|
m.MoveDown(len(m.rows))
|
|
}
|
|
|
|
// FromValues create the table rows from a simple string. It uses `\n` by
|
|
// default for getting all the rows and the given separator for the fields on
|
|
// each row.
|
|
// func (m *Model) FromValues(value, separator string) {
|
|
// rows := []Row{}
|
|
// for _, line := range strings.Split(value, "\n") {
|
|
// r := Row{}
|
|
// for _, field := range strings.Split(line, separator) {
|
|
// r = append(r, field)
|
|
// }
|
|
// rows = append(rows, r)
|
|
// }
|
|
|
|
// m.SetRows(rows)
|
|
// }
|
|
|
|
// StyleFunc is a function that can be used to customize the style of a table cell based on the row and column index.
|
|
type StyleFunc func(row, col int, value string) lipgloss.Style
|
|
|
|
func (m Model) headersView() string {
|
|
var s = make([]string, 0, len(m.cols))
|
|
for _, col := range m.cols {
|
|
if col.Width <= 0 {
|
|
continue
|
|
}
|
|
style := lipgloss.NewStyle().Width(col.Width).MaxWidth(col.Width).Inline(true)
|
|
renderedCell := style.Render(runewidth.Truncate(col.Title, col.Width, "…"))
|
|
s = append(s, m.styles.Header.Render(renderedCell))
|
|
}
|
|
return lipgloss.JoinHorizontal(lipgloss.Left, s...)
|
|
}
|
|
|
|
func (m *Model) renderRow(r int) string {
|
|
var s = make([]string, 0, len(m.cols))
|
|
for i, col := range m.cols {
|
|
// for i, task := range m.rows[r] {
|
|
if m.cols[i].Width <= 0 {
|
|
continue
|
|
}
|
|
var cellStyle lipgloss.Style
|
|
// if m.styleFunc != nil {
|
|
// cellStyle = m.styleFunc(r, i, m.rows[r].GetString(col.Name))
|
|
// if r == m.cursor {
|
|
// cellStyle.Inherit(m.styles.Selected)
|
|
// }
|
|
// } else {
|
|
cellStyle = m.rowStyles[r]
|
|
// }
|
|
if r == m.cursor {
|
|
cellStyle = cellStyle.Inherit(m.styles.Selected)
|
|
}
|
|
|
|
style := lipgloss.NewStyle().Width(m.cols[i].Width).MaxWidth(m.cols[i].Width).Inline(true)
|
|
renderedCell := cellStyle.Render(style.Render(runewidth.Truncate(m.rows[r].GetString(col.Name), m.cols[i].Width, "…")))
|
|
s = append(s, renderedCell)
|
|
}
|
|
|
|
row := lipgloss.JoinHorizontal(lipgloss.Left, s...)
|
|
|
|
if r == m.cursor {
|
|
return m.styles.Selected.Render(row)
|
|
}
|
|
|
|
return row
|
|
}
|
|
|
|
func max(a, b int) int {
|
|
if a > b {
|
|
return a
|
|
}
|
|
|
|
return b
|
|
}
|
|
|
|
func min(a, b int) int {
|
|
if a < b {
|
|
return a
|
|
}
|
|
|
|
return b
|
|
}
|
|
|
|
func clamp(v, low, high int) int {
|
|
return min(max(v, low), high)
|
|
}
|