1 /* ATK - Accessibility Toolkit
2 * Copyright 2001 Sun Microsystems Inc.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
20 #include "atkregistry.h"
21 #include "atknoopobjectfactory.h"
23 static AtkRegistry *default_registry = NULL;
25 static void atk_registry_init (AtkRegistry *instance,
26 AtkRegistryClass *klass);
27 static void atk_registry_finalize (GObject *instance);
28 static void atk_registry_class_init (AtkRegistryClass *klass);
30 static AtkRegistry* atk_registry_new ();
33 atk_registry_get_type (void)
35 static GType type = 0;
39 static const GTypeInfo info =
41 sizeof (AtkRegistryClass),
42 (GBaseInitFunc) NULL, /* base_init */
43 (GBaseFinalizeFunc) NULL, /* base_finalize */
44 (GClassInitFunc) atk_registry_class_init, /* class_init */
45 (GClassFinalizeFunc) NULL, /* class_finalize */
46 NULL, /* class_data */
47 sizeof (AtkRegistry), /* instance size */
49 (GInstanceInitFunc) atk_registry_init, /* instance init */
50 NULL /* value table */
53 type = g_type_register_static (G_TYPE_OBJECT, "AtkRegistry", &info, 0);
60 atk_registry_class_init (AtkRegistryClass *klass)
62 GObjectClass *object_class;
64 /* is paranoia appropriate in a class initializer ? */
65 g_return_if_fail (G_IS_OBJECT_CLASS (klass));
67 object_class = G_OBJECT_CLASS (klass);
68 object_class->finalize = atk_registry_finalize;
69 default_registry = atk_registry_new ();
74 * Cannot define a class_finalize function when calling
75 * g_type_register_static()
78 atk_registry_class_finalize (GObjectClass *klass)
80 g_return_if_fail (ATK_IS_REGISTRY_CLASS (klass));
82 g_free (default_registry);
87 atk_registry_init (AtkRegistry *instance, AtkRegistryClass *klass)
89 instance->factory_type_registry = g_hash_table_new ((GHashFunc) NULL,
91 instance->factory_singleton_cache = g_hash_table_new ((GHashFunc) NULL,
100 object = g_object_new (ATK_TYPE_REGISTRY, NULL);
102 g_return_val_if_fail (object != NULL, NULL);
103 g_return_val_if_fail (ATK_IS_REGISTRY (object), NULL);
105 return (AtkRegistry *) object;
109 atk_registry_finalize (GObject *instance)
111 AtkRegistry *registry;
113 g_return_if_fail (ATK_IS_REGISTRY (instance));
114 registry = ATK_REGISTRY (instance);
115 g_free (registry->factory_type_registry);
116 g_free (registry->factory_singleton_cache);
120 * atk_registry_set_factory_type:
121 * @registry: the #AtkRegistry in which to register the type association
122 * @type: an #AtkObject type
123 * @factory_type: an #AtkObjectFactory type to associate with @type. Must
124 * implement AtkObject appropriate for @type.
126 * Associate an #AtkObjectFactory subclass with a #GType. Note:
127 * The associated @factory_type will thereafter be responsible for
128 * the creation of new #AtkObject implementations for instances
129 * appropriate for @type.
132 atk_registry_set_factory_type (AtkRegistry *registry,
138 AtkObjectFactory *old_factory;
140 g_return_if_fail (ATK_IS_REGISTRY (registry));
142 value = g_hash_table_lookup (registry->factory_type_registry,
143 GUINT_TO_POINTER (type));
144 old_type = GPOINTER_TO_UINT (value);
145 if (old_type && old_type != factory_type)
147 g_hash_table_remove (registry->factory_type_registry,
148 GUINT_TO_POINTER (type));
150 * If the old factory was created, notify it that it has
151 * been replaced, then free it.
153 old_factory = g_hash_table_lookup (registry->factory_singleton_cache,
154 GUINT_TO_POINTER (old_type));
157 atk_object_factory_invalidate (old_factory);
158 g_type_free_instance ((GTypeInstance *) old_factory);
161 g_hash_table_insert (registry->factory_type_registry,
162 GUINT_TO_POINTER (type),
163 GUINT_TO_POINTER (factory_type));
167 * atk_registry_get_factory_type:
168 * @registry: an #AtkRegistry
169 * @type: a #GType with which to look up the associated #AtkObjectFactory
172 * Provides a #GType indicating the #AtkObjectFactory subclass
173 * associated with type @type
175 * Returns: a #GType associated with type @type
178 atk_registry_get_factory_type (AtkRegistry *registry,
185 * look up factory type in first hash;
186 * if there isn't an explicitly registered factory type,
187 * try inheriting one...
191 g_hash_table_lookup (registry->factory_type_registry,
192 GUINT_TO_POINTER (type));
193 type = g_type_parent (type);
194 if (type == G_TYPE_INVALID)
198 } while (value == NULL);
200 factory_type = GPOINTER_TO_UINT (value);
205 * atk_registry_get_factory:
206 * @registry: an #AtkRegistry
207 * @type: a #GType with which to look up the associated #AtkObjectFactory
209 * Gets an #AtkObjectFactory appropriate for creating #AtkObjects
210 * appropriate for @type.
212 * Returns: an #AtkObjectFactory appropriate for creating #AtkObjects
213 * appropriate for @type.
216 atk_registry_get_factory (AtkRegistry *registry,
219 gpointer factory_pointer = NULL;
222 factory_type = atk_registry_get_factory_type (registry, type);
224 if (factory_type == G_TYPE_INVALID)
226 /* Factory type has not been specified for this object type */
227 static AtkObjectFactory* default_factory = NULL;
229 if (!default_factory)
230 default_factory = atk_no_op_object_factory_new ();
232 return default_factory;
235 /* ask second hashtable for instance of factory type */
237 g_hash_table_lookup (registry->factory_singleton_cache,
238 GUINT_TO_POINTER (factory_type));
240 /* if there isn't one already, create one and save it */
241 if (factory_pointer == NULL)
243 factory_pointer = g_type_create_instance (factory_type);
244 g_hash_table_insert (registry->factory_singleton_cache,
245 GUINT_TO_POINTER (factory_type),
249 return ATK_OBJECT_FACTORY (factory_pointer);
253 *atk_get_default_registry:
255 * Gets a default implementation of the #AtkObjectFactory/type
257 * Note: For most toolkit maintainers, this will be the correct
258 * registry for registering new #AtkObject factories. Following
259 * a call to this function, maintainers may call atk_registry_set_factory_type()
260 * to associate an #AtkObjectFactory subclass with the GType of objects
261 * for whom accessibility information will be provided.
263 * Returns: a default implementation of the #AtkObjectFactory/type
267 atk_get_default_registry ()
269 if (!default_registry)
271 default_registry = atk_registry_new();
273 return default_registry;