2 * plugins.dox - this file is part of Geany, a fast and lightweight IDE
4 * Copyright 2008-2011 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
5 * Copyright 2008-2011 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
6 * Copyright 2009-2011 Frank Lanitz <frank(at)frank(dot)uvena(dot)de>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
23 * This file contains additional plugin documentation like the signal system and a small howto.
24 * It is best viewed when filetype is set to C or C++.
30 * @mainpage Geany Plugin API Documentation
32 * @author Enrico Tröger, Nick Treleaven, Frank Lanitz
35 * This is the Geany API documentation. It should be considered work in progress.
36 * We will try to document as many functions and structs as possible.
38 * @warning Do not use any symbol not in the documentation - it may change.
40 * @section pluginsupport Plugin Support
41 * - @link howto Plugin HowTo @endlink - get started
42 * - @link pluginsymbols.c Plugin Symbols @endlink
43 * - @link plugindata.h Plugin Datatypes and Macros @endlink
44 * - @link pluginsignals.c Plugin Signals @endlink
45 * - @link pluginutils.h Plugin Utility Functions @endlink
46 * - @link guidelines Plugin Writing Guidelines @endlink
47 * - <b>plugins/demoplugin.c</b> - in Geany's source, bigger than the howto example
49 * @section common Common API files
50 * - @link dialogs.h @endlink
51 * - @link document.h @endlink
52 * - @link editor.h @endlink
53 * - @link filetypes.h @endlink
54 * - @link keybindings.h @endlink
55 * - @link msgwindow.h @endlink
56 * - @link project.h @endlink
57 * - @link sciwrappers.h Scintilla Wrapper Functions @endlink
58 * - @link stash.h Stash Pref/Setting Functions @endlink
59 * - @link utils.h General Utility Functions @endlink
60 * - @link ui_utils.h Widget Utility Functions @endlink
63 * - All API functions and types - see <b>Files</b> link at the top
64 * - Deprecated symbols - see <b>Related Pages</b> link at the top
66 * @note See the HACKING file for information about developing the plugin API and
71 * @page guidelines Plugin Writing Guidelines
73 * @section intro Introduction
75 * The following hints and guidelines are only recommendations. Nobody is forced to follow
78 * @section general General notes
80 * @subsection ideas Getting a plugin idea
82 * If you want to write a plugin but don't know yet what it should do, have a look at
83 * http://www.geany.org/Support/PluginWishlist to get an idea about what users wish.
85 * @subsection code Managing the source code
87 * For authors of plugins for Geany, we created a dedicated @a geany-plugins using
88 * project Sourceforge and github to ease development of plugins and help new authors.
89 * All information about this project you can find at http://plugins.geany.org/
91 * To add a new plugin to this project, get in contact with the people at
92 * geany-devel-mailing list and create a fork of the geany-plugins-project
93 * at https://github.com/geany/geany-plugins.
94 * Beside of adding a new plugin, geany-devel-mailinglist is
95 * also the place where to discuss development related questions.
96 * However, once you have done your fork of geany-plugins you can develop
97 * your plugin until you think its the right time to publish it. At this point create a
98 * pull request for adding your patch set into master branch of geany-plugins.
99 * Of course, you don't need to use github - just any git is fine. But github
100 * is making it way easier for review, merging and get in touch with you for
103 * If you don't want to take part at the geany-plugins-project it is also fine.
104 * Just skip the part about forking geany-plugins and sending a pull request.
105 * In this case its of course also a good idea to post some kind of announcement
106 * also to geany-devel and maybe to the main geany mailinglist -- Up to you.
108 * At time of writing, there are some plugins already available in the
109 * repositories. Feel free to use any of these plugins as a start for your own,
110 * maybe by copying the directory structure and the autotools files
111 * (Makefile.am, configure.in, ...). Most of the available plugins are also ready for
112 * i18n support, just for reference.
114 * We encourage authors using this service to only commit changes to their
115 * own plugin and not to others' plugins. Instead just send patches to
116 * geany-devel at uvena.de or the plugin author directly.
118 * @section paths Installation paths
120 * - The plugin binary (@c pluginname.so) should be installed in Geany's libdir. This is
121 * necessary so that Geany can find the plugin.
122 * An easy way to retrieve Geany's libdir is to use the pkg-config tool, e.g. @code
123 * `$PKG_CONFIG --variable=libdir geany`/ geany
125 * - If your plugin creates other binary files like helper programs or helper libraries,
126 * they should go into @c $prefix/bin (for programs, ideally prefixed with @a geany),
127 * additional libraries should be installed in Geany's libdir, maybe in a subdirectory.
128 * - Plugins should install their documentation files (README, NEWS, ChangeLog, licences and
129 * other documentation files) into the common documentation directory
130 * @c $prefix/share/doc/geany-plugins/$pluginname/
131 * - Translation files should be installed normally into @c $prefix/share/locale. There is no
132 * need to use Geany's translation directory. To set up translation support properly and
133 * for additional information, see main_locale_init().
134 * - Do @a never install anything into a user's home directory like installing
135 * the plugin binary in @c ~/.config/geany/plugins/.
138 * @page howto Plugin HowTo
140 * @section intro Introduction
142 * Since Geany 0.12 there is a plugin interface to extend Geany's functionality and
143 * add new features. This document gives a brief overview about how to add new
144 * plugins by writing a simple "Hello World" plugin in C or C++.
147 * @section buildenv Build environment
149 * To be able to write plugins for Geany, you need the source code and some development
150 * packages for GTK and its dependencies. The following will only describe the way to compile and
151 * build plugins on Unix-like systems [1].
152 * If you already have the Geany source code and compiled it from them, you can skip the
155 * First you need to have Geany installed. Then install the development files for GTK
156 * and its dependencies. The easiest way to do this is to use your distribution's package
157 * management system, e.g. on Debian and Ubuntu systems you can use
158 * @code apt-get install libgtk2.0-dev intltool @endcode
159 * This will install all necessary files to be able to compile plugins for Geany. On other
160 * distributions, the package names and commands to use may differ.
162 * Basically, you are done at this point and could continue with writing the plugin code.
164 * [1] For Windows, it is basically the same but you might have some more work on setting up
165 * the general build environment(compiler, GTK development files, ...). This is described on
166 * Geany's website at http://www.geany.org/Support/BuildingOnWin32.
168 * @section helloworld "Hello World"
170 * When writing a plugin, you will find a couple of functions or macros which are mandatory
171 * and some which are free to use for implementing some useful feature once your plugin
172 * becomes more powerful like including a configuration or help dialog.
174 * You should start your plugin with including some of the needed C header files and defining
175 * some basic global variables which will help you to access all needed functions of the plugin
176 * API in a more comfortable way.
178 * Let's start with the very basic headers and add more later if necessary.
180 #include <geanyplugin.h>
183 * @a geanyplugin.h includes all of the Geany API and also the necessary GTK header files,
184 * so there is no need to include @a gtk/gtk.h yourself.
187 * @a plugindata.h contains the biggest part of the plugin API and provides some basic macros.
188 * @a geanyfunctions.h provides some macros for convenient access to plugin API functions.
190 * Then you should define three basic variables which will give access to data fields and
191 * functions provided by the plugin API.
193 GeanyPlugin *geany_plugin;
194 GeanyData *geany_data;
195 GeanyFunctions *geany_functions;
198 * Now you can go on and write your first lines for your new plugin. As mentioned before,
199 * you will need to implement and fill out a couple of functions/macros to make the plugin work.
200 * So let's start with PLUGIN_VERSION_CHECK().
202 * PLUGIN_VERSION_CHECK() is a convenient way to tell Geany which version of Geany's plugin API
203 * is needed at minimum to run your plugin. The value is defined in
204 * @a plugindata.h by @a GEANY_API_VERSION. In most cases this should be your minimum.
205 * Nevertheless when setting this value, you should choose the lowest possible version here to
206 * make the plugin compatible with a bigger number of versions of Geany.
208 * For the next step, you will need to tell Geany some basic information about your plugin
209 * which will be shown in the plugin manager dialog.
211 * To do this you should use the PLUGIN_SET_INFO() macro, which expects 4 parameters:
213 * - Short description
217 * Based on this, the line could look like:
219 PLUGIN_SET_INFO("HelloWorld", "Just another tool to say hello world",
220 "1.0", "John Doe <john.doe@example.org>");
223 * Once this is done, you will need to implement the function which will be executed when the
224 * plugin is loaded. Part of that function could be adding and removing of an item to
225 * Geany's Tools menu, setting up keybindings or registering some callbacks. Also you will
226 * need to implement the function that is called when your plugin is unloaded.
227 * These functions are called plugin_init() and plugin_cleanup(). Let's see what this
230 PLUGIN_VERSION_CHECK(211)
232 PLUGIN_SET_INFO("HelloWorld", "Just another tool to say hello world",
233 "1.0", "Joe Doe <joe.doe@example.org>");
235 void plugin_init(GeanyData *data)
239 void plugin_cleanup(void)
244 * If you think this plugin seems not to implement any functionality right now and only wastes
245 * some memory, you are right. But it should compile and load/unload in Geany nicely.
246 * Now you have the very basic layout of a new plugin. Great, isn't it?
250 * If you would rather write the plugin in C++, you can do that by marking the
251 * plugin functions that it implements as @c extern @c "C", for example:
255 extern "C" void plugin_init(GeanyData *data)
259 extern "C" void plugin_cleanup(void)
264 * @section building Building
266 * First make plugin.o:
268 * @code gcc -c plugin.c -fPIC `pkg-config --cflags geany` @endcode
270 * Then make the plugin library plugin.so (or plugin.dll on Windows):
272 * @code gcc plugin.o -o plugin.so -shared `pkg-config --libs geany` @endcode
274 * If all went OK, put the library into one of the paths Geany looks for plugins,
275 * e.g. $prefix/lib/geany. See @ref paths "Installation paths" for details.
279 * If you are writing the plugin in C++, then you will need to use your C++
280 * compiler here, for example @c g++.
282 * @section realfunc Adding functionality
284 * Let's go on and implement some real functionality.
286 * As mentioned before, plugin_init() will be called when the plugin is loaded in Geany.
287 * So it should implement everything that needs to be done during startup. In this case,
288 * we'd like to add a menu item to Geany's Tools menu which runs a dialog printing "Hello World".
290 void plugin_init(GeanyData *data)
292 GtkWidget *main_menu_item;
294 // Create a new menu item and show it
295 main_menu_item = gtk_menu_item_new_with_mnemonic("Hello World");
296 gtk_widget_show(main_menu_item);
298 // Attach the new menu item to the Tools menu
299 gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu),
302 // Connect the menu item with a callback function
303 // which is called when the item is clicked
304 g_signal_connect(main_menu_item, "activate",
305 G_CALLBACK(item_activate_cb), NULL);
309 * This will add an item to the Tools menu and connect this item to a function which implements
310 * what should be done when the menu item is activated by the user.
311 * This is done by g_signal_connect(). The Tools menu can be accessed with
312 * geany->main_widgets->tools_menu. The structure @a main_widgets contains pointers to the
313 * main GUI elements in Geany.
315 * Geany has a simple API for showing message dialogs. So our function contains
318 void item_activate_cb(GtkMenuItem *menuitem, gpointer user_data)
320 dialogs_show_msgbox(GTK_MESSAGE_INFO, "Hello World");
324 * For the moment you don't need to worry about the parameters of that function.
326 * Now we need to clean up properly when the plugin is unloaded.
328 * To remove the menu item from the Tools menu, you can use gtk_widget_destroy().
329 * gtk_widget_destroy() expects a pointer to a GtkWidget object.
331 * First you should add gtk_widget_destroy() to your plugin_cleanup() function.
332 * The argument for gtk_widget_destroy() is the widget object you created earlier in
333 * plugin_init(). To be able to access this pointer in plugin_cleanup(), you need to move
334 * its definition from plugin_init() into the global context so its visibility will increase
335 * and it can be accessed in all functions.
337 static GtkWidget *main_menu_item = NULL;
340 void plugin_init(GeanyData *data)
342 main_menu_item = gtk_menu_item_new_with_mnemonic("Hello World");
343 gtk_widget_show(main_menu_item);
347 void plugin_cleanup(void)
349 gtk_widget_destroy(main_menu_item);
353 * This will ensure your menu item is removed from the Tools menu as well as from
354 * memory once your plugin is unloaded, so you don't leave any memory leaks.
355 * Once this is done, your first plugin is ready. Congratulations!
357 * @section listing Complete listing (without comments)
360 #include <geanyplugin.h>
362 GeanyPlugin *geany_plugin;
363 GeanyData *geany_data;
364 GeanyFunctions *geany_functions;
366 PLUGIN_VERSION_CHECK(211)
368 PLUGIN_SET_INFO("HelloWorld", "Just another tool to say hello world",
369 "1.0", "John Doe <john.doe@example.org>");
372 static GtkWidget *main_menu_item = NULL;
374 static void item_activate_cb(GtkMenuItem *menuitem, gpointer gdata)
376 dialogs_show_msgbox(GTK_MESSAGE_INFO, "Hello World");
379 void plugin_init(GeanyData *data)
381 main_menu_item = gtk_menu_item_new_with_mnemonic("Hello World");
382 gtk_widget_show(main_menu_item);
383 gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu),
385 g_signal_connect(main_menu_item, "activate",
386 G_CALLBACK(item_activate_cb), NULL);
389 void plugin_cleanup(void)
391 gtk_widget_destroy(main_menu_item);
396 * Now you might like to look at Geany's source code for core plugins such as
397 * @a plugins/demoplugin.c.
399 * @section furtherimprovements Furter Improvements and next steps
400 * @subsection translatable_plugin_information Translatable plugin information
402 * After having written our first plugin, there is still room for improvement.
404 * By default, PLUGIN_SET_INFO() does not allow translation of the basic plugin
405 * information for plugins which are not shipped with Geany's core distribution.
406 * Since most plugins are not shipped with Geany's core, it makes sense to
407 * enable translation when the plugin is loaded so that it gets translated
408 * inside Geany's Plugin Manager. As of Geany 0.19, the plugin API contains
409 * the PLUGIN_SET_TRANSLATABLE_INFO() macro which enables translation of the
410 * basic plugin details passed to PLUGIN_SET_INFO() when the plugin is loaded.
412 * PLUGIN_SET_TRANSLATABLE_INFO() takes two more parameters than PLUGIN_SET_INFO(),
413 * for a total of six parameters.
418 * - Short description
422 * The @a Localdir and the @a Gettextpackage parameters are usually set inside
423 * the build system. If this has been done, the call for example HelloWorld
424 * plugin could look like:
427 PLUGIN_SET_TRANSLATABLE_INFO(
428 LOCALEDIR, GETTEXT_PACKAGE, _("Hello World"),
429 _("Just another tool to say hello world"),
430 "1.0", "John Doe <john.doe@example.org>");
433 * When using this macro, you should use the gettext macro @a _() to mark
434 * the strings like name and the short description as translatable as well. You
435 * can see how this is done in the above example.
437 * As you can see the author's information is not marked as translatable in
438 * this example. The community has agreed that the best practice here is to
439 * use, if possible, the latin version of the author's name followed by the
440 * native spelling inside parenthesis, where applicable.
442 * @subsection plugin_i18n Using i18n/l10n inside Plugin
445 * You can (and should) also mark other strings beside the plugin's meta
446 * information as translatable. Strings used in menu entries, information
447 * boxes or configuration dialogs should also be translatable as well. Geany
448 * offers a way to enable this in the plugin's code using the main_locale_init()
449 * function provided by the plugin API. This function takes the same two
450 * parameters discussed in the previous section; @a GETTEXT_PACKAGE and
453 * The main_locale_init() function is best called during initialization in the
454 * plugin's plugin_init() function. Adding this to the HelloWorld example could
457 void plugin_init(GeanyData *data)
459 main_locale_init(LOCALEDIR, GETTEXT_PACKAGE);
460 main_menu_item = gtk_menu_item_new_with_mnemonic("Hello World");
461 gtk_widget_show(main_menu_item);
462 gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu),
464 g_signal_connect(main_menu_item, "activate",
465 G_CALLBACK(item_activate_cb), NULL);
469 * @note If you've previously called the PLUGIN_SET_TRANSLATABLE_INFO() you do not
470 * need to call main_locale_init() yourself, as this has been already been