/* bind a signal */ void signal_add_to(const char *module, int pos, const char *signal, SIGNAL_FUNC func) { SIGNAL_REC *rec; int signal_id; g_return_if_fail(signal != NULL); g_return_if_fail(func != NULL); g_return_if_fail(pos >= 0 && pos < SIGNAL_LISTS); signal_id = signal_get_uniq_id(signal); rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id)); if (rec == NULL) { rec = g_mem_chunk_alloc0(signals_chunk); g_hash_table_insert(signals, GINT_TO_POINTER(signal_id), rec); } if (strcmp(signal, "signal") == 0) first_signal_rec = rec; else if (strcmp(signal, "last signal") == 0) last_signal_rec = rec; if (rec->siglist[pos] == NULL) { rec->siglist[pos] = g_ptr_array_new(); rec->modulelist[pos] = g_ptr_array_new(); } g_ptr_array_add(rec->siglist[pos], (void *) func); g_ptr_array_add(rec->modulelist[pos], (void *) module); }
TEXT_BUFFER_REC *textbuffer_create(void) { TEXT_BUFFER_REC *buffer; buffer = g_mem_chunk_alloc0(buffer_chunk); buffer->last_eol = TRUE; return buffer; }
gpointer gtk_type_new (GtkType type) { GtkTypeNode *node; GtkTypeObject *tobject; gpointer klass; LOOKUP_TYPE_NODE (node, type); g_return_val_if_fail (node != NULL, NULL); klass = node->klass; if (!klass) { klass = gtk_type_class (type); LOOKUP_TYPE_NODE (node, type); } node->chunk_alloc_locked = TRUE; if (node->mem_chunk) tobject = g_mem_chunk_alloc0 (node->mem_chunk); else tobject = g_malloc0 (node->type_info.object_size); /* we need to call the base classes' object_init_func for derived * objects with the object's ->klass field still pointing to the * corresponding base class, otherwise overridden class functions * could get called with partly-initialized objects. the real object * class is passed as second argment to the initializers. */ if (node->n_supers) { guint i; GtkType *supers; GtkTypeNode *pnode; supers = node->supers; for (i = node->n_supers; i > 0; i--) { LOOKUP_TYPE_NODE (pnode, supers[i]); if (pnode->type_info.object_init_func) { tobject->klass = pnode->klass; pnode->type_info.object_init_func (tobject, klass); } } LOOKUP_TYPE_NODE (node, type); } tobject->klass = klass; if (node->type_info.object_init_func) { node->type_info.object_init_func (tobject, klass); tobject->klass = klass; } return tobject; }
static ULONG rootDispatcher (Class *cl, Object *o, Msg msg) { ULONG retval = 0; switch (msg->MethodID) { case OM_NEW: /* Called at beginning of constructor, allocate memory for object. */ cl = _OBJECT(o)->o_Class; retval = (ULONG)g_mem_chunk_alloc0(cl->cl_MemChunk); retval = (ULONG) BASEOBJECT(retval); OCLASS(retval) = cl; break; case OM_DISPOSE: /* Speicher freigeben. Aufrufer ist verantwortlich, dass bereits alles andere freigegeben wurde ! */ cl = _OBJECT(o)->o_Class; /* g_print("rootDispatcher: DISPOSE: obj=%p cl=%p %s, clmc=%p\n", o, cl, */ /* cl->cl_ID ? cl->cl_ID : "", cl->cl_MemChunk); */ g_mem_chunk_free(cl->cl_MemChunk, _OBJECT(o)); break; #ifdef REALAROSSTUFF /* unused in Zune */ case OM_ADDTAIL: /* Fuege <o> an Liste an. */ AddTail (((struct opAddTail *)msg)->opat_List, (struct Node *) _OBJECT(o)); break; case OM_REMOVE: /* Entferne Object aus der Liste */ Remove ((struct Node *) _OBJECT(o)); break; #endif default: /* Ignore */ break; } /* switch */ return (retval); }