src/plugindata.h

   1 /*
   2  *      plugindata.h - this file is part of Geany, a fast and lightweight IDE
   3  *
   4  *      Copyright 2007-2010 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
   5  *      Copyright 2007-2010 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License
  18  *      along with this program; if not, write to the Free Software
  19  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  20  *      MA 02110-1301, USA.
  21  *
  22  * $Id$
  23  */
  24
  25 /**
  26  * @file plugindata.h
  27  * This file defines the plugin API, the interface between Geany and its plugins.
  28  * For detailed documentation of the plugin system please read the plugin
  29  * API documentation.
  30  **/
  31 /* Note: Remember to increment GEANY_API_VERSION (and GEANY_ABI_VERSION if necessary)
  32  * when making changes (see 'Keeping the plugin ABI stable' in the HACKING file). */
  33
  34
  35 #ifndef PLUGINDATA_H
  36 #define PLUGINDATA_H
  37
  38 /* Compatibility for sharing macros between API and core.
  39  * First include geany.h, then plugindata.h, then other API headers. */
  40 #undef GEANY
  41 #define GEANY(symbol_name) geany->symbol_name
  42
  43 #include "editor.h"     /* GeanyIndentType */
  44
  45
  46 /* Note: We use enum instead of 'static const gint' to allow its use in global variable
  47  * initializing, otherwise we get errors like:
  48  * error: initializer element is not constant */
  49 /** Versioning data */
  50 enum {
  51         /** The Application Programming Interface (API) version, incremented
  52          * whenever any plugin data types are modified or appended to. */
  53         GEANY_API_VERSION = 183,
  54
  55         /** The Application Binary Interface (ABI) version, incremented whenever
  56          * existing fields in the plugin data types have to be changed or reordered. */
  57         /* This should usually stay the same if fields are only appended, assuming only pointers to
  58          * structs and not structs themselves are declared by plugins. */
  59         GEANY_ABI_VERSION = 66
  60 };
  61
  62 /** Checks the plugin can be loaded by Geany.
  63  * This performs runtime checks that try to ensure:
  64  * - Geany ABI data types are compatible with this plugin.
  65  * - Geany sources provide the required API for this plugin. */
  66 #define PLUGIN_VERSION_CHECK(api_required) \
  67         gint plugin_version_check(gint abi_ver) \
  68         { \
  69                 if (abi_ver != GEANY_ABI_VERSION) \
  70                         return -1; \
  71                 if (GEANY_API_VERSION < (api_required)) \
  72                         return (api_required); \
  73                 else return 0; \
  74         }
  75
  76
  77 /** Basic information about a plugin available to Geany without loading the plugin.
  78  * The fields are set in plugin_set_info(), usually with the PLUGIN_SET_INFO() macro. */
  79 typedef struct PluginInfo
  80 {
  81         /** The name of the plugin. */
  82         gchar   *name;
  83         /** The description of the plugin. */
  84         gchar   *description;
  85         /** The version of the plugin. */
  86         gchar   *version;
  87         /** The author of the plugin. */
  88         gchar   *author;
  89 }
  90 PluginInfo;
  91
  92
  93 /** Basic information for the plugin and identification.
  94  * @see geany_plugin. */
  95 typedef struct GeanyPlugin
  96 {
  97         PluginInfo      *info;  /**< Fields set in plugin_set_info(). */
  98
  99         struct GeanyPluginPrivate *priv;        /* private */
 100 }
 101 GeanyPlugin;
 102
 103
 104 /** Sets the plugin name and some other basic information about a plugin.
 105  * This declares a function, so you can use the _() translation macro for arguments.
 106  *
 107  * Example:
 108  * @code PLUGIN_SET_INFO(_("Cool Feature"), _("Adds cool feature support."), "0.1", "Joe Author") @endcode */
 109 /* plugin_set_info() could be written manually for plugins if we want to add any
 110  * extra PluginInfo features (such as an icon), so we don't need to break API
 111  * compatibility. Alternatively just add a new macro, PLUGIN_SET_INFO_FULL(). -ntrel */
 112 #define PLUGIN_SET_INFO(p_name, p_description, p_version, p_author) \
 113         void plugin_set_info(PluginInfo* info) \
 114         { \
 115                 info->name = (p_name); \
 116                 info->description = (p_description); \
 117                 info->version = (p_version); \
 118                 info->author = (p_author); \
 119         }
 120
 121
 122 /** @deprecated - use plugin_set_key_group() instead.
 123  * @see PLUGIN_KEY_GROUP() macro. */
 124 typedef struct GeanyKeyGroupInfo
 125 {
 126         const gchar *name;              /**< Group name used in the configuration file, such as @c "html_chars" */
 127         gsize count;                    /**< The number of keybindings the group will hold */
 128 }
 129 GeanyKeyGroupInfo;
 130
 131 /** @deprecated - use plugin_set_key_group() instead.
 132  * Declare and initialise a keybinding group.
 133  * @code GeanyKeyGroup *plugin_key_group; @endcode
 134  * You must then set the @c plugin_key_group::keys[] entries for the group in plugin_init(),
 135  * normally using keybindings_set_item().
 136  * The @c plugin_key_group::label field is set by Geany after @c plugin_init()
 137  * is called, to the name of the plugin.
 138  * @param group_name A unique group name (without quotes) to be used in the
 139  * configuration file, such as @c html_chars.
 140  * @param key_count     The number of keybindings the group will hold. */
 141 #define PLUGIN_KEY_GROUP(group_name, key_count) \
 142         /* We have to declare this as a single element array.
 143          * Declaring as a pointer to a struct doesn't work with g_module_symbol(). */ \
 144         GeanyKeyGroupInfo plugin_key_group_info[1] = \
 145         { \
 146                 {G_STRINGIFY(group_name), key_count} \
 147         };\
 148         GeanyKeyGroup *plugin_key_group = NULL;
 149
 150
 151 /** Callback array entry type used with the @ref plugin_callbacks symbol. */
 152 typedef struct PluginCallback
 153 {
 154         /** The name of signal, must be an existing signal. For a list of available signals,
 155          *  please see the @link signals Signal documentation @endlink. */
 156         gchar           *signal_name;
 157         /** A callback function which is called when the signal is emitted. */
 158         GCallback       callback;
 159         /** Set to TRUE to connect your handler with g_signal_connect_after(). */
 160         gboolean        after;
 161         /** The user data passed to the signal handler. */
 162         gpointer        user_data;
 163 }
 164 PluginCallback;
 165
 166
 167 /** @deprecated Use @ref ui_add_document_sensitive() instead.
 168  * Flags to be set by plugins in PluginFields struct. */
 169 typedef enum
 170 {
 171         /** Whether a plugin's menu item should be disabled when there are no open documents */
 172         PLUGIN_IS_DOCUMENT_SENSITIVE    = 1 << 0
 173 }
 174 PluginFlags;
 175
 176 /** @deprecated Use @ref ui_add_document_sensitive() instead.
 177  * Fields set and owned by the plugin. */
 178 typedef struct PluginFields
 179 {
 180         /** Bitmask of @c PluginFlags. */
 181         PluginFlags     flags;
 182         /** Pointer to a plugin's menu item which will be automatically enabled/disabled when there
 183          *  are no open documents and @c PLUGIN_IS_DOCUMENT_SENSITIVE is set.
 184          *  This is required if using @c PLUGIN_IS_DOCUMENT_SENSITIVE, ignored otherwise */
 185         GtkWidget       *menu_item;
 186 }
 187 PluginFields;
 188
 189
 190 /** This contains pointers to global variables owned by Geany for plugins to use.
 191  * Core variable pointers can be appended when needed by plugin authors, if appropriate. */
 192 typedef struct GeanyData
 193 {
 194         struct GeanyApp                         *app;                           /**< Geany application data fields */
 195         struct GeanyMainWidgets         *main_widgets;          /**< Important widgets in the main window */
 196         GPtrArray                                       *documents_array;       /**< See document.h#documents_array. */
 197         GPtrArray                                       *filetypes_array;       /**< Dynamic array of GeanyFiletype pointers */
 198         struct GeanyPrefs                       *prefs;                         /**< General settings */
 199         struct GeanyInterfacePrefs      *interface_prefs;       /**< Interface settings */
 200         struct GeanyToolbarPrefs        *toolbar_prefs;         /**< Toolbar settings */
 201         struct GeanyEditorPrefs         *editor_prefs;          /**< Editor settings */
 202         struct GeanyFilePrefs           *file_prefs;            /**< File-related settings */
 203         struct GeanySearchPrefs         *search_prefs;          /**< Search-related settings */
 204         struct GeanyToolPrefs           *tool_prefs;            /**< Tool settings */
 205         struct GeanyTemplatePrefs       *template_prefs;        /**< Template settings */
 206         struct GeanyBuildInfo           *build_info;            /**< Current build information */
 207         GSList                                          *filetypes_by_title; /**< See filetypes.h#filetypes_by_title. */
 208 }
 209 GeanyData;
 210
 211 #define geany                   geany_data      /**< Simple macro for @c geany_data that reduces typing. */
 212
 213
 214 /** This contains pointers to functions owned by Geany for plugins to use.
 215  * Functions from the core can be appended when needed by plugin authors, but may
 216  * require some changes. */
 217 typedef struct GeanyFunctions
 218 {
 219         struct DocumentFuncs            *p_document;            /**< See document.h */
 220         struct SciFuncs                         *p_sci;                         /**< See sciwrappers.h */
 221         struct TemplateFuncs            *p_templates;           /**< See templates.h */
 222         struct UtilsFuncs                       *p_utils;                       /**< See utils.h */
 223         struct UIUtilsFuncs                     *p_ui;                          /**< See ui_utils.h */
 224         /** @deprecated Use ui_lookup_widget() instead. */
 225         struct SupportFuncs                     *p_support;
 226         struct DialogFuncs                      *p_dialogs;                     /**< See dialogs.h */
 227         /** @deprecated Use @ref GeanyFunctions::p_msgwin instead. */
 228         struct MsgWinFuncs                      *p_msgwindow;
 229         struct EncodingFuncs            *p_encodings;           /**< See encodings.h */
 230         struct KeybindingFuncs          *p_keybindings;         /**< See keybindings.h */
 231         struct TagManagerFuncs          *p_tm;                          /**< See tagmanager/include */
 232         struct SearchFuncs                      *p_search;                      /**< See search.h */
 233         struct HighlightingFuncs        *p_highlighting;        /**< See highlighting.h */
 234         struct FiletypeFuncs            *p_filetypes;           /**< See filetypes.h */
 235         struct NavQueueFuncs        *p_navqueue;                /**< See navqueue.h */
 236         struct EditorFuncs              *p_editor;                      /**< See editor.h */
 237         struct MainFuncs                *p_main;                        /**< See main.h */
 238         struct PluginFuncs              *p_plugin;                      /**< See pluginutils.c */
 239         struct ScintillaFuncs           *p_scintilla;           /**< See ScintillaFuncs */
 240         struct MsgWinFuncs                      *p_msgwin;                      /**< See msgwindow.h */
 241         struct StashFuncs                       *p_stash;                       /**< See stash.h */
 242 }
 243 GeanyFunctions;
 244
 245
 246 /* For more information about these functions, see the main source code.
 247  * E.g. for p_document->new_file(), see document_new_file() in document.c. */
 248
 249
 250 /* See document.h */
 251 typedef struct DocumentFuncs
 252 {
 253         struct GeanyDocument*   (*document_new_file) (const gchar *utf8_filename, struct GeanyFiletype *ft,
 254                         const gchar *text);
 255         struct GeanyDocument*   (*document_get_current) (void);
 256         struct GeanyDocument*   (*document_get_from_page) (guint page_num);
 257         struct GeanyDocument*   (*document_find_by_filename) (const gchar *utf8_filename);
 258         struct GeanyDocument*   (*document_find_by_real_path) (const gchar *realname);
 259         gboolean                                (*document_save_file) (struct GeanyDocument *doc, gboolean force);
 260         struct GeanyDocument*   (*document_open_file) (const gchar *locale_filename, gboolean readonly,
 261                         struct GeanyFiletype *ft, const gchar *forced_enc);
 262         void            (*document_open_files) (const GSList *filenames, gboolean readonly,
 263                         struct GeanyFiletype *ft, const gchar *forced_enc);
 264         gboolean        (*document_remove_page) (guint page_num);
 265         gboolean        (*document_reload_file) (struct GeanyDocument *doc, const gchar *forced_enc);
 266         void            (*document_set_encoding) (struct GeanyDocument *doc, const gchar *new_encoding);
 267         void            (*document_set_text_changed) (struct GeanyDocument *doc, gboolean changed);
 268         void            (*document_set_filetype) (struct GeanyDocument *doc, struct GeanyFiletype *type);
 269         gboolean        (*document_close) (struct GeanyDocument *doc);
 270         struct GeanyDocument*   (*document_index)(gint idx);
 271         gboolean        (*document_save_file_as) (struct GeanyDocument *doc, const gchar *utf8_fname);
 272         void            (*document_rename_file) (struct GeanyDocument *doc, const gchar *new_filename);
 273         const GdkColor* (*document_get_status_color) (struct GeanyDocument *doc);
 274         gchar*          (*document_get_basename_for_display) (struct GeanyDocument *doc, gint length);
 275         gint            (*document_get_notebook_page) (struct GeanyDocument *doc);
 276 }
 277 DocumentFuncs;
 278
 279
 280 struct _ScintillaObject;
 281
 282 /** See http://scintilla.org for the full documentation. */
 283 typedef struct ScintillaFuncs
 284 {
 285         /** Send Scintilla a message. */
 286         long int        (*scintilla_send_message) (struct _ScintillaObject* sci, unsigned int iMessage,
 287                         long unsigned int wParam, long int lParam);
 288         /** Create a new ScintillaObject widget. */
 289         GtkWidget*      (*scintilla_new)(void);
 290 }
 291 ScintillaFuncs;
 292
 293
 294 /** Wrapper functions for Scintilla messages.
 295  * See sciwrappers.h for the list of functions. */
 296 typedef struct SciFuncs
 297 {
 298         /** @deprecated Use @c scintilla_send_message() instead. */
 299         long int (*sci_send_message) (struct _ScintillaObject *sci, unsigned int iMessage,
 300                         long unsigned int wParam, long int lParam);
 301         void    (*sci_send_command) (struct _ScintillaObject *sci, gint cmd);
 302
 303         void    (*sci_start_undo_action) (struct _ScintillaObject *sci);
 304         void    (*sci_end_undo_action) (struct _ScintillaObject *sci);
 305         void    (*sci_set_text) (struct _ScintillaObject *sci, const gchar *text);
 306         void    (*sci_insert_text) (struct _ScintillaObject *sci, gint pos, const gchar *text);
 307         void    (*sci_get_text) (struct _ScintillaObject *sci, gint len, gchar *text);
 308         gint    (*sci_get_length) (struct _ScintillaObject *sci);
 309         gint    (*sci_get_current_position) (struct _ScintillaObject *sci);
 310         void    (*sci_set_current_position) (struct _ScintillaObject *sci, gint position,
 311                          gboolean scroll_to_caret);
 312         gint    (*sci_get_col_from_position) (struct _ScintillaObject *sci, gint position);
 313         gint    (*sci_get_line_from_position) (struct _ScintillaObject *sci, gint position);
 314         gint    (*sci_get_position_from_line) (struct _ScintillaObject *sci, gint line);
 315         void    (*sci_replace_sel) (struct _ScintillaObject *sci, const gchar *text);
 316         void    (*sci_get_selected_text) (struct _ScintillaObject *sci, gchar *text);
 317         gint    (*sci_get_selected_text_length) (struct _ScintillaObject *sci);
 318         gint    (*sci_get_selection_start) (struct _ScintillaObject *sci);
 319         gint    (*sci_get_selection_end) (struct _ScintillaObject *sci);
 320         gint    (*sci_get_selection_mode) (struct _ScintillaObject *sci);
 321         void    (*sci_set_selection_mode) (struct _ScintillaObject *sci, gint mode);
 322         void    (*sci_set_selection_start) (struct _ScintillaObject *sci, gint position);
 323         void    (*sci_set_selection_end) (struct _ScintillaObject *sci, gint position);
 324         void    (*sci_get_text_range) (struct _ScintillaObject *sci, gint start, gint end, gchar *text);
 325         gchar*  (*sci_get_line) (struct _ScintillaObject *sci, gint line_num);
 326         gint    (*sci_get_line_length) (struct _ScintillaObject *sci, gint line);
 327         gint    (*sci_get_line_count) (struct _ScintillaObject *sci);
 328         gboolean (*sci_get_line_is_visible) (struct _ScintillaObject *sci, gint line);
 329         void    (*sci_ensure_line_is_visible) (struct _ScintillaObject *sci, gint line);
 330         void    (*sci_scroll_caret) (struct _ScintillaObject *sci);
 331         gint    (*sci_find_matching_brace) (struct _ScintillaObject *sci, gint pos);
 332         gint    (*sci_get_style_at) (struct _ScintillaObject *sci, gint position);
 333         gchar   (*sci_get_char_at) (struct _ScintillaObject *sci, gint pos);
 334         gint    (*sci_get_current_line) (struct _ScintillaObject *sci);
 335         gboolean (*sci_has_selection) (struct _ScintillaObject *sci);
 336         gint    (*sci_get_tab_width) (struct _ScintillaObject *sci);
 337         void    (*sci_indicator_clear) (struct _ScintillaObject *sci, gint start, gint end);
 338         void    (*sci_indicator_set) (struct _ScintillaObject *sci, gint indic);
 339         gchar*  (*sci_get_contents) (struct _ScintillaObject *sci, gint len);
 340         gchar*  (*sci_get_contents_range) (struct _ScintillaObject *sci, gint start, gint end);
 341         gchar*  (*sci_get_selection_contents) (struct _ScintillaObject *sci);
 342         void    (*sci_set_font) (struct _ScintillaObject *sci, gint style, const gchar *font, gint size);
 343         gint    (*sci_get_line_end_position) (struct _ScintillaObject *sci, gint line);
 344         void    (*sci_set_target_start) (struct _ScintillaObject *sci, gint start);
 345         void    (*sci_set_target_end) (struct _ScintillaObject *sci, gint end);
 346         gint    (*sci_replace_target) (struct _ScintillaObject *sci, const gchar *text, gboolean regex);
 347         void    (*sci_set_marker_at_line) (struct _ScintillaObject *sci, gint line_number, gint marker);
 348         void    (*sci_delete_marker_at_line) (struct _ScintillaObject *sci, gint line_number, gint marker);
 349         gboolean (*sci_is_marker_set_at_line) (struct _ScintillaObject *sci, gint line, gint marker);
 350         void    (*sci_goto_line) (struct _ScintillaObject *sci, gint line, gboolean unfold);
 351         gint    (*sci_find_text) (struct _ScintillaObject *sci, gint flags, struct Sci_TextToFind *ttf);
 352 }
 353 SciFuncs;
 354
 355
 356 /* See templates.h */
 357 typedef struct TemplateFuncs
 358 {
 359         gchar*          (*templates_get_template_fileheader) (gint filetype_idx, const gchar *fname);
 360 }
 361 TemplateFuncs;
 362
 363
 364 /* See utils.h */
 365 typedef struct UtilsFuncs
 366 {
 367         gboolean        (*utils_str_equal) (const gchar *a, const gchar *b);
 368         guint           (*utils_string_replace_all) (GString *haystack, const gchar *needle,
 369                                  const gchar *replacement);
 370         GSList*         (*utils_get_file_list) (const gchar *path, guint *length, GError **error);
 371         gint            (*utils_write_file) (const gchar *filename, const gchar *text);
 372         gchar*          (*utils_get_locale_from_utf8) (const gchar *utf8_text);
 373         gchar*          (*utils_get_utf8_from_locale) (const gchar *locale_text);
 374         gchar*          (*utils_remove_ext_from_filename) (const gchar *filename);
 375         gint            (*utils_mkdir) (const gchar *path, gboolean create_parent_dirs);
 376         gboolean        (*utils_get_setting_boolean) (GKeyFile *config, const gchar *section, const gchar *key,
 377                                  const gboolean default_value);
 378         gint            (*utils_get_setting_integer) (GKeyFile *config, const gchar *section, const gchar *key,
 379                                  const gint default_value);
 380         gchar*          (*utils_get_setting_string) (GKeyFile *config, const gchar *section, const gchar *key,
 381                                  const gchar *default_value);
 382         gboolean        (*utils_spawn_sync) (const gchar *dir, gchar **argv, gchar **env, GSpawnFlags flags,
 383                                  GSpawnChildSetupFunc child_setup, gpointer user_data, gchar **std_out,
 384                                  gchar **std_err, gint *exit_status, GError **error);
 385         gboolean        (*utils_spawn_async) (const gchar *dir, gchar **argv, gchar **env, GSpawnFlags flags,
 386                                  GSpawnChildSetupFunc child_setup, gpointer user_data, GPid *child_pid,
 387                                  GError **error);
 388         gint            (*utils_str_casecmp) (const gchar *s1, const gchar *s2);
 389         gchar*          (*utils_get_date_time) (const gchar *format, time_t *time_to_use);
 390         void            (*utils_open_browser) (const gchar *uri);
 391         guint           (*utils_string_replace_first) (GString *haystack, const gchar *needle,
 392                                  const gchar *replace);
 393         gchar*          (*utils_str_middle_truncate) (const gchar *string, guint truncate_length);
 394         gchar*          (*utils_str_remove_chars) (gchar *string, const gchar *chars);
 395         GSList*         (*utils_get_file_list_full)(const gchar *path, gboolean full_path, gboolean sort,
 396                                 GError **error);
 397         gchar**         (*utils_copy_environment)(const gchar **exclude_vars, const gchar *first_varname, ...);
 398
 399 }
 400 UtilsFuncs;
 401
 402
 403 /* See main.h */
 404 typedef struct MainFuncs
 405 {
 406         void            (*main_reload_configuration) (void);
 407         void            (*main_locale_init) (const gchar *locale_dir, const gchar *package);
 408         gboolean        (*main_is_realized) (void);
 409 }
 410 MainFuncs;
 411
 412
 413 /* See ui_utils.h */
 414 typedef struct UIUtilsFuncs
 415 {
 416         GtkWidget*      (*ui_dialog_vbox_new) (GtkDialog *dialog);
 417         GtkWidget*      (*ui_frame_new_with_alignment) (const gchar *label_text, GtkWidget **alignment);
 418         void            (*ui_set_statusbar) (gboolean log, const gchar *format, ...) G_GNUC_PRINTF (2, 3);
 419         void            (*ui_table_add_row) (GtkTable *table, gint row, ...) G_GNUC_NULL_TERMINATED;
 420         GtkWidget*      (*ui_path_box_new) (const gchar *title, GtkFileChooserAction action, GtkEntry *entry);
 421         GtkWidget*      (*ui_button_new_with_image) (const gchar *stock_id, const gchar *text);
 422         void            (*ui_add_document_sensitive) (GtkWidget *widget);
 423         void            (*ui_widget_set_tooltip_text) (GtkWidget *widget, const gchar *text);
 424         GtkWidget*      (*ui_image_menu_item_new) (const gchar *stock_id, const gchar *label);
 425         GtkWidget*      (*ui_lookup_widget) (GtkWidget *widget, const gchar *widget_name);
 426         void            (*ui_progress_bar_start) (const gchar *text);
 427         void            (*ui_progress_bar_stop) (void);
 428         void            (*ui_entry_add_clear_icon) (GtkEntry *entry);
 429         void            (*ui_menu_add_document_items) (GtkMenu *menu, struct GeanyDocument *active,
 430                                 GCallback callback);
 431         void            (*ui_widget_modify_font_from_string) (GtkWidget *widget, const gchar *str);
 432         gboolean        (*ui_is_keyval_enter_or_return) (guint keyval);
 433         gint            (*ui_get_gtk_settings_integer) (const gchar *property_name, gint default_value);
 434 }
 435 UIUtilsFuncs;
 436
 437
 438 /* See dialogs.h */
 439 typedef struct DialogFuncs
 440 {
 441         gboolean        (*dialogs_show_question) (const gchar *text, ...) G_GNUC_PRINTF (1, 2);
 442         void            (*dialogs_show_msgbox) (GtkMessageType type, const gchar *text, ...) G_GNUC_PRINTF (2, 3);
 443         gboolean        (*dialogs_show_save_as) (void);
 444         gboolean        (*dialogs_show_input_numeric) (const gchar *title, const gchar *label_text,
 445                                  gdouble *value, gdouble min, gdouble max, gdouble step);
 446 }
 447 DialogFuncs;
 448
 449
 450 /* @deprecated Use ui_lookup_widget() instead. */
 451 typedef struct SupportFuncs
 452 {
 453         GtkWidget*      (*support_lookup_widget) (GtkWidget *widget, const gchar *widget_name);
 454 }
 455 SupportFuncs;
 456
 457
 458 /* See msgwindow.h */
 459 typedef struct MsgWinFuncs
 460 {
 461         /* status_add() does not set the status bar - use ui->set_statusbar() instead. */
 462         void            (*msgwin_status_add) (const gchar *format, ...) G_GNUC_PRINTF (1, 2);
 463         void            (*msgwin_compiler_add) (gint msg_color, const gchar *format, ...) G_GNUC_PRINTF (2, 3);
 464         void            (*msgwin_msg_add) (gint msg_color, gint line, struct GeanyDocument *doc,
 465                                  const gchar *format, ...) G_GNUC_PRINTF (4, 5);
 466         void            (*msgwin_clear_tab) (gint tabnum);
 467         void            (*msgwin_switch_tab) (gint tabnum, gboolean show);
 468 }
 469 MsgWinFuncs;
 470
 471
 472 /* See encodings.h */
 473 typedef struct EncodingFuncs
 474 {
 475         gchar*                  (*encodings_convert_to_utf8) (const gchar *buffer, gsize size, gchar **used_encoding);
 476         gchar*                  (*encodings_convert_to_utf8_from_charset) (const gchar *buffer, gsize size,
 477                                                                                                          const gchar *charset, gboolean fast);
 478         const gchar*    (*encodings_get_charset_from_index) (gint idx);
 479 }
 480 EncodingFuncs;
 481
 482
 483 struct GeanyKeyGroup;
 484 /* avoid including keybindings.h */
 485 typedef void (*_GeanyKeyCallback) (guint key_id);
 486
 487 /* See keybindings.h */
 488 typedef struct KeybindingFuncs
 489 {
 490         void            (*keybindings_send_command) (guint group_id, guint key_id);
 491         struct GeanyKeyBinding* (*keybindings_set_item) (struct GeanyKeyGroup *group, gsize key_id,
 492                                         _GeanyKeyCallback callback, guint key, GdkModifierType mod,
 493                                         gchar *name, gchar *label, GtkWidget *menu_item);
 494         struct GeanyKeyBinding* (*keybindings_get_item)(struct GeanyKeyGroup *group, gsize key_id);
 495
 496 }
 497 KeybindingFuncs;
 498
 499
 500 /* See highlighting.h */
 501 typedef struct HighlightingFuncs
 502 {
 503         const struct GeanyLexerStyle* (*highlighting_get_style) (gint ft_id, gint style_id);
 504         void            (*highlighting_set_styles) (struct _ScintillaObject *sci, struct GeanyFiletype *ft);
 505 }
 506 HighlightingFuncs;
 507
 508
 509 /* See filetypes.h */
 510 typedef struct FiletypeFuncs
 511 {
 512         GeanyFiletype*  (*filetypes_detect_from_file) (const gchar *utf8_filename);
 513         GeanyFiletype*  (*filetypes_lookup_by_name) (const gchar *name);
 514         GeanyFiletype*  (*filetypes_index)(gint idx);
 515         /* Remember to convert any filetype_id arguments to GeanyFiletype pointers in any
 516          * appended functions */
 517 }
 518 FiletypeFuncs;
 519
 520
 521 /* See search.h */
 522 typedef struct SearchFuncs
 523 {
 524         void            (*search_show_find_in_files_dialog) (const gchar *dir);
 525 }
 526 SearchFuncs;
 527
 528
 529 /* See tagmanager/include */
 530 typedef struct TagManagerFuncs
 531 {
 532         gchar*                  (*tm_get_real_path) (const gchar *file_name);
 533         TMWorkObject*   (*tm_source_file_new) (const char *file_name, gboolean update, const char *name);
 534         gboolean                (*tm_workspace_add_object) (TMWorkObject *work_object);
 535         gboolean                (*tm_source_file_update) (TMWorkObject *source_file, gboolean force,
 536                                          gboolean recurse, gboolean update_parent);
 537         void                    (*tm_work_object_free) (gpointer work_object);
 538         gboolean                (*tm_workspace_remove_object) (TMWorkObject *w, gboolean do_free, gboolean update);
 539 }
 540 TagManagerFuncs;
 541
 542
 543 /* See navqueue.h */
 544 typedef struct NavQueueFuncs
 545 {
 546         gboolean                (*navqueue_goto_line) (struct GeanyDocument *old_doc, struct GeanyDocument *new_doc,
 547                                          gint line);
 548 }
 549 NavQueueFuncs;
 550
 551
 552 struct GeanyEditor;
 553
 554 /* See editor.h */
 555 typedef struct EditorFuncs
 556 {
 557         const struct GeanyIndentPrefs* (*editor_get_indent_prefs)(struct GeanyEditor *editor);
 558         struct _ScintillaObject* (*editor_create_widget)(struct GeanyEditor *editor);
 559
 560         void    (*editor_indicator_set_on_range) (struct GeanyEditor *editor, gint indic, gint start, gint end);
 561         void    (*editor_indicator_set_on_line) (struct GeanyEditor *editor, gint indic, gint line);
 562         void    (*editor_indicator_clear) (struct GeanyEditor *editor, gint indic);
 563
 564         void    (*editor_set_indent_type)(struct GeanyEditor *editor, GeanyIndentType type);
 565         gchar*  (*editor_get_word_at_pos) (struct GeanyEditor *editor, gint pos, const gchar *wordchars);
 566
 567         const gchar*    (*editor_get_eol_char_name) (struct GeanyEditor *editor);
 568         gint                    (*editor_get_eol_char_len) (struct GeanyEditor *editor);
 569         const gchar*    (*editor_get_eol_char) (struct GeanyEditor *editor);
 570
 571         void    (*editor_insert_text_block) (struct GeanyEditor *editor, const gchar *text,
 572                          gint insert_pos, gint cursor_index, gint newline_indent_size,
 573                          gboolean replace_newlines);
 574 }
 575 EditorFuncs;
 576
 577
 578 /* avoid including keybindings.h */
 579 typedef gboolean (*_GeanyKeyGroupCallback) (guint key_id);
 580
 581 /* See pluginutils.c */
 582 typedef struct PluginFuncs
 583 {
 584         void    (*plugin_add_toolbar_item)(GeanyPlugin *plugin, GtkToolItem *item);
 585         void    (*plugin_module_make_resident) (GeanyPlugin *plugin);
 586         void    (*plugin_signal_connect) (GeanyPlugin *plugin,
 587                 GObject *object, gchar *signal_name, gboolean after,
 588                 GCallback callback, gpointer user_data);
 589         struct GeanyKeyGroup* (*plugin_set_key_group)(GeanyPlugin *plugin,
 590                 const gchar *section_name, gsize count, _GeanyKeyGroupCallback callback);
 591         void    (*plugin_show_configure)(GeanyPlugin *plugin);
 592 }
 593 PluginFuncs;
 594
 595
 596 struct StashGroup;
 597
 598 /* See stash.h */
 599 typedef struct StashFuncs
 600 {
 601         struct StashGroup *(*stash_group_new)(const gchar *name);
 602         void (*stash_group_add_boolean)(struct StashGroup *group, gboolean *setting,
 603                         const gchar *key_name, gboolean default_value);
 604         void (*stash_group_add_integer)(struct StashGroup *group, gint *setting,
 605                         const gchar *key_name, gint default_value);
 606         void (*stash_group_add_string)(struct StashGroup *group, gchar **setting,
 607                         const gchar *key_name, const gchar *default_value);
 608         void (*stash_group_add_string_vector)(struct StashGroup *group, gchar ***setting,
 609                         const gchar *key_name, const gchar **default_value);
 610         void (*stash_group_load_from_key_file)(struct StashGroup *group, GKeyFile *keyfile);
 611         void (*stash_group_save_to_key_file)(struct StashGroup *group, GKeyFile *keyfile);
 612         void (*stash_group_free)(struct StashGroup *group);
 613         gboolean (*stash_group_load_from_file)(struct StashGroup *group, const gchar *filename);
 614         gint (*stash_group_save_to_file)(struct StashGroup *group, const gchar *filename,
 615                         GKeyFileFlags flags);
 616         void (*stash_group_add_toggle_button)(struct StashGroup *group, gboolean *setting,
 617                         const gchar *key_name, gboolean default_value, gpointer widget_id);
 618         void (*stash_group_add_radio_buttons)(struct StashGroup *group, gint *setting,
 619                         const gchar *key_name, gint default_value,
 620                         gpointer widget_id, gint enum_id, ...) G_GNUC_NULL_TERMINATED;
 621         void (*stash_group_add_spin_button_integer)(struct StashGroup *group, gint *setting,
 622                         const gchar *key_name, gint default_value, gpointer widget_id);
 623         void (*stash_group_add_combo_box)(struct StashGroup *group, gint *setting,
 624                         const gchar *key_name, gint default_value, gpointer widget_id);
 625         void (*stash_group_add_combo_box_entry)(struct StashGroup *group, gchar **setting,
 626                         const gchar *key_name, const gchar *default_value, gpointer widget_id);
 627         void (*stash_group_add_entry)(struct StashGroup *group, gchar **setting,
 628                         const gchar *key_name, const gchar *default_value, gpointer widget_id);
 629         void (*stash_group_add_widget_property)(struct StashGroup *group, gpointer setting,
 630                         const gchar *key_name, gpointer default_value, gpointer widget_id,
 631                         const gchar *property_name, GType type);
 632         void (*stash_group_display)(struct StashGroup *group, GtkWidget *owner);
 633         void (*stash_group_update)(struct StashGroup *group, GtkWidget *owner);
 634 }
 635 StashFuncs;
 636
 637
 638 /* Deprecated aliases */
 639 #ifndef GEANY_DISABLE_DEPRECATED
 640
 641 /** @deprecated - copy into your plugin code if needed.
 642  * @c NULL-safe way to get the index of @a doc_ptr in the documents array. */
 643 #define DOC_IDX(doc_ptr) \
 644         (doc_ptr ? doc_ptr->index : -1)
 645 #define DOC_IDX_VALID(doc_idx) \
 646         ((doc_idx) >= 0 && (guint)(doc_idx) < documents_array->len && documents[doc_idx]->is_valid)
 647
 648 #define GEANY_WINDOW_MINIMAL_WIDTH              550
 649 #define GEANY_WINDOW_MINIMAL_HEIGHT             GEANY_DEFAULT_DIALOG_HEIGHT
 650
 651 #endif  /* GEANY_DISABLE_DEPRECATED */
 652
 653 #endif