static void
impl_Bonobo_UIComponent_execVerb (PortableServer_Servant servant,
const CORBA_char *cname,
CORBA_Environment *ev)
{
BonoboUIComponent *component;
UIVerb *verb;
component = bonobo_ui_from_servant (servant);
bonobo_object_ref (BONOBO_OBJECT (component));
/* g_warning ("TESTME: Exec verb '%s'", cname);*/
verb = g_hash_table_lookup (component->priv->verbs, cname);
if (verb && verb->closure)
/* We need a funny arg order here - so for
our C closure we do odd things ! */
bonobo_closure_invoke (
verb->closure, G_TYPE_NONE,
BONOBO_TYPE_UI_COMPONENT, component,
G_TYPE_STRING, cname,
G_TYPE_INVALID);
else
g_warning ("FIXME: verb '%s' not found, emit exception", cname);
g_signal_emit (component, signals [EXEC_VERB], 0, cname);
bonobo_object_unref (BONOBO_OBJECT (component));
}
static void
impl_Bonobo_Listener_event (PortableServer_Servant servant,
const CORBA_char *event_name,
const CORBA_any *args,
CORBA_Environment *ev)
{
BonoboListener *listener;
listener = BONOBO_LISTENER (bonobo_object_from_servant (servant));
bonobo_object_ref (BONOBO_OBJECT (listener));
if (listener->priv->event_callback)
bonobo_closure_invoke (
listener->priv->event_callback,
G_TYPE_NONE,
BONOBO_TYPE_LISTENER, listener,
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, event_name,
BONOBO_TYPE_STATIC_CORBA_ANY, args,
BONOBO_TYPE_STATIC_CORBA_EXCEPTION, ev,
G_TYPE_INVALID);
g_signal_emit (G_OBJECT (listener),
signals [EVENT_NOTIFY], 0,
event_name, args, ev);
bonobo_object_unref (BONOBO_OBJECT (listener));
}
/* Factory function for the calendar component factory; just creates and
* references a singleton service object.
*/
static BonoboObject *
comp_editor_factory_fn (void)
{
if (!comp_editor_factory) {
comp_editor_factory = comp_editor_factory_new ();
if (!comp_editor_factory)
return NULL;
}
bonobo_object_ref (BONOBO_OBJECT (comp_editor_factory));
return BONOBO_OBJECT (comp_editor_factory);
}
/**
* bonobo_event_source_notify_listeners:
* @event_source: the Event Source that will emit the event.
* @event_name: Name of the event being emitted
* @opt_value: A CORBA_any value that contains the data that is passed
* to interested clients, or NULL for an empty value
* @opt_ev: A CORBA_Environment where a failure code can be returned, can be NULL.
*
* This will notify all clients that have registered with this EventSource
* (through the addListener or addListenerWithMask methods) of the availability
* of the event named @event_name. The @value CORBA::any value is passed to
* all listeners.
*
* @event_name can not contain comma separators, as commas are used to
* separate the various event names.
*/
void
bonobo_event_source_notify_listeners (BonoboEventSource *event_source,
const char *event_name,
const CORBA_any *opt_value,
CORBA_Environment *opt_ev)
{
GSList *l, *notify;
CORBA_Environment *ev, temp_ev;
const BonoboArg *my_value;
g_return_if_fail (BONOBO_IS_EVENT_SOURCE (event_source));
if (!opt_ev) {
CORBA_exception_init (&temp_ev);
ev = &temp_ev;
} else
ev = opt_ev;
if (!opt_value)
my_value = bonobo_arg_new (BONOBO_ARG_NULL);
else
my_value = opt_value;
notify = NULL;
for (l = event_source->priv->listeners; l; l = l->next) {
ListenerDesc *desc = (ListenerDesc *) l->data;
if (desc->event_masks == NULL ||
event_match (event_name, desc->event_masks)) {
notify = g_slist_prepend (
notify,
CORBA_Object_duplicate (desc->listener, ev));
}
}
bonobo_object_ref (BONOBO_OBJECT (event_source));
for (l = notify; l; l = l->next) {
Bonobo_Listener_event (l->data, event_name, my_value, ev);
CORBA_Object_release (l->data, ev);
}
bonobo_object_unref (BONOBO_OBJECT (event_source));
g_slist_free (notify);
if (!opt_ev)
CORBA_exception_free (ev);
if (!opt_value)
bonobo_arg_release ((BonoboArg *) my_value);
}
static Bonobo_Control
impl__get_control (PortableServer_Servant servant,
CORBA_Environment *ev)
{
EvolutionConfigControl *config_control;
EvolutionConfigControlPrivate *priv;
config_control = EVOLUTION_CONFIG_CONTROL (bonobo_object_from_servant (servant));
priv = config_control->priv;
bonobo_object_ref (BONOBO_OBJECT (priv->control));
return CORBA_Object_duplicate (bonobo_object_corba_objref (BONOBO_OBJECT (priv->control)), ev);
}
static void
impl_GNOME_GnoCam_getCamera (PortableServer_Servant servant,
Bonobo_Listener listener, CORBA_Environment *ev)
{
IdleData *d;
d = g_new0 (IdleData, 1);
d->gm = GNOCAM_MAIN (bonobo_object_from_servant (servant));
bonobo_object_ref (d->gm);
d->listener = bonobo_object_dup_ref (listener, NULL);
g_message ("Adding idle function...");
g_idle_add (get_camera_idle, d);
}
static BonoboObject *
factory (BonoboGenericFactory *factory,
const char *component_id,
void *closure)
{
static gboolean initialized = FALSE;
if (! initialized) {
initialize ();
initialized = TRUE;
}
if (strcmp (component_id, CALENDAR_COMPONENT_ID) == 0) {
BonoboObject *object = BONOBO_OBJECT (calendar_component_peek ());
bonobo_object_ref (object);
return object;
} else if (strcmp (component_id, TASKS_COMPONENT_ID) == 0) {
BonoboObject *object = BONOBO_OBJECT (tasks_component_peek ());
bonobo_object_ref (object);
return object;
} else if (strcmp (component_id, ITIP_CONTROL_ID) == 0)
return BONOBO_OBJECT (itip_bonobo_control_new ());
else if (strcmp (component_id, CONFIG_CONTROL_ID) == 0) {
GtkWidget *prefs;
EvolutionConfigControl *control;
prefs = calendar_prefs_dialog_new ();
gtk_widget_show_all (prefs);
control = evolution_config_control_new (prefs);
return BONOBO_OBJECT (control);
} else if (strcmp (component_id, COMP_EDITOR_FACTORY_ID) == 0)
return BONOBO_OBJECT (comp_editor_factory_fn ());
g_warning (FACTORY_ID ": Don't know what to do with %s", component_id);
return NULL;
}
/**
* bonobo_ui_component_set_container:
* @component: the component
* @container: a remote container object.
*
* This associates this @component with a remote @container
* object.
**/
void
bonobo_ui_component_set_container (BonoboUIComponent *component,
Bonobo_UIContainer container,
CORBA_Environment *opt_ev)
{
Bonobo_UIContainer ref_cont;
g_return_if_fail (BONOBO_IS_UI_COMPONENT (component));
bonobo_object_ref (BONOBO_OBJECT (component));
if (container != CORBA_OBJECT_NIL) {
Bonobo_UIComponent corba_component;
CORBA_Environment *ev, temp_ev;
char *name;
if (!opt_ev) {
CORBA_exception_init (&temp_ev);
ev = &temp_ev;
} else
ev = opt_ev;
ref_cont = CORBA_Object_duplicate (container, ev);
corba_component = BONOBO_OBJREF (component);
name = component->priv->name ? component->priv->name : "";
Bonobo_UIContainer_registerComponent (
ref_cont, name, corba_component, ev);
if (!opt_ev && BONOBO_EX (ev)) {
char *err;
g_warning ("Serious exception registering component '%s'",
(err = bonobo_exception_get_text (ev)));
g_free (err);
}
if (!opt_ev)
CORBA_exception_free (&temp_ev);
} else
ref_cont = CORBA_OBJECT_NIL;
bonobo_ui_component_unset_container (component, NULL);
component->priv->container = ref_cont;
bonobo_object_unref (BONOBO_OBJECT (component));
}
static void
impl_GNOME_Camera_captureImage (PortableServer_Servant servant,
const Bonobo_Listener listener,
CORBA_Environment *ev)
{
IdleData *d;
d = g_new0 (IdleData, 1);
d->gc = GNOCAM_CAMERA (bonobo_object_from_servant (servant));
bonobo_object_ref (d->gc);
d->listener = CORBA_Object_duplicate (listener, NULL);
g_message ("Adding idle function...");
g_idle_add_full (0, capture_image_idle, d, idle_data_destroy);
}
/**
* bonobo_item_container_add:
* @container: The object to operate on.
* @name: The name of the object
* @object: The object to add to the container
*
* Adds the @object to the list of objects managed by this
* container
*/
void
bonobo_item_container_add (BonoboItemContainer *container,
const char *name,
BonoboObject *object)
{
g_return_if_fail (name != NULL);
g_return_if_fail (BONOBO_IS_OBJECT (object));
g_return_if_fail (BONOBO_IS_ITEM_CONTAINER (container));
if (g_hash_table_lookup (container->priv->objects, name)) {
g_warning ("Object of name '%s' already exists", name);
} else {
bonobo_object_ref (object);
g_hash_table_insert (container->priv->objects,
g_strdup (name),
object);
}
}
static void
impl_GNOME_GnoCam_getCameraByModelAndPort (
PortableServer_Servant servant,
Bonobo_Listener listener,
const CORBA_char *model, const CORBA_char *port,
CORBA_Environment *ev)
{
IdleData *d;
d = g_new0 (IdleData, 1);
d->model = CORBA_string_dup (model);
d->port = CORBA_string_dup (port);
d->gm = GNOCAM_MAIN (bonobo_object_from_servant (servant));
bonobo_object_ref (d->gm);
d->listener = bonobo_object_dup_ref (listener, NULL);
g_message ("Adding idle function...");
g_idle_add (get_camera_idle, d);
}
static void
e_cal_view_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
ECalView *view;
ECalViewPrivate *priv;
view = E_CAL_VIEW (object);
priv = view->priv;
switch (property_id) {
case PROP_VIEW:
if (priv->view != CORBA_OBJECT_NIL)
bonobo_object_release_unref (priv->view, NULL);
priv->view = bonobo_object_dup_ref (g_value_get_pointer (value), NULL);
break;
case PROP_LISTENER:
if (priv->listener) {
g_signal_handlers_disconnect_matched (priv->listener, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, view);
bonobo_object_unref (BONOBO_OBJECT (priv->listener));
}
priv->listener = bonobo_object_ref (g_value_get_pointer (value));
g_signal_connect (G_OBJECT (priv->listener), "objects_added",
G_CALLBACK (objects_added_cb), view);
g_signal_connect (G_OBJECT (priv->listener), "objects_modified",
G_CALLBACK (objects_modified_cb), view);
g_signal_connect (G_OBJECT (priv->listener), "objects_removed",
G_CALLBACK (objects_removed_cb), view);
g_signal_connect (G_OBJECT (priv->listener), "view_progress",
G_CALLBACK (view_progress_cb), view);
g_signal_connect (G_OBJECT (priv->listener), "view_done",
G_CALLBACK (view_done_cb), view);
break;
case PROP_CLIENT:
priv->client = E_CAL (g_value_dup_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
impl_Bonobo_UIComponent_uiEvent (PortableServer_Servant servant,
const CORBA_char *id,
const Bonobo_UIComponent_EventType type,
const CORBA_char *state,
CORBA_Environment *ev)
{
BonoboUIComponent *component;
component = bonobo_ui_from_servant (servant);
/* g_warning ("TESTME: Event '%s' '%d' '%s'\n", path, type, state);*/
bonobo_object_ref (BONOBO_OBJECT (component));
g_signal_emit (component, signals [UI_EVENT], 0, id, type, state);
bonobo_object_unref (BONOBO_OBJECT (component));
}
/**
* bonobo_ui_component_unset_container:
* @component: the component
*
* This dis-associates the @component from its associated
* #BonoboUIContainer.
**/
void
bonobo_ui_component_unset_container (BonoboUIComponent *component,
CORBA_Environment *opt_ev)
{
Bonobo_UIContainer container;
g_return_if_fail (BONOBO_IS_UI_COMPONENT (component));
bonobo_object_ref (BONOBO_OBJECT (component));
container = component->priv->container;
component->priv->container = CORBA_OBJECT_NIL;
if (container != CORBA_OBJECT_NIL) {
CORBA_Environment *ev, temp_ev;
char *name;
if (!opt_ev) {
CORBA_exception_init (&temp_ev);
ev = &temp_ev;
} else
ev = opt_ev;
name = component->priv->name ? component->priv->name : "";
Bonobo_UIContainer_deregisterComponent (container, name, ev);
if (!opt_ev && BONOBO_EX (ev)) {
char *err;
g_warning ("Serious exception deregistering component '%s'",
(err = bonobo_exception_get_text (ev)));
g_free (err);
}
CORBA_Object_release (container, ev);
if (!opt_ev)
CORBA_exception_free (&temp_ev);
}
bonobo_object_unref (BONOBO_OBJECT (component));
}
/**
* bonobo_ui_component_add_verb_list_with_data:
* @component: the component
* @list: the list of verbs
* @user_data: the user data passed to the verb callbacks
*
* This is a helper function to save registering verbs individualy
* it allows registration of a great batch of verbs at one time
* in a list of #BonoboUIVerb terminated by #BONOBO_UI_VERB_END
**/
void
bonobo_ui_component_add_verb_list_with_data (BonoboUIComponent *component,
const BonoboUIVerb *list,
gpointer user_data)
{
const BonoboUIVerb *l;
g_return_if_fail (list != NULL);
g_return_if_fail (BONOBO_IS_UI_COMPONENT (component));
bonobo_object_ref (BONOBO_OBJECT (component));
for (l = list; l && l->cname; l++) {
bonobo_ui_component_add_verb (
component, l->cname, l->cb,
user_data ? user_data : l->user_data);
}
bonobo_object_unref (BONOBO_OBJECT (component));
}
static gpointer
book_view_thread (gpointer data)
{
EBookBackendScalix *bs;
gboolean stopped;
const char *query;
EDataBookView *book_view;
EBookBackendScalixPrivate *priv;
ScalixBackendSearchClosure *closure;
GList *iter;
ScanContext context;
gboolean res;
book_view = data;
closure = closure_get (book_view);
bs = closure->bs;
priv = E_BOOK_BACKEND_SCALIX_GET_PRIVATE (bs);
stopped = FALSE;
bonobo_object_ref (book_view);
if (priv->container == NULL) {
e_data_book_view_notify_complete (book_view,
GNOME_Evolution_Addressbook_AuthenticationRequired);
bonobo_object_unref (book_view);
return NULL;
}
query = e_data_book_view_get_card_query (book_view);
context.sexp = e_book_backend_sexp_new (query);
context.backend = E_BOOK_BACKEND (bs);
context.obj_list = NULL;
context.return_objects = TRUE;
if (!(context.search_needed = query_is_search (query))) {
e_data_book_view_notify_status_message (book_view, _("Loading..."));
} else {
e_data_book_view_notify_status_message (book_view, _("Searching..."));
}
g_mutex_lock (closure->mutex);
g_cond_signal (closure->cond);
g_mutex_unlock (closure->mutex);
res = scalix_container_foreach (priv->container, scan_objects, &context);
if (res == FALSE) {
e_data_book_view_notify_complete (book_view,
GNOME_Evolution_Addressbook_OtherError);
bonobo_object_unref (book_view);
return NULL;
}
for (iter = context.obj_list; iter; iter = iter->next) {
g_mutex_lock (closure->mutex);
stopped = closure->stopped;
g_mutex_unlock (closure->mutex);
if (stopped) {
break;
}
e_data_book_view_notify_update (book_view, iter->data);
g_object_unref (iter->data);
}
/*FIXME: we leek objects if stopped */
g_list_free (context.obj_list);
if (!stopped) {
e_data_book_view_notify_complete (book_view,
GNOME_Evolution_Addressbook_Success);
}
bonobo_object_unref (book_view);
return NULL;
}
static GnoCamCamera *
gnocam_main_get_camera (GnoCamMain *gm, const gchar *model, const gchar *port,
CORBA_Environment *ev)
{
Camera *camera;
GnoCamCamera *gc = NULL;
g_message ("Trying to get a camera for model '%s' (port '%s')...",
model, port);
g_return_val_if_fail (GNOCAM_IS_MAIN (gm), NULL);
gc = gnocam_cache_lookup (gm->priv->cache, model, port);
if (gc) {
bonobo_object_ref (gc);
return gc;
}
CR (gp_camera_new (&camera), ev);
if (BONOBO_EX (ev))
return (CORBA_OBJECT_NIL);
if (model && strlen (model)) {
CameraAbilities a;
CameraAbilitiesList *al = NULL;
int m;
memset (&a, 0, sizeof (CameraAbilities));
gp_abilities_list_new (&al);
gp_abilities_list_load (al, NULL);
m = gp_abilities_list_lookup_model (al, model);
gp_abilities_list_get_abilities (al, m, &a);
gp_abilities_list_free (al);
CR (gp_camera_set_abilities (camera, a), ev);
if (BONOBO_EX (ev)) {
gp_camera_unref (camera);
return NULL;
}
}
if (port && strlen (port)) {
GPPortInfo info;
GPPortInfoList *il = NULL;
int p;
memset (&info, 0, sizeof (GPPortInfo));
gp_port_info_list_new (&il);
gp_port_info_list_load (il);
p = gp_port_info_list_lookup_name (il, port);
if (p < 0)
p = gp_port_info_list_lookup_path (il, port);
gp_port_info_list_get_info (il, p, &info);
gp_port_info_list_free (il);
CR (gp_camera_set_port_info (camera, info), ev);
if (BONOBO_EX (ev)) {
gp_camera_unref (camera);
return (CORBA_OBJECT_NIL);
}
}
CR (gp_camera_init (camera, NULL), ev);
if (BONOBO_EX (ev)) {
gp_camera_unref (camera);
return NULL;
}
gc = gnocam_camera_new (camera, ev);
gp_camera_unref (camera);
if (BONOBO_EX (ev))
return NULL;
gnocam_cache_add (gm->priv->cache, gc);
g_message ("Successfully created a camera.");
return gc;
}
int
main (int argc, char *argv [])
{
BonoboObject *object;
Bonobo_Unknown ref;
CORBA_Environment *ev, real_ev;
g_thread_init (NULL);
free (malloc (8));
if (bonobo_init (&argc, argv) == FALSE)
g_error ("Can not bonobo_init");
bonobo_activate ();
ev = &real_ev;
CORBA_exception_init (ev);
fprintf (stderr, "Local lifecycle\n");
{
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
g_assert (bonobo_object_ref (object) == object);
g_assert (bonobo_object_unref (BONOBO_OBJECT (object)) == NULL);
bonobo_object_unref (BONOBO_OBJECT (object));
}
fprintf (stderr, "In-proc lifecycle\n");
{
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
ref = CORBA_Object_duplicate (BONOBO_OBJREF (object), NULL);
bonobo_object_release_unref (ref, NULL);
}
fprintf (stderr, "Query interface\n");
{
BonoboObject *a, *b;
a = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
b = BONOBO_OBJECT (g_object_new (
bonobo_stream_mem_get_type (), NULL));
bonobo_object_add_interface (a, b);
fprintf (stderr, " invalid interface\n");
object = bonobo_object_query_local_interface (
a, "IDL:This/Is/Not/There:1.0");
g_assert (object == CORBA_OBJECT_NIL);
fprintf (stderr, " symmetry\n");
object = bonobo_object_query_local_interface (
a, "IDL:Bonobo/Stream:1.0");
g_assert (object == b);
bonobo_object_unref (object);
object = bonobo_object_query_local_interface (
b, "IDL:Bonobo/Stream:1.0");
g_assert (object == b);
bonobo_object_unref (object);
object = bonobo_object_query_local_interface (
a, "IDL:Bonobo/Moniker:1.0");
g_assert (object == a);
bonobo_object_unref (object);
object = bonobo_object_query_local_interface (
b, "IDL:Bonobo/Moniker:1.0");
g_assert (object == a);
bonobo_object_unref (object);
fprintf (stderr, " remote\n");
ref = Bonobo_Unknown_queryInterface (
BONOBO_OBJREF (a), "IDL:Broken/1.0", ev);
g_assert (!BONOBO_EX (ev));
g_assert (ref == CORBA_OBJECT_NIL);
ref = Bonobo_Unknown_queryInterface (
BONOBO_OBJREF (a), "IDL:Bonobo/Stream:1.0", ev);
g_assert (!BONOBO_EX (ev));
g_assert (ref == BONOBO_OBJREF (b));
bonobo_object_release_unref (ref, ev);
g_assert (!BONOBO_EX (ev));
bonobo_object_unref (a);
}
fprintf (stderr, "Environment exception checks\n");
{
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
g_signal_connect (G_OBJECT (object),
"system_exception",
G_CALLBACK (system_exception_cb),
object);
CORBA_exception_set_system (
ev, ex_CORBA_COMM_FAILURE,
CORBA_COMPLETED_MAYBE);
g_assert (BONOBO_EX (ev));
signal_emitted = 0;
BONOBO_OBJECT_CHECK (
object, BONOBO_OBJREF (object), ev);
g_assert (signal_emitted);
CORBA_exception_free (ev);
bonobo_object_unref (object);
}
fprintf (stderr, "Servant mapping...\n");
{
PortableServer_Servant servant;
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
servant = (PortableServer_Servant) &object->servant;
g_assert (bonobo_object (object) == object);
g_assert (bonobo_object (&object->servant) == object);
g_assert (bonobo_object_get_servant (object) == servant);
g_assert (bonobo_object_from_servant (servant) == object);
g_assert (bonobo_object_fast (object) == object);
g_assert (bonobo_object_fast (servant) == object);
bonobo_object_unref (object);
}
fprintf (stderr, "Ret-ex tests...\n");
{
g_assert (!ret_ex_test (ev));
ex_test (ev);
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_Bonobo_PropertyBag_NotFound, NULL);
g_assert (ret_ex_test (ev));
CORBA_exception_free (ev);
}
fprintf (stderr, "General error tests...\n");
{
bonobo_exception_general_error_set (
ev, NULL, "a%s exception occurred", "n exceptional");
g_assert (BONOBO_EX (ev));
g_assert (!strcmp (BONOBO_EX_REPOID (ev), ex_Bonobo_GeneralError));
g_assert (!strcmp (bonobo_exception_get_text (ev),
"an exceptional exception occurred"));
}
fprintf (stderr, "All tests passed\n");
return bonobo_debug_shutdown ();
}
SpiAccessible *
spi_accessible_construct (GType type, AtkObject *o)
{
SpiAccessible *retval;
CORBA_Environment ev;
CORBA_exception_init (&ev);
g_assert (o);
g_assert (g_type_is_a (type, SPI_ACCESSIBLE_TYPE));
if ((retval = g_hash_table_lookup (get_public_refs (), o)))
{
bonobo_object_ref (BONOBO_OBJECT (retval));
return retval;
}
else
{
retval = g_object_new (type, NULL);
spi_base_construct (SPI_BASE (retval), G_OBJECT(o));
}
g_hash_table_insert (get_public_refs (), o, retval);
g_signal_connect (G_OBJECT (retval), "destroy",
G_CALLBACK (de_register_public_ref),
NULL);
/* aggregate appropriate SPI interfaces based on ATK interfaces */
if (ATK_IS_ACTION (o))
{
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT (spi_action_interface_new (o)));
}
if (ATK_IS_COMPONENT (o))
{
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT (spi_component_interface_new (o)));
}
if (ATK_IS_EDITABLE_TEXT (o))
{
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT(spi_editable_text_interface_new (o)));
}
else if (ATK_IS_TEXT (o))
{
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT (spi_text_interface_new (o)));
}
if (ATK_IS_HYPERTEXT (o))
{
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT (spi_hypertext_interface_new (o)));
}
if (ATK_IS_IMAGE (o))
{
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT (spi_image_interface_new (o)));
}
if (ATK_IS_SELECTION (o))
{
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT (spi_selection_interface_new (o)));
}
if (ATK_IS_TABLE (o))
{
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT (spi_table_interface_new (o)));
}
if (ATK_IS_VALUE (o))
{
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT (spi_value_interface_new (o)));
}
if (ATK_IS_STREAMABLE_CONTENT (o))
{
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT (spi_streamable_interface_new (o)));
}
if (ATK_IS_DOCUMENT (o)) /* We add collection interface to document */
{
SpiDocument *doc = spi_document_interface_new (o);
bonobo_object_add_interface (BONOBO_OBJECT (doc),
BONOBO_OBJECT (spi_collection_interface_new (o)));
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT (doc));
}
if (ATK_IS_HYPERLINK_IMPL (o))
{
/* !!! the cast below is used instead of the ATK_HYPERLINK macro, since
the object 'o' is not really a hyperlink, but is in fact an AtkHyperlinkImpl.
Ouch. This works since it gets cast back to GObject, but it's nasty and needs
to be cleaned up.
*/
bonobo_object_add_interface (bonobo_object (retval),
BONOBO_OBJECT (spi_hyperlink_new ((AtkHyperlink*)o)));
}
return retval;
}
