src/test/test-module-plugin.c

   1 /*
   2  * Nautilus-Actions
   3  * A Nautilus extension which offers configurable context menu actions.
   4  *
   5  * Copyright (C) 2005 The GNOME Foundation
   6  * Copyright (C) 2006, 2007, 2008 Frederic Ruaudel and others (see AUTHORS)
   7  * Copyright (C) 2009, 2010, 2011 Pierre Wieser and others (see AUTHORS)
   8  *
   9  * This Program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This Program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public
  20  * License along with this Library; see the file COPYING.  If not,
  21  * write to the Free Software Foundation, Inc., 59 Temple Place,
  22  * Suite 330, Boston, MA 02111-1307, USA.
  23  *
  24  * Authors:
  25  *   Frederic Ruaudel <grumz@grumz.net>
  26  *   Rodrigo Moya <rodrigo@gnome-db.org>
  27  *   Pierre Wieser <pwieser@trychlos.org>
  28  *   ... and many others (see AUTHORS)
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34
  35 #include <glib-object.h>
  36 #include <gmodule.h>
  37
  38 /* this is a plugin, i.e. a dynamically loaded resource
  39  */
  40
  41 G_MODULE_EXPORT const gchar *g_module_check_init( GModule *module );
  42 G_MODULE_EXPORT void         g_module_unload( GModule *module );
  43
  44 #if 0
  45 /* this is first version
  46  * the module is loaded, the function called, and then the module is unloaded
  47  * note that we do not define any GType here, so do not provide any sort of
  48  * GInterface implementation
  49  *
  50         (process:23911): NA-test-DEBUG: in g_module_check_init: module=0xf97f20
  51         (process:23911): NA-test-DEBUG: say_hello: module=0xf97f20
  52         (process:23911): NA-test-DEBUG: in g_module_unload: module=0xf97f20
  53  *
  54  */
  55
  56 G_MODULE_EXPORT void         say_hello( GModule *module );
  57
  58 /* automatically called when the module is loaded
  59  */
  60 G_MODULE_EXPORT const gchar *
  61 g_module_check_init( GModule *module )
  62 {
  63         const gchar *error;
  64
  65         error = NULL;
  66         g_debug( "in g_module_check_init: module=%p", ( void * ) module );
  67
  68         return( error );
  69 }
  70
  71 /* automatically called when the module is unloaded
  72  */
  73 G_MODULE_EXPORT void
  74 g_module_unload( GModule *module )
  75 {
  76         g_debug( "in g_module_unload: module=%p", ( void * ) module );
  77 }
  78
  79 /* a function dynamically called from the program
  80  */
  81 G_MODULE_EXPORT void
  82 say_hello( GModule *module )
  83 {
  84         g_debug( "say_hello: module=%p", ( void * ) module );
  85 }
  86 #endif
  87
  88 /* version 2
  89  * define the module as a GTypeModule-derived one
  90  */
  91 #define TEST_MODULE_PLUGIN_TYPE                 ( na_module_plugin_get_type())
  92 #define TEST_MODULE_PLUGIN( object )            ( G_TYPE_CHECK_INSTANCE_CAST( object, TEST_MODULE_PLUGIN_TYPE, NAModulePlugin ))
  93 #define TEST_MODULE_PLUGIN_CLASS( klass )       ( G_TYPE_CHECK_CLASS_CAST( klass, TEST_MODULE_PLUGIN_TYPE, NAModulePluginClass ))
  94 #define TEST_IS_MODULE_PLUGIN( object )         ( G_TYPE_CHECK_INSTANCE_TYPE( object, TEST_MODULE_PLUGIN_TYPE ))
  95 #define TEST_IS_MODULE_PLUGIN_CLASS( klass )    ( G_TYPE_CHECK_CLASS_TYPE(( klass ), TEST_MODULE_PLUGIN_TYPE ))
  96 #define TEST_MODULE_PLUGIN_GET_CLASS( object )  ( G_TYPE_INSTANCE_GET_CLASS(( object ), TEST_MODULE_PLUGIN_TYPE, NAModulePluginClass ))
  97
  98 typedef struct _NAModulePluginPrivate           NAModulePluginPrivate;
  99 typedef struct _NAModulePluginClassPrivate      NAModulePluginClassPrivate;
 100
 101 typedef struct {
 102         GObject                parent;
 103         NAModulePluginPrivate *private;
 104 }
 105         NAModulePlugin;
 106
 107 typedef struct {
 108         GObjectClass                parent;
 109         NAModulePluginClassPrivate *private;
 110 }
 111         NAModulePluginClass;
 112
 113 GType na_module_plugin_get_type( void );
 114
 115 /* private instance data
 116  */
 117 struct _NAModulePluginPrivate {
 118         gboolean dispose_has_run;
 119 };
 120
 121 /* private class data
 122  */
 123 struct _NAModulePluginClassPrivate {
 124         void *empty;                                            /* so that gcc -pedantic is happy */
 125 };
 126
 127 static GType             st_module_type = 0;
 128 static GTypeModuleClass *st_parent_class = NULL;
 129
 130 static void           na_module_plugin_register_type( GTypeModule *module );
 131 static void class_init( NAModulePluginClass *klass );
 132 static void instance_init( GTypeInstance *instance, gpointer klass );
 133 static void instance_dispose( GObject *object );
 134 static void instance_finalize( GObject *object );
 135
 136 G_MODULE_EXPORT void plugin_init( GTypeModule *module );
 137
 138 GType
 139 na_module_plugin_get_type( void )
 140 {
 141         return( st_module_type );
 142 }
 143
 144 static void
 145 na_module_plugin_register_type( GTypeModule *module )
 146 {
 147         static const gchar *thisfn = "na_module_plugin_register_type";
 148
 149         static GTypeInfo info = {
 150                 sizeof( NAModulePluginClass ),
 151                 NULL,
 152                 NULL,
 153                 ( GClassInitFunc ) class_init,
 154                 NULL,
 155                 NULL,
 156                 sizeof( NAModulePlugin ),
 157                 0,
 158                 ( GInstanceInitFunc ) instance_init
 159         };
 160
 161         /*static const GInterfaceInfo iio_provider_iface_info = {
 162                 ( GInterfaceInitFunc ) iio_provider_iface_init,
 163                 NULL,
 164                 NULL
 165         };*/
 166
 167         g_debug( "%s", thisfn );
 168
 169         st_module_type = g_type_module_register_type( module, G_TYPE_OBJECT, "NAModulePlugin", &info, 0 );
 170
 171         /*g_type_module_add_interface( module, st_module_type, NA_IIO_PROVIDER_TYPE, &iio_provider_iface_info );*/
 172 }
 173
 174 static void
 175 class_init( NAModulePluginClass *klass )
 176 {
 177         static const gchar *thisfn = "na_module_plugin_class_init";
 178         GObjectClass *object_class;
 179
 180         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 181
 182         st_parent_class = g_type_class_peek_parent( klass );
 183
 184         object_class = G_OBJECT_CLASS( klass );
 185         object_class->dispose = instance_dispose;
 186         object_class->finalize = instance_finalize;
 187
 188         klass->private = g_new0( NAModulePluginClassPrivate, 1 );
 189 }
 190
 191 static void
 192 instance_init( GTypeInstance *instance, gpointer klass )
 193 {
 194         static const gchar *thisfn = "na_module_plugin_instance_init";
 195         NAModulePlugin *self;
 196
 197         g_return_if_fail( TEST_IS_MODULE_PLUGIN( instance ));
 198
 199         g_debug( "%s: instance=%p (%s), klass=%p",
 200                         thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );
 201
 202         self = TEST_MODULE_PLUGIN( instance );
 203
 204         self->private = g_new0( NAModulePluginPrivate, 1 );
 205
 206         self->private->dispose_has_run = FALSE;
 207 }
 208
 209 static void
 210 instance_dispose( GObject *object )
 211 {
 212         static const gchar *thisfn = "na_module_plugin_instance_dispose";
 213         NAModulePlugin *self;
 214
 215         g_return_if_fail( TEST_IS_MODULE_PLUGIN( object ));
 216
 217         self = TEST_MODULE_PLUGIN( object );
 218
 219         if( !self->private->dispose_has_run ){
 220
 221                 g_debug( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 222
 223                 self->private->dispose_has_run = TRUE;
 224
 225                 /* chain up to the parent class */
 226                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 227                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 228                 }
 229         }
 230 }
 231
 232 static void
 233 instance_finalize( GObject *object )
 234 {
 235         static const gchar *thisfn = "na_test_module_plugin_instance_finalize";
 236         NAModulePlugin *self;
 237
 238         g_return_if_fail( TEST_IS_MODULE_PLUGIN( object ));
 239
 240         g_debug( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 241
 242         self = TEST_MODULE_PLUGIN( object );
 243
 244         g_free( self->private );
 245
 246         /* chain call to parent class */
 247         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 248                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 249         }
 250 }
 251
 252 /* automatically called when the module is loaded
 253  * this is very less useful in this version as we need a GTypeModule to register
 254  * our dynamic types
 255  */
 256 G_MODULE_EXPORT const gchar *
 257 g_module_check_init( GModule *module )
 258 {
 259         g_debug( "in g_module_check_init: module=%p", ( void * ) module );
 260         return( NULL );
 261 }
 262
 263 /* automatically called when the module is unloaded
 264  */
 265 G_MODULE_EXPORT void
 266 g_module_unload( GModule *module )
 267 {
 268         g_debug( "in g_module_unload: module=%p", ( void * ) module );
 269 }
 270
 271 /* module is actually a NAModule, but we do not care of that
 272  * registering the type - but do not yet allocate an object
 273  */
 274 G_MODULE_EXPORT void
 275 plugin_init( GTypeModule *module )
 276 {
 277         g_debug( "plugin_init: module=%p", ( void * ) module );
 278
 279         na_module_plugin_register_type( module );
 280 }