1 /* GObject - GLib Type, Object, Parameter and Signal Library 2 * Copyright (C) 2000 Red Hat, Inc. 3 * 4 * This library is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU Lesser General Public 6 * License as published by the Free Software Foundation; either 7 * version 2.1 of the License, or (at your option) any later version. 8 * 9 * This library is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * Lesser General Public License for more details. 13 * 14 * You should have received a copy of the GNU Lesser General Public 15 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 16 */ 17 #ifndef __G_TYPE_MODULE_H__ 18 #define __G_TYPE_MODULE_H__ 19 20 #if !defined (__GLIB_GOBJECT_H_INSIDE__) && !defined (GOBJECT_COMPILATION) 21 #error "Only <glib-object.h> can be included directly." 22 #endif 23 24 #include <gobject/gobject.h> 25 #include <gobject/genums.h> 26 27 G_BEGIN_DECLS 28 29 typedef struct _GTypeModule GTypeModule; 30 typedef struct _GTypeModuleClass GTypeModuleClass; 31 32 #define G_TYPE_TYPE_MODULE (g_type_module_get_type ()) 33 #define G_TYPE_MODULE(module) (G_TYPE_CHECK_INSTANCE_CAST ((module), G_TYPE_TYPE_MODULE, GTypeModule)) 34 #define G_TYPE_MODULE_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_TYPE_MODULE, GTypeModuleClass)) 35 #define G_IS_TYPE_MODULE(module) (G_TYPE_CHECK_INSTANCE_TYPE ((module), G_TYPE_TYPE_MODULE)) 36 #define G_IS_TYPE_MODULE_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_TYPE_MODULE)) 37 #define G_TYPE_MODULE_GET_CLASS(module) (G_TYPE_INSTANCE_GET_CLASS ((module), G_TYPE_TYPE_MODULE, GTypeModuleClass)) 38 39 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GTypeModule, g_object_unref) 40 41 /** 42 * GTypeModule: 43 * @name: the name of the module 44 * 45 * The members of the GTypeModule structure should not 46 * be accessed directly, except for the @name field. 47 */ 48 struct _GTypeModule 49 { 50 GObject parent_instance; 51 52 guint use_count; 53 GSList *type_infos; 54 GSList *interface_infos; 55 56 /*< public >*/ 57 gchar *name; 58 }; 59 60 /** 61 * GTypeModuleClass: 62 * @parent_class: the parent class 63 * @load: loads the module and registers one or more types using 64 * g_type_module_register_type(). 65 * @unload: unloads the module 66 * 67 * In order to implement dynamic loading of types based on #GTypeModule, 68 * the @load and @unload functions in #GTypeModuleClass must be implemented. 69 */ 70 struct _GTypeModuleClass 71 { 72 GObjectClass parent_class; 73 74 /*< public >*/ 75 gboolean (* load) (GTypeModule *module); 76 void (* unload) (GTypeModule *module); 77 78 /*< private >*/ 79 /* Padding for future expansion */ 80 void (*reserved1) (void); 81 void (*reserved2) (void); 82 void (*reserved3) (void); 83 void (*reserved4) (void); 84 }; 85 86 /** 87 * G_DEFINE_DYNAMIC_TYPE: 88 * @TN: The name of the new type, in Camel case. 89 * @t_n: The name of the new type, in lowercase, with words 90 * separated by '_'. 91 * @T_P: The #GType of the parent type. 92 * 93 * A convenience macro for dynamic type implementations, which declares a 94 * class initialization function, an instance initialization function (see 95 * #GTypeInfo for information about these) and a static variable named 96 * `t_n`_parent_class pointing to the parent class. Furthermore, 97 * it defines a `*_get_type()` and a static `*_register_type()` functions 98 * for use in your `module_init()`. 99 * 100 * See G_DEFINE_DYNAMIC_TYPE_EXTENDED() for an example. 101 * 102 * Since: 2.14 103 */ 104 #define G_DEFINE_DYNAMIC_TYPE(TN, t_n, T_P) G_DEFINE_DYNAMIC_TYPE_EXTENDED (TN, t_n, T_P, 0, {}) 105 /** 106 * G_DEFINE_DYNAMIC_TYPE_EXTENDED: 107 * @TypeName: The name of the new type, in Camel case. 108 * @type_name: The name of the new type, in lowercase, with words 109 * separated by '_'. 110 * @TYPE_PARENT: The #GType of the parent type. 111 * @flags: #GTypeFlags to pass to g_type_module_register_type() 112 * @CODE: Custom code that gets inserted in the *_get_type() function. 113 * 114 * A more general version of G_DEFINE_DYNAMIC_TYPE() which 115 * allows to specify #GTypeFlags and custom code. 116 * 117 * |[ 118 * G_DEFINE_DYNAMIC_TYPE_EXTENDED (GtkGadget, 119 * gtk_gadget, 120 * GTK_TYPE_THING, 121 * 0, 122 * G_IMPLEMENT_INTERFACE_DYNAMIC (TYPE_GIZMO, 123 * gtk_gadget_gizmo_init)); 124 * ]| 125 * expands to 126 * |[ 127 * static void gtk_gadget_init (GtkGadget *self); 128 * static void gtk_gadget_class_init (GtkGadgetClass *klass); 129 * static void gtk_gadget_class_finalize (GtkGadgetClass *klass); 130 * 131 * static gpointer gtk_gadget_parent_class = NULL; 132 * static GType gtk_gadget_type_id = 0; 133 * 134 * static void gtk_gadget_class_intern_init (gpointer klass) 135 * { 136 * gtk_gadget_parent_class = g_type_class_peek_parent (klass); 137 * gtk_gadget_class_init ((GtkGadgetClass*) klass); 138 * } 139 * 140 * GType 141 * gtk_gadget_get_type (void) 142 * { 143 * return gtk_gadget_type_id; 144 * } 145 * 146 * static void 147 * gtk_gadget_register_type (GTypeModule *type_module) 148 * { 149 * const GTypeInfo g_define_type_info = { 150 * sizeof (GtkGadgetClass), 151 * (GBaseInitFunc) NULL, 152 * (GBaseFinalizeFunc) NULL, 153 * (GClassInitFunc) gtk_gadget_class_intern_init, 154 * (GClassFinalizeFunc) gtk_gadget_class_finalize, 155 * NULL, // class_data 156 * sizeof (GtkGadget), 157 * 0, // n_preallocs 158 * (GInstanceInitFunc) gtk_gadget_init, 159 * NULL // value_table 160 * }; 161 * gtk_gadget_type_id = g_type_module_register_type (type_module, 162 * GTK_TYPE_THING, 163 * "GtkGadget", 164 * &g_define_type_info, 165 * (GTypeFlags) flags); 166 * { 167 * const GInterfaceInfo g_implement_interface_info = { 168 * (GInterfaceInitFunc) gtk_gadget_gizmo_init 169 * }; 170 * g_type_module_add_interface (type_module, g_define_type_id, TYPE_GIZMO, &g_implement_interface_info); 171 * } 172 * } 173 * ]| 174 * 175 * Since: 2.14 176 */ 177 #define G_DEFINE_DYNAMIC_TYPE_EXTENDED(TypeName, type_name, TYPE_PARENT, flags, CODE) \ 178 static void type_name##_init (TypeName *self); \ 179 static void type_name##_class_init (TypeName##Class *klass); \ 180 static void type_name##_class_finalize (TypeName##Class *klass); \ 181 static gpointer type_name##_parent_class = NULL; \ 182 static GType type_name##_type_id = 0; \ 183 static gint TypeName##_private_offset; \ 184 \ 185 _G_DEFINE_TYPE_EXTENDED_CLASS_INIT(TypeName, type_name) \ 186 \ 187 G_GNUC_UNUSED \ 188 static inline gpointer \ 189 type_name##_get_instance_private (TypeName *self) \ 190 { \ 191 return (G_STRUCT_MEMBER_P (self, TypeName##_private_offset)); \ 192 } \ 193 \ 194 GType \ 195 type_name##_get_type (void) \ 196 { \ 197 return type_name##_type_id; \ 198 } \ 199 static void \ 200 type_name##_register_type (GTypeModule *type_module) \ 201 { \ 202 GType g_define_type_id G_GNUC_UNUSED; \ 203 const GTypeInfo g_define_type_info = { \ 204 sizeof (TypeName##Class), \ 205 (GBaseInitFunc) NULL, \ 206 (GBaseFinalizeFunc) NULL, \ 207 (GClassInitFunc)(void (*)(void)) type_name##_class_intern_init, \ 208 (GClassFinalizeFunc)(void (*)(void)) type_name##_class_finalize, \ 209 NULL, /* class_data */ \ 210 sizeof (TypeName), \ 211 0, /* n_preallocs */ \ 212 (GInstanceInitFunc)(void (*)(void)) type_name##_init, \ 213 NULL /* value_table */ \ 214 }; \ 215 type_name##_type_id = g_type_module_register_type (type_module, \ 216 TYPE_PARENT, \ 217 #TypeName, \ 218 &g_define_type_info, \ 219 (GTypeFlags) flags); \ 220 g_define_type_id = type_name##_type_id; \ 221 { CODE ; } \ 222 } 223 224 /** 225 * G_IMPLEMENT_INTERFACE_DYNAMIC: 226 * @TYPE_IFACE: The #GType of the interface to add 227 * @iface_init: The interface init function 228 * 229 * A convenience macro to ease interface addition in the @_C_ section 230 * of G_DEFINE_DYNAMIC_TYPE_EXTENDED(). See G_DEFINE_DYNAMIC_TYPE_EXTENDED() 231 * for an example. 232 * 233 * Note that this macro can only be used together with the 234 * G_DEFINE_DYNAMIC_TYPE_EXTENDED macros, since it depends on variable 235 * names from that macro. 236 * 237 * Since: 2.24 238 */ 239 #define G_IMPLEMENT_INTERFACE_DYNAMIC(TYPE_IFACE, iface_init) { \ 240 const GInterfaceInfo g_implement_interface_info = { \ 241 (GInterfaceInitFunc)(void (*)(void)) iface_init, NULL, NULL \ 242 }; \ 243 g_type_module_add_interface (type_module, g_define_type_id, TYPE_IFACE, &g_implement_interface_info); \ 244 } 245 246 /** 247 * G_ADD_PRIVATE_DYNAMIC: 248 * @TypeName: the name of the type in CamelCase 249 * 250 * A convenience macro to ease adding private data to instances of a new dynamic 251 * type in the @_C_ section of G_DEFINE_DYNAMIC_TYPE_EXTENDED(). See 252 * G_ADD_PRIVATE() for details, it is similar but for static types. 253 * 254 * Note that this macro can only be used together with the 255 * G_DEFINE_DYNAMIC_TYPE_EXTENDED macros, since it depends on variable 256 * names from that macro. 257 * 258 * Since: 2.38 259 */ 260 #define G_ADD_PRIVATE_DYNAMIC(TypeName) { \ 261 TypeName##_private_offset = sizeof (TypeName##Private); \ 262 } 263 264 GLIB_AVAILABLE_IN_ALL 265 GType g_type_module_get_type (void) G_GNUC_CONST; 266 GLIB_AVAILABLE_IN_ALL 267 gboolean g_type_module_use (GTypeModule *module); 268 GLIB_AVAILABLE_IN_ALL 269 void g_type_module_unuse (GTypeModule *module); 270 GLIB_AVAILABLE_IN_ALL 271 void g_type_module_set_name (GTypeModule *module, 272 const gchar *name); 273 GLIB_AVAILABLE_IN_ALL 274 GType g_type_module_register_type (GTypeModule *module, 275 GType parent_type, 276 const gchar *type_name, 277 const GTypeInfo *type_info, 278 GTypeFlags flags); 279 GLIB_AVAILABLE_IN_ALL 280 void g_type_module_add_interface (GTypeModule *module, 281 GType instance_type, 282 GType interface_type, 283 const GInterfaceInfo *interface_info); 284 GLIB_AVAILABLE_IN_ALL 285 GType g_type_module_register_enum (GTypeModule *module, 286 const gchar *name, 287 const GEnumValue *const_static_values); 288 GLIB_AVAILABLE_IN_ALL 289 GType g_type_module_register_flags (GTypeModule *module, 290 const gchar *name, 291 const GFlagsValue *const_static_values); 292 293 G_END_DECLS 294 295 #endif /* __G_TYPE_MODULE_H__ */ 296