app

type AddSavedKey struct{ Path string }

type AddSecretsKey struct{}

type AddSecretsPassphrase struct{ Passphrase string }

type Alerts = settings.Alerts

type AllowKey struct{ Text, Path string }

type Ask struct {
	ID      uint64
	Title   string
	Text    string
	Prompts []string
	// Secret says which fields hide what is typed.
	Secret []bool
	// Choose offers answers as buttons, the first the one Enter gives,
	// answered after the fields by the button's words; Yes names the
	// button when there is no Choose. Also is a box to tick, answered
	// after that by "yes" when ticked, and with no by "yes" alone. No
	// names the button that says no, Cancel when empty.
	Choose []string
	// FirstIsSafe says the first of Choose is the safe answer, such as
	// Leave It beside Replace: Tab reaches it before the others, so Tab
	// then Enter does what Enter alone does.
	FirstIsSafe bool
	Also        string
	Yes         string
	No          string
	// Actions are buttons that do something and leave the question
	// open, answered by AskAction; Copy is what a Copy button copies,
	// and Link what Open Link opens.
	Actions    []string
	Copy, Link string
	// Danger marks a question whose yes can do harm, and colours its
	// button so. Careful opens on Cancel without the colour. Plain has
	// Yes alone, for something only told.
	Danger, Careful, Plain bool
	// Preformatted shows Text as it was written, in the fixed-width
	// face, to be selected: a secret, not a sentence.
	Preformatted bool
	// Saved names saved secrets to answer with instead of typing, in a
	// list under the fields. Its answer comes last: the index of the
	// one picked, or -1 for none.
	Saved []string
	// Facts are what the question is about, each on a line of its own
	// before the fields: a label, a name in bold, and a note under it,
	// faint, as a key's comment. Problem says, in the colour of a
	// failure, what went wrong with the last answer.
	Facts   []AskFact
	Problem string
	// Small are lines said small and faint under Text, as the two
	// items a replace question compares.
	Small []string

	// Icon is the Lucide name of the icon before the title, one of
	// askIcons, or empty for none; a Danger question shows a warning.
	Icon string
	// contains filtered or unexported fields
}

type AskAction struct {
	ID     uint64
	Action string
}

type AskAnswered struct {
	ID      uint64
	Yes     bool
	Answers []string
}

type AskFact struct{ Label, Name, Note string }

type AttachWindow struct {
	Window machines.ID
	ID     string
}

type Box struct {
	// Pane names the pane a leaf shows; a split has none.
	Pane string
	// ID names a split, so the window keeps its divider where it is
	// from one state to the next.
	ID       string
	Vertical bool
	// Share is the first box's share of the split's space.
	Share float32
	// Opening marks a split just made, whose new pane slides in.
	Opening bool
	A, B    *Box
}

type CancelJob struct{ ID string }

type CheckUpdates struct{}

type ChooseSplit struct{ Vertical bool }

type ClearFinished struct{}

type ClearJobs struct{}

type ClearMachine struct{ ID machines.ID }

type ClipboardUnreadable struct{ Why string }

type CloseLauncher struct{}

type ClosePane struct{ Pane string }

type CloseTab struct{ Group int }

type CloseTunnel struct{ ID string }

type CloseWindow struct{}

type Config struct {
	Client         gunim.Client
	Window         *gunim.Window
	Shells         *screen.Shells
	OpenWindow     WindowOpener
	WindowClosed   func(*gunim.Window)
	Options        Options
	Themes         []look.Themed
	ThemeTrouble   error
	RegisterThemes func([]look.Themed)
	// Tray shows kakel in the system tray, and Handovers are the command
	// lines kakels started later hand this one; either may be unset.
	Tray      Tray
	Handovers <-chan single.Handover
	// OpenLauncher opens the launcher's window, and HotKeys takes its key
	// from every program; either may be unset.
	OpenLauncher LauncherOpener
	// OpenOverview opens All Panes in a window of its own, over the
	// monitor Monitors names; unset, All Panes opens over the window it
	// is asked in.
	OpenOverview OverviewOpener
	Monitors     func() []driver.Monitor
	HotKeys      HotKeys
	// Files opens the file manager's windows; unset, files open in panes.
	Files FileWindows
	// OpenPrompt opens a window of its own for a question that wants
	// something typed; unset, it is asked in a dialog.
	OpenPrompt PromptOpener
	// Sound is told which sounds play; unset, none do.
	Sound SoundSetter
	// Updates opens gunim's windows of an update; unset, kakel asks
	// about one in its own dialogs.
	Updates UpdateWindows
}

type ConnectTo struct {
	Target     string
	Server, As machines.ID
	// Quiet connects for a file manager window, which says how it
	// went: no pane of its log, no toast and no flash in kakel's
	// windows. Sign-in questions still come.
	Quiet bool
	// Only connects, and opens nothing on it: no terminal when
	// nothing else waits on the connection.
	Only bool
	// NoAsk connects only when nothing has to be asked: a key or a
	// secret already open is enough, and a question fails it. For
	// a connection nobody here asked for, whose questions would
	// wait on a screen nobody is at.
	NoAsk bool
}

type ConnectWindow struct {
	Addr, KeyFile string
	ID            machines.ID
	// Via is the saved server the window, or its relay, is reached
	// through, empty for this machine. ViaSet says Via was chosen;
	// without it, a saved window goes the way it was saved to.
	Via    machines.ID
	ViaSet bool
	// NoAsk connects only when nothing has to be asked, as
	// ConnectTo.NoAsk.
	NoAsk bool
	// Only connects, and opens nothing on it.
	Only bool
}

type CopyAgentPrompt struct{ Host string }

type CopyAgentSetup struct{ Host string }

type CopyRelayLink struct{}

type CopySecret struct{ ID string }

type DialogClosed struct{}

type DisallowKey struct{ Fingerprint string }

type Disconnect struct{ Machine machines.ID }

type DisconnectClient struct{ Name, From string }

type DisconnectClients struct{}

type DisconnectWindow struct{ ID machines.ID }

type DockPane struct {
	Pane, Beside    string
	Vertical, First bool
}

type DockTab struct {
	Group           int
	Beside          string
	Vertical, First bool
}

type DropFiles struct {
	Pane  string
	Paths []string
}

type DropJob struct{ ID string }

type EditSecret struct{ ID string }

type Exit struct{}

type ExportSecrets struct{ Path string }

type Favourite struct {
	Machine machines.ID
	Path    string
	Name    string
}

type FileWindows interface {
	NewPane(o filemanager.Options, host filemanager.PaneHost) (*filemanager.Window, error)
	Refresh()
}

type FilesOn struct {
	Machine machines.ID
	Path    string
}

type FocusPane struct{ Pane string }

type Font struct {
	// Name is the family, empty for Go Mono.
	Name string
	// Faces are its regular, bold, italic and bold italic faces; nil
	// ones are drawn from the regular face, and all nil is Go Mono.
	Faces [4]*text.Face
}

type FontSize struct{ Step int }

type ForgetCopy struct{ Saved settings.SavedCopy }

type HotKeys func(k gunim.HotKey, fn func()) (release func(), err error)

type ImportSSHConfig struct{}

type ImportSecrets struct{ Path, Duplicates string }

type InstallKakel struct{ Desktop, Autostart, AutoUpdate bool }

type Job struct {
	ID    string
	Title string
	// Machine is where it works, as its row in the sidebar is filed,
	// and Kind is copy, move or delete.
	Machine machines.ID
	Kind    string
	// From is where the names are, and To where they go. A delete has
	// no To.
	From, To JobEnd
	// Detail says how far it has got, or how it ended.
	Detail string
	// Share is how much is done, from 0 to 1, and below zero while the
	// job is still working out how much there is.
	Share float32
	// Done is set once it has stopped, Stopped when the user stopped it,
	// and Failed when it was for any other reason but finishing.
	Done, Stopped, Failed bool
	// Names are what it works on, Current the one it is on, and Ticked
	// how many of Names are done, when they are counted one by one.
	Names   []string
	Current string
	Ticked  int
	// Speeds are its speed over the last while, oldest first, for a
	// graph, and Sampled how many samples have been taken in all, so a
	// graph can tell the new ones.
	Speeds  []uint64
	Sampled int
	// Repeatable says a finished copy can be run again, and Saved that
	// it is on the saved list.
	Repeatable, Saved bool
	// Started is when it started, and Finished when it stopped, zero
	// while it runs.
	Started, Finished time.Time
}

type JobEnd struct {
	// Folder is the folder's own name, Path all of it as the machine
	// types it, and Machine what the machine is called. Local says the
	// machine is this computer.
	Folder, Path, Machine string
	Local                 bool
	// On is the machine, and Dir the folder as its files name it, to
	// open it there.
	On  machines.ID
	Dir string
}

type Launch struct {
	Machine machines.ID
	Action  string
}

type LaunchAction struct {
	ID, Title string
}

type LaunchMachine struct {
	ID      machines.ID
	Name    string
	Note    string
	Actions []LaunchAction
	Default int
	Window  bool
}

type LaunchState struct {
	Machines []LaunchMachine
	Things   []LaunchThing
	Opened   uint64
}

type LaunchThing struct {
	Title, Note string
	Also        []string
	Kind        string
	Machine     machines.ID
	Action      string
}

type LauncherOpener func() (gunim.Client, error)

type LocalKey struct{ Name, Path string }

type LockKeys struct{}

type LockSecrets struct{}

type MakeKey struct {
	Path, Comment, Passphrase string
	Generate                  bool
}

type MakePortable struct{}

type MovePane struct {
	Pane, Beside string
	Vertical     bool
	// Instead moves it into the place of that split's chooser.
	Instead string
}

type MoveTab struct{ Group, Before int }

type NewRelayCode struct{}

type NewTab struct{}

type NewTerminal struct{}

type NextPane struct{ Back bool }

type NextTab struct{ Back bool }

type NoTextToPaste struct{}

type Notice struct {
	ID          uint64
	Title, Body string
	// Kind says whether it tells of a failure, of work done, or of
	// neither.
	Kind NoticeKind
	// Action names a link on the toast, and On is the intent a click on
	// it sends.
	Action    string
	On        gunim.Intent
	Clipboard string
	// Forget has the window take Clipboard back off the clipboard in
	// half a minute, unless something else was copied since.
	Forget bool
	// contains filtered or unexported fields
}

type NoticeKind uint8

type OpenDefaultShell struct{}

type OpenFileManager struct {
	Machine machines.ID
	Path    string
}

type OpenFiles struct{}

type OpenFilesOn struct {
	Machine machines.ID
	Path    string
	NewTab  bool
}

type OpenLauncher struct{}

type OpenOn struct{ Machine machines.ID }

type OpenSavedTunnel struct{ Saved settings.SavedTunnel }

type OpenShellNamed struct{ ID string }

type OpenTunnel struct {
	Machine machines.ID
	Tunnel  remote.Tunnel
	Keep    bool
	Sure    bool
	Saved   bool
}

type Options struct {
	// contains filtered or unexported fields
}

type OutputArrived struct{}

type OverState struct {
	// Windows are kakel's windows, each saying where it stands, and
	// Panes their panes.
	Windows []OverWindow
	Panes   []Pane
	// Front numbers the window in front, and Focus is its pane with the
	// keyboard, which has the ring as All Panes opens.
	Front int
	Focus string
	// FontSize and Font are what the terminals are drawn in, PaneTitles
	// says panes show a line naming them, and Machines name the machines
	// on those lines.
	FontSize   float32
	Font       Font
	PaneTitles bool
	Machines   []machines.Info
	// Shortcuts are the changes the shortcuts file makes to the keys,
	// one of which closes it.
	Shortcuts []keys.Change
	// Close asks it to close, as its key does in a window it covers.
	Close bool
}

type OverTab struct {
	Group int
	Box   *Box
	Pane  string
}

type OverWindow struct {
	ID int
	// Tabs are its tabs, in order, and Front the group of the one in
	// front.
	Tabs  []OverTab
	Front int
	// Stage is the size of its stage, and StageAt where the stage is in
	// the window, and Size the window's own size, as it last said, in
	// its logical pixels; zero before it has.
	Stage   geom.Size
	StageAt geom.Rect
	Size    geom.Size
	// Home is where the window is on the screen, in the space of All
	// Panes' own window; empty where that cannot be said, and in the
	// windows' own state.
	Home geom.Rect
}

type OverviewDone struct{}

type OverviewFocus struct{ On bool }

type OverviewLeaving struct{}

type OverviewOpener func(m driver.Monitor, theme string) (gunim.Client, *gunim.Window, error)

type OverviewShown struct{ On bool }

type Pane struct {
	ID    string
	Title string
	// Window numbers the window it is in, among kakel's own; it is set
	// in AllPanes alone.
	Window int
	// Machine is the server the pane's shell runs on, "" for this
	// computer.
	Machine machines.ID
	// On is the machine the pane runs on when that is a server the
	// window in Machine reached, and "" for the window's own.
	On string
	// Kind says what the pane is: a terminal, a file manager or a reader.
	Kind string
	// Named is set once the user has named the pane, and shell is the
	// title its shell last gave it.
	Named bool

	// Tunnel is the tunnel a tunnel's pane tells of.
	Tunnel string
	// Ended says the program in a terminal pane has ended; the pane
	// stays, asking whether to start it again.
	Ended bool
	// Rang says its program rang the bell since the user last looked.
	Rang bool
	// Note is what the program in the pane says about itself: how far
	// along it is, and its last message.
	Note string
	// Command says the pane runs one command rather than a shell, and
	// offers to run it again when it finishes.
	Command bool
	// ShellKind is the kind of shell a terminal pane runs, as bash or
	// PowerShell, for colouring code pasted into it. It is NoRoute for a
	// pane running a command, and for one opened through another kakel
	// window, whose shell this one cannot see.
	ShellKind shellsetup.Route
	// SplitFrom is, for a split's chooser, the pane it was split from.
	SplitFrom string
	// contains filtered or unexported fields
}

type PaneDrag struct {
	Pane   string
	Window int
	Grab   geom.Point
}

type PaneToNewWindow struct {
	Pane string
	At   geom.Point
	Size geom.Size
}

type PaneToTab struct {
	Pane   string
	Window int
	Bar    bool
	Before int
}

type PaneToWindow struct{ Pane string }

type PasteImage struct{ Pane string }

type PasteImageAsFile struct{ Pane string }

type PickFont struct{ Name string }

type PickShell struct{ ID string }

type PickTheme struct{ Name string }

type Pings struct {
	Problems, Dones, Calls     uint64
	Connected, Lost            uint64
	Finished, Failed           uint64
	FrontFinished, FrontFailed uint64
}

type Placement struct {
	Beside   string
	Vertical bool
	// Instead puts the pane in the place of that one, a split's chooser,
	// which goes: the chooser's split is the one it lands in.
	Instead string
}

type PopOut struct{}

type PreviewTheme struct{ Name string }

type PromptOpener func(q Ask, theme string, near *gunim.Window) (gunim.Client, error)

type PutSecret struct {
	ID, Name, User string
	Kind           secrets.Kind
	Value          string
}

type ReadAgain struct {
	Pane string
	Text bool
}

type Reader struct {
	Path  string
	Lines []string
	// Cut says the file was longer than a reader holds.
	Cut bool
	Err string
	// Seq counts its reads.
	Seq int
	// Line is the line to show first, counted from 1, and 0 for the top.
	Line int
	// Name is the file's name, for telling its kind; Pic is it, read as
	// an image; SoFar is how much of it a read has got through.
	Name  string
	Pic   *files.Pic
	SoFar int64
	// Find opens the reader with its find bar open, as the scrollback
	// is opened, to be searched, and FindAgain counts the times it is
	// asked to open it again after.
	Find      bool
	FindAgain int
	// Of is the terminal pane whose scrollback the reader shows, which
	// reading again reads again; SaveAs is where a save is offered.
	Of, SaveAs string
	// Saves counts the reader's saves that have finished, and SaveErr
	// is why the last one failed, empty when it worked.
	Saves   int
	SaveErr string
	// Expect is how large the file was listed as, for the reader to say
	// how far a read has got of it, and 0 when nobody said.
	Expect int64
	// Gone says why a scrollback's reader has nothing left to read
	// again, its pane having closed.
	Gone string
	// Text says a file named as an image is read as lines: it was not
	// one.
	Text bool
}

type ReloadServers struct{}

type ReloadShortcuts struct{}

type ReloadThemes struct{}

type RemoteWindow struct {
	Name machines.ID
	Addr string
	// Open is what it has open, with a screen to work in, less what
	// this window already shows.
	Open []serve.Open
	// Folders are the folders it has saved for the machines it reaches,
	// by its key for each, to offer under their headings.
	Folders map[string][]string
	// Machines are the machines it is connected to, by its key for
	// each, each a heading here with nothing open on it too.
	Machines []string
}

type RemoveSavedKey struct{ Path string }

type RemoveSecret struct{ ID string }

type RemoveSecrets struct{ IDs []string }

type RemoveSecretsKey struct{ Fingerprint string }

type RemoveServer struct{ ID machines.ID }

type RenamePane struct{ Pane, Title string }

type RepeatJob struct{ ID string }

type RevealSecret struct{ ID string }

type RunCommand struct {
	Machine   machines.ID
	Line, Dir string
	Keep      bool
	// Beside puts its pane in a split beside that pane, below it with
	// Vertical, rather than on a stage of its own.
	Beside   string
	Vertical bool
	// Instead runs it in the place of that split's chooser.
	Instead string
	// Forget is a saved command picked and then unticked, which is how
	// the user says to forget it.
	Forget string
}

type RunSavedCommand struct{ Saved settings.SavedCommand }

type RunSavedCopy struct{ Saved settings.SavedCopy }

type SaveCopy struct {
	ID string
	On bool
}

type SaveLines struct {
	Pane, Path string
	Lines      []string
}

type SaveLook struct {
	Sounds, Rings  Alerts
	SystemTitleBar bool
}

type SaveServer struct {
	Host  remote.Host
	Under string
}

type SaveThemeEdits struct {
	Theme string
	Edits []byte
}

type SaveThisComputer struct {
	StartFolder string
	Shell       string
}

type SecretEdit struct {
	Seq   uint64
	Item  SecretItem
	Value string
	// contains filtered or unexported fields
}

type SecretEditShown struct{ Seq uint64 }

type SecretItem struct {
	ID, Name, User, File string
	Kind                 secrets.Kind
	// Logins are where it signs in, user@host, for a picker to put it
	// first for a pane on one of those machines.
	Logins []string
}

type SecretKey struct {
	Name, Note, Fingerprint string
	Passphrase              bool
	// Removing says what is left once it goes.
	Removing string
}

type Secrets struct {
	// Exists is set once there is a vault, and Open while it is
	// unlocked.
	Exists, Open bool
	Items        []SecretItem
	Keys         []SecretKey
	// Passphrase says a passphrase opens the vault as well as its keys.
	Passphrase bool
	// Waiting names the terminal used last when an agent has asked for a
	// secret there, which Type answers, return and all.
	Waiting string
	// TypeInto is the terminal Type types into, the one used last, and
	// TypeIntoTitle what it is called, with the machine it is on: ""
	// for none.
	TypeInto, TypeIntoTitle string
	// Editing is a secret to change, with its value, for the window
	// that asked to show it in a form once.
	Editing []SecretEdit
	// LockAfter is how long the secrets may go unused before they lock
	// themselves, 0 for never. Known only while they are open.
	LockAfter time.Duration
}

type ServedClient struct{ Name, From, As string }

type ServedTunnel struct{ Client, From, Label, On string }

type Serving struct {
	// On says the window is served, at Addr, by the host key with
	// Fingerprint.
	On          bool
	Addr        string
	Fingerprint string
	// Clients are the windows connected, by the name their key has in
	// the authorized keys, and where they came from, and Tunnels the
	// tunnels they hold through this window.
	Clients []ServedClient
	Tunnels []ServedTunnel
	// Port and Anywhere are what serving starts with: the port asked
	// for last, and whether it listened on every network. AtStart is
	// what kakel does as it starts, when the window was served as it
	// last closed: settings.ServeAsk, ServeAlways or ServeNever.
	Port     int
	Anywhere bool
	AtStart  string
	// Relay is how serving goes through a relay: RelayOn says it does,
	// NoPort that it listens on no port of its own, RelayURL is the
	// relay with its secret, RelayHost the relay without it, and Code
	// what a window connecting gives there. Link is the URL and the
	// code together, for a window connecting to paste.
	RelayOn  bool
	NoPort   bool
	RelayURL string
	// RelayVia is the saved server the relay is reached through, empty
	// for this machine.
	RelayVia  machines.ID
	RelayHost string
	Code      string
	Link      string
	// Relayed says the window is served through the relay now; Reached
	// that the relay has it, and RelayTrouble why not when it has not.
	Relayed      bool
	Reached      bool
	RelayTrouble string
	// RelayLast is the relay last connected to a window through, to
	// offer again.
	RelayLast string
	// Host is this machine's name, for the ssh commands the window
	// explains.
	Host string
	// TunnelsConnect lets plain ssh's tunnels connect this window to
	// saved servers on the way, and go through kakel windows.
	TunnelsConnect bool
	// Proxy is the HTTP proxy relays are reached through, as set: empty
	// for the system's, relay.NoProxy for none.
	Proxy string
	// Allowed are the keys that may connect, by name, from the file at
	// AllowedAt, Keys the same keys with their fingerprints, and
	// Problem what stops that file being read.
	Allowed   []string
	Keys      []serve.AllowedKey
	AllowedAt string
	Problem   string
	// Here are the public keys on this machine that may not connect
	// yet, to pick one to add.
	Here []LocalKey
	// Edits counts the changes asked to the keys that may connect,
	// which worked or did not, for the window that asked to hear how it
	// went.
	Edits uint64
	// Tries counts the times serving was asked to start, which worked
	// or did not, for the window that asked to hear how it went.
	Tries uint64
}

type SetAgentMay struct {
	Pane string
	May  settings.AgentMay
}

type SetBeta struct{ On bool }

type SetFontSize struct{ Size float32 }

type SetLauncherFiles struct{ Where string }

type SetLauncherKey struct{ Key string }

type SetPasteCheck struct{ On bool }

type SetRelayProxy struct{ Proxy string }

type SetSecretsLockAfter struct{ After time.Duration }

type SetServeAtStart struct{ When string }

type SetServeDefaults struct {
	Port     int
	Anywhere bool
}

type SetTermProgram struct{ Called string }

type SetTunnelsConnect struct{ On bool }

type SetUpdates struct{ What string }

type Share struct {
	Code  string
	Panes []SharedPane
	// Host is the agent program the prompt is written for.
	Host string
}

type SharePane struct{ Pane string }

type SharedPane struct {
	Pane string
	May  settings.AgentMay
	// Note says whether an agent is working in it or it is only
	// offered.
	Note string
}

type ShellChoice struct {
	ID, Title string
	// Folder is where Windows reaches a WSL distribution's files, empty
	// for any other shell.
	Folder string
}

type ShiftTab struct{ Back bool }

type ShowAbout struct{}

type ShowCopies struct{}

type ShowHelp struct{}

type ShowJobs struct{}

type ShowLog struct{ Machine machines.ID }

type ShowReadyUpdate struct{ Release install.Release }

type ShowScrollback struct{ Pane string }

type ShowSecrets struct{}

type ShowServers struct{}

type ShowSettings struct{}

type ShowTab struct{ Group int }

type ShowThemeEditor struct{}

type ShowTunnel struct{ ID string }

type ShowTyped struct{ Pane string }

type ShowWhatsNew struct{ From string }

type SoundSetter func(iface, any bool)

type SplitMoved struct {
	Split string
	Share float32
}

type SplitPane struct {
	Vertical  bool
	Machine   machines.ID
	Elsewhere bool
	Shell     string
	// Instead opens it in the place of that split's chooser, on the
	// machine of the pane the chooser was split from.
	Instead string
}

type StageSized struct {
	At     geom.Rect
	Window geom.Size
}

type StartServing struct {
	Port     string
	Anywhere bool
	// NoPort listens on no port, and Relay serves through the relay
	// at RelayURL as well, or instead, reached through the saved
	// server RelayVia, or from this machine when that is empty.
	NoPort   bool
	Relay    bool
	RelayURL string
	RelayVia machines.ID
}

type State struct {
	// Window numbers the window, among kakel's own, and Behind says
	// another is in front, which sends the echoes and asks for the
	// user's attention in its place.
	Window int
	Behind bool
	// Panes are the open panes, in the sidebar's order.
	Panes []Pane
	// Stage is the arrangement on screen: the group of panes the
	// focused pane belongs to. Nil when no pane is open.
	Stage *Box
	// Groups are how each of the window's panes is arranged, by pane:
	// the split it sits in, or itself alone, for the switcher to grow a
	// pane into its place and its neighbours into theirs.
	Groups map[string]*Box
	Focus  string
	// Tabs are the window's tabs, in order.
	Tabs []Tab
	// AllPanes are every window's panes, each saying which window it is
	// in, for the Machines pane to list, and Working the pane last worked
	// in, in whichever window, whose row it lights.
	AllPanes []Pane
	Working  string
	// Overview is every window, with its tabs, for All Panes;
	// Overviewing says All Panes is open somewhere, so the windows share
	// what their panes draw; and OverviewAlone says it opens in a window
	// of its own.
	Overview      []OverWindow
	Overviewing   bool
	OverviewAlone bool
	// InTray says kakel is to show its icon in the system tray, and run
	// on there once its last window closes, where there is a tray.
	InTray bool
	// LauncherKey is the launcher's key, as written.
	LauncherKey string
	// LauncherFiles is where files from the launcher or the tray open:
	// settings.LauncherFilesTab, LauncherFilesBeside or
	// LauncherFilesWindow.
	LauncherFiles string
	// Update is where kakel stands on installing and updating.
	Update Update
	// Sounds and Rings are the events kakel tells of by a sound and by
	// rings around the window, and SystemTitleBar says windows opened
	// from now on take the system's title bar.
	Sounds, Rings  Alerts
	SystemTitleBar bool
	// FontSize is the terminals' font size in logical pixels.
	FontSize float32
	// Fonts are the families to draw the terminals in, and Font the one
	// they are drawn in.
	Fonts []string
	Font  Font
	// Marks are the colours of the rings round shared panes.
	Marks look.Marks
	// KeyFiles are the key files kept, newest first, offered when a
	// server is saved.
	KeyFiles []string
	// Theme names the theme the window is drawn in, and Themes those on
	// offer.
	Theme  string
	Themes []string
	// Asks are the questions connections are waiting on the user for,
	// oldest first.
	Asks []Ask
	// Saved are the saved servers.
	Saved []remote.Host
	// Readers are what the readers show, by pane. Each is replaced
	// whole, never changed in place.
	Readers map[string]Reader
	// Tunnels are the tunnels open, and those stopped until cleared,
	// and SavedTunnels those kept for next time, newest first.
	Tunnels []Tunnel
	// Jobs are the file jobs, running and finished, oldest first.
	Jobs []Job
	// Accounts are the machines with a connection log, in the order
	// their first connection began.
	Accounts []machines.ID
	// Secrets is what the vault holds, by name.
	Secrets Secrets
	// Share is the panes shared with an agent.
	Share Share
	// Serving is this window served to others.
	Serving Serving
	// Windows are the windows this one is connected to.
	Windows []RemoteWindow
	// Machines are what everything else names machines by, their IDs,
	// with the names to show: the saved servers and windows, and the
	// quick connections.
	Machines []machines.Info
	// PaneTitles says each pane shows a line naming it, and Bells
	// counts the bells rung in panes, for the window to ask for the
	// user's attention.
	PaneTitles bool
	// SavedCommands are the commands kept, newest first.
	SavedCommands []settings.SavedCommand
	// Shells are the shells found on this machine, and ChosenShell the
	// one new terminals start, "" for the user's own.
	// Connected are the servers connected to, by name, and Dialing the
	// ones being connected to.
	Connected []machines.ID
	Dialing   []machines.ID
	// Dropped are the machines whose connection went by itself, kept on
	// the sidebar, greyed, until cleared.
	Dropped     []machines.ID
	Shells      []ShellChoice
	ChosenShell string
	// DefaultShell is the ID of the shell a new terminal here starts:
	// ChosenShell, or the user's own as found among Shells; "" where
	// that is not known.
	DefaultShell string
	// HereMachine is the machine a new terminal and New Files open on,
	// from the pane in front, and HereShell the name of the shell such
	// a terminal runs on this computer: the one in front, or else the
	// default. It is "" on a server, or where it is not known.
	HereMachine machines.ID
	HereShell   string
	// ThisComputer is this computer's settings: where a new terminal
	// starts.
	ThisComputer ThisComputer
	// Favourites are the folders saved on any machine, in the user's
	// order.
	Favourites []Favourite
	// ShellSetup says new shells here are taught to say what they are
	// doing, and TermProgram what they are told the terminal is called,
	// "" for kakel's own name.
	// Shortcuts are the changes the user's shortcuts file makes to the
	// window's keys, and ShortcutsRead counts its reads; ShortcutsAgain
	// says the last read was asked for, and the window says so once it
	// has taken the file. Contents are
	// the themes' colours for the panes, when the themes were read
	// again.
	// SavedCopies are the copies kept, newest first.
	SavedCopies   []settings.SavedCopy
	Shortcuts     []keys.Change
	ShortcutsRead uint64
	// See Shortcuts.
	ShortcutsAgain bool
	Contents       map[string]theme.Theme
	// Looks are the themes whole, when they were read again: for the
	// theme editor, each with its edits.
	Looks       []look.Themed
	ShellSetup  bool
	TermProgram string
	// PasteCheck says a paste of several lines, or a large one, opens in
	// an editor before it reaches the pane.
	PasteCheck bool
	Bells      uint64
	// Pings counts what the window sends an echo out for, past its
	// edges.
	Pings        Pings
	SavedTunnels []settings.SavedTunnel
	Status       string
	// Notices are the latest notices, oldest first, for the window to
	// show each once.
	Notices []Notice
	// Views are the latest files to show in the viewer, oldest first,
	// for the window to open each once.
	Views []Viewed
}

type StopServing struct{}

type StopSharing struct{}

type Tab struct {
	// Group numbers it, for the intents about it.
	Group int
	// Pane is the pane in it that last had the keyboard, whose title
	// the tab shows, and Panes counts the panes in it.
	Pane  string
	Panes int
}

type TabToNewWindow struct {
	Group int
	At    geom.Point
	Size  geom.Size
}

type ThisComputer struct {
	StartFolder string
}

type ToggleAutostart struct{}

type ToggleFolders struct{}

type ToggleOverview struct{}

type TogglePaneTitles struct{}

type ToggleServers struct{}

type ToggleShellSetup struct{}

type ToggleTray struct{}

type ToolWindow struct {
	Kind string
	At   geom.Point
	Size geom.Size
}

type Tray struct {
	Set      func(gunim.Tray) error
	StayOpen func(bool)
	// Notify shows a message from the icon, and may be nil.
	Notify func(title, body string) error
}

type Tunnel struct {
	ID      string
	Machine machines.ID
	// Label says what it forwards, as ":8080 → db:5432".
	Label string
	// Note says what it is doing: the streams it carries, how many
	// failed, or that it stopped.
	Note string
	// Live is set while it forwards, and Watching while its traffic is
	// written into its account.
	Live, Watching bool
	// Pane is the pane showing its account, or "".
	Pane string
	// Meter counts what goes through it, for the sidebar to draw.
	Meter *meter.Meter
}

type TypeSecret struct{ ID, Into string }

type UnlockSecrets struct{}

type UnsharePane struct{ Pane string }

type Update struct {
	// Installed says this is the installed copy, Installable that this
	// system can have one, and Autostart that it starts with the
	// computer. Folders says folders open with it, where FoldersHere
	// says they can. Updates is the setting.
	Installed, Installable, Autostart bool
	Folders, FoldersHere              bool
	Updates                           string
	// Beta says updates take beta releases too.
	Beta bool
}

type UpdateWindows interface {
	ShowUpdate(u install.Update) error
	ShowWhatsNew(from string) error
	ShowAbout(o install.About) error
}

type ViewLink struct {
	ID  uint64
	URL string
}

type Viewed struct {
	ID uint64
	// Name is the file's name, and Path and Where where it is: the path
	// on the machine Where names.
	Name, Path, Where string
	Data              []byte
	Cut               bool
	Line              int
	Err               string
	// contains filtered or unexported fields
}

type WatchTunnel struct {
	ID string
	On bool
}

type WindowFocused struct{}

type WindowOpener func(from *gunim.Window, at geom.Point, size geom.Size, place *driver.Placement) (gunim.Client, *gunim.Window, error)

type WriteShortcuts struct{ Bindings []ui.Binding }

type WriteSkill struct {
	Host string
	Over bool
}

type WriteThemeFile struct{}