src/test/test-iface2.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-2008 Frederic Ruaudel and others (see AUTHORS)
   7  * Copyright (C) 2009-2015 Pierre Wieser and others (see AUTHORS)
   8  *
   9  * Nautilus-Actions 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  * Nautilus-Actions 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 GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with Nautilus-Actions; see the file COPYING. If not, see
  21  * <http://www.gnu.org/licenses/>.
  22  *
  23  * Authors:
  24  *   Frederic Ruaudel <grumz@grumz.net>
  25  *   Rodrigo Moya <rodrigo@gnome-db.org>
  26  *   Pierre Wieser <pwieser@trychlos.org>
  27  *   ... and many others (see AUTHORS)
  28  */
  29
  30 /* A class with implements an interface
  31  * This interface itself requiring the class...
  32  */
  33
  34 #include <glib.h>
  35 #include <glib-object.h>
  36
  37 /* ********************************************************************
  38  * Declaring the interface
  39  * ********************************************************************/
  40 #define TEST_IFACE_TYPE                                         ( test_iface_get_type())
  41 #define TEST_IFACE( object )                            ( G_TYPE_CHECK_INSTANCE_CAST( object, TEST_IFACE_TYPE, TestIFace ))
  42 #define TEST_IS_IFACE( object )                         ( G_TYPE_CHECK_INSTANCE_TYPE( object, TEST_IFACE_TYPE ))
  43 #define TEST_IFACE_GET_INTERFACE( instance )( G_TYPE_INSTANCE_GET_INTERFACE(( instance ), TEST_IFACE_TYPE, TestIFaceInterface ))
  44
  45 typedef struct TestIFace TestIFace;
  46
  47 typedef struct TestIFaceInterfacePrivate TestIFaceInterfacePrivate;
  48
  49 typedef struct {
  50         GTypeInterface             parent;
  51         TestIFaceInterfacePrivate *private;
  52 }
  53         TestIFaceInterface;
  54
  55 GType test_iface_get_type( void );
  56
  57 /* ********************************************************************
  58  * Declaring the class
  59  * ********************************************************************/
  60 #define TEST_BASE_TYPE                                  ( test_base_get_type())
  61 #define TEST_BASE( object )                             ( G_TYPE_CHECK_INSTANCE_CAST( object, TEST_BASE_TYPE, TestBase ))
  62 #define TEST_BASE_CLASS( klass )                ( G_TYPE_CHECK_CLASS_CAST( klass, TEST_BASE_TYPE, TestBaseClass ))
  63 #define TEST_IS_BASE( object )                  ( G_TYPE_CHECK_INSTANCE_TYPE( object, TEST_BASE_TYPE ))
  64 #define TEST_IS_BASE_CLASS( klass )             ( G_TYPE_CHECK_CLASS_TYPE(( klass ), TEST_BASE_TYPE ))
  65 #define TEST_BASE_GET_CLASS( object )   ( G_TYPE_INSTANCE_GET_CLASS(( object ), TEST_BASE_TYPE, TestBaseClass ))
  66
  67 typedef struct TestBasePrivate TestBasePrivate;
  68
  69 typedef struct {
  70         GObject          parent;
  71         TestBasePrivate *private;
  72 }
  73         TestBase;
  74
  75 typedef struct TestBaseClassPrivate TestBaseClassPrivate;
  76
  77 typedef struct {
  78         GObjectClass          parent;
  79         TestBaseClassPrivate *private;
  80 }
  81         TestBaseClass;
  82
  83 GType     test_base_get_type( void );
  84
  85 static TestBase *test_base_new( void );
  86
  87 /* ********************************************************************
  88  * Implementing the interface
  89  * ********************************************************************/
  90
  91 /* private interface data
  92  */
  93 struct TestIFaceInterfacePrivate {
  94         void *empty;                                            /* so that gcc -pedantic is happy */
  95 };
  96
  97 static guint st_initializations = 0;
  98
  99 static GType iface_register_type( void );
 100 static void  interface_base_init( TestIFaceInterface *klass );
 101 static void  interface_base_finalize( TestIFaceInterface *klass );
 102
 103 GType
 104 test_iface_get_type( void )
 105 {
 106         static GType iface_type = 0;
 107
 108         if( !iface_type ){
 109                 iface_type = iface_register_type();
 110         }
 111
 112         return( iface_type );
 113 }
 114
 115 static GType
 116 iface_register_type( void )
 117 {
 118         static const gchar *thisfn = "test_iface_iface_register_type";
 119         GType type;
 120
 121         static const GTypeInfo info = {
 122                 sizeof( TestIFaceInterface ),
 123                 ( GBaseInitFunc ) interface_base_init,
 124                 ( GBaseFinalizeFunc ) interface_base_finalize,
 125                 NULL,
 126                 NULL,
 127                 NULL,
 128                 0,
 129                 0,
 130                 NULL
 131         };
 132
 133         g_debug( "%s", thisfn );
 134
 135         type = g_type_register_static( G_TYPE_INTERFACE, "TestIFace", &info, 0 );
 136
 137         g_type_interface_add_prerequisite( type, TEST_BASE_TYPE );
 138
 139         return( type );
 140 }
 141
 142 static void
 143 interface_base_init( TestIFaceInterface *klass )
 144 {
 145         static const gchar *thisfn = "test_iface_iface_interface_base_init";
 146
 147         if( !st_initializations ){
 148
 149                 g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 150
 151                 klass->private = g_new0( TestIFaceInterfacePrivate, 1 );
 152         }
 153
 154         st_initializations += 1;
 155 }
 156
 157 static void
 158 interface_base_finalize( TestIFaceInterface *klass )
 159 {
 160         static const gchar *thisfn = "test_iface_iface_interface_base_finalize";
 161
 162         st_initializations -= 1;
 163
 164         if( !st_initializations ){
 165
 166                 g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 167
 168                 g_free( klass->private );
 169         }
 170 }
 171
 172 /* ********************************************************************
 173  * Implementing the class
 174  * ********************************************************************/
 175
 176 /* private class data
 177  */
 178 struct TestBaseClassPrivate {
 179         void *empty;                                            /* so that gcc -pedantic is happy */
 180 };
 181
 182 /* private instance data
 183  */
 184 struct TestBasePrivate {
 185         gboolean dispose_has_run;
 186 };
 187
 188 static GObjectClass *st_parent_class = NULL;
 189
 190 static GType base_register_type( void );
 191 static void  class_init( TestBaseClass *klass );
 192 static void  instance_init( GTypeInstance *instance, gpointer klass );
 193 static void  instance_dispose( GObject *object );
 194 static void  instance_finalize( GObject *object );
 195
 196 static void  iface_iface_init( TestIFaceInterface *iface, void *user_data );
 197
 198 GType
 199 test_base_get_type( void )
 200 {
 201         static GType object_type = 0;
 202
 203         static const GInterfaceInfo iface_iface_info = {
 204                 ( GInterfaceInitFunc ) iface_iface_init,
 205                 NULL,
 206                 NULL
 207         };
 208
 209         if( !object_type ){
 210                 object_type = base_register_type();
 211                 g_type_add_interface_static( object_type, TEST_IFACE_TYPE, &iface_iface_info );
 212         }
 213
 214         return( object_type );
 215 }
 216
 217 static GType
 218 base_register_type( void )
 219 {
 220         static const gchar *thisfn = "test_iface_base_register_type";
 221         GType type;
 222
 223         static GTypeInfo info = {
 224                 sizeof( TestBaseClass ),
 225                 ( GBaseInitFunc ) NULL,
 226                 ( GBaseFinalizeFunc ) NULL,
 227                 ( GClassInitFunc ) class_init,
 228                 NULL,
 229                 NULL,
 230                 sizeof( TestBase ),
 231                 0,
 232                 ( GInstanceInitFunc ) instance_init
 233         };
 234
 235         g_debug( "%s", thisfn );
 236
 237         type = g_type_register_static( G_TYPE_OBJECT, "TestBase", &info, 0 );
 238
 239         return( type );
 240 }
 241
 242 static void
 243 class_init( TestBaseClass *klass )
 244 {
 245         static const gchar *thisfn = "test_iface_base_class_init";
 246         GObjectClass *object_class;
 247
 248         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 249
 250         st_parent_class = g_type_class_peek_parent( klass );
 251
 252         object_class = G_OBJECT_CLASS( klass );
 253         object_class->dispose = instance_dispose;
 254         object_class->finalize = instance_finalize;
 255
 256         klass->private = g_new0( TestBaseClassPrivate, 1 );
 257 }
 258
 259 static void
 260 instance_init( GTypeInstance *instance, gpointer klass )
 261 {
 262         static const gchar *thisfn = "test_iface_base_instance_init";
 263         TestBase *self;
 264
 265         g_return_if_fail( TEST_IS_BASE( instance ));
 266
 267         self = TEST_BASE( instance );
 268
 269         g_debug( "%s: instance=%p, klass=%p", thisfn, ( void * ) instance, ( void * ) klass );
 270
 271         self->private = g_new0( TestBasePrivate, 1 );
 272
 273         self->private->dispose_has_run = FALSE;
 274 }
 275
 276 static void
 277 instance_dispose( GObject *object )
 278 {
 279         static const gchar *thisfn = "test_iface_base_instance_dispose";
 280         TestBase *self;
 281
 282         g_return_if_fail( TEST_IS_BASE( object ));
 283
 284         self = TEST_BASE( object );
 285
 286         if( !self->private->dispose_has_run ){
 287
 288                 g_debug( "%s: object=%p", thisfn, ( void * ) object );
 289
 290                 self->private->dispose_has_run = TRUE;
 291
 292                 /* chain up to the parent class */
 293                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 294                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 295                 }
 296         }
 297 }
 298
 299 static void
 300 instance_finalize( GObject *object )
 301 {
 302         static const gchar *thisfn = "test_iface_base_instance_finalize";
 303         TestBase *self;
 304
 305         g_return_if_fail( TEST_IS_BASE( object ));
 306
 307         self = ( TestBase * ) object;
 308
 309         g_debug( "%s: object=%p", thisfn, ( void * ) object );
 310
 311         g_free( self->private );
 312
 313         /* chain call to parent class */
 314         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 315                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 316         }
 317 }
 318
 319 static TestBase *
 320 test_base_new( void )
 321 {
 322         TestBase *object = g_object_new( TEST_BASE_TYPE, NULL );
 323
 324         return( object );
 325 }
 326
 327 static void
 328 iface_iface_init( TestIFaceInterface *iface, void *user_data )
 329 {
 330         static const gchar *thisfn = "test_iface_base_iface_iface_init";
 331
 332         g_debug( "%s: iface=%p, user_data=%p", thisfn, ( void * ) iface, ( void * ) user_data );
 333 }
 334
 335 /* ********************************************************************
 336  * main
 337  * ********************************************************************/
 338
 339 int
 340 main( int argc, char **argv )
 341 {
 342         TestBase *base;
 343
 344 #if !GLIB_CHECK_VERSION( 2,36, 0 )
 345         g_type_init();
 346 #endif
 347
 348         g_debug( "allocating TestBase -------------------------------------" );
 349         base = test_base_new();
 350
 351         g_debug( "unreffing TestBase ------------------------------------" );
 352         g_object_unref( base );
 353
 354         g_debug( "end -----------------------------------------------------" );
 355
 356         return( 0 );
 357 }