void
bonobo_event_source_client_remove_listener (Bonobo_Unknown object,
Bonobo_Listener listener,
CORBA_Environment *opt_ev)
{
Bonobo_Unknown es;
CORBA_Environment *ev, temp_ev;
g_return_if_fail (object != CORBA_OBJECT_NIL);
if (!opt_ev) {
CORBA_exception_init (&temp_ev);
ev = &temp_ev;
} else
ev = opt_ev;
es = Bonobo_Unknown_queryInterface (object,
"IDL:Bonobo/EventSource:1.0", ev);
if (!BONOBO_EX (ev) && es) {
Bonobo_EventSource_removeListener (es, listener, ev);
Bonobo_Unknown_unref (es, ev);
}
if (!opt_ev) {
if (BONOBO_EX (ev)) {
char *text = bonobo_exception_get_text (ev);
g_warning ("remove_listener failed '%s'", text);
g_free (text);
}
CORBA_exception_free (ev);
}
}
static void
control_activate_cb (BonoboControl *control,
gboolean activate,
EYank *yank)
{
BonoboUIComponent *ui_component;
ui_component = bonobo_control_get_ui_component (control);
if (yank->shell_view_interface == NULL) {
Bonobo_ControlFrame control_frame;
CORBA_Environment ev;
control_frame = bonobo_control_get_control_frame (control);
if (control_frame == NULL) {
goto out;
}
CORBA_exception_init (&ev);
yank->shell_view_interface = Bonobo_Unknown_queryInterface (control_frame, "IDL:GNOME/Evolution/ShellView:1.0", &ev);
if (BONOBO_EX (&ev)) {
g_warning ("Error getting ShellView. %s", CORBA_exception_id (&ev));
yank->shell_view_interface = CORBA_OBJECT_NIL;
}
CORBA_exception_free (&ev);
}
out:
if (activate)
control_activate (control, ui_component, yank);
else
control_deactivate (control, ui_component, yank);
}
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);
}
SPIBoolean
cspi_accessible_is_a (Accessible *accessible,
const char *interface_name)
{
SPIBoolean retval;
Bonobo_Unknown unknown;
if (accessible == NULL)
{
return FALSE;
}
unknown = Bonobo_Unknown_queryInterface (CSPI_OBJREF (accessible),
interface_name, cspi_ev ());
if (ev._major != CORBA_NO_EXCEPTION)
{
g_warning ("Exception '%s' checking if is '%s'",
cspi_exception_get_text (),
interface_name);
retval = FALSE;
}
else if (unknown != CORBA_OBJECT_NIL)
{
retval = TRUE;
cspi_release_unref (unknown);
}
else
{
retval = FALSE;
}
return retval;
}
static void
on_view_as_activate (GtkMenuItem *item, ViewAsData *d)
{
GtkWidget *w, *c, *s;
Bonobo_Control control;
CORBA_Environment ev;
CameraFile *f;
int result;
Bonobo_PersistStream pstream;
BonoboObject *stream;
const char *data = NULL;
unsigned long int size;
const char *type;
g_return_if_fail (d->iid != NULL);
CORBA_exception_init (&ev);
control = bonobo_get_object (d->iid, "IDL:Bonobo/Control:1.0", &ev);
if (BONOBO_EX (&ev) || (control == CORBA_OBJECT_NIL)) {
CORBA_exception_free (&ev);
g_warning ("Could not get control from '%s'.", d->iid);
return;
}
w = bonobo_window_new (d->file, d->file);
c = bonobo_widget_new_control_from_objref (control, CORBA_OBJECT_NIL);
gtk_widget_show (c);
bonobo_window_set_contents (BONOBO_WINDOW (w), c);
gtk_widget_show (w);
s = gtkam_status_new (_("Downloading '%s' from '%s'..."), d->file,
d->folder);
g_signal_emit (G_OBJECT (d->list), signals[NEW_STATUS], 0, s);
gp_file_new (&f);
result = gp_camera_file_get (d->camera->camera, d->folder, d->file,
GP_FILE_TYPE_NORMAL, f,
GTKAM_STATUS (s)->context->context);
if (d->camera->multi)
gp_camera_exit (d->camera->camera, NULL);
if (result >= 0) {
CORBA_exception_init (&ev);
pstream = Bonobo_Unknown_queryInterface (control,
"IDL:Bonobo/PersistStream:1.0", &ev);
if (!BONOBO_EX (&ev) && (pstream != CORBA_OBJECT_NIL)) {
gp_file_get_data_and_size (f, &data, &size);
gp_file_get_mime_type (f, &type);
stream = bonobo_stream_mem_create (data, size,
TRUE, FALSE);
Bonobo_PersistStream_load (pstream,
bonobo_object_corba_objref (stream), type, &ev);
g_object_unref (G_OBJECT (stream));
bonobo_object_release_unref (pstream, NULL);
}
CORBA_exception_free (&ev);
}
gp_file_unref (f);
gtk_object_destroy (GTK_OBJECT (s));
}
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;
}
Bonobo_Unknown
bonobo_moniker_ior_resolve (BonoboMoniker *moniker,
const Bonobo_ResolveOptions *options,
const CORBA_char *requested_interface,
CORBA_Environment *ev)
{
const char *ior;
CORBA_Object object;
Bonobo_Unknown retval;
gboolean is_unknown, is_correct;
ior = bonobo_moniker_get_name (moniker);
object = CORBA_ORB_string_to_object (bonobo_orb (), ior, ev);
BONOBO_RET_VAL_EX (ev, CORBA_OBJECT_NIL);
is_unknown = CORBA_Object_is_a (object, "IDL:Bonobo/Unknown:1.0", ev);
BONOBO_RET_VAL_EX (ev, CORBA_OBJECT_NIL);
if (!is_unknown) {
is_correct = CORBA_Object_is_a (object, requested_interface, ev);
BONOBO_RET_VAL_EX (ev, CORBA_OBJECT_NIL);
if (is_correct)
return object;
else {
CORBA_exception_set (
ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Moniker_InterfaceNotFound, NULL);
return CORBA_OBJECT_NIL;
}
}
retval = Bonobo_Unknown_queryInterface (
object, requested_interface, ev);
BONOBO_RET_VAL_EX (ev, CORBA_OBJECT_NIL);
if (retval == CORBA_OBJECT_NIL)
CORBA_exception_set (
ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Moniker_InterfaceNotFound, NULL);
return retval;
}
PeacockFileClient *
peacock_file_new (PeacockWindow *window)
{
GtkWidget *control;
BonoboUIContainer *uiContainer;
PeacockFileClient *fileClient;
CORBA_Environment ev;
CORBA_Object interface;
uiContainer = bonobo_window_get_ui_container (BONOBO_WINDOW (window));
control = bonobo_widget_new_control (PEACOCK_FILE_CONTROL_OAFIID,
BONOBO_OBJREF (uiContainer));
peacock_util_activate_bonobo_control (BONOBO_WIDGET (control));
gtk_widget_show (control);
/* Get the PersistFile interface for loading/saving. */
CORBA_exception_init (&ev);
interface = Bonobo_Unknown_queryInterface (bonobo_widget_get_objref (BONOBO_WIDGET (control)), "IDL:Bonobo/PersistFile:1.0", &ev);
CORBA_exception_free (&ev);
if (interface == CORBA_OBJECT_NIL) {
g_warning ("Oh No! Control doesn't support IDL:Bonobo/PersistFile:1.0!!!");
return NULL;
}
/* Initialize the PeacockFileClient struct. */
fileClient = peacock_file_client_new ();
fileClient->control = control;
fileClient->persistFile = interface;
fileClient->tabWidget = peacock_file_client_create_tab_widget (fileClient, window);
gtk_widget_ref (fileClient->control);
gtk_widget_ref (fileClient->tabWidget);
/* For setting the current_file in PeacockMDI. */
g_object_set_data (G_OBJECT (fileClient->control), PEACOCK_FILE_CLIENT_TAG, fileClient);
return fileClient;
}
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 ();
}
Bonobo_Unknown
bonobo_stream_extender_resolve (BonoboMonikerExtender *extender,
const Bonobo_Moniker m,
const Bonobo_ResolveOptions *options,
const CORBA_char *display_name,
const CORBA_char *requested_interface,
CORBA_Environment *ev)
{
char *mime_type;
char *requirements;
Bonobo_Unknown object;
Bonobo_Unknown stream;
Bonobo_Persist persist;
#ifdef G_ENABLE_DEBUG
g_message ("Stream extender: '%s'", display_name);
#endif
if (!m)
return CORBA_OBJECT_NIL;
stream = Bonobo_Moniker_resolve (m, options, "IDL:Bonobo/Stream:1.0", ev);
if (!stream)
return CORBA_OBJECT_NIL;
mime_type = get_stream_type (stream, ev);
if (!mime_type)
goto unref_stream_exception;
requirements = g_strdup_printf (
"bonobo:supported_mime_types.has ('%s') AND repo_ids.has ('%s') AND "
"repo_ids.has ('IDL:Bonobo/PersistStream:1.0')",
mime_type, requested_interface);
object = bonobo_activation_activate (requirements, NULL, 0, NULL, ev);
#ifdef G_ENABLE_DEBUG
g_message ("Attempt activate object satisfying '%s': %p",
requirements, object);
#endif
g_free (requirements);
if (ev->_major != CORBA_NO_EXCEPTION)
goto unref_stream_exception;
if (object == CORBA_OBJECT_NIL) {
#ifdef G_ENABLE_DEBUG
g_warning ("Can't find object satisfying requirements");
#endif
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Moniker_InterfaceNotFound, NULL);
goto unref_stream_exception;
}
persist = Bonobo_Unknown_queryInterface (
object, "IDL:Bonobo/PersistStream:1.0", ev);
if (ev->_major != CORBA_NO_EXCEPTION)
goto unref_object_exception;
if (persist != CORBA_OBJECT_NIL) {
Bonobo_PersistStream_load (
persist, stream, (const Bonobo_Persist_ContentType) mime_type, ev);
bonobo_object_release_unref (persist, ev);
bonobo_object_release_unref (stream, ev);
return bonobo_moniker_util_qi_return (
object, requested_interface, ev);
}
g_free (mime_type);
unref_object_exception:
bonobo_object_release_unref (object, ev);
unref_stream_exception:
bonobo_object_release_unref (stream, ev);
return CORBA_OBJECT_NIL;
}