path: root/pkg/gui/context.go

package gui

import (
	"github.com/golang-collections/collections/stack"
	"github.com/jesseduffield/gocui"
)

// changeContext is a helper function for when we want to change a 'main' context
// which currently just means a context that affects both the main and secondary views
// other views can have their context changed directly but this function helps
// keep the main and secondary views in sync
func (gui *Gui) changeMainViewsContext(context string) {
	if gui.State.MainContext == context {
		return
	}

	switch context {
	case "normal", "patch-building", "staging", "merging":
		gui.getMainView().Context = context
		gui.getSecondaryView().Context = context
	}

	gui.State.MainContext = context
}

type Stack struct {
	stack []Context
}

func (s *Stack) Push(contextKey Context) {
	s.stack = append(s.stack, contextKey)
}

func (s *Stack) Pop() (Context, bool) {
	if len(s.stack) == 0 {
		return nil, false
	}

	n := len(s.stack) - 1
	value := s.stack[n]
	s.stack = s.stack[:n]

	return value, true
}

// the context manager maintains a stack of contexts so that we can easily switch focus back and forth
type contextManager struct {
	gui   *Gui
	stack stack.Stack
}

func (c *contextManager) push(contextKey string) {
	c.stack.Push(contextKey)
}

// push focus, pop focus.

const (
	SIDE_CONTEXT int = iota
	MAIN_CONTEXT
	TEMPORARY_POPUP
	PERSISTENT_POPUP
)

func GetKindWrapper(k int) func() int { return func() int { return k } }

type Context interface {
	HandleFocus() error
	HandleFocusLost() error
	GetKind() int
	GetViewName() string
	GetKey() string
}

type BasicContext struct {
	OnFocus     func() error
	OnFocusLost func() error
	Kind        int
	Key         string
	ViewName    string
}

func (c BasicContext) GetViewName() string {
	return c.ViewName
}

func (c BasicContext) HandleFocus() error {
	return c.OnFocus()
}

func (c BasicContext) HandleFocusLost() error {
	if c.OnFocusLost != nil {
		return c.OnFocusLost()
	}
	return nil
}

func (c BasicContext) GetKind() int {
	return c.Kind
}

func (c BasicContext) GetKey() string {
	return c.Key
}

type SimpleContextNode struct {
	Context Context
}

type RemotesContextNode struct {
	Context  Context
	Branches SimpleContextNode
}

type CommitsContextNode struct {
	Context Context
	Files   SimpleContextNode
}

type ContextTree struct {
	Status        SimpleContextNode
	Files         SimpleContextNode
	Menu          SimpleContextNode
	Branches      SimpleContextNode
	Remotes       RemotesContextNode
	Tags          SimpleContextNode
	BranchCommits CommitsContextNode
	ReflogCommits SimpleContextNode
	Stash         SimpleContextNode
	Staging       SimpleContextNode
	PatchBuilding SimpleContextNode
	Merging       SimpleContextNode
	Credentials   SimpleContextNode
	Confirmation  SimpleContextNode
	CommitMessage SimpleContextNode
	Search        SimpleContextNode
}

func (gui *Gui) switchContext(c Context) error {
	// push onto stack
	// if we are switching to a side context, remove all other contexts in the stack
	if c.GetKind() == SIDE_CONTEXT {
		gui.State.ContextStack = []Context{c}
	} else {
		// TODO: think about other exceptional cases
		gui.State.ContextStack = append(gui.State.ContextStack, c)
	}

	return gui.activateContext(c)
}

// switchContextToView is to be used when you don't know which context you
// want to switch to: you only know the view that you want to switch to. It will
// look up the context currently active for that view and switch to that context
func (gui *Gui) switchContextToView(viewName string) error {
	return gui.switchContext(gui.State.ViewContextMap[viewName])
}

func (gui *Gui) renderContextStack() string {
	result := ""
	for _, context := range gui.State.ContextStack {
		result += context.GetViewName() + "\n"
	}
	return result
}

func (gui *Gui) activateContext(c Context) error {
	gui.Log.Warn(gui.renderContextStack())

	if _, err := gui.g.SetCurrentView(c.GetViewName()); err != nil {
		return err
	}

	if _, err := gui.g.SetViewOnTop(c.GetViewName()); err != nil {
		return err
	}

	newView := gui.g.CurrentView()

	gui.g.Cursor = newView.Editable

	// TODO: move this logic to the context
	if err := gui.renderPanelOptions(); err != nil {
		return err
	}

	// return gui.newLineFocused(newView)

	if err := c.HandleFocus(); err != nil {
		return err
	}

	gui.State.ViewContextMap[c.GetViewName()] = c

	return nil
}

func (gui *Gui) returnFromContext() error {
	// TODO: add mutexes

	if len(gui.State.ContextStack) == 1 {
		// cannot escape from bottommost context
		return nil
	}

	n := len(gui.State.ContextStack) - 1

	currentContext := gui.State.ContextStack[n]
	newContext := gui.State.ContextStack[n-1]

	gui.State.ContextStack = gui.State.ContextStack[:n]

	if err := currentContext.HandleFocusLost(); err != nil {
		return err
	}

	return gui.activateContext(newContext)
}

func (gui *Gui) currentContext() Context {
	return gui.State.ContextStack[len(gui.State.ContextStack)-1]
}

func (gui *Gui) createContextTree() {
	gui.Contexts = ContextTree{
		Status: SimpleContextNode{
			Context: BasicContext{
				OnFocus:  gui.handleStatusSelect,
				Kind:     SIDE_CONTEXT,
				ViewName: "status",
			},
		},
		Files: SimpleContextNode{
			Context: gui.filesListView(),
		},
		Menu: SimpleContextNode{
			Context: gui.menuListView(),
		},
		Remotes: RemotesContextNode{
			Context: gui.remotesListView(),
			Branches: SimpleContextNode{
				Context: gui.remoteBranchesListView(),
			},
		},
		BranchCommits: CommitsContextNode{
			Context: gui.branchCommitsListView(),
			Files: SimpleContextNode{