USER_OBJECT_ R_internal_getGTypeHierarchy(GType type) { USER_OBJECT_ ans; int n = 0; GType orig = type; while(type != 0 && type != G_TYPE_INVALID) { type = g_type_parent(type); n++; } PROTECT(ans = NEW_CHARACTER(n)); n = 0; type = orig; while(type != G_TYPE_INVALID) { const char *val; val = g_type_name(type); SET_STRING_ELT(ans, n, COPY_TO_USER_STRING(val)); n++; type = g_type_parent(type); } UNPROTECT(1); return(ans); }
static GValueTransform transform_func_lookup (GType src_type, GType dest_type) { TransformEntry entry; entry.src_type = src_type; do { entry.dest_type = dest_type; do { TransformEntry *e; e = g_bsearch_array_lookup (transform_array, &transform_bconfig, &entry); if (e) { /* need to check that there hasn't been a change in value handling */ if (g_type_value_table_peek (entry.dest_type) == g_type_value_table_peek (dest_type) && g_type_value_table_peek (entry.src_type) == g_type_value_table_peek (src_type)) return e->func; } entry.dest_type = g_type_parent (entry.dest_type); } while (entry.dest_type); entry.src_type = g_type_parent (entry.src_type); } while (entry.src_type); return NULL; }
static gboolean __type_is_valid(GType type) { GType _type = type; if(!_type) return FALSE; if(type == MIDGARD_TYPE_DBOBJECT || type == MIDGARD_TYPE_OBJECT) return TRUE; /* check MIDGARD_TYPE_OBJECT */ if(g_type_parent(_type) != MIDGARD_TYPE_DBOBJECT) { /* if fails, try MIDGARD_TYPE_DBOBJECT */ if(g_type_parent(_type) == MIDGARD_TYPE_OBJECT || g_type_parent(_type) == MIDGARD_TYPE_VIEW) { return TRUE; } else { return FALSE; } } return TRUE; }
static void test_widget_type (gpointer data) { GType type = GPOINTER_TO_SIZE (data); if (!g_type_is_a (type, GTK_TYPE_WIDGET)) { GString* chain = g_string_new (g_type_name (type)); if (type != G_TYPE_OBJECT) { GType parent = g_type_parent (type); g_string_append_printf (chain, " is a %s", g_type_name (parent)); for (; g_type_name (parent) ; parent = g_type_parent (parent)) { g_print ("%d (%s)\n", parent, g_type_name (parent)); g_string_append_printf (chain, ", which is a %s", g_type_name (parent)); } g_print ("%d (%s)\n", parent, g_type_name (parent)); } g_warning ("The type %s doesn't derive from %s (%s)", g_type_name (type), g_type_name (GTK_TYPE_WIDGET), chain->str); g_string_free (chain, TRUE); } }
/* Find the type that implemented the GESExtractable interface */ static inline const gchar * _extractable_type_name (GType type) { while (1) { if (g_type_is_a (g_type_parent (type), GES_TYPE_EXTRACTABLE)) type = g_type_parent (type); else return g_type_name (type); } }
/** * atk_registry_get_factory_type: * @registry: an #AtkRegistry * @type: a #GType with which to look up the associated #AtkObjectFactory * subclass * * Provides a #GType indicating the #AtkObjectFactory subclass * associated with @type. * * Returns: a #GType associated with type @type **/ GType atk_registry_get_factory_type (AtkRegistry *registry, GType type) { GType factory_type; gpointer value; /* * look up factory type in first hash; * if there isn't an explicitly registered factory type, * try inheriting one... */ do { value = g_hash_table_lookup (registry->factory_type_registry, (gpointer) type); type = g_type_parent (type); if (type == G_TYPE_INVALID) { break; } } while (value == NULL); factory_type = (GType) value; return factory_type; }
void mcd_dbus_get_interfaces (TpSvcDBusProperties *self, const gchar *name, GValue *value) { McdInterfaceData *iface_data, *id; GPtrArray *a_ifaces; GType type; DEBUG ("called"); a_ifaces = g_ptr_array_new (); for (type = G_OBJECT_TYPE (self); type != 0; type = g_type_parent (type)) { iface_data = g_type_get_qdata (type, MCD_INTERFACES_QUARK); if (!iface_data) continue; for (id = iface_data; id->get_type; id++) { if (id->optional && !mcd_dbus_is_active_optional_interface (self, id->get_type ())) { DEBUG ("skipping inactive optional iface %s", id->interface); continue; } g_ptr_array_add (a_ifaces, g_strdup (id->interface)); } } g_ptr_array_add (a_ifaces, NULL); g_value_init (value, G_TYPE_STRV); g_value_take_boxed (value, g_ptr_array_free (a_ifaces, FALSE)); }
void gom_resource_build_save_cmd (GomResource *resource, GomAdapter *adapter) { GomCommandBuilder *builder; gboolean has_pkey, is_insert; GSList *types = NULL; GSList *iter; GType resource_type; GList *cmds = NULL; resource_type = G_TYPE_FROM_INSTANCE(resource); g_assert(g_type_is_a(resource_type, GOM_TYPE_RESOURCE)); builder = g_object_new(GOM_TYPE_COMMAND_BUILDER, "adapter", adapter, NULL); has_pkey = has_primary_key(resource); if (has_pkey) { /* Could be an insert for a non-automatic primary key, * or an update */ is_insert = !resource->priv->is_from_table; } else { is_insert = TRUE; } g_object_set_data (G_OBJECT (resource), "is-insert", GINT_TO_POINTER (is_insert)); do { types = g_slist_prepend(types, GINT_TO_POINTER(resource_type)); } while ((resource_type = g_type_parent(resource_type)) != GOM_TYPE_RESOURCE); for (iter = types; iter; iter = iter->next) { GomCommand *command; resource_type = GPOINTER_TO_INT(iter->data); g_object_set(builder, "resource-type", resource_type, NULL); if (is_insert) { command = gom_command_builder_build_insert(builder, resource); } else { command = gom_command_builder_build_update(builder, resource); } if (is_insert && gom_resource_has_dynamic_pkey(resource_type)) is_insert = FALSE; cmds = g_list_prepend (cmds, command); } cmds = g_list_reverse (cmds); g_object_set_data_full (G_OBJECT(resource), "save-commands", cmds, free_save_cmds); g_slist_free(types); g_object_unref (builder); }
static AtkObject * gtk_switch_get_accessible (GtkWidget *widget) { static gboolean first_time = TRUE; if (G_UNLIKELY (first_time)) { AtkObjectFactory *factory; AtkRegistry *registry; GType derived_type; GType derived_atk_type; /* Figure out whether accessibility is enabled by looking at the * type of the accessible object which would be created for the * parent type of GtkSwitch */ derived_type = g_type_parent (GTK_TYPE_SWITCH); registry = atk_get_default_registry (); factory = atk_registry_get_factory (registry, derived_type); derived_atk_type = atk_object_factory_get_accessible_type (factory); if (g_type_is_a (derived_atk_type, GTK_TYPE_ACCESSIBLE)) atk_registry_set_factory_type (registry, GTK_TYPE_SWITCH, gtk_switch_accessible_factory_get_type ()); first_time = FALSE; } return GTK_WIDGET_CLASS (gtk_switch_parent_class)->get_accessible (widget); }
static gboolean gtk_real_model_types_iter_parent (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *child) { GType type; GType parent; type = GPOINTER_TO_INT (child->user_data); parent = g_type_parent (type); if (parent == G_TYPE_INVALID) { if (type > G_TYPE_FUNDAMENTAL_MAX) g_warning ("no parent for %ld %s\n", (long int) type, g_type_name (type)); return FALSE; } else { iter->user_data = GINT_TO_POINTER (parent); return TRUE; } }
static gboolean unserialize (QCADDesignObject *obj, FILE *fp) { char *pszLine = NULL, *pszValue = NULL ; gboolean bStopReading = FALSE, bParentInit = FALSE ; if (!SkipPast (fp, '\0', "[TYPE:" QCAD_TYPE_STRING_RULER "]", NULL)) return FALSE ; while (TRUE) { if (NULL == (pszLine = ReadLine (fp, '\0', TRUE))) break ; if (!strcmp (pszLine, "[#TYPE:" QCAD_TYPE_STRING_RULER "]")) { g_free (pszLine) ; break ; } if (!bStopReading) { tokenize_line (pszLine, strlen (pszLine), &pszValue, '=') ; if (!strncmp (pszLine, "[TYPE:", 6)) { if (!(bParentInit = QCAD_DESIGN_OBJECT_CLASS (g_type_class_peek (g_type_parent (QCAD_TYPE_STRETCHY_OBJECT)))->unserialize (obj, fp))) bStopReading = TRUE ; } } g_free (pszLine) ; g_free (ReadLine (fp, '\0', FALSE)) ; } return bParentInit ; }
static void qcad_layer_instance_finalize (GObject *object) { GList *llItr = NULL, *llNext = NULL ; QCADLayer *layer = QCAD_LAYER (object) ; void (*parent_finalize) (GObject *object) ; /* DBG_OO (fprintf (stderr, "QCADLayer::instance_finalize:Layer %s:destroying lstObjs\n", layer->pszDescription)) ;*/ for (llItr = layer->lstObjs ; llItr != NULL ; ) { llNext = llItr->next ; if (NULL != llItr->data) { /* DBG_REFS (fprintf (stderr, "QCADLayer::instance_finalize:unref-ing object 0x%08X\n", (int)(llItr->data))) ;*/ g_object_unref (G_OBJECT (llItr->data)) ; } llItr = llNext ; } g_free (layer->pszDescription) ; g_list_free (layer->lstObjs) ; g_list_free (layer->lstSelObjs) ; /* DBG_OO (fprintf (stderr, "QCADLayer::instance_finalize: Calling parent\n")) ;*/ if (NULL != (parent_finalize = G_OBJECT_CLASS (g_type_class_peek (g_type_parent (QCAD_TYPE_LAYER)))->finalize)) (*parent_finalize) (object) ; }
/** * panel_a11y_query_accessible_parent_type * @type: widget type * @type_info: accessible object type info to complete * * Standard hack which figures out the #GType of the accessible * object for @type's parent type. Also, fills out the class_size * and instance_size of @type_info to match the size of the parent * type. * * Basically, this is the hack to use if you want to derive from * an accessible object implementation in gail. * * Returns: the #GType of @type's parent's accessible peer */ GType panel_a11y_query_accessible_parent_type (GType type, GTypeInfo *type_info) { AtkObjectFactory *factory; GType parent_type; GType accessible_parent_type; g_return_val_if_fail (G_TYPE_IS_OBJECT (type), G_TYPE_INVALID); parent_type = g_type_parent (type); factory = atk_registry_get_factory (atk_get_default_registry (), parent_type); accessible_parent_type = atk_object_factory_get_accessible_type (factory); if (type_info) { GTypeQuery query; g_type_query (accessible_parent_type, &query); type_info->class_size = query.class_size; type_info->instance_size = query.instance_size; } return atk_object_factory_get_accessible_type (factory); }
static void each_cinfo(gpointer instance, ClassInfoCallbackFunc func, gpointer user_data) { const GType gtype = G_TYPE_FROM_INSTANCE(instance); GType* interfaces; guint n_interfaces = 0; interfaces = g_type_interfaces(gtype, &n_interfaces); { guint i; for (i = 0; i < n_interfaces; i++) { const RGObjClassInfo *info; info = GTYPE2CINFO_NO_CREATE(interfaces[i]); if (info) func(instance, info, user_data); } } g_free(interfaces); { GType type; for (type = gtype; type != G_TYPE_INVALID; type = g_type_parent(type)) { const RGObjClassInfo *info; info = GTYPE2CINFO_NO_CREATE(type); if (info) func(instance, info, user_data); } } }
static void ada_class_record_init (GObjectClass* klass, gpointer class_data) { GType type = G_TYPE_FROM_CLASS (klass); GType parent = g_type_parent (type); GTypeQuery query; GTypeQuery parent_query; const AdaGObjectClass ada_klass = (AdaGObjectClass)class_data; g_type_query (type, &query); g_type_query (parent, &parent_query); /* Initialize the function pointers for the new signals to NULL */ memset ((char*)(klass) + parent_query.class_size, 0, query.class_size - parent_query.class_size); /* Set a pointer to the AdaGObjectClass, so that we can retrieve it * later from a type. */ SET_ADA_CLASS_FROM_C_CLASS(klass, ada_klass); if (ada_klass->class_init) { ada_klass->class_init (klass); } }
static AtkObject * mate_druid_get_accessible (GtkWidget *widget) { static gboolean first_time = TRUE; if (first_time) { AtkObjectFactory *factory; AtkRegistry *registry; GType derived_type; GType derived_atk_type; /* * Figure out whether accessibility is enabled by looking at the * type of the accessible object which would be created for * the parent type of MateDruid. */ derived_type = g_type_parent (MATE_TYPE_DRUID); registry = atk_get_default_registry (); factory = atk_registry_get_factory (registry, derived_type); derived_atk_type = atk_object_factory_get_accessible_type (factory); if (g_type_is_a (derived_atk_type, GTK_TYPE_ACCESSIBLE)) { atk_registry_set_factory_type (registry, MATE_TYPE_DRUID, mate_druid_accessible_factory_get_type ()); } first_time = FALSE; } return GTK_WIDGET_CLASS (parent_class)->get_accessible (widget); }
GskXmlNode *gsk_xml_context_serialize_value (GskXmlContext *context, GValue *value, GError **error) { GType type; for (type = G_VALUE_TYPE (value); type != 0; type = g_type_parent (type)) { TypeInfo *type_info = try_type_info (context, type); if (type_info != NULL && type_info->to_xml != NULL) { GError *e = NULL; GskXmlNode *node = type_info->to_xml (context, value, type_info->data, &e); /* success */ if (node != NULL) return node; /* real error */ if (e) { g_propagate_error (error, e); return NULL; } /* continue trying */ } } g_set_error (error, GSK_G_ERROR_DOMAIN, GSK_ERROR_BAD_FORMAT, "no working serializer registered for type %s", G_VALUE_TYPE_NAME (value)); return NULL; }
static void print_hierarchy (GType type, gint level, gint * maxlevel) { GType parent; gint i; parent = g_type_parent (type); *maxlevel = *maxlevel + 1; level++; if (parent) print_hierarchy (parent, level, maxlevel); if (_name) g_print ("%s", _name); for (i = 1; i < *maxlevel - level; i++) g_print (" "); if (*maxlevel - level) g_print (" +----"); g_print ("%s\n", g_type_name (type)); if (level == 1) n_print ("\n"); }
gboolean gsk_xml_context_deserialize_value (GskXmlContext *context, GskXmlNode *node, GValue *out, GError **error) { GType type; for (type = G_VALUE_TYPE (out); type != 0; type = g_type_parent (type)) { TypeInfo *type_info = try_type_info (context, type); if (type_info != NULL && type_info->func != NULL) { GError *e = NULL; if (type_info->func (context, node, out, type_info->data, &e)) return TRUE; /* real error */ if (e) { g_propagate_error (error, e); return FALSE; } /* continue trying */ } } g_set_error (error, GSK_G_ERROR_DOMAIN, GSK_ERROR_BAD_FORMAT, "no working serializer registered for type %s", G_VALUE_TYPE_NAME (out)); return FALSE; }
static void build_map (GHashTable *table_map, GType type, const gchar *m2m_table) { GomResourceClass *klass; const gchar *prefix; gchar *key; gchar *value; g_assert(table_map); g_assert(g_type_is_a(type, GOM_TYPE_RESOURCE)); g_assert(!m2m_table || type != GOM_TYPE_RESOURCE); if (!m2m_table) { return; } prefix = g_type_name(type); do { klass = g_type_class_ref(type); key = g_strdup_printf("%s.%s", prefix, klass->table); value = g_strdup_printf("%s_%s", m2m_table, klass->table); g_hash_table_replace(table_map, key, value); g_type_class_unref(klass); } while ((type = g_type_parent(type)) != GOM_TYPE_RESOURCE); }
static void stretch_draw_state_change (QCADStretchyObject *obj, int x, int y, int xRef, int yRef) { int Nix ; QCADRuler *ruler = QCAD_RULER (obj) ; int xMIN = MIN (x, xRef), xMAX = MAX (x, xRef), yMIN = MIN (y, yRef), yMAX = MAX (y, yRef) ; QCADStretchyObjectClass *klass = QCAD_STRETCHY_OBJECT_CLASS (g_type_class_peek (g_type_parent (QCAD_TYPE_RULER))) ; if (NULL != klass->stretch_draw_state_change) klass->stretch_draw_state_change (obj, x, y, xRef, yRef) ; ruler->ruler_bounding_box.xWorld = real_to_world_x (xMIN) ; ruler->ruler_bounding_box.yWorld = real_to_world_y (yMIN) ; ruler->ruler_bounding_box.cxWorld = real_to_world_cx (xMAX - xMIN) ; ruler->ruler_bounding_box.cyWorld = real_to_world_cy (yMAX - yMIN) ; memcpy (&(QCAD_DESIGN_OBJECT (obj)->bounding_box), &(ruler->ruler_bounding_box), sizeof (WorldRectangle)) ; for (Nix = 0 ; Nix < ruler->icLabelsVisible ; Nix++) world_rect_union (&(QCAD_DESIGN_OBJECT (obj)->bounding_box), &(QCAD_DESIGN_OBJECT (exp_array_index_1d (ruler->labels, GRADUATION, Nix).lbl)->bounding_box), &(QCAD_DESIGN_OBJECT (obj)->bounding_box)) ; QCAD_RULER (obj)->orientation = QCAD_RULER_CALCULATE_ORIENTATION ( ruler->ruler_bounding_box.cxWorld, ruler->ruler_bounding_box.cyWorld, x, y, xRef, yRef) ; }
AtkObject * gal_a11y_e_cell_registry_get_object (GalA11yECellRegistry *registry, ETableItem *item, ECellView *cell_view, AtkObject *parent, int model_col, int view_col, int row) { GalA11yECellRegistryFunc func = NULL; GType type; if (registry == NULL) { init_default_registry (); registry = default_registry; } type = GTK_OBJECT_TYPE (cell_view->ecell); while (func == NULL && type != 0) { func = g_hash_table_lookup (registry->priv->table, GINT_TO_POINTER (type)); type = g_type_parent (type); } if (func) return func (item, cell_view, parent, model_col, view_col, row); else return gal_a11y_e_cell_new (item, cell_view, parent, model_col, view_col, row); }
static gboolean gom_resource_do_delete (GomResource *resource, GomAdapter *adapter, GError **error) { GomCommandBuilder *builder; GType resource_type; g_return_val_if_fail(GOM_IS_RESOURCE(resource), FALSE); g_return_val_if_fail(GOM_IS_ADAPTER(adapter), FALSE); resource_type = G_TYPE_FROM_INSTANCE(resource); builder = g_object_new(GOM_TYPE_COMMAND_BUILDER, "adapter", adapter, NULL); do { GomResourceClass *klass; GParamSpec *pspec; GomCommand *command; GomFilter *filter; GArray *values; GValue value = { 0 }; gchar *sql; klass = g_type_class_peek(resource_type); g_assert(GOM_IS_RESOURCE_CLASS(klass)); pspec = g_object_class_find_property(G_OBJECT_CLASS(klass), klass->primary_key); g_assert(pspec); g_value_init(&value, pspec->value_type); g_object_get_property(G_OBJECT(resource), klass->primary_key, &value); sql = g_strdup_printf("'%s'.'%s' = ?", klass->table, klass->primary_key); values = g_array_sized_new(FALSE, FALSE, sizeof(GValue), 1); g_array_append_val(values, value); filter = gom_filter_new_sql(sql, values); g_free(sql); memset(&value, 0, sizeof value); g_array_unref(values); g_object_set(builder, "filter", filter, "resource-type", resource_type, NULL); g_object_unref(filter); command = gom_command_builder_build_delete(builder); if (!gom_command_execute(command, NULL, error)) { g_object_unref(command); g_object_unref(builder); return FALSE; } g_object_unref(command); } while ((resource_type = g_type_parent(resource_type)) != GOM_TYPE_RESOURCE); g_object_unref(builder); return TRUE; }
void rbgobj_initialize_object(VALUE obj, gpointer cobj) { GType type; GType parent_type; if (!cobj) rb_raise(rb_eRuntimeError, "failed to initialize"); type = RVAL2GTYPE(obj); for (parent_type = type; parent_type != G_TYPE_INVALID; parent_type = g_type_parent(parent_type)) { if (rbgobj_convert_initialize(parent_type, obj, cobj)) return; } type = G_TYPE_FUNDAMENTAL(type); switch (type){ case G_TYPE_OBJECT: rbgobj_gobject_initialize(obj, cobj); break; case G_TYPE_PARAM: rbgobj_param_spec_initialize(obj, cobj); break; case G_TYPE_BOXED: rbgobj_boxed_initialize(obj, cobj); break; default: rbgobj_convert_initialize(type, obj, cobj); } }
VALUE rbgobj_ruby_object_from_instance2(gpointer instance, gboolean alloc) { VALUE object; GType type; if (!instance) return Qnil; type = G_TYPE_FROM_INSTANCE(instance); if (alloc) { GType parent_type; for (parent_type = type; parent_type != G_TYPE_INVALID; parent_type = g_type_parent(parent_type)) { if (rbgobj_convert_instance2robj(parent_type, instance, &object)) return object; } } switch (G_TYPE_FUNDAMENTAL(type)) { case G_TYPE_OBJECT: return rbgobj_get_ruby_object_from_gobject(instance, alloc); case G_TYPE_PARAM: return rbgobj_get_ruby_object_from_param_spec(instance, alloc); default: if (alloc) { rb_raise(rb_eTypeError, "%s isn't supported", g_type_name(type)); } else { return Qnil; } } }
GType ev_view_accessible_get_type (void) { static GType type = 0; if (G_UNLIKELY (type == 0)) { GTypeInfo tinfo = { 0, /* class size */ (GBaseInitFunc) NULL, /* base init */ (GBaseFinalizeFunc) NULL, /* base finalize */ (GClassInitFunc) ev_view_accessible_class_init, /* class init */ (GClassFinalizeFunc) NULL, /* class finalize */ NULL, /* class data */ 0, /* instance size */ 0, /* nb preallocs */ (GInstanceInitFunc) NULL, /* instance init */ NULL /* value table */ }; const GInterfaceInfo atk_text_info = { (GInterfaceInitFunc) ev_view_accessible_text_iface_init, (GInterfaceFinalizeFunc) NULL, NULL }; const GInterfaceInfo atk_action_info = { (GInterfaceInitFunc) ev_view_accessible_action_iface_init, (GInterfaceFinalizeFunc) NULL, NULL }; /* * Figure out the size of the class and instance * we are deriving from */ AtkObjectFactory *factory; GType derived_type; GTypeQuery query; GType derived_atk_type; derived_type = g_type_parent (EV_TYPE_VIEW); factory = atk_registry_get_factory (atk_get_default_registry (), derived_type); derived_atk_type = atk_object_factory_get_accessible_type (factory); g_type_query (derived_atk_type, &query); tinfo.class_size = query.class_size; tinfo.instance_size = query.instance_size; type = g_type_register_static (derived_atk_type, "EvViewAccessible", &tinfo, 0); g_type_add_interface_static (type, ATK_TYPE_TEXT, &atk_text_info); g_type_add_interface_static (type, ATK_TYPE_ACTION, &atk_action_info); } return type; }
/** * A meta table for a class has been created on the stack. Now * try to find the base class and call _get_object_meta for it, too. * * @param L Lua State * @param type_nr The GType of the class to find the parent for * * Input stack: metaclass * Output stack: metaclass * * @return 1 on success, 0 otherwise */ static int _get_object_meta_parent(lua_State *L, GType type_nr) { const char *parent_name; GType parent_type_nr; GTypeQuery query; query.type_name = NULL; int rc; typespec_t ts; /* determine the name of the parent class, if any */ parent_type_nr = g_type_parent(type_nr); if (!parent_type_nr) { /* printf("%s no parent for type 0x%x\n", msgprefix, type_nr); */ return 1; } parent_name = g_type_name(parent_type_nr); /* printf("%s parent 0x%x -> 0x%x %s\n", msgprefix, type_nr, parent_type_nr, parent_name); */ if (!parent_name) { fprintf(stderr, "%s Unknown GType 0x%x, supposed parent of %s\n", msgprefix, (unsigned int) parent_type_nr, g_type_name(type_nr)); return 1; } /* Get LuaGnome description of this structure. It might not exist, as * abstract, empty base classes like GInitiallyUnowned or GBoxed are * not known to LuaGnome. Also, when a base class should be handled by * another module, which doesn't have it or isn't loaded, this fails * in the same way. */ ts = lg_find_struct(L, parent_name, 0); if (!ts.value) { /* Might be a non-native type of this module; it could be looked * for by the hash value; on the other hand, non-native types are * not registered anywhere, so a linear search would be required * on the type list. If found, indicates a problem; the non-native * type should exist in another module. */ if (!strcmp(parent_name, "GBoxed")) return 1; printf("%s warning: type not found: %s\n", msgprefix, parent_name); return 1; } /* the parent class might actually be handled by another module. */ ts = lg_type_normalize(L, ts); rc = _get_object_meta(L, ts); if (rc == 1) { /* add _parent -- used by _fe_recurse to climb up the hierarchy */ lua_pushliteral(L, "_parent"); // meta parentmeta name lua_insert(L, -2); // meta name parentmeta lua_rawset(L, -3); // meta } return 1; }
static void qcad_undo_entry_instance_finalize (GObject *object) { void (*parent_finalize) (GObject *obj) = G_OBJECT_CLASS (g_type_class_peek (g_type_parent (QCAD_TYPE_UNDO_ENTRY)))->finalize ; if (NULL != parent_finalize) (*parent_finalize) (object) ; DBG_OO (fprintf (stderr, QCAD_TYPE_STRING_UNDO_ENTRY "::instance_finalize:Leaving\n")) ; }
static GObjectClass * get_threshold_class (GObject *obj) { GType gtype = G_TYPE_FROM_INSTANCE (obj); while (HAS_PREFIX (g_type_name (gtype))) gtype = g_type_parent (gtype); GObjectClass *klass = g_type_class_peek (gtype); if (klass == NULL) klass = g_type_class_ref (gtype); return klass; }
static void qcad_label_instance_finalize (GObject *object) { DBG_OO (fprintf (stderr, "QCADLabel::instance_finalize:Entering\n")) ; g_free (QCAD_LABEL (object)->psz) ; #ifdef GTK_GUI exp_pixmap_free (QCAD_LABEL (object)->epm) ; #endif /* def GTK_GUI */ G_OBJECT_CLASS (g_type_class_peek (g_type_parent (QCAD_TYPE_LABEL)))->finalize (object) ; DBG_OO (fprintf (stderr, "QCADLabel::instance_finalize:Leaving\n")) ; }