* Boston, MA 02111-1307, USA.
*/
+#include "config.h"
+
#include "atkregistry.h"
#include "atknoopobjectfactory.h"
-static AtkRegistry *default_registry = NULL;;
+/**
+ * SECTION:atkregistry
+ * @Short_description: An object used to store the GType of the
+ * factories used to create an accessible object for an object of a
+ * particular GType.
+ * @Title:AtkRegistry
+ *
+ * The AtkRegistry is normally used to create appropriate ATK "peers"
+ * for user interface components. Application developers usually need
+ * only interact with the AtkRegistry by associating appropriate ATK
+ * implementation classes with GObject classes via the
+ * atk_registry_set_factory_type call, passing the appropriate GType
+ * for application custom widget classes.
+ */
+
+static AtkRegistry *default_registry = NULL;
static void atk_registry_init (AtkRegistry *instance,
AtkRegistryClass *klass);
static void atk_registry_finalize (GObject *instance);
static void atk_registry_class_init (AtkRegistryClass *klass);
+static AtkRegistry* atk_registry_new (void);
-static AtkRegistry* atk_registry_new ();
-static GType atk_registry_get_factory_type (AtkRegistry *registry,
- GType type);
+static gpointer parent_class = NULL;
GType
atk_registry_get_type (void)
static void
atk_registry_class_init (AtkRegistryClass *klass)
{
- GObjectClass *object_class;
+ GObjectClass *object_class = (GObjectClass *) klass;
- /* is paranoia appropriate in a class initializer ? */
- g_return_if_fail (G_IS_OBJECT_CLASS (klass));
+ parent_class = g_type_class_peek_parent (klass);
- object_class = G_OBJECT_CLASS (klass);
object_class->finalize = atk_registry_finalize;
- default_registry = atk_registry_new ();
}
-#if 0
-/*
- * Cannot define a class_finalize function when calling
- * g_type_register_static()
- */
-static void
-atk_registry_class_finalize (GObjectClass *klass)
-{
- g_return_if_fail (ATK_IS_REGISTRY_CLASS (klass));
-
- g_free (default_registry);
-}
-#endif
-
static void
atk_registry_init (AtkRegistry *instance, AtkRegistryClass *klass)
{
- instance->factory_type_registry = g_hash_table_new (NULL, NULL);
- instance->factory_singleton_cache = g_hash_table_new (NULL, NULL);
+ instance->factory_type_registry = g_hash_table_new ((GHashFunc) NULL,
+ (GEqualFunc) NULL);
+ instance->factory_singleton_cache = g_hash_table_new ((GHashFunc) NULL,
+ (GEqualFunc) NULL);
}
-static AtkRegistry*
-atk_registry_new ()
+static AtkRegistry *
+atk_registry_new (void)
{
GObject *object;
object = g_object_new (ATK_TYPE_REGISTRY, NULL);
- g_return_val_if_fail ((object != NULL), NULL);
g_return_val_if_fail (ATK_IS_REGISTRY (object), NULL);
return (AtkRegistry *) object;
}
static void
-atk_registry_finalize (GObject *instance)
+atk_registry_finalize (GObject *object)
{
- AtkRegistry *registry;
+ AtkRegistry *registry = ATK_REGISTRY (object);
- g_return_if_fail (ATK_IS_REGISTRY (instance));
- registry = ATK_REGISTRY (instance);
- g_free (registry->factory_type_registry);
- g_free (registry->factory_singleton_cache);
-}
+ g_hash_table_destroy (registry->factory_type_registry);
+ g_hash_table_destroy (registry->factory_singleton_cache);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+/**
+ * atk_registry_set_factory_type:
+ * @registry: the #AtkRegistry in which to register the type association
+ * @type: an #AtkObject type
+ * @factory_type: an #AtkObjectFactory type to associate with @type. Must
+ * implement AtkObject appropriate for @type.
+ *
+ * Associate an #AtkObjectFactory subclass with a #GType. Note:
+ * The associated @factory_type will thereafter be responsible for
+ * the creation of new #AtkObject implementations for instances
+ * appropriate for @type.
+ **/
void
atk_registry_set_factory_type (AtkRegistry *registry,
GType type,
g_return_if_fail (ATK_IS_REGISTRY (registry));
value = g_hash_table_lookup (registry->factory_type_registry,
- GUINT_TO_POINTER (type));
- old_type = GPOINTER_TO_UINT (value);
+ (gpointer) type);
+ old_type = (GType) value;
if (old_type && old_type != factory_type)
{
g_hash_table_remove (registry->factory_type_registry,
- GUINT_TO_POINTER (type));
+ (gpointer) type);
/*
* If the old factory was created, notify it that it has
* been replaced, then free it.
*/
old_factory = g_hash_table_lookup (registry->factory_singleton_cache,
- GUINT_TO_POINTER (old_type));
+ (gpointer) old_type);
if (old_factory)
{
atk_object_factory_invalidate (old_factory);
}
}
g_hash_table_insert (registry->factory_type_registry,
- GUINT_TO_POINTER (type),
- GUINT_TO_POINTER (factory_type));
+ (gpointer) type,
+ (gpointer) factory_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)
do {
value =
g_hash_table_lookup (registry->factory_type_registry,
- GUINT_TO_POINTER (type));
+ (gpointer) type);
type = g_type_parent (type);
if (type == G_TYPE_INVALID)
{
}
} while (value == NULL);
- factory_type = GPOINTER_TO_UINT (value);
+ factory_type = (GType) value;
return factory_type;
}
-
+/**
+ * atk_registry_get_factory:
+ * @registry: an #AtkRegistry
+ * @type: a #GType with which to look up the associated #AtkObjectFactory
+ *
+ * Gets an #AtkObjectFactory appropriate for creating #AtkObjects
+ * appropriate for @type.
+ *
+ * Returns: (transfer none): an #AtkObjectFactory appropriate for creating
+ * #AtkObjects appropriate for @type.
+ **/
AtkObjectFactory*
atk_registry_get_factory (AtkRegistry *registry,
GType type)
/* ask second hashtable for instance of factory type */
factory_pointer =
g_hash_table_lookup (registry->factory_singleton_cache,
- GUINT_TO_POINTER (factory_type));
+ (gpointer) factory_type);
/* if there isn't one already, create one and save it */
if (factory_pointer == NULL)
{
factory_pointer = g_type_create_instance (factory_type);
g_hash_table_insert (registry->factory_singleton_cache,
- GUINT_TO_POINTER (factory_type),
+ (gpointer) factory_type,
factory_pointer);
}
return ATK_OBJECT_FACTORY (factory_pointer);
}
-
+/**
+ * atk_get_default_registry:
+ *
+ * Gets a default implementation of the #AtkObjectFactory/type
+ * registry.
+ * Note: For most toolkit maintainers, this will be the correct
+ * registry for registering new #AtkObject factories. Following
+ * a call to this function, maintainers may call atk_registry_set_factory_type()
+ * to associate an #AtkObjectFactory subclass with the GType of objects
+ * for whom accessibility information will be provided.
+ *
+ * Returns: (transfer full): a default implementation of the
+ * #AtkObjectFactory/type registry
+ **/
AtkRegistry*
-atk_get_default_registry ()
+atk_get_default_registry (void)
{
if (!default_registry)
- {
- default_registry = atk_registry_new();
- }
+ {
+ default_registry = atk_registry_new ();
+ }
return default_registry;
}
projects / platform / upstream / atk.git / blobdiff