wicore

type BorderType int

type Command interface {
	// Name is the name of the command.
	Name() string
	// Handle executes the command.
	Handle(e EditorW, w Window, args ...string)
	// Category returns the category the command should be bucketed in, for help
	// documentation purpose.
	Category(e Editor, w Window) CommandCategory
	// ShortDesc returns a short description of the command in the language
	// requested.
	ShortDesc() string
	// LongDesc returns a long explanation of the command in the language
	// requested.
	LongDesc() string
}

type CommandAlias struct {
	NameValue    string
	CommandValue string
	ArgsValue    []string
}

type CommandCategory int

type CommandHandler func(e EditorW, w Window, args ...string)

type CommandImpl struct {
	NameValue      string
	ExpectedArgs   int // If >= 0, the command will be aborted if the number of arguments is not exactly this value. Set to -1 to disable verification. On abort, an alert with the long description of the command is done.
	HandlerValue   CommandImplHandler
	CategoryValue  CommandCategory
	ShortDescValue lang.Map
	LongDescValue  lang.Map
}

type CommandImplHandler func(c *CommandImpl, e EditorW, w Window, args ...string)

type Commands interface {
	// Get returns a command if registered, nil otherwise.
	Get(cmdName string) Command
	// GetNames() return the name of all the commands.
	GetNames() []string
}

type CommandsW interface {
	Commands

	// Register registers a command so it can be executed later. In practice
	// commands should normally be registered on startup. Returns false if a
	// command was already registered and was lost.
	Register(cmd Command) bool
}

type DockingType int

type Document interface {
	fmt.Stringer
	io.Closer
	Proxyable

	// RenderInto renders a view of a document.
	//
	// TODO(maruel): Likely return a new Buffer instance instead, for RPC
	// friendlyness. To be decided.
	RenderInto(buffer *raster.Buffer, view View, offsetColumn, offsetLine int)
	// FileType returns the file type as determined by the scanners.
	FileType() FileType
	// IsDirty is true if the content should be saved before quitting.
	IsDirty() bool
}

type Editor interface {
	Proxyable
	EventRegistry

	// ActiveWindow returns the current active Window.
	ActiveWindow() Window
	// ViewFactoryNames return the name of all the view factories.
	ViewFactoryNames() []string
	// AllDocuments returns all the active documents. Some of them may not be in
	// a View.
	AllDocuments() []Document
	// AllPlugins returns details about all the loaded plugins.
	AllPlugins() []PluginDetails
	// KeyboardMode is global to the editor. It matches vim behavior. For example
	// in a 2-window setup while in insert mode, using Ctrl-O, Ctrl-W, Down will
	// move to the next window but will stay in insert mode.
	//
	// Technically, each View could have their own KeyboardMode but in practice
	// it just creates a cognitive overhead without much benefit.
	KeyboardMode() KeyboardMode
	// Version returns the version number of this build of wi.
	Version() string
}

type EditorDetails struct {
	ID      string
	Version string
}

type EditorW interface {
	Editor

	// ExecuteCommand executes a command now. This is only meant to run a command
	// reentrantly; e.g. running a command triggers another one. This usually
	// happens for key binding, command aliases, when a command triggers an error.
	//
	// TODO(maruel): Remove?
	ExecuteCommand(w Window, cmdName string, args ...string)
	// RegisterViewFactory makes a new view available by name.
	RegisterViewFactory(name string, viewFactory ViewFactory) bool
}

type EnqueuedCommands struct {
	Commands [][]string
	Callback func()
}

type EventListener interface {
	io.Closer
}

type EventRegistry interface {
	EventTrigger

	RegisterCommands(callback func(cmds EnqueuedCommands)) EventListener
	RegisterDocumentCreated(callback func(doc Document)) EventListener
	RegisterDocumentCursorMoved(callback func(doc Document, col, row int)) EventListener
	RegisterEditorKeyboardModeChanged(callback func(mode KeyboardMode)) EventListener
	RegisterEditorLanguage(callback func(l lang.Language)) EventListener
	RegisterTerminalKeyPressed(callback func(k key.Press)) EventListener
	RegisterTerminalMetaKeyPressed(callback func(k key.Press)) EventListener
	RegisterTerminalResized(callback func()) EventListener
	RegisterViewActivated(callback func(view View)) EventListener
	RegisterViewCreated(callback func(view View)) EventListener
	RegisterWindowCreated(callback func(window Window)) EventListener
	RegisterWindowResized(callback func(window Window)) EventListener
}

type EventTrigger interface {
	// TriggerCommands dispatches one or multiple commands to the current active
	// listener. Normally, it's the View contained to the active Window. Using
	// this function guarantees that all the commands will be executed in order
	// without commands interfering.
	//
	// `callback` is called synchronously after the command is executed.
	TriggerCommands(cmds EnqueuedCommands)
	TriggerDocumentCreated(doc Document)
	TriggerDocumentCursorMoved(doc Document, col, row int)
	TriggerEditorKeyboardModeChanged(mode KeyboardMode)
	TriggerEditorLanguage(l lang.Language)
	TriggerTerminalKeyPressed(k key.Press)
	TriggerTerminalMetaKeyPressed(k key.Press)
	TriggerTerminalResized()
	TriggerViewActivated(view View)
	TriggerViewCreated(view View)
	TriggerWindowCreated(window Window)
	TriggerWindowResized(window Window)
}

type FileType string

type KeyBindings interface {
	// Get returns a command if registered, nil otherwise.
	Get(mode KeyboardMode, key key.Press) string
	// GetAssigned returns all the assigned keys for this mode.
	GetAssigned(mode KeyboardMode) []key.Press
}

type KeyBindingsW interface {
	KeyBindings

	// Set registers a keyboard mapping. In practice keyboard mappings
	// should normally be registered on startup. Returns false if a key mapping
	// was already registered and was lost. Set cmdName to "" to remove a key
	// binding.
	Set(mode KeyboardMode, key key.Press, cmdName string) bool
}

type KeyboardMode int

type MultiCloser []io.Closer

type Plugin interface {
	io.Closer
	fmt.Stringer

	// Details returns the plugin details for UI purposes. It's the first
	// function called and it is called synchronously. wicore/plugin provides a
	// trivial implementation.
	Details() PluginDetails

	// Init is called to do slower initialization part and is called
	// asynchronously as the editor process is started. When this function is
	// called, events are already registered and can fire simultaneously. It's up
	// to the plugin to handle these events properly.
	Init(e Editor)
}

type PluginDetails struct {
	Name        string
	Description string
}

type Proxyable interface {
	// ID represents the unique object id. The IDs must be unique through the
	// process lifetime of the editor.
	ID() string
}

type View interface {
	fmt.Stringer
	io.Closer
	Proxyable

	// Commands returns the commands registered for this specific view. For
	// example a text window will have commands specific to the file type
	// enabled.
	Commands() Commands
	// KeyBindings returns the key bindings registered for this specific key. For
	// example the 'command' view has different behavior on up/down arrow keys
	// than a text editor view.
	KeyBindings() KeyBindings
	// Title is View's title, which can be the current file name or any other
	// relevant detail.
	Title() string
	// IsDisabled returns false if the View can be activated to receive user
	// inputs at all.
	IsDisabled() bool
	// Buffer returns the display buffer for this Window.
	Buffer() *raster.Buffer
	// NaturalSize returns the natural size of the content. It can be -1 for as
	// long/large as possible, 0 if indeterminate. The return value of this
	// function is not affected by SetSize().
	NaturalSize() (width, height int)
	// DefaultFormat returns the default coloring for this View. If this View has
	// an CellFormat.Empty()==true format, it will uses whatever parent Window's
	// View DefaultFormat().
	DefaultFormat() raster.CellFormat
}

type ViewFactory func(e Editor, id int, args ...string) ViewW

type ViewW interface {
	View

	// CommandsW returns the writeable interface of Commands.
	CommandsW() CommandsW
	// KeyBindingsW returns the writeable interface of KeyBindings.
	KeyBindingsW() KeyBindingsW
	// SetSize resets the View Buffer size.
	SetSize(x, y int)
	// OnAttach is called by the Window after it was attached.
	// TODO(maruel): Maybe split in ViewFull?
	OnAttach(w Window)
}

type Window interface {
	fmt.Stringer
	Proxyable

	// Parent returns the parent Window.
	Parent() Window
	// ChildrenWindows returns a copy of the slice of children windows.
	ChildrenWindows() []Window
	// Rect returns the position based on the parent Window area, except if
	// Docking() is DockingFloating.
	Rect() raster.Rect
	// Docking returns where this Window is docked relative to the parent Window.
	// A DockingFloating window is effectively starting a new independent Rect.
	Docking() DockingType
	// View returns the View contained by this Window. There is exactly one.
	View() View
}