Startup

At startup, Geany loads all files from the last time Geany was launched. You can disable this feature in the preferences dialog (see General tab in preferences dialog). If you specify some files on the command line, only these files will be opened, but you can find the files from the last session in the file menu under the "Recent files" item. By default this contains the last 10 recently opened files. You can change the amount of recently opened files in the preferences dialog.

You can start several instances of Geany, but only the first will load files from the last session. To run a second instance of Geany, do not specify any filenames on the command-line, or disable opening files in a running instance using the appropriate command line option.

Opening files from the command-line in a running instance

Geany detects an already running instance of itself and opens files from the command-line in the already running instance. So, Geany can be used to view and edit files by opening them from other programs such as a file manager. If you do not like this for some reason, you can disable using the first instance by using the appropriate command line option -- see the section called Command line options.

Virtual terminal emulator widget (VTE)

If you have installed libvte.so in your system, it is loaded automatically by Geany, and you will have a terminal widget in the notebook at the bottom.

If Geany cannot find any libvte.so at startup, the terminal widget will not be loaded. So there is no need to install the package containing this file in order to run Geany. Additionally, you can disable the use of the terminal widget by command line option, for more information see the section called Command line options.

You can use this terminal (from now on called VTE) nearly as an usual terminal program like xterm. There is basic clipboard support. You can paste the contents of the clipboard by pressing the right mouse button to open the popup menu and choosing Paste. To copy text from the VTE, just select the desired text and then press the right mouse button and choose Copy from the popup menu. On systems running the X Window System you can paste the last selected text by pressing the middle mouse button in the VTE (on 2-button mice, the middle button can often be simulated by pressing both mouse buttons together).

In the preferences dialog you can specify a shell which should be started in the VTE. To make the specified shell a login shell just use the appropriate command line options for the shell. These options should be found in the manual page of the shell. For zsh and bash you can use the argument --login.

It could be, that the library is called something else than libvte.so (e.g. on FreeBSD 6.0 it is called libvte.so.8). So please set a link to the correct file (as root):

# ln -s /usr/lib/libvte.so.X /usr/lib/libvte.so

Obviously, you have to adjust the paths and set X to the number of your libvte.so.

You can also specify the filename of the VTE library to use on the command line (see the section called Command line options) or at compile time by specifying the command line option --with-vte-module-path to ./configure.

Defining own widget styles using .gtkrc-2.0

You can define your widget style for many of Geany's GUI parts. To do this, just edit your .gtkrc-2.0 (usually found in your home directory on UNIX-like systems and in the etc subdirectory of your Geany installation on Windows).

To get a defined style get noticed by Geany you must it assign to one of Geany's widgets. To do so, use the following line:

widget "Geany*" style "geany_style"

This would assign your already defined style "geany_style" to all Geany widgets. You can also assign styles only to specific widgets. At the moment you can use the following widgets:

• GeanyMainWindow
• GeanyEditMenu
• GeanyToolbarMenu
• GeanyDialog
• GeanyDialogPrefs
• GeanyDialogProject
• GeanyDialogSearch

Example of a simple .gtkrc-2.0:

style "geanyStyle"
{
    font_name="Sans 12"
}
widget "GeanyMainWindow" style "geanyStyle"

style "geanyStyle"
{
    font_name="Sans 10"
}
widget "GeanyPrefsDialog" style "geanyStyle"

Switching between documents

The documents list and the editor tabs are two different ways to switch between documents using the mouse. When you hit the key combination to move between tabs, the order is determined by the tab order, not alphabetical as shown in the documents list (regardless of whether or not editor tabs are visible).

Using character sets

Geany provides support for detecting and converting character sets. So you can open and save files in different character sets and even can convert a file from a character set to another one. To do this, Geany uses the character conversion capabilities of the GLib.

Only text files are supported, i.e. opening files which contain NUL-bytes may fail. Geany will try to open the file anyway but it is likely that the file will be truncated because it can only opened up to the first occurrence of a NUL-byte. All characters after this position are lost and are not written when you save the file.

Geany tries to detect the encoding of a file while opening it. It might be that the encoding of a file cannot be detected correctly so you have to set manually the encoding of the file in order to display it correctly. You can this in the file open dialog by selecting an encoding in the drop down box or by reloading the file with the file menu item "Reload as". The auto detection works well for most encodings but there are also some encodings known where auto detection has its problems. Auto detecting the encoding of a file is not easy and sometimes an encoding might be detected not correctly.

There are different ways to use different encodings in Geany:

• Using the file open dialog

  This opens the file with the encoding specified in the encoding drop down box. If the encoding is set to "Detect from file" auto detection will be used. If the encoding is set to "Without encoding (None)" the file will be opened without any character conversion and Geany will not try to auto detect the encoding(see below for more information).

• Using the "Reload as" menu item

  This item reloads the current file with the specified encoding. It can help if you opened a file and found out that a wrong encoding was used.

• Using the "Set encoding" menu item

  In contrary to the above two options, this will not change or reload the current file unless you save it. It is useful when you want to change the encoding of the file.

• Specifying the encoding in the file itself As mentioned above, auto detecting the encoding of a file may fail on some encodings. If you know that Geany doesn't open a certain file, you can add a special line to the beginning of the file to force an encoding when opening the file (for details see below).

In-file encoding specification

Geany detects meta tags of HTML files which contain charset information like:

<meta http-equiv="content-type" content="text/html; charset=ISO-8859-15" />

and the found charset is used when opening the file. This is useful if the encoding of the file cannot be detected properly. For non-HTML files you can also define a line like:

/* geany_encoding=ISO-8859-15 */

or:

# geany_encoding=ISO-8859-15 #

to force an encoding to be used. The used #, /* and */ are only examples for filetype-specific comment characters. It doesn't matter which characters are around the string " geany_encoding=ISO-8859-15 " as long as there is at least one whitespace character before and after this string. Whitespace characters are in this case a space or tab character. "geany_encoding" must be in lower-case, the charset string is case-independent. There must not be any whitespace between "geany_encoding", the "=" sign and the charset. An example to use this could be you have a file with ISO-8859-15 encoding but Geany constantly detects the file encoding as ISO-8859-1. Then you simply add such a line to the file and Geany will open it correctly the next time.

Special encoding "None"

There is a special encoding "None" which is actually no real encoding. It is useful when you know that Geany cannot auto detect the encoding of a file and it is not displayed correctly. Especially when the file contains NUL-bytes this can be useful to skip auto detection and open the file properly at least until the occurrence of the first NUL-byte. Using this encoding opens the file as it is without any character conversion.

Unicode Byte-Order-Mark (BOM)

Furthermore, Geany detects an Unicode Byte Order Mark (see http://en.wikipedia.org/wiki/Byte_Order_Mark for details). Of course, this feature is only available if the opened file is in an unicode encoding. The Byte Order Mark helps to detect the encoding of a file, e.g. whether it is UTF-16LE or UTF-16BE and so on. On Unix-like systems using a Byte Order Mark could cause some problems, e.g. the gcc stops with stray errors, PHP does not parse a script containing a BOM and script files starting with a she-bang maybe cannot be started. In the status bar you can easily see whether the file starts with a BOM or not. If you want to set a BOM for a file or if you want to remove it from a file, just use the document menu and toggle the checkbox.

Folding

Geany provides basic code folding support. Folding means the ability to show and hide parts of the text in the current file. You can hide unimportant code sections and concentrate on the parts you are working on and later you can show these sections again. In the editor window there is a small grey margin on the left side with some [+] and [-] symbols. By clicking on these icons you can simply show and hide sections which are marked by vertical lines within this margin. For many filetypes nested folding is supported, so there may be several fold points within other fold points.

If you don't like it or don't need it at all, you can simply disable folding support completely in the preferences dialog.

The folding behaviour can be changed with the "Fold/Unfold all children of a fold point" option in the preference dialog. If activated, Geany will unfold all nested fold points below the current one if they are already folded (when clicking on a [+] symbol). When clicking on a [-] symbol, Geany will fold all nested fold points below the current one if they are unfolded.

The usage of this option can be instantly inverted by pressing the Shift key while clicking on a fold symbol. That means, if the "Fold/Unfold all children of a fold point" option is enabled, pressing Shift will disable it for this click and vice versa.

Column mode editing

There is basic support for column mode editing. To use it, create a rectangular selection by holding down the Control key while selecting some text. It is also possible to create a zero-column selection but be careful because there is no visual indication of this selection. Once a rectangular selection exists you can start editing the text within this selection and the modifications will be done for every line in the selection.

Drag and drop of text

If you drag selected text in the editor widget of Geany the text is moved to the position where the mouse pointer is when releasing the mouse button. Holding Control when releasing the mouse button will copy the text instead. This behaviour was changed in Geany 0.11 - before the selected text was copied to the new position.

Indentation

Geany allows each document to indent either with a tab character or multiple spaces. The default indent mode is set in the Editor tab in preferences dialog. But this can be overridden using either the Document->Indent Type menu, or by using the Detect from file indentation preference. When enabled, this scans each file that is opened and sets the indent mode based on how many lines start with a tab vs. 2 or more spaces.

The indent mode for the current document is shown on the status bar as follows:

TAB

Indent with Tab characters.

SP

Indent with spaces.

Auto-indentation

When enabled, auto-indentation happens when pressing Enter in the Editor. It adds a certain amount of indentation to the new line so the user doesn't always have to indent each line manually.

Geany knows four types of auto-indentation:

None

Disables auto-indentation completely.

Basic

Adds the same amount of whitespace on a new line as on the last line.

Current chars

Does the same as Basic but also indents a new line after an opening brace '{', and de-indents when typing a closing brace '}'. For Python, a new line will be indented after typing ':' at the end of the previous line.

Match braces

Similar to Current chars but the closing brace will be aligned to match the indentation of the line with the opening brace.

Bookmarks

Geany provides a handy bookmarking feature that lets you mark one or more lines in a document, and return the cursor to them using a key combination.

To place a mark on a line, either left-mouse-click in the left margin of the editor window, or else use Ctrl-m. Either way, this will produce a small green plus symbol in the margin. You can have as many marks in a document as you like. Click again (or use Ctrl-m again) to remove the bookmark. To remove all the marks in a given document, use "Remove Markers" in the Document menu.

To navigate down your document, jumping from one mark to the next, use Ctrl-. (control period). To go in the opposite direction on the page, use Ctrl-, (control comma). Using the bookmarking feature together with the commands to switch from one editor tab to another (Ctrl-PgUp/PgDn and Ctrl-Tab) provides a particularly fast way to navigate around multiple files.

Code Navigation History

To ease navigation in source files and especially between different files, Geany lets you jump between different navigation points. Currently, this works when using the Go to tag declaration, Go to tag definition commands and when clicking on symbol list items.

When using one of these actions, Geany remembers your current position and jumps to the new one. If you decide to go back to your previous position in the file, just use "Navigate back a location". To get back to the new position again, just use "Navigate forward a location". This makes it easier to navigate in e.g. foreign code and between different files.

Send text through definable commands

You can define several custom commands in Geany and send the current selection to one of these commands. The output of the command will be used to replace the current selection. So, it is possible to use text formatting tools with Geany in a general way. The selected text will be sent to the standard input of the executed command, so the command should be able to read from it and it should print all results to its standard output which will be read by Geany. To help finding errors in executing the command, the output of the program's standard error will be printed on Geany's standard output.

To add a custom command, just go to the Set Custom Commands dialog in the Format sub menu of the Edit and Popup menu. Then click on Add to get a new text entry and type the command. You can also specify some command line options. To delete a command, just clear the text entry and press OK. It will be deleted automatically.

Context actions

You can execute a specified command on the current word near the cursor position or an available selection and this word is passed as an argument to this command. It can be used for example to open some API documentation in a browser window or open any other external program. To do this, there is an menu entry in the popup menu of the editor widget and also a keyboard shortcut(see the section called Keybindings).

The command can be specified in the preferences dialog and additionally for each filetype (see "context_action_cmd" in the section called Format). At executing, the filetype specific command is used if available otherwise the command specified in the preferences dialog is executed.

The passed word can be referred with the wildcard "%s" everywhere in the command, before executing it will be replaced by the current word. For example, the command to open the PHP API documentation would be:

firefox "http://www.php.net/%s"

when executing the command, the %s is substituted by the word near the cursor position or by the current selection. If the cursor is at the word "echo", a browser window will open(assumed your browser is called firefox) and it will open the address: http://www.php.net/echo.

User-definable snippets

Snippets are small strings or code constructs which can be replaced or completed to a more complex string. So you can save a lot of time by not typing often used strings and letting Geany do the work for you. To know what to complete or replace Geany reads a configuration file called snippets.conf at startup.

The system-wide configuration file can be found in $prefix/share/geany, where $prefix is the path where Geany is installed (commonly /usr/local). It is not recommended to edit the system-wide file, because it will be overridden when Geany is updated.

To change the settings, copy the file from $prefix/share/geany in your configuration directory (usually ~/.geany/).

For example:

% cp /usr/local/share/geany/snippets.conf /home/username/.geany/

Then you can edit the file and the changes are also available after an update of Geany because the file resides in your configuration directory. Alternatively, you can create a file ~/.geany/snippets.conf and add only these settings you want to change. All missing settings will be read from the global snippets file in $prefix/share/geany.

The file snippets.conf may contain several sections for each filetype. It also contains two additional sections "Default" and "Special". Default contains all snippets which are available for every filetype. You may define another section for a certain filetype(e.g. C++) containing the same snippets. Then when using such a snippet in a C++ file the snippet defined in the C++ section will be used. In any other file the snippet defined in the Default section will be used unless a section for the current filetype exists and the used snippet is defined in this section. The section "Special" contains special snippets which can only be used in other snippets. So you can define often used parts of snippets and just use the special snippet as a placeholder (see the snippets.conf for details).

To define snippets you can use several special characters which will be replaced when using the snippet:

Wildcards for snippets

Defined snippets must not contain spaces otherwise they won't work correctly. But beside that you can define almost everything string as a snippet and use it later in Geany. It is not limited to existing contructs of certain programming languages(like if, for, switch). Define whatever you need.

Maybe you need to often type your name, so define a snippet like this:

[Default]
myname=Enrico Tröger

Everytime you write myname <TAB> in Geany, it will replace "myname" with "Enrico Tröger". The key to start auto completion can be changed in the preferences dialog, by default it is TAB.

You may change the behaviour Geany recognizes the word to complete, i.e. where define the start and end of a word. The section "Special" may contain a key "wordchars" which lists all characters a string may contain to be recognized as a word for completion. Leave it commented to use default characters or define it to add or remove characters to fit your needs.

Inserting unicode characters

With GTK 2.10 and above, you can hit Ctrl-Shift-u, then still holding Ctrl-Shift, type some hex digits representing the code point for the character you want, then let go of Ctrl-Shift and hit a key such as the right arrow.

For this to work in Geany, you'll need to first unbind Ctrl-Shift-u in the keybinding tab in preferences dialog, then restart Geany. Note that it works slightly differently from other GTK applications, in that you'll need to continue to hold down the Ctrl and Shift keys while typing the code point hex digits.

For GTK < 2.10, it is also possible, but typing the first Ctrl-Shift-u is not necessary. One problem is that you may find the alphabetic keys conflict with other Geany keybindings.

Find

The Find dialog is used for finding text in one or more open documents.

style "search_style"
{
    font_name="Monospace 8"
}
widget "GeanyDialogSearch.*.GtkEntry" style:highest "search_style"

Find usage

Find usage searches all open files. It is similar to the Find All In Session Find dialog command.

If there is a selection, then it is used as the search text; otherwise the current word is used. The current word is either taken from the word nearest the edit cursor, or the word underneath the popup menu click position when the popup menu is used. The search results are shown in the Messages tab of the Message Window.

Find in files

Find in files is a more powerful version of Find usage that searches all files in a certain directory using the Grep tool. The Grep tool must be correctly set in Preferences to the path of the system's Grep utility. GNU Grep is recommended.

The Extra options field is used to pass any additional arguments to the grep tool.

Replace

The Replace dialog is used for replacing text in one or more open documents.

The Replace dialog has the same options for matching text as the Find dialog. See the section called Matching options.

The Use regular expressions option applies both to the search string and to the replacement text; for the latter back references can be used -- see the entry for '\n' in Regular expressions.

Go to tag definition

If the current word is the name of a tag definition (like a function body) and the file containing the tag definition is open, this command will switch to that file and go to the corresponding line number. The current word is either taken from the word nearest the edit cursor, or the word underneath the popup menu click position when the popup menu is used.

Go to tag declaration

Like Go to tag definition, but for a forward declaration such as a function prototype or extern declaration instead of a function body.

Go to line

Go to a particular line number in the current file.

Regular expressions

You can use regular expressions in the Find and Replace dialogs by selecting the Use regular expressions check box. The syntax is POSIX-like, as described below in Regular expressions.

In a regular expression, the following characters are interpreted:

Workspace tags

Tags for each document are parsed whenever a file is loaded or saved. These are shown in the Symbol list in the Sidebar. These tags are also used for autocompletion of symbols and calltips for all documents open in the current session that have the same filetype.

The Go to Tag commands can be used with all workspace tags. See Go to tag definition.

Global tags

Global tags are used to provide autocompletion of symbols and calltips without having to open the corresponding source files. This is intended for library APIs, as the tags file only has to be updated when you upgrade the library.

You can load a custom global tags file in two ways:

• Using the Load Tags command in the File menu.
• By creating a directory ~/.geany/tags, and moving or symlinking the tags files there before starting Geany.

You can either download these files or generate your own. They have the format:

name.lang_ext.tags

lang_ext is one of the extensions set for the filetype associated with the tags. See the section called Filetype extensions for more information.

geany -g [-P] <Tag File> <File list>

geany -g wxd.d.tags /home/username/wxd/wx/*.d

CFLAGS=`pkg-config --cflags libgnomeui-2.0` geany -g gnomeui.c.tags \
/usr/include/libgnomeui-2.0/gnome.h

Ignore tags

You can also ignore certain tags if they would lead to wrong parsing of the code. Simply create a file called "ignore.tags" in your Geany configuration directory (usually ~/.geany/). Then list all tags you want to ignore in this file, separated by spaces and/or newlines.

More detailed information about the usage from the Exuberant Ctags manual page:

Specifies a list of identifiers which are to be specially handled
while  parsing C and C++ source files. This option is specifically
provided to handle special cases arising through the use of
preprocessor macros. When the identifiers listed are simple identifiers,
these identifiers will be ignored during parsing of the source files.
If an identifier is suffixed with a '+' character, ctags will also
ignore any parenthesis-enclosed argument list which may immediately
follow the identifier in the source files.
If two identifiers are separated with the '=' character, the first
identifiers is replaced by the second identifiers for parsing purposes.

For even more detailed information please read the manual page of Exuberant Ctags.

General tab in preferences dialog

Interface tab in preferences dialog

Toolbar tab in preferences dialog

Affects the main toolbar underneath the menu bar.

Display tab in preferences dialog

This is for visual elements displayed in the editor window.

Editor tab in preferences dialog

Files tab in preferences dialog

Tools tab in preferences dialog

Template tab in preferences dialog

This data is used as metadata for various template text to insert into a document, such as the file header. You only need to set fields that you want to use in your template files.

Keybinding tab in preferences dialog

There are some handy commands in here that are not, by default, bound to a key combination, and may not be available as a menu item.

Printing tab in preferences dialog

Use external command for printing

Use a system command to print your file out.

Use native GTK printing

Let the GTK GUI toolkit handle your print request.

Print line numbers

Print the line numbers on the left of your paper.

Print page number

Print the page number on the bottom right of your paper.

Print page header

Print a header on every page that is sent to the printer.

Use base name of the printed file

Don't use the entire path for the header, only the filename.

Date format

How the date should be printed. You can use the same format specifiers as in the ANSI C function strftime(). For details please see http://man.cx/strftime.

VTE tab in preferences dialog

See also: Virtual terminal emulator widget (VTE).

New Project

To create a new project, fill in the Name field. By default this will setup a new project file ~/projects/name.geany. Usually it's best to store all your project files in the same directory (they are independent of any source directory trees).

The Base path text field is setup to use ~/projects/name. This can safely be set to any existing path -- it will not touch the file structure contained in it.

Project Properties

You can set an optional description for the project, but it is not used elsewhere by Geany.

The Base path field is used as the directory to run the Make and Make custom commands in. It is also used as working directory for the project specific Run command. The specified path can be an absolute path or relative to the project's file name.

Open Project

The Open command displays a standard file chooser, starting in ~/projects. Choose a project file named with the .geany extension.

When project session support is enabled, Geany will close the currently open files and open the session files associated with the project.

Close Project

Project file settings are saved when the project is closed.

When project session support is enabled, Geany will close the project session files and open any previously closed default session files.

Compile

The Compile command has different uses for different kinds of files.

For compilable languages such as C and C++, the Compile command is setup to compile the current source file into a binary object file.

Java source files will be compiled to class file bytecode. Interpreted languages such as Perl, Python, Ruby will compile to bytecode if the language supports it, or will run a syntax check, or failing that will run the file in its language interpreter.

Build

For compilable languages such as C and C++, the Build command will link the current source file's equivalent object file into an executable. If the object file does not exist, the source will be compiled and linked in one step, producing just the executable binary.

Interpreted languages do not use the Build command.

Make all

This effectively runs "make all" in the same directory as the current file.

Make custom target

This is similar to running 'Make all' but you will be prompted for the make target name to be passed to the Make tool. For example, typing 'clean' in the dialog prompt will run "make clean".

Make object

Make object will run "make current_file.o" in the same directory as the current file, using its prefix for 'current_file'. It is useful for compiling just the current file without building the whole project.

Execute

Execute will run the corresponding executable file, shell script or interpreted script in a terminal window. Note that the Terminal tool path must be correctly set in the Tools tab of the Preferences dialog - you can use any terminal program that runs a Bourne compatible shell and accept the "-e" command line argument to start a command.

After your program or script has finished executing, you will be prompted to press the return key. This allows you to review any text output from the program before the terminal window is closed.

Stopping running processes

When there is a running program, the Run button in the toolbar becomes a stop button and you can stop the current action. This works by sending a signal to the process (and its child process(es)) to stop the process. The used signal is SIGQUIT.

Depending on the process you started it might occur that the process cannot be stopped. This can happen when the process creates more than one child process.

Set Includes and Arguments

By default the Compile and Build commands invoke the compiler and linker with only the basic arguments needed by all programs. Using Set Includes and Arguments you can add any include paths and compile flags for the compiler, any library names and paths for the linker, and any arguments you want to use when running Execute.

These settings are saved automatically when Geany is shut down.

The following variables can be used:

• %f -- complete filename without path
• %e -- filename without path and without extension

See [build_settings] Section for details.

If you need complex settings for your build system, or several different settings, then writing a Makefile and using the Make commands is recommended.

Indicators

Indicators are red squiggly underlines which are used to highlight errors which occured while compiling the current file. So you can easily see where your code failed to compile. To remove the indicators, just click on "Remove all indicators" in the document file menu.

If you do not like this feature, you can disable it in the preferences dialog.

Switching documents

There are a few non-configurable bindings to switch between documents, listed below. These can also be overridden by custom keybindings.

Configurable keybindings

For all actions listed below you can define your own keybindings. Open the Preferences dialog, select the desired action and click on change. In the opening dialog you can press any key combination you want and it will be saved when you press OK. You can define only one key combination for one action.

Some of the default key combinations cannot be changed, e.g. menu_new or menu_open. These are set by GTK and should be kept, but you can still add other key combinations for these actions. For example to execute menu_open by default Ctrl-O is set, but you can also define Alt-O, so that the file open dialog is shown by pressing either Ctrl-O or Alt-O.

The following table lists all customizable keyboard shortcuts.

Format

Special file filetypes.common

There is a special filetype definition file called filetypes.common. This file defines some general non-filetype-specific settings.

default

This is the default style. It is used for styling files without a filetype set.

Example: default=0x000000;0xffffff;false;false

selection

The style for colouring selected text. The format is:

• Foreground colour
• Background colour
• Use foreground colour
• Use background colour

The colours are only set if the 3rd or 4th argument is true. When the colours are not overridden, the default is a dark grey background with syntax highlighted foreground text.

Example: selection=0xc0c0c0;0x00007F;true;true

brace_good

The style for brace highlighting when a matching brace was found.

Example: brace_good=0xff0000;0xFFFFFF;true;false

brace_bad

The style for brace highlighting when no matching brace was found.

Example: brace_bad=0x0000ff;0xFFFFFF;true;false

caret

The style for colouring the caret(the blinking cursor). Only first and third argument is interpreted. Set the third argument to true to change the caret into a block caret.

Example: caret=0x000000;0x0;false;false

caret_width

The width for the caret(the blinking cursor). Only the first argument is interpreted. The width is specified in pixels with a maximum of three pixel. Use the width 0 to make the caret invisible.

Example: caret=1;0;false;false

current_line

The style for colouring the background of the current line. Only the second and third arguments are interpreted. The second argument is the background colour. Use the third argument to enable or disable background highlighting for the current line (has to be true/false).

Example: current_line=0x0;0xe5e5e5;true;false

indent_guide

The style for colouring the indentation guides. Only the first and second arguments are interpreted.

Example: indent_guide=0xc0c0c0;0xffffff;false;false

white_space

The style for colouring the white space if it is shown. The first both arguments define the foreground and background colours, the third argument sets whether to use the defined foreground colour or to use the colour defined by each filetype for the white space. The fourth argument defines whether to use the background colour.

Example: white_space=0xc0c0c0;0xffffff;true;true

folding_style

The style of folding icons. Only first and second arguments are used.

Valid values for the first argument are:

• 1 -- for boxes
• 2 -- for circles

Valid values for the second argument are:

• 1 -- for straight lines
• 2 -- for curved lines

Example: folding_style=1;1;false;false

folding_horiz_line

Draw a thin horizontal line at the line where text is folded. Only first argument is used.

Valid values for the first argument are:

• 0 -- disable, do not draw a line
• 1 -- draw the line above folded text
• 2 -- draw the line below folded text

Example: folding_horiz_line=0;0;false;false

invert_all

Whether to invert all defined colours. This is useful if you like a dark background colour(e.g. black) and do not want to change every single line. Please note, at time of writing this was only tested with the C syntax highlighting.

Only first argument is interpreted. Set it to 1 to invert all colours.

Example: invert_all=0;0;false;false

line_wrap_visuals

First argument: drawing of visual flags to indicate a line is wrapped. This is a bitmask of the values:

• 0 -- No visual flags
• 1 -- Visual flag at end of subline of a wrapped line
• 2 -- Visual flag at begin of subline of a wrapped line. Subline is indented by at least 1 to make room for the flag.

Second argument: wether the visual flags to indicate a line is wrapped are drawn near the border or near the text. This is a bitmask of the values:

• 0 -- Visual flags drawn near border
• 1 -- Visual flag at end of subline drawn near text
• 2 -- Visual flag at begin of subline drawn near text

Only first and second argument is interpreted.

Example: line_wrap_visuals=3;0;false;false

line_wrap_indent

Sets the size of indentation of sublines for wrapped lines in terms of the width of a space.

Only first argument is interpreted.

Example: line_wrap_indent=0;0;false;false

translucency

Translucency for the current line (first argument) and the selection (second argument). Values between 0 and 256 are accepted.

Note for Windows 95, 98 and ME users: keep this value at 256 to disable translucency otherwise Geany might crash.

Only the first and second argument is interpreted.

Example: translucency=256;256;false;false

marker_line

The style for a highlighted line (e.g when using Goto line or goto tag). The forground colour (first argument) is only used when the Markers margin is enabled (see View menu).

Only the first and second argument is interpreted.

Example: marker_line=0x000000;0xffff00;false;false

marker_search

The style for a highlighted search result (e.g when using "Mark" in Search dialogs). The foreground colour (first argument) is only used when the Markers margin is enabled (see View menu).

Only the first and second argument is interpreted.

Example: marker_search=0x000000;0xB8F4B8;false;false

marker_translucency

Translucency for the line marker (first argument) and the search marker (second argument). Values between 0 and 256 are accepted.

Note for Windows 95, 98 and ME users: keep this value at 256 to disable translucency otherwise Geany might crash.

Only the first and second argument is interpreted.

Example: marker_translucency=256;256;false;false

whitespace_chars

Characters to treat as whitespace. These characters are ignored when moving, selecting and deleting across word boundaries (see Scintilla keyboard commands).

This should include space (\s) and tab (\t).

Example: whitespace_chars=\s\t!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~

Template metadata

Metadata can be used with all templates, but by default user set metadata is only used for the ChangeLog and File header templates.

In the configuration dialog you can find a tab "Templates" (see Template tab in preferences dialog). You can define the default values which will be inserted in the templates. You should restart Geany after making changes, because they are only read at startup.

Filetype templates

Filetype templates are templates used as the basis of a new file. To use them, choose the New (with Template) menu item from the File menu.

By default, templates are created for some filetypes. Other filetype templates can be added by creating the appropriate template file and restarting Geany. You can also edit the default filetype templates.

Filetype template files are read from the ~/.geany/templates directory, and are named "filetype." followed by the filetype name, e.g. "filetype.python", "filetype.sh", etc. If you are unsure about the filetype name extensions, they are the same as the filetype configuration file extensions, commonly installed in /usr/share/geany, with the prefix "filetypes.".

The file's contents are just the text to place in the document, except for the optional {fileheader} template wildcard. This can be placed anywhere, but is usually on the first line of the file, followed by a blank line.

There is also a template file template.none which is used when the New command is used without a filetype. This is empty by default.

Customizing templates

Each template can be customized to your needs. The templates are stored in the ~/.geany/templates/ directory (see the section called Command line options for further information about the configuration directory). Just open the desired template with an editor (ideally, Geany ;-) ) and edit the template to your needs. There are some wildcards which will be automatically replaced by Geany at startup.