types

Documentation

Index

• type Binding
• type CheckoutRefOptions
• type ConfirmOpts
• type Context
• type ContextKey
• type ContextKind
• type CreateMenuOptions
• type CreatePopupPanelOpts
• type Guard
• type HasKeybindings
• type HelperCommon
• type IBaseContext
• type IController
• type IGuiCommon
• type IList
• type IListContext
• type IListCursor
• type IListPanelState
• type IPatchExplorerContext
• type IPopupHandler
• type IViewTrait
• type Key
• type KeybindingGuards
• type KeybindingsFn
• type KeybindingsOpts
• type ListItem
• type MainContextPair
  • func NewMainContextPair(main Context, secondary Context) MainContextPair
• type MainViewPairs
• type MenuItem
• type Model
• type Modes
• type MouseKeybindingsFn
• type Mutexes
• type OnFocusLostOpts
• type OnFocusOpts
• type ParentContexter
• type PromptOpts
• type Ref
• type RefreshMainOpts
• type RefreshMode
• type RefreshOptions
• type RefreshableView
• type RenderStringTask
  • func NewRenderStringTask(str string) *RenderStringTask
  • func (t *RenderStringTask) IsUpdateTask()
• type RenderStringWithScrollTask
  • func NewRenderStringWithScrollTask(str string, originX int, originY int) *RenderStringWithScrollTask
  • func (t *RenderStringWithScrollTask) IsUpdateTask()
• type RenderStringWithoutScrollTask
  • func NewRenderStringWithoutScrollTask(str string) *RenderStringWithoutScrollTask
  • func (t *RenderStringWithoutScrollTask) IsUpdateTask()
• type RunCommandTask
  • func NewRunCommandTask(cmd *exec.Cmd) *RunCommandTask
  • func NewRunCommandTaskWithPrefix(cmd *exec.Cmd, prefix string) *RunCommandTask
  • func (t *RunCommandTask) IsUpdateTask()
• type RunPtyTask
  • func NewRunPtyTask(cmd *exec.Cmd) *RunPtyTask
  • func (t *RunPtyTask) IsUpdateTask()
• type Suggestion
• type UpdateTask
• type ViewUpdateOpts

Types

type Binding

type Binding struct {
	ViewName    string
	Handler     func() error
	Key         Key
	Modifier    gocui.Modifier
	Description string
	Alternative string
	Tag         string // e.g. 'navigation'. Used for grouping things in the cheatsheet
	OpensMenu   bool

	// to be displayed if the keybinding is highlighted from within a menu
	Tooltip string
}

Binding - a keybinding mapping a key and modifier to a handler. The keypress is only handled if the given view has focus, or handled globally if the view is ""

type CheckoutRefOptions

type CheckoutRefOptions struct {
	WaitingStatus string
	EnvVars       []string
	OnRefNotFound func(ref string) error
}

type ConfirmOpts

type ConfirmOpts struct {
	Title               string
	Prompt              string
	HandleConfirm       func() error
	HandleClose         func() error
	HasLoader           bool
	FindSuggestionsFunc func(string) []*Suggestion
	Editable            bool
	Mask                bool
}

type Context

type Context interface {
	IBaseContext

	HandleFocus(opts OnFocusOpts) error
	HandleFocusLost(opts OnFocusLostOpts) error
	HandleRender() error
	HandleRenderToMain() error
}

type ContextKey

type ContextKey string

type ContextKind

type ContextKind int

const (
	// this is your files, branches, commits, contexts etc. They're all on the left hand side
	// and you can cycle through them.
	SIDE_CONTEXT ContextKind = iota
	// This is either the left or right 'main' contexts that appear to the right of the side contexts
	MAIN_CONTEXT
	// A persistent popup is one that has its own identity e.g. the commit message context.
	// When you open a popup over it, we'll let you return to it upon pressing escape
	PERSISTENT_POPUP
	// A temporary popup is one that could be used for various things (e.g. a generic menu or confirmation popup).
	// Because we re-use these contexts, they're temporary in that you can't return to them after you've switched from them
	// to some other context, because the context you switched to might actually be the same context but rendering different content.
	// We should really be able to spawn new contexts for menus/prompts so that we can actually return to old ones.
	TEMPORARY_POPUP
	// This contains the command log, underneath the main contexts.
	EXTRAS_CONTEXT
	// only used by the one global context, purely for the sake of defining keybindings globally
	GLOBAL_CONTEXT
	// a display context only renders a view. It has no keybindings associated and
	// it cannot receive focus.
	DISPLAY_CONTEXT
)

type CreateMenuOptions

type CreateMenuOptions struct {
	Title      string
	Items      []*MenuItem
	HideCancel bool
}

type CreatePopupPanelOpts

type CreatePopupPanelOpts struct {
	HasLoader           bool
	Editable            bool
	Title               string
	Prompt              string
	HandleConfirm       func() error
	HandleConfirmPrompt func(string) error
	HandleClose         func() error

	FindSuggestionsFunc func(string) []*Suggestion
	Mask                bool
}

type Guard

type Guard func(func() error) func() error

A guard is a decorator which checks something before executing a handler and potentially early-exits if some precondition hasn't been met.

type HasKeybindings

type HasKeybindings interface {
	GetKeybindings(opts KeybindingsOpts) []*Binding
	GetMouseKeybindings(opts KeybindingsOpts) []*gocui.ViewMouseBinding
	GetOnClick() func() error
}

type HelperCommon

type HelperCommon struct {
	*common.Common
	IGuiCommon
}

type IBaseContext

type IBaseContext interface {
	HasKeybindings
	ParentContexter

	GetKind() ContextKind
	GetViewName() string
	GetView() *gocui.View
	GetViewTrait() IViewTrait
	GetWindowName() string
	SetWindowName(string)
	GetKey() ContextKey
	IsFocusable() bool
	// if a context is transient, then it only appears via some keybinding on another
	// context. Until we add support for having multiple of the same context, no two
	// of the same transient context can appear at once meaning one might be 'stolen'
	// from another window.
	IsTransient() bool
	// this tells us if the view's bounds are determined by its window or if they're
	// determined independently.
	HasControlledBounds() bool

	// returns the desired title for the view upon activation. If there is no desired title (returns empty string), then
	// no title will be set
	Title() string

	GetOptionsMap() map[string]string

	AddKeybindingsFn(KeybindingsFn)
	AddMouseKeybindingsFn(MouseKeybindingsFn)

	// This is a bit of a hack at the moment: we currently only set an onclick function so that
	// our list controller can come along and wrap it in a list-specific click handler.
	// We'll need to think of a better way to do this.
	AddOnClickFn(func() error)
}

type IController

type IController interface {
	HasKeybindings
	Context() Context
}

type IGuiCommon

type IGuiCommon interface {
	IPopupHandler

	LogAction(action string)
	LogCommand(cmdStr string, isCommandLine bool)
	// we call this when we want to refetch some models and render the result. Internally calls PostRefreshUpdate
	Refresh(RefreshOptions) error
	// we call this when we've changed something in the view model but not the actual model,
	// e.g. expanding or collapsing a folder in a file view. Calling 'Refresh' in this
	// case would be overkill, although refresh will internally call 'PostRefreshUpdate'
	PostRefreshUpdate(Context) error
	// this just re-renders the screen
	Render()
	// allows rendering to main views (i.e. the ones to the right of the side panel)
	// in such a way that avoids concurrency issues when there are slow commands
	// to display the output of
	RenderToMainViews(opts RefreshMainOpts) error
	// used purely for the sake of RenderToMainViews to provide the pair of main views we want to render to
	MainViewPairs() MainViewPairs

	// returns true if command completed successfully
	RunSubprocess(cmdObj oscommands.ICmdObj) (bool, error)
	RunSubprocessAndRefresh(oscommands.ICmdObj) error

	PushContext(context Context, opts ...OnFocusOpts) error
	PopContext() error
	CurrentContext() Context
	CurrentStaticContext() Context
	IsCurrentContext(Context) bool
	// enters search mode for the current view
	OpenSearch()

	GetAppState() *config.AppState
	SaveAppState() error

	// Runs the given function on the UI thread (this is for things like showing a popup asking a user for input).
	// Only necessary to call if you're not already on the UI thread i.e. you're inside a goroutine.
	// All controller handlers are executed on the UI thread.
	OnUIThread(f func() error)
}

type IList

type IList interface {
	IListCursor
	Len() int
}

type IListContext

type IListContext interface {
	Context

	GetSelectedItemId() string

	GetList() IList

	OnSearchSelect(selectedLineIdx int) error
	FocusLine()
}

type IListCursor

type IListCursor interface {
	GetSelectedLineIdx() int
	SetSelectedLineIdx(value int)
	MoveSelectedLine(delta int)
	RefreshSelectedIdx()
}

type IListPanelState

type IListPanelState interface {
	SetSelectedLineIdx(int)
	GetSelectedLineIdx() int
}

type IPatchExplorerContext

type IPatchExplorerContext interface {
	Context

	GetState() *patch_exploring.State
	SetState(*patch_exploring.State)
	GetIncludedLineIndices() []int
	RenderAndFocus(isFocused bool) error
	Render(isFocused bool) error
	Focus() error
	GetContentToRender(isFocused bool) string
	NavigateTo(isFocused bool, selectedLineIdx int) error
	GetMutex() *deadlock.Mutex
}

type IPopupHandler

type IPopupHandler interface {
	// Shows a popup with a (localized) "Error" caption and the given error message (in red).
	//
	// This is a convenience wrapper around Alert().
	ErrorMsg(message string) error
	Error(err error) error
	// Shows a notification popup with the given title and message to the user.
	//
	// This is a convenience wrapper around Confirm(), thus the popup can be closed using both 'Enter' and 'ESC'.
	Alert(title string, message string) error
	// Shows a popup asking the user for confirmation.
	Confirm(opts ConfirmOpts) error
	// Shows a popup prompting the user for input.
	Prompt(opts PromptOpts) error
	WithLoaderPanel(message string, f func() error) error
	WithWaitingStatus(message string, f func() error) error
	Menu(opts CreateMenuOptions) error
	Toast(message string)
	GetPromptInput() string
}

type IViewTrait

type IViewTrait interface {
	FocusPoint(yIdx int)
	SetViewPortContent(content string)
	SetContent(content string)
	SetFooter(value string)
	SetOriginX(value int)
	ViewPortYBounds() (int, int)
	ScrollLeft()
	ScrollRight()
	ScrollUp(value int)
	ScrollDown(value int)
	PageDelta() int
	SelectedLineIdx() int
	SetHighlight(bool)
}

type Key

type Key interface{} // FIXME: find out how to get `gocui.Key | rune`

type KeybindingGuards

type KeybindingGuards struct {
	OutsideFilterMode Guard
	NoPopupPanel      Guard
}

type KeybindingsFn

type KeybindingsFn func(opts KeybindingsOpts) []*Binding

type KeybindingsOpts

type KeybindingsOpts struct {
	GetKey func(key string) Key
	Config config.KeybindingConfig
	Guards KeybindingGuards
}

type ListItem

type ListItem interface {
	// ID is a SHA when the item is a commit, a filename when the item is a file, 'stash@{4}' when it's a stash entry, 'my_branch' when it's a branch
	ID() string

	// Description is something we would show in a message e.g. '123as14: push blah' for a commit
	Description() string
}

type MainContextPair

type MainContextPair struct {
	Main      Context
	Secondary Context
}

func NewMainContextPair

func NewMainContextPair(main Context, secondary Context) MainContextPair

type MainViewPairs

type MainViewPairs struct {
	Normal         MainContextPair
	MergeConflicts MainContextPair
	Staging        MainContextPair
	PatchBuilding  MainContextPair
}

type MenuItem

type MenuItem struct {
	Label string

	// alternative to Label. Allows specifying columns which will be auto-aligned
	LabelColumns []string

	OnPress func() error

	// Only applies when Label is used
	OpensMenu bool

	// If Key is defined it allows the user to press the key to invoke the menu
	// item, as opposed to having to navigate to it
	Key Key

	// The tooltip will be displayed upon highlighting the menu item
	Tooltip string
}

type Model

type Model struct {
	CommitFiles  []*models.CommitFile
	Files        []*models.File
	Submodules   []*models.SubmoduleConfig
	Branches     []*models.Branch
	Commits      []*models.Commit
	StashEntries []*models.StashEntry
	SubCommits   []*models.Commit
	Remotes      []*models.Remote

	// FilteredReflogCommits are the ones that appear in the reflog panel.
	// when in filtering mode we only include the ones that match the given path
	FilteredReflogCommits []*models.Commit
	// ReflogCommits are the ones used by the branches panel to obtain recency values
	// if we're not in filtering mode, CommitFiles and FilteredReflogCommits will be
	// one and the same
	ReflogCommits []*models.Commit

	BisectInfo     *git_commands.BisectInfo
	RemoteBranches []*models.RemoteBranch
	Tags           []*models.Tag

	// for displaying suggestions while typing in a file name
	FilesTrie *patricia.Trie
}

type Modes

type Modes struct {
	Filtering     filtering.Filtering
	CherryPicking *cherrypicking.CherryPicking
	Diffing       diffing.Diffing
}

type MouseKeybindingsFn

type MouseKeybindingsFn func(opts KeybindingsOpts) []*gocui.ViewMouseBinding

type Mutexes

type Mutexes struct {
	RefreshingFilesMutex  *deadlock.Mutex
	RefreshingStatusMutex *deadlock.Mutex
	SyncMutex             *deadlock.Mutex
	LocalCommitsMutex     *deadlock.Mutex
	SubprocessMutex       *deadlock.Mutex
	PopupMutex            *deadlock.Mutex
	PtyMutex              *deadlock.Mutex
}

if you add a new mutex here be sure to instantiate it. We're using pointers to mutexes so that we can pass the mutexes to controllers.

type OnFocusLostOpts

type OnFocusLostOpts struct {
	NewContextKey ContextKey
}

type OnFocusOpts

type OnFocusOpts struct {
	ClickedWindowName  string
	ClickedViewLineIdx int
}

type ParentContexter

type ParentContexter interface {
	SetParentContext(Context)
	// we return a bool here to tell us whether or not the returned value just wraps a nil
	GetParentContext() (Context, bool)
}

type PromptOpts

type PromptOpts struct {
	Title               string
	InitialContent      string
	FindSuggestionsFunc func(string) []*Suggestion
	HandleConfirm       func(string) error
	// CAPTURE THIS
	HandleClose func() error
	Mask        bool
}

type Ref

type Ref interface {
	FullRefName() string
	RefName() string
	ParentRefName() string
	Description() string
}

type RefreshMainOpts

type RefreshMainOpts struct {
	Pair      MainContextPair
	Main      *ViewUpdateOpts
	Secondary *ViewUpdateOpts
}

type RefreshMode

type RefreshMode int

const (
	SYNC     RefreshMode = iota // wait until everything is done before returning
	ASYNC                       // return immediately, allowing each independent thing to update itself
	BLOCK_UI                    // wrap code in an update call to ensure UI updates all at once and keybindings aren't executed till complete
)

type RefreshOptions

type RefreshOptions struct {
	Then  func()
	Scope []RefreshableView // e.g. []int{COMMITS, BRANCHES}. Leave empty to refresh everything
	Mode  RefreshMode       // one of SYNC (default), ASYNC, and BLOCK_UI
}

type RefreshableView

type RefreshableView int

models/views that we can refresh

const (
	COMMITS RefreshableView = iota
	REBASE_COMMITS
	BRANCHES
	FILES
	STASH
	REFLOG
	TAGS
	REMOTES
	STATUS
	SUBMODULES
	STAGING
	PATCH_BUILDING
	MERGE_CONFLICTS
	COMMIT_FILES
	// not actually a view. Will refactor this later
	BISECT_INFO
)

type RenderStringTask

type RenderStringTask struct {
	Str string
}

func NewRenderStringTask

func NewRenderStringTask(str string) *RenderStringTask

func (*RenderStringTask) IsUpdateTask

func (t *RenderStringTask) IsUpdateTask()

type RenderStringWithScrollTask

type RenderStringWithScrollTask struct {
	Str     string
	OriginX int
	OriginY int
}

func NewRenderStringWithScrollTask

func NewRenderStringWithScrollTask(str string, originX int, originY int) *RenderStringWithScrollTask

func (*RenderStringWithScrollTask) IsUpdateTask

func (t *RenderStringWithScrollTask) IsUpdateTask()

type RenderStringWithoutScrollTask

type RenderStringWithoutScrollTask struct {
	Str string
}

func NewRenderStringWithoutScrollTask

func NewRenderStringWithoutScrollTask(str string) *RenderStringWithoutScrollTask

func (*RenderStringWithoutScrollTask) IsUpdateTask

func (t *RenderStringWithoutScrollTask) IsUpdateTask()

type RunCommandTask

type RunCommandTask struct {
	Cmd    *exec.Cmd
	Prefix string
}

func NewRunCommandTask

func NewRunCommandTask(cmd *exec.Cmd) *RunCommandTask

func NewRunCommandTaskWithPrefix

func NewRunCommandTaskWithPrefix(cmd *exec.Cmd, prefix string) *RunCommandTask

func (*RunCommandTask) IsUpdateTask

func (t *RunCommandTask) IsUpdateTask()

type RunPtyTask

type RunPtyTask struct {
	Cmd    *exec.Cmd
	Prefix string
}

func NewRunPtyTask

func NewRunPtyTask(cmd *exec.Cmd) *RunPtyTask

func (*RunPtyTask) IsUpdateTask

func (t *RunPtyTask) IsUpdateTask()

type Suggestion

type Suggestion struct {
	// value is the thing that we're matching on and the thing that will be submitted if you select the suggestion
	Value string
	// label is what is actually displayed so it can e.g. contain color
	Label string
}

type UpdateTask

type UpdateTask interface {
	IsUpdateTask()
}

type ViewUpdateOpts

type ViewUpdateOpts struct {
	Title string

	Task UpdateTask
}