glib/gobject/gtypemodule.c

431 lines
12 KiB
C
Raw Normal View History

2000-11-11 07:46:30 +01:00
/* GObject - GLib Type, Object, Parameter and Signal Library
* Copyright (C) 2000 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <stdlib.h>
2000-11-11 07:46:30 +01:00
#include "gtypeplugin.h"
#include "gtypemodule.h"
#include "gobjectalias.h"
2000-11-11 07:46:30 +01:00
typedef struct _ModuleTypeInfo ModuleTypeInfo;
typedef struct _ModuleInterfaceInfo ModuleInterfaceInfo;
struct _ModuleTypeInfo
{
gboolean loaded;
GType type;
GType parent_type;
GTypeInfo info;
};
struct _ModuleInterfaceInfo
{
gboolean loaded;
GType instance_type;
GType interface_type;
GInterfaceInfo info;
};
static void g_type_module_use_plugin (GTypePlugin *plugin);
static void g_type_module_complete_type_info (GTypePlugin *plugin,
GType g_type,
GTypeInfo *info,
GTypeValueTable *value_table);
static void g_type_module_complete_interface_info (GTypePlugin *plugin,
GType instance_type,
2000-11-11 07:46:30 +01:00
GType interface_type,
GInterfaceInfo *info);
static gpointer parent_class = NULL;
2000-11-11 07:46:30 +01:00
static void
g_type_module_dispose (GObject *object)
2000-11-11 07:46:30 +01:00
{
GTypeModule *module = G_TYPE_MODULE (object);
if (module->type_infos || module->interface_infos)
{
g_warning (G_STRLOC ": unsolicitated invocation of g_object_dispose() on GTypeModule");
2000-11-11 07:46:30 +01:00
g_object_ref (object);
}
G_OBJECT_CLASS (parent_class)->dispose (object);
2000-11-11 07:46:30 +01:00
}
static void
g_type_module_finalize (GObject *object)
{
GTypeModule *module = G_TYPE_MODULE (object);
g_free (module->name);
G_OBJECT_CLASS (parent_class)->finalize (object);
2000-11-11 07:46:30 +01:00
}
static void
g_type_module_class_init (GTypeModuleClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (class));
gobject_class->dispose = g_type_module_dispose;
2000-11-11 07:46:30 +01:00
gobject_class->finalize = g_type_module_finalize;
}
static void
g_type_module_iface_init (GTypePluginClass *iface)
{
iface->use_plugin = g_type_module_use_plugin;
iface->unuse_plugin = (void (*) (GTypePlugin *))g_type_module_unuse;
iface->complete_type_info = g_type_module_complete_type_info;
iface->complete_interface_info = g_type_module_complete_interface_info;
}
GType
g_type_module_get_type (void)
{
static GType type_module_type = 0;
if (!type_module_type)
{
static const GTypeInfo type_module_info = {
sizeof (GTypeModuleClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) g_type_module_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GTypeModule),
0, /* n_preallocs */
NULL, /* instance_init */
};
static const GInterfaceInfo iface_info = {
(GInterfaceInitFunc) g_type_module_iface_init,
NULL, /* interface_finalize */
NULL, /* interface_data */
};
type_module_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GTypeModule"), &type_module_info, G_TYPE_FLAG_ABSTRACT);
2000-11-11 07:46:30 +01:00
g_type_add_interface_static (type_module_type, G_TYPE_TYPE_PLUGIN, &iface_info);
}
return type_module_type;
}
void
g_type_module_set_name (GTypeModule *module,
const gchar *name)
{
g_return_if_fail (G_IS_TYPE_MODULE (module));
g_free (module->name);
module->name = g_strdup (name);
}
static ModuleTypeInfo *
g_type_module_find_type_info (GTypeModule *module,
GType type)
{
GSList *tmp_list = module->type_infos;
while (tmp_list)
{
ModuleTypeInfo *type_info = tmp_list->data;
if (type_info->type == type)
return type_info;
tmp_list = tmp_list->next;
}
return NULL;
}
static ModuleInterfaceInfo *
g_type_module_find_interface_info (GTypeModule *module,
GType instance_type,
GType interface_type)
{
GSList *tmp_list = module->interface_infos;
while (tmp_list)
{
ModuleInterfaceInfo *interface_info = tmp_list->data;
if (interface_info->instance_type == instance_type &&
interface_info->interface_type == interface_type)
return interface_info;
tmp_list = tmp_list->next;
}
return NULL;
}
gboolean
g_type_module_use (GTypeModule *module)
{
g_return_val_if_fail (G_IS_TYPE_MODULE (module), FALSE);
module->use_count++;
if (module->use_count == 1)
{
GSList *tmp_list;
if (!G_TYPE_MODULE_GET_CLASS (module)->load (module))
{
module->use_count--;
return FALSE;
}
2000-11-11 07:46:30 +01:00
tmp_list = module->type_infos;
while (tmp_list)
{
ModuleTypeInfo *type_info = tmp_list->data;
if (!type_info->loaded)
{
g_warning ("plugin '%s' failed to register type '%s'\n",
module->name ? module->name : "(unknown)",
g_type_name (type_info->type));
return FALSE;
}
tmp_list = tmp_list->next;
}
}
return TRUE;
}
void
g_type_module_unuse (GTypeModule *module)
{
g_return_if_fail (G_IS_TYPE_MODULE (module));
g_return_if_fail (module->use_count > 0);
module->use_count--;
if (module->use_count == 0)
{
GSList *tmp_list;
G_TYPE_MODULE_GET_CLASS (module)->unload (module);
tmp_list = module->type_infos;
while (tmp_list)
{
ModuleTypeInfo *type_info = tmp_list->data;
type_info->loaded = FALSE;
tmp_list = tmp_list->next;
}
}
}
static void
g_type_module_use_plugin (GTypePlugin *plugin)
{
GTypeModule *module = G_TYPE_MODULE (plugin);
if (!g_type_module_use (module))
{
g_warning ("Fatal error - Could not reload previously loaded plugin '%s'\n",
module->name ? module->name : "(unknown)");
exit (1);
}
}
static void
g_type_module_complete_type_info (GTypePlugin *plugin,
GType g_type,
GTypeInfo *info,
GTypeValueTable *value_table)
{
GTypeModule *module = G_TYPE_MODULE (plugin);
ModuleTypeInfo *module_type_info = g_type_module_find_type_info (module, g_type);
*info = module_type_info->info;
if (module_type_info->info.value_table)
*value_table = *module_type_info->info.value_table;
}
static void
g_type_module_complete_interface_info (GTypePlugin *plugin,
GType instance_type,
GType interface_type,
2000-11-11 07:46:30 +01:00
GInterfaceInfo *info)
{
GTypeModule *module = G_TYPE_MODULE (plugin);
ModuleInterfaceInfo *module_interface_info = g_type_module_find_interface_info (module, instance_type, interface_type);
2000-11-11 07:46:30 +01:00
*info = module_interface_info->info;
}
GType
g_type_module_register_type (GTypeModule *module,
GType parent_type,
const gchar *type_name,
const GTypeInfo *type_info,
GTypeFlags flags)
{
ModuleTypeInfo *module_type_info = NULL;
GType type;
g_return_val_if_fail (module != NULL, 0);
g_return_val_if_fail (type_name != NULL, 0);
g_return_val_if_fail (type_info != NULL, 0);
type = g_type_from_name (type_name);
if (type)
{
GTypePlugin *old_plugin = g_type_get_plugin (type);
if (old_plugin != G_TYPE_PLUGIN (module))
{
g_warning ("Two different plugins tried to register '%s'.", type_name);
return 0;
}
}
if (type)
{
module_type_info = g_type_module_find_type_info (module, type);
if (module_type_info->parent_type != parent_type)
{
const gchar *parent_type_name = g_type_name (parent_type);
g_warning ("Type '%s' recreated with different parent type.\n"
"(was '%s', now '%s')", type_name,
g_type_name (module_type_info->parent_type),
parent_type_name ? parent_type_name : "(unknown)");
return 0;
}
if (module_type_info->info.value_table)
g_free ((GTypeValueTable *) module_type_info->info.value_table);
2000-11-11 07:46:30 +01:00
}
else
{
module_type_info = g_new (ModuleTypeInfo, 1);
module_type_info->parent_type = parent_type;
module_type_info->type = g_type_register_dynamic (parent_type, type_name, G_TYPE_PLUGIN (module), flags);
module->type_infos = g_slist_prepend (module->type_infos, module_type_info);
}
module_type_info->loaded = TRUE;
module_type_info->info = *type_info;
if (type_info->value_table)
module_type_info->info.value_table = g_memdup (type_info->value_table,
sizeof (type_info->value_table));
return module_type_info->type;
}
void
g_type_module_add_interface (GTypeModule *module,
GType instance_type,
GType interface_type,
const GInterfaceInfo *interface_info)
2000-11-11 07:46:30 +01:00
{
ModuleInterfaceInfo *module_interface_info = NULL;
g_return_if_fail (module != NULL);
g_return_if_fail (interface_info != NULL);
fixed dealing with collection/lcopy of NULL values. Mon Dec 11 04:44:11 2000 Tim Janik <timj@gtk.org> * gboxed.c: fixed dealing with collection/lcopy of NULL values. * gclosure.h: removed insane ramblings, added G_CALLBACK() a casting convenience macro. * Makefile.am: cleanups, marshaller generation rules. * gmarshal.[hc]: new files with GRuntime standard marshallers. * glib-genmarshal.c: fix log domain, support gruntime standard marshallers, suport G_TYPE_PARAM, come with extern "C" and #include gmarshal.h. * glib-genmarshal.1: reflect glib-genmarshal.c updates. * gobject.[hc]: implement object constructor. rework parameter changed notification queueing, we support queue freezes now and don't dispatch from an idle handler anymore. parameter->property rename hassle. implemented ::properties_changed and ::notify::* signals for property change notification (the later supports property names as details). added signal connection and named data properties. (g_signal_connect_object): new function to setup while_alive connections. (g_object_class_install_property): sink properties now, since they are initially floating. (g_object_steal_data): (g_object_set_data_full): (g_object_set_data): (g_object_get_data): set/get data by using g_datalist_*() functions directly. (g_object_queue_param_changed): nuked. (g_object_freeze_notify): start queueing of property changes (freeze/ thaw calls stack). (g_object_notify): announce changes of a certain property directly. (g_object_thaw_notify): process queue of property changes, therefore emitting GObject::notify::detail with detail being the changed properties names. (G_OBJECT_WARN_INVALID_PROPERTY_ID): saner macro variant of former G_WARN_INVALID_PARAM_ID(). * gparam.[hc]: param specs are now initially floating and need to be sunken with g_param_spec_sink(), support G_TYPE_PARAM values. added G_PARAM_CONSTRUCT and G_PARAM_CONSTRUCT_ONLY parameter flags, required by GObjectClass.constructor(). * gparamspecs.[hc]: added GParamSpecParam, GParamSpecPointer and GParamSpecCCallback, param specs for G_TYPE_PARAM, G_TYPE_POINTER and G_TYPE_CCALLBACK respectively. * gsignal.[hc]: cleanups. (signal_id_lookup): after walking the anchestry, try interfaces as well. (g_signal_new): new function to create signals from varargs type list. (g_signal_connect_closure): closure connection variant that works from signal name+detail. (g_signal_connect_data): c handler connection variant that works from signal name+detail. (g_signal_emit_valist): emit signal for an instance with paraneters collected from a va_list. (g_signal_emit): emit signal, taking parameters from varargs list. (g_signal_emit_by_name): same as g_signal_emit, working from signal name+detail. (signal_emit_R): return whether return_value needs to be altered. * gtype.[hc]: set log-domain to GRuntime, i'm slowly getting to all the points that need to reflect the upcoming rename. melt g_type_conforms_to() functionality into g_type_is_a(), as that is what we really want (liskov substitution principle). assorted changes to other files due to conforms_to->is_a. * gvalue.[hc]: implemented g_value_set_instance() that sets a value from an instantiatable type via the value_table's collect_value() function (based on an idea from James Henstridge <james@daa.com.au>). cleanups/fixes. * gvaluetypes.[hc]: implement G_TYPE_CCALLBACK and G_TYPE_PARAM.
2000-12-12 08:32:00 +01:00
if (g_type_is_a (instance_type, interface_type))
2000-11-11 07:46:30 +01:00
{
GTypePlugin *old_plugin = g_type_interface_get_plugin (instance_type,
interface_type);
if (!old_plugin)
{
g_warning ("Interface '%s' for '%s' was previously registered statically or for a parent type.",
g_type_name (interface_type), g_type_name (instance_type));
return;
}
else if (old_plugin != G_TYPE_PLUGIN (module))
{
g_warning ("Two different plugins tried to register interface '%s' for '%s'.",
g_type_name (interface_type), g_type_name (instance_type));
return;
}
module_interface_info = g_type_module_find_interface_info (module, instance_type, interface_type);
g_assert (module_interface_info);
}
else
{
module_interface_info = g_new (ModuleInterfaceInfo, 1);
module_interface_info->instance_type = instance_type;
module_interface_info->interface_type = interface_type;
g_type_add_interface_dynamic (instance_type, interface_type, G_TYPE_PLUGIN (module));
module->interface_infos = g_slist_prepend (module->interface_infos, module_interface_info);
}
module_interface_info->loaded = TRUE;
module_interface_info->info = *interface_info;
}
GType
g_type_module_register_enum (GTypeModule *module,
const gchar *name,
const GEnumValue *const_static_values)
{
GTypeInfo enum_type_info = { 0, };
g_return_val_if_fail (G_IS_TYPE_MODULE (module), 0);
g_return_val_if_fail (name != NULL, 0);
g_return_val_if_fail (const_static_values != NULL, 0);
g_enum_complete_type_info (G_TYPE_ENUM,
&enum_type_info, const_static_values);
return g_type_module_register_type (G_TYPE_MODULE (module),
G_TYPE_ENUM, name, &enum_type_info, 0);
}
GType
g_type_module_register_flags (GTypeModule *module,
const gchar *name,
const GFlagsValue *const_static_values)
{
GTypeInfo flags_type_info = { 0, };
g_return_val_if_fail (G_IS_TYPE_MODULE (module), 0);
g_return_val_if_fail (name != NULL, 0);
g_return_val_if_fail (const_static_values != NULL, 0);
g_flags_complete_type_info (G_TYPE_FLAGS,
&flags_type_info, const_static_values);
return g_type_module_register_type (G_TYPE_MODULE (module),
G_TYPE_FLAGS, name, &flags_type_info, 0);
}
#define __G_TYPE_MODULE_C__
#include "gobjectaliasdef.c"