Working with Plugins
You can enable the individual plugins in the configuration dialog, which also provides access to additional configuration options for plugins that require it.

Application Plugins
plugins are additional functions for the editor. They can add extra menus and shortcuts, and extend 's features. You can install as many or as few as you like, from within . Open 's configuration dialog with Settings Configure ... Select Application Plugins to choose the wanted plugins.
The available application plugins are:
External Tools - Run external tools and applications
Backtrace Browser - C/C++ Backtrace navigation tool view
Build Plugin - Compile or Make and parse error messages
Close Except/Like - Close group of documents based on a common path or file extension
Color Picker - Show preview for known color names
Colored Brackets - Colored brackets for readability
CTags - Look up definitions/declarations with CTags
Document preview - Preview the document in the target format.
Document switcher - Quick document switching with behavior
File System Browser - File system browser tool view
Document Tree View - Displays the open files in a file tree
Plugin - Provides a simple frontend
Project Plugin - Integration with and other source control systems
Replicode - Constructivist AI language and runtime
LSP Client - LSP client providing code navigation and code completion for many languages
Search & Replace - Search and replace in documents, folders, or projects
Snippets tool view - Tool view embedding the snippets management
Keyboard Macros - Record and play keyboard macros (i.e., keyboard action sequences)
SQL Plugin - Execute query on SQL databases
Symbol Viewer - Extract and show reference symbols from source
Terminal tool view - Have a terminal at the ready, using 's widget
Text Filter - Process text using terminal commands
Completetion - Lists elements, attributes, attribute values and entities allowed by DTD
Validation- Validates files using xmllint

External Tools
The External Tools plugin allows to invoke external applications with data related to the current document, for example its URL, directory, text or selection. Once enabled, a config page appears as depicted below that allows to change or remove existing tools. Similarly, new tools can be added to your liking. The tools will then appear in the External Tools submenu of the Tools menu of the application.
The config page allows to add new external tools by clicking on the Add button. In this case, a popup menu appears where one can either add a new external tool, add an existing tool from a predefined list, or add a new category to organize the external tools into categories. Similarly, the existing tools can be modified either by double-click or by invoking Edit..., and Remove removes the selected tools.

Configuring External Tools
Editing a tool opens a config dialog that allows fine-grained configuration of the tool:
As can be seen, many details can be defined, namely: 	 Name, the name of the tool, which will later appear in the menu.
Icon, optional icon that is visible in the menu.
Executable, executable including either a full path, or your executable must be in the PATH environment variable.
Arguments, optional arguments that are passed to the executable.
Input, optional input that is passed to the process via stdin.
Working directory, the working directory the tool will be started in. If empty, the working directory is set to the current document’s path.
Mime types, if set, the tool is active only if the current document’s mime type matches.
Save, when invoked, saves none, the current document, or all documents.
Trigger, a trigger to execute this tool. A trigger will only affect the currently active document and will only execute if the mimetype of current active document matches the mimetype of the external tool.
Following triggers are available: 	 None, this is the default, it means the tool has no trigger.
Before Save, this trigger will execute right before saving the document.
After Save, this trigger will execute the tool after the document was saved.
Reload current document after execution, useful when the current file is modified on disk.
Output, the output defines the target of stdout. It is either set to Ignored, Insert at Cursor Position, Replace Selected Text, Replace Current Document, Append to Current Document, Insert in New Document, Copy to Clipboard, or Display in Pane.
Editor command, optional command that can be used to invoke the external tool via the built-in command line.
The button Defaults is visible only for tools that are shipped with Kate. When clicked, all tool’s settings reverted to default (aka factory) values.

Variable Expansion
Some editing fields such as the Executable, the Arguments, the Input and the Working Directory support variables that are expanded on tool invocation. This is indicated by the icon {} that appears once one of these text input fields has focus (see red circle):
Hovering over one of these text input fields also shows a tooltip with the current expanded text. Further, clicking on the {} action will open a dialog that lists all available variables:
This feature provides a lot of flexibility when defining an external tool since all variables of the form %{...} are expanded when the tool gets invoked. There are two kind of variables supported:
%{variable-name}
%{variable-name:<value>}
The first form %{variable-name} simply replaces the variable with its contents. For instance, the variable %{Document:FileName} is replaced by the current document’s filename without its path. The second form %{variable-name:<value>} gets the <value> as contents. For example, this can be used to expand an environment variable with %{ENV:HOME}, or one can obtain the current date in the preferred format like %{Date:yyyy-MM-dd}.
Supported variables include: 	 Document:FileBaseName: File base name without path and suffix of the current document.
Document:FileExtension: File extension of the current document.
Document:FileName: File name without path of the current document.
Document:FilePath: Full path of the current document including the file name
Document:Text: Contents of the current document.
Document:Path: Full path of the current document excluding the file name.
Document:NativeFilePath: Full document path including file name, with native path separator (backslash on Windows).
Document:NativePath: Full document path excluding file name, with native path separator (backslash on Windows).
Document:Cursor:Line: Line number of the text cursor position in current document (starts with 0).
Document:Cursor:Column: Column number of the text cursor position in current document (starts with 0).
Document:Cursor:XPos: X component in global screen coordinates of the cursor position.
Document:Cursor:YPos: Y component in global screen coordinates of the cursor position.
Document:Selection:Text: Text selection of the current document.
Document:Selection:StartLine: Start line of selected text of the current document.
Document:Selection:StartColumn: Start column of selected text of the current document.
Document:Selection:EndLine: End line of selected text of the current document.
Document:Selection:EndColumn: End column of selected text of the current document.
Document:RowCount: Number of rows of the current document.
Document:Variable:<variable>: Expand arbitrary document variables.
Date:Locale: The current date in current locale format.
Date:ISO: The current date (ISO).
Date:<value>: The current date (QDate formatstring).
Time:Locale: The current time in current locale format.
Time:ISO: The current time (ISO).
Time:<value>: The current time (QTime formatstring).
ENV:<value>: Access to environment variables.
JS:<expression>: Evaluate simple JavaScript statements.
PercentEncoded:<text>: Percent encoded text.
UUID: Generate a new UUID.

List of Default Tools
Several tools are shipped by default. However, if you have more useful tools please contribute those to kwrite-devel@kde.org so that we can add them to this list. All default tools are visible in the list view by default. However, all tools can be changed to your liking, including the category or even deleting tools. Deleted tools can be added back again by clicking on the Add button in the config page as described above.

git-cola
git-cola is a graphical git client that enables you to easily stage and commit changes. If installed, it is available also through the command line by typing git-cola 	 Name: git-cola
Icon: git-cola
Executable: git-cola
Arguments: -r %{Document:Path}
Editor command: git-cola

gitk
gitk is a git client as well that allows to nicely visualize the git history. 	 Name: gitk
Icon: git-gui
Executable: gitk
Working directory: %{Document:Path}
Editor command: gitk

git blame
Starts git blame to easily follow git changes in the current file. 	 Name: git blame
Executable: git
Arguments: gui blame %{Document:FileName}
Save: Current Document
Working directory: %{Document:Path}
Editor command: git-blame

Run Shell Script
Starts an external konsole in which the current document is executed. The script needs to state the interpreter in the first line via a shebang #!/path/interpreter. 	 Name: Run Shell Script
Icon: system-run
Executable: konsole
Arguments: -e sh -c "cd %{Document:Path} && pwd && chmod -vc a+x %{Document:FileName} && ./%{Document:FileName} ; echo Press any key to continue. && read -n 1"
Save: Current Document
Working directory: %{Document:Path}
Editor command: run-script

Google Selected Text
Search in google for the selected text. 	 Name: Google Selected Text
Icon: globe
Executable: xdg-open
Arguments: "https://www.google.com/search?q=%{Document:Selection:Text}"
Editor command: google

Insert UUID
Inserts a new UUID each time this action is invoked. 	 Name: Insert UUID
Executable: echo
Arguments: %{UUID}
Output: Insert at Cursor Position
Editor command: uuid

Clang Format Full File
Runs clang-format on the current file on disk. The document is reloaded afterwards. 	 Name: Clang Format Full File
Executable: clang-format
Arguments: -i %{Document:FileName}
Working directory: %{Document:Path}
Save: Current Document
Reload: Yes
Editor command: clang-format-file

Clang Format Selected Text
Runs clang-format just on the selected text in the current document. 	 Name: Clang Format Selected Text
Executable: clang-format
Arguments: -assume-fileName: %{Document:FileName}
Working directory: %{Document:Path}
Input: %{Document:Selection:Text}
Output: Replace Selected Text
Editor command: clang-format-selection

Qt Quick 2 Preview (qmlscene)
Previews the current qml file in qmlscene. 	 Name: Qt Quick 2 Preview (qmlscene)
Executable: qmlscene
Arguments: %{Document:FileName}
Save: Current Document
Working directory: %{Document:Path}
Editor command: qml-preview

JSON Format Full File
Format the entire JSON file. 	 Name: JSON Format Full File
Icon: application-json
Executable: jq
Arguments: %{Document:FileName}
Save: Current Document
Working directory: %{Document:Path}
Output: Replace Current Document
Editor command: json-format-file

XML Format Full File
Format the entire XML file. 	 Name: JSON Format Full File
Icon: application-xml
Executable: xmllint
Arguments: --format %{Document:FileName}
Save: Current Document
Working directory: %{Document:Path}
Output: Replace Current Document
Editor command: xml-format-file

Backtrace Browser Plugin

Using the Backtrace Browser Plugin
This plugin is meant for developers and probably of little use for users. It shows a backtrace delivered by gdb in a listview in a toolview. Clicking on an item opens the selected file and jumps to the correct line number. It works for backtraces generated on your own machine, but it will also work for backtraces from other people, with /home/dummy/qt-copy/…/qwidget.cpp will still be found on other machines. For that to work, you have to index the directories where the source code is located.
Sometimes there are several files with the same name, ⪚
kdegraphics/okular/generators/dvi/config.h
kdepim-runtime/resources/gmail/saslplugin/config.h
To pick the right choice, the plugin picks the last two parts of the , in this case this would be
dvi/config.h
saslplugin/config.h
And then usually the plugin finds the correct one.
Indexing master and a branches of course will lead to a clash.

Configuration
On the configuration page add the directories containing the source code.
Backtrace Browser
Configure Paths in Backtrace browser tool view
Clicking OK will start indexing. When indexing is finished, open the toolview Backtrace Browser.
Now you can load a backtrace from the clipboard (⪚, when you clicked Copy to Clipboard in ) or from a file.

Build Plugin

Introduction
The Build plugin allows you to run actions like build, clean and compile on a project.

Using the Build Plugin
The Build plugin adds a Build Output tool view at the bottom and a Build menu on the menubar. The tool view can be used to configure build target settings, while the menu can be used to perform build, clean and compile actions.
Build Output
The Build Output tool view has two tabs:
Target Settings
Output

Target Settings tab
The target settings tab can be used to configure various build targets and define targets sets.
To change the names or commands double click on the entries in the table and use the dropdown box to select the active target set. Use the checkbox in front of each target to define a default.
A new target set contains several configuration options:
Working Directory 	You can set the path to the project here. Leave this empty to use the directory the current document is located in.
Build 	This option lets you define the build command. It is set to make by default.
Clean 	The option lets you define the clean command. It is set to make clean by default.
Config 	This option lets you define the config command. It is set to cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=/usr/local ../ by default.
On the top this plugin has a toolbar with the following buttons :
Build the selected target
Add a new build target
Create a new build target set
Copy a command or target set
Delete the current command or target set

Output tab
The Output tab shows the console output generated by the last command.
Use the slider at the top to show or hide categories of output:
Full Output, Parsed Output, Errors and Warnings or Only Errors
Each line contains a message and the file name and line number if available. Clicking on the error or warning takes you to the appropriate file and places the cursor on the corresponding line number.
To navigate to the previous error, press . To navigate to the next error, press .

Menu Structure
Build Select Target 	Select from a list of targets configured by the user.
Build Build Default Target 	Builds the target defined as default in the active target set.
Build Build Previous Target 	Switch to the previous target configured by the user.
Build Stop 	Stop building a target.
Build Previous Error 	Moves the cursor to the location of the previous error in the document.
Build Next Error 	Moves the cursor to the location of the next error in the document.

Thanks and Acknowledgments
The Build Plugin was written by Kåre Särs.
Special thanks to Google Code-In 2011 participant Salma Sultana for writing much of this section.

Close Except/Like Plugin

Introduction
This plugin allows you to close a group of documents based on their extension and path.

Using the Close Except/Like Plugin
Assumed you have these documents opened in :
/tmp/subfolder/test.h
/tmp/test.cpp
/tmp/test.txt
Then you have the following options to close documents as displayed in the screenshot:
Close Except
Use the checkbox in the last item of the list to enable or disable a confirmation dialog. The selected option will be applied to both close actions.

Menu Structure
File Close Except 	 Close all open documents, except those which match the path or file extension selected from the submenu.
File Close Like 	 Close all open documents which match the path or file extension selected from the submenu.

Color Picker Plugin

Introduction
This plugin adds an inline color preview/picker to colors in the text (⪚, #FFFFFF, white).
To load this plugin open 's configuration dialog under Settings Configure .... Then select Color Picker and close the dialog.

Configuration
On the Color Picker settings page in 's configuration, you can configure the following options of the plugin behavior.
Show preview for known color names 	 Whether to show the color picker for known color names (⪚, skyblue). See this page for the list of colors.
Place preview after text color 	 Whether to place the inline preview after text color in the text.
Hex color matching 	 Here, you can choose the best matching option for the colors used in your code.

Colored Brackets

Introduction
Colored brackets plugin colors matching bracket pairs in different colors to enhance readability. However, not all brackets get colored. A bracket whose matching opener or closer is not visible will be ignored. Similarly, a bracket pair that is the sole bracket pair on a line will not get colored.

Configuration
The plugin doesn't provide any configurations.

CTags Plugin

Introduction
CTags generates an index (or tag) file of language objects found in source files that allows these items to be quickly and easily located using this plugin in .
A tag signifies a language object for which an index entry is available (or, alternatively, the index entry created for that object).
Tag generation is supported for these programming languages.

Configuration
The CTags plugin uses two different database files for the index.
On the CTags settings page in 's configuration you can add or remove directories containing the source code and regenerate the common CTags database.

Common Index
CTags Settings
Configure CTags Global Database
At the bottom of the settings page you can adapt the CTags command.
For more information about all available options please read the CTags man page. This man page is available in and you can also enter the man:/ctags directly into
Clicking Update will start indexing. When indexing is finished, close the dialog.

Session Index
To configure the session index open the CTags view.
Index Targets 	 On this tab you can add or remove directories containing the source code and manually regenerate the session specific CTags database.
Database 	 Database Settings
Configure CTags Session Database
Select another CTags database file, configure the CTags command or revert to the default command.

Using the CTags Plugin
You place the mouse cursor on the language object like function, symbol that you are interested in and then select one of the actions in the CTags menu to jump to the line and file where the object is defined or declared.
By default the actions in the CTags menu have no shortcuts assigned. Use the keyboard shortcut editor to configure your own shortcuts.
Alternatively use the search field on the Lookup tab of the CTags view.
Entering characters into the search field will start the search and display matching names of language objects like functions, classes, symbols together with type and filename.
Select an item in the list to jump to the corresponding line in the source file.

Menu Structure
CTags Jump back one step 	 Navigate back in the history to the last visited tag.
CTags Lookup Current Text 	 Opens the Lookup tab of the CTags view and displays all language objects matching the current text selection in the list.
CTags Go to Declaration 	 If the cursor is in a definition object this will open the document containing the corresponding declaration if needed, activate its view and place the cursor at the start of the declaration.
CTags Go to Definition 	 If the cursor is in a declaration object this will open the document containing the corresponding definition if needed, activate its view and place the cursor at the start of the definition.

Document Preview Plugin

Introduction
The plugin enables a live preview of the currently edited text document in the final format in the sidebar. So when editing ⪚ a text or an image, the result is instantly visible next to the source text.
For the display the plugin uses that plugin which is currently selected as the preferred one for the type of the document. If there is no plugin for that type, no preview is possible.
To change the preferred plugin open the File Associations module in the and edit the Services Preference Order on the Embedding tab.

Some available plugins
type	plugin
text	KMarkdownWebViewPart or OkularPart
image	SVGPart
UI files	KUIViewerPart
graph files	KGraphviewerPart

Menu Structure
View Tool Views Show Preview 	 Toggle the display of 's Document preview in a sidebar.

Interface
The buttons at the top of the preview window provide these actions:
Lock the preview to a given document. Selecting this option ensures that if switching the focus to the view of another document in the same window, the preview will not follow to that document, but keep previewing this document.
Enable or disable updates of the preview of the current document content
Manually update the preview of the current document content
A dropdown menu with actions from the plugin

Document Switcher Plugin

Menu Structure
View Last Used Views 	 View Last Used Views (Reverse) 	 Opens a list with the last viewed documents:
Last viewed documents
Keep the key pressed and use the key to cycle forward through the list. Additionally press the key to reverse the direction.
Keep the shortcut pressed and can use the , , or keys to navigate in the list. Pressing a char key consecutively will cycle through all items with the first matching in the list. If you release the shortcut keys the view will switch to the selected document in the list.

File System Browser
The File System Browser is a folder viewer, allowing you to open files from a displayed folder in the current frame.

Menu Structure
View Tool Views Show Filesystem Browser 	 Toggle the display of 's Filesystem Browser.

Interface
From the top down, the Filesystem Browser consists of the following elements:
A Toolbar 	 This contains standard navigations tool buttons:
Back 	Causes the folder view to cd to the previously displayed folder in the history. This button is disabled, if there is no previous item.
Forward 	Causes the folder view to cd to the next folder in the history. This button is disabled, if there is no next folder.
Bookmarks 	Opens a submenu to edit or add bookmarks and to add a new bookmark folder.
Current Document Folder 	This button will cause the folder view to cd to the folder of the currently active document if possible. This button is disabled, if the active document is a new, unsaved file, or the folder in which it resides can not be decided.
Options 	
Short View 	Displays only the filenames.
Detailed View 	Displays Name, Date and Size of the files.
Tree View 	Like Short View, but folders can be expanded to view their contents.
Detailed Tree View 	This also allows folders to be expanded, but displays the additional columns available in Detailed View.
Show Hidden Files 	Displays files normally hidden by your .
Automatically synchronize with current document 	When this option is enabled the filesystem browser will automatically cd to the folder of the document currently open in the editing area every time it changes.
A Location Entry 	 This displays a breadcrumb navigation to the currently open folder, similarly to . You can click on a any folder to browse to it, or click on one of the arrows to the left of a folder to select any folders beneath it. You may also select from your list of Places by clicking the leftmost icon in the breadcrumb navigation, which displays an icon that represents your current Place.
You can also click to the right of the breadcrumbs to change them to a text box where you can type the path of a folder to browse. The entry maintains a list of previously typed paths. To choose one, use the arrow button to the right of the entry.
The entry has folder auto-completion. The completion method can be set using the menu of the text entry.
A Folder View 	This is a standard folder view.
A Filter Entry 	 The Filter entry allows you to enter a filter for the files displayed in the folder view. The filter uses standard globs; patterns must be separated by white space. Example: *.cpp *.h *.moc
To display all files, enter a single asterisk *.
The filter entry saves the last 10 filters entered between sessions. To use one, press the arrow button on the right of the entry and select the desired filter string. You can disable the filter by pressing the Clear text button to the left of the autocompletion arrow button.

Configuration
This plugin can be configured on the Filesystem Browser page of 's configuration.
Toolbar 	Configure the buttons on the Filesystem Browser toolbar by moving the ones you want enabled to the Selected Actions list, and order them using the arrow buttons at the side of the list.

The Documents List

Introduction
The documents list displays a list of all documents currently open in . Modified files will have a small floppy disk icon on their left to indicate that state.
On the top the Documents list has a toolbar with the following buttons:
Create new document
Open an existing document
Previous Document
Next Document
Save the current document
Save the current document under a new name
By default, the Documents list appears in Tree Mode, which displays the folder structure surrounding all currently open documents. Also available is List Mode, which displays a simple list of all open documents. You can switch modes by right-clicking on the list and selecting from the View Mode menu.
If two or more files with the same name (located in different folders) are open in List Mode, the names of the second will be prepended (2) and so on. The tool-tip for the file will display its full name including the path, allowing you to choose the desired one.
To display a document in the currently active frame, click the document name in the list.
The context menu has some common actions from the File menu.
Additionally there are filemanager actions to rename or delete the file. With Copy Location you can copy the full path of the document to the clipboard.
You can sort the list in a few different ways by right clicking the list and selecting from the Sort By menu. The options are:
Document Name 	Lists the documents alphabetically by their name.
Document Path 	Lists the documents alphabetically by the path to them.
Opening Order 	Lists the documents in the order of opening.
The document list will per default visualize your history by shading the entries for the most recent documents with a background color. If the document was edited, an extra color is blended in. The most recent document has the strongest color, so that you can easily find the documents you are working on. This feature can be disabled in the Documents page of the configuration dialog.
The default location of the document list in the window is to the left of the editing area.

Menu Structure
View Previous Document 	 Opens the document displayed above the currently open document in the Documents list.
View Next Document 	 Opens the document displayed below the currently open document in the Documents list.
View Show Active 	 Displays the currently open document in the Documents list.

Configuration
Background Shading 	This section allows you to enable or disable the background shading visualization of your recent activity, and choose which colors to use if enabled.
Sort By 	Set how you want the document list sorted. This can be set from the menu in the document list as well.
View Mode 	This provides two options that effect the display of the Documents tool view. The Tree View option will display the documents in a tree underneath the folders they are in, while the List View option will display a flat list of documents.
Show Full Path 	When Tree View and this option are enabled, the folder entries displayed in the Documents tool view will display the full filesystem path to the folder in addition to the name of the folder. It has no effect in List View.
Show Toolbar 	When Tree View and this option are enabled, a toolbar with actions like Save is displayed above the list of documents. Uncheck this option if the toolbar should be hidden.
Show Close Button 	When this option is enabled, will show a close button for opened documents on hover.

Plugin

Introduction
's plugin provides a simple frontend to the popular Project Debugger.
Previous experience with is strongly recommended. For more information on using , visit the website.
You can enable the plugin in the Plugins section of 's configuration.
For the plugin to work properly, you must have a source file (of any type supported by ) and an executable.
If you compile using /g++ you might want to use the -ggdb command line argument.
After these preparations are made, open the source file in , enter the path to the executable in the Settings tab of the Debug View tool view, and select Debug Start Debugging from the menu to get started.

Menu and Toolbar Structure
All of these options are available in 's menus, and many are available on the Debug toolbar as well.
View Tool View Show Debug View 	Shows a tool view containing output, the command line used, and other settings.
View Tool View Show Locals and Stack 	Shows a list of all currently loaded variables and their values and a backtrace.
Debug Targets 	A submenu containing a list of targets (executables).
Debug Start Debugging 	Starts with a target.
Debug Kill / Stop Debugging 	Stops .
Debug Restart Debugging 	Restarts .
Debug Toggle Breakpoint / Break 	Set a breakpoint at the current cursor position.
Debug Step In 	Execute the present statement (function call will be debugged).
Debug Step Over 	Execute the present statement (function call will not be debugged).
Debug Step Out 	Resumes execution until the program that is executing terminates.
Debug Move PC 	Move program counter (next execution).
Debug Run To Cursor 	Runs the program until it reaches current cursor position.
Debug Continue 	Ignores any breakpoints and executes program until it terminates (successfully or not).
Debug Print Value 	Prints the value of the variable that the cursor is currently pointing to.
Settings Toolbars Shown Plugin 	Display the debugging toolbar.

Debug View
The Debug View tool view consists of several tabs:
Output 	 Contains output from and a command line.
The Output Tab
The Output tab.
The Output tab displaying the output from a debugging session.
Settings 	
Executable 	Path to the target (executable) for debugging.
Working Directory 	The current working directory provided to the target.
Arguments 	Arguments passed to the program.
Keep focus 	Keeps focus on the command line.
Redirect IO 	Opens a new IO tab in the Debug View where you can view output and provide input to the running program.
The Settings dialog
The Settings dialog
The Settings dialog displaying the configuration of a debugging session.
IO 	 Contains an area that displays output from the running program and a command line where you may provide input to it.
The IO Tab
The IO tab.
The IO tab displaying output from a simple test program.

Call Stack and Locals
The Call Stack tool view contains a list of the formatted backtrace returned from .
The Call Stack Tool View
The Call Stack tool view.
The Plugin's Call Stack tool view.
The Locals tool view contains a list of all currently loaded variables from the program and their corresponding values.
The Locals Tool View
The Locals tool view.
The Plugin's Locals tool view.

Thanks and Acknowledgments
Special thanks to Google Code-In 2011 participant Martin Gergov for writing much of this section.

Project Plugin

Introduction
The basic idea of the Project plugin is to have a structured list of files belonging to the project with the following properties:
Provide a structured view of the files
Make it easy and very fast to open and switch projects
Support search and replace for a project
Provide simple auto completion
Make it simple to quickly open files in the project
Support for building the project

Structured View of the Files
Once the Project plugin is loaded in the configuration page, open a file in a project and a sidebar appears that lists all projects as well as the project files as follows:
Project View
As you can see, the currently active project is Kate, and its contents is listed in the tree view. Clicking on files in the tree view opens the file in the editor. Further, a context menu is provided with which you can open files with other applications, such as a .ui file with Qt Designer.
You can filter the items by typing parts of the file name you are looking for into the search bar at the bottom of the list.

Switching Projects
The idea is that you never have to open a project manually, this is even not supported at all. Hence, what happens if you open a file, the Project plugin quickly scans the folder and its parent folders for a .kateproject file. If found, the project is automatically loaded.
Furthermore, if you open another document in , that belongs to another project, the Project plugin automatically switches the current project. So intuitively, always the correct project is active. Of course, you can also switch the currently active project using the combo box.

Search and Replace in Projects
has a Search and Replace plugin that shows up in the bottom sidebar. If a project is loaded, open the Search and Replace sidebar, and switch to the mode to search and replace in the current project:
Search in Projects

Simple Auto Completion
With the knowledge of all files belonging to a project, the Project plugin provides simple auto completion facilities based on CTags. If a project is initially opened, CTags parses all project files in a background thread and saves the CTags information to /tmp. This file then is used to populate the auto completion popup in .
In contrast, without this auto completion, is only capable of showing auto completion items based on the words in the current file. So the auto completion provided by the Project plugin is much more powerful.
Completion in Projects
If CTags is missing, a passive popup warns you about this issue. It is also noteworthy, that the CTags file in /tmp is cleaned up when exits, so the plugin does not pollute any folder with unwanted files.

Support for Building the Project
Another feature is to have support for the Build Plugin, so that it automatically is configured correctly.

Creating Projects

Loading Projects Automatically
The Project plugin has an auto-loading feature. You can read the file list from the version control system. To this end, auto-loading for the respective version control system needs to be enabled in the settings (enabled by default):
Project Plugin Configuration

Creating Projects Manually
You just have to create a .kateproject file in the root folder of the project. For instance, the Kate .kateproject file looks like this:

{
  "name": "Kate",
  "files": [
    {
      "git": 1
    }
  ]
}

The file content is written in syntax. The project name is Kate, and the files contained in should be read from .
Also supported instead of git is subversion through svn and mercurial through hg. If you do not want to read files from a version control system, you can just invoke kate from command line as:

kate /path/to/folder

or you can tell it to recursively load files from directories as follows:

{
  "name": "Kate",
  "files": [
    {
      "directory": "kate",
      "filters": [
        "*.cpp",
        "*.h",
        "*.ui",
        "CMakeLists.txt",
        "Find*.cmake"
      ],
      "recursive": 1
    }
  ]
}

Here, subfolders and filters define what’s part of the project. You can also mix version control and files based on filters.
If you want to add support for the building, you can write a .kateproject like this:

{
  "name": "Kate",
  "files": [
    {
      "git": 1
    }
  ],
  "build": {
    "directory": "build",
    "build": "make all",
    "clean": "make clean",
    "install": "make install",
    "targets": [
      {
        "name": "all",
        "build_cmd": "ninja"
        "run_cmd": "./bin/kate"
      },
      {
        "name": "kate",
        "build_cmd": "ninja kate-bin"
      }
    ]
  }
}

The targets specified above will then appear in the Build Plugin under "Project Plugin Targets". If the "targets" array is specified then "build", "clean" and "install" are ignored. Each element in the array specifies a target. "name" is the name of the target, "build_cmd" will be used to build the target, "run_cmd" will be used to run the target. Most important of all is "directory", this is where the commands will be executed.
In case you have a .kateproject file tracked by a control version system, but you need to tweak the configuration for a particular workspace, you can save those changes to a separated file named .kateproject.local. The content of this file will take precedence over .kateproject.

Current Project
Using 1 Projects Go To you can open the Current Project view at the bottom of the editor window with four tabs:
Current Project
Terminal Panel 	 A Terminal emulator starting in the root folder of the project.
Code Index 	 Entering characters into the search bar will start the search and display matching names of functions, classes, symbols together with kind, filename and line number.
Select an item in the list to jump to the corresponding line in the source file.
Code Analysis 	 Click Start Analysis to run a static code analysis for the C and C++ using cppcheck and to generate a report showing filename, line number, severity (style, warning ) and the issue found.
Select an item in the list to jump to the corresponding line in the source file.
Notes 	 Text entered in this tab will be saved in the file .kateproject.notes.

The Projects Menu
The Projects menu allows you to switch between currently open projects. It is displayed by the Project plugin.
Projects Back 	 Switch to the previous project.
Projects Forward 	 Switch to the next project.
1 Projects Go To 	 Open the Current Project view at the bottom of the editor window.

LSP Client Plugin
The LSP Client plugin provides many language features such as code completion, code navigation or finding references based on the Language Server Protocol.
Once you have enabled the LSP Client in the plugin page, a new page called LSP Client will appear in your configuration dialog.

Menu Structure
If appropriate, a corresponding LSP command is also mentioned in the explanation below, the documentation of which may then provide additional background and interpretation, though it may vary depending on the actual language. The phrase 'current symbol' refers to the symbol corresponding to the current cursor position, as so determined by the language and server implementation.
LSP Client Go to Definition 	 [textDocument/definition] Go to current symbol definition.
LSP Client Go to Declaration 	 [textDocument/declaration] Go to current symbol declaration.
LSP Client Go to Type Definition 	 [textDocument/typeDefinition] Go to current symbol type definition.
LSP Client Find References 	 [textDocument/references] Find references to current symbol.
LSP Client Find Implementations 	 [textDocument/implementation] Find implementations of current symbol.
LSP Client Highlight 	 [textDocument/documentHighlight] Highlight current symbol references in current document.
LSP Client Hover 	 [textDocument/hover] Hover info for current symbol.
LSP Client Format 	 [textDocument/formatting] [textDocument/rangeFormatting] Format the current document or current selection.
LSP Client Rename 	 [textDocument/rename] Rename current symbol.
LSP Client Quick Fix 	 [textDocument/codeAction, workspace/executeCommand] Computes and applies a quick fix for a diagnostic on current position (or line).
LSP Client Show selected completion documentation 	 Show documentation for a selected item in the completion list.
LSP Client Enable signature help with auto completion 	 Also show signature help in the completion list.
LSP Client Include declaration in references 	 Request to include a symbol's declaration when requesting references.
LSP Client Add parentheses upon function completion 	 Automatically add a pair of parentheses after completion of a function.
LSP Client Show hover information 	 Show hover information upon (mouse cursor) hover. Regardless of this setting, the request can always be manually initiated.
LSP Client Format on typing 	 [document/onTypeFormatting] Format parts of document when typing certain trigger characters. For example, this might apply indentation upon newline, or as otherwise determined by LSP Server. Note that editor indentation scripts might be trying to do the same (depending on the mode) and so it may not be advisable to have both enabled at the same time.
LSP Client Incremental document synchronization 	 Send partial document edits to update the server rather than whole document text (if supported).
LSP Client Highlight goto location 	 Provide a transient visual cue after performing a goto to a location (of definition, declaration, etc).
LSP Client Show diagnostics notifications 	 [textDocument/publishDiagnostics] Process and show diagnostics notifications sent by server.
LSP Client Show diagnostics highlights 	 Add text highlights for ranges indicated in diagnostics.
LSP Client Show diagnostics marks 	 Add document marks for lines indicated in diagnostics.
LSP Client Switch to diagnostic tab 	 Switch to the diagnostic tab in the plugin toolview.
LSP Client Close all non-diagnostics tabs 	 Close all non-diagnostics (⪚ references) tabs in plugin toolview.
LSP Client Restart LSP Server 	 Restart current document's LSP Server.
LSP Client Restart all LSP Servers 	 Stop all LSP Servers which will then be (re)started as needed.

Goto Symbol support
LSP Client can help you jump to any symbol in your project or current file. To jump to any symbol in the file, use the toolview "LSP Client Symbol Outline" on the right border of kate. This toolview lists all symbols found by the server in current document.

Configuring LSP Client Symbol Outline
By default the symbols are sorted by their occurrence in the document but you can change the sort to be alphabetical. To do so, right click in the toolview and check "Sort Alphabetically".
The toolview shows the symbols in tree mode by default, however you can change it to a list using the context menu.

Global Goto symbol support
To jump to any symbol in your project, you can open the goto symbol dialog using p. The dialog is empty when it opens but as soon as you type something the dialog will start showing you matching symbols. The quality of matches as well as filtering capabilities depend upon the server that you use. For example, clangd supports fuzzy filtering but some other server may not.

Other Features
Clangd switch source header command is supported. To switch source header in a C or C++ project either use the "Switch Source Header" option from the context menu or the shortcut F12.
You can jump to a symbol quickly by putting your mouse over the symbol and then pressing + left mouse button.

Configuration
The plugin's configuration page mostly allows for persistent configuration of some of the above menu items. However, there is one additional entry to specify the Server Configuration file. This is a file that can be used to specify the LSP server to start (and then to communicate with over stdin/stdout). For convenience, some default configuration is included, which can be inspected in the plugin's configuration page. To aid in the explanation below, an excerpt of that configuration is given here:

{
    "servers": {
        "bibtex": {
            "use": "latex",
            "highlightingModeRegex": "^BibTeX$"
        },
        "c": {
            "command": ["clangd", "-log=error", "--background-index"],
            "commandDebug": ["clangd", "-log=verbose", "--background-index"],
            "url": "https://clang.llvm.org/extra/clangd/",
            "highlightingModeRegex": "^(C|ANSI C89|Objective-C)$"
        },
        "cpp": {
            "use": "c",
            "highlightingModeRegex": "^(C\\+\\+|ISO C\\+\\+|Objective-C\\+\\+)$"
        },
        "d": {
            "command": ["dls", "--stdio"],
            "url": "https://github.com/d-language-server/dls",
            "highlightingModeRegex": "^D$"
        },
        "fortran": {
            "command": ["fortls"],
            "rootIndicationFileNames": [".fortls"],
            "url": "https://github.com/hansec/fortran-language-server",
            "highlightingModeRegex": "^Fortran.*$"
        },
        "javascript": {
            "command": ["typescript-language-server", "--stdio"],
            "rootIndicationFileNames": ["package.json", "package-lock.json"],
            "url": "https://github.com/theia-ide/typescript-language-server",
            "highlightingModeRegex": "^JavaScript.*$",
            "documentLanguageId": false
        },
        "latex": {
            "command": ["texlab"],
            "url": "https://texlab.netlify.com/",
            "highlightingModeRegex": "^LaTeX$"
        },
        "go": {
            "command": ["go-langserver"],
            "commandDebug": ["go-langserver", "-trace"],
            "url": "https://github.com/sourcegraph/go-langserver",
            "highlightingModeRegex": "^Go$"
        },
        "python": {
            "command": ["python3", "-m", "pyls", "--check-parent-process"],
            "url": "https://github.com/palantir/python-language-server",
            "highlightingModeRegex": "^Python$"
        },
        "rust": {
            "command": ["rls"],
            "path": ["%{ENV:HOME}/.cargo/bin", "%{ENV:USERPROFILE}/.cargo/bin"],
            "rootIndicationFileNames": ["Cargo.lock", "Cargo.toml"],
            "url": "https://github.com/rust-lang/rls",
            "highlightingModeRegex": "^Rust$"
        },
        "ocaml": {
            "command": ["ocamlmerlin-lsp"],
            "url": "https://github.com/ocaml/merlin",
            "highlightingModeRegex": "^Objective Caml.*$"
        }
    }
}

Note that each "command" may be an array or a string (in which case it is split into an array). Also, a top-level "global" entry (next to "server") is considered as well (see further below). The specified binary is searched for in the usual way, e.g. using PATH. If it is installed in some custom location, then the latter may have to be extended. Or alternatively, a (sym)link or wrapper script may be used in a location that is within the usual PATH. As illustrated above, one may also specify a "path" that will be searched for after the standard locations.
All of the entries in "command", "root" and "path" are subject to variable expansion.
The "highlightingModeRegex" is used to map the highlighting mode as used by to the language id of the server. If no regular expression is given, the language id itself is used. If a "documentLanguageId" entry is set to false, then no language id is provided to the server when opening the document. This may have better results for some servers that are more precise in determining the document type than doing so based on a kate mode.
From the above example, the gist is presumably clear. In addition, each server entry object may also have an "initializationOptions" entry, which is passed along to the server as part of the 'initialize' method. If present, a "settings" entry is passed to the server by means of the 'workspace/didChangeConfiguration' notification.
Various stages of override/merge are applied;
user configuration (loaded from file) overrides (internal) default configuration
"lspclient" entry in .kateproject project configuration overrides the above
the resulting "global" entry is used to supplement (not override) any server entry
One server instance is used per (root, servertype) combination. If "root" is specified as an absolute path, then it used as-is, otherwise it is relative to the projectBase (as determined by the Project plugin) if applicable, or otherwise relative to the document's directory. If not specified and "rootIndicationFileNames" is an array as filenames, then a parent directory of current document containing such a file is selected. Alternatively, if "root" is not specified and "rootIndicationFilePatterns" is an array of file patterns, then a parent directory of the current document matching the file pattern is selected. As a last fallback, the home directory is selected as "root". For any document, the resulting "root" then determines whether or not a separate instance is needed. If so, the "root" is passed as rootUri/rootPath.
In general, it is recommended to leave root unspecified, as it is not that important for a server (your mileage may vary though). Fewer server instances are obviously more efficient, and they also have a 'wider' view than the view of many separate instances.
As mentioned above, several entries are subject to variable expansion. A suitable application of that combined with "wrapper script" approaches allows for customization to a great many circumstances. For example, consider a python development scenario that consists of multiple projects (e.g. git repos), each with its own virtualenv setup. Using the default configuration, the python language server will not be aware of the virtual env. However, that can be remedied with the following approach. First, the following fragment can be entered in LSPClient plugin's "User Server Settings":

{
        "servers":
        {
                "python":
                {
                        "command": ["pylsp_in_env"], ["%{Project:NativePath}"],
                        "root": "."
                }
        }
}

The root entry above is relative to the project directory and ensures that a separate language server is started for each project, which is necessary in this case as each has a distinct virtual environment.
pylsp_in_env is a small "wrapper script" that should be placed in PATH with the following (to-be-adjusted) content:

#!/bin/bash
cd $1
# run the server (python-lsp-server) within the virtualenv
# (i.e. with virtualenv variables setup)
# so source the virtualenv
source XYZ
# server mileage or arguments may vary
exec myserver

LSP Server Configuration
Each particular LSP server has its own way of customization and may use language/tool specific means for configuration, ⪚ tox.ini (a.o. for python), .clang-format for C++ style format. Such configuration may then also be used by other (non-LSP) tools (such as then tox or clang-format). On top of that, some LSP servers also load configuration from custom files (⪚ .ccls). Furthermore, custom server configuration can also be passed through LSP (protocol), see the aforementioned "initializationOptions" and "settings" entries in server configuration.
Since various level of override/merge are applied, the following example of user specified client configuration tweaks some python-language-server configuration.

{
    "servers": {
        "python": {
            "settings": {
                "pyls": {
                    "plugins": {
                        "pylint": {
                            "enable": true
                        }
                    }
                }
            }
        }
    }
}

Unfortunately, LSP server configuration/customization is often not so well documented, in ways that only examining the source code shows configuration approaches and the set of available configuration options. In particular, the above example's server supports many more options in "settings". See another LSP client's documentation for various other language server examples and corresponding settings, which can easily and readily be transformed to the configuration that is used here and outlined above.

LSP Server Diagnostic Suppression
It may happen that diagnostics are reported which are not quite useful. This can be quite cumbersome, especially if there are many (often of the same kind). In some cases, this may be tweaked by language (server) specific means. For example, the clangd configuration mechanism allows tweaking of some diagnostics aspects. In general, however, it may not always be evident how to do so, or it may not even be possible at all in desired ways due to server limitations or bug.
As such, the plugin supports diagnostics suppression similar to e.g. valgrind suppressions. The most fine-grained configuration can be supplied in a "suppressions" key in the (merged) configuration.

{
    "servers": {
        "c": {
            "suppressions": {
                "rulename": ["filename", "foo"],
                "clang_pointer": ["", "clang-tidy", "clear_pointer"],
            }
        }
    }
}

Each (valid) rule has an arbitrary name and is defined by an array of length 2 or 3 which provides a regex to match against the (full) filename, a regex to match against the diagnostic (text) and an optional regex matched against the (source code range of) text to which the diagnostic applies.
In addition to the above fine-grained configuration, the context menu in the diagnostics tab also supports add/remove of suppressions that match a particular diagnostic (text) exactly, either globally (any file) or locally (the specific file in question). These suppression are stored in and loaded from session config.

LSP Server Troubleshooting
It is one thing to describe how to configure a (custom) LSP server for any particular language, it is another to end up with the server running smoothly. Usually, the latter is fortunately the case. Sometimes, however, problems may arise due to either some "silly" misconfiguration or a more fundamental problem with the server itself. The latter might typically manifest itself as a couple of attempts at starting the server, as so reported in Output tab. The latter, however, is only meant to convey high-level messages or progress rather than to provide detailed diagnostics, and even less so for what is in fact another process (the LSP server).
The usual way to diagnose this is to add some flag(s) to the startup command (of the language server) that enables (additional) logging (to some file or standard error), in as far as it does not do so by default. If is then started on the command line, then one might be able to obtain more (in)sight in what might be going wrong.
It may also be informative to examine the protocol exchange between 's LSP client and the LSP server. Again, the latter usually has ways to trace that. The LSP client also provides additional debug tracing (to stderr) when is invoked with the following QT_LOGGING_RULES=katelspclientplugin=true suitably export'ed.

Search & Replace

Introduction
's Search & Replace plugin allows you to search for text or regular expressions in many different files at once. You can search all open files, all the files in one directory and optionally its subdirectories, or in the active file. You can even filter by filename, for instance searching only files that end with a particular file extension.

Interface

Search Query
The following options are always displayed at the top of the Search in Files tool view:
	 You can have as many searches as you want open at the same time. Simply click the new tab button at the top-left corner of the Search tool view and a new results tab will open permitting you to perform another search.
	 The button in the top right-corner of the Search in Files tool view will toggle the bottom half of the tool view between displaying additional options for the Search in Folder mode and the results of your search.
Find 	 This is where you type in what you want to find. You may enter standard text, or a regular expression if enabled.
Replace (text box) 	 Replacement text that will be added to file(s) in place of the text in the Find text box.
Search 	 When you've finished configuring everything, just press the Search button to perform your search. You may also press in the Find text box to do the same.
Replace 	 When you've finished configuring everything, just press the Replace button to replace the text entered in the Find text box with that of the Replace text box. You may also press in the Replace text box to do the same.
Next 	 Go to the next match of your search query, switching files if necessary.
Replace Checked 	 The same as Replace, but will only perform replacements in files that are checked in the pane below.

Search in Folder Options
These options are displayed below the aforementioned query options. If search results are being displayed instead, press the button to display them.
Search in 	 This has three options. Select Open Files to search all files currently open in . Select Folder to search inside a folder and optionally its subfolders. Select Current File to search only in the active file.
If the Projects plugin is loaded, you can also search in the Current Project or in All Open Projects.
Match case 	 Restricts search results to only those that have the exact same combination of upper and lower case letters as your search query.
Regular expressions 	 Permits you to use regular expressions instead of simple text as your search query.
Expand results 	 Display all the results found in each file, instead of just a list of files that contain the search query.
Folder 	 You may enter the path of the folder you wish to search. For instance, you might enter ~/development/kde/kate/ if you wished to search the source code. This option is only available when using in Folder mode.
Open file dialog 	 Press this button to locate the folder in your desktop's folder browser. This button only works when using Folder mode.
	 Press this button to change Folder to the parent of the currently selected folder. This button only works when using Folder mode.
	 This button will set the Folder entry to the folder in which the currently open document is located. This button only works when using Folder mode.
Filter 	 This permits you to only search filenames that match a particular pattern. For instance, to only search files written in C++, change it to *.cpp. To search only files beginning with kate, change it to kate*. You can enter multiple filters separated with a comma (,). This option is not available when using Open files mode.
Exclude 	 The opposite of Filter, this prevents from searching files that match the specified patterns. As with Filter, you can enter multiple patterns separated with a comma (,). This option is not available when using Open files mode.
Recursive 	 If this option is enabled, will also search in all subfolders of the selected folder. This option is only available when using Folder mode.
Include hidden 	 If this option is enabled, will also search in files or folders that are typically hidden by your . This option is only available when using Folder mode.
Follow symbolic links 	 The Search in Files plugin typically does not follow symbolic links. When this option is enabled, the plugin will follow them instead and search inside the files or folders they reference. This option is only available when using Folder mode.
It's possible for symbolic links to reference a folder that is the parent of the folder currently being searched, or other folders that contain symbolic links to their parent. If there is such a link in the folder being searched and this option is enabled, will repeatedly follow the link and search the folder, and the search will never complete.
Include binary files 	 If enabled, will also search in files that do not appear to be text files.

Search Results
The results of your search are displayed below the query options. If options for Search in Folder mode are displayed, simply press the button to display them. They will also automatically be displayed as soon as a search is performed.
The search results display a list of files that contains text that matches your search query, followed by the number of matches found in that file.
To see a list of matches in that file, simply click the expansion arrow to the left of the file name. (If you selected the Expand results option, this will already be done for you.) The line number each match is found on will be displayed, followed by the contents of that line, with your search query indicated in bold text.
To open the file your result was found in, simply double-click it. will open the file if needed. You can also move the cursor to the location of a particular match by double-clicking on its listing instead of the file name.

Menu Structure
F Edit Search in Files 	 Launches the Search and Replace tool view.
Edit Go to Next Match 	 Go to the next match in a search performed by the Search and Replace plugin.
Edit Go to Previous Match 	 Go to the previous match in a search performed by the Search and Replace plugin.
View Tool Views Show Search and Replace 	 Toggle the display of 's Search and Replace tool.

Snippets

Introduction
Snippets is a plugin used to save you some time by adding support for so-called snippets (re-usable source code, machine code or text). The plugin also supports code completion and .

Menu Structure
View Tool Views Show Snippets 	Shows snippets panel containing all snippets in your repository that are for the currently opened file type.
Tools Create Snippet 	 Create a new snippet, which is a reusable chunk of text you may insert in any part of any document.

Snippets panel
Snippets Panel
The snippets panel.
The panel for Snippets.
In the panel you should see a list of snippet repositories, along with options to create your own, get them from the Internet or load them from a local file. Each repository has a checkbox that can be used to activate or deactivate it. There are also buttons to edit and delete existing repositories.

Loading Snippet Repository Files
You can download snippet repositories from the Internet. Just click Get New Snippets and a window with a list of snippet repositories will open. After downloading the desired snippet, make sure that you have activated it.

Creating and Editing Repositories
To create a new snippet repository, click Add Repository. You should now see a dialog that asks for the name of the snippet file, license and author. After choosing the desired options, click OK.
Snippet Editor
The repository editor.
The repository editor interface.
The snippet repository editor contains the following options:
Name 	Appears in the list of snippets in the tool view and is also searched when using the code completion feature.
Namespace 	Prefix used while using code completion.
License 	Select the license for you snippet repository.
Authors 	Enter the name(s) of the author(s) of the snippet file.
File types 	Select the file type(s) you want the snippet repository to apply to. It is set to by default, so the repository applies to all files. You can change it to something like C++ for instance, or select from a list by clicking on the items. You can specify more than one file type pressing the while adding types.

Creating and Editing Snippets
Snippet Editor
The snippet editor.
The snippet editor interface.
Name 	The name will be shown in the completion list.
Shortcut 	Pressing this shortcut will insert the snippet into the document.
Snippets 	The text your snippet will insert into the document.
A snippet can contain editable fields. They can be cycled by pressing . The following expressions can be used in the template text to create fields:
${field_name} creates a simple, editable field. All subsequent occurrences of the same field_name create fields which mirror the contents of the first during editing.
${field_name=default} can be used to specify a default value for the field. default can be any expression.
Use ${field_name=text} to specify a fixed string as default value.
${func(other_field1, other_field2, ...)} can be used to create a field which evaluates a function on each edit and contains its contents. See the Scripts tab for more information.
${cursor} can be used to mark the end position of the cursor after everything else was filled in.
Scripts 	 helper functions to use in your snippets.
All functions should return the contents you want to place in a template field as a string.
Functions are called in a scope which contains the contents of all editable template fields as local variables. For example in a snippet containing ${field}, a variable called field will be present which contains the up-to-date contents of the template field. Those variables can either be used in the function statically or passed as arguments, by using the ${func(field)} or ${field2=func(field)} syntax in the snippet string.
You can use the scripting API to get the selected text, full text, file name and more by using the appropriate methods of the document and view objects. Refer to the scripting API documentation for more information.
For more complex scripts it may be important to understand that first, the raw snippet is inserted into the document, and then functions are being evaluated. E.g., if a function retrieves the text on the line where the snippet is being inserted, that text will also contain ${functionCall()}.
As an example of working with selections using the scripting API, a simple way to wrap selected text inside tags is this snippet: <strong>${view.selectedText()}</strong>
The following example invokes a script that inserts a default text in case there is no selection. Snippet:
${rangeCommand("<strong>%%1</strong>", "Bold")}
Script:

function rangeCommand(command, def) {
    if (view.selectedText().length > 0) {
        return command.replace("%%1", view.selectedText());
    } else {
        return command.replace("%%1", def);
    }
}

Using Snippets
Snippets in Action
Accessing Snippets from a tool view and a drop down menu.
Selecting from a list of snippets.
You can call snippets in two ways:
By choosing the snippet from the tool view.
While writing, you can press , which will display all the snippets in a convenient window from which you can choose. This key combination provides functionality similar to code completion.
If the snippet contains variables (besides ${cursor}) the cursor will automatically go to the first occurrence of a variable and will wait for you to write something. When you are done, you can press to move to the next variable, and so on.

Thanks and Acknowledgments
Snippets was written by Joseph Wenninger.
Special thanks to Google Code-In 2011 participant Martin Gergov for writing much of this section.

Keyboard Macros Plugin

Introduction
Record and play keyboard macros (i.e., keyboard action sequences).

Basic usage

To start recording a keyboard macro:
Tools Keyboard Macros Record Macro... (K).
The plugin will record every key presses until you end recording.

To end recording:
Tools Keyboard Macros End Macro Recording (K).
The plugin will stop recording key presses and save the sequence as the current macro.

To cancel recording:
Tools Keyboard Macros Cancel Macro Recording (K).
The plugin will stop recording key presses but the current macro won't change.

To play the current macro:
Tools Keyboard Macros Play Macro (K).
The plugin will play the current macro.
The kmplay command without any arguments will also play the current macro.

Named macros
It is possible to save keyboard macros by giving them a name.
Named macros are persistent between Kate's sessions, they're saved in the keyboardmacros.json file in Kate's user data directory (usually ~/.local/share/kate/).

To save the current macro:
Tools Keyboard Macros Save Current Macro (K).
The plugin will prompt you for a name and save the macro under it.
The kmsave name command will save the current macro under the name name.

To load a saved macro as the current one:
Tools Keyboard Macros Load Named Macro....
The plugin lists saved macros as items in this submenu, activating an item will load the corresponding macro as the current one.
The kmload name command will load the macro saved under the name name as the current one.

To play a saved macro without loading it:
Tools Keyboard Macros Play Named Macro....
The plugin lists saved macros as items in this submenu, activating an item will play the corresponding macro without loading it.
Note that each saved macros is an action that is part of the current action collection so that a custom shortcut can be assigned to it through the Settings Configure Keyboard Shortcuts... interface.
The kmplay name command will play the macro saved under the name name without loading it.

To wipe (i.e., delete) a saved macro:
Tools Keyboard Macros Wipe Named Macro....
The plugin lists saved macros as items in this submenu, activating an item will wipe (i.e., delete) the corresponding macro.
The kmwipe name command will wipe the macro saved under the name name.

Tips for commands:
Note that after the km prefix, all these commands use a different letter so you can efficiently call them using tab-completion!

Limitations
As of now, keyboard macros fail to play properly if some types of GUI widgets are used: QMenu, QuickOpenLineEdit, or TabSwitcherTreeView, for example. I'm not sure why but my first guess would be that these widgets work in a non-standard way regarding keyboard events.

SQL Plugin

Introduction
The Structured Query Language (SQL) is a specialized language for updating, deleting, and requesting information from databases.
The SQL Plugin allows you to:
Create a database
Connect to existing databases
Insert and delete data in the database
Execute queries
Display results in a table

Connecting to a Database
Select Add Connection from the SQL menu or toolbar, and then select the database driver you want to use (including QSQLITE, QMYSQL3, QMYSQL, QODBC3, QODBC, QPSQL7, and QPSQL). If you can't see the desired driver, you need to install it. Then, press Next.
If the database you selected uses a file, simply indicate the database's location and press the Next button. If it requires connecting to a server, you must enter the hostname of the server, your username and password, and any other information that particular driver may require. Then press Next.
Finally, give a name to your connection, and press Finish.

Running Queries

INSERT/DELETE/UPDATE
You can insert, delete, and update data using the SQL plugin just as you would from the command line or from within a program. Simply enter a query and press the Run query button in the toolbar or use SQL Run query (E).

Some Example Queries
INSERT 	

INSERT INTO table_name ("feature1", "feature2", "feature3", "feature4", "feature5")
VALUES ("value1", "value2", "value3", "value4", "value5" )

DELETE 	

DELETE FROM table_name WHERE name = "text"

UPDATE 	

UPDATE table_name SET "feature1" = "text", "feature2" = "text", "feature3" = "text", "feature4" = "text", "feature5" = "text"

SELECT
After running a SELECT query, you can view the results as a table that will appear in the SQL Data Output tool view at the bottom of , or as text in the SQL Text Output. If there is an error, you can see it in the text output.

Example SELECT Query

SELECT * FROM table_name

In the SQL Data Output tool view, there are several buttons:
Resize columns to contents 	Changes the size of columns to fit their contents.
Resize rows to contents 	Changes the size of rows to fit their contents.
Copy 	Selects all of the table contents and copies it to the clipboard buffer.
Export 	Exports all of the table contents to a file, the clipboard, or the current document in the Comma Separated Values format.
Clear 	Removes everything from the table view.
You can now change the colors displayed in the table in the SQL section of Settings Configure ... .

Browsing
You can browse your database using the Database schema browser tool view on the left. The information displayed varies depending on which database driver you are using.
To refresh this list, right-click anywhere in the tool view and select Refresh. To generate a query on any entry in the list, right-click on an entry, select Generate, and select the query type (SELECT, UPDATE, INSERT, or DELETE) from the submenu that appears.

Menu Structure
SQL Add connection... 	 Adds a new connection using any database driver.
SQL Remove connection 	 Removes the selected connection.
SQL Edit connection... 	 Edits the current connection's settings.
Connections 	 All database connections you have created are listed between the Edit connection and Run query menu items. Select one to run queries or make modifications to it.
E SQL Run query 	 Runs your query.

Thanks and Acknowledgments
The SQL Plugin was written by Marco Mentasti.
Special thanks to Google Code-In 2011 participant Ömer Faruk ORUÇ for writing much of this section.

Symbol Viewer Plugin

Using the Close Except/Like Plugin
It allows developers to view symbols (functions, macros and structures) from source code.
By clicking the parsed information you can easily browse the code.
At the moment the following languages are supported:
C/C++, , Perl, PHP, Python, Ruby, XSLT, Tcl/Tk, Fortran
Feature list:
List/Tree mode
Enable/disable sorting
Hide/Show Functions Parameters
Expand/collapse tree mode
Auto-update on document change
Code parsing is based on the Syntax-Highlighting framework from

Menu Structure
\ View Tool Views Show Symbol List 	 Toggle the display of 's Symbol List displaying Functions, Macros and Structures of the source code in the active document.

Configuration
Symbol Viewer
Choose the default parser options

Terminal Tool View Plugin
The built in Terminal Emulator is a copy of the terminal application, for your convenience. It is available from the View Tool Views Show Terminal Panel menu item and will get the focus whenever displayed. Additionally, if the Automatically synchronize the terminal with the current document when possible option is enabled, it will change to the directory of the current document if possible when it is displayed, or when the current document changes.
The default location in the window is at the bottom, below the editing area.
You can configure the using its menu, for more information, see the manual.
The built-in terminal emulator is provided by the Terminal Tool View plugin.

Menu Structure
View Tool Views Show Terminal Panel 	 Toggles the display of the built-in terminal emulator.
When activated for the first time, the terminal will be created.
When the terminal emulator is displayed, it will get the focus, so that you can start typing in commands immediately. If the Automatically synchronize the terminal with the current document when possible option is enabled in the Terminal page of the Main configuration dialog the shell session will change to the directory of the active document, if it is a local file.
Tools Pipe to Terminal 	Feed the currently selected text into the built-in terminal emulator. No newline is added after the text.
Tools Synchronize Terminal with Current Document 	 This will cause the built-in Terminal to cd into the directory of the active document.
Alternatively, you can configure to always keep the terminal in sync with the current document. See Configuration for more information.
Tools Focus/Defocus Terminal Panel 	 Switch the focus from the current document to the terminal and vice versa.

Configuration
You can configure the Terminal Tool View plugin on the Terminal page of the configuration dialog.
The following options are available:
Automatically synchronize the terminal with the current document when possible 	This will cause the built-in terminal to cd into the directory of the active document when launched and when a new document gets the focus. If not enabled, you have to do all your navigation in the terminal on your own.
Set EDITOR environment variable to 'kate -b' 	This sets the EDITOR environment variable so programs run in the built-in terminal that automatically open a file in an editor will open them in instead of the default editor configured in your shell. You will not be able to continue using the terminal until you have closed the file in , so the calling program is aware you have finished editing the file.
Hide on pressing 'Esc' 	This allows closing the built-in terminal by pressing the key. May cause issues with terminal applications that use key, ⪚ vim. Add such applications in the text input box below. The items in the list should be separated with comma.

Text Filter Plugin

Using the Text Filter Plugin
You can use this plugin to process selected text using terminal commands. The selection will be used as input for the command, and the output will either replace the selection or be copied to the clipboard, depending on the user's preference.

Examples:
less /etc/fstab - paste the contents of this file or copy it to the clipboard
wc - count lines, words and characters of the selection and paste this into the document or copy it to the clipboard
sort - sort lines of the selection and paste the result into the document or copy it to the clipboard

Menu Structure
\ Tools Filter Text 	 Opens the Text Filter dialog:
Text Filter dialog
Enter the shell command into the combobox or select a previous command from the history.
Copy the result instead of pasting it 	 Copy the result to clipboard leaving a document unchanged.
Merge STDOUT and STDERR 	 If checked, an output from STDOUT and STDERR will be merged and no errors will be reported. Otherwise, STDERR will be displayed as a passive message.

Validation
This plugin checks files for validity and being well-formed.
This plugin checks the current file. A list of warnings and errors will appear at the bottom of 's main window. You can click on an error message to jump to the corresponding place in the file. If the file has a DOCTYPE the DTD given with this doctype will be used to check the file for validity. The DTD is expected at a position relative to the current file, ⪚ if the doctype refers to DTD/xhtml1-transitional.dtd and the file is /home/peter/test.xml the DTD is expected to be located at /home/peter/DTD/xhtml1-transitional.dtd. However, remote DTDs specified via http are supported.
If the file has no doctype it will be checked for being well-formed.
To learn more about check out the official W3C pages.
Internally this plugin calls the external command xmllint, which is part of libxml2. If this command is not correctly installed on your system, the plugin will not work.
To load this plugin open 's configuration dialog under Settings Configure .... Then select Validation which will appear in the Application / Plugins section and close the dialog.

Menu Structure
Validate 	This will start the check, as described above.

Thanks and Acknowledgments
Plugin Validation copyright 2002 .
Documentation copyright 2002

Completion
This plugin gives hints about what is allowed at a certain position in an file, according to the file's DTD. It will list possible elements, attributes, attribute values or entities, depending on the cursor position (⪚ all entities are listed if the character on the left of the cursor is &). It's also possible to close the nearest open tag on the left.
The DTD must exist in format, as produced by the Perl program dtdparse. We will call a DTD in this format meta DTD. Some meta DTDs are supplied. They are installed in katexmltools/ in qtpaths --paths GenericDataLocation , which is also the default folder when you choose Assign Meta DTD.... To produce your own meta DTDs, get dtdparse from http://dtdparse.sourceforge.net.

How to Use
Start and open the configuration dialog under Settings Configure .... Then select Completion which will appear in the Application Plugins page and close the dialog. After that, select Assign Meta DTD.... If your document contains no DOCTYPE or the doctype is unknown, you will have to select a meta DTD from the file system. Otherwise the meta DTD that matches the current document's DOCTYPE will be loaded automatically.
You can now use the plugin while typing your text:
< (less than key) 	This will trigger a list of possible elements unless the cursor is inside a tag already. Note that you currently cannot use this to insert the top level element (⪚ <html>).
< /(less than key + slash) 	Entering these characters will offer to close the current element (nearest open one to the left of the cursor). Press to accept the suggestion. Unlike the Close Element menu item, this works only with a DTD assigned.
" (quote key) 	The quote key will trigger a list of possible attribute values (if there are any) if you are inside a tag.
  (space key) 	This key will trigger a list of possible attributes for the current element if you are inside a tag.
& (ampersand key) 	This key will trigger a list of named entities.

Features and Limitations
You can test all functions and limitations by loading katexmltools/testcases.xml in qtpaths --paths GenericDataLocation into and following the instructions.

Menu Structure
Insert Element... 	This will open a dialog that lets you insert an element. The <, > characters and the closing tag will be inserted automatically. If you have selected text when this menu item is selected, the selected text will be surrounded by the opening and the closing tag. The dialog also offers completion of all elements that may be inserted at the current cursor position if you have assigned a meta DTD by using Assign Meta DTD....
< Close Element 	This will search your text for a tag that is not yet closed and will close it by inserting the corresponding closing tag. The search starts at the cursor position and goes left. If it cannot find an open tag nothing will happen.
Assign Meta DTD... 	This will tell the plugin which meta DTD to use for the current document. Note that this assignment will not be saved. You will have to repeat it when you start the next time.

Thanks and Acknowledgments
Plugin Completion copyright 2001,2002 .
SC 4 version copyright 2010 Tomáš Trnka
Documentation copyright 2001,2002