gui

Documentation

Index

• Constants
• Variables
• func GetKeyDisplay(key interface{}) string
• func NewFileWatcher(log *logrus.Entry) *fileWatcher
• type Binding
  • func (b *Binding) GetDisplayStrings(isFocused bool) []string
• type DiffState
• type Gui
  • func NewGui(log *logrus.Entry, gitCommand *commands.GitCommand, ...) (*Gui, error)
  • func (gui *Gui) GenerateSentinelErrors()
  • func (gui *Gui) GetInitialKeybindings() []*Binding
  • func (gui *Gui) HandleCredentialsPopup(g *gocui.Gui, popupOpened bool, cmdErr error)
  • func (gui *Gui) HandlePasteCommits(g *gocui.Gui, v *gocui.View) error
  • func (gui *Gui) PrepareSubProcess(g *gocui.Gui, commands ...string)
  • func (gui *Gui) RenderCommitLength()
  • func (gui *Gui) Run() error
  • func (gui *Gui) RunWithSubprocesses() error
  • func (gui *Gui) WithWaitingStatus(name string, f func() error) error
• type SentinelErrors
• type Teml

Constants

const (
	SCREEN_NORMAL int = iota
	SCREEN_HALF
	SCREEN_FULL
)

const (
	INITIAL = iota
	COMPLETE
)

startup stages so we don't need to load everything at once

const (
	LINE = iota
	RANGE
	HUNK
)

these represent what select mode we're in

const (
	CHECKOUT = iota
	COMMIT
	REBASE
	CURRENT_REBASE
)

const (
	COMMITS = iota
	BRANCHES
	FILES
	STASH
	REFLOG
	TAGS
	REMOTES
	STATUS
)

models/views that we can refresh

const (
	SYNC     = 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
)

const MAX_WATCHED_FILES = 50

macs for some bizarre reason cap the number of watchable files to 256. there's no obvious platform agonstic way to check the situation of the user's computer so we're just arbitrarily capping at 200. This isn't so bad because file watching is only really an added bonus for faster refreshing.

const StartupPopupVersion = 1

Variables

var OverlappingEdges = false

OverlappingEdges determines if panel edges overlap

Functions

func GetKeyDisplay

func GetKeyDisplay(key interface{}) string

func NewFileWatcher

func NewFileWatcher(log *logrus.Entry) *fileWatcher

Types

type Binding

type Binding struct {
	ViewName    string
	Contexts    []string
	Handler     func(*gocui.Gui, *gocui.View) error
	Key         interface{} // FIXME: find out how to get `gocui.Key | rune`
	Modifier    gocui.Modifier
	Description string
	Alternative 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 ""

func (*Binding) GetDisplayStrings

func (b *Binding) GetDisplayStrings(isFocused bool) []string

GetDisplayStrings returns the display string of a file

type DiffState

type DiffState struct {
	Ref     string
	Reverse bool
}

if ref is blank we're not diffing anything

type Gui

type Gui struct {
	Log        *logrus.Entry
	GitCommand *commands.GitCommand
	OSCommand  *commands.OSCommand
	SubProcess *exec.Cmd
	State      *guiState
	Config     config.AppConfigurer
	Tr         *i18n.Localizer
	Errors     SentinelErrors
	Updater    *updates.Updater
	// contains filtered or unexported fields
}

Gui wraps the gocui Gui object which handles rendering and events

func NewGui

func NewGui(log *logrus.Entry, gitCommand *commands.GitCommand, oSCommand *commands.OSCommand, tr *i18n.Localizer, config config.AppConfigurer, updater *updates.Updater, filterPath string) (*Gui, error)

for now the split view will always be on NewGui builds a new gui handler

func (*Gui) GenerateSentinelErrors

func (gui *Gui) GenerateSentinelErrors()

GenerateSentinelErrors makes the sentinel errors for the gui. We're defining it here because we can't do package-scoped errors with localization, and also because it seems like package-scoped variables are bad in general https://dave.cheney.net/2017/06/11/go-without-package-scoped-variables In the future it would be good to implement some of the recommendations of that article. For now, if we don't need an error to be a sentinel, we will just define it inline. This has implications for error messages that pop up everywhere in that we'll be duplicating the default values. We may need to look at having a default localisation bundle defined, and just using keys-only when localising things in the code.

func (*Gui) GetInitialKeybindings

func (gui *Gui) GetInitialKeybindings() []*Binding

GetInitialKeybindings is a function.

func (*Gui) HandleCredentialsPopup

func (gui *Gui) HandleCredentialsPopup(g *gocui.Gui, popupOpened bool, cmdErr error)

HandleCredentialsPopup handles the views after executing a command that might ask for credentials

func (*Gui) HandlePasteCommits

func (gui *Gui) HandlePasteCommits(g *gocui.Gui, v *gocui.View) error

HandlePasteCommits begins a cherry-pick rebase with the commits the user has copied

func (*Gui) PrepareSubProcess

func (gui *Gui) PrepareSubProcess(g *gocui.Gui, commands ...string)

PrepareSubProcess - prepare a subprocess for execution and tell the gui to switch to it

func (*Gui) RenderCommitLength

func (gui *Gui) RenderCommitLength()

RenderCommitLength is a function.

func (*Gui) Run

func (gui *Gui) Run() error

Run setup the gui with keybindings and start the mainloop

func (*Gui) RunWithSubprocesses

func (gui *Gui) RunWithSubprocesses() error

RunWithSubprocesses loops, instantiating a new gocui.Gui with each iteration if the error returned from a run is a ErrSubProcess, it runs the subprocess otherwise it handles the error, possibly by quitting the application

func (*Gui) WithWaitingStatus

func (gui *Gui) WithWaitingStatus(name string, f func() error) error

WithWaitingStatus wraps a function and shows a waiting status while the function is still executing

type SentinelErrors

type SentinelErrors struct {
	ErrSubProcess error
	ErrNoFiles    error
	ErrSwitchRepo error
	ErrRestart    error
}

SentinelErrors are the errors that have special meaning and need to be checked by calling functions. The less of these, the better

type Teml

type Teml i18n.Teml

Teml is short for template used to make the required map[string]interface{} shorter when using gui.Tr.SLocalize and gui.Tr.TemplateLocalize