From edcdb2068858eebca3c23978c91b827a077c02a1 Mon Sep 17 00:00:00 2001 From: Federico Mena Quintero Date: Wed, 12 Jan 2000 01:36:56 +0000 Subject: New IDL for the personal calendar server. 2000-01-11 Federico Mena Quintero * gnome-calendar.idl: New IDL for the personal calendar server. * cal.h cal.c: New files with the calendar object. * cal-listener.h cal-listener.c: New files with the calendar listener object. * cal-factory.h cal-factory.c: New files with the calendar factory object. svn path=/trunk/; revision=1555 --- calendar/ChangeLog | 12 ++ calendar/cal-client/cal-listener.c | 310 ++++++++++++++++++++++++++++++++ calendar/cal-client/cal-listener.h | 70 ++++++++ calendar/cal-factory.c | 272 ++++++++++++++++++++++++++++ calendar/cal-factory.h | 70 ++++++++ calendar/cal-listener.c | 310 ++++++++++++++++++++++++++++++++ calendar/cal-listener.h | 70 ++++++++ calendar/cal.c | 343 ++++++++++++++++++++++++++++++++++++ calendar/cal.h | 70 ++++++++ calendar/evolution-calendar.idl | 63 +++++++ calendar/idl/evolution-calendar.idl | 63 +++++++ calendar/pcs/cal-factory.c | 272 ++++++++++++++++++++++++++++ calendar/pcs/cal-factory.h | 70 ++++++++ calendar/pcs/cal.c | 343 ++++++++++++++++++++++++++++++++++++ calendar/pcs/cal.h | 70 ++++++++ 15 files changed, 2408 insertions(+) create mode 100644 calendar/cal-client/cal-listener.c create mode 100644 calendar/cal-client/cal-listener.h create mode 100644 calendar/cal-factory.c create mode 100644 calendar/cal-factory.h create mode 100644 calendar/cal-listener.c create mode 100644 calendar/cal-listener.h create mode 100644 calendar/cal.c create mode 100644 calendar/cal.h create mode 100644 calendar/evolution-calendar.idl create mode 100644 calendar/idl/evolution-calendar.idl create mode 100644 calendar/pcs/cal-factory.c create mode 100644 calendar/pcs/cal-factory.h create mode 100644 calendar/pcs/cal.c create mode 100644 calendar/pcs/cal.h diff --git a/calendar/ChangeLog b/calendar/ChangeLog index 6cc4fa71f1..6ba65647f6 100644 --- a/calendar/ChangeLog +++ b/calendar/ChangeLog @@ -1,3 +1,15 @@ +2000-01-11 Federico Mena Quintero + + * gnome-calendar.idl: New IDL for the personal calendar server. + + * cal.h cal.c: New files with the calendar object. + + * cal-listener.h cal-listener.c: New files with the calendar + listener object. + + * cal-factory.h cal-factory.c: New files with the calendar factory + object. + 2000-01-09 Eskil Heyn Olsen * Makefile.am: Changes to remove todo capplet stuff from distro. diff --git a/calendar/cal-client/cal-listener.c b/calendar/cal-client/cal-listener.c new file mode 100644 index 0000000000..3c6e3c57f7 --- /dev/null +++ b/calendar/cal-client/cal-listener.c @@ -0,0 +1,310 @@ +/* GNOME calendar listener + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include "cal-listener.h" + + + +/* Signal IDs */ +enum { + CAL_LOADED, + OBJ_ADDED, + OBJ_REMOVED, + OBJ_CHANGED, + LAST_SIGNAL +}; + +static void cal_listener_class_init (CalListenerClass *class); + +static POA_GNOME_Calendar_Listener__vepv cal_listener_vepv; + +static guint cal_listener_signals[LAST_SIGNAL]; + + + +/** + * cal_listener_get_type: + * @void: + * + * Registers the #CalListener class if necessary, and returns the type ID + * associated to it. + * + * Return value: The type ID of the #CalListener class. + **/ +GtkType +cal_listener_get_type (void) +{ + static GtkType cal_listener_type = 0; + + if (!cal_listener_type) { + static const GtkTypeInfo cal_listener_info = { + "CalListener", + sizeof (CalListener), + sizeof (CalListenerClass), + (GtkClassInitFunc) cal_listener_class_init, + (GtkObjectInitFunc) NULL, + NULL, /* reserved_1 */ + NULL, /* reserved_2 */ + (GtkClassInitFunc) NULL + }; + + cal_listener_type = gtk_type_unique (gnome_object_get_type (), &cal_listener_info); + } + + return cal_listener_type; +} + +/* CORBA class initialization function for the calendar listener */ +static void +init_cal_listener_corba_class (void) +{ + cal_listener_vepv.GNOME_Unknown_epv = gnome_object_get_epv (); + cal_listener_vepv.GNOME_Calendar_Listener_epv = cal_listener_get_epv (); +} + +/* Class initialization function for the calendar listener */ +static void +cal_listener_class_init (CalListenerClass *class) +{ + GtkObjectClass *object_class; + + object_class = (GtkObjectClass *) class; + + cal_listener_signals[CAL_LOADED] = + gtk_signal_new ("cal_loaded", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalListenerClass, cal_loaded), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, + GTK_TYPE_POINTER); + cal_listener_signals[OBJ_ADDED] = + gtk_signal_new ("obj_added", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalListenerClass, obj_added), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, + GTK_TYPE_POINTER); + cal_listener_signals[OBJ_REMOVED] = + gtk_signal_new ("obj_removed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalListenerClass, obj_removed), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, + GTK_TYPE_POINTER); + cal_listener_signals[OBJ_CHANGED] = + gtk_signal_new ("obj_changed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalListenerClass, obj_changed), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, + GTK_TYPE_POINTER); + + gtk_object_class_add_signals (object_class, cal_listener_signals, LAST_SIGNAL); + + init_cal_listener_corba_class (); +} + + + +/* CORBA servant implementation */ + +/* Listener::cal_loaded method */ +static void +Listener_cal_loaded (PortableServer_Servant servant, + GNOME_Calendar_Cal cal, + GNOME_Calendar_CalObj calobj, + CORBA_Environment *ev) +{ + CalListener *listener; + + listener = CAL_LISTENER (gnome_object_from_servant (servant)); + gtk_signal_emit (GTK_OBJECT (listener), cal_listener_signals[CAL_LOADED], + cal, calobj); +} + +/* Listener::obj_added method */ +static void +Listener_obj_added (PortableServer_Servant servant, + GNOME_Calendar_Cal cal, + GNOME_Calendar_CalObj calobj, + CORBA_Environment *ev) +{ + CalListener *listener; + + listener = CAL_LISTENER (gnome_object_from_servant (servant)); + gtk_signal_emit (GTK_OBJECT (listener), cal_listener_signals[OBJ_ADDED], + cal, calobj); +} + +/* Listener::obj_removed method */ +static void +Listener_obj_removed (PortableServer_Servant servant, + GNOME_Calendar_Cal cal, + GNOME_Calendar_CalObjUID uid, + CORBA_Environment *ev) +{ + CalListener *listener; + + listener = CAL_LISTENER (gnome_object_from_servant (servant)); + gtk_signal_emit (GTK_OBJECT (listener), cal_listener_signals[OBJ_REMOVED], + cal, uid); +} + +/* Listener::obj_changed method */ +static void +Listener_obj_changed (PortableServer_Servant servant, + GNOME_Calendar_Cal cal, + GNOME_Calendar_CalObj calobj, + CORBA_Environment *ev) +{ + CalListener *listener; + + listener = CAL_LISTENER (gnome_object_from_servant (servant)); + gtk_signal_emit (GTK_OBJECT (listener), cal_listener_signals[OBJ_CHANGED], + cal, calobj); +} + +/** + * cal_listener_get_epv: + * @void: + * + * Creates an EPV for the Listener CORBA class. + * + * Return value: A newly-allocated EPV. + **/ +POA_GNOME_Calendar_Listener__epv * +cal_listener_get_epv (void) +{ + POA_GNOME_Calendar_Listener__epv *epv; + + epv = g_new0 (POA_GNOME_Calendar_Listener__epv, 1); + epv->cal_loaded = Listener_cal_loaded; + epv->obj_added = Listener_obj_added; + epv->obj_removed = Listener_obj_removed; + epv->obj_changed = Listener_obj_changed; + + return epv; +} + + + +/* Returns whether a CORBA object is nil */ +static gboolean +corba_object_is_nil (CORBA_Object object) +{ + CORBA_Environment ev; + gboolean retval; + + CORBA_exception_init (&ev); + retval = CORBA_Object_is_nil (object, &ev); + CORBA_exception_free (&ev); + + return retval; +} + +/** + * cal_listener_construct: + * @listener: A calendar listener. + * @corba_listener: CORBA object for the calendar listener. + * + * Constructs a calendar listener by binding the corresponding CORBA object to + * it. + * + * Return value: the same object as the @listener argument. + **/ +CalListener * +cal_listener_construct (CalListener *listener, GNOME_Calendar_Listener corba_listener) +{ + g_return_val_if_fail (listener != NULL, NULL); + g_return_val_if_fail (IS_CAL_LISTENER (listener), NULL); + g_return_val_if_fail (!corba_object_is_nil (corba_listener), NULL); + + gnome_object_construct (GNOME_OBJECT (listener), corba_listener); + return listener; +} + +/** + * cal_listener_corba_object_create: + * @object: #GnomeObject that will wrap the CORBA object. + * + * Creates and activates the CORBA object that is wrapped by the specified + * calendar listener @object. + * + * Return value: An activated object reference or #CORBA_OBJECT_NIL in case of + * failure. + **/ +GNOME_Calendar_Listener +cal_listener_corba_object_create (GnomeObject *object) +{ + POA_GNOME_Calendar_Listener *servant; + CORBA_Environment ev; + + g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL); + g_return_val_if_fail (IS_CAL_LISTENER (object), CORBA_OBJECT_NIL); + + servant = (POA_GNOME_Calendar_Listener *) g_new0 (GnomeObjectServant, 1); + servant->vepv = &cal_listener_vepv; + + CORBA_exception_init (&ev); + POA_GNOME_Calendar_Listener__init ((PortableServer_Servant) servant, &ev); + if (ev._major != CORBA_NO_EXCEPTION) { + g_free (servant); + CORBA_exception_free (&ev); + return CORBA_OBJECT_NIL; + } + + CORBA_exception_free (&ev); + return (GNOME_Calendar_Listener) gnome_object_activate_servant (object, servant); +} + +/** + * cal_listener_new: + * @void: + * + * Creates a new #CalListener object. + * + * Return value: A newly-created #CalListener, or NULL if its corresponding + * CORBA object could not be created. + **/ +CalListener * +cal_listener_new (void) +{ + CalListener *listener; + GNOME_Calendar_Listener corba_listener; + + listener = gtk_type_new (CAL_LISTENER_TYPE); + corba_listener = cal_listener_corba_object_create (GNOME_OBJECT (listener)); + if (corba_object_is_nil (corba_listener)) { + gtk_object_destroy (listener); + return NULL; + } + + return cal_listener_construct (listener, corba_listener); +} diff --git a/calendar/cal-client/cal-listener.h b/calendar/cal-client/cal-listener.h new file mode 100644 index 0000000000..aa502f3fb3 --- /dev/null +++ b/calendar/cal-client/cal-listener.h @@ -0,0 +1,70 @@ +/* GNOME calendar listener + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef CAL_LISTENER_H +#define CAL_LISTENER_H + +#include +#include +#include "gnome-calendar.h" + +BEGIN_GNOME_DECLS + + + +#define CAL_LISTENER_TYPE (cal_listener_get_type ()) +#define CAL_LISTENER(obj) (GTK_CHECK_CAST ((obj), CAL_LISTENER_TYPE, CalListener)) +#define CAL_LISTENER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), CAL_LISTENER_TYPE, \ + CalListenerClass)) +#define IS_CAL_LISTENER(obj) (GTK_CHECK_TYPE ((obj), CAL_LISTENER_TYPE)) +#define IS_CAL_LISTENER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), CAL_LISTENER_TYPE)) + +typedef struct _CalListener CalListener; +typedef struct _CalListenerClass CalListenerClass; + +struct _CalListener { + GnomeObject object; +}; + +struct _CalListenerClass { + GnomeObjectClass parent_class; + + void (* cal_loaded) (CalListener *listener, GNOME_Calendar_Cal cal, + GNOME_Calendar_CalObj calobj); + void (* obj_added) (CalListener *listener, GNOME_Calendar_CalObj calobj); + void (* obj_removed) (CalListener *listener, GNOME_Calendar_CalObjUID uid); + void (* obj_changed) (CalListener *listener, GNOME_Calendar_CalObj calobj); +}; + +GtkType cal_listener_get_type (void); + +CalListener *cal_listener_construct (CalListener *listener, GNOME_Calendar_Listener corba_listener); +GNOME_Calendar_Listener cal_listener_corba_object_create (GnomeObject *object); + +CalListener *cal_listener_new (void); + +POA_GNOME_Calendar_Listener__epv *cal_listener_get_epv (void); + + + +END_GNOME_DECLS + +#endif diff --git a/calendar/cal-factory.c b/calendar/cal-factory.c new file mode 100644 index 0000000000..2dc1260f1b --- /dev/null +++ b/calendar/cal-factory.c @@ -0,0 +1,272 @@ +/* GNOME calendar factory + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include "cal-factory.h" + + + +/* Private part of the CalFactory structure */ +typedef struct { + /* Hash table from canonized uris to loaded calendars */ + GHashTable *calendars; +} CalFactoryPrivate; + + + +static void cal_factory_class_init (CalFactoryClass *class); +static void cal_factory_init (CalFactory *factory); +static void cal_factory_destroy (GtkObject *object); + +static POA_GNOME_Calendar_CalFactory__vepv cal_factory_vepv; + +static GnomeObjectClass *parent_class; + + + +/** + * cal_factory_get_type: + * @void: + * + * Registers the #CalFactory class if necessary, and returns the type ID + * associated to it. + * + * Return value: The type ID of the #CalFactory class. + **/ +GtkType +cal_factory_get_type (void) +{ + static GtkType cal_factory_type = 0; + + if (!cal_factory_type) { + static const GtkTypeInfo cal_factory_info = { + "CalFactory", + sizeof (CalFactory), + sizeof (CalFactoryClass), + (GtkClassInitFunc) cal_factory_class_init, + (GtkObjectInitFunc) cal_factory_init, + NULL, /* reserved_1 */ + NULL, /* reserved_2 */ + (GtkClassInitFunc) NULL + }; + + cal_factory_type = gtk_type_unique (gnome_object_get_type (), &cal_factory_info); + } + + return cal_factory_type; +} + +/* CORBA class initialization function for the calendar factory */ +static void +init_cal_factory_corba_class (void) +{ + cal_factory_vepv.GNOME_Unknown_epv = gnome_object_get_epv (); + cal_factory_vepv.GNOME_Calendar_CalFactory_epv = cal_factory_get_epv (); +} + +/* Class initialization function for the calendar factory */ +static void +cal_factory_class_init (CalFactoryClass *class) +{ + GtkObjectClass *parent_class; + + object_class = (GtkObjectClass *) class; + + parent_class = gtk_type_class (gnome_object_get_type ()); + + object_class->destroy = cal_factory_destroy; + + init_cal_factory_corba_class (); +} + +/* Object initialization function for the calendar factory */ +static void +cal_factory_init (CalFactory *factory) +{ + CalFactoryPrivate *priv; + + priv = g_new0 (CalFactoryPrivate, 1); + factory->priv = priv; + + priv->calendars = g_hash_table_new (g_str_hash, g_str_equal); +} + +/* Destroy handler for the calendar */ +static void +cal_factory_destroy (GtkObject *object) +{ + CalFactory *factory; + CalFactoryPrivate *priv; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_CAL_FACTORY (object)); + + factory = CAL_FACTORY (object); + priv = factory->priv; + + g_free (priv); + + if (GTK_OBJECT_CLASS (parent_class)->destroy) + (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); +} + + + +/* CORBA servant implementation */ + +/* CalFactory::load method */ +static void +CalFactory_load (PortableServer_Servant servant, + CORBA_char *uri, + GNOME_Calendar_Listener listener, + CORBA_Environment *ev) +{ + CalFactory *factory; + CalFactoryPrivate *priv; + + factory = CAL_FACTORY (gnome_object_from_servant (servant)); + priv = factory->priv; + + cal_factory_load (factory, uri, listener); +} + +/* CalFactory::create method */ +static GNOME_Calendar_Cal +CalFactory_create (PortableServer_Servant servant, + CORBA_char *uri, + CORBA_Environment *ev) +{ + CalFactory *factory; + CalFactoryPrivate *priv; + + factory = CAL_FACTORY (gnome_object_from_servant (servant)); + priv = factory->priv; + + return cal_factory_create (factory, uri); +} + +POA_GNOME_Calendar_CalFactory__epv * +cal_factory_get_epv (void) +{ + POA_GNOME_Calendar_CalFactory__epv *epv; + + epv = g_new0 (POA_GNOME_Calendar_CalFactory__epv, 1); + epv->load = CalFactory_load; + epv->create = CalFactory_create; + + return epv; +} + + + +/* Returns whether a CORBA object is nil */ +static gboolean +corba_object_is_nil (CORBA_Object object) +{ + CORBA_Environment ev; + gboolean retval; + + CORBA_exception_init (&ev); + retval = CORBA_Object_is_nil (object, &ev); + CORBA_exception_free (&ev); + + return retval; +} + +/** + * cal_factory_construct: + * @factory: A calendar factory. + * @corba_factory: CORBA object for the calendar factory. + * + * Constructs a calendar factory by binding the corresponding CORBA object to + * it. + * + * Return value: The same object as the @factory argument. + **/ +CalFactory * +cal_factory_construct (CalFactory *factory, GNOME_Calendar_CalFactory corba_factory) +{ + g_return_val_if_fail (factory != NULL, NULL); + g_return_val_if_fail (IS_CAL_FACTORY (factory), NULL); + g_return_val_if_fail (!corba_object_is_nil (corba_factory), NULL); + + gnome_object_construct (GNOME_OBJECT (factory), corba_factory); + return factory; +} + +/** + * cal_factory_corba_object_create: + * @object: #GnomeObject that will wrap the CORBA object. + * + * Creates and activates the CORBA object that is wrapped by the specified + * calendar factory @object. + * + * Return value: An activated object reference or #CORBA_OBJECT_NIL in case of + * failure. + **/ +GNOME_Calendar_CalFactory +cal_factory_corba_object_create (GnomeObject *object) +{ + POA_GNOME_Calendar_CalFactory *servant; + CORBA_Environment ev; + + g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL); + g_return_val_if_fail (IS_CAL_FACTORY (object), CORBA_OBJECT_NIL); + + servant = (POA_GNOME_Calendar_CalFactory *) g_new0 (GnomeObjectServant, 1); + servant->vepv = &cal_factory_vepv; + + CORBA_exception_init (&ev); + POA_GNOME_Calendar_CalFactory__init ((PortableServer_Servant) servant, &ev); + if (ev._major != CORBA_NO_EXCEPTION) { + g_free (servant); + CORBA_exception_free (&ev); + return CORBA_OBJECT_NIL; + } + + CORBA_exception_free (&ev); + return (GNOME_Calendar_CalFactory) gnome_object_activate_servant (object, servant); +} + +/** + * cal_factory_new: + * @void: + * + * Creates a new #CalFactory object. + * + * Return value: A newly-created #CalFactory, or NULL if its corresponding CORBA + * object could not be created. + **/ +CalFactory * +cal_factory_new (void) +{ + CalFactory *factory; + GNOME_Calendar_CalFactory corba_factory; + + factory = gtk_type_new (CAL_FACTORY_TYPE); + corba_factory = cal_factory_corba_object_create (GNOME_OBJECT (factory)); + if (corba_object_is_nil (corba_factory)) { + gtk_object_destroy (factory); + return NULL; + } + + return cal_factory_construct (factory, corba_factory); +} diff --git a/calendar/cal-factory.h b/calendar/cal-factory.h new file mode 100644 index 0000000000..0baa3f746a --- /dev/null +++ b/calendar/cal-factory.h @@ -0,0 +1,70 @@ +/* GNOME calendar factory + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef CAL_FACTORY_H +#define CAL_FACTORY_H + +#include +#include +#include "gnome-calendar.h" + +BEGIN_GNOME_DECLS + + + +#define CAL_FACTORY_TYPE (cal_factory_get_type ()) +#define CAL_FACTORY(obj) (GTK_CHECK_CAST ((obj), CAL_FACTORY_TYPE, CalFactory)) +#define CAL_FACTORY_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), CAL_FACTORY_TYPE, \ + CalFactoryClass)) +#define IS_CAL_FACTORY(obj) (GTK_CHECK_TYPE ((obj), CAL_FACTORY_TYPE)) +#define IS_CAL_FACTORY_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), CAL_FACTORY_TYPE)) + +typedef struct _CalFactory CalFactory; +typedef struct _CalFactoryClass CalFactoryClass; + +struct _CalFactory { + GnomeObject object; + + /* Private data */ + gpointer priv; +}; + +struct _CalFactoryClass { + GnomeObjectClass parent_class; +}; + +GtkType cal_factory_get_type (void); + +CalFactory *cal_factory_construct (CalFactory *factory, GNOME_Calendar_CalFactory corba_factory); +GNOME_Calendar_CalFactory cal_factory_corba_object_create (GnomeObject *object); + +CalFactory *cal_factory_new (void); + +void cal_factory_load (CalFactory *factory, const char *uri, GNOME_Calendar_Listener listener); +GNOME_Calendar_Cal cal_factory_create (CalFactory *factory, const char *uri); + +POA_GNOME_Calendar_CalFactory__epv *cal_factory_get_epv (void); + + + +END_GNOME_DECLS + +#endif diff --git a/calendar/cal-listener.c b/calendar/cal-listener.c new file mode 100644 index 0000000000..3c6e3c57f7 --- /dev/null +++ b/calendar/cal-listener.c @@ -0,0 +1,310 @@ +/* GNOME calendar listener + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include "cal-listener.h" + + + +/* Signal IDs */ +enum { + CAL_LOADED, + OBJ_ADDED, + OBJ_REMOVED, + OBJ_CHANGED, + LAST_SIGNAL +}; + +static void cal_listener_class_init (CalListenerClass *class); + +static POA_GNOME_Calendar_Listener__vepv cal_listener_vepv; + +static guint cal_listener_signals[LAST_SIGNAL]; + + + +/** + * cal_listener_get_type: + * @void: + * + * Registers the #CalListener class if necessary, and returns the type ID + * associated to it. + * + * Return value: The type ID of the #CalListener class. + **/ +GtkType +cal_listener_get_type (void) +{ + static GtkType cal_listener_type = 0; + + if (!cal_listener_type) { + static const GtkTypeInfo cal_listener_info = { + "CalListener", + sizeof (CalListener), + sizeof (CalListenerClass), + (GtkClassInitFunc) cal_listener_class_init, + (GtkObjectInitFunc) NULL, + NULL, /* reserved_1 */ + NULL, /* reserved_2 */ + (GtkClassInitFunc) NULL + }; + + cal_listener_type = gtk_type_unique (gnome_object_get_type (), &cal_listener_info); + } + + return cal_listener_type; +} + +/* CORBA class initialization function for the calendar listener */ +static void +init_cal_listener_corba_class (void) +{ + cal_listener_vepv.GNOME_Unknown_epv = gnome_object_get_epv (); + cal_listener_vepv.GNOME_Calendar_Listener_epv = cal_listener_get_epv (); +} + +/* Class initialization function for the calendar listener */ +static void +cal_listener_class_init (CalListenerClass *class) +{ + GtkObjectClass *object_class; + + object_class = (GtkObjectClass *) class; + + cal_listener_signals[CAL_LOADED] = + gtk_signal_new ("cal_loaded", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalListenerClass, cal_loaded), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, + GTK_TYPE_POINTER); + cal_listener_signals[OBJ_ADDED] = + gtk_signal_new ("obj_added", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalListenerClass, obj_added), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, + GTK_TYPE_POINTER); + cal_listener_signals[OBJ_REMOVED] = + gtk_signal_new ("obj_removed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalListenerClass, obj_removed), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, + GTK_TYPE_POINTER); + cal_listener_signals[OBJ_CHANGED] = + gtk_signal_new ("obj_changed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalListenerClass, obj_changed), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, + GTK_TYPE_POINTER); + + gtk_object_class_add_signals (object_class, cal_listener_signals, LAST_SIGNAL); + + init_cal_listener_corba_class (); +} + + + +/* CORBA servant implementation */ + +/* Listener::cal_loaded method */ +static void +Listener_cal_loaded (PortableServer_Servant servant, + GNOME_Calendar_Cal cal, + GNOME_Calendar_CalObj calobj, + CORBA_Environment *ev) +{ + CalListener *listener; + + listener = CAL_LISTENER (gnome_object_from_servant (servant)); + gtk_signal_emit (GTK_OBJECT (listener), cal_listener_signals[CAL_LOADED], + cal, calobj); +} + +/* Listener::obj_added method */ +static void +Listener_obj_added (PortableServer_Servant servant, + GNOME_Calendar_Cal cal, + GNOME_Calendar_CalObj calobj, + CORBA_Environment *ev) +{ + CalListener *listener; + + listener = CAL_LISTENER (gnome_object_from_servant (servant)); + gtk_signal_emit (GTK_OBJECT (listener), cal_listener_signals[OBJ_ADDED], + cal, calobj); +} + +/* Listener::obj_removed method */ +static void +Listener_obj_removed (PortableServer_Servant servant, + GNOME_Calendar_Cal cal, + GNOME_Calendar_CalObjUID uid, + CORBA_Environment *ev) +{ + CalListener *listener; + + listener = CAL_LISTENER (gnome_object_from_servant (servant)); + gtk_signal_emit (GTK_OBJECT (listener), cal_listener_signals[OBJ_REMOVED], + cal, uid); +} + +/* Listener::obj_changed method */ +static void +Listener_obj_changed (PortableServer_Servant servant, + GNOME_Calendar_Cal cal, + GNOME_Calendar_CalObj calobj, + CORBA_Environment *ev) +{ + CalListener *listener; + + listener = CAL_LISTENER (gnome_object_from_servant (servant)); + gtk_signal_emit (GTK_OBJECT (listener), cal_listener_signals[OBJ_CHANGED], + cal, calobj); +} + +/** + * cal_listener_get_epv: + * @void: + * + * Creates an EPV for the Listener CORBA class. + * + * Return value: A newly-allocated EPV. + **/ +POA_GNOME_Calendar_Listener__epv * +cal_listener_get_epv (void) +{ + POA_GNOME_Calendar_Listener__epv *epv; + + epv = g_new0 (POA_GNOME_Calendar_Listener__epv, 1); + epv->cal_loaded = Listener_cal_loaded; + epv->obj_added = Listener_obj_added; + epv->obj_removed = Listener_obj_removed; + epv->obj_changed = Listener_obj_changed; + + return epv; +} + + + +/* Returns whether a CORBA object is nil */ +static gboolean +corba_object_is_nil (CORBA_Object object) +{ + CORBA_Environment ev; + gboolean retval; + + CORBA_exception_init (&ev); + retval = CORBA_Object_is_nil (object, &ev); + CORBA_exception_free (&ev); + + return retval; +} + +/** + * cal_listener_construct: + * @listener: A calendar listener. + * @corba_listener: CORBA object for the calendar listener. + * + * Constructs a calendar listener by binding the corresponding CORBA object to + * it. + * + * Return value: the same object as the @listener argument. + **/ +CalListener * +cal_listener_construct (CalListener *listener, GNOME_Calendar_Listener corba_listener) +{ + g_return_val_if_fail (listener != NULL, NULL); + g_return_val_if_fail (IS_CAL_LISTENER (listener), NULL); + g_return_val_if_fail (!corba_object_is_nil (corba_listener), NULL); + + gnome_object_construct (GNOME_OBJECT (listener), corba_listener); + return listener; +} + +/** + * cal_listener_corba_object_create: + * @object: #GnomeObject that will wrap the CORBA object. + * + * Creates and activates the CORBA object that is wrapped by the specified + * calendar listener @object. + * + * Return value: An activated object reference or #CORBA_OBJECT_NIL in case of + * failure. + **/ +GNOME_Calendar_Listener +cal_listener_corba_object_create (GnomeObject *object) +{ + POA_GNOME_Calendar_Listener *servant; + CORBA_Environment ev; + + g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL); + g_return_val_if_fail (IS_CAL_LISTENER (object), CORBA_OBJECT_NIL); + + servant = (POA_GNOME_Calendar_Listener *) g_new0 (GnomeObjectServant, 1); + servant->vepv = &cal_listener_vepv; + + CORBA_exception_init (&ev); + POA_GNOME_Calendar_Listener__init ((PortableServer_Servant) servant, &ev); + if (ev._major != CORBA_NO_EXCEPTION) { + g_free (servant); + CORBA_exception_free (&ev); + return CORBA_OBJECT_NIL; + } + + CORBA_exception_free (&ev); + return (GNOME_Calendar_Listener) gnome_object_activate_servant (object, servant); +} + +/** + * cal_listener_new: + * @void: + * + * Creates a new #CalListener object. + * + * Return value: A newly-created #CalListener, or NULL if its corresponding + * CORBA object could not be created. + **/ +CalListener * +cal_listener_new (void) +{ + CalListener *listener; + GNOME_Calendar_Listener corba_listener; + + listener = gtk_type_new (CAL_LISTENER_TYPE); + corba_listener = cal_listener_corba_object_create (GNOME_OBJECT (listener)); + if (corba_object_is_nil (corba_listener)) { + gtk_object_destroy (listener); + return NULL; + } + + return cal_listener_construct (listener, corba_listener); +} diff --git a/calendar/cal-listener.h b/calendar/cal-listener.h new file mode 100644 index 0000000000..aa502f3fb3 --- /dev/null +++ b/calendar/cal-listener.h @@ -0,0 +1,70 @@ +/* GNOME calendar listener + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef CAL_LISTENER_H +#define CAL_LISTENER_H + +#include +#include +#include "gnome-calendar.h" + +BEGIN_GNOME_DECLS + + + +#define CAL_LISTENER_TYPE (cal_listener_get_type ()) +#define CAL_LISTENER(obj) (GTK_CHECK_CAST ((obj), CAL_LISTENER_TYPE, CalListener)) +#define CAL_LISTENER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), CAL_LISTENER_TYPE, \ + CalListenerClass)) +#define IS_CAL_LISTENER(obj) (GTK_CHECK_TYPE ((obj), CAL_LISTENER_TYPE)) +#define IS_CAL_LISTENER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), CAL_LISTENER_TYPE)) + +typedef struct _CalListener CalListener; +typedef struct _CalListenerClass CalListenerClass; + +struct _CalListener { + GnomeObject object; +}; + +struct _CalListenerClass { + GnomeObjectClass parent_class; + + void (* cal_loaded) (CalListener *listener, GNOME_Calendar_Cal cal, + GNOME_Calendar_CalObj calobj); + void (* obj_added) (CalListener *listener, GNOME_Calendar_CalObj calobj); + void (* obj_removed) (CalListener *listener, GNOME_Calendar_CalObjUID uid); + void (* obj_changed) (CalListener *listener, GNOME_Calendar_CalObj calobj); +}; + +GtkType cal_listener_get_type (void); + +CalListener *cal_listener_construct (CalListener *listener, GNOME_Calendar_Listener corba_listener); +GNOME_Calendar_Listener cal_listener_corba_object_create (GnomeObject *object); + +CalListener *cal_listener_new (void); + +POA_GNOME_Calendar_Listener__epv *cal_listener_get_epv (void); + + + +END_GNOME_DECLS + +#endif diff --git a/calendar/cal.c b/calendar/cal.c new file mode 100644 index 0000000000..44b9361398 --- /dev/null +++ b/calendar/cal.c @@ -0,0 +1,343 @@ +/* GNOME calendar object + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include "cal.h" + + + +/* Private part of the Cal structure */ +typedef struct { + /* The URI where this calendar is stored */ + char *uri; + + /* List of listeners for this calendar */ + GList *listeners; +} CalPrivate; + + + +static void cal_class_init (CalClass *class); +static void cal_init (Cal *cal); +static void cal_destroy (GtkObject *object); + +static POA_GNOME_Calendar_Cal__vepv cal_vepv; + +static GnomeObjectClass *parent_class; + + + +/** + * cal_get_type: + * @void: + * + * Registers the #Cal class if necessary, and returns the type ID associated to + * it. + * + * Return value: The type ID of the #Cal class. + **/ +GtkType +cal_get_type (void) +{ + static GtkType cal_type = 0; + + if (!cal_type) { + static const GtkTypeInfo cal_info = { + "Cal", + sizeof (Cal), + sizeof (CalClass), + (GtkClassInitFunc) cal_class_init, + (GtkObjectInitFunc) cal_init, + NULL, /* reserved_1 */ + NULL, /* reserved_2 */ + (GtkClassInitFunc) NULL + }; + + cal_type = gtk_type_unique (gnome_object_get_type (), &cal_info); + } + + return cal_type; +} + +/* CORBA class initialzation function for the calendar */ +static void +init_cal_corba_class (void) +{ + cal_vepv.GNOME_Unknown_epv = gnome_object_get_epv (); + cal_vepv.GNOME_Calendar_Cal_epv = cal_get_epv (); +} + +/* Class initialization function for the calendar */ +static void +cal_class_init (CalClass *class) +{ + GtkObjectClass *object_class; + + object_class = (GtkObjectClass *) class; + + parent_class = gtk_type_class (gnome_object_get_type ()); + + object_class->destroy = cal_destroy; + + init_cal_corba_class (); +} + +/* Object initialization function for the calendar */ +static void +cal_init (Cal *cal) +{ + CalPrivate *priv; + + priv = g_new0 (CalPrivate, 1); + cal->priv = priv; +} + +/* Destroy handler for the calendar */ +static void +cal_destroy (GtkObject *object) +{ + Cal *cal; + CalPrivate *priv; + GList *l; + CORBA_Environment *ev; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_CAL (object)); + + cal = CAL (object); + priv = cal->priv; + + if (priv->uri) + g_free (priv->uri); + + CORBA_exception_init (&ev); + + for (l = priv->listeners; l; l = l->next) + CORBA_Object_release (l->data, &ev); + + g_list_free (priv->listeners); + + g_free (priv); + + if (GTK_OBJECT_CLASS (parent_class)->destroy) + (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); +} + + + + +/* CORBA servant implementation */ + +/* Cal::get_uri method */ +static CORBA_char * +Cal_get_uri (PortableServer_Servant servant, + CORBA_Environment *ev) +{ + Cal *cal; + CalPrivate *priv; + + cal = CAL (gnome_object_from_servant (servant)); + priv = cal->priv; + + return CORBA_string_dup (priv->uri); +} + +/* Cal::add_listener method */ +static void +Cal_add_listener (PortableServer_Servant servant, + GNOME_Calendar_Listener listener, + CORBA_Environment *ev) +{ + Cal *cal; + + cal = CAL (gnome_object_from_servant (servant)); + cal_add_listener (cal, listener); +} + +/* Cal::remove_listener method */ +static void +Cal_remove_listener (PortableServer_Servant servant, + GNOME_Calendar_Listener listener, + CORBA_Environment *ev) +{ + Cal *cal; + + cal = CAL (gnome_object_from_servant (servant)); + cal_remove_listener (cal, listener); +} + +/** + * cal_get_epv: + * @void: + * + * Creates an EPV for the Cal CORBA class. + * + * Return value: A newly-allocated EPV. + **/ +POA_GNOME_Calendar_Cal__epv * +cal_get_epv (void) +{ + POA_GNOME_Calendar_Cal__epv *epv; + + epv = g_new0 (POA_GNOME_Calendar_Cal__epv, 1); + epv->get_uri = Cal_get_uri; + epv->add_listener = Cal_add_listener; + epv->remove_listener = Cal_remove_listener; + + return epv; +} + + + +/* Returns whether a CORBA object is nil */ +static gboolean +corba_object_is_nil (CORBA_Object object) +{ + CORBA_Environment ev; + gboolean retval; + + CORBA_exception_init (&ev); + retval = CORBA_Object_is_nil (object, &ev); + CORBA_exception_free (&ev); + + return retval; +} + +/** + * cal_construct: + * @cal: A calendar. + * @corba_cal: CORBA object for the calendar. + * + * Constructs a calendar by binding the corresponding CORBA object to it. + * + * Return value: The same object as the @cal argument. + **/ +Cal * +cal_construct (Cal *cal, GNOME_Calendar_Cal corba_cal) +{ + g_return_val_if_fail (cal != NULL, NULL); + g_return_val_if_fail (IS_CAL (cal), NULL); + g_return_val_if_fail (!corba_object_is_nil (corba_cal), NULL); + + gnome_object_construct (GNOME_OBJECT (cal), corba_cal); + return cal; +} + +/** + * cal_corba_object_create: + * @object: #GnomeObject that will wrap the CORBA object. + * + * Creates and activates the CORBA object that is wrapped by the specified + * calendar @object. + * + * Return value: An activated object reference or #CORBA_OBJECT_NIL in case of + * failure. + **/ +GNOME_Calendar_Cal +cal_corba_object_create (GnomeObject *object) +{ + POA_GNOME_Calendar_Cal *servant; + CORBA_Environment ev; + + g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL); + g_return_val_if_fail (IS_CAL (object), CORBA_OBJECT_NIL); + + servant = (POA_GNOME_Calendar_Cal *) g_new0 (GnomeObjectServant, 1); + servant->vepv = &cal_vepv; + + CORBA_exception_init (&ev); + POA_GNOME_Calendar_Cal__init ((PortableServer_Servant) servant, &ev); + if (ev._major != CORBA_NO_EXCEPTION) { + g_free (servant); + CORBA_exception_free (&ev); + return CORBA_OBJECT_NIL; + } + + CORBA_exception_free (&ev); + return (GNOME_Calendar_Cal) gnome_object_activate_servant (object, servant); +} + +/** + * cal_add_listener: + * @cal: A calendar. + * @listener: A listener. + * + * Adds a listener for changes to a calendar. The specified listener object + * will be used for notification when objects are added, removed, or changed in + * the calendar. + **/ +void +cal_add_listener (Cal *cal, GNOME_Calendar_Listener listener) +{ + CalPrivate *priv; + CORBA_Environment ev; + + g_return_if_fail (cal != NULL); + g_return_if_fail (IS_CAL (cal)); + g_return_if_fail (!corba_object_is_nil (listener)); + + priv = cal->priv; + + CORBA_exception_init (&ev); + + GNOME_Unknown_ref (listener, &ev); + priv->listeners = g_list_prepend (priv->listeners, CORBA_Object_duplicate (listener, &ev)); + + CORBA_exception_free (&ev); +} + +/** + * cal_remove_listener: + * @cal: A calendar. + * @listener: A listener. + * + * Removes a listener from a calendar so that no more notification events will + * be sent to the listener. + **/ +void +cal_remove_listener (Cal *cal, GNOME_Calendar_Listener listener) +{ + CalPrivate *priv; + CORBA_Environment ev; + GList *l; + + g_return_if_fail (cal != NULL); + g_return_if_fail (IS_CAL (cal)); + + priv = cal->priv; + + CORBA_exception_init (&ev); + + /* FIXME: CORBA_Object_is_equivalent() is not what one thinks. This + * code could fail in situtations subtle enough that I don't understand + * them. Someone has to figure out the standard CORBA idiom for + * listeners or notification. + */ + for (l = priv->listeners; l; l = l->next) + if (CORBA_Object_is_equivalent (listener, l->data)) { + GNOME_Unknown_unref (listener, &ev); + priv->listeners = g_list_remove_link (priv->listeners, l); + g_list_free_1 (l); + break; + } + + CORBA_exception_free (&ev); +} diff --git a/calendar/cal.h b/calendar/cal.h new file mode 100644 index 0000000000..959331595c --- /dev/null +++ b/calendar/cal.h @@ -0,0 +1,70 @@ +/* GNOME calendar object + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef CAL_H +#define CAL_H + +#include +#include +#include "gnome-calendar.h" + +BEGIN_GNOME_DECLS + + + +#define CAL_TYPE (cal_get_type ()) +#define CAL(obj) (GTK_CHECK_CAST ((obj), CAL_TYPE, Cal)) +#define CAL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), CAL_TYPE, CalClass)) +#define IS_CAL(obj) (GTK_CHECK_TYPE ((obj), CAL_TYPE)) +#define IS_CAL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), CAL_TYPE)) + +typedef struct _Cal Cal; +typedef struct _CalClass CalClass; + +struct _Cal { + GnomeObject object; + + /* Private data */ + gpointer priv; +}; + +struct _CalClass { + GnomeObjectClass parent_class; +}; + +GtkType cal_get_type (void); + +Cal *cal_construct (Cal *cal, GNOME_Calendar_Cal corba_cal); +GNOME_Calendar_Cal cal_corba_object_create (GnomeObject *object); + +Cal *cal_new (char *uri); +Cal *cal_new_from_file (char *uri); + +void cal_add_listener (Cal *cal, GNOME_Calendar_Listener listener); +void cal_remove_listener (Cal *cal, GNOME_Calendar_Listener listener); + +POA_GNOME_Calendar_Cal__epv *cal_get_epv (void); + + + +END_GNOME_DECLS + +#endif diff --git a/calendar/evolution-calendar.idl b/calendar/evolution-calendar.idl new file mode 100644 index 0000000000..6357a014d0 --- /dev/null +++ b/calendar/evolution-calendar.idl @@ -0,0 +1,63 @@ +/* GNOME calendar interfaces + * + * Copyright (C) 2000 Eskil Heyn Olsen + * Copyright (C) 2000 Helix Code, Inc. + * + * Authors: Eskil Heyn Olsen + * Federico Mena-Quintero + */ + +#ifndef _GNOME_CALENDAR_IDL_ +#define _GNOME_CALENDAR_IDL_ + +#include + +module GNOME { + +module Calendar { + /* A calendar object (event/todo/journal/etc), represented as an + * iCalendar string. + */ + typedef string CalObj; + + /* An unique identifier for a calendar object */ + typedef string CalObjUID; + + interface Listener; + + /* A calendar handle */ + interface Cal : Unknown { + /* A calendar is identified by its URI */ + readonly attribute string uri; + }; + + /* Listener for changes in a calendar */ + interface Listener : Unknown { + /* Called from a CalFactory when a calendar is initially loaded + * or created. The listener must remember the cal object. + */ + void cal_loaded (in Cal cal, in CalObj calobj); + + /* Called from a Calendar when an object is added */ + void obj_added (in CalObj calobj); + + /* Called from a Calendar when an object is removed */ + void obj_removed (in CalObjUID uid); + + /* Called from a Calendar when an object is changed */ + void obj_changed (in CalObj calobj); + }; + + /* A calendar factory, can load and create calendars */ + interface CalFactory : Unknown { + /* Load a calendar from an URI */ + void load (in string uri, in Listener listener); + + /* Create a new calendar at the specified URI */ + void create (in string uri, in Listener listener); + }; +}; + +}; + +#endif diff --git a/calendar/idl/evolution-calendar.idl b/calendar/idl/evolution-calendar.idl new file mode 100644 index 0000000000..6357a014d0 --- /dev/null +++ b/calendar/idl/evolution-calendar.idl @@ -0,0 +1,63 @@ +/* GNOME calendar interfaces + * + * Copyright (C) 2000 Eskil Heyn Olsen + * Copyright (C) 2000 Helix Code, Inc. + * + * Authors: Eskil Heyn Olsen + * Federico Mena-Quintero + */ + +#ifndef _GNOME_CALENDAR_IDL_ +#define _GNOME_CALENDAR_IDL_ + +#include + +module GNOME { + +module Calendar { + /* A calendar object (event/todo/journal/etc), represented as an + * iCalendar string. + */ + typedef string CalObj; + + /* An unique identifier for a calendar object */ + typedef string CalObjUID; + + interface Listener; + + /* A calendar handle */ + interface Cal : Unknown { + /* A calendar is identified by its URI */ + readonly attribute string uri; + }; + + /* Listener for changes in a calendar */ + interface Listener : Unknown { + /* Called from a CalFactory when a calendar is initially loaded + * or created. The listener must remember the cal object. + */ + void cal_loaded (in Cal cal, in CalObj calobj); + + /* Called from a Calendar when an object is added */ + void obj_added (in CalObj calobj); + + /* Called from a Calendar when an object is removed */ + void obj_removed (in CalObjUID uid); + + /* Called from a Calendar when an object is changed */ + void obj_changed (in CalObj calobj); + }; + + /* A calendar factory, can load and create calendars */ + interface CalFactory : Unknown { + /* Load a calendar from an URI */ + void load (in string uri, in Listener listener); + + /* Create a new calendar at the specified URI */ + void create (in string uri, in Listener listener); + }; +}; + +}; + +#endif diff --git a/calendar/pcs/cal-factory.c b/calendar/pcs/cal-factory.c new file mode 100644 index 0000000000..2dc1260f1b --- /dev/null +++ b/calendar/pcs/cal-factory.c @@ -0,0 +1,272 @@ +/* GNOME calendar factory + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include "cal-factory.h" + + + +/* Private part of the CalFactory structure */ +typedef struct { + /* Hash table from canonized uris to loaded calendars */ + GHashTable *calendars; +} CalFactoryPrivate; + + + +static void cal_factory_class_init (CalFactoryClass *class); +static void cal_factory_init (CalFactory *factory); +static void cal_factory_destroy (GtkObject *object); + +static POA_GNOME_Calendar_CalFactory__vepv cal_factory_vepv; + +static GnomeObjectClass *parent_class; + + + +/** + * cal_factory_get_type: + * @void: + * + * Registers the #CalFactory class if necessary, and returns the type ID + * associated to it. + * + * Return value: The type ID of the #CalFactory class. + **/ +GtkType +cal_factory_get_type (void) +{ + static GtkType cal_factory_type = 0; + + if (!cal_factory_type) { + static const GtkTypeInfo cal_factory_info = { + "CalFactory", + sizeof (CalFactory), + sizeof (CalFactoryClass), + (GtkClassInitFunc) cal_factory_class_init, + (GtkObjectInitFunc) cal_factory_init, + NULL, /* reserved_1 */ + NULL, /* reserved_2 */ + (GtkClassInitFunc) NULL + }; + + cal_factory_type = gtk_type_unique (gnome_object_get_type (), &cal_factory_info); + } + + return cal_factory_type; +} + +/* CORBA class initialization function for the calendar factory */ +static void +init_cal_factory_corba_class (void) +{ + cal_factory_vepv.GNOME_Unknown_epv = gnome_object_get_epv (); + cal_factory_vepv.GNOME_Calendar_CalFactory_epv = cal_factory_get_epv (); +} + +/* Class initialization function for the calendar factory */ +static void +cal_factory_class_init (CalFactoryClass *class) +{ + GtkObjectClass *parent_class; + + object_class = (GtkObjectClass *) class; + + parent_class = gtk_type_class (gnome_object_get_type ()); + + object_class->destroy = cal_factory_destroy; + + init_cal_factory_corba_class (); +} + +/* Object initialization function for the calendar factory */ +static void +cal_factory_init (CalFactory *factory) +{ + CalFactoryPrivate *priv; + + priv = g_new0 (CalFactoryPrivate, 1); + factory->priv = priv; + + priv->calendars = g_hash_table_new (g_str_hash, g_str_equal); +} + +/* Destroy handler for the calendar */ +static void +cal_factory_destroy (GtkObject *object) +{ + CalFactory *factory; + CalFactoryPrivate *priv; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_CAL_FACTORY (object)); + + factory = CAL_FACTORY (object); + priv = factory->priv; + + g_free (priv); + + if (GTK_OBJECT_CLASS (parent_class)->destroy) + (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); +} + + + +/* CORBA servant implementation */ + +/* CalFactory::load method */ +static void +CalFactory_load (PortableServer_Servant servant, + CORBA_char *uri, + GNOME_Calendar_Listener listener, + CORBA_Environment *ev) +{ + CalFactory *factory; + CalFactoryPrivate *priv; + + factory = CAL_FACTORY (gnome_object_from_servant (servant)); + priv = factory->priv; + + cal_factory_load (factory, uri, listener); +} + +/* CalFactory::create method */ +static GNOME_Calendar_Cal +CalFactory_create (PortableServer_Servant servant, + CORBA_char *uri, + CORBA_Environment *ev) +{ + CalFactory *factory; + CalFactoryPrivate *priv; + + factory = CAL_FACTORY (gnome_object_from_servant (servant)); + priv = factory->priv; + + return cal_factory_create (factory, uri); +} + +POA_GNOME_Calendar_CalFactory__epv * +cal_factory_get_epv (void) +{ + POA_GNOME_Calendar_CalFactory__epv *epv; + + epv = g_new0 (POA_GNOME_Calendar_CalFactory__epv, 1); + epv->load = CalFactory_load; + epv->create = CalFactory_create; + + return epv; +} + + + +/* Returns whether a CORBA object is nil */ +static gboolean +corba_object_is_nil (CORBA_Object object) +{ + CORBA_Environment ev; + gboolean retval; + + CORBA_exception_init (&ev); + retval = CORBA_Object_is_nil (object, &ev); + CORBA_exception_free (&ev); + + return retval; +} + +/** + * cal_factory_construct: + * @factory: A calendar factory. + * @corba_factory: CORBA object for the calendar factory. + * + * Constructs a calendar factory by binding the corresponding CORBA object to + * it. + * + * Return value: The same object as the @factory argument. + **/ +CalFactory * +cal_factory_construct (CalFactory *factory, GNOME_Calendar_CalFactory corba_factory) +{ + g_return_val_if_fail (factory != NULL, NULL); + g_return_val_if_fail (IS_CAL_FACTORY (factory), NULL); + g_return_val_if_fail (!corba_object_is_nil (corba_factory), NULL); + + gnome_object_construct (GNOME_OBJECT (factory), corba_factory); + return factory; +} + +/** + * cal_factory_corba_object_create: + * @object: #GnomeObject that will wrap the CORBA object. + * + * Creates and activates the CORBA object that is wrapped by the specified + * calendar factory @object. + * + * Return value: An activated object reference or #CORBA_OBJECT_NIL in case of + * failure. + **/ +GNOME_Calendar_CalFactory +cal_factory_corba_object_create (GnomeObject *object) +{ + POA_GNOME_Calendar_CalFactory *servant; + CORBA_Environment ev; + + g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL); + g_return_val_if_fail (IS_CAL_FACTORY (object), CORBA_OBJECT_NIL); + + servant = (POA_GNOME_Calendar_CalFactory *) g_new0 (GnomeObjectServant, 1); + servant->vepv = &cal_factory_vepv; + + CORBA_exception_init (&ev); + POA_GNOME_Calendar_CalFactory__init ((PortableServer_Servant) servant, &ev); + if (ev._major != CORBA_NO_EXCEPTION) { + g_free (servant); + CORBA_exception_free (&ev); + return CORBA_OBJECT_NIL; + } + + CORBA_exception_free (&ev); + return (GNOME_Calendar_CalFactory) gnome_object_activate_servant (object, servant); +} + +/** + * cal_factory_new: + * @void: + * + * Creates a new #CalFactory object. + * + * Return value: A newly-created #CalFactory, or NULL if its corresponding CORBA + * object could not be created. + **/ +CalFactory * +cal_factory_new (void) +{ + CalFactory *factory; + GNOME_Calendar_CalFactory corba_factory; + + factory = gtk_type_new (CAL_FACTORY_TYPE); + corba_factory = cal_factory_corba_object_create (GNOME_OBJECT (factory)); + if (corba_object_is_nil (corba_factory)) { + gtk_object_destroy (factory); + return NULL; + } + + return cal_factory_construct (factory, corba_factory); +} diff --git a/calendar/pcs/cal-factory.h b/calendar/pcs/cal-factory.h new file mode 100644 index 0000000000..0baa3f746a --- /dev/null +++ b/calendar/pcs/cal-factory.h @@ -0,0 +1,70 @@ +/* GNOME calendar factory + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef CAL_FACTORY_H +#define CAL_FACTORY_H + +#include +#include +#include "gnome-calendar.h" + +BEGIN_GNOME_DECLS + + + +#define CAL_FACTORY_TYPE (cal_factory_get_type ()) +#define CAL_FACTORY(obj) (GTK_CHECK_CAST ((obj), CAL_FACTORY_TYPE, CalFactory)) +#define CAL_FACTORY_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), CAL_FACTORY_TYPE, \ + CalFactoryClass)) +#define IS_CAL_FACTORY(obj) (GTK_CHECK_TYPE ((obj), CAL_FACTORY_TYPE)) +#define IS_CAL_FACTORY_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), CAL_FACTORY_TYPE)) + +typedef struct _CalFactory CalFactory; +typedef struct _CalFactoryClass CalFactoryClass; + +struct _CalFactory { + GnomeObject object; + + /* Private data */ + gpointer priv; +}; + +struct _CalFactoryClass { + GnomeObjectClass parent_class; +}; + +GtkType cal_factory_get_type (void); + +CalFactory *cal_factory_construct (CalFactory *factory, GNOME_Calendar_CalFactory corba_factory); +GNOME_Calendar_CalFactory cal_factory_corba_object_create (GnomeObject *object); + +CalFactory *cal_factory_new (void); + +void cal_factory_load (CalFactory *factory, const char *uri, GNOME_Calendar_Listener listener); +GNOME_Calendar_Cal cal_factory_create (CalFactory *factory, const char *uri); + +POA_GNOME_Calendar_CalFactory__epv *cal_factory_get_epv (void); + + + +END_GNOME_DECLS + +#endif diff --git a/calendar/pcs/cal.c b/calendar/pcs/cal.c new file mode 100644 index 0000000000..44b9361398 --- /dev/null +++ b/calendar/pcs/cal.c @@ -0,0 +1,343 @@ +/* GNOME calendar object + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include "cal.h" + + + +/* Private part of the Cal structure */ +typedef struct { + /* The URI where this calendar is stored */ + char *uri; + + /* List of listeners for this calendar */ + GList *listeners; +} CalPrivate; + + + +static void cal_class_init (CalClass *class); +static void cal_init (Cal *cal); +static void cal_destroy (GtkObject *object); + +static POA_GNOME_Calendar_Cal__vepv cal_vepv; + +static GnomeObjectClass *parent_class; + + + +/** + * cal_get_type: + * @void: + * + * Registers the #Cal class if necessary, and returns the type ID associated to + * it. + * + * Return value: The type ID of the #Cal class. + **/ +GtkType +cal_get_type (void) +{ + static GtkType cal_type = 0; + + if (!cal_type) { + static const GtkTypeInfo cal_info = { + "Cal", + sizeof (Cal), + sizeof (CalClass), + (GtkClassInitFunc) cal_class_init, + (GtkObjectInitFunc) cal_init, + NULL, /* reserved_1 */ + NULL, /* reserved_2 */ + (GtkClassInitFunc) NULL + }; + + cal_type = gtk_type_unique (gnome_object_get_type (), &cal_info); + } + + return cal_type; +} + +/* CORBA class initialzation function for the calendar */ +static void +init_cal_corba_class (void) +{ + cal_vepv.GNOME_Unknown_epv = gnome_object_get_epv (); + cal_vepv.GNOME_Calendar_Cal_epv = cal_get_epv (); +} + +/* Class initialization function for the calendar */ +static void +cal_class_init (CalClass *class) +{ + GtkObjectClass *object_class; + + object_class = (GtkObjectClass *) class; + + parent_class = gtk_type_class (gnome_object_get_type ()); + + object_class->destroy = cal_destroy; + + init_cal_corba_class (); +} + +/* Object initialization function for the calendar */ +static void +cal_init (Cal *cal) +{ + CalPrivate *priv; + + priv = g_new0 (CalPrivate, 1); + cal->priv = priv; +} + +/* Destroy handler for the calendar */ +static void +cal_destroy (GtkObject *object) +{ + Cal *cal; + CalPrivate *priv; + GList *l; + CORBA_Environment *ev; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_CAL (object)); + + cal = CAL (object); + priv = cal->priv; + + if (priv->uri) + g_free (priv->uri); + + CORBA_exception_init (&ev); + + for (l = priv->listeners; l; l = l->next) + CORBA_Object_release (l->data, &ev); + + g_list_free (priv->listeners); + + g_free (priv); + + if (GTK_OBJECT_CLASS (parent_class)->destroy) + (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); +} + + + + +/* CORBA servant implementation */ + +/* Cal::get_uri method */ +static CORBA_char * +Cal_get_uri (PortableServer_Servant servant, + CORBA_Environment *ev) +{ + Cal *cal; + CalPrivate *priv; + + cal = CAL (gnome_object_from_servant (servant)); + priv = cal->priv; + + return CORBA_string_dup (priv->uri); +} + +/* Cal::add_listener method */ +static void +Cal_add_listener (PortableServer_Servant servant, + GNOME_Calendar_Listener listener, + CORBA_Environment *ev) +{ + Cal *cal; + + cal = CAL (gnome_object_from_servant (servant)); + cal_add_listener (cal, listener); +} + +/* Cal::remove_listener method */ +static void +Cal_remove_listener (PortableServer_Servant servant, + GNOME_Calendar_Listener listener, + CORBA_Environment *ev) +{ + Cal *cal; + + cal = CAL (gnome_object_from_servant (servant)); + cal_remove_listener (cal, listener); +} + +/** + * cal_get_epv: + * @void: + * + * Creates an EPV for the Cal CORBA class. + * + * Return value: A newly-allocated EPV. + **/ +POA_GNOME_Calendar_Cal__epv * +cal_get_epv (void) +{ + POA_GNOME_Calendar_Cal__epv *epv; + + epv = g_new0 (POA_GNOME_Calendar_Cal__epv, 1); + epv->get_uri = Cal_get_uri; + epv->add_listener = Cal_add_listener; + epv->remove_listener = Cal_remove_listener; + + return epv; +} + + + +/* Returns whether a CORBA object is nil */ +static gboolean +corba_object_is_nil (CORBA_Object object) +{ + CORBA_Environment ev; + gboolean retval; + + CORBA_exception_init (&ev); + retval = CORBA_Object_is_nil (object, &ev); + CORBA_exception_free (&ev); + + return retval; +} + +/** + * cal_construct: + * @cal: A calendar. + * @corba_cal: CORBA object for the calendar. + * + * Constructs a calendar by binding the corresponding CORBA object to it. + * + * Return value: The same object as the @cal argument. + **/ +Cal * +cal_construct (Cal *cal, GNOME_Calendar_Cal corba_cal) +{ + g_return_val_if_fail (cal != NULL, NULL); + g_return_val_if_fail (IS_CAL (cal), NULL); + g_return_val_if_fail (!corba_object_is_nil (corba_cal), NULL); + + gnome_object_construct (GNOME_OBJECT (cal), corba_cal); + return cal; +} + +/** + * cal_corba_object_create: + * @object: #GnomeObject that will wrap the CORBA object. + * + * Creates and activates the CORBA object that is wrapped by the specified + * calendar @object. + * + * Return value: An activated object reference or #CORBA_OBJECT_NIL in case of + * failure. + **/ +GNOME_Calendar_Cal +cal_corba_object_create (GnomeObject *object) +{ + POA_GNOME_Calendar_Cal *servant; + CORBA_Environment ev; + + g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL); + g_return_val_if_fail (IS_CAL (object), CORBA_OBJECT_NIL); + + servant = (POA_GNOME_Calendar_Cal *) g_new0 (GnomeObjectServant, 1); + servant->vepv = &cal_vepv; + + CORBA_exception_init (&ev); + POA_GNOME_Calendar_Cal__init ((PortableServer_Servant) servant, &ev); + if (ev._major != CORBA_NO_EXCEPTION) { + g_free (servant); + CORBA_exception_free (&ev); + return CORBA_OBJECT_NIL; + } + + CORBA_exception_free (&ev); + return (GNOME_Calendar_Cal) gnome_object_activate_servant (object, servant); +} + +/** + * cal_add_listener: + * @cal: A calendar. + * @listener: A listener. + * + * Adds a listener for changes to a calendar. The specified listener object + * will be used for notification when objects are added, removed, or changed in + * the calendar. + **/ +void +cal_add_listener (Cal *cal, GNOME_Calendar_Listener listener) +{ + CalPrivate *priv; + CORBA_Environment ev; + + g_return_if_fail (cal != NULL); + g_return_if_fail (IS_CAL (cal)); + g_return_if_fail (!corba_object_is_nil (listener)); + + priv = cal->priv; + + CORBA_exception_init (&ev); + + GNOME_Unknown_ref (listener, &ev); + priv->listeners = g_list_prepend (priv->listeners, CORBA_Object_duplicate (listener, &ev)); + + CORBA_exception_free (&ev); +} + +/** + * cal_remove_listener: + * @cal: A calendar. + * @listener: A listener. + * + * Removes a listener from a calendar so that no more notification events will + * be sent to the listener. + **/ +void +cal_remove_listener (Cal *cal, GNOME_Calendar_Listener listener) +{ + CalPrivate *priv; + CORBA_Environment ev; + GList *l; + + g_return_if_fail (cal != NULL); + g_return_if_fail (IS_CAL (cal)); + + priv = cal->priv; + + CORBA_exception_init (&ev); + + /* FIXME: CORBA_Object_is_equivalent() is not what one thinks. This + * code could fail in situtations subtle enough that I don't understand + * them. Someone has to figure out the standard CORBA idiom for + * listeners or notification. + */ + for (l = priv->listeners; l; l = l->next) + if (CORBA_Object_is_equivalent (listener, l->data)) { + GNOME_Unknown_unref (listener, &ev); + priv->listeners = g_list_remove_link (priv->listeners, l); + g_list_free_1 (l); + break; + } + + CORBA_exception_free (&ev); +} diff --git a/calendar/pcs/cal.h b/calendar/pcs/cal.h new file mode 100644 index 0000000000..959331595c --- /dev/null +++ b/calendar/pcs/cal.h @@ -0,0 +1,70 @@ +/* GNOME calendar object + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Author: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef CAL_H +#define CAL_H + +#include +#include +#include "gnome-calendar.h" + +BEGIN_GNOME_DECLS + + + +#define CAL_TYPE (cal_get_type ()) +#define CAL(obj) (GTK_CHECK_CAST ((obj), CAL_TYPE, Cal)) +#define CAL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), CAL_TYPE, CalClass)) +#define IS_CAL(obj) (GTK_CHECK_TYPE ((obj), CAL_TYPE)) +#define IS_CAL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), CAL_TYPE)) + +typedef struct _Cal Cal; +typedef struct _CalClass CalClass; + +struct _Cal { + GnomeObject object; + + /* Private data */ + gpointer priv; +}; + +struct _CalClass { + GnomeObjectClass parent_class; +}; + +GtkType cal_get_type (void); + +Cal *cal_construct (Cal *cal, GNOME_Calendar_Cal corba_cal); +GNOME_Calendar_Cal cal_corba_object_create (GnomeObject *object); + +Cal *cal_new (char *uri); +Cal *cal_new_from_file (char *uri); + +void cal_add_listener (Cal *cal, GNOME_Calendar_Listener listener); +void cal_remove_listener (Cal *cal, GNOME_Calendar_Listener listener); + +POA_GNOME_Calendar_Cal__epv *cal_get_epv (void); + + + +END_GNOME_DECLS + +#endif -- cgit v1.2.3