callisto-debian/evolution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added the array of objects and the hash table of UID->array index.

Browse Source 
2000-06-13  Federico Mena Quintero  <federico@helixcode.com>

	* gui/calendar-model.c (CalendarModelPrivate): Added the array of
	objects and the hash table of UID->array index.
	(calendar_model_row_count): Return the length directly from the
	array instead of asking the Wombat.
	(calendar_model_value_at): Implemented.
	(calendar_model_new): Create an empty model.  We provide a new
	setter function now.
	(calendar_model_construct): Removed function.
	(calendar_model_set_cal_client): New function to set the calendar
	client and object type at any time.  This lets us reuse a calendar
	model object.

	* cal-util/calobj.h (iCalObjectField): Just report whether the
	object has alarms; not every single alarm.

svn path=/trunk/; revision=3547
This commit is contained in:
Federico Mena Quintero
2000-06-13 07:38:47 +00:00
committed by Federico Mena Quintero
parent 7ba831860d
commit e7deedccda
5 changed files with 565 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
calendar/ChangeLog
View File

@ -1,3 +1,20 @@
2000-06-13 Federico Mena Quintero <federico@helixcode.com>
* gui/calendar-model.c (CalendarModelPrivate): Added the array of
objects and the hash table of UID->array index.
(calendar_model_row_count): Return the length directly from the
array instead of asking the Wombat.
(calendar_model_value_at): Implemented.
(calendar_model_new): Create an empty model. We provide a new
setter function now.
(calendar_model_construct): Removed function.
(calendar_model_set_cal_client): New function to set the calendar
client and object type at any time. This lets us reuse a calendar
model object.
* cal-util/calobj.h (iCalObjectField): Just report whether the
object has alarms; not every single alarm.
2000-06-13 Ettore Perazzoli <ettore@helixcode.com>
* gui/Makefile.am (SHELL_OBJS): Removed.

5
calendar/cal-util/calobj.h
View File

@ -45,10 +45,7 @@ typedef enum {
ICAL_OBJECT_FIELD_PRIORITY,
ICAL_OBJECT_FIELD_SUMMARY,
ICAL_OBJECT_FIELD_URL,
ICAL_OBJECT_FIELD_DALARM,
ICAL_OBJECT_FIELD_AALARM,
ICAL_OBJECT_FIELD_PALARM,
ICAL_OBJECT_FIELD_MALARM,
ICAL_OBJECT_FIELD_HAS_ALARMS, /* not a real field */
ICAL_OBJECT_FIELD_NUM_FIELDS
} iCalObjectField;

482
calendar/gui/calendar-model.c Normal file
View File

@ -0,0 +1,482 @@
/* Evolution calendar - Data model for ETable
*
* Copyright (C) 2000 Helix Code, Inc.
*
* Authors: Federico Mena-Quintero <federico@helixcode.com>
*
* 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 <config.h>
#include "calendar-model.h"
/* Private part of the ECalendarModel structure */
typedef struct {
/* Calendar client we are using */
CalClient *client;
/* Types of objects we are dealing with */
CalObjType type;
/* Array of calendar objects */
GPtrArray *objects;
/* UID -> array index hash */
GHashTable *uid_index_hash;
} CalendarModelPrivate;
static void calendar_model_class_init (CalendarModelClass *class);
static void calendar_model_init (CalendarModel *model);
static void calendar_model_destroy (GtkObject *object);
static int calendar_model_column_count (ETableModel *etm);
static int calendar_model_row_count (ETableModel *etm);
static void *calendar_model_value_at (ETableModel *etm, int col, int row);
static void calendar_model_set_value_at (ETableModel *etm, int col, int row, const void *value);
static gboolean calendar_model_is_cell_editable (ETableModel *etm, int col, int row);
static void *calendar_model_duplicate_value (ETableModel *etm, int col, const void *value);
static void calendar_model_free_value (ETableModel *etm, int col, void *value);
static void *calendar_model_initialize_value (ETableModel *etm, int col);
static gboolean calendar_model_value_is_empty (ETableModel *etm, int col, const void *value);
static void calendar_model_freeze (ETableModel *etm);
static void calendar_model_thaw (ETableModel *etm);
static ETableModelClass *parent_class;
/**
* calendar_model_get_type:
* @void:
*
* Registers the #CalendarModel class if necessary, and returns the type ID
* associated to it.
*
* Return value: The type ID of the #CalendarModel class.
**/
GtkType
calendar_model_get_type (void)
{
static GtkType calendar_model_type = 0;
if (!calendar_model_type) {
static GtkTypeInfo calendar_model_info = {
"CalendarModel",
sizeof (CalendarModel),
sizeof (CalendarModelClass),
(GtkClassInitFunc) calendar_model_class_init,
(GtkObjectInitFunc) calendar_model_init,
NULL, /* reserved_1 */
NULL, /* reserved_2 */
(GtkClassInitFunc) NULL
};
calendar_model_type = gtk_type_unique (E_TABLE_MODEL_TYPE, &calendar_model_info);
}
return calendar_model_type;
}
/* Class initialization function for the calendar table model */
static void
calendar_model_class_init (CalendarModelClass *class)
{
GtkObjectClass *object_class;
ETableModelClass *etm_class;
object_class = (GtkObjectClass *) class;
etm_class = (ETableModelClass *) class;
parent_class = gtk_type_class (E_TABLE_MODEL_TYPE);
object_class->destroy = calendar_model_destroy;
}
/* Object initialization function for the calendar table model */
static void
calendar_model_init (CalendarModel *model)
{
CalendarModelPrivate *priv;
priv = g_new0 (CalendarModelPrivate, 1);
model->priv = priv;
priv->objects = g_ptr_array_new ();
priv->uid_index_hash = g_hash_table_new (g_str_hash, g_str_equal);
}
/* Called from g_hash_table_foreach_remove(), frees a stored UID->index
* mapping.
*/
static gboolean
free_uid_index (gpointer key, gpointer value, gpointer data)
{
int *idx;
idx = value;
g_free (idx);
return TRUE;
}
/* Frees the objects stored in the calendar model */
static void
free_objects (CalendarModel *model)
{
CalendarModelPrivate *priv;
int i;
priv = model->data;
g_hash_table_foreach_remove (priv->objects, free_uid_index, NULL);
for (i = 0; i < priv->objects->len; i++) {
iCalObject *ico;
ico = g_ptr_array_index (priv->objects, i);
g_assert (ico != NULL);
ical_object_unref (ico);
}
g_ptr_array_set_size (priv->objects, 0);
}
/* Destroy handler for the calendar table model */
static void
calendar_model_destroy (GtkObject *object)
{
CalendarModel *model;
CalendarModelPrivate *priv;
int i;
g_return_if_fail (object != NULL);
g_return_if_fail (IS_CALENDAR_MODEL (object));
model = CALENDAR_MODEL (object);
priv = model->priv;
/* Free the calendar client interface object */
if (priv->client) {
gtk_object_unref (GTK_OBJECT (priv->client));
priv->client = NULL;
}
/* Free the uid->index hash data and the array of UIDs */
free_objects (model);
g_hash_table_destroy (priv->uid_index_hash);
priv->uid_index_hash = NULL;
g_ptr_array_free (priv->objects, TRUE);
priv->objects = NULL;
/* Free the private structure */
g_free (priv);
model->priv = NULL;
if (GTK_OBJECT_CLASS (parent_class)->destroy)
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}
/* ETableModel methods */
/* column_count handler for the calendar table model */
static int
calendar_model_column_count (ETableModel *etm)
{
return ICAL_OBJECT_FIELD_NUM_FIELDS;
}
/* row_count handler for the calendar table model */
static int
calendar_model_row_count (ETableModel *etm)
{
CalendarModel *model;
CalendarModelPrivate *priv;
model = CALENDAR_MODEL (etm);
priv = model->priv;
return priv->objects->len;
}
/* value_at handler for the calendar table model */
static void *
calendar_model_value_at (ETableModel *etm, int col, int row)
{
CalendarModel *model;
CalendarModelPrivate *priv;
iCalObject *ico;
void *retval;
model = CALENDAR_MODEL (etm);
priv = model->priv;
if (row >= priv->objects->len) {
g_message ("calendar_model_value_at(): Requested invalid row index %d", row);
return NULL;
}
ico = g_ptr_array_index (priv->objects, row);
g_assert (ico != NULL);
switch (col) {
case ICAL_OBJECT_FIELD_COMMENT:
return ico->comment ? ico->commment : "";
case ICAL_OBJECT_FIELD_COMPLETED:
return &ico->completed;
case ICAL_OBJECT_FIELD_CREATED:
return &ico->created;
case ICAL_OBJECT_FIELD_DESCRIPTION:
return ico->desc ? ico->desc : "";
case ICAL_OBJECT_FIELD_DTSTAMP:
return &ico->dtstamp;
case ICAL_OBJECT_FIELD_DTSTART:
return &ico->dtstart;
case ICAL_OBJECT_FIELD_DTEND:
return &ico->dtend;
case ICAL_OBJECT_FIELD_GEO:
return &ico->geo;
case ICAL_OBJECT_FIELD_LAST_MOD:
return &ico->last_mod;
case ICAL_OBJECT_FIELD_LOCATION:
return ico->location ? ico->location : "";
case ICAL_OBJECT_FIELD_ORGANIZER:
return ico->organizer;
case ICAL_OBJECT_FIELD_PERCENT:
return &ico->percent;
case ICAL_OBJECT_FIELD_PRIORITY:
return &ico->priority;
case ICAL_OBJECT_FIELD_SUMMARY:
return ico->summary ? ico->summary : "";
case ICAL_OBJECT_FIELD_URL:
return ico->url ? ico->url : "";
case ICAL_OBJECT_FIELD_HAS_ALARMS:
return (ico->dalarm.enabled || ico->aalarm.enabled
|| ico->palarm.enabled || ico->malarm.enabled);
default:
g_message ("calendar_model_value_at(): Requested invalid column %d", col);
return NULL;
}
}
/**
* calendar_model_new:
*
* Creates a new calendar model. It must be told about the calendar client
* interface object it will monitor with calendar_model_set_cal_client().
*
* Return value: A newly-created calendar model.
**/
CalendarModel *
calendar_model_new (void)
{
return CALENDAR_MODEL (gtk_type_new (TYPE_CALENDAR_MODEL));
}
/* Removes an object from the model and updates all the indices that follow.
* Returns the index of the object that was removed, or -1 if no object with
* such UID was found.
*/
static int
remove_object (CalendarModel *model, const char *uid)
{
CalendarModelPrivate *priv;
int *idx;
iCalObject *orig_ico;
int i;
int n;
priv = model->priv;
/* Find the index of the object to be removed */
idx = g_hash_table_lookup (priv->uid_index_hash, uid);
if (!idx)
return -1;
orig_ico = g_ptr_array_index (priv->objects, *idx);
g_assert (orig_ico != NULL);
/* Decrease the indices of all the objects that follow in the array */
for (i = *idx + 1; i < priv->objects->len; i++) {
iCalObject *ico;
int *ico_idx;
ico = g_ptr_array_index (priv->objects, i);
g_assert (ico != NULL);
ico_idx = g_hash_table_lookup (priv->uid_index_hash, ico->uid);
g_assert (ico_idx != NULL);
*ico_idx--;
g_assert (*ico_idx >= 0);
}
/* Remove this object from the array and hash */
g_hash_table_remove (priv->uid_index_hash, uid);
g_array_remove (priv->objects, *idx);
ical_object_unref (orig_ico);
n = *idx;
g_free (idx);
return n;
}
/* Callback used when an object is updated in the server */
static void
obj_updated_cb (CalClient *client, const char *uid, gpointer data)
{
CalendarModel *model;
CalendarModelPrivate *priv;
int orig_idx;
model = CALENDAR_MODEL (data);
priv = model->priv;
orig_idx = remove_object (model, uid);
}
/* Loads the required objects from the calendar client */
static void
load_objects (CalendarModel *model)
{
CalendarModelPrivate *priv;
GList *uids;
GList *l;
priv = model->priv;
uids = cal_client_get_uids (priv->client, priv->type);
for (l = uids; l; l = l->next) {
char *uid;
iCalObject *ico;
CalClientGetStatus status;
int *idx;
uid = l->data;
status = cal_client_get_object (priv->client, uid, &ico);
switch (status) {
case CAL_CLIENT_GET_SUCCESS:
break;
case CAL_CLIENT_GET_NOT_FOUND:
/* Nothing; the object may have been removed from the server */
continue;
case CAL_CLIENT_GET_SYNTAX_ERROR:
g_message ("load_objects(): Syntax error when getting object %s", uid);
continue;
}
g_assert (ico->uid != NULL);
idx = g_new (int, 1);
g_ptr_array_add (priv->objects, ico);
*idx = priv->objects->len - 1;
g_hash_table_insert (priv->uid_index_hash, ico->uid, idx);
}
cal_obj_uid_list_free (uids);
}
/**
* calendar_model_set_cal_client:
* @model: A calendar model.
* @client: A calendar client interface object.
* @type: Type of objects to present.
*
* Sets the calendar client interface object that a calendar model will monitor.
* It also sets the types of objects this model will present to an #ETable.
**/
void
calendar_model_set_cal_client (CalendarModel *model, CalClient *client, CalObjType type)
{
CalendarModelPrivate *priv;
g_return_if_fail (model != NULL);
g_return_if_fail (IS_CALENDAR_MODEL (model));
if (client)
g_return_if_fail (IS_CAL_CLIENT (client));
priv = model->priv;
if (priv->client == client && priv->type == type)
return;
if (client)
gtk_object_ref (GTK_OBJECT (client));
if (priv->client) {
gtk_signal_disconnect_by_data (GTK_OBJECT (priv->client), model);
gtk_object_unref (GTK_OBJECT (priv->client));
}
free_objects (model);
priv->client = client;
priv->type = type;
if (priv->client) {
gtk_signal_connect (GTK_OBJECT (priv->client), "obj_updated",
GTK_SIGNAL_FUNC (obj_updated_cb), model);
gtk_signal_connect (GTK_OBJECT (priv->clinet), "obj_removed",
GTK_SIGNAL_FUNC (obj_removed_cb), model);
}
load_objects (model);
e_table_model_changed (E_TABLE_MODEL (model));
}

64
calendar/gui/calendar-model.h Normal file
View File

@ -0,0 +1,64 @@
/* Evolution calendar - Data model for ETable
*
* Copyright (C) 2000 Helix Code, Inc.
*
* Authors: Federico Mena-Quintero <federico@helixcode.com>
*
* 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 CALENDAR_MODEL_H
#define CALENDAR_MODEL_H
#include <libgnome/gnome-defs.h>
#include <e-table/e-table-model.h>
#include <cal-util/cal-util.h>
BEGIN_GNOME_DECLS
#define TYPE_CALENDAR_MODEL (calendar_model_get_type ())
#define CALENDAR_MODEL(obj) (GTK_CHECK_CAST ((obj), TYPE_CALENDAR_MODEL, CalendarModel))
#define CALENDAR_MODEL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), TYPE_CALENDAR_MODEL, \
CalendarModelClass))
#define IS_CALENDAR_MODEL(obj) (GTK_CHECK_TYPE ((obj), TYPE_CALENDAR_MODEL))
#define IS_CALENDAR_MODEL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), TYPE_CALENDAR_MODEL))
typedef struct _CalendarModel CalendarModel;
typedef struct _CalendarModelClass CalendarModelClass;
struct _CalendarModel {
ETableModel model;
/* Private data */
gpointer priv;
};
struct _CalendarModelClass {
ETableModelClass parent_class;
};
GtkType calendar_model_get_type (void);
CalendarModel *calendar_model_new ();
void calendar_model_set_cal_client (CalendarModel *model, CalClient *client, CalObjType type);
END_GNOME_DECLS
#endif

2
libical/src/test/Makefile.in
View File

@ -128,7 +128,7 @@ DIST_COMMON = Makefile.am Makefile.in
DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
TAR = tar
TAR = gtar
GZIP_ENV = --best
DEP_FILES = .deps/copycluster.P .deps/findobj.P .deps/icaltestparser.P \
.deps/regression.P .deps/storage.P .deps/stow.P .deps/usecases.P