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)); }
int main (int argc, char **argv) { BonoboObject *context; g_thread_init (NULL); if (!bonobo_init (&argc, argv)) g_error ("Could not initialize Bonobo"); orb = bonobo_orb (); create_bag (); print_props (); /* FIXME: this is unusual, with a factory you normally * want to use bonobo_running_context_auto_exit_unref */ context = bonobo_context_running_get (); g_signal_connect_data ( G_OBJECT (context), "last_unref", G_CALLBACK (quit_main), NULL, NULL, 0); bonobo_object_unref (context); bonobo_main (); return bonobo_debug_shutdown (); }
static void set_data (BonoboWidget *control, const char *string) { Bonobo_PersistStream persist; BonoboObject *bstream; CORBA_Environment ev; persist = (Bonobo_PersistStream) Bonobo_Unknown_queryInterface ( bonobo_widget_get_objref (control), "IDL:Bonobo/PersistStream:1.0", &ev); if (persist == CORBA_OBJECT_NIL) { g_object_ref_sink (G_OBJECT (control)); return ; } bstream = bonobo_stream_mem_create (string, strlen (string), TRUE, FALSE); CORBA_exception_init (&ev); Bonobo_PersistStream_load (persist, BONOBO_OBJREF (bstream), "text/calendar", &ev); bonobo_object_unref (BONOBO_OBJECT (bstream)); Bonobo_Unknown_unref (persist, &ev); CORBA_Object_release (persist, &ev); }
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)); }
static void idle_data_destroy (gpointer user_data) { IdleData *d = user_data; bonobo_object_unref (d->gc); g_free (d); }
Bonobo_Listener bonobo_event_source_client_add_listener_full (Bonobo_Unknown object, GClosure *event_callback, const char *opt_mask, CORBA_Environment *opt_ev) { BonoboListener *listener = NULL; Bonobo_Listener corba_listener = CORBA_OBJECT_NIL; Bonobo_Unknown es; CORBA_Environment *ev, temp_ev; g_return_val_if_fail (event_callback != NULL, CORBA_OBJECT_NIL); if (!opt_ev) { ev = &temp_ev; CORBA_exception_init (ev); } else ev = opt_ev; es = Bonobo_Unknown_queryInterface (object, "IDL:Bonobo/EventSource:1.0", ev); if (BONOBO_EX (ev) || !es) goto add_listener_end; if (!(listener = bonobo_listener_new_closure (event_callback))) goto add_listener_end; corba_listener = BONOBO_OBJREF (listener); if (opt_mask) Bonobo_EventSource_addListenerWithMask ( es, corba_listener, opt_mask, ev); else Bonobo_EventSource_addListener ( es, corba_listener, ev); corba_listener = CORBA_Object_duplicate (corba_listener, ev); bonobo_object_unref (BONOBO_OBJECT (listener)); bonobo_object_release_unref (es, ev); add_listener_end: if (!opt_ev) { if (BONOBO_EX (ev)) { char *text = bonobo_exception_get_text (ev); g_warning ("add_listener failed '%s'", text); g_free (text); } CORBA_exception_free (ev); } return corba_listener; }
static gboolean remove_object (gpointer key, gpointer value, gpointer user_data) { g_free (key); bonobo_object_unref (value); return TRUE; }
static void run_tests (void) { BonoboEventSource *es; CORBA_Environment ev; CORBA_any *value; char *mask; CORBA_exception_init (&ev); g_source_remove (idle_id); value = bonobo_arg_new (BONOBO_ARG_LONG); es = bonobo_event_source_new (); g_assert (es != NULL); mask = "a/test"; bonobo_event_source_client_add_listener (BONOBO_OBJREF (es), event_cb, mask, &ev, mask); mask = "=a/test"; bonobo_event_source_client_add_listener (BONOBO_OBJREF (es), event_cb, mask, &ev, mask); bonobo_event_source_notify_listeners (es, "a/test", value, &ev); CHECK_RESULT (&ev, 2, 1); bonobo_event_source_notify_listeners (es, "a/test/xyz", value, &ev); CHECK_RESULT (&ev, 3, 1); bonobo_event_source_notify_listeners (es, "a/tes", value, &ev); CHECK_RESULT (&ev, 3, 1); bonobo_event_source_notify_listeners (es, "test", value, &ev); CHECK_RESULT (&ev, 3, 1); bonobo_event_source_notify_listeners (es, "a/test", value, &ev); CHECK_RESULT (&ev, 5, 2); bonobo_event_source_notify_listeners (es, "a/test:", value, &ev); CHECK_RESULT (&ev, 6, 2); bonobo_event_source_notify_listeners (es, "a/test:xyz", value, &ev); CHECK_RESULT (&ev, 7, 2); bonobo_event_source_notify_listeners (es, "a/", value, &ev); CHECK_RESULT (&ev, 7, 2); bonobo_event_source_notify_listeners (es, "a/test1:xyz", value, &ev); CHECK_RESULT (&ev, 8, 2); bonobo_object_unref (BONOBO_OBJECT (es)); bonobo_main_quit (); }
static void test_exit (TestGnomeApp *app) { bonobo_object_unref (BONOBO_OBJECT (app->ui_component)); gtk_widget_destroy (app->app); g_free (app); gtk_main_quit (); }
static void impl_dispose (GObject *object) { EvolutionConfigControl *config_control; EvolutionConfigControlPrivate *priv; config_control = EVOLUTION_CONFIG_CONTROL (object); priv = config_control->priv; if (priv->control != NULL) { bonobo_object_unref (BONOBO_OBJECT (priv->control)); priv->control = NULL; } if (priv->event_source != NULL) { bonobo_object_unref (BONOBO_OBJECT (priv->event_source)); priv->event_source = NULL; } (* G_OBJECT_CLASS (parent_class)->dispose) (object); }
/** * 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); }
BonoboControl * itip_bonobo_control_new (void) { BonoboControl *control; BonoboPropertyBag *prop_bag; BonoboPersistStream *stream; GtkWidget *itip; itip = e_itip_control_new (); gtk_widget_show (itip); control = bonobo_control_new (itip); /* create a property bag */ prop_bag = bonobo_property_bag_new (get_prop, set_prop, itip); bonobo_property_bag_add (prop_bag, "from_address", FROM_ADDRESS_ARG_ID, BONOBO_ARG_STRING, NULL, "from_address", 0 ); bonobo_property_bag_add (prop_bag, "view_only", VIEW_ONLY_ARG_ID, BONOBO_ARG_INT, NULL, "view_only", 0 ); bonobo_control_set_properties (control, bonobo_object_corba_objref (BONOBO_OBJECT (prop_bag)), NULL); bonobo_object_unref (BONOBO_OBJECT (prop_bag)); bonobo_control_set_automerge (control, TRUE); stream = bonobo_persist_stream_new (pstream_load, pstream_save, pstream_get_content_types, "OAFIID:GNOME_Evolution_Calendar_iTip_Control:" BASE_VERSION, itip); if (stream == NULL) { bonobo_object_unref (BONOBO_OBJECT (control)); return NULL; } bonobo_object_add_interface (BONOBO_OBJECT (control), BONOBO_OBJECT (stream)); return control; }
static BonoboObject * bonobo_shlib_factory_new_generic (BonoboGenericFactory *factory, const char *act_iid) { BonoboObject *retval; retval = BONOBO_GENERIC_FACTORY_CLASS ( bonobo_shlib_factory_parent_class)->new_generic (factory, act_iid); /* The factory reference doesn't persist inside bonobo-activation */ bonobo_object_unref (BONOBO_OBJECT (factory)); return retval; }
/** * 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)); }
/* Free application data. */ static void release_data (void) { if (gth_application != NULL) bonobo_object_unref (gth_application); free_icon_pixbufs (); if (gth_monitor != NULL) { g_object_unref (gth_monitor); gth_monitor = NULL; } gthumb_release (); eel_global_client_free (); }
void bonobo_ui_component_widget_set (BonoboUIComponent *component, const char *path, GtkWidget *widget, CORBA_Environment *opt_ev) { gpointer in_proc_servant; BonoboObject *in_proc_container; CORBA_Environment *real_ev, tmp_ev; Bonobo_UIContainer container; g_return_if_fail (widget != CORBA_OBJECT_NIL); g_return_if_fail (BONOBO_IS_UI_COMPONENT (component)); container = component->priv->container; g_return_if_fail (container != CORBA_OBJECT_NIL); if (opt_ev) real_ev = opt_ev; else { CORBA_exception_init (&tmp_ev); real_ev = &tmp_ev; } if ((in_proc_servant = ORBit_small_get_servant (container)) && (in_proc_container = bonobo_object (in_proc_servant)) && BONOBO_IS_UI_CONTAINER (in_proc_container)) { BonoboUIEngine *engine; engine = bonobo_ui_container_get_engine ( BONOBO_UI_CONTAINER (in_proc_container)); g_return_if_fail (engine != NULL); bonobo_ui_engine_widget_set (engine, path, widget); } else { BonoboControl *control = bonobo_control_new (widget); Bonobo_UIContainer_setObject ( container, path, BONOBO_OBJREF (control), real_ev); bonobo_object_unref (control); } if (!opt_ev && BONOBO_EX (real_ev)) g_warning ("Serious exception setting object '%s' '%s'", path, bonobo_exception_get_text (real_ev)); if (!opt_ev) CORBA_exception_free (&tmp_ev); }
static gboolean spi_application_toolkit_event_listener (GSignalInvocationHint *signal_hint, guint n_param_values, const GValue *param_values, gpointer data) { Accessibility_Event e; AtkObject *aobject; SpiAccessible *source; GSignalQuery signal_query; char *event_name; g_return_val_if_fail (the_app != NULL, FALSE); g_signal_query (signal_hint->signal_id, &signal_query); /* TODO: move GTK reference out of app.c into bridge */ event_name = g_strdup_printf ("Gtk:%s:%s", g_type_name (signal_query.itype), signal_query.signal_name); #ifdef SPI_DEBUG fprintf (stderr, "Received signal %s\n", event_name); #endif aobject = get_atk_object_ref (g_value_get_object (param_values + 0)); source = spi_accessible_new (aobject); e.type = CORBA_string_dup (event_name); e.source = CORBA_OBJECT_NIL; e.detail1 = 0; e.detail2 = 0; spi_init_any_nil (&e.any_data, spi_accessible_new_return (atk_get_root (), FALSE, NULL), Accessibility_ROLE_UNKNOWN, ""); notify_listeners (the_app->toolkit_listeners, source, &e); bonobo_object_unref (BONOBO_OBJECT (source)); g_object_unref (G_OBJECT (aobject)); g_free (event_name); return TRUE; }
/** * bonobo_item_container_remove_by_name: * @container: The object to operate on. * @name: The name of the object to remove from the container * * Removes the named object from the @container */ void bonobo_item_container_remove_by_name (BonoboItemContainer *container, const char *name) { gpointer key, value; g_return_if_fail (name != NULL); g_return_if_fail (BONOBO_IS_ITEM_CONTAINER (container)); if (!g_hash_table_lookup_extended (container->priv->objects, name, &key, &value)) g_warning ("Removing '%s' but not in container", name); else { g_free (key); bonobo_object_unref (value); g_hash_table_remove (container->priv->objects, name); } }
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)); }
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; } }
/** * 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)); }
static gboolean get_camera_idle (gpointer data) { IdleData *d = data; GnoCamCamera *gc; CORBA_Environment ev; CORBA_any any; CORBA_exception_init (&ev); /* Get the camera */ gc = gnocam_main_get_camera (d->gm, (const gchar *) d->model, (const gchar *) d->port, &ev); if (BONOBO_EX (&ev)) { GNOME_GnoCam_ErrorCode e = GNOME_GnoCam_ERROR; any._type = TC_GNOME_GnoCam_ErrorCode; any._value = &e; } else { GNOME_Camera c = BONOBO_OBJREF (gc); any._type = TC_GNOME_Camera; any._value = &c; } /* Notify */ g_message ("Notifying..."); Bonobo_Listener_event (d->listener, "result", &any, &ev); g_message ("Notified."); /* Clean up */ if (gc) bonobo_object_idle_unref (gc); bonobo_object_release_unref (d->listener, NULL); bonobo_object_unref (d->gm); if (d->model) CORBA_free (d->model); if (d->port) CORBA_free (d->port); g_free (d); CORBA_exception_free (&ev); return (FALSE); };
/** * 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 void check_string (const char *prefix, const char *escaped, const char *unescaped) { BonoboMoniker *moniker; const char *const_str; char *str; char *s, *name; CORBA_Environment ev; CORBA_long equal; moniker = bonobo_moniker_construct ( g_object_new (bonobo_moniker_get_type (), NULL), prefix); name = g_strconcat (prefix, escaped, NULL); bonobo_moniker_set_name (moniker, name); const_str = bonobo_moniker_get_name (moniker); fprintf (stderr, "'%s' == '%s'\n", unescaped, const_str); g_assert (!strcmp (const_str, unescaped)); CORBA_exception_init (&ev); equal = Bonobo_Moniker_equal (BONOBO_OBJREF (moniker), name, &ev); g_assert (!BONOBO_EX (&ev)); g_assert (equal); CORBA_exception_free (&ev); s = g_strconcat (prefix, escaped, NULL); str = bonobo_moniker_get_name_escaped (moniker); fprintf (stderr, "'%s' == '%s'\n", str, s); g_assert (!strcmp (str, s)); g_free (str); g_free (s); g_assert (bonobo_moniker_client_equal ( BONOBO_OBJREF (moniker), name, NULL)); bonobo_object_unref (BONOBO_OBJECT (moniker)); g_free (name); }
/** * peacock_file_control_add_property_bag: * @control: * @widget: * * Map the GObject's properties to a BonoboPropertyBag for our BonoboObject. **/ static void peacock_file_control_add_property_bag (BonoboControl *control, GtkWidget *widget) { BonoboPropertyBag *pb; GParamSpec **pspecs; guint n_props; pb = bonobo_property_bag_new (peacock_file_control_get_prop, peacock_file_control_set_prop, (gpointer) control); bonobo_control_set_properties (control, BONOBO_OBJREF (pb), NULL); bonobo_object_unref (BONOBO_OBJECT (pb)); pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (widget), &n_props); bonobo_property_bag_map_params (pb, G_OBJECT (widget), (const GParamSpec **) pspecs, n_props); g_free (pspecs); return; }
/* Finalize handler for the calendar view */ static void e_cal_view_finalize (GObject *object) { ECalView *view; ECalViewPrivate *priv; g_return_if_fail (object != NULL); g_return_if_fail (E_IS_CAL_VIEW (object)); view = E_CAL_VIEW (object); priv = view->priv; /* The server keeps a copy of the view listener, so we must unref it */ g_signal_handlers_disconnect_matched (priv->listener, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, view); bonobo_object_unref (BONOBO_OBJECT (priv->listener)); if (priv->view != CORBA_OBJECT_NIL) bonobo_object_release_unref (priv->view, NULL); g_free (priv); if (G_OBJECT_CLASS (parent_class)->finalize) (* G_OBJECT_CLASS (parent_class)->finalize) (object); }
BonoboControl * eab_vcard_control_new (void) { BonoboControl *control; BonoboPersistStream *stream; GtkWidget *display; GtkWidget *button1, *button2; GtkWidget *bbox; GtkWidget *vbox; EABVCardControl *vcard_control = g_new (EABVCardControl, 1); vcard_control->card_list = NULL; vcard_control->display = NULL; vcard_control->label = NULL; vcard_control->render_mode = EAB_CONTACT_DISPLAY_RENDER_COMPACT; /* Create the control. */ display = eab_contact_display_new (); vcard_control->display = EAB_CONTACT_DISPLAY (display); bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START); gtk_box_set_spacing (GTK_BOX (bbox), 12); button1 = gtk_button_new_with_label(_("Show Full vCard")); g_signal_connect (button1, "clicked", G_CALLBACK (toggle_full_vcard), vcard_control); gtk_box_pack_start (GTK_BOX (bbox), button1, FALSE, FALSE, 0); button2 = gtk_button_new_with_label(_("Save in addressbook")); g_signal_connect (button2, "clicked", G_CALLBACK (save_in_addressbook), vcard_control); gtk_box_pack_start (GTK_BOX (bbox), button2, FALSE, FALSE, 0); /* This is intentionally not shown. */ vcard_control->label = gtk_label_new (""); vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), display, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), vcard_control->label, TRUE, TRUE, 0); gtk_widget_show_all (bbox); gtk_widget_show (display); gtk_widget_show (vbox); control = bonobo_control_new (vbox); g_object_weak_ref (G_OBJECT (control), free_struct, vcard_control); stream = bonobo_persist_stream_new (pstream_load, pstream_save, pstream_get_content_types, VCARD_CONTROL_ID, vcard_control); if (stream == NULL) { bonobo_object_unref (BONOBO_OBJECT (control)); return NULL; } bonobo_object_add_interface (BONOBO_OBJECT (control), BONOBO_OBJECT (stream)); return control; }
BonoboObject * circle_control_new (CommonData *com) { BonoboPropertyBag *pb; BonoboControl *control; GParamSpec **pspecs; guint n_pspecs; GtkWidget *button, *frame, *spin, *hbox, *spin_label; GtkObject *adj; GSList **list = &com->list; GSList *li; ObjectData *object = NULL; frame = gtk_frame_new("Circle"); hbox = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(frame), hbox); button = gtk_button_new(); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); spin_label = gtk_label_new ("Speed:"); gtk_box_pack_start (GTK_BOX (hbox), spin_label, FALSE, FALSE, 0); adj = gtk_adjustment_new(100.0, 0.0, 1000.0, 1.0, 10.0, 0.0); g_signal_connect(adj, "value_changed", G_CALLBACK(set_speed), com); spin = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 0.0, 0); gtk_box_pack_start (GTK_BOX (hbox), spin, FALSE, FALSE, 0); gtk_widget_show_all(frame); control = bonobo_control_new (frame); pb = bonobo_property_bag_new (NULL, NULL, NULL); bonobo_control_set_properties (control, BONOBO_OBJREF (pb), NULL); bonobo_object_unref (BONOBO_OBJECT (pb)); g_signal_connect(button, "clicked", G_CALLBACK(on_press), com); pspecs = g_object_class_list_properties ( G_OBJECT_GET_CLASS (button), &n_pspecs); bonobo_property_bag_map_params ( pb, G_OBJECT (button), (const GParamSpec **)pspecs, n_pspecs); g_free (pspecs); bonobo_control_life_instrument (control); li = g_slist_last(*list); if (li) { object = li->data; } if (!object || object->button) { object = g_new0(ObjectData, 1); *list = g_slist_append(*list, object); } object->button = button; object->adj = GTK_ADJUSTMENT(adj); update_button(object, com); set_speed(GTK_ADJUSTMENT(adj), com); return BONOBO_OBJECT (control); }
static void no_windows_left_cb (EShell *shell, gpointer data) { bonobo_object_unref (BONOBO_OBJECT (shell)); bonobo_main_quit (); }
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 (); }