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/pcs/cal-factory.c | 272 +++++++++++++++++++++++++++++++++++ calendar/pcs/cal-factory.h | 70 +++++++++ calendar/pcs/cal.c | 343 +++++++++++++++++++++++++++++++++++++++++++++ calendar/pcs/cal.h | 70 +++++++++ 4 files changed, 755 insertions(+) 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 (limited to 'calendar/pcs') 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