libanjuta/anjuta-plugin.h

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * Anjuta
   4  * Copyright (C) 2000 Dave Camp, Naba Kumar  <naba@gnome.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #ifndef ANJUTA_PLUGIN_H
  23 #define ANJUTA_PLUGIN_H
  24
  25 #include <glib.h>
  26 #include <glib-object.h>
  27
  28 #include <string.h>
  29 #include <libanjuta/anjuta-shell.h>
  30 #include <libanjuta/anjuta-ui.h>
  31 #include <libanjuta/anjuta-preferences.h>
  32 #include <libanjuta/anjuta-utils.h>
  33 #include <libanjuta/glue-plugin.h>
  34
  35 G_BEGIN_DECLS
  36
  37 typedef struct _AnjutaPlugin        AnjutaPlugin;
  38 typedef struct _AnjutaPluginClass   AnjutaPluginClass;
  39 typedef struct _AnjutaPluginPrivate AnjutaPluginPrivate;
  40
  41 /**
  42  * AnjutaPluginValueAdded:
  43  * @plugin: The #AnjutaPlugin based plugin
  44  * @name: name of value being added.
  45  * @value: value of value being added.
  46  * @user_data: User data set during anjuta_plugin_add_watch()
  47  *
  48  * The callback to pass to anjuta_plugin_add_watch(). When a @name value
  49  * is added to shell by another plugin, this callback will be called.
  50  */
  51 typedef void (*AnjutaPluginValueAdded) (AnjutaPlugin *plugin,
  52                                                                                 const char *name,
  53                                                                                 const GValue *value,
  54                                                                                 gpointer user_data);
  55
  56 /**
  57  * AnjutaPluginValueRemoved:
  58  * @plugin: The #AnjutaPlugin based plugin
  59  * @name: name of value being added.
  60  * @user_data: User data set during anjuta_plugin_add_watch()
  61  *
  62  * The callback to pass to anjuta_plugin_add_watch(). When the @name value
  63  * is removed from the shell (by the plugin exporting this value), this
  64  * callback will be called.
  65  */
  66 typedef void (*AnjutaPluginValueRemoved) (AnjutaPlugin *plugin,
  67                                                                                   const char *name,
  68                                                                                   gpointer user_data);
  69
  70
  71 #define ANJUTA_TYPE_PLUGIN         (anjuta_plugin_get_type ())
  72 #define ANJUTA_PLUGIN(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), ANJUTA_TYPE_PLUGIN, AnjutaPlugin))
  73 #define ANJUTA_PLUGIN_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), ANJUTA_TYPE_PLUGIN, AnjutaPluginClass))
  74 #define ANJUTA_IS_PLUGIN(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), ANJUTA_TYPE_PLUGIN))
  75 #define ANJUTA_IS_PLUGIN_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), ANJUTA_TYPE_PLUGIN))
  76 #define ANJUTA_PLUGIN_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), ANJUTA_TYPE_PLUGIN, AnjutaPluginClass))
  77
  78 struct _AnjutaPlugin {
  79         GObject parent;
  80
  81         /* The shell in which the plugin has been added */
  82         AnjutaShell *shell;
  83
  84         /*< private >*/
  85         AnjutaPluginPrivate *priv;
  86 };
  87
  88 struct _AnjutaPluginClass {
  89         GObjectClass parent_class;
  90
  91         /* Signals  */
  92         void (*activated) (AnjutaPlugin *plugin);
  93         void (*deactivated) (AnjutaPlugin *plugin);
  94
  95         /* Virtual functions */
  96         gboolean (*activate) (AnjutaPlugin *plugin);
  97         gboolean (*deactivate) (AnjutaPlugin *plugin);
  98 };
  99
 100 GType anjuta_plugin_get_type   (void);
 101
 102 gboolean anjuta_plugin_activate (AnjutaPlugin *plugin);
 103
 104 gboolean anjuta_plugin_deactivate (AnjutaPlugin *plugin);
 105
 106 gboolean anjuta_plugin_is_active (AnjutaPlugin *plugin);
 107
 108 guint anjuta_plugin_add_watch (AnjutaPlugin *plugin,
 109                                                            const gchar *name,
 110                                                            AnjutaPluginValueAdded added,
 111                                                            AnjutaPluginValueRemoved removed,
 112                                                            gpointer user_data);
 113
 114 void anjuta_plugin_remove_watch (AnjutaPlugin *plugin, guint id,
 115                                                                  gboolean send_remove);
 116
 117 /**
 118  * ANJUTA_PLUGIN_BEGIN:
 119  * @class_name: Name of the class. e.g. EditorPlugin
 120  * @prefix: prefix of member function names. e.g. editor_plugin
 121  *
 122  * This is a convienient macro defined to make it easy to write plugin
 123  * classes . This macro begins the class type definition. member function
 124  * @prefix _class_init and @prefix _instance_init should be statically defined
 125  * before using this macro.
 126  *
 127  * The class type definition is finished with ANJUTA_PLUGIN_END() macro. In
 128  * between which any number of interface definitions could be added with
 129  * ANJUTA_PLUGIN_ADD_INTERFACE() macro.
 130  */
 131 #define ANJUTA_PLUGIN_BEGIN(class_name, prefix)                          \
 132 extern GType                                                             \
 133 prefix##_get_type (GluePlugin *plugin)                                   \
 134 {                                                                        \
 135         static GType type = 0;                                               \
 136         if (G_UNLIKELY (!type)) {                                            \
 137                 static const GTypeInfo type_info = {                             \
 138                         sizeof (class_name##Class),                                  \
 139                         NULL,                                                        \
 140                         NULL,                                                        \
 141                         (GClassInitFunc)prefix##_class_init,                         \
 142                         NULL,                                                        \
 143                         NULL,                                                        \
 144                         sizeof (class_name),                                         \
 145                         0,                                                           \
 146                         (GInstanceInitFunc)prefix##_instance_init                    \
 147                 };                                                               \
 148                 g_return_val_if_fail (plugin != NULL, 0);                        \
 149                 type = g_type_module_register_type (G_TYPE_MODULE (plugin),      \
 150                                                     ANJUTA_TYPE_PLUGIN,                          \
 151                                                     #class_name,                                 \
 152                                                     &type_info, 0);
 153 /**
 154  * ANJUTA_PLUGIN_END:
 155  *
 156  * Ends the plugin class type definition started with ANJUTA_PLUGIN_BEGIN()
 157  */
 158 #define ANJUTA_PLUGIN_END                                               \
 159         }                                                                   \
 160         return type;                                                        \
 161 }
 162
 163 /**
 164  * ANJUTA_PLUGIN_ADD_INTERFACE:
 165  * @interface_type: Interface type. e.g. IANJUTA_TYPE_EDITOR
 166  * @prefix: prefix of member function names.
 167  *
 168  * This is a convienient macro defined to make it easy to add interfaces
 169  * to a plugin type. @prefix _iface_init should be statically defined
 170  * before using this macro. This macro should be called between
 171  * ANJUTA_PLUGIN_BEGIN() and ANJUTA_PLUGIN_END() macros.
 172  */
 173 #define ANJUTA_PLUGIN_ADD_INTERFACE(prefix,interface_type)             \
 174     {                                                                  \
 175         GInterfaceInfo iface_info = {                                  \
 176             (GInterfaceInitFunc)prefix##_iface_init,                   \
 177             NULL,                                                      \
 178             NULL                                                       \
 179         };                                                             \
 180         g_type_module_add_interface (G_TYPE_MODULE (plugin),           \
 181                                      type, interface_type,             \
 182                                      &iface_info);                     \
 183     }
 184
 185 /**
 186  * ANJUTA_PLUGIN_BOILERPLATE:
 187  * @class_name: Name of the class. e.g EditorPlugin
 188  * @prefix: prefix of member function names. e.g. editor_plugin
 189  *
 190  * This macro is similar to using ANJUTA_PLUGIN_BEGIN() and then immediately
 191  * using ANJUTA_PLUGIN_END(). It is basically a plugin type definition macro
 192  * that does not have any interface implementation.
 193  */
 194 #define ANJUTA_PLUGIN_BOILERPLATE(class_name, prefix)                   \
 195 ANJUTA_PLUGIN_BEGIN(class_name, prefix);                                \
 196 ANJUTA_PLUGIN_END
 197
 198 /**
 199  * ANJUTA_SIMPLE_PLUGIN:
 200  * @class_name: Name of the class. e.g. EditorPlugin
 201  * @prefix: prefix of member function names. e.g. editor_plugin
 202  *
 203  * Sets up necessary codes for the plugin factory to know the class type of
 204  * of the plugin. This macro is generally used at the end of plugin class
 205  * and member functions definitions.
 206  */
 207 #define ANJUTA_SIMPLE_PLUGIN(class_name, prefix)                      \
 208 G_MODULE_EXPORT void glue_register_components (GluePlugin *plugin);   \
 209 G_MODULE_EXPORT GType glue_get_component_type (GluePlugin *plugin, const char *name); \
 210 G_MODULE_EXPORT void                                                  \
 211 glue_register_components (GluePlugin *plugin)                         \
 212 {                                                                     \
 213         prefix##_get_type (plugin);                                       \
 214 }                                                                     \
 215 G_MODULE_EXPORT GType                                                 \
 216 glue_get_component_type (GluePlugin *plugin, const char *name)        \
 217 {                                                                     \
 218         if (!strcmp (name, #class_name)) {                                \
 219                 return prefix##_get_type (plugin);                            \
 220         } else {                                                          \
 221                 return G_TYPE_INVALID;                                        \
 222         }                                                                 \
 223 }
 224
 225 G_END_DECLS
 226
 227 #endif