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
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));
}
GnoCamCamera *
gnocam_camera_new (Camera *camera, CORBA_Environment *ev)
{
GnoCamCamera *gc;
BonoboStorageCamera *storage;
bonobo_return_val_if_fail (camera, NULL, ev);
g_message ("Creating storage...");
storage = bonobo_storage_camera_new (camera, "/",
Bonobo_Storage_READ |
Bonobo_Storage_WRITE, ev);
if (BONOBO_EX (ev))
return (NULL);
gc = g_object_new (GNOCAM_TYPE_CAMERA, NULL);
gc->camera = camera;
gp_camera_ref (camera);
g_message ("Adding interfaces...");
bonobo_object_add_interface (BONOBO_OBJECT (gc),
BONOBO_OBJECT (storage));
gc->priv->event_source = bonobo_event_source_new ();
bonobo_object_add_interface (BONOBO_OBJECT (gc),
BONOBO_OBJECT (gc->priv->event_source));
return (gc);
}
static BonoboObject*
bonobo_sample_moody_component_factory (BonoboGenericFactory* factory, void* data)
{
GoodMood *good_mood = good_mood_new ();
BadMood *bad_mood = bad_mood_new ();
bonobo_object_add_interface
(BONOBO_OBJECT(good_mood), BONOBO_OBJECT(bad_mood));
return BONOBO_OBJECT (good_mood);
}
/**
* 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);
}
/* 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);
}
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);
}
/**
* 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));
}
/**
* bonobo_zoomable_frame_bind_to_zoomable:
* @zoomable_frame: A BonoboZoomableFrame object.
* @zoomable: The CORBA object for the BonoboZoomable embedded
* in this BonoboZoomableFrame.
*
* Associates @zoomable with this @zoomable_frame.
*/
void
bonobo_zoomable_frame_bind_to_zoomable (BonoboZoomableFrame *zoomable_frame,
Bonobo_Zoomable zoomable,
CORBA_Environment *opt_ev)
{
CORBA_Environment *ev, temp_ev;
g_return_if_fail (zoomable != CORBA_OBJECT_NIL);
g_return_if_fail (BONOBO_IS_ZOOMABLE_FRAME (zoomable_frame));
if (zoomable_frame->priv->zoomable != CORBA_OBJECT_NIL)
CORBA_Object_release (zoomable_frame->priv->zoomable, NULL);
zoomable_frame->priv->zoomable = CORBA_Object_duplicate (zoomable, NULL);
if (!opt_ev) {
CORBA_exception_init (&temp_ev);
ev = &temp_ev;
} else
ev = opt_ev;
Bonobo_Zoomable_setFrame (zoomable, BONOBO_OBJREF (zoomable_frame), ev);
if (BONOBO_EX (ev))
bonobo_object_check_env (BONOBO_OBJECT (zoomable_frame), zoomable, ev);
if (!opt_ev)
CORBA_exception_free (&temp_ev);
}
SpiHyperlink *
spi_hyperlink_new (AtkHyperlink *object)
{
SpiHyperlink *new_hyperlink = g_object_new (
SPI_HYPERLINK_TYPE, NULL);
spi_base_construct (SPI_BASE (new_hyperlink), G_OBJECT(object));
/*
* some hyperlinks are actionable... this is an ATK convention
* that seems convenient though possibly poorly documented or unintended.
*/
if (ATK_IS_ACTION (object))
{
/*
* NOTE: we don't cast 'object' to ATK_OBJECT in the call to
* spi_action_interface_new(), because of the above convention,
* even though it means we may be violating the func prototype.
* See discussion in bugzilla bug #120659.
* !!!
* IMPORTANT! The 'AtkObject' typecast, instead of the cast macro,
* is used below, because 'object' may NOT really be an AtkObject;
* it will be cast back to a G_OBJECT inside spi_action_interface_new
* before use, so this is OK though very ropey coding style.
*/
/* Don't aggregate action twice... if this is from AtkHyperlinkImpl */
if (!bonobo_object_query_interface (bonobo_object (new_hyperlink), "IDL:Accessibility/Action:1.0",
NULL))
bonobo_object_add_interface (bonobo_object (new_hyperlink),
BONOBO_OBJECT (spi_action_interface_new ((AtkObject *) object)));
}
return new_hyperlink;
}
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);
}
BonoboObject *
gwget_application_server_new (GdkScreen *screen)
{
BonoboGenericFactory *factory;
char *display_name;
char *registration_id;
/* We must ensure an instance of gwget per screen
* as gwget has no multiscreen support
*/
display_name = gdk_screen_make_display_name (screen);
registration_id = bonobo_activation_make_registration_id (
"OAFIID:GNOME_Gwget_Factory",
display_name);
factory = bonobo_generic_factory_new ("OAFIID:GNOME_Gwget_Factory",
gwget_application_server_factory,
NULL);
if (!BONOBO_IS_GENERIC_FACTORY(factory))
g_message("Cant create corba factory");
g_free (display_name);
g_free (registration_id);
return BONOBO_OBJECT (factory);
}
static BonoboObject *
factory_fn (BonoboGenericFactory *factory,
void *closure)
{
EvolutionShellComponent *shell_component;
running_objects++;
shell_component = evolution_shell_component_new (folder_types,
NULL,
create_view,
create_folder,
remove_folder,
xfer_folder, NULL,
NULL, NULL);
/* New Yank in the File-New menu */
/* evolution_shell_component_add_user_creatable_item (shell_component, "Yank", _("New Yank"), _("New _Yank"), 'y'); */
/* Connect a cb to this menu item */
/* gtk_signal_connect (GTK_OBJECT(shell_component), "user_create_new_item", */
/* GTK_SIGNAL_FUNC (user_create_new_item_cb), NULL); */
gtk_signal_connect (GTK_OBJECT (shell_component), "destroy",
GTK_SIGNAL_FUNC (component_destroy), NULL);
gtk_signal_connect (GTK_OBJECT (shell_component), "owner_set",
GTK_SIGNAL_FUNC (owner_set_cb), NULL);
gtk_signal_connect (GTK_OBJECT (shell_component), "owner_unset",
GTK_SIGNAL_FUNC (owner_unset_cb), NULL);
return BONOBO_OBJECT (shell_component);
}
static EvolutionShellComponentResult
create_view (EvolutionShellComponent *shell,
const char *physical_uri,
const char *folder_type,
BonoboControl **control_return,
void *closure)
{
EvolutionShellClient *shell_client;
GNOME_Evolution_Shell corba_shell;
BonoboControl *control;
puts("create view");
if (g_strcasecmp (folder_type, YANK_TYPE) != 0) {
return EVOLUTION_SHELL_COMPONENT_UNSUPPORTEDTYPE;
}
shell_client = evolution_shell_component_get_owner (shell);
corba_shell = bonobo_object_corba_objref (BONOBO_OBJECT (shell_client));
control = e_yank_factory_new_control (physical_uri, corba_shell);
if (!control)
return EVOLUTION_SHELL_COMPONENT_NOTFOUND;
*control_return = control;
return EVOLUTION_SHELL_COMPONENT_OK;
}
static void
peacock_file_control_construct (BonoboControl *control, GtkWidget *widget)
{
PeacockFileControlData *cd;
cd = peacock_file_control_data_new ();
cd->control = control;
cd->uiContainer = bonobo_control_get_remote_ui_container (cd->control,
NULL);
/* Create the PeacockFile. */
cd->file = peacock_file_new ();
/* ...then the PeacockFileView */
cd->view = PEACOCK_FILE_VIEW (peacock_file_view_new (cd->file, cd->uiContainer));
gtk_box_pack_start_defaults (GTK_BOX (widget), GTK_WIDGET (cd->view));
gtk_widget_show (GTK_WIDGET (cd->view));
/* Add the Bonobo::PersistFile interface. */
cd->persistFile = peacock_file_persist_file_new (cd->file);
bonobo_object_add_interface (BONOBO_OBJECT (cd->control),
cd->persistFile);
/* Load the menus and toolbars. */
peacock_file_control_load_ui (control, cd);
/*
* Expose the GObject properties through the
* BonoboPropertyBag interface.
*/
peacock_file_control_add_property_bag (control, widget);
return;
}
GList *
bonobo_zoomable_frame_get_preferred_zoom_level_names (BonoboZoomableFrame *zoomable_frame)
{
CORBA_Environment ev;
Bonobo_ZoomLevelNameList *zoom_level_names;
GList *list = NULL;
int i;
g_return_val_if_fail (BONOBO_IS_ZOOMABLE_FRAME (zoomable_frame), NULL);
CORBA_exception_init (&ev);
zoom_level_names = Bonobo_Zoomable__get_preferredLevelNames (
zoomable_frame->priv->zoomable, &ev);
if (BONOBO_EX (&ev)) {
bonobo_object_check_env (BONOBO_OBJECT (zoomable_frame),
zoomable_frame->priv->zoomable, &ev);
CORBA_exception_free (&ev);
return NULL;
}
CORBA_exception_free (&ev);
if (zoom_level_names == CORBA_OBJECT_NIL)
return NULL;
for (i = 0; i < zoom_level_names->_length; i++)
list = g_list_prepend (list, g_strdup (zoom_level_names->_buffer [i]));
CORBA_free (zoom_level_names);
return g_list_reverse (list);
}
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 BonoboObject *
gth_application_factory (BonoboGenericFactory *this_factory,
const char *iid,
gpointer user_data)
{
if (strcmp (iid, "OAFIID:GNOME_GThumb_Application") != 0)
return NULL;
else
return BONOBO_OBJECT (g_object_new (GTH_TYPE_APPLICATION, NULL));
}
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));
}
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
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 BonoboObject *
gwget_application_server_factory (BonoboGenericFactory *this_factory,
const char *iid,
gpointer user_data)
{
GwgetApplicationServer *a;
a = g_object_new (GWGET_APPLICATION_SERVER_TYPE, NULL);
return BONOBO_OBJECT (a);
}
static BonoboObject *
stardict_application_server_factory (BonoboGenericFactory *this_factory,
const char *iid,
gpointer user_data)
{
StardictApplicationServer *a;
a = (StardictApplicationServer *)g_object_new (STARDICT_APPLICATION_SERVER_TYPE, NULL);
return BONOBO_OBJECT (a);
}
/**
* 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
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);
}
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;
}
void
bonobo_zoomable_frame_set_zoom_level (BonoboZoomableFrame *zoomable_frame, float zoom_level)
{
CORBA_Environment ev;
g_return_if_fail (BONOBO_IS_ZOOMABLE_FRAME (zoomable_frame));
CORBA_exception_init (&ev);
Bonobo_Zoomable_setLevel (zoomable_frame->priv->zoomable, zoom_level, &ev);
bonobo_object_check_env (BONOBO_OBJECT (zoomable_frame),
zoomable_frame->priv->zoomable, &ev);
CORBA_exception_free (&ev);
}
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;
}
void
bonobo_zoomable_frame_zoom_to_default (BonoboZoomableFrame *zoomable_frame)
{
CORBA_Environment ev;
g_return_if_fail (BONOBO_IS_ZOOMABLE_FRAME (zoomable_frame));
g_return_if_fail (zoomable_frame->priv->zoomable != CORBA_OBJECT_NIL);
CORBA_exception_init (&ev);
Bonobo_Zoomable_zoomDefault (zoomable_frame->priv->zoomable, &ev);
bonobo_object_check_env (BONOBO_OBJECT (zoomable_frame),
zoomable_frame->priv->zoomable, &ev);
CORBA_exception_free (&ev);
}
