code

package
v0.2.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 31, 2026 License: BSD-3-Clause Imports: 76 Imported by: 0

README

Cogent Code is a general purpose code / text editor, written in pure Go, using the Cogent Core GUI (for which it serves as a continuous testing platform) and the parse interactive parser for syntax highlighting and more advanced code completion.

Some of the main features of Code include:

  • Designed to function as both a general-purpose text editor and a reasonably powerful Go development tool, including a full GUI interface to the delve debugger. It comes configured with command support for LaTeX, Markdown, and Makefiles, in addition to Go, and the command system is fully extensible to support any command-line tools.

  • Provides a tree-based file browser on the left, with built-in support for version control (git, svn, etc) and standard file management functionality through drag-and-drop, etc. You can look at git logs, diffs, etc through this interface. The VCS Log gives complete git log and version diff browser, so you don't need to go to github for all that. The Open setting of Find uses the currently open folders in the file browser to control where searching happens, which can be useful when working in a large multi-repository project.

  • Command actions show output on a tabbed output display, along with other special "Panels" such as Find / Replace, Symbols, Debugger, etc. Thus, the overall design is extensible and new panels can be easily added to supply new functionality.

  • Strongly keyboard focused, inspired by Emacs, so existing Emacs users should be immediately productive. However, other common keyboard bindings are also supported, and key bindings are entirely customizable.

Install

See Cogent Core for general setup info for Cogent Core.

go install cogentcore.org/cogent/code/cmd/cogentcode@latest
  • See Releases on this github page for pre-built OS-specific app packages that install the compiled binaries.

MacOS environment variables

When Code is run from an installed mac app bundle, it does not inherit the normal shell environment. To set environment variables in a way that extends to GUI apps, you must use:

launchctl setenv VAR VALUE

The goal shell automatically does this for you when setting any environment variables.

This does not extend to the PATH variable, which requires this command:

sudo launchctl config user path $PATH

This only takes effect after a reboot. Also, once done, then the default shell path will have that path, already, so commands to set the path in the shell will end up with duplicates.

Future Plans

We plan to incorporate gopls to provide more comprehensive Go language IDE-level support, similar to what is found in VS Code. At present, the completion can be a bit spotty for some kinds of expressions, and the lookup "go to definition" functionality is also not perfect. However, the basic code editing dynamics are pretty solid, so adding gopls would bring it much closer to feature-parity with VS Code.

Help Guide

General

The toolbar has lots of buttons to accomplish many tasks. Depending on how wide your window is, these buttons can migrate to the overflow menu (three vertical dots) at the end of the toolbar. In addition, some less-frequent functions are always found in that overflow menu, so you can look through there as well.

Cogent Code is based on the notion of a "project", which is just a directory containing files.

  • Use Open in toolbar to open an existing directory (e.g., a github project repository, etc).

  • Or File/New Project in the : overflow menu to create a new directory for a new project.

The project has its own specific Settings which can be accessed from the toolbar button of that name. The permanent overflow menu Settings option is for the overall Cogent Core global settings, which include some important options for Code as well. The project-specific Settings are saved in a .code file at the top level of your project, and are auto-saved whenever you edit the project settings, and whenever you click Save All.

A major design goal for Cogent Code is to replicate the emacs-like ability to use relatively-easy-to-remember keyboard sequences to do just about everything, without ever touching the mouse.

The Splits menu can be used to to configure the size and layout of the different panels used in Code, which are as follows:

  • File Browser (on the left) -- click on files here to edit / run / view etc. Use the Context Menu (hint: always check the context menu! -- i.e., right-mouse-click or whatever it is on your Mac) to run commands, or delete, rename, etc files (multiple files can be operated on at once). You can also use drag-and-drop to move files into other subdirectories etc.

    • It knows about your VCS (version control system, e.g., git or svn) and color-codes files according to whether they are under VCS control or not, and have been edited since last commit. File actions automatically work through the VCS (e.g., rename, move, delete etc).

    • The folders that are currently open in the File Browser determine which files are searched in Find / Replace! So you can regulate that scope dynamically I that way (you can also tell Find to only look in the current Directory or other options too).

    • You can open files outside of the scope of the current file tree (e.g., using the Open action, or through Lookup or Debugging) -- they will show up at the top of the list under [external files]. These are automatically excluded from any file operations.

  • Text Editor(s) (up to 2) -- this is obviously where you do your editing. Many functions work on the active text view, which is brighter than the other one (e.g., the Open, Save, Edit etc buttons.

    • A key design feature (borrowed from emacs) is that either editor window can view any given underlying file (buffer), and that a typical workflow involves jumping frequently between these two editors and loading different files between each (including looking at two different regions of the same file). This is different from the typical tabs-based design where each editor window has a fixed set of file tabs associated with it. Once you learn the relevant shortcuts for switching between panels and selecting files to view in a given panel, it becomes a very fluid and powerful way of working.

    • The right-most editor window is "special" in that actions in the Tab views always operate on it.

  • Tabs -- contains all special-purpose "panels" (Find, Debug, Symbols..), and where the output of commands goes -- e.g., the output of your make or build commands, etc. You can hit the x on a tab to kill a running process if you need to, and that's also how you close the debugger.

The idea here is to have a really simple overall plan, with easy customization of what panels are visible for different use-cases, so you know exactly where to look for anything. We rely on tabs to hold all the many different kinds of output etc, and support multi-row tabs and a menu so you can really load them up.

The overall Build and Run commands are defined in the project Settings. You can also select the executable to run (and debug) from the file tree context menu or in the Command menu.

Keyboard Usage

You can customize your keyboard shortcuts in the Core Settings panel.

  • Use Ctrl+G to clear highlighting in a buffer (e.g., after a Find) -- it is the CancelSelect function and defined as this key by default on all platforms. Some platforms also define Shift+Control+A to do this.

  • The Complete key function (Ctrl+. in most cases) can be used on-demand to drive completion -- automatic continuous completion is only triggered when typing in new text. It also will pull up a spelling correction menu on misspelled words.

  • The Lookup key (Ctrl+, -- right next to Complete) will pull up the source code where any given entity is defined (e.g., the type of a variable, or method being called). From there, you can also bring the file into the file tree view (as an external file if not under your current tree).

  • To trigger a Save All of all edited files, just do File/Save Project which has the standard Command+S (Ctrl or the mac command key) shortcut.

  • Use the Recenter command, which is Ctrl+L by default for all platforms, to trigger a re-highlight if anything gets out-of whack.

  • The interactive "query-replace" function has a Lexical Items option, which is key for replacing short variable names like i which appear in many words etc -- it will only find cases of i that are separate lexical items (variables, etc).

  • The full "kill ring" of prior cut / paste items is available with Shift-Ctrl-Y in a chooser -- very convenient to grab something you were pasting previously. As in emacs, it moves any used item up to top so subsequent paste will be of that as well.

Emacs mode

The KeyMaps "MacEmacs" and "LinuxEmacs" include the following emacs mappings.

Not everything in emacs is intended to be supported, but the most important keyboard functions are there, including a few that work slightly differently. In general for the Ctrl-X and Ctrl-C execute / command prefixes, the subsequent key sequence can be either with a Ctrl or not, just because sometimes it is easier to keep the ctrl key down (except where there is a precedent for each use).

  • Esc-based commands are not supported. Esc is used widely for abort throughout the Gi gui, and it is really awkward to hit.. it is time to fix that and just use Alt or another option!

  • Ctrl-X o -- go to next ("other") panel to the right, looping around at the end back to the first panel. Within the tabs panels, use Ctrl+N to quickly go down into the content of the tab.

  • Ctrl-X p = go to previous panel on the left.

  • Ctrl-X Ctrl-o = clone buffer in other textview -- very handy for looking up some other stuff in another place in same file.

  • Ctrl-X b = choose buffer, Ctrl-X f = open file, Ctrl-X s = save file, Ctrl-X w = save as file, all work as expected.

  • Ctrl-C c = execute command on active file

  • Ctrl-X x / g = register copy / paste supported. registers are saved with the .gide project and thus persistent across sessions.

  • Shift+Ctrl-Y = Paste History, which works like Esc Ctrl+Y (yank previous), avoiding Esc, and adding a nice chooser.

  • Ctrl-J = goto-line (i.e., jump to line). never had a good emacs default and people mapped it differently.. Ctrl-X Ctrl-J is also avail just in case that was what you used..

  • Ctrl-U = PageUp, in complement to Ctrl-V -- this is super convenient, and the "universal" arg thing in emacs isn't supported anyway. Likewise, Esc-x command stuff is not supported. This is NOT full emacs :)

  • Ctrl+/ = Undo -- this is one of several "standard" keys for undo. Set the Emacs Undo option to enable the "undo the undo" native behavior of emacs, where typing any non-undo key causes all the undo actions to be added to the undo stack, so you can then do redo by just doing more undos at that point.

  • Ctrl-X Ctrl-X, Ctrl-X Alt-W, Ctrl-X Ctrl-Y = rectangle versions of cut, copy, and paste, respectively -- can be very handy for repeated edits across multiple lines.

  • Ctrl+[, Ctrl+] = mark-ring -- the emacs native commands for going to previous marks (set-mark-command) doesn't have a good default key, so we're using the web standard Ctrl+[ and Ctrl+] (also ⌘ versions on the mac) for prev / next history. cursor positions are saved "heuristically" at important junctures, not just mark sets (i.e., select toggle, Ctrl+space). these can be extremely handy! they are also stored with the buffer.

  • Ctrl-S = interactive search, which works just like in emacs. this is great for within-file searching (including in the Console and other command outputs). Use "standard" Command+F for cross-file find / replace.

  • Ctrl-R = query-replace (instead of M-%) -- it is mapped to Ctrl-R by default as more mnemonic and easier to type -- it is avail directly in TextView, so has a single-length sequence. doesn't need full Cogent Code.

  • Ctrl-L = recenter -- works with 3 different modes as you repeat, as in emacs.

  • Ctrl-T = transpose letters (also Alt version for words).

Non-Emacs Versions

The other shortcut maps attempt to use OS-specific conventions as much as possible. How anyone gets anything done without the emacs navigation keys (Ctrl+F/B/N/P) remains a mystery (do you really lift your hand up and go all the way over to the arrow keys every single time you want to move the cursor??), but it is there..

The one place that is somewhat unconventional is in how we handle the multi-key sequences to activate many of the commands. In emacs, Ctrl+X or Ctrl+C are general prefixes that then allow you to use more mnemonic 2nd keys in the sequence to execute various functions (see above for details). This overall seems preferable to using more complex and obscure single-sequence shortcuts, which often involve so many simultaneous modifiers and such obscure letter mappings that they are likely rarely used in practice.

So, we chose Ctrl-M as the general coMMand key for these other platforms, as it is not generally used for anything else, and it is mnemonic. Thus, by analogy with the emacs versions above, there are shortcuts such as the following. The Control+ version of the 2nd key is also defined as it is easier to keep the control key down sometimes:

  • Ctrl-M o = move focus to "other" or next panel
  • Ctrl+M p = move focus to previous panel
  • Ctrl+M c = execute command
  • Ctrl+M x = register copy
  • Ctrl+M g = register get
  • Ctrl+M i = indent
  • Ctrl+M k = close (kill) buffer
  • Ctrl+M t = comment / uncomment (k, c are taken) (also Ctrl+/ is supported as used in some other IDE's)

Also, the following emacs-isms (which don't conflict with anything else) are supported and strongly recommended:

  • Ctrl+Spacebar = start selecting text -- then you can just use any navigation keys to select whatever you want
  • Ctrl+G = cancel selection and also clear any highlights
  • Ctrl+R = query-replace
  • Alt+S = interactive search

Commands

Much of the language-specific functionality (and version control operations) is achieved by calling command-line commands, configured under the Settings: click on Edit cmds in toolbar, and then View standard in the toolbar of the window that comes up from there, to see all the standard built-in commands.

You can add additional custom commands to achieve anything not covered under the standard commands, and also any custom command with same name as a standard command will override the standard version, so that is how you can customize the standard commands.

You can do the Context menu on any of the standard commands and then Paste into the custom commands editor, and modify from there.

Click on the Cmds field to edit the actual commands executed -- there can be multiple individual commands executed for any given overall named command.

You can use variables specified below to insert values derived from the current active file or file being operated in the file browser, or variables defined in the project preferences.

Special Arg Variables
	/// Current Filename
	"{FilePath}":       ArgVarInfo{"Current file name with full path.", ArgVarFile},
	"{FileName}":       ArgVarInfo{"Current file name only, without path.", ArgVarFile},
	"{FileExt}":        ArgVarInfo{"Extension of current file name.", ArgVarExt},
	"{FileExtLC}":      ArgVarInfo{"Extension of current file name, lowercase.", ArgVarExt},
	"{FileNameNoExt}":  ArgVarInfo{"Current file name without path and extension.", ArgVarFile},
	"{FileDir}":        ArgVarInfo{"Name only of current file's directory.", ArgVarDir},
	"{FileDirPath}":    ArgVarInfo{"Full path to current file's directory.", ArgVarDir},
	"{FileDirProjRel}": ArgVarInfo{"Path to current file's directory relative to project root.", ArgVarDir},

	// Project Root dir
	"{ProjDir}":  ArgVarInfo{"Current project directory name, without full path.", ArgVarDir},
	"{ProjPath}": ArgVarInfo{"Full path to current project directory.", ArgVarDir},

	// BuildDir
	"{BuildDir}":    ArgVarInfo{"Full path to BuildDir specified in project prefs -- the default Build.", ArgVarDir},
	"{BuildDirRel}": ArgVarInfo{"Path to BuildDir relative to project root.", ArgVarDir},

	// BuildTarg
	"{BuildTarg}":           ArgVarInfo{"Build target specified in prefs BuildTarg, just filename by itself, without path.", ArgVarFile},
	"{BuildTargPath}":       ArgVarInfo{"Full path to build target specified in prefs BuildTarg.", ArgVarFile},
	"{BuildTargDirPath}":    ArgVarInfo{"Full path to build target directory, without filename.", ArgVarDir},
	"{BuildTargDirPathRel}": ArgVarInfo{"Project-relative path to build target directory, without filename.", ArgVarDir},

	// RunExec
	"{RunExec}":           ArgVarInfo{"Run-time executable file RunExec specified in project prefs -- just the raw name of the file, without path.", ArgVarFile},
	"{RunExecPath}":       ArgVarInfo{"Full path to the run-time executable file RunExec specified in project prefs.", ArgVarFile},
	"{RunExecDirPath}":    ArgVarInfo{"Full path to the directory of the run-time executable file RunExec specified in project prefs.", ArgVarDir},
	"{RunExecDirPathRel}": ArgVarInfo{"Project-root relative path to the directory of the run-time executable file RunExec specified in project prefs.", ArgVarDir},

	// Cursor, Selection
	"{CurLine}":      ArgVarInfo{"Cursor current line number (starts at 1).", ArgVarPos},
	"{CurCol}":       ArgVarInfo{"Cursor current column number (starts at 0).", ArgVarPos},
	"{SelStartLine}": ArgVarInfo{"Selection starting line (same as CurLine if no selection).", ArgVarPos},
	"{SelStartCol}":  ArgVarInfo{"Selection starting column (same as CurCol if no selection).", ArgVarPos},
	"{SelEndLine}":   ArgVarInfo{"Selection ending line (same as CurLine if no selection).", ArgVarPos},
	"{SelEndCol}":    ArgVarInfo{"Selection ending column (same as CurCol if no selection).", ArgVarPos},

	"{CurSel}":      ArgVarInfo{"Currently selected text.", ArgVarText},
	"{CurLineText}": ArgVarInfo{"Current line text under cursor.", ArgVarText},
	"{CurWord}":     ArgVarInfo{"Current word under cursor.", ArgVarText},

	"{PromptFilePath}":       ArgVarInfo{"Prompt user for a file, and this is the full path to that file.", ArgVarPrompt},
	"{PromptFileName}":       ArgVarInfo{"Prompt user for a file, and this is the filename (only) of that file.", ArgVarPrompt},
	"{PromptFileDir}":        ArgVarInfo{"Prompt user for a file, and this is the directory name (only) of that file.", ArgVarPrompt},
	"{PromptFileDirPath}":    ArgVarInfo{"Prompt user for a file, and this is the full path to that directory.", ArgVarPrompt},
	"{PromptFileDirProjRel}": ArgVarInfo{"Prompt user for a file, and this is the path of that directory relative to the project root.", ArgVarPrompt},
	"{PromptString1}":        ArgVarInfo{"Prompt user for a string -- this is it.", ArgVarPrompt},
	"{PromptString2}":        ArgVarInfo{"Prompt user for another string -- this is it.", ArgVarPrompt},

Debugging

The debugger (currently only supported for Go) runs through a Debug Tab, which provides full access to the running process information.

  • Debug operates on the current RunExec (the same thing that is Run with that button). It starts by building the executable in debug mode, so you typically have to wait a few secs (in Go) until the status says "Ready".

  • Debug Test operates on the file in the active editor view, to determine the directory to debug tests in.

  • Debug Attach in the Command menu allows you to attach to a running process.

In general, everything works through double-clicking. If you want to move to a different frame in the Stack, double click on it. If you want detail on a specific variable, double-click on it, etc..

Breakpoints

Breakpoints can only be set once the debugger has started

Breakpoints only 'take' when the debugger is Stopped

If you set or modify a breakpoint when the process is running, it will show up in the Breaks list, but that will not reflect the actual set breakpoints until after you hit Stop or it stops on another breakpoint. At which point, you'll likely have to activate any new breakpoints by toggling the On flag. When you do Cont or Step, the breaks will update with more info indicating that they've been set in the debugger.

You set / delete breakpoints in the text editor, by double-clicking on a given line (or via the context menu).

All breakpoints will be auto-deleted when you close the debugger tab to quit a debugging session.

If you toggle a breakpoint On / Off in the Breaks view, that just tells the debugger whether to actually use a given breakpoint, but doesn't officially "delete" it -- it will still show up in the textview. If you want to fully delete it, you can toggle it off in the textview.

Find Frames

Particularly in Go, there can be a large number of Tasks (Go routines), most of which are at runtime.gopark as they wait for one thing or another, making it impossible to see from the Task list where something of interest might be (note: it does already try to avoid showing the runtime frames in the Task list, but that does not guarantee showing the frames of particular interest).

Find Frames, which you access via the context menu on a file you're viewing, will show you exactly those Frames across all the Tasks / Threads that have some stack frame which is in that file. The frames are sorted in order of how close they are to the line you clicked on when you did Find Frames. This makes it very easy to find the frames of interest.

Params

See the Project Prefs for Debug params that control how much detail is returned about variables, and optional args you can pass to the debugger as needed.

Misc

  • When you change the Dark / Light settings, any existing output text in the command output panels will not update. This is because the markup colors are generated when output is generated, whereas the main text editors use standard syntax-based markup and can regenerate this when the theme changes.

Documentation

Overview

Package code provides the main Cogent Code GUI.

Package code implements the Code editor and all the infrastructure and supporting widgets for filetree, commands, console, settings, splitviews, etc.

Index

Constants

View Source 
const (
	FileTreeIndex = iota
	TextEditor1Index
	TextEditor2Index
	TabsIndex
)

These are then the fixed indices of the different elements in the splitview

View Source 
const (
	CmdWait      = true
	CmdNoWait    = false
	CmdFocus     = true
	CmdNoFocus   = false
	CmdConfirm   = true
	CmdNoConfirm = false
)

Use these for more obvious command options

View Source 
const (
	DebugTabConsole = "Console"
	DebugTabBreaks  = "Breaks"
	DebugTabStack   = "Stack"
	DebugTabTasks   = "Tasks"
	DebugTabThreads = "Threads"
	DebugTabVars    = "Vars"
	DebugTabFrames  = "Find Frames"
	DebugTabGlobals = "Global Vars"
)
View Source 
const (
	// move to next panel to the right
	KeyNextPanel keymap.Functions = keymap.FunctionsN + iota

	// move to prev panel to the left
	KeyPrevPanel

	// open a new file in active texteditor
	KeyFileOpen

	// select an open buffer to edit in active texteditor
	KeyBufSelect

	// open active file in other view
	KeyBufClone

	// save active texteditor buffer to its file
	KeyBufSave

	// save as active texteditor buffer to its file
	KeyBufSaveAs

	// close active texteditor buffer
	KeyBufClose

	// execute a command on active texteditor buffer
	KeyExecCmd

	// copy rectangle
	KeyRectCopy

	// cut rectangle
	KeyRectCut

	// paste rectangle
	KeyRectPaste

	// copy selection to named register
	KeyRegCopy

	// paste selection from named register
	KeyRegPaste

	// comment out region
	KeyCommentOut

	// indent region
	KeyIndent

	// jump to line (same as keyfun.Jump)
	KeyJump

	// set named splitter config
	KeySetSplit

	// build overall project
	KeyBuildProject

	// run overall project
	KeyRunProject

	// report problems with open files.
	KeyProblems

	// move to next problem (if problems tab open).
	KeyNextProblem

	// lookup at the cursor: quick fixes if there is an error there,
	// and otherwise completions and go to definition (see [Code.Lookup])
	KeyQuickFix

	// show signature help for the callable at the cursor
	KeySignatureHelp

	// expand the selection to the next larger syntactic element
	KeyExpandSelection

	// shrink the selection to the next smaller syntactic element
	KeyShrinkSelection
)
View Source 
const NTextEditors = 2

NTextEditors is the number of text views to create -- to keep things simple and consistent (e.g., splitter settings always have the same number of values), we fix this degree of freedom, and have flexibility in the splitter settings for what to actually show.

View Source 
const TerminalTabName = "Terminal"

TerminalTabName is the name of the tab of the default terminal.

Variables

View Source 
var (
	// RecentPaths is a slice of recent file paths
	RecentPaths core.FilePaths

	// SavedPathsFilename is the name of the saved file paths file in Cogent Code data directory
	SavedPathsFilename = "saved-paths.json"
)
View Source 
var ArgVars = map[string]ArgVarInfo{

	"{FilePath}":          {"Current file name with full path.", ArgVarFile},
	"{Filename}":          {"Current file name only, without path.", ArgVarFile},
	"{FileExt}":           {"Extension of current file name.", ArgVarExt},
	"{FileExtLC}":         {"Extension of current file name, lowercase.", ArgVarExt},
	"{FilenameNoExt}":     {"Current file name without path and extension.", ArgVarFile},
	"{FileDir}":           {"Name only of current file's directory.", ArgVarDir},
	"{FileDirPath}":       {"Full path to current file's directory.", ArgVarDir},
	"{FileDirProjectRel}": {"Path to current file's directory relative to project root.", ArgVarDir},

	"{ProjectDir}":  {"Current project directory name, without full path.", ArgVarDir},
	"{ProjectPath}": {"Full path to current project directory.", ArgVarDir},

	"{BuildDir}":    {"Full path to BuildDir specified in project prefs -- the default Build.", ArgVarDir},
	"{BuildDirRel}": {"Path to BuildDir relative to project root.", ArgVarDir},

	"{BuildTarg}":           {"Build target specified in prefs BuildTarg, just filename by itself, without path.", ArgVarFile},
	"{BuildTargPath}":       {"Full path to build target specified in prefs BuildTarg.", ArgVarFile},
	"{BuildTargDirPath}":    {"Full path to build target directory, without filename.", ArgVarDir},
	"{BuildTargDirPathRel}": {"Project-relative path to build target directory, without filename.", ArgVarDir},

	"{RunExec}":           {"Run-time executable file RunExec specified in project prefs -- just the raw name of the file, without path.", ArgVarFile},
	"{RunExecPath}":       {"Full path to the run-time executable file RunExec specified in project prefs.", ArgVarFile},
	"{RunExecDirPath}":    {"Full path to the directory of the run-time executable file RunExec specified in project prefs.", ArgVarDir},
	"{RunExecDirPathRel}": {"Project-root relative path to the directory of the run-time executable file RunExec specified in project prefs.", ArgVarDir},

	"{CurLine}":      {"Cursor current line number (starts at 1).", ArgVarPos},
	"{CurCol}":       {"Cursor current column number (starts at 0).", ArgVarPos},
	"{SelStartLine}": {"Selection starting line (same as CurLine if no selection).", ArgVarPos},
	"{SelStartCol}":  {"Selection starting column (same as CurCol if no selection).", ArgVarPos},
	"{SelEndLine}":   {"Selection ending line (same as CurLine if no selection).", ArgVarPos},
	"{SelEndCol}":    {"Selection ending column (same as CurCol if no selection).", ArgVarPos},

	"{CurSel}":      {"Currently selected text.", ArgVarText},
	"{CurLineText}": {"Current line text under cursor.", ArgVarText},
	"{CurWord}":     {"Current word under cursor.", ArgVarText},

	"{PromptFilePath}":          {"Prompt user for a file, and this is the full path to that file.", ArgVarPrompt},
	"{PromptFilename}":          {"Prompt user for a file, and this is the filename (only) of that file.", ArgVarPrompt},
	"{PromptFileDir}":           {"Prompt user for a file, and this is the directory name (only) of that file.", ArgVarPrompt},
	"{PromptFileDirPath}":       {"Prompt user for a file, and this is the full path to that directory.", ArgVarPrompt},
	"{PromptFileDirProjectRel}": {"Prompt user for a file, and this is the path of that directory relative to the project root.", ArgVarPrompt},
	"{PromptString1}":           {"Prompt user for a string -- this is it.", ArgVarPrompt},
	"{PromptString2}":           {"Prompt user for another string -- this is it.", ArgVarPrompt},
	"{PromptBranch}":            {"Prompt user for a VCS branch.", ArgVarPrompt},
}

ArgVars are variables that can be used for arguments to commands in CmdAndArgs

View Source 
var AvailableLanguagesChanged = false

AvailableLanguagesChanged is used to update core.LangsView toolbars via following menu, toolbar properties update methods -- not accurate if editing any other map but works for now..

View Source 
var AvailableRegisterNames []string

AvailableRegisterNames are the names of the current AvailRegisters -- used for some choosers

View Source 
var AvailableRegistersChanged = false

AvailableRegistersChanged is used to update toolbars via following menu, toolbar properties update methods -- not accurate if editing any other map but works for now..

View Source 
var AvailableSplitNames []string

AvailableSplitNames are the names of the current AvailableSplits -- used for some choosers

View Source 
var AvailableSplitsChanged = false

AvailableSplitsChanged is used to update toolbars via following menu, toolbar properties update methods -- not accurate if editing any other map but works for now..

View Source 
var CatNoEdit = map[fileinfo.Known]bool{
	fileinfo.Rtf:          true,
	fileinfo.MSWord:       true,
	fileinfo.OpenText:     true,
	fileinfo.OpenPres:     true,
	fileinfo.MSPowerpoint: true,
	fileinfo.EBook:        true,
	fileinfo.EPub:         true,
}

CatNoEdit are the files to NOT edit from categories: Doc, Data

View Source 
var CmdNoUserPrompt bool

CmdNoUserPrompt can be set to true to prevent user from being prompted for strings this is useful when a custom outer-loop has already set the string values. this will be reset automatically after command is run.

View Source 
var CmdOutStatusLen = 80

CmdOutStatusLen is amount of command output to include in the status update

View Source 
var CmdPrompt1Vals = map[string]string{}

CmdPrompt1Vals holds last values for PromptString1 per command, so that each such command has its own appropriate history

View Source 
var CmdPrompt2Vals = map[string]string{}

CmdPrompt2Vals holds last values for PromptString2 per command, so that each such command has its own appropriate history

View Source 
var CmdWaitOverride bool

CmdWaitOverride will cause the next commands that are run to be in wait mode (sequentially, waiting for completion after each), instead of running each in a separate process as is typical. Don't forget to reset it after commands. This is important when running multiple of the same command, to prevent collisions in the output buffer.

View Source 
var CommandIcons = map[string]icons.Icon{"File": icons.File, "Git": icons.Git, "Build": icons.Build, "Core": icons.CogentCore, "Go": icons.Go}
View Source 
var CommandSettingsFilename = "command-settings.toml"

CommandSettingsFilename is the name of the settings file in the app settings directory for saving / loading your CustomCommands commands list

View Source 
var CustomCommands = Commands{}

CustomCommands is user-specific list of commands saved in settings available for all Code projects. These will override StdCmds with the same names.

View Source 
var CustomCommandsChanged = false

CustomCommandsChanged is used to update core.CmdsView toolbars via following menu, toolbar properties update methods.

View Source 
var (
	// DebugBreakColors are the colors indicating different breakpoint statuses.
	DebugBreakColors = map[DebugBreakStatus]image.Image{
		DebugBreakInactive: colors.Scheme.Warn.Base,
		DebugBreakActive:   colors.Scheme.Error.Base,
		DebugBreakCurrent:  colors.Scheme.Success.Base,
		DebugPCCurrent:     colors.Scheme.Primary.Base,
	}
)
View Source 
var DebugStatusColors = map[cdebug.Status]image.Image{
	cdebug.NotInit:    colors.Scheme.SurfaceContainerHighest,
	cdebug.Error:      colors.Scheme.Error.Container,
	cdebug.Building:   colors.Scheme.Warn.Container,
	cdebug.Ready:      colors.Scheme.Success.Container,
	cdebug.Running:    colors.Scheme.Tertiary.Container,
	cdebug.Stopped:    colors.Scheme.Warn.Container,
	cdebug.Breakpoint: colors.Scheme.Warn.Container,
	cdebug.Finished:   colors.Scheme.SurfaceContainerHighest,
}

DebugStatusColors contains the status colors for different debugging states.

View Source 
var LanguageSettingsFilename = "language-settings.toml"

LanguageSettingsFilename is the name of the settings file in the app settings directory for saving / loading the default AvailableLanguages languages list

View Source 
var RegisterSettingsFilename = "register-settings.toml"

RegisterSettingsFilename is the name of the settings file in the app settings directory for saving / loading the default AvailableRegisters

View Source 
var Settings = &SettingsData{
	Name: "Code",
	File: filepath.Join(core.TheApp.DataDir(), "Cogent Code", "settings.toml"),
}

Settings are the overall Code settings

View Source 
var SplitsSettingsFilename = "splits-settings.json"

SplitsSettingsFilename is the name of the settings file in App prefs directory for saving / loading the default AvailSplits

View Source 
var StandardCommands = Commands{
	{Cat: "Build", Name: "Run Project",
		Desc: "run RunExec executable set in project",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "{RunExecPath}"}},
		Dir:  "{RunExecDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},
	{Cat: "Build", Name: "Run Prompt",
		Desc: "run any command you enter at the prompt",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "{PromptString1}"}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Build", Name: "Make",
		Desc: "run make with no args",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "make"}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Build", Name: "Make Prompt",
		Desc: "run make with prompted make target",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "make",
			Args: []string{"{PromptString1}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "File", Name: "Grep",
		Desc: "recursive grep of all files for prompted value",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "grep",
			Args: []string{"-R", "-e", "{PromptString1}", "{FileDirPath}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "File", Name: "Open",
		Desc: "open file using OS 'open' command",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "open",
			Args: []string{"{FilePath}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "File", Name: "Open Target",
		Desc: "open project target file using OS 'open' command",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "open",
			Args: []string{"{RunExecPath}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Imports File",
		Desc: "run goimports on file",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "goimports",
			Args: []string{"-w", "{FilePath}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Fmt File",
		Desc: "run go fmt on file",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "gofmt",
			Args: []string{"-w", "{FilePath}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Build Dir",
		Desc: "run go build to build in current dir",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args: []string{"build", "-v"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Build Proj",
		Desc: "run go build for project BuildDir",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args: []string{"build", "-v"}}},
		Dir:  "{BuildDir}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Build All",
		Desc: "run go build ./... in current dir",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args: []string{"build", "-v", "./..."}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Install Dir",
		Desc: "run go install in current dir",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args: []string{"install", "-v"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Generate",
		Desc: "run go generate in current dir",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args: []string{"generate"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Test",
		Desc: "run go test in current dir.  Options include: -run TestName or -bench",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args: []string{"test", "-v", "{PromptString1}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Test All",
		Desc: "run go test ./... in current dir. Options include: -run TestName or -bench",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args: []string{"test", "-v", "./...", "{PromptString1}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Vet",
		Desc: "run go vet in current dir",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args: []string{"vet"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Mod Tidy",
		Desc: "run go mod tidy in current dir",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args: []string{"mod", "tidy"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Mod Init",
		Desc: "run go mod init in current dir with module path from prompt",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args: []string{"mod", "init", "{PromptString1}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Get",
		Desc: "run go get on package(s) you enter at prompt",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args: []string{"get", "{PromptString1}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Go", Name: "Get Update",
		Desc: "run go get -u (update) on package(s) you enter at prompt.  use ./... for all.",
		Lang: fileinfo.Go,
		Cmds: []CmdAndArgs{{Cmd: "go",
			Args:    []string{"get", "-u", "{PromptString1}"},
			Default: "./..."}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Add",
		Desc: "git add file",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args: []string{"add", "{FilePath}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Switch To Branch",
		Desc: "git switch to an existing branch",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args: []string{"switch", "{PromptBranch}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Switch",
		Desc: "git switch to new branch or existing commit: -c or -C (force) <branch> to create new; --detach <commit> to switch to older (non-HEAD) commit; --orphan to abandon history",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args:    []string{"switch", "{PromptString1}"},
			Default: "-c "}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Restore",
		Desc: "git restore: file, directory -- undoes any current changes and restores from last commit; -s option specifies source -- also available as revert in file picker",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args: []string{"restore", "{PromptString1}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Checkout",
		Desc: "git checkout: file, directory, branch; -b <branch> creates a new branch",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args: []string{"checkout", "{PromptString1}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Status",
		Desc: "git status",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args: []string{"status"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Diff",
		Desc: "git diff -- see changes since last checkin",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args: []string{"diff", "{PromptString1}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm, Hilight: fileinfo.Diff},

	{Cat: "Git", Name: "Log",
		Desc: "git log",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args: []string{"log"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Commit",
		Desc: "git commit",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args: []string{"commit", "-am", "{PromptString1}"}, PromptIsString: true}},
		Dir:  "{FileDirPath}",
		Wait: CmdWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Pull Branch",
		Desc: "git pull from existing branch",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args: []string{"pull", "origin", "{PromptBranch}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Pull",
		Desc: "git pull",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args:    []string{"pull", "{PromptString1}"},
			Default: "origin"}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Push",
		Desc: "git push to update remote (origin) for given branch",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args:    []string{"push", "origin", "{PromptBranch}"},
			Default: "origin"}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Push Force",
		Desc: "git push to update remote (origin) for given branch -- force -- needed for example after rebase or merge with conflicts",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args:    []string{"push", "--force", "origin", "{PromptBranch}"},
			Default: "origin"}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Stash",
		Desc: "git stash: push / pop local changes for later without committing, resetting to HEAD: also list, show, drop, clear",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args:    []string{"stash", "{PromptString1}"},
			Default: "push"}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Branch",
		Desc: "git branch: -a shows all; --list shows local; <branchname> makes a new one, optionally given sha; -d to delete; -r delete remote; -D force delete",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args:    []string{"branch", "{PromptString1}"},
			Default: "-a"}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Branch Delete",
		Desc: "git branch -d -r selected branch name",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args: []string{"branch", "-d", "-r", "{PromptBranch}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Rebase",
		Desc: "git rebase: updates current branch to given branch, often master",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args:    []string{"rebase", "{PromptBranch}"},
			Default: "master"}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Rebase Continue",
		Desc: "git rebase: updates current branch to given branch, often master -- does --continue to continue process",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args: []string{"rebase", "--continue"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Reset",
		Desc: "git reset: resets current state to given source -- use --hard to override -- CAN RESULT IN LOSS OF CHANGES -- make sure everything is committed",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args:    []string{"reset", "{PromptString1}"},
			Default: "--hard origin/master"}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Remote",
		Desc: "git remote: prune origin = remove stale branches; show; add <name> <URL>; remove <name>; get-url / set-url <name>",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "git",
			Args:    []string{"remote", "{PromptString1}"},
			Default: "prune origin"}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Git", Name: "Count LOC",
		Desc: "runs bash -c git ls-files with command sequence that counts lines of code in git repository -- edit with extra | grep steps to filter accordingly",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "bash",
			Args:    []string{"-c", "{PromptString1}"},
			Default: `"git ls-files | xargs wc -l"`}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Svn", Name: "Add",
		Desc: "svn add file",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "svn",
			Args: []string{"add", "{FilePath}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Svn", Name: "Status",
		Desc: "svn status",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "svn",
			Args: []string{"status"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Svn", Name: "Info",
		Desc: "svn info",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "svn",
			Args: []string{"info"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Svn", Name: "Log",
		Desc: "svn log",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "svn",
			Args: []string{"log", "-v"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Svn", Name: "Commit Project",
		Desc: "svn commit for entire project directory",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "svn",
			Args: []string{"commit", "-m", "{PromptString1}"}, PromptIsString: true}},
		Dir:  "{ProjectPath}",
		Wait: CmdWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Svn", Name: "Commit Dir",
		Desc: "svn commit in directory of current file",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "svn",
			Args: []string{"commit", "-m", "{PromptString1}"}, PromptIsString: true}},
		Dir:  "{FileDirPath}",
		Wait: CmdWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Svn", Name: "Update",
		Desc: "svn update",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "svn",
			Args: []string{"update"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "LaTeX", Name: "LaTeX PDF",
		Desc: "run PDFLaTeX on file",
		Lang: fileinfo.TeX,
		Cmds: []CmdAndArgs{{Cmd: "pdflatex",
			Args: []string{"-file-line-error", "-interaction=nonstopmode", "{FilePath}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "LaTeX", Name: "BibTeX",
		Desc: "run BibTeX on file",
		Lang: fileinfo.TeX,
		Cmds: []CmdAndArgs{{Cmd: "bibtex",
			Args: []string{"{FilenameNoExt}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "LaTeX", Name: "Biber",
		Desc: "run Biber on file",
		Lang: fileinfo.TeX,
		Cmds: []CmdAndArgs{{Cmd: "biber",
			Args: []string{"{FilenameNoExt}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "LaTeX", Name: "CleanTeX",
		Desc: "remove aux LaTeX files",
		Lang: fileinfo.TeX,
		Cmds: []CmdAndArgs{{Cmd: "rm",
			Args: []string{"*.aux", "*.log", "*.blg", "*.bbl", "*.fff", "*.lof", "*.ttt", "*.toc", "*.spl"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Core", Name: "Run",
		Desc: "Builds and runs go executable in current directory: core run [ios | android | web | darwin | windows | linux]",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "core",
			Args: []string{"run", "{PromptString1}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Core", Name: "Install",
		Desc: "Installs go executable in current directory: core install -t [ios | android | web | darwin | windows | linux]",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "core",
			Args: []string{"install", "{PromptString1}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Core", Name: "Next-Release",
		Desc: "increments the patch-level version number and pushes a release tag at this new version",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "core",
			Args: []string{"next-release"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdConfirm},

	{Cat: "Core", Name: "Release",
		Desc: "sets the version to the given value at the prompt and pushes a release tag at this version",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "core",
			Args: []string{"release", "{PromptString1}"}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Core", Name: "Generate All",
		Desc: "runs core generate ./... to update all generated files in current dir and below",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "core",
			Args: []string{"generate", "./..."}}},
		Dir:  "{FileDirPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Core", Name: "Changed",
		Desc: "show which packages are changed, at the root project level",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "core",
			Args: []string{"changed"}}},
		Dir:  "{ProjectPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},

	{Cat: "Core", Name: "Pull",
		Desc: "pull all packages at the root project level",
		Lang: fileinfo.Any,
		Cmds: []CmdAndArgs{{Cmd: "core",
			Args: []string{"pull"}}},
		Dir:  "{ProjectPath}",
		Wait: CmdNoWait, Focus: CmdNoFocus, Confirm: CmdNoConfirm},
}

StandardCommands is the original compiled-in set of standard commands.

View Source 
var StandardIgnoreProblems = []string{
	"struct literal uses unkeyed fields",
	"copies lock value",
	"passes lock by value",
	"non-constant format string",
	"error strings should not be capitalized",
	"error strings should not end with punctuation",
	"should not use dot imports",
	"methods on the same type should have the same receiver name",
	"receiver name should be",
	"could use tagged switch",
	"could remove embedded field",
	"should merge variable declaration with assignment",
	"unused parameter",

	"can be modernized",
	"interface{} can be replaced by any",
	"can be simplified using",
	"ReplaceAll instead",
	"could apply De Morgan's law",
	"could lift into loop condition",
	"could merge conditional assignment",
	"could eliminate this type assertion",
}

StandardIgnoreProblems are commonly ignored Go warnings, which are added to ProjectSettings.IgnoreProblems, disabled, so that they are easy to enable.

View Source 
var StandardKeyMaps = keymap.Maps{
	{"MacStandard", "Standard Mac KeyMap", keymap.Map{
		"Control+Tab":             KeyNextPanel,
		"Control+Shift+Tab":       KeyPrevPanel,
		"Control+X o":             KeyNextPanel,
		"Control+X Control+O":     KeyNextPanel,
		"Control+X p":             KeyPrevPanel,
		"Control+X Control+P":     KeyPrevPanel,
		"Control+X f":             KeyFileOpen,
		"Control+X Control+F":     KeyFileOpen,
		"Control+X b":             KeyBufSelect,
		"Control+X Control+B":     KeyBufSelect,
		"Control+X s":             KeyBufSave,
		"Control+X Control+S":     KeyBufSave,
		"Control+X w":             KeyBufSaveAs,
		"Control+X Control+W":     KeyBufSaveAs,
		"Control+X k":             KeyBufClose,
		"Control+X Control+K":     KeyBufClose,
		"Control+X c":             KeyExecCmd,
		"Control+X Control+C":     KeyExecCmd,
		"Control+C c":             KeyExecCmd,
		"Control+C Control+C":     KeyExecCmd,
		"Control+C o":             KeyBufClone,
		"Control+C Control+O":     KeyBufClone,
		"Control+C p":             KeyProblems,
		"Control+C Control+P":     KeyProblems,
		"Control+C n":             KeyNextProblem,
		"Control+C Control+N":     KeyNextProblem,
		"Control+X x":             KeyRegCopy,
		"Control+X g":             KeyRegPaste,
		"Control+X Control+X":     KeyRectCut,
		"Control+X Control+Y":     KeyRectPaste,
		"Control+X Alt+∑":         KeyRectCopy,
		"Control+C k":             KeyCommentOut,
		"Control+C Control+K":     KeyCommentOut,
		"Control+X i":             KeyIndent,
		"Control+X Control+I":     KeyIndent,
		"Control+X j":             KeyJump,
		"Control+X Control+J":     KeyJump,
		"Control+X v":             KeySetSplit,
		"Control+X Control+V":     KeySetSplit,
		"Control+X m":             KeyBuildProject,
		"Control+X Control+M":     KeyBuildProject,
		"Control+X r":             KeyRunProject,
		"Control+X Control+R":     KeyRunProject,
		"Control+.":               KeyQuickFix,
		"Control+Shift+Space":     KeySignatureHelp,
		"Control+Shift+UpArrow":   KeyExpandSelection,
		"Control+Shift+DownArrow": KeyShrinkSelection,
	}},
	{"MacEmacs", "Mac with emacs-style navigation -- emacs wins in conflicts", keymap.Map{
		"Control+Tab":             KeyNextPanel,
		"Control+Shift+Tab":       KeyPrevPanel,
		"Control+X o":             KeyNextPanel,
		"Control+X Control+O":     KeyNextPanel,
		"Control+X p":             KeyPrevPanel,
		"Control+X Control+P":     KeyPrevPanel,
		"Control+X f":             KeyFileOpen,
		"Control+X Control+F":     KeyFileOpen,
		"Control+X b":             KeyBufSelect,
		"Control+X Control+B":     KeyBufSelect,
		"Control+X s":             KeyBufSave,
		"Control+X Control+S":     KeyBufSave,
		"Control+X w":             KeyBufSaveAs,
		"Control+X Control+W":     KeyBufSaveAs,
		"Control+X k":             KeyBufClose,
		"Control+X Control+K":     KeyBufClose,
		"Control+X c":             KeyExecCmd,
		"Control+X Control+C":     KeyExecCmd,
		"Control+C c":             KeyExecCmd,
		"Control+C Control+C":     KeyExecCmd,
		"Control+C o":             KeyBufClone,
		"Control+C Control+O":     KeyBufClone,
		"Control+C p":             KeyProblems,
		"Control+C Control+P":     KeyProblems,
		"Control+C n":             KeyNextProblem,
		"Control+C Control+N":     KeyNextProblem,
		"Control+X x":             KeyRegCopy,
		"Control+X g":             KeyRegPaste,
		"Control+X Control+X":     KeyRectCut,
		"Control+X Control+Y":     KeyRectPaste,
		"Control+X Alt+∑":         KeyRectCopy,
		"Control+C k":             KeyCommentOut,
		"Control+C Control+K":     KeyCommentOut,
		"Control+X i":             KeyIndent,
		"Control+X Control+I":     KeyIndent,
		"Control+X j":             KeyJump,
		"Control+X Control+J":     KeyJump,
		"Control+X v":             KeySetSplit,
		"Control+X Control+V":     KeySetSplit,
		"Control+X m":             KeyBuildProject,
		"Control+X Control+M":     KeyBuildProject,
		"Control+X r":             KeyRunProject,
		"Control+X Control+R":     KeyRunProject,
		"Control+.":               KeyQuickFix,
		"Control+Shift+Space":     KeySignatureHelp,
		"Control+Shift+UpArrow":   KeyExpandSelection,
		"Control+Shift+DownArrow": KeyShrinkSelection,
	}},
	{"LinuxEmacs", "Linux with emacs-style navigation -- emacs wins in conflicts", keymap.Map{
		"Control+Tab":             KeyNextPanel,
		"Control+Shift+Tab":       KeyPrevPanel,
		"Control+X o":             KeyNextPanel,
		"Control+X Control+O":     KeyNextPanel,
		"Control+X p":             KeyPrevPanel,
		"Control+X Control+P":     KeyPrevPanel,
		"Control+X f":             KeyFileOpen,
		"Control+X Control+F":     KeyFileOpen,
		"Control+X b":             KeyBufSelect,
		"Control+X Control+B":     KeyBufSelect,
		"Control+X s":             KeyBufSave,
		"Control+X Control+S":     KeyBufSave,
		"Control+X w":             KeyBufSaveAs,
		"Control+X Control+W":     KeyBufSaveAs,
		"Control+X k":             KeyBufClose,
		"Control+X Control+K":     KeyBufClose,
		"Control+X c":             KeyExecCmd,
		"Control+X Control+C":     KeyExecCmd,
		"Control+C c":             KeyExecCmd,
		"Control+C Control+C":     KeyExecCmd,
		"Control+C o":             KeyBufClone,
		"Control+C Control+O":     KeyBufClone,
		"Control+C p":             KeyProblems,
		"Control+C Control+P":     KeyProblems,
		"Control+C n":             KeyNextProblem,
		"Control+C Control+N":     KeyNextProblem,
		"Control+X x":             KeyRegCopy,
		"Control+X g":             KeyRegPaste,
		"Control+X Control+X":     KeyRectCut,
		"Control+X Control+Y":     KeyRectPaste,
		"Control+X Alt+∑":         KeyRectCopy,
		"Control+C k":             KeyCommentOut,
		"Control+C Control+K":     KeyCommentOut,
		"Control+X i":             KeyIndent,
		"Control+X Control+I":     KeyIndent,
		"Control+X j":             KeyJump,
		"Control+X Control+J":     KeyJump,
		"Control+X v":             KeySetSplit,
		"Control+X Control+V":     KeySetSplit,
		"Control+X m":             KeyBuildProject,
		"Control+X Control+M":     KeyBuildProject,
		"Control+X r":             KeyRunProject,
		"Control+X Control+R":     KeyRunProject,
		"Control+.":               KeyQuickFix,
		"Control+Shift+Space":     KeySignatureHelp,
		"Control+Shift+UpArrow":   KeyExpandSelection,
		"Control+Shift+DownArrow": KeyShrinkSelection,
	}},
	{"LinuxStandard", "Standard Linux key map", keymap.Map{
		"Control+Tab":             KeyNextPanel,
		"Control+Shift+Tab":       KeyPrevPanel,
		"Control+E o":             KeyNextPanel,
		"Control+E Control+O":     KeyNextPanel,
		"Control+E p":             KeyPrevPanel,
		"Control+E Control+P":     KeyPrevPanel,
		"Control+O":               KeyFileOpen,
		"Control+E f":             KeyFileOpen,
		"Control+E Control+F":     KeyFileOpen,
		"Control+E b":             KeyBufSelect,
		"Control+E Control+B":     KeyBufSelect,
		"Control+S":               KeyBufSave,
		"Control+Shift+S":         KeyBufSaveAs,
		"Control+E s":             KeyBufSave,
		"Control+E Control+S":     KeyBufSave,
		"Control+E w":             KeyBufSaveAs,
		"Control+E Control+W":     KeyBufSaveAs,
		"Control+E k":             KeyBufClose,
		"Control+E Control+K":     KeyBufClose,
		"Control+B c":             KeyExecCmd,
		"Control+B Control+C":     KeyExecCmd,
		"Control+B o":             KeyBufClone,
		"Control+B Control+O":     KeyBufClone,
		"Control+B p":             KeyProblems,
		"Control+B Control+P":     KeyProblems,
		"Control+B n":             KeyNextProblem,
		"Control+B Control+N":     KeyNextProblem,
		"Control+E x":             KeyRegCopy,
		"Control+E g":             KeyRegPaste,
		"Control+E Control+X":     KeyRectCut,
		"Control+E Control+Y":     KeyRectPaste,
		"Control+E Alt+∑":         KeyRectCopy,
		"Control+/":               KeyCommentOut,
		"Control+B k":             KeyCommentOut,
		"Control+B Control+K":     KeyCommentOut,
		"Control+E i":             KeyIndent,
		"Control+E Control+I":     KeyIndent,
		"Control+E j":             KeyJump,
		"Control+E Control+J":     KeyJump,
		"Control+E v":             KeySetSplit,
		"Control+E Control+V":     KeySetSplit,
		"Control+E m":             KeyBuildProject,
		"Control+E Control+M":     KeyBuildProject,
		"Control+E r":             KeyRunProject,
		"Control+E Control+R":     KeyRunProject,
		"Control+.":               KeyQuickFix,
		"Control+Shift+Space":     KeySignatureHelp,
		"Control+Shift+UpArrow":   KeyExpandSelection,
		"Control+Shift+DownArrow": KeyShrinkSelection,
	}},
	{"WindowsStandard", "Standard Windows key map", keymap.Map{
		"Control+Tab":             KeyNextPanel,
		"Control+Shift+Tab":       KeyPrevPanel,
		"Control+E o":             KeyNextPanel,
		"Control+E Control+O":     KeyNextPanel,
		"Control+E p":             KeyPrevPanel,
		"Control+E Control+P":     KeyPrevPanel,
		"Control+O":               KeyFileOpen,
		"Control+E f":             KeyFileOpen,
		"Control+E Control+F":     KeyFileOpen,
		"Control+E b":             KeyBufSelect,
		"Control+E Control+B":     KeyBufSelect,
		"Control+S":               KeyBufSave,
		"Control+Shift+S":         KeyBufSaveAs,
		"Control+E s":             KeyBufSave,
		"Control+E Control+S":     KeyBufSave,
		"Control+E w":             KeyBufSaveAs,
		"Control+E Control+W":     KeyBufSaveAs,
		"Control+E k":             KeyBufClose,
		"Control+E Control+K":     KeyBufClose,
		"Control+B c":             KeyExecCmd,
		"Control+B Control+C":     KeyExecCmd,
		"Control+B o":             KeyBufClone,
		"Control+B Control+O":     KeyBufClone,
		"Control+B p":             KeyProblems,
		"Control+B Control+P":     KeyProblems,
		"Control+B n":             KeyNextProblem,
		"Control+B Control+N":     KeyNextProblem,
		"Control+E x":             KeyRegCopy,
		"Control+E g":             KeyRegPaste,
		"Control+E Control+X":     KeyRectCut,
		"Control+E Control+Y":     KeyRectPaste,
		"Control+E Alt+∑":         KeyRectCopy,
		"Control+/":               KeyCommentOut,
		"Control+B k":             KeyCommentOut,
		"Control+B Control+K":     KeyCommentOut,
		"Control+E i":             KeyIndent,
		"Control+E Control+I":     KeyIndent,
		"Control+E j":             KeyJump,
		"Control+E Control+J":     KeyJump,
		"Control+E v":             KeySetSplit,
		"Control+E Control+V":     KeySetSplit,
		"Control+E m":             KeyBuildProject,
		"Control+E Control+M":     KeyBuildProject,
		"Control+E r":             KeyRunProject,
		"Control+E Control+R":     KeyRunProject,
		"Control+.":               KeyQuickFix,
		"Control+Shift+Space":     KeySignatureHelp,
		"Control+Shift+UpArrow":   KeyExpandSelection,
		"Control+Shift+DownArrow": KeyShrinkSelection,
	}},
	{"ChromeStd", "Standard chrome-browser and linux-under-chrome bindings", keymap.Map{
		"Control+Tab":             KeyNextPanel,
		"Control+Shift+Tab":       KeyPrevPanel,
		"Control+E o":             KeyNextPanel,
		"Control+E Control+O":     KeyNextPanel,
		"Control+E p":             KeyPrevPanel,
		"Control+E Control+P":     KeyPrevPanel,
		"Control+O":               KeyFileOpen,
		"Control+E f":             KeyFileOpen,
		"Control+E Control+F":     KeyFileOpen,
		"Control+E b":             KeyBufSelect,
		"Control+E Control+B":     KeyBufSelect,
		"Control+S":               KeyBufSave,
		"Control+Shift+S":         KeyBufSaveAs,
		"Control+E s":             KeyBufSave,
		"Control+E Control+S":     KeyBufSave,
		"Control+E w":             KeyBufSaveAs,
		"Control+E Control+W":     KeyBufSaveAs,
		"Control+E k":             KeyBufClose,
		"Control+E Control+K":     KeyBufClose,
		"Control+B c":             KeyExecCmd,
		"Control+B Control+C":     KeyExecCmd,
		"Control+B o":             KeyBufClone,
		"Control+B Control+O":     KeyBufClone,
		"Control+B p":             KeyProblems,
		"Control+B Control+P":     KeyProblems,
		"Control+B n":             KeyNextProblem,
		"Control+B Control+N":     KeyNextProblem,
		"Control+E x":             KeyRegCopy,
		"Control+E g":             KeyRegPaste,
		"Control+E Control+X":     KeyRectCut,
		"Control+E Control+Y":     KeyRectPaste,
		"Control+E Alt+∑":         KeyRectCopy,
		"Control+/":               KeyCommentOut,
		"Control+B k":             KeyCommentOut,
		"Control+B Control+K":     KeyCommentOut,
		"Control+E i":             KeyIndent,
		"Control+E Control+I":     KeyIndent,
		"Control+E j":             KeyJump,
		"Control+E Control+J":     KeyJump,
		"Control+E v":             KeySetSplit,
		"Control+E Control+V":     KeySetSplit,
		"Control+E m":             KeyBuildProject,
		"Control+E Control+M":     KeyBuildProject,
		"Control+E r":             KeyRunProject,
		"Control+E Control+R":     KeyRunProject,
		"Control+.":               KeyQuickFix,
		"Control+Shift+Space":     KeySignatureHelp,
		"Control+Shift+UpArrow":   KeyExpandSelection,
		"Control+Shift+DownArrow": KeyShrinkSelection,
	}},
}

StandardKeyMaps are the standard extended maps for Code

View Source 
var StandardLanguages = Languages{
	fileinfo.Go:       {PostSaveCmds: CmdNames{"Go: Imports File"}},
	fileinfo.Markdown: {Parser: true},
	fileinfo.TeX:      {Parser: true},
}

StandardLanguages is the original compiled-in set of standard language options.

View Source 
var StandardSplits = Splits{
	{"Compact", "2 text views, tabs under", [4]float32{.2, .5, .5, .3}, true},
	{"Wide", "2 text views, tabs, in a row", [4]float32{.1, .325, .325, .25}, false},
	{"Small", "1 text view, tabs", [4]float32{.2, 1, 0, .3}, true},
	{"BigTabs", "1 text view, big tabs", [4]float32{.1, .3, 0, .6}, false},
	{"Debug", "bigger command panel for debugging", [4]float32{0.1, 0.3, 0.3, 0.3}, false},
}

StandardSplits is the original compiled-in set of standard named splits.

Functions

func ArgVarKeys 

func ArgVarKeys() []string

ArgVarKeys creates a slice of string to hold the keys

func ArgVarPrompts 

func ArgVarPrompts(arg string) (map[string]struct{}, bool)

ArgVarPrompts returns any Prompt* variables required by this string, false if none

func CheckForProjectAtPath 

func CheckForProjectAtPath(path string) (string, bool)

CheckForProjectAtPath checks if there is a .code project at the given path returns project path and true if found, otherwise false

func CmdsView 

func CmdsView(pt *Commands)

CmdsView opens a view of a commands table

func CommandName 

func CommandName(cat, cmd string) string

CommandName returns a qualified command name as cat: cmd

func ConfigOutputTextEditor 

func ConfigOutputTextEditor(ed *textcore.Editor)

ConfigOutputTextEditor configures a command-output texteditor within given parent layout

func DebugSettingsEditor 

func DebugSettingsEditor(pf *cdebug.Params) *core.Form

DebugSettingsEditor opens a view of project Debug settings, returns form if not already open

func ExecCmds 

func ExecCmds(cv *Code) [][]string

ExecCmds gets list of available commands for current active file

func GetVCSRepo added in v0.1.1 

func GetVCSRepo(obj any) vcs.Repo

GetVCSRepo returns vcs.Repo from given object's metadata. Returns nil if none or no metadata.

func LangSymbolToSyms added in v0.2.0 

func LangSymbolToSyms(sy lang.Symbol) syms.Symbol

LangSymbolToSyms converts a lang.Symbol to the syms.Symbol representation used by the symbols panels, recursively.

func LanguagesView 

func LanguagesView(pt *Languages)

LanguagesView opens a view of a languages options map

func MarkupCmdOutput 

func MarkupCmdOutput(buf *lines.Lines, out []rune, lexName string) rich.Text

MarkupCmdOutput applies links to the first element in command output line if it looks like a file name / position, and runs markup using given lexer name if provided (default is "bash")

func MarkupStderr 

func MarkupStderr(buf *lines.Lines, out []rune) rich.Text

func MarkupStdout 

func MarkupStdout(buf *lines.Lines, out []rune) rich.Text

func MergeAvailableCmds 

func MergeAvailableCmds()

MergeAvailableCmds updates the AvailCmds list from CustomCmds and StdCmds

func NewDebugger 

func NewDebugger(sup fileinfo.Known, path, rootPath string, outbuf *lines.Lines, pars *cdebug.Params) (cdebug.GiDebug, error)

NewDebugger returns a new debugger for given supported file type

func OpenPaths 

func OpenPaths()

OpenPaths loads the active SavedPaths from settings dir

func ProjectPathParse 

func ProjectPathParse(path string) (root, projnm, fnm string, ok bool)

ProjectPathParse parses given project path into a root directory (which could be the path or just the directory portion of the path, depending in whether the path is a directory or not), and a bool if all is good (otherwise error message has been reported). projnm is always the last directory of the path.

func ProjectSettingsEditor 

func ProjectSettingsEditor(pf *ProjectSettings) *core.Form

ProjectSettingsEditor opens a view of project settings, returns form if not already open

func RegistersMenu 

func RegistersMenu(ctx core.Widget, curVal string, fun func(regNm string))

RegistersMenu presents a menu of existing registers, calling the given function with the selected register name

func RegistersView 

func RegistersView(pt *Registers)

RegistersView opens a view of a commands table

func RepoCurBranches 

func RepoCurBranches(repo vcs.Repo) (string, []string, error)

RepoCurBranches returns the current branch and a list of all branches ensuring that the current also appears on the list of all. In git, a new branch may not so appear.

func SavePaths 

func SavePaths()

SavePaths saves the active SavedPaths to settings dir

func SelectSymbol 

func SelectSymbol(cv *Code, ssym syms.Symbol)

func SetGoMod 

func SetGoMod(gomod bool)

SetGoMod applies the given gomod setting, setting the GO111MODULE env var

func SetVCSRepo added in v0.1.1 

func SetVCSRepo(obj any, repo vcs.Repo)

SetVCSRepo sets a pointer to the vcs.Repo into given object's metadata, used on Lines.

func SplitsView 

func SplitsView(pt *Splits)

SplitsView opens a view of a splits table

func UpdateParserUse added in v0.2.0 

func UpdateParserUse(cvs ...*Code)

UpdateParserUse applies changes in the use of the built-in parser, from the language backend of the projects and the Parser language options, to the files open in all Code windows. Any given Code windows are included even if they are not yet in core.AllRenderWindows.

Types

type ArgVarInfo 

type ArgVarInfo struct {

	// description of arg var
	Desc string

	// type of variable -- used for checking usage and other special features such as prompting
	Type ArgVarTypes
}

ArgVarInfo has info about argument variables that fill in relevant values for commands, used in ArgVars list of variables

type ArgVarTypes 

type ArgVarTypes int32 //enums:enum -trim-prefix ArgVar

ArgVarTypes describe the type of information in the arg var -- used for checking usage and special features. 

const (
	// ArgVarFile is a file name, not a directory
	ArgVarFile ArgVarTypes = iota

	// ArgVarDir is a directory name, not a file
	ArgVarDir

	// ArgVarExt is a file extension
	ArgVarExt

	// ArgVarPos is a text position
	ArgVarPos

	// ArgVarText is text from a buffer
	ArgVarText

	// ArgVarPrompt is a user-prompted variable
	ArgVarPrompt
)
const ArgVarTypesN ArgVarTypes = 6

ArgVarTypesN is the highest valid value for type ArgVarTypes, plus one.

func ArgVarTypesValues 

func ArgVarTypesValues() []ArgVarTypes

ArgVarTypesValues returns all possible values for the type ArgVarTypes.

func (ArgVarTypes) Desc 

func (i ArgVarTypes) Desc() string

Desc returns the description of the ArgVarTypes value.

func (ArgVarTypes) Int64 

func (i ArgVarTypes) Int64() int64

Int64 returns the ArgVarTypes value as an int64.

func (ArgVarTypes) MarshalText 

func (i ArgVarTypes) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface.

func (*ArgVarTypes) SetInt64 

func (i *ArgVarTypes) SetInt64(in int64)

SetInt64 sets the ArgVarTypes value from an int64.

func (*ArgVarTypes) SetString 

func (i *ArgVarTypes) SetString(s string) error

SetString sets the ArgVarTypes value from its string representation, and returns an error if the string is invalid.

func (ArgVarTypes) String 

func (i ArgVarTypes) String() string

String returns the string representation of this ArgVarTypes value.

func (*ArgVarTypes) UnmarshalText 

func (i *ArgVarTypes) UnmarshalText(text []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface.

func (ArgVarTypes) Values 

func (i ArgVarTypes) Values() []enums.Enum

Values returns all possible values for the type ArgVarTypes.

type ArgVarVals 

type ArgVarVals map[string]string

ArgVarVals are current values of arg var vals -- updated on demand when a command is invoked

func (*ArgVarVals) Bind 

func (avp *ArgVarVals) Bind(arg string) string

Bind replaces the variables in the given arg string with their values

func (*ArgVarVals) Set 

func (avp *ArgVarVals) Set(fpath string, ppref *ProjectSettings, tv *textcore.Editor)

Set sets the current values for arg variables -- prompts must be already set!

type CmdAndArgs 

type CmdAndArgs struct {

	// external program to execute -- must be on path or have full path specified -- use {RunExec} for the project RunExec executable.
	Cmd string `width:"25"`

	// args to pass to the program, one string per arg.
	// Use {Filename} etc to refer to special variables.
	// Use backslash-quoted bracket to insert a literal curly bracket.
	// Use unix-standard path separators (/); they will be replaced with
	// proper os-specific path separator on Windows.
	Args CmdArgs `width:"25"`

	// default value for prompt string, for first use -- thereafter it uses last value provided for given command
	Default string `width:"25"`

	// if true, then do not split any prompted string into separate space-separated fields -- otherwise do so, except for values within quotes
	PromptIsString bool
}

CmdAndArgs contains the name of an external program to execute and args to pass to that program

func (*CmdAndArgs) BindArgs 

func (cm *CmdAndArgs) BindArgs(avp *ArgVarVals) []string

BindArgs replaces any variables in the args with their values, and returns resulting args

func (*CmdAndArgs) HasPrompts 

func (cm *CmdAndArgs) HasPrompts() (map[string]struct{}, bool)

HasPrompts returns true if any prompts are required before running command, and the set of such args

func (CmdAndArgs) Label 

func (cm CmdAndArgs) Label() string

Label satisfies the Labeler interface

func (*CmdAndArgs) PrepCmd 

func (cm *CmdAndArgs) PrepCmd(avp *ArgVarVals) (*exec.Cmd, string)

PrepCmd prepares to run command, returning *exec.Cmd and a string of the full command

type CmdArgs 

type CmdArgs []string

CmdArgs is a slice of arguments for a command

type CmdButton 

type CmdButton struct {
	core.Button
}

CmdButton represents a CmdName value with a button that opens a [CmdView].

func NewCmdButton 

func NewCmdButton(parent ...tree.Node) *CmdButton

NewCmdButton returns a new CmdButton with the given optional parent: CmdButton represents a CmdName value with a button that opens a [CmdView].

func (*CmdButton) Init 

func (cb *CmdButton) Init()

func (*CmdButton) WidgetValue 

func (cb *CmdButton) WidgetValue() any

type CmdName 

type CmdName string

CmdName has an associated ValueView for selecting from the list of available command names, for use in settings etc. Formatted as Cat: Name as in Command.Label()

func (CmdName) Command 

func (cn CmdName) Command() (*Command, bool)

Command returns command associated with command name in AvailCmds, and false if it doesn't exist

func (CmdName) IsValid 

func (cn CmdName) IsValid() bool

IsValid checks if command name exists on AvailCmds list

func (CmdName) Widget added in v0.1.3 

func (cn CmdName) Widget() core.Value

type CmdNames 

type CmdNames []CmdName

CmdNames is a slice of command names

func (*CmdNames) Add 

func (cn *CmdNames) Add(cmd CmdName)

Add adds a name to the list

type CmdRun 

type CmdRun struct {

	// Name of command being run -- same as Command.Name
	Name string

	// command string
	CmdStr string

	// Details of the command and args
	CmdArgs *CmdAndArgs

	// exec.Cmd for the command
	Exec *exec.Cmd
}

CmdRun tracks running commands

func (*CmdRun) Kill 

func (cm *CmdRun) Kill()

Kill kills the process

type CmdRuns 

type CmdRuns []*CmdRun

CmdRuns is a slice list of running commands

func (*CmdRuns) Add 

func (rc *CmdRuns) Add(cm *CmdRun)

Add adds a new running command

func (*CmdRuns) AddCmd 

func (rc *CmdRuns) AddCmd(name, cmdstr string, cmdargs *CmdAndArgs, ex *exec.Cmd)

AddCmd adds a new running command, creating CmdRun via args

func (*CmdRuns) ByName 

func (rc *CmdRuns) ByName(name string) (*CmdRun, int)

ByName returns command with given name

func (*CmdRuns) DeleteByName 

func (rc *CmdRuns) DeleteByName(name string) bool

DeleteByName deletes command by name

func (*CmdRuns) DeleteIndex 

func (rc *CmdRuns) DeleteIndex(idx int)

DeleteIndex delete command at given index

func (*CmdRuns) KillByName 

func (rc *CmdRuns) KillByName(name string) bool

KillByName kills a running process by name, and removes it from the list of running commands

type Code 

type Code struct {
	core.Frame

	// root directory for the project -- all projects must be organized within a top-level root directory, with all the files therein constituting the scope of the project -- by default it is the path for ProjectFilename
	ProjectRoot core.Filename

	// current project filename for saving / loading specific Code configuration information in a .code file (optional)
	ProjectFilename core.Filename `extension:".code"`

	// filename of the currently active texteditor
	ActiveFilename core.Filename `set:"-"`

	// language for current active filename
	ActiveLang fileinfo.Known

	// VCS repo for current active filename
	ActiveVCS vcs.Repo `set:"-"`

	// VCS info for current active filename (typically branch or revision) -- for status
	ActiveVCSInfo string `set:"-"`

	// has the root changed?  we receive update signals from root for changes
	Changed bool `set:"-" json:"-"`

	// the last status update message
	StatusMessage string

	// timestamp for when a file was last saved -- provides dirty state for various updates including rebuilding in debugger
	LastSaveTStamp time.Time `set:"-" json:"-"`

	// all the files in the project directory and subdirectories
	Files *filetree.Tree `set:"-" json:"-"`

	// index of the currently active texteditor -- new files will be viewed in other views if available
	ActiveEditorIndex int `set:"-" json:"-"`

	// list of open files, most recent first
	OpenFiles OpenFiles `json:"-"`

	// the command buffers for commands run in this project
	CmdBufs map[string]*lines.Lines `set:"-" json:"-"`

	// history of commands executed in this session
	CmdHistory CmdNames `set:"-" json:"-"`

	// currently running commands in this project
	RunningCmds CmdRuns `set:"-" json:"-" xml:"-"`

	// current arg var vals
	ArgVals ArgVarVals `set:"-" json:"-" xml:"-"`

	// settings for this project -- this is what is saved in a .code project file
	Settings ProjectSettings `set:"-"`

	// current debug view
	CurDbg *DebugPanel `set:"-"`

	// first key in sequence if needs2 key pressed
	KeySeq1 key.Chord `set:"-"`

	// mutex for protecting overall updates to Code
	UpdateMu sync.Mutex `set:"-"`
	// contains filtered or unexported fields
}

Code is the core editor and tab viewer widget for the Code system. The default view has a tree browser of files on the left, editor panels in the middle, and a tabbed viewer on the right.

func CodeInScene 

func CodeInScene(sc *core.Scene) *Code

func NewCode 

func NewCode(parent ...tree.Node) *Code

NewCode returns a new Code with the given optional parent: Code is the core editor and tab viewer widget for the Code system. The default view has a tree browser of files on the left, editor panels in the middle, and a tabbed viewer on the right.

func NewCodeProjectPath 

func NewCodeProjectPath(path string) *Code

NewCodeProjectPath creates a new Code window with a new Code project for given path, returning the window and the path

func NewCodeWindow 

func NewCodeWindow(path, projnm, root string, doPath bool) *Code

NewCodeWindow is common code for Open CodeWindow from Project or Path

func OpenCodeProject 

func OpenCodeProject(projfile string) *Code

OpenCodeProject creates a new Code window opened to given Code project, returning the window and the path

func ParentCode 

func ParentCode(tn tree.Node) (*Code, bool)

ParentCode returns the Code parent of given node

func (*Code) ActiveEditor added in v0.1.1 

func (cv *Code) ActiveEditor() *TextEditor

ActiveEditor returns the currently active TextEditor

func (*Code) ActiveLines added in v0.1.1 

func (cv *Code) ActiveLines() *lines.Lines

ActiveLines returns the Lines for the active file; nil if none

func (*Code) AddCloseDialog 

func (cv *Code) AddCloseDialog()

AddCloseDialog adds the close dialog that automatically saves the project and prompts the user to save open files when they try to close the scene containing this code view.

func (*Code) ApplySettings 

func (cv *Code) ApplySettings()

ApplySettings applies current project preference settings into places where they are used -- only for those done prior to loading

func (*Code) ApplySettingsAction 

func (cv *Code) ApplySettingsAction()

ApplySettingsAction applies current settings to the project, and updates the project

func (*Code) ApplySplitsSettings added in v0.1.0 

func (cv *Code) ApplySplitsSettings(sv *core.Splits)

func (*Code) AutosaveCheck added in v0.1.1 

func (cv *Code) AutosaveCheck(tv *TextEditor, vidx int, ln *lines.Lines) bool

AutosaveCheck checks for an autosave file and prompts user about opening it. Returns true if autosave file does exist for a file that currently unchanged (means just opened).

func (*Code) CallFind 

func (cv *Code) CallFind(ctx core.Widget)

func (*Code) CallSaveActiveViewAs 

func (cv *Code) CallSaveActiveViewAs(ctx core.Widget)

func (*Code) CallSplitsSetView 

func (cv *Code) CallSplitsSetView(ctx core.Widget)

func (*Code) CallViewFile 

func (cv *Code) CallViewFile(ctx core.Widget)

CallViewFile calls ViewFile with ActiveFilename set as arg

func (*Code) ChooseRunExec 

func (cv *Code) ChooseRunExec(exePath core.Filename)

ChooseRunExec selects the executable to run for the project

func (*Code) ClearDebug 

func (cv *Code) ClearDebug()

ClearDebug clears the current debugger setting -- no more debugger active.

func (*Code) CloneActiveView 

func (cv *Code) CloneActiveView() (*TextEditor, int)

CloneActiveView sets the next text view to view the same file currently being vieweds in the active view. returns text view and index

func (*Code) CloseActiveView 

func (cv *Code) CloseActiveView()

CloseActiveView closes the buffer associated with active view.

func (*Code) CloseOpenFile added in v0.1.1 

func (cv *Code) CloseOpenFile(fname string)

CloseOpenFile closes given file if it is open.

func (*Code) CloseOpenFiles added in v0.1.1 

func (cv *Code) CloseOpenFiles(fnames []string)

CloseOpenFiles closes any open files on the given list of filenames.

func (*Code) CmdBuffsReMarkup added in v0.1.1 

func (cv *Code) CmdBuffsReMarkup()

CmdBuffsReMarkup runs ReMarkup on all command bufs.

func (*Code) CommandMenu added in v0.1.1 

func (cv *Code) CommandMenu(lang fileinfo.Known, repo vcs.Repo, fname string) func(mm *core.Scene, pos image.Point)

CommandMenu returns a menu function for commands for given language and vcs name

func (*Code) CommandMenuFileNode added in v0.1.1 

func (cv *Code) CommandMenuFileNode(fn *filetree.Node) func(mm *core.Scene, pos image.Point)

CommandMenuFileNode returns a menu function for commands for FileNode.

func (*Code) CommandMenuLines added in v0.1.1 

func (cv *Code) CommandMenuLines(ln *lines.Lines) func(mm *core.Scene, pos image.Point)

CommandMenuLines returns a menu function for commands for Lines.

func (*Code) CommentOut 

func (cv *Code) CommentOut() bool

CommentOut comments-out selected lines in active text view and uncomments if already commented If multiple lines are selected and any line is uncommented all will be commented

func (*Code) Commit 

func (cv *Code) Commit()

Commit commits the current changes using relevant VCS tool. Checks for VCS setting and for unsaved files.

func (*Code) CommitNoChecks 

func (cv *Code) CommitNoChecks()

CommitNoChecks does the commit without any further checks for VCS, and unsaved files

func (*Code) ConfigActiveFilename 

func (cv *Code) ConfigActiveFilename(fb *core.FuncButton) *core.FuncButton

ConfigActiveFilename configures the first arg of given FuncButton to use the ActiveFilename

func (*Code) ConfigFindButton 

func (cv *Code) ConfigFindButton(fb *core.FuncButton) *core.FuncButton

ConfigFindButton configures the Find FuncButton with current params

func (*Code) ConfigLines added in v0.1.1 

func (cv *Code) ConfigLines(tb *lines.Lines)

ConfigLines configures the text buffer according to the settings, for files that are being edited (not for output buffers).

func (*Code) CopyRect 

func (cv *Code) CopyRect()

CopyRect copies rectangle in active text view

func (*Code) CountWords 

func (cv *Code) CountWords() string

CountWords counts number of words (and lines) in active file returns a string report thereof.

func (*Code) CountWordsRegion 

func (cv *Code) CountWordsRegion() string

CountWordsRegion counts number of words (and lines) in selected region in file if no selection, returns numbers for entire file.

func (*Code) CurDebug 

func (cv *Code) CurDebug() *DebugPanel

CurDebug returns the current debug view

func (*Code) CurPanel 

func (cv *Code) CurPanel() int

CurPanel returns the splitter panel that currently has keyboard focus

func (*Code) CurrentTerminal added in v0.2.3 

func (cv *Code) CurrentTerminal() *terminal.Terminal

CurrentTerminal returns the terminal for terminal commands: the one in the selected tab, if it is a terminal, or else the last one used, or else the default one, which is made if needed.

func (*Code) CursorToHistNext 

func (cv *Code) CursorToHistNext() bool

CursorToHistNext moves forward to the next history item.

func (*Code) CursorToHistPrev 

func (cv *Code) CursorToHistPrev() bool

CursorToHistPrev moves back to the previous history item.

func (*Code) CutRect 

func (cv *Code) CutRect()

CutRect cuts rectangle in active text view

func (*Code) Debug 

func (cv *Code) Debug()

Debug starts the debugger on the RunExec executable.

func (*Code) DebugAttach 

func (cv *Code) DebugAttach(pid uint64)

DebugAttach runs the debugger by attaching to an already-running process. pid is the process id to attach to.

func (*Code) DebugTest 

func (cv *Code) DebugTest(testName string)

DebugTest runs the debugger using testing mode in current active texteditor path. testName specifies which test(s) to run according to the standard go test -run specification.

func (*Code) Defaults 

func (cv *Code) Defaults()

Defaults sets new project defaults based on overall settings

func (*Code) DiffFileLines added in v0.1.1 

func (cv *Code) DiffFileLines(lna *lines.Lines, fnmB string)

DiffFileLines shows the differences between given file node as the A file, and another given file as the B file, in side-by-side DiffEditor and in the console as a context diff.

func (*Code) DiffFiles 

func (cv *Code) DiffFiles(fnmA, fnmB core.Filename)

DiffFiles shows the differences between two given files in side-by-side DiffEditor and in the console as a context diff. It opens the files as file nodes and uses existing contents if open already.

func (*Code) EditProjectSettings 

func (cv *Code) EditProjectSettings()

EditProjectSettings allows editing of project settings (settings specific to this project)

func (*Code) EditRecentPaths 

func (cv *Code) EditRecentPaths()

EditRecentPaths opens a dialog editor for editing the recent project paths list

func (*Code) EditorButtonByIndex added in v0.1.1 

func (cv *Code) EditorButtonByIndex(idx int) *core.Button

EditorButtonByIndex returns the top texteditor menu button by index (0 or 1)

func (*Code) EditorButtonMenu added in v0.1.1 

func (cv *Code) EditorButtonMenu(idx int, m *core.Scene)

func (*Code) EditorByIndex added in v0.1.1 

func (cv *Code) EditorByIndex(idx int) *TextEditor

EditorByIndex returns the TextEditor by index (0 or 1), nil if not found

func (*Code) EditorForLines added in v0.1.1 

func (cv *Code) EditorForLines(ln *lines.Lines) (*TextEditor, int, bool)

EditorForLines finds a Editor that is viewing given Lines, and its index, or false if none is

func (*Code) EditorIndex added in v0.1.1 

func (cv *Code) EditorIndex(av *TextEditor) int

EditorIndex finds index of given texteditor (0 or 1)

func (*Code) ExecCmd 

func (cv *Code) ExecCmd()

ExecCmd pops up a menu to select a command appropriate for the current active text view, and shows output in Tab with name of command

func (*Code) ExecCmdFileNode 

func (cv *Code) ExecCmdFileNode(fn *filetree.Node)

ExecCmdFileNode pops up a menu to select a command appropriate for the given node, and shows output in Tab with name of command

func (*Code) ExecCmdName 

func (cv *Code) ExecCmdName(cmdName CmdName)

ExecCmdName executes command of given name; this is the final common pathway for all command invocation except on a node.

func (*Code) ExecCmdNameActive 

func (cv *Code) ExecCmdNameActive(cmdName string)

ExecCmdNameActive calls given command on current active texteditor

func (*Code) ExecCmdNameFile added in v0.1.1 

func (cv *Code) ExecCmdNameFile(fname string, cmdNm CmdName)

ExecCmdNameFile executes command of given name on given file name

func (*Code) ExecCmds 

func (cv *Code) ExecCmds(cmdNms CmdNames)

ExecCmds executes a sequence of commands.

func (*Code) ExecCmdsFile added in v0.1.1 

func (cv *Code) ExecCmdsFile(fname string, cmdNames CmdNames)

ExecCmdsFile executes a sequence of commands on file node

func (*Code) ExpandSelection added in v0.2.0 

func (cv *Code) ExpandSelection()

ExpandSelection expands the selection to the next larger syntactic element around it, using the language server: word, expression, statement, block, function, etc.

func (*Code) FileNodeForFile 

func (cv *Code) FileNodeForFile(fpath string) *filetree.Node

FileNodeForFile returns file node for given file path. nil if not found or is a directory.

func (*Code) FileNodeOpened 

func (cv *Code) FileNodeOpened(fn *filetree.Node)

FileNodeOpened is called whenever file node is double-clicked in file tree

func (*Code) FileNodeRunExe 

func (cv *Code) FileNodeRunExe(fn *filetree.Node)

FileNodeRunExe runs the given executable file node

func (*Code) FileNodeSelected 

func (cv *Code) FileNodeSelected(fn *filetree.Node)

FileNodeSelected is called whenever tree browser has file node selected

func (*Code) Find 

func (cv *Code) Find(find string, repl string, ignoreCase bool, regExp bool, loc Locations, langs []fileinfo.Known)

Find does Find / Replace in files, using given options and filters -- opens up a main tab with the results and further controls.

func (*Code) FindImplementations added in v0.2.0 

func (cv *Code) FindImplementations()

FindImplementations lists the implementations of the interface or method at the cursor, or the interfaces that the type at the cursor implements, using the language server, in a menu for selection.

func (*Code) FindReferences added in v0.2.0 

func (cv *Code) FindReferences()

FindReferences lists all references to the symbol at the cursor, using the language server, in the References tab, where they can be clicked to go to them.

func (*Code) FocusActiveEditor added in v0.1.1 

func (cv *Code) FocusActiveEditor() *TextEditor

FocusActiveEditor sets focus to active text editor

func (*Code) FocusNextPanel 

func (cv *Code) FocusNextPanel()

FocusNextPanel moves the keyboard focus to the next panel to the right

func (*Code) FocusOnPanel 

func (cv *Code) FocusOnPanel(panel int) bool

FocusOnPanel moves keyboard focus to given panel -- returns false if nothing at that tab

func (*Code) FocusOnTabs 

func (cv *Code) FocusOnTabs() bool

func (*Code) FocusPrevPanel 

func (cv *Code) FocusPrevPanel()

FocusPrevPanel moves the keyboard focus to the previous panel to the left

func (*Code) GetOpenFile added in v0.1.1 

func (cv *Code) GetOpenFile(fpath string) *lines.Lines

GetOpenFile either returns the Lines for a file in OpenFiles.

func (*Code) GotoDefinition added in v0.2.0 

func (cv *Code) GotoDefinition()

GotoDefinition jumps to the definition of the symbol at the cursor, using the active language backend.

func (*Code) GotoTypeDefinition added in v0.2.0 

func (cv *Code) GotoTypeDefinition()

GotoTypeDefinition jumps to the definition of the type of the symbol at the cursor, e.g., the type of a variable, using the language server.

func (*Code) GrabSettings 

func (cv *Code) GrabSettings()

GrabSettings grabs the current project preference settings from various places, e.g., prior to saving or editing.

func (*Code) GuessMainLang 

func (cv *Code) GuessMainLang() bool

GuessMainLang guesses the main language in the project -- returns true if successful

func (*Code) HelpWiki 

func (cv *Code) HelpWiki()

HelpWiki opens wiki page for code on github

func (*Code) InRootPath added in v0.1.1 

func (cv *Code) InRootPath(fpath string) bool

InRootPath returns true if the given path, which must be an absolute path, is under the current file browser root path.

func (*Code) Indent 

func (cv *Code) Indent() bool

Indent indents selected lines in active view

func (*Code) Init 

func (cv *Code) Init()

func (*Code) IsEmpty 

func (cv *Code) IsEmpty() bool

func (*Code) JoinParaLines 

func (cv *Code) JoinParaLines()

JoinParaLines merges sequences of lines with hard returns forming paragraphs, separated by blank lines, into a single line per paragraph, for given selected region (full text if no selection)

func (*Code) LangDefaults 

func (cv *Code) LangDefaults()

LangDefaults applies default language settings based on MainLang

func (*Code) LangFormat added in v0.2.0 

func (cv *Code) LangFormat()

LangFormat formats the current file using the active language backend, if it supports formatting (e.g., gopls for Go).

func (*Code) LangSvc added in v0.2.0 

func (cv *Code) LangSvc() *LangService

LangSvc returns the language service for this Code window, creating it if needed.

func (*Code) LinkViewFile 

func (cv *Code) LinkViewFile(fnm string) (*TextEditor, int, bool)

LinkViewFile opens the file in the 2nd texteditor, which is next to the tabs where links are clicked, if it is not collapsed, else 1st. It uses SourceOfGenerated to get the source of any generated files.

func (*Code) LinkViewLines added in v0.1.1 

func (cv *Code) LinkViewLines(ln *lines.Lines) (*TextEditor, int)

LinkViewLines opens the file Lines in the 2nd texteditor, which is next to the tabs where links are clicked, if it is not collapsed, else 1st.

func (*Code) Lookup added in v0.2.0 

func (cv *Code) Lookup()

Lookup is the Ctrl+. action at the cursor: if there is an error with quick fixes from the language server there, it shows a menu of them, and otherwise it shows the completions for the text up to the cursor, headed by a go to definition item for the symbol at the cursor.

func (*Code) LookupFun 

func (cv *Code) LookupFun(data any, txt string, posLine, posChar int) (ld complete.Lookup)

LookupFun is the completion system Lookup function that makes a custom texteditor dialog that has option to edit resulting file.

func (*Code) MakeToolbar 

func (cv *Code) MakeToolbar(p *tree.Plan)

func (*Code) MenuSearch added in v0.1.1 

func (cv *Code) MenuSearch(items *[]core.ChooserItem)

func (*Code) NChangedFiles 

func (cv *Code) NChangedFiles() int

NChangedFiles returns number of opened files with unsaved changes

func (*Code) NewFile 

func (cv *Code) NewFile(filename string, addToVcs bool)

NewFile creates a new file in the project

func (*Code) NewProject 

func (cv *Code) NewProject(path core.Filename, folder string, mainLang fileinfo.Known, versionControl vcs.Types) *Code

NewProject creates a new project at given path, making a new folder in that path -- all Code projects are essentially defined by a path to a folder containing files. If the folder already exists, then use OpenPath. Can also specify main language and version control type.

func (*Code) NewTerminal added in v0.2.3 

func (cv *Code) NewTerminal()

NewTerminal makes a new terminal tab, in addition to the default one. The keymap.New key does this in a terminal (see terminal.KeyFunction).

func (*Code) NextProblem added in v0.2.1 

func (cv *Code) NextProblem()

NextProblem goes to the current problem in the Problems tab, if the cursor is not already on it in the active editor, and otherwise to the next one. The current problem is the last one clicked or gone to, and when it goes away, e.g., after applying a fix for it, NextProblem goes to the next one, which is highlighted. The Problems tab is shown if it is not already.

func (*Code) NextTab added in v0.2.3 

func (cv *Code) NextTab()

NextTab selects the next tab in the tabs panel, after the last one the first, and focuses it. Shift+RightArrow does this when the focus is in the tabs panel.

func (*Code) NextTextEditor 

func (cv *Code) NextTextEditor() (*TextEditor, int)

NextTextEditor returns the next text view available for viewing a file and its index -- if the active text view is empty, then it is used, otherwise it is the next one (if visible)

func (*Code) NextViewFile 

func (cv *Code) NextViewFile(fnm string) (*TextEditor, int, bool)

NextViewFile sets the next text view to view given file name. Will use a more robust search of file tree if file path is not directly openable. Returns texteditor and its index, false if not found.

func (*Code) NextViewLines added in v0.1.1 

func (cv *Code) NextViewLines(ln *lines.Lines) (*TextEditor, int)

NextViewLines sets the next text view to view file in given lines. If already being viewed, that is activated, returns text view and index.

func (*Code) OpenConsoleTab 

func (cv *Code) OpenConsoleTab()

OpenConsoleTab opens a main tab displaying console output (stdout, stderr)

func (*Code) OpenFile 

func (cv *Code) OpenFile(fnm string)

OpenFile opens file in an open project if it has the same path as the file or in a new window.

func (*Code) OpenFileAtRegion 

func (cv *Code) OpenFileAtRegion(filename string, tr textpos.Region) (tv *TextEditor, ok bool)

func (*Code) OpenFileURL 

func (cv *Code) OpenFileURL(ur string, ftv *textcore.Editor) bool

OpenFileURL is the link handler for command editors: opens given file:/// url

func (*Code) OpenFindURL 

func (cv *Code) OpenFindURL(ur string, ftv *textcore.Editor) bool

OpenFindURL opens given find:/// url from Find; delegates to FindPanel

func (*Code) OpenLines added in v0.1.1 

func (cv *Code) OpenLines(fpath string) *lines.Lines

OpenLines opens a Lines buffer for given file path. Must already have determined that it is not in the list of OpenFiles, and it must be an Abs path. If file is outside the current root path, it is also added to external files in the file browser.

func (*Code) OpenPath 

func (cv *Code) OpenPath(path core.Filename) *Code

OpenPath creates a new project by opening given path, which can either be a specific file or a folder containing multiple files of interest -- opens in current Code object if it is empty, or otherwise opens a new window.

func (*Code) OpenProject 

func (cv *Code) OpenProject(filename core.Filename) *Code

OpenProject opens .code project file and its settings from given filename, in a standard toml-formatted file.

func (*Code) OpenRecent 

func (cv *Code) OpenRecent(filename core.Filename)

OpenRecent opens a recently used file

func (*Code) OpenTerminal added in v0.2.3 

func (cv *Code) OpenTerminal()

OpenTerminal shows the default terminal tab, making it if needed. Terminals run the shell (or the command in the terminal settings) in the project root directory.

func (*Code) OverflowMenu 

func (cv *Code) OverflowMenu(m *core.Scene, pos image.Point)

func (*Code) PanelIsOpen 

func (cv *Code) PanelIsOpen(panel int) bool

PanelIsOpen returns true if the given panel has not been collapsed and is avail and visible for displaying something

func (*Code) PasteRect 

func (cv *Code) PasteRect()

PasteRect cuts rectangle in active text view

func (*Code) PrevTab added in v0.2.3 

func (cv *Code) PrevTab()

PrevTab selects the previous tab in the tabs panel, before the first one the last, and focuses it. Shift+LeftArrow does this when the focus is in the tabs panel.

func (*Code) QuickFix added in v0.2.0 

func (cv *Code) QuickFix()

QuickFix prompts for and applies a quick fix or refactoring from the language server at the cursor or selection, like other editors' Ctrl+. (Ctrl+period). The diagnostics cached for the position are sent as context, which is what turns the quick fixes on: organize imports, missing returns, error-check wrapping, typo fixes, etc, along with refactorings like extract function/variable.

func (*Code) ReCase 

func (cv *Code) ReCase(c strcase.Cases) string

ReCase replaces currently selected text in current active view with given case

func (*Code) RecycleCmdBuf 

func (cv *Code) RecycleCmdBuf(cmdName string) (*lines.Lines, bool)

RecycleCmdBuf creates the buffer for command output, or returns existing. Returns true if new buffer created.

func (*Code) RecycleCmdTab 

func (cv *Code) RecycleCmdTab(cmdName string) (*lines.Lines, *textcore.Editor, bool)

RecycleCmdTab creates the tab to show command output, including making a buffer object to save output from the command. Returns true if a new buffer was created, false if one already existed.

func (*Code) RecycleFile added in v0.1.1 

func (cv *Code) RecycleFile(fpath string) (*lines.Lines, bool)

RecycleFile either opens given file or returns already open one. Returns true if it is a new file, false otherwise. If file is outside the current root path, it is also added to external files in the file browser. Can return nil if not openable.

func (*Code) RecycleTabTextEditor 

func (cv *Code) RecycleTabTextEditor(name string, buf *lines.Lines) *textcore.Editor

RecycleTabTextEditor returns a text editor in a tab with the given name, first by looking for an existing one, and if not found, making a new one with a text editor in it.

func (*Code) RegisterCopy 

func (cv *Code) RegisterCopy(regNm RegisterName)

RegisterCopy saves current selection in active text view to register of given name returns true if saved.

func (*Code) RegisterPaste 

func (cv *Code) RegisterPaste(ctx core.Widget)

RegisterPaste prompts user for available registers, and pastes selected one into active text view

func (*Code) RenameSymbol added in v0.2.0 

func (cv *Code) RenameSymbol()

RenameSymbol prompts for a new name and renames the symbol at the cursor across the workspace, using the language server. The proposed edits are shown in the Find tab for review before applying: click a result to jump to it, Replace for one at a time, or All for all (open buffers are edited, unopened files are opened; save to write).

func (*Code) ReplaceInActive 

func (cv *Code) ReplaceInActive()

ReplaceInActive does query-replace in active file only

func (*Code) RevertActiveView 

func (cv *Code) RevertActiveView()

RevertActiveView revert active view to saved version.

func (*Code) Run 

func (cv *Code) Run()

Run runs the RunCmds set for this project

func (*Code) RunBuild 

func (cv *Code) RunBuild()

RunBuild runs the BuildCmds set for this project

func (*Code) RunPostCmds added in v0.1.1 

func (cv *Code) RunPostCmds(ln *lines.Lines) bool

RunPostCmds runs any registered post commands on the given open file. Returns true if commands were run and file was reverted after that. Uses MainLang to disambiguate if multiple languages associated with extension.

func (*Code) SaveActiveView 

func (cv *Code) SaveActiveView()

SaveActiveView saves the contents of the currently active texteditor.

func (*Code) SaveActiveViewAs 

func (cv *Code) SaveActiveViewAs(filename core.Filename)

SaveActiveViewAs save with specified filename the contents of the currently active texteditor

func (*Code) SaveAll 

func (cv *Code) SaveAll()

SaveAll saves all of the open filenodes to their current file names and saves the project state if it has been saved before (i.e., the .code file exists)

func (*Code) SaveAllCheck 

func (cv *Code) SaveAllCheck(cancelOpt bool, fun func()) bool

SaveAllCheck -- check if any files have not been saved, and prompt to save them returns true if there were unsaved files, false otherwise. cancelOpt presents an option to cancel current command, in which case function is not called. if function is passed, then it is called in all cases except if the user selects cancel.

func (*Code) SaveAllOpenFiles added in v0.1.1 

func (cv *Code) SaveAllOpenFiles()

SaveAllOpenFiles saves all of the open filenodes to their current file names

func (*Code) SaveProject 

func (cv *Code) SaveProject()

SaveProject saves project file containing custom project settings, in a standard toml-formatted file

func (*Code) SaveProjectAs 

func (cv *Code) SaveProjectAs(filename core.Filename) bool

SaveProjectAs saves project custom settings to given filename, in a standard toml-formatted file saveAllFiles indicates if user should be prompted for saving all files returns true if the user was prompted, false otherwise

func (*Code) SaveProjectIfExists 

func (cv *Code) SaveProjectIfExists(saveAllFiles bool) bool

SaveProjectIfExists saves project file containing custom project settings, in a standard toml-formatted file, only if it already exists -- returns true if saved saveAllFiles indicates if user should be prompted for saving all files

func (*Code) SelectOpenFile added in v0.1.1 

func (cv *Code) SelectOpenFile()

SelectOpenFile pops up a menu to select an open file to view in current active texteditor.

func (*Code) SelectTabByName 

func (cv *Code) SelectTabByName(name string) core.Widget

SelectTabByName Selects given main tab, and returns all of its contents as well.

func (*Code) SelectedFileNode 

func (cv *Code) SelectedFileNode() *filetree.Node

SelectedFileNode returns currently selected file tree node as a *filetree.Node could be nil.

func (*Code) SetActiveEditor added in v0.1.1 

func (cv *Code) SetActiveEditor(av *TextEditor) int

SetActiveEditor sets the given texteditor as the active one, configures it, and returns its index.

func (*Code) SetActiveEditorIndex added in v0.1.1 

func (cv *Code) SetActiveEditorIndex(idx int) *TextEditor

SetActiveEditorIndex sets the given view index as the currently active Editor -- returns that texteditor. This is the main method for activating a text editor.

func (*Code) SetActiveFileInfo 

func (cv *Code) SetActiveFileInfo(ln *lines.Lines)

SetActiveFileInfo sets the active file info from Lines.

func (*Code) SetActiveLang 

func (t *Code) SetActiveLang(v fileinfo.Known) *Code

SetActiveLang sets the Code.ActiveLang: language for current active filename

func (*Code) SetArgVarVals 

func (cv *Code) SetArgVarVals()

SetArgVarVals sets the ArgVar values for commands, from Code values

func (*Code) SetInlayHints added in v0.2.0 

func (cv *Code) SetInlayHints(on bool)

SetInlayHints turns the inlay hints setting on or off, applying it to the running language servers: already-running gopls re-fetches its settings through workspace/configuration (gopls supports dynamic configuration), so no restart is needed for it; servers that only read options at startup pick the change up when they next start. The server work runs in the background.

func (*Code) SetOpenFiles added in v0.1.1 

func (t *Code) SetOpenFiles(v OpenFiles) *Code

SetOpenFiles sets the Code.OpenFiles: list of open files, most recent first

func (*Code) SetProjectFilename 

func (t *Code) SetProjectFilename(v core.Filename) *Code

SetProjectFilename sets the Code.ProjectFilename: current project filename for saving / loading specific Code configuration information in a .code file (optional)

func (*Code) SetProjectRoot 

func (t *Code) SetProjectRoot(v core.Filename) *Code

SetProjectRoot sets the Code.ProjectRoot: root directory for the project -- all projects must be organized within a top-level root directory, with all the files therein constituting the scope of the project -- by default it is the path for ProjectFilename

func (*Code) SetStatus 

func (cv *Code) SetStatus(msg string)

SetStatus sets the current status update message for the StatusBar next time it renders

func (*Code) SetStatusMessage 

func (t *Code) SetStatusMessage(v string) *Code

SetStatusMessage sets the Code.StatusMessage: the last status update message

func (*Code) SetWindowNameTitle 

func (cv *Code) SetWindowNameTitle()

SetWindowNameTitle sets the window name and title based on current project name

func (*Code) ShowFile 

func (cv *Code) ShowFile(fpath string, ln int) (*TextEditor, error)

ShowFile shows given file name at given line, returning TextEditor showing it or error if not found.

func (*Code) ShowInlayHints added in v0.2.0 

func (cv *Code) ShowInlayHints()

ShowInlayHints requests the language server's inlay hints for the current file and lists them in a dialog, as a display-only overview: nothing is inserted into the buffer (the per-hint TextEdits that would insert the label text are ignored). Requires the InlayHints setting to be on for servers like gopls that gate hints behind settings.

func (*Code) ShowProblems added in v0.2.0 

func (cv *Code) ShowProblems(scope Locations)

ShowProblems shows the problems (errors and warnings) reported by the language servers for the files in the given scope in the Problems tab, where they can be clicked to go to them. The tab is updated as the problems change, while it is open.

func (*Code) ShowSignatureHelp added in v0.2.0 

func (cv *Code) ShowSignatureHelp()

ShowSignatureHelp explicitly requests signature help at the cursor and shows all of the signatures in a dialog, for cases where the automatic display is not desired or the cursor is not in a call context.

func (*Code) ShrinkSelection added in v0.2.0 

func (cv *Code) ShrinkSelection()

ShrinkSelection shrinks the selection back to the next smaller syntactic element, after it has been expanded with Code.ExpandSelection.

func (*Code) SourceOfGenerated added in v0.1.1 

func (cv *Code) SourceOfGenerated(ln *lines.Lines) *lines.Lines

SourceOfGenerated returns the source of the given generated file. This should be listed in a //line comment right after the first comment line that indicates that it is generated. Returns the input lines if source comment not found.

func (*Code) SpacesToTabs 

func (cv *Code) SpacesToTabs()

SpacesToTabs converts spaces to tabs for given selected region (full text if no selection)

func (*Code) Spell 

func (cv *Code) Spell()

Spell checks spelling in active text view

func (*Code) Splits 

func (cv *Code) Splits() *core.Splits

Splits returns the main Splits, nil if the tree has not been built

func (*Code) SplitsEdit 

func (cv *Code) SplitsEdit()

SplitsEdit opens the SplitsView editor to customize saved splitter settings

func (*Code) SplitsSave 

func (cv *Code) SplitsSave(split SplitName)

SplitsSave saves current splitter settings to named splitter settings under existing name, and saves to settings file

func (*Code) SplitsSaveAs 

func (cv *Code) SplitsSaveAs(name, desc string)

SplitsSaveAs saves current splitter settings to new named splitter settings, and saves to settings file

func (*Code) SplitsSetView 

func (cv *Code) SplitsSetView(split SplitName)

SplitsSetView sets split view splitters to given named setting

func (*Code) StatusBar 

func (cv *Code) StatusBar() *core.Frame

StatusBar returns the statusbar widget

func (*Code) StatusText 

func (cv *Code) StatusText() *core.Text

StatusText returns the status bar text widget

func (*Code) SwapTextEditors 

func (cv *Code) SwapTextEditors() bool

SwapTextEditors switches the buffers for the two open texteditors only operates if both panels are open.

func (*Code) Symbols 

func (cv *Code) Symbols()

Symbols displays the Symbols of a file or package

func (*Code) TabByName 

func (cv *Code) TabByName(name string) core.Widget

TabByName returns a tab with given name, nil if not found.

func (*Code) TabDeleted 

func (cv *Code) TabDeleted(tabnm string)

TabDeleted is called when a main tab is deleted -- we cancel any running commands

func (*Code) Tabs 

func (cv *Code) Tabs() *core.Tabs

Tabs returns the main TabView

func (*Code) TabsToSpaces 

func (cv *Code) TabsToSpaces()

TabsToSpaces converts tabs to spaces for given selected region (full text if no selection)

func (*Code) TerminalCdToFile added in v0.2.3 

func (cv *Code) TerminalCdToFile()

TerminalCdToFile changes the directory of the shell in the current terminal to the directory of the file in the active editor.

func (*Code) TerminalCdToProject added in v0.2.3 

func (cv *Code) TerminalCdToProject()

TerminalCdToProject changes the directory of the shell in the current terminal to the project root directory.

func (*Code) Terminals added in v0.2.3 

func (cv *Code) Terminals() []*terminal.Terminal

Terminals returns the terminals in the tabs.

func (*Code) UpdateFiles 

func (cv *Code) UpdateFiles()

UpdateFiles updates the list of files saved in project

func (*Code) UpdateStatusText 

func (cv *Code) UpdateStatusText()

UpdateStatusText updates the status bar text with current data.

func (*Code) UpdateTextButtons 

func (cv *Code) UpdateTextButtons()

UpdateTextButtons updates texteditor menu buttons is called by SetStatus. Doesn't do anything unless a change is required, so safe to call frequently.

func (*Code) VCSLog 

func (cv *Code) VCSLog() (vcs.Log, error)

VCSLog shows the VCS log of commits in this project, in an interactive browser from which any revisions can be compared and diffs browsed.

func (*Code) VCSUpdateAll 

func (cv *Code) VCSUpdateAll()

VCSUpdateAll does an Update (e.g., Pull) on all VCS repositories within the open tree nodes in FileTree.

func (*Code) VersionControl 

func (cv *Code) VersionControl() vcs.Types

VersionControl returns the version control system in effect, using the file tree detected version or whatever is set in project settings.

func (*Code) ViewFile 

func (cv *Code) ViewFile(fnm core.Filename) (*TextEditor, int, bool)

ViewFile views file in an existing TextEditor if it is already viewing that file, otherwise opens ViewLines in active buffer.

func (*Code) ViewFileInIndex 

func (cv *Code) ViewFileInIndex(fnm string, idx int) (*TextEditor, int, bool)

ViewFileInIndex views file in given text view index

func (*Code) ViewLines added in v0.1.1 

func (cv *Code) ViewLines(tv *TextEditor, vidx int, ln *lines.Lines)

ViewLines sets the given text view to view file lines.

func (*Code) WorkspaceSymbolPrompt added in v0.2.0 

func (cv *Code) WorkspaceSymbolPrompt()

WorkspaceSymbolPrompt prompts for a symbol name and shows matching symbols from the entire workspace project, using the language server.

type Command 

type Command struct {

	// category for the command -- commands are organized in to hierarchical menus according to category
	Cat string

	// name of this command (must be unique in list of commands)
	Name string `width:"20"`

	// brief description of this command
	Desc string `width:"40"`

	// supported language / file type that this command applies to -- choose Any or e.g., AnyCode for subtypes -- filters the list of commands shown based on file language type
	Lang fileinfo.Known

	// sequence of commands to run for this overall command.
	Cmds []CmdAndArgs `table-select:"-"`

	// if specified, will change to this directory before executing the command;
	// e.g., use {FileDirPath} for current file's directory. Only use directory
	// values here; if not specified, directory will be project root directory.
	Dir string `width:"20"`

	// if true, we wait for the command to run before displaying output -- mainly for post-save commands and those with subsequent steps: if multiple commands are present, then it uses Wait mode regardless.
	Wait bool

	// if true, keyboard focus is directed to the command output tab panel after the command runs.
	Focus bool

	// if true, command requires Ok / Cancel confirmation dialog -- only needed for non-prompt commands
	Confirm bool

	// what type of file to use for syntax highlighting.  Bash is the default.
	Hilight fileinfo.Known
}

Command defines different types of commands that can be run in the project. The output of the commands shows up in an associated tab.

func (*Command) AppendCmdOut 

func (cm *Command) AppendCmdOut(cv *Code, buf *lines.Lines, out []rune)

AppendCmdOut appends command output to buffer, applying markup for links

func (*Command) HasPrompts 

func (cm *Command) HasPrompts() (map[string]struct{}, bool)

HasPrompts returns true if any prompts are required before running command, and the set of such args

func (Command) Label 

func (cm Command) Label() string

Label satisfies the Labeler interface

func (*Command) LangMatch 

func (cm *Command) LangMatch(lang fileinfo.Known) bool

LangMatch returns true if the given language matches the command Lang constraints

func (*Command) MarkupCmdOutput 

func (cm *Command) MarkupCmdOutput(buf *lines.Lines, out []rune) rich.Text

func (*Command) PromptUser 

func (cm *Command) PromptUser(cv *Code, buf *lines.Lines, pvals map[string]struct{})

PromptUser prompts for values that need prompting for, and then runs RunAfterPrompts if not otherwise cancelled by user

func (*Command) Run 

func (cm *Command) Run(cv *Code, buf *lines.Lines)

Run runs the command and saves the output in the Buf if it is non-nil, which can be displayed. If !wait, then Buf is updated online as output occurs. Status is updated with status of command exec. User is prompted for any values that might be needed for command.

func (*Command) RunAfterPrompts 

func (cm *Command) RunAfterPrompts(cv *Code, buf *lines.Lines)

RunAfterPrompts runs after any prompts have been set, if needed

func (*Command) RunBuf 

func (cm *Command) RunBuf(cv *Code, buf *lines.Lines, cma *CmdAndArgs) bool

RunBuf runs a command with output to the buffer, incrementally updating the buffer with new results line-by-line as they come in

func (*Command) RunBufWait 

func (cm *Command) RunBufWait(cv *Code, buf *lines.Lines, cma *CmdAndArgs) bool

RunBufWait runs a command with output to the buffer, using CombinedOutput so it waits for completion -- returns overall command success, and logs one line of the command output to code statusbar

func (*Command) RunNoBuf 

func (cm *Command) RunNoBuf(cv *Code, cma *CmdAndArgs) bool

RunNoBuf runs a command without any output to the buffer -- can call using go as a goroutine for no-wait case -- returns overall command success, and logs one line of the command output to code statusbar

func (*Command) RunStatus 

func (cm *Command) RunStatus(cv *Code, buf *lines.Lines, cmdstr string, err error, out []byte) bool

RunStatus reports the status of the command run (given in cmdstr) to ge.StatusBar, and appends to the buffer. Returns true if there are no errors, and false if there were errors.

type Commands 

type Commands []*Command //types:add

Commands is a list of different commands 

var AvailableCommands Commands

AvailableCommands is the current list of ALL available commands for use -- it combines StdCmds and CustomCmds. Custom overrides Std items with the same names.

func (*Commands) CmdByName 

func (cm *Commands) CmdByName(name CmdName, msg bool) (*Command, int, bool)

CmdByName returns a command and index by name -- returns false and emits a message to log if not found if msg is true

func (*Commands) CopyFrom 

func (cm *Commands) CopyFrom(cp Commands)

CopyFrom copies commands from given other map

func (*Commands) FilterCmdNames 

func (cm *Commands) FilterCmdNames(lang fileinfo.Known, vcstype vcs.Types) [][]string

FilterCmdNames returns a slice of commands organized by category that are compatible with given language and version control system.

func (*Commands) Open 

func (cm *Commands) Open(filename core.Filename) error

Open opens commands from a toml-formatted file.

func (*Commands) OpenSettings 

func (cm *Commands) OpenSettings() error

OpenSettings opens custom Commands from the app settings directory, using CommandSettingsFilename.

func (*Commands) Save 

func (cm *Commands) Save(filename core.Filename) error

Save saves commands to a toml-formatted file.

func (*Commands) SaveSettings 

func (cm *Commands) SaveSettings() error

SaveSettings saves custom Commands to the app settings directory, using CommandSettingsFilename.

func (*Commands) ViewStandard 

func (cm *Commands) ViewStandard()

ViewStandard shows the standard types that are compiled into the program and have all the lastest standards. Useful for comparing against custom lists.

type Console 

type Console struct {

	// std out writer -- set to os.Stdout
	StdoutWrite *os.File `json:"-" xml:"-"`

	// std out reader -- used to read os.Stdout
	StdoutRead *os.File `json:"-" xml:"-"`

	// std err writer -- set to os.Stderr
	StderrWrite *os.File `json:"-" xml:"-"`

	// std err reader -- used to read os.Stderr
	StderrRead *os.File `json:"-" xml:"-"`

	// text lines holding all output
	Lines *lines.Lines `json:"-" xml:"-"`

	// set to true to cancel monitoring
	Cancel bool `json:"-" xml:"-"`

	// mutex protecting updating of buffer between out / err
	Mu sync.Mutex `json:"-" xml:"-"`

	// original os.Stdout writer
	OrgoutWrite *os.File `json:"-" xml:"-"`

	// original os.Stderr writer
	OrgerrWrite *os.File `json:"-" xml:"-"`

	// log file writer
	LogWrite *os.File `json:"-" xml:"-"`
}

Console redirects our os.Stdout and os.Stderr to a buffer for display within app 

var TheConsole Console

func (*Console) Close 

func (cn *Console) Close()

Close closes all the files -- call on exit

func (*Console) Init 

func (cn *Console) Init(logFile string)

Init initializes the console -- sets up the capture, Buf, and starts the routine that monitors output. if logFile is non-empty, writes output to that file as well.

func (*Console) MonitorErr 

func (cn *Console) MonitorErr()

MonitorErr monitors std error and appends it to the buffer should be in a separate routine

func (*Console) MonitorOut 

func (cn *Console) MonitorOut()

MonitorOut monitors std output and appends it to the buffer should be in a separate routine

type DebugBreakStatus 

type DebugBreakStatus int32 //enums:enum -trim-prefix Debug

DebugBreakStatus represents the status of a certain breakpoint. 

const (
	// DebugBreakInactive is an inactive break point
	DebugBreakInactive DebugBreakStatus = iota

	// DebugBreakActive is an active break point
	DebugBreakActive

	// DebugBreakCurrent is the current break point
	DebugBreakCurrent

	// DebugPCCurrent is the current program execution point,
	// updated for every ShowFile action
	DebugPCCurrent
)
const DebugBreakStatusN DebugBreakStatus = 4

DebugBreakStatusN is the highest valid value for type DebugBreakStatus, plus one.

func DebugBreakStatusValues 

func DebugBreakStatusValues() []DebugBreakStatus

DebugBreakStatusValues returns all possible values for the type DebugBreakStatus.

func (DebugBreakStatus) Desc 

func (i DebugBreakStatus) Desc() string

Desc returns the description of the DebugBreakStatus value.

func (DebugBreakStatus) Int64 

func (i DebugBreakStatus) Int64() int64

Int64 returns the DebugBreakStatus value as an int64.

func (DebugBreakStatus) MarshalText 

func (i DebugBreakStatus) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface.

func (*DebugBreakStatus) SetInt64 

func (i *DebugBreakStatus) SetInt64(in int64)

SetInt64 sets the DebugBreakStatus value from an int64.

func (*DebugBreakStatus) SetString 

func (i *DebugBreakStatus) SetString(s string) error

SetString sets the DebugBreakStatus value from its string representation, and returns an error if the string is invalid.

func (DebugBreakStatus) String 

func (i DebugBreakStatus) String() string

String returns the string representation of this DebugBreakStatus value.

func (*DebugBreakStatus) UnmarshalText 

func (i *DebugBreakStatus) UnmarshalText(text []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface.

func (DebugBreakStatus) Values 

func (i DebugBreakStatus) Values() []enums.Enum

Values returns all possible values for the type DebugBreakStatus.

type DebugPanel 

type DebugPanel struct {
	core.Frame

	// known file type to determine debugger
	Known fileinfo.Known

	// path to executable / dir to debug
	ExePath string

	// time when dbg was last restarted
	DbgTime time.Time

	// the debugger
	Dbg cdebug.GiDebug `set:"-" json:"-" xml:"-"`

	// all relevant debug state info
	State cdebug.AllState `set:"-" json:"-" xml:"-"`

	// current ShowFile location -- cleared before next one or run
	CurFileLoc cdebug.Location `set:"-" json:"-" xml:"-"`

	// backup breakpoints list -- to track deletes
	BBreaks []*cdebug.Break `set:"-" json:"-" xml:"-"`

	// output from the debugger
	OutputBuffer *lines.Lines `set:"-" json:"-" xml:"-"`

	// parent code project
	Code *Code `set:"-" json:"-" xml:"-"`
}

DebugPanel is the debugger panel.

func NewDebugPanel 

func NewDebugPanel(parent ...tree.Node) *DebugPanel

NewDebugPanel returns a new DebugPanel with the given optional parent: DebugPanel is the debugger panel.

func (*DebugPanel) AddBreak 

func (dv *DebugPanel) AddBreak(fpath string, line int)

AddBreak adds a breakpoint at given file path and line number. note: all breakpoints are just set in our master list and uploaded to the system right before starting running.

func (*DebugPanel) BackupBreaks 

func (dv *DebugPanel) BackupBreaks()

BackupBreaks makes a backup copy of current breaks

func (*DebugPanel) Config 

func (dv *DebugPanel) Config(cv *Code, known fileinfo.Known, exePath string)

Config sets parameters that must be set for a new view

func (*DebugPanel) ConsoleText 

func (dv *DebugPanel) ConsoleText() *textcore.Editor

ConsoleText returns the console TextEditor

func (*DebugPanel) Continue 

func (dv *DebugPanel) Continue()

Continue continues running from current point -- this MUST be called in a separate goroutine!

func (*DebugPanel) DbgCanStep 

func (dv *DebugPanel) DbgCanStep() bool

DbgCanStep means the debugger is started AND process is not currently running, AND it is not already waiting for a next step

func (*DebugPanel) DbgIsActive 

func (dv *DebugPanel) DbgIsActive() bool

DbgIsActive means debugger is started.

func (*DebugPanel) DbgIsAvail 

func (dv *DebugPanel) DbgIsAvail() bool

DbgIsAvail means the debugger is started AND process is not currently running -- it is available for command input.

func (*DebugPanel) DeleteAllBreaks 

func (dv *DebugPanel) DeleteAllBreaks()

DeleteAllBreaks deletes all breakpoints

func (*DebugPanel) DeleteBreak 

func (dv *DebugPanel) DeleteBreak(fpath string, line int)

DeleteBreak deletes given breakpoint. If debugger is not yet activated then it just deletes from master list. Note that breakpoints can be turned on and off directly using On flag.

func (*DebugPanel) DeleteBreakImpl 

func (dv *DebugPanel) DeleteBreakImpl(fpath string, line int)

DeleteBreakImpl deletes given breakpoint with no other updates

func (*DebugPanel) DeleteBreakInBuf 

func (dv *DebugPanel) DeleteBreakInBuf(fpath string, line int)

DeleteBreakInBuf delete breakpoint in its TextBuf line is 1-based line number

func (*DebugPanel) DeleteBreakIndex 

func (dv *DebugPanel) DeleteBreakIndex(bidx int)

DeleteBreakIndex deletes break at given index in list of breaks

func (*DebugPanel) DeleteCurPCInBuf 

func (dv *DebugPanel) DeleteCurPCInBuf()

DeleteCurPCInBuf deletes the current PC location in given file line is 1-based line number

func (*DebugPanel) Destroy 

func (dv *DebugPanel) Destroy()

func (*DebugPanel) Detach 

func (dv *DebugPanel) Detach()

Detach from debugger

func (*DebugPanel) FindFrames 

func (dv *DebugPanel) FindFrames(fpath string, line int)

FindFrames finds the frames where given file and line are active Selects the one that is closest and shows the others in Find Tab. The fpath can be just the path or any string fragment contained within the target filename.

func (*DebugPanel) Init 

func (dv *DebugPanel) Init()

func (*DebugPanel) InitState 

func (dv *DebugPanel) InitState(ds *cdebug.State)

InitState updates the State and View from given debug state Call this when debugger returns from any action update

func (*DebugPanel) InitTabs 

func (dv *DebugPanel) InitTabs()

func (*DebugPanel) ListGlobalVars 

func (dv *DebugPanel) ListGlobalVars(filter string)

ListGlobalVars lists global vars matching the given optional filter.

func (*DebugPanel) MakeToolbar 

func (dv *DebugPanel) MakeToolbar(p *tree.Plan)

func (*DebugPanel) SetBreaks 

func (dv *DebugPanel) SetBreaks()

SetBreaks sets the current breakpoints from State, call this prior to running

func (*DebugPanel) SetCurPCInBuf 

func (dv *DebugPanel) SetCurPCInBuf(fpath string, line int)

SetCurPCInBuf sets the current PC location in given file line is 1-based line number

func (*DebugPanel) SetDbgTime 

func (t *DebugPanel) SetDbgTime(v time.Time) *DebugPanel

SetDbgTime sets the DebugPanel.DbgTime: time when dbg was last restarted

func (*DebugPanel) SetExePath 

func (t *DebugPanel) SetExePath(v string) *DebugPanel

SetExePath sets the DebugPanel.ExePath: path to executable / dir to debug

func (*DebugPanel) SetFrame 

func (dv *DebugPanel) SetFrame(depth int)

SetFrame sets the given frame depth level as active

func (*DebugPanel) SetKnown added in v0.1.1 

func (t *DebugPanel) SetKnown(v fileinfo.Known) *DebugPanel

SetKnown sets the DebugPanel.Known: known file type to determine debugger

func (*DebugPanel) SetStatus 

func (dv *DebugPanel) SetStatus(stat cdebug.Status)

func (*DebugPanel) SetThread 

func (dv *DebugPanel) SetThread(threadID int)

SetThread sets the given thread as active -- this must be TaskID if HasTasks and ThreadID if not.

func (*DebugPanel) SetThreadIndex 

func (dv *DebugPanel) SetThreadIndex(thridx int)

SetThreadIndex sets the given thread by index in threads list as active this must be TaskID if HasTasks and ThreadID if not.

func (*DebugPanel) ShowBreakFile 

func (dv *DebugPanel) ShowBreakFile(bidx int)

ShowBreakFile shows the file for given break index

func (*DebugPanel) ShowFile 

func (dv *DebugPanel) ShowFile(fpath string, line int)

ShowFile shows the file name in code

func (*DebugPanel) ShowTab 

func (dv *DebugPanel) ShowTab(tab string)

ShowTab shows given tab

func (*DebugPanel) ShowVar 

func (dv *DebugPanel) ShowVar(name string) error

ShowVar shows info on a given variable within the current frame scope in a text view dialog

func (*DebugPanel) SingleStep 

func (dv *DebugPanel) SingleStep()

SingleStep steps a single CPU instruction.

func (*DebugPanel) Start 

func (dv *DebugPanel) Start()

Start starts the debuger

func (*DebugPanel) StepInto 

func (dv *DebugPanel) StepInto()

StepInto continues to the next source line, entering function calls.

func (*DebugPanel) StepOut 

func (dv *DebugPanel) StepOut()

StepOut continues to the return point of the current function.

func (*DebugPanel) StepOver 

func (dv *DebugPanel) StepOver()

StepOver continues to the next source line, not entering function calls.

func (*DebugPanel) Stop 

func (dv *DebugPanel) Stop()

Stop stops a running process.

func (*DebugPanel) SyncBreaks 

func (dv *DebugPanel) SyncBreaks()

SyncBreaks synchronizes backup breaks with current breaks, after Breaks Changed

func (*DebugPanel) Tabs 

func (dv *DebugPanel) Tabs() *core.Tabs

Tabs returns the tabs

func (*DebugPanel) Toolbar 

func (dv *DebugPanel) Toolbar() *core.Frame

Toolbar returns the debug toolbar

func (*DebugPanel) UpdateAllBreaks 

func (dv *DebugPanel) UpdateAllBreaks()

UpdateAllBreaks updates all breakpoints

func (*DebugPanel) UpdateBreakInBuf 

func (dv *DebugPanel) UpdateBreakInBuf(fpath string, line int, stat DebugBreakStatus)

UpdateBreakInBuf updates break status in its TextBuf line is 1-based line number

func (*DebugPanel) UpdateFromState 

func (dv *DebugPanel) UpdateFromState()

UpdateFromState updates the view from current debugger state

func (*DebugPanel) UpdateTab 

func (dv *DebugPanel) UpdateTab(tab string)

UpdateTab updates given tab

func (*DebugPanel) UpdateView 

func (dv *DebugPanel) UpdateView()

UpdateView updates current view of state

func (*DebugPanel) VarValue 

func (dv *DebugPanel) VarValue(varNm string) string

VarValue returns the value of given variable, first looking in local stack vars and then in global vars

type FileNode 

type FileNode struct {
	filetree.Node
}

FileNode is Code version of FileNode for FileTree

func NewFileNode 

func NewFileNode(parent ...tree.Node) *FileNode

NewFileNode returns a new FileNode with the given optional parent: FileNode is Code version of FileNode for FileTree

func (*FileNode) ContextMenu 

func (fn *FileNode) ContextMenu(m *core.Scene, pos image.Point)

func (*FileNode) DeleteFiles added in v0.1.1 

func (fn *FileNode) DeleteFiles()

DeleteFiles calls DeleteFile on any selected nodes, after prompting.

func (*FileNode) EditFile 

func (fn *FileNode) EditFile()

EditFile pulls up this file in Code

func (*FileNode) EditFiles 

func (fn *FileNode) EditFiles()

EditFiles calls EditFile on selected files

func (*FileNode) ExecCmdFile 

func (fn *FileNode) ExecCmdFile()

ExecCmdFile pops up a menu to select a command appropriate for the given node, and shows output in MainTab with name of command

func (*FileNode) ExecCmdNameFile 

func (fn *FileNode) ExecCmdNameFile(cmdNm string)

ExecCmdNameFile executes given command name on node

func (*FileNode) Init 

func (fn *FileNode) Init()

func (*FileNode) OnClose added in v0.2.1 

func (fn *FileNode) OnClose()

OnClose updates the Problems tab for the closed directory.

func (*FileNode) OnOpen added in v0.2.1 

func (fn *FileNode) OnOpen()

OnOpen updates the Problems tab for the newly opened directory.

func (*FileNode) RenameFiles 

func (fn *FileNode) RenameFiles()

RenameFiles calls RenameFile on any selected nodes

func (*FileNode) SetRunExec 

func (fn *FileNode) SetRunExec()

SetRunExec sets executable as the RunExec executable that will be run with Run / Debug buttons

func (*FileNode) SetRunExecs 

func (fn *FileNode) SetRunExecs()

SetRunExecs sets executable as the RunExec executable that will be run with Run / Debug buttons

type FileSettings 

type FileSettings struct {

	// if true, then all directories are placed at the top of the tree -- otherwise everything is alpha sorted
	DirsOnTop bool
}

FileSettings contains file picker settings

func (*FileSettings) Defaults 

func (se *FileSettings) Defaults()

Defaults are the defaults for FileSettings

type FindPanel 

type FindPanel struct {
	core.Frame

	// parent code project
	Code *Code `json:"-" xml:"-"`

	// time of last find
	Time time.Time

	// compiled regexp
	Re *regexp.Regexp

	// Renaming indicates this panel is showing proposed symbol rename
	// edits from a language server, instead of search results:
	// the Find string is the old name and Replace is the new name.
	// Replace and All then apply the rename, one at a time or all.
	Renaming bool `json:"-" xml:"-"`

	// Renamed counts the rename edits applied in this session.
	Renamed int `json:"-" xml:"-"`

	// OnReplace, if set, is called after a replace is applied in a
	// buffer, e.g. to sync a language server with the new text.
	OnReplace func(tv *TextEditor) `json:"-" xml:"-"`
}

FindPanel is a find / replace widget that displays results in a TextEditor and has a toolbar for controlling find / replace process.

func NewFindPanel 

func NewFindPanel(parent ...tree.Node) *FindPanel

NewFindPanel returns a new FindPanel with the given optional parent: FindPanel is a find / replace widget that displays results in a TextEditor and has a toolbar for controlling find / replace process.

func (*FindPanel) CheckValidRegexp 

func (fv *FindPanel) CheckValidRegexp() bool

CheckValidRegexp returns false if using regexp and it is not valid

func (*FindPanel) CompileRegexp 

func (fv *FindPanel) CompileRegexp() bool

CompileRegexp compiles the regexp if necessary -- returns false if it is invalid

func (*FindPanel) FindAction 

func (fv *FindPanel) FindAction()

FindAction runs a new find with current params

func (*FindPanel) HighlightFinds 

func (fv *FindPanel) HighlightFinds(tv, ftv *textcore.Editor, res *search.Results, find string)

HighlightFinds highlights all the find results in ftv buffer

func (*FindPanel) Init 

func (fv *FindPanel) Init()

func (*FindPanel) NextFind 

func (fv *FindPanel) NextFind()

NextFind shows next find result

func (*FindPanel) OnAdd 

func (fv *FindPanel) OnAdd()

func (*FindPanel) OpenFindURL 

func (fv *FindPanel) OpenFindURL(ur string, ftv *textcore.Editor) bool

OpenFindURL opens given find:/// url from Find

func (*FindPanel) Params 

func (fv *FindPanel) Params() *FindParams

Params returns the find params

func (*FindPanel) PrevFind 

func (fv *FindPanel) PrevFind()

PrevFind shows previous find result

func (*FindPanel) ReplaceAction 

func (fv *FindPanel) ReplaceAction() bool

ReplaceAction performs the replace. if using regexp mode, regexp must be compiled in advance.

func (*FindPanel) ReplaceAll 

func (fv *FindPanel) ReplaceAll()

ReplaceAll performs replace all

func (*FindPanel) ReplaceAllAction 

func (fv *FindPanel) ReplaceAllAction()

ReplaceAllAction performs replace all, prompting before proceeding

func (*FindPanel) SetCode 

func (t *FindPanel) SetCode(v *Code) *FindPanel

SetCode sets the FindPanel.Code: parent code project

func (*FindPanel) SetOnReplace added in v0.2.0 

func (t *FindPanel) SetOnReplace(v func(tv *TextEditor)) *FindPanel

SetOnReplace sets the FindPanel.OnReplace: OnReplace, if set, is called after a replace is applied in a buffer, e.g. to sync a language server with the new text.

func (*FindPanel) SetRe 

func (t *FindPanel) SetRe(v *regexp.Regexp) *FindPanel

SetRe sets the FindPanel.Re: compiled regexp

func (*FindPanel) SetRenamed added in v0.2.0 

func (t *FindPanel) SetRenamed(v int) *FindPanel

SetRenamed sets the FindPanel.Renamed: Renamed counts the rename edits applied in this session.

func (*FindPanel) SetRenaming added in v0.2.0 

func (t *FindPanel) SetRenaming(v bool) *FindPanel

SetRenaming sets the FindPanel.Renaming: Renaming indicates this panel is showing proposed symbol rename edits from a language server, instead of search results: the Find string is the old name and Replace is the new name. Replace and All then apply the rename, one at a time or all.

func (*FindPanel) SetTime 

func (t *FindPanel) SetTime(v time.Time) *FindPanel

SetTime sets the FindPanel.Time: time of last find

func (*FindPanel) ShowResults 

func (fv *FindPanel) ShowResults(res []search.Results)

ShowResults shows the results in the buffer

func (*FindPanel) TextEditor 

func (fv *FindPanel) TextEditor() *textcore.Editor

TextEditor returns the find results TextEditor

type FindParams 

type FindParams struct {

	// find string
	Find string

	// replace string
	Replace string

	// ignore case
	IgnoreCase bool

	// use regexp regular expression search and replace
	Regexp bool

	// locations to search in
	Loc Locations

	// languages for files to search
	Languages []fileinfo.Known

	// history of finds
	FindHist []string

	// history of replaces
	ReplHist []string
}

FindParams are parameters for find / replace

type LangBackends added in v0.2.0 

type LangBackends int32 //enums:enum -trim-prefix LangBackend

LangBackends specifies which system provides the language services: diagnostics, completions, hover docs, navigation, and symbols. 

const (
	// LangBackendLSP uses external language servers (gopls etc),
	// which run as separate processes and provide full IDE-level
	// language features for any file with an available server,
	// except for languages set to use the parser in the Languages
	// settings (Markdown and TeX by default)
	LangBackendLSP LangBackends = iota

	// LangBackendParser uses the built-in interactive parse system,
	// which runs in-process
	LangBackendParser
)
const LangBackendsN LangBackends = 2

LangBackendsN is the highest valid value for type LangBackends, plus one.

func LangBackendsValues added in v0.2.0 

func LangBackendsValues() []LangBackends

LangBackendsValues returns all possible values for the type LangBackends.

func (LangBackends) Desc added in v0.2.0 

func (i LangBackends) Desc() string

Desc returns the description of the LangBackends value.

func (LangBackends) Int64 added in v0.2.0 

func (i LangBackends) Int64() int64

Int64 returns the LangBackends value as an int64.

func (LangBackends) MarshalText added in v0.2.0 

func (i LangBackends) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface.

func (*LangBackends) SetInt64 added in v0.2.0 

func (i *LangBackends) SetInt64(in int64)

SetInt64 sets the LangBackends value from an int64.

func (*LangBackends) SetString added in v0.2.0 

func (i *LangBackends) SetString(s string) error

SetString sets the LangBackends value from its string representation, and returns an error if the string is invalid.

func (LangBackends) String added in v0.2.0 

func (i LangBackends) String() string

String returns the string representation of this LangBackends value.

func (*LangBackends) UnmarshalText added in v0.2.0 

func (i *LangBackends) UnmarshalText(text []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface.

func (LangBackends) Values added in v0.2.0 

func (i LangBackends) Values() []enums.Enum

Values returns all possible values for the type LangBackends.

type LangService added in v0.2.0 

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

LangService manages the language services for a Code window, routing editor actions to the lsp.Backend (external language servers such as gopls) when the ProjectSettings.LangBackend setting selects it and a server is available for a file, and otherwise leaving the built-in parse system to provide what it can through the standard editor machinery.

It syncs open files with the servers, applies diagnostics as buffer tags, provides completions, hover docs, definitions, references, and symbols to the editor and panels.

func NewLangService added in v0.2.0 

func NewLangService(cv *Code) *LangService

NewLangService returns a new language service for given Code window.

func (*LangService) Activated added in v0.2.0 

func (ls *LangService) Activated(tv *TextEditor)

Activated should be called when a texteditor becomes active, opening its file with the backend and configuring completion functions to use the active backend.

func (*LangService) Change added in v0.2.0 

func (ls *LangService) Change(ln *lines.Lines)

Change syncs the current contents of the buffer to the backend now.

func (*LangService) Closed added in v0.2.0 

func (ls *LangService) Closed(ln *lines.Lines)

Closed should be called when a file is closed in the editor. Language servers are shut down automatically when the last of their files closes. It can be called after the buffer has been closed, which clears its filename. Must be called from the event loop.

func (*LangService) DiagStatusMsg added in v0.2.0 

func (ls *LangService) DiagStatusMsg(ln *lines.Lines) string

DiagStatusMsg returns the current status-bar summary of diagnostics for the given buffer, or "" if none. Called from UpdateStatusText when regenerating the official status line.

func (*LangService) EditorInput added in v0.2.0 

func (ls *LangService) EditorInput(tv *TextEditor)

EditorInput should be called on editor Input events (text changes and cursor movements), to sync changed text to the language server with a debounce delay, and update the signature help.

func (*LangService) ExpandSelection added in v0.2.0 

func (ls *LangService) ExpandSelection(tv *TextEditor) bool

ExpandSelection does Code.ExpandSelection in the given editor, returning false if there is no larger element.

func (*LangService) FilesChanged added in v0.2.2 

func (ls *LangService) FilesChanged(changes []lsp.FileChange)

FilesChanged notifies the language servers of changes to files on disk, and refreshes the problems of files that are not open if the Problems tab is shown. Must be called from the event loop.

func (*LangService) HoverAt added in v0.2.0 

func (ls *LangService) HoverAt(tv *TextEditor, pos textpos.Pos) string

HoverAt returns hover documentation for the word at the given position, using a short-lived cache. The request runs synchronously on the UI goroutine with the server's bounded quick timeout: tooltips are generated once, at LongHoverStart, so there is no second request that an async result could arrive on. Any diagnostic message tagged at that position is included first, from the local record, followed by the available quick fixes.

func (*LangService) Input added in v0.2.0 

func (ls *LangService) Input(ln *lines.Lines)

Input should be called on editor Input events, to sync changed text to the language server with a debounce delay.

func (*LangService) LSPActive added in v0.2.0 

func (ls *LangService) LSPActive(ln *lines.Lines) bool

LSPActive returns whether the language server backend is being used for the given buffer: the LSP backend must be selected in settings, the language must not be set to use the parser in its LanguageOptions, and a server must be registered for the file's language. Otherwise, the built-in parse system provides whatever features it can through the standard editor machinery.

func (*LangService) Lookup added in v0.2.0 

func (ls *LangService) Lookup(tv *TextEditor) bool

Lookup does Code.Lookup for the given editor, returning true if it showed quick fixes or spelling corrections, and false if it offered completions.

func (*LangService) ProgressStatusMsg added in v0.2.0 

func (ls *LangService) ProgressStatusMsg() string

ProgressStatusMsg returns the status bar message for the language server operation in progress, or "" if none.

func (*LangService) Saved added in v0.2.0 

func (ls *LangService) Saved(ln *lines.Lines)

Saved should be called after a file has been saved.

func (*LangService) ScheduleSigHelp added in v0.2.0 

func (ls *LangService) ScheduleSigHelp(tv *TextEditor)

ScheduleSigHelp schedules a LangService.SigHelpUpdate for after the current event has been fully processed and the editor rendered. It must be called from the event loop, for every key event and Input event: the Input event for typed text is sent before the editor moves the cursor past the new text, and some keys move the cursor without any Input event (e.g., typing over an auto-inserted ")").

func (*LangService) SemanticRefresh added in v0.2.0 

func (ls *LangService) SemanticRefresh(ln *lines.Lines)

SemanticRefresh requests semantic tokens for the given buffer from the server asynchronously, replacing any prior semantic tags. The request runs in its own goroutine with the server's bounded timeout; results are applied with self-locking Lines methods, and discarded if a newer pass (or a change/close) has superseded this one.

func (*LangService) ShrinkSelection added in v0.2.0 

func (ls *LangService) ShrinkSelection(tv *TextEditor)

ShrinkSelection does Code.ShrinkSelection in the given editor.

func (*LangService) SigHelpUpdate added in v0.2.0 

func (ls *LangService) SigHelpUpdate(tv *TextEditor)

SigHelpUpdate checks whether the editor cursor is in a function-call parameter context and updates the signature display accordingly: a display-only popup anchored below the cursor (like the completion popup, but nothing is ever inserted) plus the status-bar line. It must be called from the event loop: see LangService.ScheduleSigHelp.

func (*LangService) SigStatusMsg added in v0.2.0 

func (ls *LangService) SigStatusMsg() string

SigStatusMsg returns the current signature help status message, or "" if none. Called from UpdateStatusText when regenerating the official status line.

func (*LangService) Stop added in v0.2.0 

func (ls *LangService) Stop()

Stop halts all language servers and ends the event loop. The service cannot be used after this.

type LanguageOptions 

type LanguageOptions struct {

	// command(s) to run after a file of this type is saved
	PostSaveCmds CmdNames

	// Parser uses the built-in parser for this language, for highlighting,
	// completion, lookup, symbols, and indentation, instead of a language
	// server, when the project uses the LSP language backend. Other
	// languages use a language server when one is available, and otherwise
	// just chroma highlighting. With the Parser backend, the parser is used
	// for all languages that it supports.
	Parser bool
}

LanguageOptions defines options associated with a given language / file format only languages in fileinfo.Known list are supported..

type Languages 

type Languages map[fileinfo.Known]*LanguageOptions

Languages is a map of language options 

var AvailableLanguages Languages

AvailableLanguages is the current set of language options -- can be loaded / saved / edited with settings. This is set to StandardLanguages at startup.

func (*Languages) CopyFrom 

func (lt *Languages) CopyFrom(cp Languages)

CopyFrom copies languages from given other map

func (*Languages) Open 

func (lt *Languages) Open(filename core.Filename) error

Open opens languages from a toml-formatted file.

func (*Languages) OpenSettings 

func (lt *Languages) OpenSettings() error

OpenSettings opens the Langs from the app settings directory, using LanguageSettingsFilename.

func (*Languages) RevertToStandard 

func (lt *Languages) RevertToStandard()

RevertToStandard reverts this map to using the StdLangs that are compiled into the program and have all the lastest standards.

func (*Languages) Save 

func (lt *Languages) Save(filename core.Filename) error

Save saves languages to a toml-formatted file.

func (*Languages) SaveSettings 

func (lt *Languages) SaveSettings() error

SaveSettings saves the Langs to the app settings directory, using LanguageSettingsFilename.

func (Languages) Validate 

func (lt Languages) Validate() bool

Validate checks to make sure post save command names exist, issuing warnings to log for those that don't

func (*Languages) ViewStandard 

func (lt *Languages) ViewStandard()

ViewStandard shows the standard languages that are compiled into the program and have all the lastest standards. Useful for comparing against custom lists.

type Locations added in v0.1.1 

type Locations int32 //enums:enum

Locations are different locations to search in 

const (
	// Open searches in all open directories in a filetree.
	Open Locations = iota

	// All searches in all directories under the root path.
	All

	// Dir searches in the current active directory.
	Dir

	// File searches in the current active file.
	File
)
const LocationsN Locations = 4

LocationsN is the highest valid value for type Locations, plus one.

func LocationsValues added in v0.1.1 

func LocationsValues() []Locations

LocationsValues returns all possible values for the type Locations.

func (Locations) Desc added in v0.1.1 

func (i Locations) Desc() string

Desc returns the description of the Locations value.

func (Locations) Int64 added in v0.1.1 

func (i Locations) Int64() int64

Int64 returns the Locations value as an int64.

func (Locations) MarshalText added in v0.1.1 

func (i Locations) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface.

func (*Locations) SetInt64 added in v0.1.1 

func (i *Locations) SetInt64(in int64)

SetInt64 sets the Locations value from an int64.

func (*Locations) SetString added in v0.1.1 

func (i *Locations) SetString(s string) error

SetString sets the Locations value from its string representation, and returns an error if the string is invalid.

func (Locations) String added in v0.1.1 

func (i Locations) String() string

String returns the string representation of this Locations value.

func (*Locations) UnmarshalText added in v0.1.1 

func (i *Locations) UnmarshalText(text []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface.

func (Locations) Values added in v0.1.1 

func (i Locations) Values() []enums.Enum

Values returns all possible values for the type Locations.

type OpenFiles added in v0.1.1 

type OpenFiles struct {
	keylist.List[string, *lines.Lines]
}

OpenFiles is the ordered list of open files that are being edited. The key is the full filepath, and a recency order is maintained.

func (*OpenFiles) Add added in v0.1.1 

func (of *OpenFiles) Add(ln *lines.Lines) *lines.Lines

Add adds given Lines buffer to list of open files. If already on the list, moves it to the top. Returns the Lines.

func (*OpenFiles) Move added in v0.1.1 

func (of *OpenFiles) Move(to, from int)

Move moves item at given index to destination index. Item is deleted first and then inserted at given index.

func (*OpenFiles) NChanged added in v0.1.1 

func (of *OpenFiles) NChanged() int

NChanged returns number of changed open files.

func (*OpenFiles) Paths added in v0.1.1 

func (of *OpenFiles) Paths() []string

Paths returns the list of full paths of open files.

func (*OpenFiles) ReMarkup added in v0.1.1 

func (of *OpenFiles) ReMarkup()

ReMarkup all open files: when mode color changes etc, during rebuild

func (*OpenFiles) SearchInPaths added in v0.1.1 

func (of *OpenFiles) SearchInPaths(paths []string, find string, ignoreCase bool, langs []fileinfo.Known) []search.Results

SearchInPaths returns search results for given string literal with ignoreCase setting, in all open files contained directly in given paths. If paths is nil then all open files are searched.

func (*OpenFiles) SearchRegexpInPaths added in v0.1.1 

func (of *OpenFiles) SearchRegexpInPaths(paths []string, re *regexp.Regexp, langs []fileinfo.Known) []search.Results

SearchRegexpInPaths returns search results for given string literal with ignoreCase setting, in all open files contained directly in given paths. If paths is nil then all open files are searched.

func (*OpenFiles) Strings added in v0.1.1 

func (of *OpenFiles) Strings(root string) []string

Strings returns a string list of nodes, with paths relative to proj root.

type PreviewPanel added in v0.1.1 

type PreviewPanel struct {
	core.Frame
	// contains filtered or unexported fields
}

PreviewPanel is a widget that displays an interactive live preview of a MD, HTML, or SVG file currently open.

func NewPreviewPanel added in v0.1.1 

func NewPreviewPanel(parent ...tree.Node) *PreviewPanel

NewPreviewPanel returns a new PreviewPanel with the given optional parent: PreviewPanel is a widget that displays an interactive live preview of a MD, HTML, or SVG file currently open.

func (*PreviewPanel) Init added in v0.1.1 

func (pp *PreviewPanel) Init()

type ProjectSettings 

type ProjectSettings struct {

	// file picker settings
	Files FileSettings

	// editor settings
	Editor text.EditorSettings `display:"inline"`

	// current named-split config in use for configuring the splitters
	SplitName SplitName

	// the language associated with the most frequently encountered file
	// extension in the file tree -- can be manually set here as well
	MainLang fileinfo.Known

	// backend that provides language services (diagnostics, completion, hover, navigation, symbols) for this project -- LSP uses external language servers such as gopls, except for languages set to use the parser in the Languages settings (Markdown and TeX by default)
	LangBackend LangBackends

	// if set, language servers that support inlay hints (e.g. gopls) are configured to return them, and the Show Inlay Hints command can display them; running servers pick the change up immediately through dynamic reconfiguration
	InlayHints bool

	// problem messages to ignore: the problems (diagnostics) from language servers whose message contains a key whose value is true are not shown, in the Problems tab or in the editor; commonly ignored Go warnings are listed, disabled, so that they are easy to enable
	IgnoreProblems map[string]bool

	// if set, info and hint problems from language servers (e.g., gopls modernize suggestions) are shown in the editor and the Problems tab, in addition to errors and warnings
	ShowHints bool

	// the type of version control system used in this project (git, svn, etc).
	// filters commands available
	VersionControl vcs.Types

	// current project filename for saving / loading specific Code
	// configuration information in a .code file (optional)
	ProjectFilename core.Filename `extension:".code"`

	// root directory for the project. all projects must be organized within
	// a top-level root directory, with all the files therein constituting
	// the scope of the project. By default it is the path for ProjectFilename
	ProjectRoot core.Filename

	// if true, use Go modules, otherwise use GOPATH -- this sets your effective GO111MODULE environment variable accordingly, dynamically -- updated by toolbar checkbox, dynamically
	GoMod bool

	// command(s) to run for main Build button
	BuildCmds CmdNames

	// build directory for main Build button -- set this to the directory where you want to build the main target for this project -- avail as {BuildDir} in commands
	BuildDir core.Filename

	// build target for main Build button, if relevant for your  BuildCmds
	BuildTarg core.Filename

	// executable to run for this project via main Run button -- called by standard Run Project command
	RunExec core.Filename

	// command(s) to run for main Run button (typically Run Project)
	RunCmds CmdNames

	// custom debugger parameters for this project
	Debug cdebug.Params

	// saved find params
	Find FindParams `display:"-"`

	// saved structure params
	Symbols SymbolsParams `display:"-"`

	// saved scope of the problems shown in the Problems tab
	ProblemsLoc Locations `display:"-"`

	// directory properties
	Dirs filetree.DirFlagMap `display:"-"`

	// last register used
	Register RegisterName `display:"-"`

	// current splitter splits
	Splits [4]float32 `display:"-"`

	// current tabUnder setting for splits
	TabsUnder bool `display:"-"`
}

ProjectSettings are the settings for saving for a project. This IS the project file

func (*ProjectSettings) Open 

func (se *ProjectSettings) Open(filename core.Filename) error

Open open from file

func (*ProjectSettings) RunExecIsExec 

func (se *ProjectSettings) RunExecIsExec() bool

RunExecIsExec returns true if the RunExec is actually executable

func (*ProjectSettings) Save 

func (se *ProjectSettings) Save(filename core.Filename) error

Save save to file

func (*ProjectSettings) Update 

func (se *ProjectSettings) Update()

type RegisterName 

type RegisterName string

RegisterName has an associated ValueView for selecting from the list of available named registers

func (RegisterName) Widget added in v0.1.3 

func (rn RegisterName) Widget() core.Value

Widget registers core.Chooser as the core.Value widget for RegisterName

type Registers 

type Registers map[string]string //types:add

Registers is a list of named strings 

var AvailableRegisters Registers

AvailableRegisters are available named registers. can be loaded / saved / edited with settings.

func (*Registers) Names 

func (lt *Registers) Names() []string

Names returns a slice of current register names

func (*Registers) Open 

func (lt *Registers) Open(filename core.Filename) error

Open opens named registers from a toml-formatted file.

func (*Registers) OpenSettings 

func (lt *Registers) OpenSettings() error

OpenSettings opens the Registers from the app settings directory, using RegisterSettingsFilename.

func (*Registers) Save 

func (lt *Registers) Save(filename core.Filename) error

Save saves named registers to a toml-formatted file.

func (*Registers) SaveSettings 

func (lt *Registers) SaveSettings() error

SaveSettings saves the Registers to the app settings directory, using RegisterSettingsFilename.

type SettingsData 

type SettingsData struct {
	core.SettingsBase

	// file picker settings
	Files FileSettings

	// Terminal has the settings for terminals.
	Terminal TerminalSettings

	// if set, the current customized set of language options (see Edit Lang Opts) is saved / loaded along with other settings -- if not set, then you always are using the default compiled-in standard set (which will be updated)
	SaveLangOpts bool

	// if set, the current customized set of command parameters (see Edit Cmds) is saved / loaded along with other settings -- if not set, then you always are using the default compiled-in standard set (which will be updated)
	SaveCmds bool

	// executable paths for language servers, keyed by server id (gopls, typescript-language-server, pyright-langserver, pylsp, rust-analyzer, clangd, bash-language-server, vscode-json-language-server) -- paths or names to search in PATH if not an absolute path -- empty by default, meaning just search the PATH for the standard executable
	LSExecs map[string]string `display:"-"`
}

SettingsData is the data type for the overall user settings for Code.

func (*SettingsData) Apply 

func (se *SettingsData) Apply()

Apply settings updates things according with settings

func (*SettingsData) Defaults 

func (se *SettingsData) Defaults()

Defaults are the defaults for Settings

func (*SettingsData) EditCmds 

func (se *SettingsData) EditCmds()

EditCmds opens the CmdsView editor to customize commands you can run.

func (*SettingsData) EditLangOpts 

func (se *SettingsData) EditLangOpts()

EditLangOpts opens the LangsView editor to customize options for each type of language / data / file type.

func (*SettingsData) EditRegisters 

func (se *SettingsData) EditRegisters()

EditRegisters opens the RegistersView editor to customize saved registers

func (*SettingsData) EditSplits 

func (se *SettingsData) EditSplits()

EditSplits opens the SplitsView editor to customize saved splitter settings

func (*SettingsData) MakeToolbar 

func (se *SettingsData) MakeToolbar(p *tree.Plan)

func (*SettingsData) Open 

func (se *SettingsData) Open() error

func (*SettingsData) Save 

func (se *SettingsData) Save() error

type SpellPanel 

type SpellPanel struct {
	core.Frame

	// parent code project
	Code *Code `json:"-" xml:"-" copier:"-"`

	// texteditor that we're spell-checking
	Text *TextEditor `json:"-" xml:"-" copier:"-"`

	// current spelling errors
	Errs lexer.Line

	// current line in text we're on
	CurLn int

	// current index in Errs we're on
	CurIndex int

	// current unknown lex token
	UnkLex lexer.Lex

	// current unknown word
	UnkWord string

	// a list of suggestions from spell checker
	Suggest []string

	// last user action (ignore, change, learn)
	LastAction *core.Button
}

SpellPanel is a widget that displays results of a spell check.

func NewSpellPanel 

func NewSpellPanel(parent ...tree.Node) *SpellPanel

NewSpellPanel returns a new SpellPanel with the given optional parent: SpellPanel is a widget that displays results of a spell check.

func (*SpellPanel) AcceptSuggestion 

func (sv *SpellPanel) AcceptSuggestion(s string)

AcceptSuggestion replaces the misspelled word with the word in the ChangeText field

func (*SpellPanel) Change 

func (sv *SpellPanel) Change()

func (*SpellPanel) ChangeBar 

func (sv *SpellPanel) ChangeBar() *core.Toolbar

ChangeBar returns the suggest toolbar

func (*SpellPanel) ChangeText 

func (sv *SpellPanel) ChangeText() *core.TextField

ChangeText returns the unknown word textfield from toolbar

func (*SpellPanel) CheckNext 

func (sv *SpellPanel) CheckNext()

CheckNext will find the next misspelled/unknown word and get suggestions for replacing it

func (*SpellPanel) Config 

func (sv *SpellPanel) Config(cv *Code, atv *TextEditor)

func (*SpellPanel) Destroy 

func (sv *SpellPanel) Destroy()

func (*SpellPanel) Init 

func (sv *SpellPanel) Init()

func (*SpellPanel) SetCode 

func (t *SpellPanel) SetCode(v *Code) *SpellPanel

SetCode sets the SpellPanel.Code: parent code project

func (*SpellPanel) SetCurIndex 

func (t *SpellPanel) SetCurIndex(v int) *SpellPanel

SetCurIndex sets the SpellPanel.CurIndex: current index in Errs we're on

func (*SpellPanel) SetCurLn 

func (t *SpellPanel) SetCurLn(v int) *SpellPanel

SetCurLn sets the SpellPanel.CurLn: current line in text we're on

func (*SpellPanel) SetErrs 

func (t *SpellPanel) SetErrs(v lexer.Line) *SpellPanel

SetErrs sets the SpellPanel.Errs: current spelling errors

func (*SpellPanel) SetLastAction 

func (t *SpellPanel) SetLastAction(v *core.Button) *SpellPanel

SetLastAction sets the SpellPanel.LastAction: last user action (ignore, change, learn)

func (*SpellPanel) SetSuggest 

func (t *SpellPanel) SetSuggest(v ...string) *SpellPanel

SetSuggest sets the SpellPanel.Suggest: a list of suggestions from spell checker

func (*SpellPanel) SetText 

func (t *SpellPanel) SetText(v *TextEditor) *SpellPanel

SetText sets the SpellPanel.Text: texteditor that we're spell-checking

func (*SpellPanel) SetUnkLex 

func (t *SpellPanel) SetUnkLex(v lexer.Lex) *SpellPanel

SetUnkLex sets the SpellPanel.UnkLex: current unknown lex token

func (*SpellPanel) SetUnkWord 

func (t *SpellPanel) SetUnkWord(v string) *SpellPanel

SetUnkWord sets the SpellPanel.UnkWord: current unknown word

func (*SpellPanel) SpellBar 

func (sv *SpellPanel) SpellBar() *core.Toolbar

SpellBar returns the spell toolbar

func (*SpellPanel) SuggestView 

func (sv *SpellPanel) SuggestView() *core.List

SuggestView returns the view for the list of suggestions

func (*SpellPanel) UnkEndPos 

func (sv *SpellPanel) UnkEndPos() textpos.Pos

UnkEndPos returns the end position of the current unknown word

func (*SpellPanel) UnkStartPos 

func (sv *SpellPanel) UnkStartPos() textpos.Pos

UnkStartPos returns the start position of the current unknown word

func (*SpellPanel) UnknownBar 

func (sv *SpellPanel) UnknownBar() *core.Toolbar

UnknownBar returns the toolbar that displays the unknown word

func (*SpellPanel) UnknownText 

func (sv *SpellPanel) UnknownText() *core.TextField

UnknownText returns the unknown word textfield from toolbar

type Split 

type Split struct {

	// name of splitter config
	Name string

	// brief description
	Desc string

	// splitter panel proportions
	Splits [4]float32 `min:"0" max:"1" step:".05"`

	// TabsUnder sets the tabs under the editors, making a more compact layout,
	// suitable for laptop and smaller displays.
	TabsUnder bool
}

Split is a named splitter configuration

func (Split) Label 

func (lt Split) Label() string

Label satisfies the Labeler interface

func (*Split) SaveSplits 

func (lt *Split) SaveSplits(sp []float32)

SaveSplits saves given splits to this setting -- must use copy!

type SplitName 

type SplitName string

SplitName has an associated ValueView for selecting from the list of available named splits

func (SplitName) Widget added in v0.1.3 

func (sn SplitName) Widget() core.Value

Widget registers core.Chooser as the core.Value widget for SplitName

type Splits 

type Splits []*Split //types:add

Splits is a list of named splitter configurations 

var AvailableSplits Splits

AvailableSplits are available named splitter settings. can be loaded / saved / edited with settings. This is set to StandardSplits at startup.

func (*Splits) Add 

func (lt *Splits) Add(name, desc string, splits []float32, tabsUnder bool) (*Split, int)

Add adds a new splitter setting, returns split and index

func (*Splits) CopyFrom 

func (lt *Splits) CopyFrom(cp Splits)

CopyFrom copies named splits from given other map

func (*Splits) Names 

func (lt *Splits) Names() []string

Names returns a slice of current names

func (*Splits) Open 

func (lt *Splits) Open(filename core.Filename) error

Open opens named splits from a json-formatted file.

func (*Splits) OpenSettings 

func (lt *Splits) OpenSettings() error

OpenSettings opens Splits from App standard prefs directory, using PrefSplitsFilename

func (*Splits) Save 

func (lt *Splits) Save(filename core.Filename) error

Save saves named splits to a json-formatted file.

func (*Splits) SaveSettings 

func (lt *Splits) SaveSettings() error

SaveSettings saves Splits to App standard prefs directory, using PrefSplitsFilename

func (*Splits) SplitByName 

func (lt *Splits) SplitByName(name SplitName) (*Split, int, bool)

SplitByName returns a named split and index by name -- returns false and emits a message to stdout if not found

type SymNode 

type SymNode struct {
	tree.NodeBase

	// the symbol
	Symbol syms.Symbol
}

SymNode represents a language symbol -- the name of the node is the name of the symbol. Some symbols, e.g. type have children

func NewSymNode 

func NewSymNode(parent ...tree.Node) *SymNode

NewSymNode returns a new SymNode with the given optional parent: SymNode represents a language symbol -- the name of the node is the name of the symbol. Some symbols, e.g. type have children

func (*SymNode) GetIcon 

func (sn *SymNode) GetIcon() icons.Icon

GetIcon returns the appropriate Icon for this symbol type

func (*SymNode) OpenSyms 

func (sn *SymNode) OpenSyms(pkg *syms.Symbol, fname, match string)

OpenSyms opens symbols from given symbol map (assumed to be package-level symbols) filtered by filename and match -- called on root node of tree.

func (*SymNode) SetSymbol 

func (t *SymNode) SetSymbol(v syms.Symbol) *SymNode

SetSymbol sets the SymNode.Symbol: the symbol

type SymScopes 

type SymScopes int32 //enums:enum -trim-prefix SymScope

SymScopes corresponds to the search scope 

const (
	// SymScopePackage scopes list of symbols to the package of the active file
	SymScopePackage SymScopes = iota

	// SymScopeFile restricts the list of symbols to the active file
	SymScopeFile
)
const SymScopesN SymScopes = 2

SymScopesN is the highest valid value for type SymScopes, plus one.

func SymScopesValues 

func SymScopesValues() []SymScopes

SymScopesValues returns all possible values for the type SymScopes.

func (SymScopes) Desc 

func (i SymScopes) Desc() string

Desc returns the description of the SymScopes value.

func (SymScopes) Int64 

func (i SymScopes) Int64() int64

Int64 returns the SymScopes value as an int64.

func (SymScopes) MarshalText 

func (i SymScopes) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface.

func (*SymScopes) SetInt64 

func (i *SymScopes) SetInt64(in int64)

SetInt64 sets the SymScopes value from an int64.

func (*SymScopes) SetString 

func (i *SymScopes) SetString(s string) error

SetString sets the SymScopes value from its string representation, and returns an error if the string is invalid.

func (SymScopes) String 

func (i SymScopes) String() string

String returns the string representation of this SymScopes value.

func (*SymScopes) UnmarshalText 

func (i *SymScopes) UnmarshalText(text []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface.

func (SymScopes) Values 

func (i SymScopes) Values() []enums.Enum

Values returns all possible values for the type SymScopes.

type SymTree 

type SymTree struct {
	core.Tree
}

SymTree is a Tree that knows how to operate on FileNode nodes

func NewSymTree 

func NewSymTree(parent ...tree.Node) *SymTree

NewSymTree returns a new SymTree with the given optional parent: SymTree is a Tree that knows how to operate on FileNode nodes

func (*SymTree) Init 

func (st *SymTree) Init()

func (*SymTree) SymNode 

func (st *SymTree) SymNode() *SymNode

SymNode returns the SrcNode as a *code* SymNode

type SymbolsPanel 

type SymbolsPanel struct {
	core.Frame

	// parent code project
	Code *Code `json:"-" xml:"-"`

	// params for structure display
	SymParams SymbolsParams

	// all the symbols for the file or package in a tree
	Syms *SymNode

	// only show symbols that match this string
	Match string
	// contains filtered or unexported fields
}

SymbolsPanel is a widget that displays results of a file or package parse of symbols.

func NewSymbolsPanel 

func NewSymbolsPanel(parent ...tree.Node) *SymbolsPanel

NewSymbolsPanel returns a new SymbolsPanel with the given optional parent: SymbolsPanel is a widget that displays results of a file or package parse of symbols.

func (*SymbolsPanel) Config 

func (sv *SymbolsPanel) Config(cv *Code, sp SymbolsParams)

func (*SymbolsPanel) Init 

func (sv *SymbolsPanel) Init()

func (*SymbolsPanel) OpenFile 

func (sv *SymbolsPanel) OpenFile()

OpenFile opens file-level symbols for current active texteditor

func (*SymbolsPanel) OpenPackage 

func (sv *SymbolsPanel) OpenPackage()

OpenPackage opens package-level symbols for current active texteditor

func (*SymbolsPanel) Params 

func (sv *SymbolsPanel) Params() *SymbolsParams

Params returns the symbols params

func (*SymbolsPanel) SetCode 

func (t *SymbolsPanel) SetCode(v *Code) *SymbolsPanel

SetCode sets the SymbolsPanel.Code: parent code project

func (*SymbolsPanel) SetMatch 

func (t *SymbolsPanel) SetMatch(v string) *SymbolsPanel

SetMatch sets the SymbolsPanel.Match: only show symbols that match this string

func (*SymbolsPanel) SetSymParams 

func (t *SymbolsPanel) SetSymParams(v SymbolsParams) *SymbolsPanel

SetSymParams sets the SymbolsPanel.SymParams: params for structure display

func (*SymbolsPanel) SetSyms 

func (t *SymbolsPanel) SetSyms(v *SymNode) *SymbolsPanel

SetSyms sets the SymbolsPanel.Syms: all the symbols for the file or package in a tree

func (*SymbolsPanel) UpdateSymbols 

func (sv *SymbolsPanel) UpdateSymbols()

type SymbolsParams 

type SymbolsParams struct {

	// scope of symbols to list
	Scope SymScopes
}

SymbolsParams are parameters for structure view of file or package

type TerminalSettings added in v0.2.3 

type TerminalSettings struct {

	// Command is the command to run in terminals, with its arguments,
	// such as goal; the default is the user's shell.
	Command string
}

TerminalSettings are the settings for terminals.

type TextEditor 

type TextEditor struct {
	textcore.Editor

	Code *Code
}

TextEditor is the Code-specific version of the TextEditor, with support for setting / clearing breakpoints, etc

func NewTextEditor 

func NewTextEditor(parent ...tree.Node) *TextEditor

NewTextEditor returns a new TextEditor with the given optional parent: TextEditor is the Code-specific version of the TextEditor, with support for setting / clearing breakpoints, etc

func (*TextEditor) ClearBreakpoint 

func (ed *TextEditor) ClearBreakpoint(ln int)

func (*TextEditor) ContextMenu 

func (ed *TextEditor) ContextMenu(m *core.Scene, pos image.Point)

func (*TextEditor) CurDebug 

func (ed *TextEditor) CurDebug() (*DebugPanel, bool)

CurDebug returns the current debugger, true if it is present

func (*TextEditor) DebugVarValueAtPos 

func (ed *TextEditor) DebugVarValueAtPos(pos image.Point) string

DebugVarValueAtPos returns debugger variable value for given mouse position

func (*TextEditor) FindFrames 

func (ed *TextEditor) FindFrames(ln int)

FindFrames finds stack frames in the debugger containing this file and line

func (*TextEditor) HandleDebugDoubleClick 

func (ed *TextEditor) HandleDebugDoubleClick(e events.Event, tpos textpos.Pos)

HandleDebugDoubleClick processes double-clicks NOT on the line-number section

func (*TextEditor) HasBreakpoint 

func (ed *TextEditor) HasBreakpoint(ln int) bool

HasBreakpoint checks if line has a breakpoint

func (*TextEditor) Init 

func (ed *TextEditor) Init()

func (*TextEditor) LineNumberDoubleClick 

func (ed *TextEditor) LineNumberDoubleClick(tpos textpos.Pos)

LineNumberDoubleClick processes double-clicks on the line-number section

func (*TextEditor) SetBreakpoint 

func (ed *TextEditor) SetBreakpoint(ln int)

SetBreakpoint sets breakpoint at given line (e.g., tv.CursorPos.Line)

func (*TextEditor) SetCode 

func (t *TextEditor) SetCode(v *Code) *TextEditor

SetCode sets the TextEditor.Code

func (*TextEditor) ShowContextMenu added in v0.2.0 

func (ed *TextEditor) ShowContextMenu(e events.Event)

ShowContextMenu builds the text editor context menu ShowContextMenu shows the context menu, first moving the cursor to the position of the click if there is no selection, so that the language actions in the menu (lookup, code actions, etc) apply there.

func (*TextEditor) ToggleBreakpoint 

func (ed *TextEditor) ToggleBreakpoint(ln int)

func (*TextEditor) WidgetTooltip 

func (ed *TextEditor) WidgetTooltip(pos image.Point) (string, image.Point)

type VarView 

type VarView struct {
	core.Frame

	// variable being edited
	Var *cdebug.Variable `set:"-"`

	SelectVar *cdebug.Variable `set:"-"`

	// frame info
	FrameInfo string `set:"-"`

	// parent DebugPanel
	DbgView *DebugPanel `json:"-" xml:"-"`
}

VarView shows a debug variable in an inspector-like framework, with sub-variables in a tree.

func NewVarView 

func NewVarView(parent ...tree.Node) *VarView

NewVarView returns a new VarView with the given optional parent: VarView shows a debug variable in an inspector-like framework, with sub-variables in a tree.

func VarViewDialog 

func VarViewDialog(vr *cdebug.Variable, frinfo string, dbgVw *DebugPanel) *VarView

VarViewDialog opens an interactive editor of the given variable.

func (*VarView) Form 

func (vv *VarView) Form() *core.Form

Form returns the main Form

func (*VarView) Init 

func (vv *VarView) Init()

func (*VarView) MakeToolbar 

func (vv *VarView) MakeToolbar(p *tree.Plan)

func (*VarView) SetDbgView 

func (t *VarView) SetDbgView(v *DebugPanel) *VarView

SetDbgView sets the VarView.DbgView: parent DebugPanel

func (*VarView) SetVar 

func (vv *VarView) SetVar(vr *cdebug.Variable, frinfo string)

SetVar sets the source variable and ensures configuration

func (*VarView) Splits 

func (vv *VarView) Splits() *core.Splits

Splits returns the main Splits

func (*VarView) Tree 

func (vv *VarView) Tree() *core.Tree

Tree returns the main Tree

Source Files

View all Source files

Directories

Path Synopsis
Package cdebug provides the general interface for a debugger.
 Package cdebug provides the general interface for a debugger.
cdelve
Package cdelve provides the low-level implementation of the cdebug interface, for the the delve Go debugger.
 Package cdelve provides the low-level implementation of the cdebug interface, for the the delve Go debugger.
stubdbg
cmd
cogent-lsp command
cogent-lsp is a command-line helper around the Cogent LSP client (cogentcore.org/cogent/code/lsp), exposing language server features (gopls and other registered servers) to shells, scripts, CI, and AI agents, without needing to open the editor.
 cogent-lsp is a command-line helper around the Cogent LSP client (cogentcore.org/cogent/code/lsp), exposing language server features (gopls and other registered servers) to shells, scripts, CI, and AI agents, without needing to open the editor.
cogentcode command
lsp-server command
lsp-server manages the language servers used by Cogent's Code editor LSP backend: it lists, installs, and tests the standard set of supported servers (gopls, typescript-language-server, pyright, rust-analyzer, clangd, bash-language-server, vscode-json-language-server, and optional alternatives such as pylsp).
 lsp-server manages the language servers used by Cogent's Code editor LSP backend: it lists, installs, and tests the standard set of supported servers (gopls, typescript-language-server, pyright, rust-analyzer, clangd, bash-language-server, vscode-json-language-server, and optional alternatives such as pylsp).
pie command
Package lang defines backend-neutral data types for the language services used by the Cogent Code editor: diagnostics, locations, and symbols, with positions in editor-native units (0-based lines, rune offsets within lines).
 Package lang defines backend-neutral data types for the language services used by the Cogent Code editor: diagnostics, locations, and symbols, with positions in editor-native units (0-based lines, rune offsets within lines).
Package lsp implements a Language Server Protocol (LSP) client for the Cogent Code editor, driving external language server programs such as gopls (the Go language server) as subprocesses that speak JSON-RPC over stdio.
 Package lsp implements a Language Server Protocol (LSP) client for the Cogent Code editor, driving external language server programs such as gopls (the Go language server) as subprocesses that speak JSON-RPC over stdio.
Package piv provides the PiView object for the full GUI view of the interactive parser (pi) system.
 Package piv provides the PiView object for the full GUI view of the interactive parser (pi) system.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.