/* 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);
}
