499 lines
13 KiB
Go
499 lines
13 KiB
Go
package ui
|
|
|
|
import (
|
|
"time"
|
|
|
|
"git.bullercodeworks.com/brian/boltbrowser/models"
|
|
"git.bullercodeworks.com/brian/boltbrowser/util"
|
|
"git.bullercodeworks.com/brian/wandle"
|
|
"git.bullercodeworks.com/brian/widdles"
|
|
"github.com/nsf/termbox-go"
|
|
)
|
|
|
|
type BoltTreePane struct {
|
|
x, y int
|
|
width int
|
|
height int
|
|
scrollRow int
|
|
active bool
|
|
visible bool
|
|
|
|
buffer []string
|
|
pathBuffer [][]string
|
|
currentPath []string
|
|
currentPathIdx int
|
|
search *widdles.Field
|
|
|
|
insertPairCmd func(*models.BoltBucket) wandle.Cmd
|
|
insertBucketCmd func(*models.BoltBucket) wandle.Cmd
|
|
editPairKeyCmd func(*models.BoltPair) wandle.Cmd
|
|
editPairValueCmd func(*models.BoltPair) wandle.Cmd
|
|
editBucketCmd func(*models.BoltBucket) wandle.Cmd
|
|
deleteItemCmd func([]string) wandle.Cmd
|
|
setStatus func(string, time.Duration)
|
|
|
|
db *models.BoltDB
|
|
|
|
detailPane *BoltDetailPane
|
|
}
|
|
|
|
type TreePaneRenamePath struct {
|
|
oldPath []string
|
|
newPath []string
|
|
}
|
|
|
|
func NewBoltTreePane(x, y, w, h int) *BoltTreePane {
|
|
return &BoltTreePane{
|
|
x: x, y: y,
|
|
width: w, height: h,
|
|
search: widdles.NewField("Search", "", x, y+h),
|
|
}
|
|
}
|
|
|
|
func (w *BoltTreePane) Init() wandle.Cmd {
|
|
if w.db != nil {
|
|
w.refreshDBAndBuffer()
|
|
}
|
|
w.search.SetWidth(w.width)
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) SetDetailPane(pane *BoltDetailPane) { w.detailPane = pane }
|
|
func (w *BoltTreePane) Measure() {
|
|
}
|
|
func (w *BoltTreePane) Update(msg wandle.Msg) wandle.Cmd {
|
|
if w.db == nil {
|
|
return nil
|
|
}
|
|
if len(w.currentPath) == 0 {
|
|
w.currentPath = w.db.GetNextVisiblePath(nil, w.search.GetValue())
|
|
}
|
|
switch msg := msg.(type) {
|
|
case BrowseMsg:
|
|
if msg.source == BS_CmdRefreshTree {
|
|
pth, ok := msg.data.(TreePaneRenamePath)
|
|
if ok {
|
|
if comparePaths(w.currentPath, pth.oldPath) {
|
|
w.currentPath = pth.newPath
|
|
}
|
|
for i := range w.pathBuffer {
|
|
if comparePaths(w.pathBuffer[i], pth.oldPath) {
|
|
for j := range w.pathBuffer[i] {
|
|
w.pathBuffer[i][j] = pth.newPath[j]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
w.refreshDBAndBuffer()
|
|
}
|
|
case termbox.Event:
|
|
return w.handleTermboxEvent(msg)
|
|
}
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) handleTermboxEvent(msg termbox.Event) wandle.Cmd {
|
|
if w.search.IsActive() {
|
|
if msg.Type == termbox.EventKey {
|
|
if msg.Key == termbox.KeyEnter {
|
|
return func() wandle.Msg {
|
|
w.search.SetActive(false)
|
|
return nil
|
|
}
|
|
} else {
|
|
w.setStatus(w.search.Message, time.Second)
|
|
return w.search.Update(msg)
|
|
}
|
|
}
|
|
} else {
|
|
switch msg.Type {
|
|
case termbox.EventKey:
|
|
if msg.Ch == 'g' {
|
|
return w.jumpToStart
|
|
} else if msg.Ch == 'G' {
|
|
return w.jumpToEnd
|
|
} else if msg.Key == termbox.KeyCtrlF {
|
|
return w.pageDown
|
|
} else if msg.Key == termbox.KeyCtrlB {
|
|
return w.pageUp
|
|
} else if msg.Ch == 'j' || msg.Key == termbox.KeyArrowDown {
|
|
return w.moveCursorDown
|
|
} else if msg.Ch == 'k' || msg.Key == termbox.KeyArrowUp {
|
|
return w.moveCursorUp
|
|
} else if msg.Key == termbox.KeyCtrlR {
|
|
return w.refreshDBAndBuffer
|
|
} else if msg.Ch == 'p' {
|
|
return w.insertPairAtCurrent
|
|
} else if msg.Ch == 'P' {
|
|
return w.insertPairAtParent
|
|
} else if msg.Ch == 'b' {
|
|
return w.insertBucketAtCurrent
|
|
} else if msg.Ch == 'B' {
|
|
return w.insertBucketAtParent
|
|
} else if msg.Ch == 'e' {
|
|
return w.editPairValue
|
|
} else if msg.Ch == 'r' {
|
|
return w.renameBucketOrPair
|
|
} else if msg.Key == termbox.KeyEnter {
|
|
return w.handleEnterPressed
|
|
} else if msg.Ch == 'l' || msg.Key == termbox.KeyArrowRight {
|
|
return w.handleRightPressed
|
|
} else if msg.Ch == 'h' || msg.Key == termbox.KeyArrowLeft {
|
|
return w.handleLeftPressed
|
|
} else if msg.Ch == 'D' {
|
|
return w.handleDelete
|
|
} else if msg.Ch == 'x' {
|
|
// TODO: Export Value
|
|
} else if msg.Ch == 'X' {
|
|
// TODO: Export Key/Value (or Bucket) as JSON
|
|
} else if msg.Ch == '/' {
|
|
return func() wandle.Msg {
|
|
w.search.SetActive(true)
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) View(style wandle.Style) {
|
|
if !w.visible {
|
|
return
|
|
}
|
|
if w.db == nil {
|
|
txt := "No Database Loaded"
|
|
midX := (w.x + w.width/2) - len(txt)/2
|
|
midY := (w.y + w.height/2) - 2
|
|
wandle.Print(midX, midY, style, txt)
|
|
return
|
|
}
|
|
if w.search.IsActive() || w.search.GetValue() != "" {
|
|
w.search.View(style)
|
|
}
|
|
// Find the cursor in the pane
|
|
for k, v := range w.pathBuffer {
|
|
if comparePaths(w.currentPath, v) {
|
|
w.scrollRow = k
|
|
break
|
|
}
|
|
}
|
|
treeOffset := 0
|
|
maxCursor := w.height * 2 / 3
|
|
if w.scrollRow > maxCursor {
|
|
treeOffset = w.scrollRow - maxCursor
|
|
}
|
|
if len(w.buffer) > 0 {
|
|
kIdx := 0
|
|
for k := treeOffset; k < len(w.buffer); k++ {
|
|
v := w.buffer[k]
|
|
st := style
|
|
if k < len(w.pathBuffer) && comparePaths(w.currentPath, w.pathBuffer[k]) {
|
|
st = st.Invert()
|
|
}
|
|
pos := (w.y + kIdx - 1)
|
|
bot := (w.y + w.height)
|
|
if pos < bot {
|
|
valBuffer := wandle.WrapText(util.Stringify([]byte(v)), w.width)
|
|
for i := range valBuffer {
|
|
wandle.Print(w.x, pos, st, valBuffer[i])
|
|
pos++
|
|
}
|
|
//wandle.Print(w.x, pos, st, out)
|
|
}
|
|
kIdx++
|
|
}
|
|
}
|
|
}
|
|
func (w *BoltTreePane) SetInsertPairCommand(cmd func(*models.BoltBucket) wandle.Cmd) {
|
|
w.insertPairCmd = cmd
|
|
}
|
|
func (w *BoltTreePane) SetInsertBucketCommand(cmd func(*models.BoltBucket) wandle.Cmd) {
|
|
w.insertBucketCmd = cmd
|
|
}
|
|
func (w *BoltTreePane) SetEditPairKeyCommand(cmd func(*models.BoltPair) wandle.Cmd) {
|
|
w.editPairKeyCmd = cmd
|
|
}
|
|
func (w *BoltTreePane) SetEditPairValueCommand(cmd func(*models.BoltPair) wandle.Cmd) {
|
|
w.editPairValueCmd = cmd
|
|
}
|
|
func (w *BoltTreePane) SetRenameBucketCommand(cmd func(*models.BoltBucket) wandle.Cmd) {
|
|
w.editBucketCmd = cmd
|
|
}
|
|
func (w *BoltTreePane) SetDeleteItemCommand(cmd func([]string) wandle.Cmd) {
|
|
w.deleteItemCmd = cmd
|
|
}
|
|
func (w *BoltTreePane) IsActive() bool { return w.active }
|
|
func (w *BoltTreePane) SetActive(b bool) { w.active = b }
|
|
func (w *BoltTreePane) IsVisible() bool { return w.visible }
|
|
func (w *BoltTreePane) SetVisible(b bool) { w.visible = b }
|
|
func (w *BoltTreePane) Focusable() bool { return true }
|
|
func (w *BoltTreePane) SetX(x int) { w.x = x }
|
|
func (w *BoltTreePane) SetY(y int) { w.y = y }
|
|
func (w *BoltTreePane) GetX() int { return w.x }
|
|
func (w *BoltTreePane) GetY() int { return w.y }
|
|
func (w *BoltTreePane) SetHeight(h int) { w.height = h }
|
|
func (w *BoltTreePane) GetHeight() int { return w.height }
|
|
func (w *BoltTreePane) SetWidth(wdt int) { w.height = wdt }
|
|
func (w *BoltTreePane) GetWidth() int { return w.width }
|
|
|
|
func (w *BoltTreePane) HasDB() bool { return w.db != nil }
|
|
func (w *BoltTreePane) SetDB(db *models.BoltDB) {
|
|
w.db = db
|
|
w.detailPane.SetDB(db)
|
|
w.refreshDBAndBuffer()
|
|
}
|
|
|
|
func (w *BoltTreePane) refreshDBAndBuffer() wandle.Msg {
|
|
w.db.RefreshDatabase()
|
|
w.RefreshBuffer()
|
|
w.UpdateDetailPane()
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) RefreshBuffer() {
|
|
w.buffer = nil
|
|
buckets := w.db.GetBuckets()
|
|
for i := range buckets {
|
|
w.buffer = append(w.buffer, buckets[i].Lines()...)
|
|
}
|
|
w.pathBuffer, _ = w.db.BuildVisiblePathSlice(w.search.GetValue())
|
|
if len(w.currentPath) == 0 {
|
|
w.currentPath = w.db.GetNextVisiblePath(nil, w.search.GetValue())
|
|
}
|
|
}
|
|
|
|
func (w *BoltTreePane) jumpCursorDown(distance int) {
|
|
findPath := w.currentPath
|
|
for idx, pth := range w.pathBuffer {
|
|
startJump := true
|
|
for i := range pth {
|
|
if len(w.currentPath) > i && pth[i] != w.currentPath[i] {
|
|
startJump = false
|
|
}
|
|
}
|
|
if startJump {
|
|
distance--
|
|
if distance == 0 {
|
|
w.currentPath = w.pathBuffer[len(w.pathBuffer)-1-idx]
|
|
}
|
|
}
|
|
}
|
|
isCurPath := true
|
|
for i := range w.currentPath {
|
|
if w.currentPath[i] != findPath[i] {
|
|
isCurPath = false
|
|
break
|
|
}
|
|
}
|
|
if isCurPath {
|
|
w.currentPath = w.db.GetNextVisiblePath(nil, w.search.GetValue())
|
|
}
|
|
w.UpdateDetailPane()
|
|
}
|
|
func (w *BoltTreePane) jumpCursorUp(distance int) {
|
|
findPath := w.currentPath
|
|
for idx, pth := range w.pathBuffer {
|
|
startJump := true
|
|
for i := range pth {
|
|
if len(w.currentPath) > i && pth[i] != w.currentPath[i] {
|
|
startJump = false
|
|
}
|
|
}
|
|
if startJump {
|
|
distance--
|
|
if distance == 0 {
|
|
w.currentPath = w.pathBuffer[idx]
|
|
break
|
|
}
|
|
}
|
|
}
|
|
isCurPath := true
|
|
for i := range w.currentPath {
|
|
if w.currentPath[i] != findPath[i] {
|
|
isCurPath = false
|
|
break
|
|
}
|
|
}
|
|
if isCurPath {
|
|
w.currentPath = w.db.GetNextVisiblePath(nil, w.search.GetValue())
|
|
}
|
|
w.UpdateDetailPane()
|
|
}
|
|
func (w *BoltTreePane) jumpToStart() wandle.Msg {
|
|
w.currentPath = w.db.GetNextVisiblePath(nil, w.search.GetValue())
|
|
w.UpdateDetailPane()
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) jumpToEnd() wandle.Msg {
|
|
w.currentPath = w.db.GetPrevVisiblePath(nil, w.search.GetValue())
|
|
w.UpdateDetailPane()
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) pageUp() wandle.Msg {
|
|
w.jumpCursorDown(w.height / 2)
|
|
w.UpdateDetailPane()
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) pageDown() wandle.Msg {
|
|
w.jumpCursorDown(w.height / 2)
|
|
w.UpdateDetailPane()
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) moveCursorUp() wandle.Msg {
|
|
p := w.db.GetPrevVisiblePath(w.currentPath, w.search.GetValue())
|
|
if p != nil {
|
|
w.currentPath = p
|
|
}
|
|
w.UpdateDetailPane()
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) moveCursorDown() wandle.Msg {
|
|
p := w.db.GetNextVisiblePath(w.currentPath, w.search.GetValue())
|
|
if p != nil {
|
|
w.currentPath = p
|
|
}
|
|
w.UpdateDetailPane()
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) handleEnterPressed() wandle.Msg {
|
|
b, p, _ := w.GetSelected()
|
|
// Select the current item
|
|
if b != nil {
|
|
if w.db.ToggleOpenBucket(w.currentPath) == nil {
|
|
w.RefreshBuffer()
|
|
}
|
|
} else if p != nil {
|
|
// Edit the pair
|
|
if w.editPairValueCmd != nil {
|
|
return w.editPairValueCmd(p)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) handleRightPressed() wandle.Msg {
|
|
b, p, _ := w.GetSelected()
|
|
// Select the current item
|
|
if b != nil {
|
|
if w.db.OpenBucket(w.currentPath) == nil {
|
|
w.RefreshBuffer()
|
|
}
|
|
} else if p != nil {
|
|
// Edit the pair
|
|
if w.editPairValueCmd != nil {
|
|
return w.editPairValueCmd(p)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) handleLeftPressed() wandle.Msg {
|
|
b, _, e := w.GetSelected()
|
|
if e == nil && b != nil && b.IsExpanded() {
|
|
if err := w.db.CloseBucket(w.currentPath); err == nil {
|
|
w.RefreshBuffer()
|
|
}
|
|
} else {
|
|
if len(w.currentPath) > 1 {
|
|
parent, err := w.db.GetBucketFromPath(w.currentPath[:len(w.currentPath)-1])
|
|
if err == nil {
|
|
if w.db.CloseBucket(parent.GetPath()) == nil {
|
|
w.currentPath = parent.GetPath()
|
|
w.RefreshBuffer()
|
|
}
|
|
}
|
|
} else {
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) handleDelete() wandle.Msg {
|
|
if w.deleteItemCmd != nil {
|
|
return w.deleteItemCmd(w.currentPath)
|
|
}
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) insertBucketAtCurrent() wandle.Msg {
|
|
if w.insertBucketCmd == nil {
|
|
return nil
|
|
}
|
|
insertPath := w.currentPath
|
|
b, p, e := w.GetSelected()
|
|
if p != nil {
|
|
insertPath = insertPath[:len(insertPath)-1]
|
|
b, e = w.db.GetBucketFromPath(insertPath)
|
|
}
|
|
if e != nil {
|
|
w.setStatus("Error inserting new pair. Invalid Path.", time.Second)
|
|
return nil
|
|
}
|
|
return w.insertBucketCmd(b)
|
|
}
|
|
func (w *BoltTreePane) insertBucketAtParent() wandle.Msg {
|
|
if w.insertBucketCmd == nil {
|
|
return nil
|
|
}
|
|
insertPath := w.currentPath[:len(w.currentPath)-1]
|
|
b, e := w.db.GetBucketFromPath(insertPath)
|
|
if e != nil {
|
|
w.setStatus("Error inserting new bucket. Invalid Path.", time.Second)
|
|
return nil
|
|
}
|
|
return w.insertBucketCmd(b)
|
|
}
|
|
func (w *BoltTreePane) insertPairAtCurrent() wandle.Msg {
|
|
insertPath := w.currentPath
|
|
b, p, e := w.GetSelected()
|
|
if p != nil {
|
|
insertPath = insertPath[:len(insertPath)-1]
|
|
b, e = w.db.GetBucketFromPath(insertPath)
|
|
}
|
|
if e != nil {
|
|
w.setStatus("Error inserting new pair. Invalid Path.", time.Second)
|
|
return nil
|
|
}
|
|
return w.insertPairCmd(b)
|
|
}
|
|
func (w *BoltTreePane) insertPairAtParent() wandle.Msg {
|
|
insertPath := w.currentPath[:len(w.currentPath)-1]
|
|
b, e := w.db.GetBucketFromPath(insertPath)
|
|
if e != nil {
|
|
w.setStatus("Error inserting new pair. Invalid Path.", time.Second)
|
|
return nil
|
|
}
|
|
return w.insertPairCmd(b)
|
|
}
|
|
func (w *BoltTreePane) editPairValue() wandle.Msg {
|
|
if w.editPairValueCmd == nil {
|
|
return nil
|
|
}
|
|
b, p, _ := w.GetSelected()
|
|
if b != nil {
|
|
w.setStatus("Cannot edit a bucket, did you mean to (r)ename?", time.Second*2)
|
|
} else if p != nil {
|
|
return w.editPairValueCmd(p)
|
|
}
|
|
return nil
|
|
}
|
|
func (w *BoltTreePane) renameBucketOrPair() wandle.Msg {
|
|
b, p, e := w.GetSelected()
|
|
if e != nil {
|
|
w.setStatus("Error renaming entity", time.Second)
|
|
} else if b != nil {
|
|
return w.editBucketCmd(b)
|
|
} else if p != nil {
|
|
if w.editPairKeyCmd != nil {
|
|
return w.editPairKeyCmd(p)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (w *BoltTreePane) SetStatusFunc(f func(string, time.Duration)) { w.setStatus = f }
|
|
|
|
// We do this a lot, so here's a helper function
|
|
func (w *BoltTreePane) GetCurrentPath() []string { return w.currentPath }
|
|
func (w *BoltTreePane) GetSelected() (*models.BoltBucket, *models.BoltPair, error) {
|
|
return w.db.GetGenericFromPath(w.currentPath)
|
|
}
|
|
func (w *BoltTreePane) UpdateDetailPane() {
|
|
if w.detailPane != nil {
|
|
w.detailPane.SetActiveItem(w.GetSelected())
|
|
}
|
|
}
|