Merge new-ui-branch to the trunk.

svn path=/trunk/; revision=22965

63 files changed, 9850 insertions, 5005 deletions

diff --git a/calendar/ChangeLog b/calendar/ChangeLog
index 0d6fb57dfe..023e9f7ecd 100644
--- a/calendar/ChangeLog
+++ b/calendar/ChangeLog
@@ -1,9 +1,239 @@
-2003-10-17  Jeffrey Stedfast  <fejj@ximian.com>
+2003-10-21  Rodrigo Moya <rodrigo@ximian.com>
 
-	* conduits/calendar/Makefile.am: Fixed for libical changes.
+	* gui/calendar-component.c (calendar_component_init): fixed
+	a leak caused by only freeing 'base_uri' in some cases.
+
+2003-10-21  JP Rosevear <jpr@ximian.com>
+
+	* gui/control-factory.c (get_prop): fix parse error
+	(set_prop): gnome_calendar_open was renamed
+
+	* conduits/todo/todo-conduit.c (start_calendar_server): adapt to
+	the cal_client_new changes and the lack of a default calendar
+	routine
+	(pre_sync): don't have to pass a type for the default object any
+	more
+
+	* conduits/calendar/calendar-conduit.c (start_calendar_server):
+	adapt to the cal_client_new changes and the lack of a default
+	calendar routine
+	(pre_sync): don't have to pass a type for the default object any
+	more
+
+	* cal-client/cal-client.c (cal_client_open_async): add FIXME
+	comment
+
+2003-10-21  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-file.c: store recurrences per object.
+	(free_object): free correctly the CalBackendFileObject's
+	contained in 'priv->comp_uid_hash'.
+	(lookup_component, check_dup_uid, add_component, remove_component,
+	match_object_sexp):
+	adapted to changes in comp_uid_hash.
+	
+2003-10-20  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/gnome-cal.[ch] (gnome_calendar_add_event_uri): renamed
+	from gnome_calendar_open.
+
+	* gui/calendar-component.c (load_uri_for_source): call
+	gnome_calendar_add_event_uri instead of setting the URI property on
+	the Bonobo control.
+
+2003-10-17  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/migration.c (process_calendar_dir): process subfolders.
+
+2003-10-17  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/migration.[ch] (migrate_old_calendars): new function.
+
+	* gui/calendar-component.c (calendar_component_init): call
+	the above function to migrate from old setups.
+
+	* gui/Makefile.am: added new files.
+
+2003-10-17  Jeffrey Stedfast <fejj@ximian.com>
+	
+	* conduits/calendar/Makefile.am: Fixed for libical build changes.
 
 	* conduits/todo/Makefile.am: Same.
 
+2003-10-17  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-cal-view.c (on_print): call
+	e_cal_view_get_visible_time_range, not the gnome_calendar_
+	version.
+	(e_cal_view_new_appointment_for, e_cal_view_new_appointment,
+	e_cal_view_edit_appointment): new functions.
+
+	* gui/gnome-cal.[ch] (gnome_calendar_new_appointment_for,
+	gnome_calendar_new_appointment, gnome_calendar_edit_object):
+	removed these functions, now available in e-cal-view.
+
+	* gui/calendar-commands.c:
+	* gui/e-day-view.c:
+	* gui/e-week-view-event-item.c:
+	* gui/e-week-view.c: replaced calls to gnome_calendar_* with
+	e_cal_view_* equivalents.
+
+2003-10-17  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-cal-view.[ch] (e_cal_view_get_default_category):
+	(e_cal_view_set_default_category): new functions.
+	(e_cal_view_destroy): free the default_category field.
+
+	* gui/e-day-view.[ch] (e_day_view_set_default_category):
+	removed obsolete function.
+	(e_day_view_init, e_day_view_destroy, e_day_view_do_key_press):
+	use the ECalView's default_category.
+
+	* gui/e-week-view.[ch] (e_week_view_set_default_category):
+	removed obsolete function.
+	(e_week_view_init, e_week_view_destroy, e_week_view_do_key_press):
+	use the ECalView's default_category.
+
+	* gui/gnome-cal.c (gnome_calendar_set_query): set the query
+	also on the list view by using the priv->views array.
+	(search_bar_category_changed_cb, gnome_calendar_set_default_client):
+	use the priv->views array.
+	(gnome_calendar_get_calendar_model): return the model for the
+	current view widget.
+	(gnome_calendar_open): removed tasks opening code.
+
+2003-10-16  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/dialogs/new-calendar.c (new_calendar_dialog): if the user
+	presses Cancel, just terminate.
+
+2003-10-16  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/calendar-component.c (calendar_component_init): create
+	directories for the newly-created calendars.
+
+	* gui/dialogs/new-calendar.c (create_new_source_with_group): use
+	e_mkdir_hier instead of mkdir.
+
+2003-10-16  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/calendar-component.c (calendar_component_init): if no groups
+	are present in the configuration, create the "On This Computer"
+	group and the "Personal" and "Work" calendars on it.
+
+	* gui/dialogs/new-calendar.c (new_calendar_dialog): moved the
+	source creation...
+	(create_new_source_with_group): ...here, and made the code create
+	the directory for the new calendar.
+
+2003-10-15  Hans Petter Jansson  <hpj@ximian.com>
+
+	* gui/e-select-names-editable.c (e_selct_names_editable_get_address):
+	EDestination -> EABDestination.
+
+	* gui/gnome-cal.c (setup_widgets): evolution_dir -> ".evolution".
+
+2003-10-15  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-select-names-editable.c (e_select_names_editable_get_address):
+	use EABDestination instead of EDestination.
+
+	* gui/gnome-cal.c (gnome_calendar_open): disabled tasks opening code.
+
+2003-10-15  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-meeting-list-view.c: adapted to new addressbook API.
+
+	* gui/e-meeting-store.c: adapted to new addressbook API.
+	(find_zone): fixed usage of icalcomponent where an icalproperty
+	is expected.
+	(refresh_busy_periods): fixed call to cal_client_get_free_busy().
+
+	* gui/e-meeting-time-sel.c (e_meeting_time_selector_construct):
+	added missing variable.
+	
+2003-10-15  Jeffrey Stedfast  <fejj@ximian.com>
+
+	* gui/dialogs/meeting-page.c: #include <gal/e-table/e-table.h>
+
+2003-10-15  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-meeting-list-view.c (start_addressbook_server):
+	updated to new addressbook API.
+	(book_open_cb): removed unneeded function, since we load
+	the local addressbook synchronously.
+
+2003-10-15  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/Makefile.am: added missing header directories.
+
+	* pcs/cal-factory.h: include <libical/ical.h>, not <ical.h>.
+
+	* gui/dialogs/meeting-page.c: added missing headers.
+	(meeting_page_construct): free 'backend_address' as returned
+	by cal_client_get_cal_address(). Removed code to create the
+	meeting model's ETable not removed with the merge.
+
+	* gui/e-meeting-list-view.c: updated addressbook headers.
+
+	* gui/gnome-cal.h: added missing ',' in the GnomeCalendarViewType
+	enum.
+	
+2003-10-14  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-day-view.c (e_day_view_update_query): dont set status
+	messages here, already set in e_cal_view_update_query.
+	(update_query): removed this function.
+	(e_day_view_recalc_day_starts): call e_day_view_update_query,
+	not update_query.
+
+	* gui/e-week-view.c (e_week_view_update_query): dont set status
+	messages here, already set in e_cal_view_update_query.
+
+	* gui/gnome-cal.c (adjust_query_for_view): new function to adjust
+	the query for the visible time range on a given view.
+	(gnome_calendar_set_query): call adjust_query_for_view for each
+	one of the views.
+
+2003-10-14  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-cal-view.c (e_cal_view_init): connect to signals on the
+	model we create here, so that we get notifications for changes.
+
+	* gui/gnome-cal.c (gnome_calendar_set_query): set the query
+	on all models.
+	(gnome_calendar_open): update the date navigator query.
+
+2003-10-14  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal.c (cal_notify_timezone_requested): never send NULL
+	strings to ORBit.
+
+	* gui/e-cal-view.c (e_cal_view_create_popup_menu): removed
+	unneeded variables. Also, fixed a typo that was making the
+	menu options be disabled when they should be enabled.
+
+2003-10-13  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-cal-model.[ch] (e_cal_model_get_client_for_uri): new function.
+
+	* gui/gnome-cal.[ch] (gnome_calendar_set_default_client): new function.
+
+	* gui/calendar-component.c (primary_source_selection_changed_callback):
+	set the default client on the calendar view to be the primary
+	selection on the source list.
+
+2003-10-13  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/dialogs/new-calendar.c (new_calendar_dialog): set a default group
+	on the calendar group option menu and create the source if all checks
+	are passed.
+
+2003-10-12  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/dialogs/new-calendar.c (new_calendar_dialog): set up widgets
+	loaded from the Glade file.
+
 2003-10-10  Hans Petter Jansson  <hpj@ximian.com>
 
 	* gui/Makefile.am (etspec_DATA): Add e-cal-list-view.etspec.
@@ -44,6 +274,66 @@
 	* gui/e-cal-list-view.[ch]: Implement ECalListView, subclassing
 	ECalView.
 
+2003-10-10  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/dialogs/new-calendar.[ch]: added new widget, which implements
+	the dialog to create new calendars.
+
+	* gui/dialogs/new-calendar.glade: basic mockup of the dialog.
+
+	* gui/dialogs/Makefile.am: added new files.
+
+	* gui/calendar-commands.c (file_new_calendar_cb): open the new calendar
+	dialog to allow user to create a new cal.
+
+2003-10-10  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/control-factory.c (calendar_properties_init): pass the
+	BonoboControl to get_prop/set_prop.
+	(get_prop): obtain the GnomeCalendar from the control.
+	(set_prop): ditto, and when the URI property is changed,
+	sensitize the UI as approppriate.
+
+	* gui/calendar-commands.c (calendar_control_sensitize_calendar_commands):
+	made this function public.
+
+	* gui/calendar-commands.h: added new prototype.
+
+2003-10-10  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/calendar-commands.c (file_new_calendar_cb,
+	file_new_appointment_cb, file_new_event_cb, file_new_meeting_cb,
+	file_new_task_cb): callbacks for "New..." verbs.
+	(sensitize_calendar_commands): sensitize new verbs, and made it
+	sensitize correctly based on the set of clients currently loaded.
+	(sensitize_taskpad_commands): likewise.
+
+2003-10-09  Hans Petter Jansson  <hpj@ximian.com>
+
+	* gui/e-cal-model.c (get_classification): Adapt to libical API changes.
+	(ecm_set_value_at): Break after each case, so we don't set the passed value
+	in more than one field.
+
+2003-10-09  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-cal-view.c (e_cal_view_delete_selected_occurrence):
+	* cal-client/cal-client.c (cal_client_remove_object): added missing
+	argument when calling cal_client_remove_object_with_mod().
+
+2003-10-09  Rodrigo Moya <rodrigo@ximian.com>
+
+	* idl/evolution-calendar.idl: added missing 'rid' argument to the
+	removeObject method.
+
+	* cal-client/cal-client.c (cal_client_remove_object_with_mod):
+	* pcs/cal-backend.h:
+	* pcs/cal-backend.c (cal_backend_remove_object):
+	* pcs/cal-backend-sync.h:
+	* pcs/cal-backend-sync.c (cal_backend_sync_remove_object,
+	_cal_backend_remove_object):
+	* pcs/cal-backend-file.c (cal_backend_file_remove_object):
+	* pcs/cal.c (impl_cal_removeObject): adapted to changes in IDL.
+
 2003-10-09  Jeffrey Stedfast  <fejj@ximian.com>
 
 	* cal-client/Makefile.am: INCLUDE path fixes for changes made to
@@ -90,6 +380,165 @@
 	* gui/dialogs/task-details-page.glade: Make percent-complete of
 	task details dialog numeric only.
 
+2003-10-08  Chris Toshok  <toshok@ximian.com>
+
+	* gui/dialogs/e-delegate-dialog.c (e_delegate_dialog_construct):
+	EDestination => EABDestination, and e_destination =>
+	eab_destination.
+	(e_delegate_dialog_get_delegate): same.
+	(e_delegate_dialog_get_delegate_name): same.
+
+	* gui/dialogs/comp-editor-util.c: remove unnecessary #include of
+	e-destination.h.
+
+	* gui/dialogs/alarm-options.c (alarm_to_malarm_widgets):
+	EDestination => EABDestination, and e_destination =>
+	eab_destination.
+	(malarm_widgets_to_alarm): same.
+
+	* gui/e-meeting-model.c (book_open_cb): track change to error
+	return codes.
+	(start_addressbook_server): use
+	e_book_async_get_default_addressbook.
+	(contacts_cb): rename cursor_cb to this, as we no longer get
+	passed a cursur, and we don't need to check the email address
+	since the query is now "is" instead of "contains".
+	(refresh_busy_periods): use an "is" query, and use
+	e_book_async_get_contacts instead of getting a CardCursor.
+	(process_section): this takes an EABDestination** instead of a
+	SimpleCardList*, which is gone.
+	(select_names_ok_cb): get "destinations" instead of
+	"simple_card_list".
+
+2003-10-08  Rodrigo Moya <rodrigo@ximian.com>
+
+	* cal-client/cal-client.c (cal_client_is_read_only): fixed
+	documentation comments.
+
+	* gui/calendar-commands.c (sensitize_calendar_commands): figure
+	out read-only menu items to disable based on the currently
+	selected object's CalClient.
+
+2003-10-08  Rodrigo Moya <rodrigo@ximian.com>
+
+	* cal-client/cal-client.c: set better error m,essages on the
+	E_CALENDAR_CHECK_STATUS macro.
+	(cal_client_get_error_message): new function.
+
+	* cal-client/cal-client.h: added new prototype.
+
+	* gui/dialogs/comp-editor.c (save_comp): use the GError argument
+	for the cal_client_create/_modify_object calls, and display the
+	error message coming from the backend.
+
+	* gui/comp-util.c (cal_comp_is_on_server): likewise.
+
+2003-10-07  Dan Winship  <danw@ximian.com>
+
+	* idl/evolution-calendar.idl (getDefaultObject): Remove the "type"
+	arg; the backend knows what type it is
+
+	* pcs/cal.c (impl_Cal_getDefaultObject): Likewise
+
+	* pcs/cal-backend.c (cal_backend_get_default_object): Likewise
+
+	* pcs/cal-backend-sync.c (cal_backend_sync_get_default_object,
+	_cal_backend_get_default_object): Likewise
+
+	* pcs/cal-backend-file.c (cal_backend_file_get_default_object):
+	Likewise. (Use cal_backend_get_kind() instead.)
+
+	* cal-client/cal-client.c (cal_client_get_default_object):
+	Likewise
+
+	* gui/comp-util.c (cal_comp_event_new_with_defaults,
+	cal_comp_task_new_with_defaults): Update calls to
+	cal_client_get_default_object().
+
+	* pcs/cal-backend-sync.c (_cal_backend_get_static_capabilities):
+	Use the right cal notification
+
+2003-10-07  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-cal-model.c (e_cal_model_create_component_with_defaults):
+	dont clone NULL icalcomponent's.
+
+2003-10-07  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-cal-model.c (e_cal_model_get_default_client): make sure we
+	always return a default client, if possible, since we rely on having
+	a default client in many places.
+
+	* gui/e-day-view.c (e_day_view_do_key_press): dont create event if
+	e_cal_model_create_component_with_defaults returns NULL.
+
+	* gui/e-week-view.c (e_week_view_do_key_press): dont create event if
+	e_cal_model_create_component_with_defaults returns NULL.
+	
+2003-10-06  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-cal-model.c (e_cal_model_create_component_with_defaults):
+	make sure the component has always an UID.
+
+	* gui/e-day-view.c  (e_day_view_find_event_from_uid):
+	* gui/e-week-view.c (e_week_view_find_event_from_uid): check
+	pointers passed to strcmp().
+
+2003-10-06  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/gnome-cal.c (gnome_calendar_open): added missing call to
+	cal_client_open().
+
+	* cal-client/cal-client.c (cal_client_new): fixed documentation
+	comments.
+	(cal_client_open): emit CAL_OPENED signal with appropriate status codes.
+	(open_sync): dont emit CAL_OPENED signal, it's already emitted in
+	cal_client_open().
+
+2003-10-06  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/comp-editor-factory.c (open_client):
+	* gui/gnome-cal.c (gnome_calendar_open, gnome_calendar_construct):
+	* gui/calendar-offline-handler.c (backend_go_offline, backend_go_online,
+	calendar_offline_handler_init): adapted to changes in cal_client and
+	manage GError's returned by cal_client_open.
+
+	* gui/e-itip-control.c: dont run anymore sub event loops.
+	(start_calendar_server): use synchronous interface for opening calendars.
+	(start_default_server): renamed it from *_async.
+	(start_calendar_server_cb): removed unneeded function.
+	(object_requested_cb): use sync interface.
+
+	* gui/e-tasks.c (e_tasks_construct): dont create the CalClient here.
+	(e_tasks_open): do it here, where we've got all the info needed.
+
+	* importers/icalendar-importer.c (update_single_object): killed warning.
+	(ical_importer_new, vcal_importer_new): don't create CalClient's here.
+	(load_file_fn): create them here.
+	(vcal_load_file_fn): and here.
+	(gnome_calendar_import_data_fn): fixed usage of cal_client_*.
+
+	* */*: integrated JP's changes for synchronous open's in cal_client
+	and one model per view instead of one model for all views.
+	
+2003-10-02  Rodrigo Moya <rodrigo@ximian.com>
+
+	* cal-client/cal-client.c (cal_client_modify_object): return FALSE
+	if the icalcomponent is NULL.
+
+	* gui/e-day-view.c (e_day_view_finish_resize): commit sequence on
+	CalComponent after changing start/end dates.
+
+2003-10-01  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-day-view.c (process_component):
+	* gui/e-week-view.c (process_component): expand recurrences here.
+
+2003-09-30  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-file.c (match_recurrence_sexp): removed.
+	(match_object_sexp): dont expand recurrences here.
+
 2003-09-30  Mike Kestner <mkestner@ximian.com>
 
 	* cal-util/cal-util-marshal.list : new VOID:STRING,STRING,STRING
@@ -113,6 +562,519 @@
 
 	* conduits/calendar/Makefile.am: ditto	
 	
+2003-09-26  JP Rosevear <jpr@ximian.com>
+
+	* pcs/cal-backend.c (cal_backend_class_init): remove cal_added
+	signal
+
+2003-09-26  JP Rosevear <jpr@ximian.com>
+
+	* pcs/cal.h: add protos
+
+	* pcs/cal.c (cal_get_backend): accessor
+	(cal_get_listener): ditto
+
+	* pcs/cal-factory.c (impl_CalFactory_getCal): update to new
+	routine name
+
+	* pcs/cal-backend.h: add protos
+	
+	* pcs/cal-backend.c (cal_backend_init): init client mutex
+	(cal_backend_finalize): destroy client mutex
+	(cal_destroy_cb): just remove the client
+	(listener_died_cb): remove the client, the listener died so it
+	can't really do anything
+	(last_client_gone): signal the last client gone
+	(cal_backend_add_client): add a client with locking and listen for
+	the death of the listener
+	(cal_backend_remove_client): remove client
+
+2003-09-26  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-sync.c (_cal_backend_create_object): only free the
+	returned UID if it's not NULL.
+
+	* pcs/cal.c (cal_notify_object_created): dont send NULL strings to
+	ORBit code.
+
+2003-09-26  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/comp-util.c (cal_comp_is_on_server): free the icalcomponent
+	returned from cal_client_get_object, and return TRUE if we find
+	the component on the backend.
+
+	* gui/e-day-view.c (process_component):
+	* gui/e-week-view.c (process_component): added missing case, so that
+	we also display recurrent meetings starting before the time range and
+	ending after the time range.
+
+	* cal-client/cal-listener.c (impl_notifyReadOnly): pass the
+	'read_only' argument to the signal callback correctly (a gboolean
+	not a 'gboolean *').
+
+	* gui/comp-editor-factory.c (resolve_pending_requests): removed
+	the g_assert on 'oc->pending != NULL', since there are now cases
+	(local calendar) where we get to call this function (cal_opened_cb)
+	with no pending requests yet.
+
+2003-09-25  JP Rosevear <jpr@ximian.com>
+
+	* gui/calendar-commands.c (publish_freebusy_cmd): adapt to new
+	get_free_busy api
+
+	* conduits/calendar/calendar-conduit.c (post_sync): ditto
+	(pre_sync): ditto
+
+	* conduits/todo/todo-conduit.c (pre_sync): ditto
+	(post_sync): ditto
+
+	* gui/e-meeting-model.c (refresh_busy_periods): ditto
+
+	* gui/e-itip-control.c (send_freebusy): ditto
+
+	* gui/e-cal-view.c (on_publish): ditto
+
+	* cal-client/cal-listener.h: add signals
+
+	* cal-client/cal-listener.c (build_change_list): move here from
+	cal-client.c
+	(impl_notifyChanges): implement
+	(build_free_busy_list): util to create the GList of free busy
+	objects
+	(impl_notifyFreeBusy): implement
+	(cal_listener_class_init): set free busy and changes epv methods,
+	add signals
+
+	* cal-client/cal-client.h: update protos
+
+	* cal-client/cal-client.c (cal_get_changes_cb): get changes call
+	back
+	(cal_get_free_busy_cb): get free busy call back
+	(cal_client_init): listen for free busy and changes signals
+	(cal_client_get_changes): convert to new threaded sync api
+	(cal_client_get_free_busy): ditto
+
+	* pcs/cal.h: add protos
+
+	* pcs/cal.c: remove dead type conversion function
+	(impl_Cal_getChanges): implement by just calling, no return stuff
+	(impl_Cal_getFreeBusy): ditto
+	(cal_notify_changes): do getChanges callback
+	(cal_notify_free_busy): do getFreeBusy callback
+
+	* pcs/cal-backend.h: update protos, vmethods
+	
+	* pcs/cal-backend.c (cal_backend_get_free_busy): call through
+	(cal_backend_get_changes): ditto
+
+	* pcs/cal-backend-sync.h: add vmethods, protos
+
+	* pcs/cal-backend-sync.c (cal_backend_sync_get_changes): call
+	through
+	(cal_backend_sync_get_free_busy): ditto
+	(_cal_backend_get_changes): backend implementation, notify
+	(_cal_backend_get_free_busy): ditto
+	(cal_backend_sync_class_init): set free busy and changes
+	implementations
+
+	* pcs/cal-backend-file.c (cal_backend_file_get_free_busy): convert
+	to sync backend method
+	(cal_backend_file_compute_changes_foreach_key): remove from the
+	hash here
+	(cal_backend_file_compute_changes): no need to build the sequence
+	here
+	(cal_backend_file_get_changes): convert to sync backend method
+	(cal_backend_file_class_init): set sync backend methods for free
+	busy and changes
+
+	* idl/evolution-calendar.idl: convert getChanges and getFreeBusy
+	to new async api
+
+2003-09-25  JP Rosevear  <jpr@ximian.com>
+
+	* pcs/cal-backend.h: remove dead result enums
+
+	* pcs/cal-backend.c: fix comments
+
+	* idl/evolution-calendar.idl: remove dead exceptions
+
+2003-09-25  JP Rosevear <jpr@ximian.com>
+
+	* pcs/cal.c (cal_notify_default_object): send back the empty
+	string if the object is NULL
+	(cal_notify_object): ditto
+
+2003-09-25  JP Rosevear <jpr@ximian.com>
+
+	* gui/comp-editor-factory.c (edit_existing): convert to api
+	changes
+
+	* conduits/todo/todo-conduit.c (local_record_from_uid): ditto
+	(pre_sync): ditto
+
+	* conduits/calendar/calendar-conduit.c (local_record_from_uid):
+	ditto
+	(pre_sync): ditto
+
+	* importers/icalendar-importer.c (update_single_object): ditto
+
+	* gui/dialogs/comp-editor.c (obj_updated_cb): ditto
+
+	* gui/e-itip-control.c (get_real_item): ditto
+	(find_server): ditto
+
+	* gui/comp-util.c (cal_comp_is_on_server): ditto
+	(cal_comp_event_new_with_defaults): ditto
+	(cal_comp_task_new_with_defaults): ditto
+
+	* cal-client/cal-listener.h: add signals
+
+	* cal-client/cal-listener.c (impl_notifyDefaultObjectRequested):
+	implement
+	(impl_notifyObjectRequested): ditto
+	(cal_listener_class_init): set above epv implementations, add signals
+
+	* cal-client/cal-client.h: update protos
+
+	* cal-client/cal-client.c (cal_default_object_requested_cb): get
+	default object callback
+	(cal_object_requested_cb): get object callback
+	(cal_client_init): listen for get and get default object signals
+	(cal_client_get_default_object): convert to new sync api
+	(cal_client_get_object): ditto
+
+	* pcs/cal.h: add protos
+
+	* pcs/cal.c (impl_Cal_getDefaultObject): just call the backend, it
+	does the notification now
+	(impl_Cal_getObject): ditto
+	(cal_notify_default_object): do getDefaultObject response
+	(cal_notify_object): do getObject response
+
+	* pcs/cal-backend.h: remove vmethods, protos
+
+	* pcs/cal-backend.c: remove a couple of dead functions
+	(cal_backend_class_init): get_object_component is no longer a
+	vmethod
+	(cal_backend_get_default_object): call through
+	(cal_backend_get_object): ditto
+
+	* pcs/cal-backend-sync.h: add protos, vmethods
+
+	* pcs/cal-backend-sync.c (cal_backend_sync_get_default_object):
+	call through
+	(cal_backend_sync_get_object): ditto
+	(_cal_backend_discard_alarm): pass correct params to
+	cal_notify_discard_alarm
+	(_cal_backend_get_default_object): call through and notify
+	(_cal_backend_get_object): ditto
+	(cal_backend_sync_class_init): set backend implementations
+
+	* pcs/cal-backend-file.c (cal_backend_file_get_default_object):
+	convert to sync backend method
+	(cal_backend_file_get_object): ditto
+	(cal_backend_file_compute_changes_foreach_key): just look up the
+	component rather than using the backend vmethod
+	(cal_backend_file_remove_object): return valid sync status codes
+	(cal_backend_file_class_init): move get_object, get_default_object
+	to sync class
+
+	* idl/evolution-calendar.idl: convert getObject and
+	getDefaultObject to new async idl
+
+2003-09-25  JP Rosevear  <jpr@ximian.com>
+
+	* pcs/cal.c (impl_Cal_discardAlarm): just call the backend
+	function, it does the notification
+	(cal_notify_alarm_discarded): notify of discard alarm call
+
+	* pcs/cal-backend.h: update proto
+
+	* pcs/cal-backend.c (cal_backend_discard_alarm): call through
+
+	* pcs/cal-backend-sync.h: add proto, vmethod
+
+	* pcs/cal-backend-sync.c (cal_backend_sync_discard_alarm): call
+	through
+	(_cal_backend_discard_alarm): call through and notify
+	(cal_backend_sync_class_init): set discard alarm implementation
+
+	* pcs/cal-backend-file.c (cal_backend_file_discard_alarm): match
+	sync backend vmethod
+	(cal_backend_file_class_init): set alarm vmethod implementation
+
+	* idl/evolution-calendar.idl: switch discardAlarm to new api
+
+	* gui/alarm-notify/alarm-queue.c (remove_queued_alarm): match new
+	api
+
+	* cal-client/cal-listener.h: add signal
+
+	* cal-client/cal-listener.c (impl_notifyAlarmDiscarded): implement
+	(cal_listener_class_init): add alarm, send, receive epv functions,
+	alarm signal
+
+	* cal-client/cal-client.h: update proto
+
+	* cal-client/cal-client.c (cal_alarm_discarded_cb): discardAlarm
+	callback
+	(cal_client_init): listen to discard alarm signal
+	(cal_client_discard_alarm): implement with new threaded sync api
+
+2003-09-25  JP Rosevear <jpr@ximian.com>
+
+	* idl/evolution-calendar.idl: remove unused user exceptions
+
+2003-09-24  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-util.[ch] (cal_backend_util_fill_alarm_instances_seq):
+	removed unneeded function.
+
+2003-09-24  JP Rosevear  <jpr@ximian.com>
+
+	* conduits/*/*.c: adjust to new timezone api calls
+
+	* gui/*.c: ditto
+
+	* gui/dialogs/*.c: ditto
+
+	* cal-client/cal-listener.h: add new signals
+
+	* cal-client/cal-listener.c (convert_status): convert invalid
+	object as well
+	(impl_notifyTimezoneRequested): implement
+	(impl_notifyDefaultTimezoneSet): ditto
+	(cal_listener_class_init): set epv implementations for timezone
+	functions
+	(cal_listener_class_init): create timezone response signals
+
+	* cal-client/cal-client.h: update protos
+
+	* cal-client/cal-client.c: fix return values all over the place
+	(cal_get_timezone_cb): getTimezone response
+	(cal_query_cb): setDefaultTimezone response
+	(cal_client_init): listen for new response signals
+	(cal_client_get_timezone): implement using new thread sync api
+	(cal_client_ensure_timezone_on_server): use add timezone call
+	(cal_client_set_default_timezone): oimplement using new thread sync
+	api
+
+	* cal-client/cal-client-types.h: add invalid object status code
+
+	* idl/evolution-calendar.idl: getQuery no longer raises any user
+	exceptions, remove dead types and exceptions
+
+2003-09-24  JP Rosevear <jpr@ximian.com>
+
+	* pcs/cal.h: new protos
+
+	* pcs/cal.c (impl_Cal_getTimezone): call backend implementation
+	(impl_Cal_addTimezone): ditto
+	(impl_Cal_setDefaultTimezone): ditto
+	(cal_class_init): set epv implementations of timezone functions
+	(cal_notify_timezone_requested): notify of get timezone response
+	(cal_notify_default_timezone_set): notify of default timezone
+	being set
+
+	* pcs/cal-backend.h: new vmethods, protos
+
+	* pcs/cal-backend.c (cal_backend_class_init): init new timezone
+	vmethods
+	(cal_backend_get_timezone): call through
+	(cal_backend_set_default_timezone): ditto
+	(cal_backend_add_timezone): ditto
+	(cal_backend_internal_get_default_timezone): ditto
+	(cal_backend_internal_get_timezone): ditto
+
+	* pcs/cal-backend-sync.h: add vmethods, protos
+
+	* pcs/cal-backend-sync.c (cal_backend_sync_get_timezone): call
+	through
+	(cal_backend_sync_set_default_timezone): ditto
+	(_cal_backend_set_default_timezone): call through and notify
+	(_cal_backend_get_timezone): ditto
+	(cal_backend_sync_class_init): set backend implementations for new
+	funcs
+
+	* pcs/cal-backend-object-sexp.c (func_occur_in_time_range): get
+	time_t values based on the zone
+
+	* pcs/cal-backend-file.c: reorg so we don't have to prototype
+	everything
+	(cal_backend_file_get_timezone): implement the sync backend way
+	(cal_backend_file_add_timezone): ditto
+	(cal_backend_file_set_default_timezone): ditto
+	(cal_backend_file_internal_get_default_timezone): internal method,
+	for sexp comparison
+	(cal_backend_file_internal_get_timezone): ditto
+
+	* idl/evolution-calendar.idl: convert timezone routines to async
+	api
+
+2003-09-23  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-object-sexp.c (func_occur_in_time_range): dont expand
+	recurrences, since they are supposed to be expanded in the backends.
+	(instance_occur_cb, resolve_tzid): removed unneeded functions.
+
+	* pcs/cal-backend-file.c (cal_backend_file_add_timezone): guard against
+	adding the timezone if it's already there.
+
+2003-09-23  JP Rosevear <jpr@ximian.com>
+
+	* pcs/cal.c (cal_notify_object_created): notify with the object,
+	not the uid
+
+	* gui/e-cal-model.c (add_new_client): don't listen for
+	non-existent signal
+
+2003-09-23  JP Rosevear <jpr@ximian.com>
+
+	* cal-client/cal-client.h: remove dead proto
+
+2003-09-23  JP Rosevear <jpr@ximian.com>
+
+	* cal-client/cal-client.h: remove send result enum
+
+	* gui/itip-utils.c (comp_server_send): use the new send_objects
+	routine
+
+2003-09-23  JP Rosevear <jpr@ximian.com>
+
+	* cal-client/cal-client.h: remove send result enum
+
+2003-09-23  JP Rosevear <jpr@ximian.com>
+
+	* cal-client/cal-client.h: remove enum, protos
+
+	* cal-client/cal-client.c: remove remove status enum typing
+
+2003-09-23  Rodrigo Moya <rodrigo@ximian.com>
+
+	* importers/icalendar-importer.c (update_objects): new function
+	to manage the update of components, taking into account
+	VTIMEZONE components.
+	(process_item_fn, gnome_calendar_import_data_fn): use
+	update_objects instead of cal_client_update_objects.
+
+2003-09-23  JP Rosevear <jpr@ximian.com>
+
+	* pcs/cal.h: update proto
+
+	* pcs/cal.c (impl_Cal_addTimezone): just call add_timezone, it
+	does the notification
+	(cal_notify_object_created): only notify the query if the object
+	matches
+	(cal_notify_object_removed): ditto
+
+	* pcs/cal-backend.h: update proto, vmethod
+
+	* pcs/cal-backend.c (cal_backend_add_timezone): returns void
+
+	* pcs/cal-backend-sync.h: update proto, vmethod
+
+	* pcs/cal-backend-sync.c (cal_backend_sync_remove_object): add the
+	object as an out param
+	(_cal_backend_remove_object): get the object and pass it in the
+	notification
+
+	* pcs/cal-backend-file.c (cal_backend_file_create_object): kill
+	cal_backend_file_update_objects call, its more efficient to create
+	the comp ourselves; stamp the creation time, add the component to
+	the toplevel
+	(cal_backend_file_modify_object): kill the
+	cal_backend_file_update_objects call, add the component to the
+	toplevel
+	(cal_backend_file_remove_object): pass back the object when
+	removing
+
+2003-09-23  JP Rosevear  <jpr@ximian.com>
+
+	* cal-client/cal-query.c (cal_query_finalize): disconnect the
+	signal handlers
+
+	* cal-client/cal-client.c (cal_client_get_query): unref the
+	listener when done
+
+2003-09-23  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-cal-view.c (selection_received): add VTIMEZONE components
+	contained in the clipboard data to the backend.
+
+2003-09-22  JP Rosevear <jpr@ximian.com>
+
+	* gui/dialogs/comp-editor.c (save_comp): modify and create instead
+	of update, simplify mod code
+
+2003-09-22  JP Rosevear <jpr@ximian.com>
+
+	* gui/e-day-view.c (e_day_view_finish_long_event_resize): modify
+	the object instead of update, simplify the instance handling
+	(e_day_view_finish_resize): ditto
+	(e_day_view_on_top_canvas_drag_data_received): ditto
+	(e_day_view_on_main_canvas_drag_data_received): ditto
+
+2003-09-22  Rodrigo Moya <rodrigo@ximian.com>
+
+	* cal-client/cal-client.c (cal_client_get_alarms_in_range): use
+	'has-alarms' function in the search expression.
+
+	* pcs/cal-backend-object-sexp.c (func_has_alarms): new SExp function.
+
+2003-09-22  JP Rosevear <jpr@ximian.com>
+
+	* gui/e-day-view.c (e_day_view_on_editing_stopped): create the
+	object if its not on the server or modify it if it is
+
+	* gui/e-week-view.c (e_week_view_on_editing_stopped): we return if
+	there is no text and it *not* on the server
+
+2003-09-22  JP Rosevear <jpr@ximian.com>
+
+	* gui/e-week-view.c (e_week_view_on_editing_stopped): create the
+	object if its not on the server or modify it if it is
+
+2003-09-22  JP Rosevear <jpr@ximian.com>
+
+	* gui/gnome-cal.h: remove proto
+
+	* gui/gnome-cal.c: remove gnome_calendar_unrecur_selection
+
+	* gui/e-week-view.h: remove proto
+
+	* gui/e-week-view.c: remove e_week_view_unrecur_appointment
+
+	* gui/e-day-view.h: remove proto
+
+	* gui/e-day-view.c: remove e_day_view_unrecur_appointment
+
+	* gui/e-cal-view.c: remove on_unrecur_appointment (this is handled
+	better via recurrence id's now)
+
+2003-09-22  JP Rosevear <jpr@ximian.com>
+
+	* gui/e-itip-control.c (update_attendee_status): ifdef out, leave
+	temporarily for reference, but otherwise it shouldn't be needed
+	(update_item): switch to using receive objects
+	(ok_clicked_cb): update item when receiving a reply
+
+	* gui/e-calendar-table.c (selection_received): switch to using
+	create object from update_objects
+
+	* gui/e-cal-view.c (selection_received_add_event): util routine to
+	prevent duplication
+	(selection_received): use above
+
+	* gui/e-cal-model.c (ecm_set_value_at): switch to using modify
+	object from update_objects
+	(ecm_append_row): switch to using create object from
+	update_objects
+
+	* gui/e-cal-model-calendar.c (ecmc_set_value_at): switch to using
+	modify object from update_objects
+
+	* gui/e-cal-model-tasks.c (ecmt_set_value_at): ditto
+
 2003-09-22  Hans Petter Jansson  <hpj@ximian.com>
 
 	* cal-util/Makefile.am (libical_util_la_LIBADD):
@@ -121,10 +1083,177 @@
 	* importers/Makefile.am (libevolution_calendar_importers_la_LIBADD):
 	libicalvcal.la -> libicalvcal-evolution.la
 
+	
+2003-09-19  Rodrigo Moya <rodrigo@ximian.com>
+
+	* idl/evolution-calendar.idl: removed getAlarmsInRange and
+	getAlarmsForObject methods.
+
+	* pcs/cal.c (impl_Cal_getAlarmsInRange, impl_Cal_getAlarmsForObject):
+	removed unneeded CORBA methods.
+	(cal_class_init): dont set removed methods in the epv.
+
+	* pcs/cal-backend.[ch]: removed get_alarms_in_range and
+	get_alarms_for_object virtual methods.
+	(cal_backend_get_alarms_in_range, cal_backend_get_alarms_for_object):
+	removed.
+	(cal_backend_class_init): dont set removed virtual methods.
+
+	* pcs/cal-backend-file.c (cal_backend_file_get_alarms_in_range,
+	cal_backend_file_get_alarms_for_object): removed.
+	(cal_backend_file_class_init): dont set removed virtual methods.
+
+2003-09-19  Rodrigo Moya <rodrigo@ximian.com>
+
+	* cal-client/cal-client.c (cal_client_get_alarms_in_range): changed
+	to use queries.
+	(build_component_alarms_list): create the alarm list from a list
+	of iCalendar strings.
+	(build_alarm_instance_list): removed.
+	(cal_client_get_alarms_for_object): dont call the CORBA methods,
+	just get alarms by itself.
+
+2003-09-18  Rodrigo Moya <rodrigo@ximian.com>
+
+	* cal-client/cal-listener.[ch]: added "add_timezone" signal.
+	(impl_notifyTimezoneAdded): implemented new CalListener method.
+	(cal_listener_class_init): create "add_timezone" signal for the class.
+
+	* cal-client/cal-client.[ch] (cal_client_add_timezone): new function.
+	(cal_client_init): connect to "add_timezone" signal on the
+	CalListener.
+	(cal_add_timezone_cb): callback for the "add_timezone" signal.
+
+2003-09-18  Rodrigo Moya <rodrigo@ximian.com>
+
+	* idl/evolution-calendar.idl: added 'notifyTimezoneAdded' method
+	to the Calendar::Listener interface.
+
+	* pcs/cal-backend-sync.[ch] (cal_backend_sync_add_timezone):
+	(_cal_backend_add_timezone): new functions for the new virtual
+	method implementation.
+
+	* pcs/cal.[ch] (cal_notify_timezone_added): new function.
+
+	* pcs/cal-backend-file.c (cal_backend_add_timezone): converted to
+	return a CalBackendSyncStatus.
+	(cal_backend_file_class_init): the 'add_timezone' method we implement
+	is the one in the CalBackendSync class.
+	(cancel_receive_object): added missing 'return'.
+	(free_cal_component): removed unused function.
+
+2003-09-17  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-file.c (cal_backend_add_timezone): added new
+	virtual method implementation.
+
+	* pcs/cal.c (impl_Cal_addTimezone): check return value from
+	cal_backend_add_timezone, and set an exception if an error is
+	returned.
+
+2003-09-16  Rodrigo Moya <rodrigo@ximian.com>
+
+	* idl/evolution-calendar.idl: added addTimezone method.
+
+	* pcs/cal.c (impl_Cal_addTimezone): implemented new method.
+	(cal_class_init): set new method on the epv.
+
+	* pcs/cal-backend.[ch]: added 'add_timezone' virtual method.
+	(cal_backend_add_timezone): implemented new virtual method.
+
+	* pcs/cal-backend-file.c (cal_backend_file_modify_object): it's
+	cal_component_get_as_string, not cal_component_as_string.
+
+	* cal-client/cal-client.c (cal_client_ensure_timezone_on_server):
+	dont use anymore updateObjects method, use addTimezone instead.
+	
 2003-09-16  Rodrigo Moya <rodrigo@ximian.com>
 
 	* conduits/todo/Makefile.am: removed libwombat reference.
 
+2003-09-15  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-file.c (cal_backend_file_create_object): return
+	the UID of the added object.
+	(cal_backend_file_remove_object): ditto for old_object.
+
+2003-09-15  JP Rosevear <jpr@ximian.com>
+
+	* conduits/todo/todo-conduit.c (replace_record): switch to modify
+	object
+	(add_record): switch to using create object
+
+	* conduits/calendar/calendar-conduit.c (process_multi_day): switch
+	to using create object
+	(add_record): switch to using create object
+	(replace_record): switch to modify object
+
+	* cal-client/cal-listener.h: add signals
+
+	* cal-client/cal-listener.c (impl_notifyObjectsReceived):
+	implement listener method
+	(build_object_list): ditto
+	(cal_listener_class_init): create receive_objects and send_objects
+	signals
+
+	* cal-client/cal-client.h: add, update protos
+
+	* cal-client/cal-client.c (cal_objects_received_cb):
+	receive_objects callback
+	(cal_objects_sent_cb): send_objects callback
+	(cal_client_init): listen for above signals
+	(cal_client_create_object): pass back uid
+	(cal_client_receive_objects): implement
+	(cal_client_send_objects): ditto
+
+	* idl/evolution-calendar.idl: add receive/send objects methods and
+	yank updateObjects
+
+	* pcs/cal.h: add protos
+
+	* pcs/cal.c (impl_Cal_receiveObjects): implement
+	(impl_Cal_sendObjects): ditto
+	(cal_class_init): add epv methods
+	(cal_notify_objects_received): notify of objects received call,
+	updating queries
+	(cal_notify_objects_sent): notify of objects sent
+
+	* pcs/cal-backend.h: remove proto
+
+	* pcs/cal-backend.c (cal_backend_class_init): remove obj_updated
+	signal
+	(cal_backend_class_init): init vmethods properly
+	(cal_backend_receive_objects): call through
+	(cal_backend_send_objects): ditto
+
+	* pcs/cal-backend-sync.h: add protos, vmethods
+
+	* pcs/cal-backend-sync.c (cal_backend_sync_receive_objects): call
+	through
+	(cal_backend_sync_send_objects): ditto
+	(_cal_backend_receive_objects): call backend method and notify
+	(_cal_backend_send_objects): ditto
+	(cal_backend_sync_class_init): override send/receive object
+	vmethods
+
+	* pcs/cal-backend-file.c (cal_backend_file_class_init): set
+	remove/send objects sync vmethods
+	(cal_backend_file_create_object): remove call to dead method
+	(cal_backend_file_remove_object): ditto
+	(cal_backend_file_modify_object): ditto
+	(cancel_received_object): cancel an object
+	(check_tzids): check we have all the tzid's for the object
+	(cal_backend_file_receive_objects): receive a bunch of objects via
+	itip
+	(cal_backend_file_send_objects): skeleton implementation
+
+2003-09-15  Rodrigo Moya <rodrigo@ximian.com>
+
+	* idl/evolution-calendar.idl: added InvalidObject CallStatus.
+
+	* pcs/cal-backend-file.c (cal_backend_file_create_object): implemented.
+	(cal_backend_file_modify_object): implemented.
+
 2003-09-15  Harry Lu  <harry.lu@sun.com>
 
 	* gui/apps_evolution_calendar.schemas: change last_notification_time's
@@ -137,6 +1266,219 @@
 	 (e_week_view_jump_to_button_item): new function, jump to the day view.
 	 (e_week_view_is_jump_button_visible): new function.
 
+	
+2003-09-12  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal.c (cal_notify_cal_address, cal_notify_alarm_email_address,
+	cal_notify_ldap_attribute, cal_notify_static_capability):
+	make sure we always notify listeners, regardless of whether the
+	string is empty or not.
+
+	* cal-client/cal-client.c (check_capability): guard against using
+	NULL strings with strstr.
+
+2003-09-12  JP Rosevear <jpr@ximian.com>
+
+	* cal-client/client-test.c (cal_opened_cb): listen for other query
+	signals
+
+	* cal-client/cal-listener.h: add signals
+
+	* cal-client/cal-listener.c (impl_notifyObjectCreated): implement
+	(impl_notifyObjectModified): implement
+	(cal_listener_class_init): assign epv implementations
+	(cal_listener_class_init): add create/modify object signals
+
+	* cal-client/cal-client.h: add protos
+
+	* cal-client/cal-client.c (cal_object_created_cb): object created
+	callback
+	(cal_object_modified_cb): object modified callback
+	(cal_client_init): listen for create/modify object signals from
+	the listener
+	(cal_client_create_object): call the create object method
+	(cal_client_modify_object): call the modify object method
+
+	* cal-client/client-test.c (cal_opened_cb): listen for all the
+	query signals, tidy
+
+2003-09-12  JP Rosevear <jpr@ximian.com>
+
+	* pcs/cal.c (impl_Cal_createObject): implement
+	(impl_Cal_modifyObject): ditto
+	(cal_class_init): set epv methods for create/modify
+
+	* pcs/cal-backend.h: add protos, vmethod
+
+	* pcs/cal-backend.c (cal_backend_class_init): init new vmethods
+	(cal_backend_create_object): call through
+	(cal_backend_modify_object): ditto
+
+	* pcs/cal-backend-sync.h: add protos, vmethods
+
+	* pcs/cal-backend-sync.c (cal_backend_sync_create_object): call
+	through
+	(cal_backend_sync_modify_object): ditto
+	(_cal_backend_create_object): create object and notify
+	(_cal_backend_modify_object): modify object and notify
+
+	* pcs/cal-backend-file.c (cal_backend_file_create_object):
+	skeleton routine for creating objects
+	(cal_backend_file_modify_object): ditto for modifying
+
+	* idl/evolution-calendar.idl: add createObject and modifyObject
+	calls
+
+2003-09-12  JP Rosevear  <jpr@ximian.com>
+
+	* pcs/cal.c (cal_notify_object_removed): its uid, not uids
+
+2003-09-12  JP Rosevear <jpr@ximian.com>
+
+	* pcs/query.h: add protos
+
+	* pcs/query.c (query_object_matches): use the sexp to check for a
+	match
+	(query_notify_objects_added_1): notify of one object added to
+	query
+	(query_notify_objects_modified_1): ditto for modification
+	(query_notify_objects_removed_1): ditto for removal
+
+	* pcs/cal.h: add protos
+
+	* pcs/cal.c (cal_notify_object_created): notify of object creation
+	(cal_notify_object_modified): notify of object modification
+	(cal_notify_object_removed): use the _1 routines
+
+	* pcs/cal-backend-file.c (match_recurrence_sexp): this returns a
+	boolean
+	(cal_backend_file_update_objects): don't signal removals here now
+
+	* idl/evolution-calendar.idl: add object created and modified
+	responses
+
+	
+2003-09-11  JP Rosevear <jpr@ximian.com>
+
+	* pcs/cal.h: update proto
+
+	* pcs/cal.c (cal_notify_object_removed): notify relevant queries
+	of removal
+
+	* pcs/cal-backend.c (cal_backend_get_queries): ref the list before
+	passing it back
+
+	* pcs/cal-backend-sync.c (_cal_backend_remove_object): pass uid to
+	notification
+
+2003-09-11  JP Rosevear <jpr@ximian.com>
+
+	* pcs/cal-backend-file.c (match_recurrence_sexp): don't unref the
+	component
+
+	* cal-client/client-test.c (cal_opened_cb): listen to objects
+	added signal
+	(objects_added_cb): print the object uid
+	
+2003-09-11  JP Rosevear <jpr@ximian.com>
+
+	* pcs/cal-backend-object-sexp.c (cal_backend_object_sexp_text):
+	return the base text
+
+2003-09-11  JP Rosevear <jpr@ximian.com>
+
+	* gui/gnome-cal.c (update_query): fix c/p typo
+
+2003-09-11  JP Rosevear <jpr@ximian.com>
+
+	* gui/gnome-cal.c (update_query): start the query
+
+	* gui/e-cal-model.c (update_query_for_client): ditto
+
+	* cal-client/client-test.c (cal_opened_cb): ditto
+	
+2003-09-11  JP Rosevear <jpr@ximian.com>
+
+	* cal-client/cal-query.h: add proto
+
+	* cal-client/cal-query.c (cal_query_start): start the query
+
+2003-09-11  JP Rosevear <jpr@ximian.com>
+
+	* gui/dialogs/delete-error.c (delete_error_dialog): accept GError
+	and base error messages on that
+
+	* gui/dialogs/delete-error.h: update proto
+
+	* gui/e-tasks.c (e_tasks_delete_completed): pass extra param to
+	cal_client_remove_object
+
+	* conduits/todo/todo-conduit.c (delete_record): ditto
+
+	* conduits/calendar/calendar-conduit.c (process_multi_day): ditto
+	(delete_record): ditto
+	
+	* gui/gnome-cal.c (gnome_calendar_purge): ditto
+
+	* gui/dialogs/comp-editor.c (delete_comp): ditto
+	
+	* gui/e-cal-view.c (e_cal_view_cut_clipboard): pass the error to
+	delete_error_dialog
+	(delete_event): ditto
+	(e_cal_view_delete_selected_occurrence): ditto
+	
+	* gui/e-itip-control.c (remove_item): ditto
+
+	* gui/e-calendar-table.c (delete_selected_components): ditto
+
+	* cal-client/cal-listener.h: add signal
+
+	* cal-client/cal-listener.c (impl_notifyObjectRemoved): implement
+	(cal_listener_class_init): set object removed implementation and
+	create signal
+
+	* cal-client/cal-client.h: update protos
+
+	* cal-client/cal-client.c (cal_object_removed_cb): object removal
+	callback
+	(cal_client_init): listen for object removal signal
+	(cal_client_remove_object_with_mod): make call synchronous
+	(cal_client_remove_object): pass new params
+
+	* pcs/cal.h: add proto
+
+	* pcs/cal.c (impl_Cal_removeObject): just call the backend
+	function
+	(cal_notify_object_removed): notify of removal
+
+	* pcs/cal-backend.h: remove and update protos, remove signal
+
+	* pcs/cal-backend.c (cal_backend_class_init): kill obj_removed
+	signal
+	(cal_backend_remove_object): there is no return value now
+
+	* pcs/cal-backend-sync.h: add vmethod, proto
+
+	* pcs/cal-backend-sync.c (cal_backend_sync_remove_object): call
+	through
+	(_cal_backend_remove_object): remove the object and then do the
+	notification
+
+	* pcs/cal-backend-file.c (cal_backend_file_class_init): remove
+	object is not part of the sync class
+	(cal_backend_file_update_objects): there is no more removed signal
+	(cal_backend_file_remove_object): return sync status codes
+
+	* idl/evolution-calendar.idl: make removeObject oneway and and a
+	notification method in the listener
+
+2003-09-11  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/query.[ch] (query_get_text): new function.
+	(query_get_object_sexp): new function.
+
+	* pcs/cal-backend-file.c (cal_backend_file_start_query): implemented.
+
 2003-09-11  Hans Petter Jansson  <hpj@ximian.com>
 
 	* cal-util/Makefile.am (libcal_util_la_LIBADD):
@@ -193,12 +1535,279 @@
 	Statically link with wombat. Fix ETodo conduit.
 	(Mdk bug #5348)
 
+	
+2003-09-10  JP Rosevear  <jpr@ximian.com>
+
+	* pcs/cal.h: update proto
+
+	* pcs/cal.c (impl_Cal_getObjectList): just call the backend, it
+	will do the notification now
+	(cal_notify_object_list): the list is a list of strings
+
+	* pcs/cal-backend.h: update vmethod, proto
+
+	* pcs/cal-backend.c (cal_backend_get_object_list): call through
+
+	* pcs/cal-backend-sync.h: add proto, vmethod
+
+	* pcs/cal-backend-sync.c (cal_backend_sync_get_object_list): call
+	through
+	(_cal_backend_get_object_list): get the list of objects from the
+	sync backend and do the notification
+	(cal_backend_sync_class_init): set vmethod implementation
+
+	* pcs/cal-backend-file.c (cal_backend_file_class_init): the get
+	object list call is now part of the sync backend
+	(cal_backend_file_get_object_list): return a status and put the
+	object list in the passed in param
+
+2003-09-10  JP Rosevear  <jpr@ximian.com>
+
+	* pcs/cal-backend.c (cal_backend_finalize): unref the elist
+	(cal_backend_init): init the query elist
+
+2003-09-10  JP Rosevear <jpr@ximian.com>
+
+	* gui/gnome-cal.c (dn_query_objects_added_cb): match new query
+	signals - just tag here
+	(dn_query_objects_modified_cb): always retag
+	(dn_query_objects_removed_cb): ditto
+	(update_query): connect to new signals
+	(gnome_calendar_destroy): we don't keep a list of expunging
+	queries
+	(gnome_calendar_purge): no need to do the
+	expunge async, just get the object list immediately
+
+	* gui/e-tasks.c (e_tasks_delete_completed): no need to do the
+	expunge async, just get the object list immediately
+
+	* gui/e-cal-model.c (query_objects_added_cb): callback for objects
+	added to the query
+	(query_objects_modified_cb): ditto for modifications
+	(query_objects_removed_cb): ditto for removed
+	(query_progress_cb): progress of the query
+	(query_done_cb): query is done
+	(update_query_for_client): connect to the new signals
+
+	* cal-client/client-test.c (cal_opened_cb): run a query
+
+	* cal-client/cal-query.c: we are given the listener now - listen
+	for signals from the listener and emit signals matching the api
+	changes
+
+	* cal-client/query-listener.[hc]: rewrite to match new query
+	listener methods and emit signals rather than using function
+	callbacks
+
+	* cal-client/cal-marshal.list: add to marshallers
+
+	* cal-client/cal-listener.h: add query signal
+
+	* cal-client/cal-listener.c (impl_notifyQuery): implement
+	(cal_listener_class_init): set notifyQuery method
+	(cal_listener_class_init): add query signal
+
+	* cal-client/cal-client.h: update protos
+
+	* cal-client/cal-client.c (cal_query_cb): handle response to
+	getQuery
+	(cal_client_init): listen for query signal
+	(cal_client_get_query): get a query from the calendar
+
+	* pcs/query.h: update protos
+
+	* pcs/query.c: rewrite to implement the query start method and
+	provide notification calls
+
+	* pcs/cal.h: add proto
+
+	* pcs/cal.c (impl_Cal_getQuery): re-implement so the backend
+	doesn't create the query for us
+	(cal_notify_query): respond with the query
+
+	* pcs/cal-factory.c: re-order includes
+
+	* pcs/cal-common.h: add types
+
+	* pcs/cal-backend.h: update protos, vmethods
+
+	* pcs/cal-backend.c (cal_backend_class_init): init start_query
+	vmethod
+	(cal_backend_finalize): free mutex
+	(cal_backend_start_query): call through
+	(cal_backend_add_query): add a query to the list the backend is
+	running
+	(cal_backend_get_queries): get the query list
+
+	* pcs/cal-backend-object-sexp.h: add proto
+
+	* pcs/cal-backend-file.c (cal_backend_file_start_query): skeleton
+	for new backend implementation
+
+	* pcs/Makefile.am: don't build dead files
+
+	* idl/evolution-calendar.idl: make the getQuery call async, make
+	the query listener calls oneway and match the addressbook
+
+2003-09-09  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-file.c (cal_backend_file_get_object_component):
+	added case for getting the individual recurrences if 'rid' is
+	not NULL,
+
+2003-09-09  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-file.c (match_object_sexp): expand recurrences
+	for recurrent objects.
+	(match_recurrence_sexp): add the recurrences that match the query
+	expression to the object list.
+
+2003-09-08  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-file.c: don't store all recurrences in the
+	private structure.
+	
+2003-09-04  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-day-view.c (process_component):
+	* gui/e-week-view.c (process_component): dont expand recurrences,
+	since they are now expanded by the backends.
+
+2003-09-02  JP Rosevear <jpr@ximian.com>
+
+	* gui/tasks-control.c (sensitize_commands): adapt to cal-client
+	threaded sync api changes
+
+	* gui/itip-utils.c (itip_organizer_is_user): ditto
+
+	* gui/gnome-cal.c (gnome_calendar_purge): ditto
+
+	* gui/e-meeting-model.c (process_section): ditto
+
+	* gui/e-calendar-table.c (e_calendar_table_show_popup_menu): ditto
+
+	* gui/e-cal-view.c (e_cal_view_create_popup_menu): ditto
+
+	* gui/calendar-commands.c (sensitize_calendar_commands): ditto
+	(sensitize_taskpad_commands): ditto
+
+	* gui/dialogs/task-editor.c (set_menu_sens): ditto
+
+	* gui/dialogs/meeting-page.c (meeting_page_construct): ditto
+
+	* gui/dialogs/event-editor.c (set_menu_sens): ditto
+
+	* gui/dialogs/alarm-page.c (add_clicked_cb): ditto
+
+	* conduits/calendar/calendar-conduit.c (pre_sync): convert to
+	cal_client api changes
+
+	* conduits/todo/todo-conduit.c (pre_sync): ditto
+	
+	* cal-client/client-test.c (list_uids): match new error handling
+
+	* cal-client/cal-marshal.list: marshallers
+
+	* cal-client/cal-listener.[hc]: emit signals for corba listener
+	callbacks - start with is_read_only, get_static_capabilities,
+	get_cal_address, get_ldap_attribute, open, remove and object_list
+
+	* cal-client/cal-client.h: move the status enum away from here,
+	update protos to new thread sync api standard
+
+	* cal-client/cal-client.c: the listener emits signals instead of
+	using callback functions now and we return booleans + GError in
+	outs for results
+	(e_calendar_error_quark): for GError handling
+	(cal_read_only_cb): handle listener op callback
+	(cal_cal_address_cb): ditto
+	(cal_alarm_address_cb): ditto
+	(cal_ldap_attribute_cb): ditto
+	(cal_static_capabilities_cb): ditto
+	(cal_opened_cb): ditto
+	(cal_removed_cb): ditto
+	(cal_object_list_cb): ditto
+
+	* cal-client/cal-client-types.h: add GError stuff
+
+	* cal-client/Makefile.am: build glib marshal stuff
+
+	* pcs/query.c (backend_opened_cb): comment out some break
+	temporarily
+
+	* pcs/cal.h: add protos
+
+	* pcs/cal.c (impl_Cal_open): just call the backend method, it will
+	handle the notification
+	(impl_Cal_remove): ditto
+	(impl_Cal_isReadOnly): ditto
+	(impl_Cal_getCalAddress): ditto
+	(impl_Cal_getAlarmEmailAddress): ditto
+	(impl_Cal_getLdapAttribute): ditto
+	(impl_Cal_getStaticCapabilities): ditto
+	(impl_Cal_getObjectList): simplify
+	(cal_new): set poa to be threaded
+	(cal_notify_read_only): notification utils
+	(cal_notify_cal_address): ditto
+	(cal_notify_alarm_email_address): ditto
+	(cal_notify_ldap_attribute): ditto
+	(cal_notify_static_capabilities): ditto
+	(cal_notify_open): ditto
+	(cal_notify_remove): ditto
+	(cal_notify_object_list): ditto
+
+	* pcs/cal-factory.c (impl_CalFactory_getCal): dup the key and the
+	object
+	(cal_factory_new): set poa to be threaded
+
+	* pcs/cal-backend.h: update vmethods and protos
+
+	* pcs/cal-backend.c (cal_backend_get_cal_address): we no longer
+	return anything - the callee is responsible for notification
+	(cal_backend_get_alarm_email_address): ditto
+	(cal_backend_get_ldap_attribute): ditto
+	(cal_backend_get_static_capabilities): ditto
+	(cal_backend_open): ditto
+	(cal_backend_remove): ditto
+
+	* pcs/cal-backend-file.h: update inheritance
+
+	* pcs/cal-backend-file.c: inherit from CalBackendSync and make
+	is_read_only, get_static_capabilities, get_cal_address, get_ldap_attribute, open and
+	remove match
+
+	* pcs/Makefile.am: build new files
+
+2003-09-02 JP Rosevear  <jpr@ximian.com>
+
+	* idl/evolution-calendar.idl: make all listener callbacks one ways
+
+2003-09-02  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-file.c (match_recurrence_sexp, match_object_sexp):
+	new callbacks for g_hash_table_foreach in get_object_list.
+	(cal_backend_file_get_object_list): don't use the priv->comp list
+	to check the components, use the hash table, which contains all
+	the recurrences already expanded.
+	(add_component): only expand recurrences for recurrent components.
+
 2003-09-01  Andrew Wu <Yang.Wu@sun.com>
-       * gui/e-day-view.c:
-       (e_day_view_change_event_end_time_up):
-       (e_day_view_change_event_end_time_down):
-       Use "ctrl+shift+alt+Up/Down" to change the end time of the editing event.
 
+	* gui/e-day-view.c:
+	(e_day_view_change_event_end_time_up):
+	(e_day_view_change_event_end_time_down): Use
+	"ctrl+shift+alt+Up/Down" to change the end time of the editing
+	event.
+
+2003-08-29  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-file.c (lookup_component): take into account the 'rid'
+	argument.
+	(get_rid_string): new function to convert the recurrence ID to string.
+	(add_recurrence_to_object): callback for cal_recur_generate_instances.
+	(add_component): expand recurrences and g_strdup the hash's key.
+	(free_cal_component): free also the hash's key.
+	
 2003-08-28  Hans Petter Jansson  <hpj@ximian.com>
 
 	* gui/alarm-notify/alarm-queue.c (tray_icon_blink_cb)
@@ -243,6 +1852,72 @@
 	* gui/alarm-notify/alarm-notify.c (AlarmNotify_removeCalendar): set
 	the initial value of lc_ptr and orig_str_ptr to NULL to avoid crash.
 
+
+2003-08-26  Rodrigo Moya <rodrigo@ximian.com>
+
+	* idl/evolution-calendar.idl: QueryListener::notifyObjUpdated now gets
+	a sequence of CalObj's.
+
+	* pcs/query.c (add_component): send the whole object to the listener,
+	not just the UID. Improved the way the listeners are notified, by allocating
+	a CORBA sequence to be used for all listeners, not one for each.
+	(match_component): pass the CalComponent to add_component, not only the UID.
+	(start_cached_query_cb): send the whole object to the listener.
+
+	* cal-client/cal-query.[ch]: changed argument names for "obj_updated"
+	signal.
+	(obj_updated_cb): pass the calobj's, not uid's.
+
+	* gui/e-tasks.c (query_obj_updated_cb):
+	* gui/gnome-cal.c (dn_query_obj_updated_cb, purging_obj_updated_cb):
+	* gui/e-cal-model.c (query_obj_updated_cb): we now get the object's
+	string representation instead of the UID.
+
+2003-08-25  Rodrigo Moya <rodrigo@ximian.com>
+
+	* cal-client/cal-client.c (cal_client_get_object): added a 'rid' argument
+	to match the IDL method.
+
+	* conduits/calendar/calendar-conduit.c (local_record_from_uid):
+	* conduits/todo/todo-conduit.c (local_record_from_uid):
+	* gui/comp-editor-factory.c (edit_existing):
+	* gui/comp-util.c (cal_comp_is_on_server):
+	* gui/e-cal-model.c (query_obj_updated_cb):
+	* gui/e-itip-control.c (find_server, get_real_item, update_attendee_status):
+	* gui/gnome-cal.c (dn_query_obj_updated_cb, purging_obj_updated_cb):
+	* gui/dialogs/comp-editor.c (obj_updated_cb): adapted to changes in
+	cal_client_get_object().
+
+2003-08-23  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/query-backend.c (object_updated_cb):
+	* pcs/cal-backend.c (cal_backend_get_type_by_uid): use 'rid' parameter
+	where appropriate.
+
+	* pcs/cal-backend-file.c (check_dup_uid): removed unused variables.
+	(cal_backend_file_compute_changes_foreach_key): pass a NULL 'rid'
+	to cal_backend_get_object().
+	(lookup_component): get a 'rid' argument also.
+	(cal_backend_file_cancel_object, cal_backend_file_remove_object):
+	pass correct number of parameters to lookup_component().
+
+2003-08-22  Rodrigo Moya <rodrigo@ximian.com>
+
+	* idl/evolution-calendar.idl: use UID/RID pairs to identify objects.
+
+	* pcs/cal.c (impl_Cal_getObject): added 'rid' parameter.
+
+	* pcs/cal-backend.c (cal_backend_get_object): added 'rid' parameter.
+	(cal_backend_get_object_component): ditto.
+	(get_object): ditto.
+
+	* pcs/cal-backend-file.c (cal_backend_file_get_object_component):
+	added 'rid' parameter.
+	(lookup_component): added 'rid' parameter and made it search for the
+	recurrence when that parameter is not NULL.
+	(cal_backend_file_get_alarms_for_object, cal_backend_file_update_object):
+	adapted to changes in lookup_component().
+	
 2003-08-22  Frederic Crozat  <fcrozat@mandrakesoft.com>
 
 	* gui/alarm-notify/notify-main.c: (main):
@@ -300,6 +1975,111 @@
 	  (gnome_calendar_get_search_bar_widget),
           (gnome_calendar_get_view_notebook_widget): new functions
 
+
+2003-08-20  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/query-backend.c (foreach_uid_cb): use the icalcomponent
+	to call icalcomponent_get_uid, not the string.
+
+2003-08-20  Rodrigo Moya <rodrigo@ximian.com>
+
+	* pcs/cal-backend-file.c: store objects by UID and RID.
+	(free_object): new function to free the CalBackendFileObject structure.
+	(cal_backend_file_dispose): use free_object callback to remove the
+	objects in the comp_uid_hash.
+	(lookup_component): search correctly the component in the new hash
+	table organizarion.
+	(check_dup_uid): ditto.
+	(add_component): ditto.
+	(remove_component): ditto.
+
+2003-08-19  JP Rosevear  <jpr@ximian.com>
+
+	* gui/gnome-cal.c (setup_widgets): set up models here
+	(gnome_calendar_construct): not here
+
+	* conduits/calendar/calendar-conduit.c
+	(e_calendar_context_destroy): we have a list of calcomponents
+	rather than uids now
+	(process_multi_day): build a list of components rather than uids
+	(pre_sync): use get_object_list instead of getting uids
+	(for_each): create local records from calcomponents
+
+	* conduits/todo/todo-conduit.c: as above
+	
+	* gui/print.c (instance_cb): mark as true if we found an instance
+	(print_month_small): see if atleast one instance exists in a
+	slight different way
+
+	* cal-client/client-test.c (list_uids): use get_object_list
+
+	* cal-client/cal-listener.h: update protos
+
+	* cal-client/cal-listener.c (cal_listener_class_init): set object
+	list callback implementation
+	(impl_notifyObjectListRequested): implement
+	(cal_listener_construct): take object list callback function
+	(cal_listener_new): ditto
+
+	* cal-client/cal-client.h: update protos, add status
+
+	* cal-client/cal-client.c (e_calendar_new_op): create new op
+	(e_calendar_get_op): retrieve current op
+	(e_calendar_free_op): free the op
+	(e_calendar_remove_op): clear current op
+	(cal_client_init): create new mutex
+	(cal_client_finalize): destroy mutex
+	(build_object_list): build list of icalcomponents
+	(cal_object_list_cb): handle getObjectList response
+	(real_open_calendar): pass extra listener arg
+	(cal_client_get_object_list): implement using thread safe mutex
+	locking
+	(cal_client_get_object_list_as_comp): return calcomponents instead
+	of icalcomponents
+	(cal_client_generate_instances): just get the object list - no
+	need to make it atomic since get_object_list is already atomic
+
+	* pcs/query.c (query_finalize): free new sexp class
+	(parse_sexp): use new sexp class
+	(match_component): ditto
+
+	* pcs/query-backend.c (foreach_uid_cb): use icalcomponent to
+	extract uid
+	(query_backend_new): get all objects using object list call
+
+	* pcs/cal.c (impl_Cal_getObjectList): implement
+	(cal_class_init): adjust for idl method changes
+
+	* pcs/cal-backend.h: update vmethods, add proto
+
+	* pcs/cal-backend.c (cal_backend_class_init): remove get_uids and
+	get_objects_in_range vmethods, add get_object_list vmethod
+	(cal_backend_get_object_list): call through to vmethod implementation
+
+	* pcs/cal-backend-object-sexp.[hc]: nice class to represent a sexp
+	and search cal components
+
+	* pcs/cal-backend-file.c (cal_backend_file_class_init): remove
+	get_uids and get_objects_in_range calls and set get_object_list
+	call
+	(cal_backend_file_get_object_list): implement
+	(create_user_free_busy): use sexp ops to implement
+	(cal_backend_file_compute_changes): just iterate over the
+	component list rather than fetching uids
+	
+	* pcs/Makefile.am: build new files
+
+	* idl/evolution-calendar.idl: make opening a oneway call, add
+	getObjectList call, remove getUIDS and getObjectsInRange call -
+	both can be done with getObjectList; make listener callbacks
+	oneway
+
+2003-08-19  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/gnome-cal.c (gnome_calendar_purge): don't leak the client list.
+	(gnome_calendar_destroy): disconnect from all callbacks on all
+	loaded clients.
+	
 2003-08-19  Rodrigo Moya <rodrigo@ximian.com>
 
 	* gui/e-cal-model-tasks.c (ecmt_get_color_for_component): use
@@ -321,6 +2101,51 @@
 	* gui/e-week-view.c (e_week_view_add_event, e_week_view_do_key_press):
 	same as e-day-view.c
 
+2003-08-18  Ettore Perazzoli  <ettore@ximian.com>
+
+	* gui/calendar-component.c (impl_createControls): Oops, pass
+	[NULL, NULL] to gtk_scrolled_window_new().
+
+2003-08-18  Ettore Perazzoli  <ettore@ximian.com>
+
+	* gui/main.c (factory): Ref the object from
+	calendar_component_peek() before returning it.
+
+2003-08-17  Ettore Perazzoli  <ettore@ximian.com>
+
+	* gui/control-factory.h: #include <bonobo/bonobo-control.h>.
+
+	* gui/Makefile.am (libevolution_calendar_la_LIBADD): Link to
+	libeutil.
+
+	* gui/e-calendar-table.c (e_calendar_table_set_status_message):
+	Don't use the global_shell_client.
+
+	* gui/main.c (factory): Call calendar_component_peek() for the
+	GNOME_Evolution_Calendar_Component OAFIID.
+
+	* gui/GNOME_Evolution_Calendar.server.in.in: Set up the
+	GNOME_Evolution_Calendar_Component server and rename
+	GNOME_Evolution_Calendar_Factory to
+	GNOME_Evolution_Calendar_Factory_2.
+	* gui/main.c: Updated IDs accordingly.
+
+	* gui/e-meeting-time-sel.c (e_meeting_time_selector_construct):
+	Use calendar_component_peek_config_directory() instead of
+	evolution_dir.
+	* gui/gnome-cal.c (setup_widgets): Likewise.
+	(gnome_calendar_destroy): Likewise.
+	* gui/dialogs/meeting-page.c (meeting_page_construct): Likewise.
+
+	* gui/gnome-cal.c (gnome_calendar_open): #if 0 some code for
+	figuring out where the task list is.
+
+	* gui/calendar-component.c: New file.
+	* gui/calendar-component.h: New file.
+
+	* gui/itip-utils.c (itip_addresses_get): Unref the GConf client
+	from gconf_client_get_default.
+
 2003-08-15  Rodrigo Moya <rodrigo@ximian.com>
 
 	* gui/e-cal-model.c (ecm_get_color_for_component): use tigert's
@@ -341,16 +2166,6 @@
 
 2003-08-14  Rodrigo Moya <rodrigo@ximian.com>
 
-	* gui/e-cal-model.c (e_cal_model_create_component_with_defaults):
-	use the default client to call cal_comp_*_new_with_defaults, and
-	if no client is available, just create an empty icalcomponent.
-
-	* gui/e-cal-view.c (e_cal_view_init): create an empty model.
-
-	* gui/e-week-view.c (e_week_view_add_event): use the event's client.
-
-2003-08-14  Rodrigo Moya <rodrigo@ximian.com>
-
 	* gui/e-cal-model.[ch] (e_cal_model_free_component_data): new
 	function.
 
@@ -367,6 +2182,46 @@
 	e_week_view_update_event_cb, e_week_view_remove_event_cb,
 	e_week_view_free_events): same as EDayView.
 
+2003-08-14  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-cal-model.c (e_cal_model_create_component_with_defaults):
+	use the default client to call cal_comp_*_new_with_defaults, and
+	if no client is available, just create an empty icalcomponent.
+
+	* gui/e-cal-view.c (e_cal_view_init): create an empty model.
+
+	* gui/e-week-view.c (e_week_view_add_event): use the event's client.
+
+2003-08-13  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/gnome-cal.c (gnome_calendar_open): unref the client if there
+	is an error.
+	(update_query): set status bar messages for progress.
+	(update_query_timeout): re-enabled.
+	(client_cal_opened_cb): install timeout handler for the query updates.
+
+	* gui/e-cal-view.c (e_cal_view_set_model): connect to all appropriate
+	signals on the model, to be called for every change.
+	(model_row_changed_cb, model_rows_changed_cb): new model callbacks.
+
+	* gui/e-week-view-event-item.c (e_week_view_event_item_draw): colorize
+	the background for multiple days events.
+
+2003-08-13  Rodrigo Moya <rodrigo@ximian.com>
+
+	* gui/e-cal-model.c (ecm_append_row, ecm_get_color_for_component):
+	* gui/e-cal-model-tasks.c (ecmt_get_color_for_component): merged
+	missing bith from calendar-views-with-model branch.
+
+2003-08-13  JP Rosevear  <jpr@ximian.com>
+
+	* cal-client/cal-client.c (real_open_calendar): set the priv->cal
+	pointer in a slightly different spot so we have it in the call
+	back
+
+	* gui/e-cal-model.c (e_cal_model_get_client_list): merge this in
+	properly
+
 2003-08-13  Rodrigo Moya <rodrigo@ximian.com>
 
 	* gui/e-cal-model.c (ecm_get_color_for_component): assign the colors
@@ -393,7 +2248,170 @@
 
 	* gui/e-week-view-event-item.c (e_week_view_event_item_draw): colorize
 	the background for multiple days events.
+	
+2003-08-13  JP Rosevear  <jpr@ximian.com>
+
+	* cal-client/client-test.c (create_client): there is no more
+	object updated signal
+
+	* cal-client/cal-listener.c: clean up comment
+
+	* cal-client/cal-client.c (cal_client_class_init): remove
+	obj_updated and obj_removed signals
+
+	* cal-client/cal-client.h: ditto
+	
+2003-08-12  JP Rosevear  <jpr@ximian.com>
+
+	* pcs/cal-backend.h: remove get_uri vmethod
+
+	* pcs/cal-backend.c (cal_backend_class_init): remove get_uri
+	vmethod init
+
+	* pcs/cal-backend-file.c (cal_backend_file_class_init): no longer
+	a get uri vmethod
+	(cal_backend_file_get_uri): remove implementation of above
+
+2003-08-12  JP Rosevear  <jpr@ximian.com>
+	
+	* cal-client/client-test.c (main): use tmp uris
+
+	* cal-client/cal-listener.h: update protos
+
+	* cal-client/cal-listener.c (cal_listener_init): init removed
+	function
+	(cal_listener_finalize): clear removed function
+	(impl_notifyCalOpened): take file status
+	(impl_notifyCalRemoved): implement
+	(cal_listener_construct): take remove function arg
+	(cal_listener_new): ditto
+
+	* cal-client/cal-client.h: update protos, add remove status
+
+	* cal-client/cal-client.c
+	(cal_client_remove_status_enum_get_type): add remove status type
+	(cal_client_class_init): add removed signal
+	(cal_opened_cb): can no longer get unsupported exception here
+	(cal_removed_cb): emit removed status
+	(real_open_calendar): pass removed callback function to listener
+	(get_fall_back_uri): no longer append tasks.ics or calendar.ics
+	(cal_client_remove_calendar): new c wrapper for corba function -
+	calendar must be open currently
+
+	* pcs/query.c (backend_opened_cb): only disconnect the open
+	callback
+	(backend_removed_cb): handle calendar removal
+	(query_construct): listen for remove signal as well
+
+	* pcs/cal.h: cal no longer takes uri during construction
+
+	* pcs/cal.c (backend_to_listener_status): convert backend to corba
+	status code
+	(impl_Cal_open): backend open no longer takes uri, use above to
+	send back status
+	(impl_Cal_remove): implement
+	(cal_construct): we no longer track the uri
+	(cal_finalize): ditto
+	(cal_class_init): set remove epv method
+
+	* pcs/cal-factory.c (impl_CalFactory_getCal): instantiate backend
+	with uri and kind properties
+
+	* pcs/cal-backend.h: list file status enum, add protos
+
+	* pcs/cal-backend.c (cal_backend_set_property): implement object
+	properties
+	(cal_backend_get_property): ditto
+	(cal_backend_class_init): add properties vmethods and uri, kind
+	properties, removed signal
+	(cal_backend_get_uri): don't get the uri from the backend
+	(cal_backend_get_kind): get the kind from the backend
+	(cal_backend_open): adapt to new open call, no uri passed in
+	(cal_backend_remove): call through to remove implementation
+	(cal_backend_opened): use new file status
+	(cal_backend_removed): emit removed signal
+
+	* pcs/cal-backend-file.h: update protos
+
+	* pcs/cal-backend-file.c (cal_backend_file_class_init): override
+	remove vmethod
+	(cal_backend_file_init): default file name to calendar.ics
+	(cal_backend_file_set_file_name): accessor for filename tacked on
+	to uri
+	(cal_backend_file_get_file_name): ditto
+	(open_cal): return "file" type status codes
+	(create_cal): ditto
+	(get_uri_string): construct the full uri string
+	(cal_backend_file_open): use above
+	(cal_backend_file_remove): implement
+
+	* pcs/cal-backend-file-todos.c (cal_backend_file_todos_init): set
+	the file name to tasks.ics
+
+	* pcs/cal-backend-file-events.c (cal_backend_file_events_init):
+	set the file name to calendar.ics
+
+	* cal-util/cal-util.c (cal_util_expand_uri): just return a copy of
+	the uri now
+
+	* idl/evolution-calendar.idl: convert OpenStatus to FileStatus so
+	remove() can use it as well
+
+	* gui/gnome-cal.c (gnome_calendar_open): just open the default
+	folder in all cases
+
+2003-08-12  Rodrigo Moya <rodrigo@ximian.com>
+
+	* cal-util/cal-util.[ch] (cal_util_component_has_alarms): new function.
+
+	* gui/gnome-cal.[ch]:
+	* gui/goto.c:
+	* gui/itip-bonobo-control.c:
+	* gui/print.c:
+	* gui/e-week-view.[ch]:
+	* gui/e-day-view.[ch]: lots of fixes to make all compile with no
+	warnings.
+
+2003-08-12  Rodrigo Moya <rodrigo@ximian.com>
 
+	* cal-util/cal-util.[ch] (cal_util_component_has_organizer):
+	new function.
+
+	* gui/e-day-view-main-item.c:
+	* gui/e-day-view-top-item.c:
+	* gui/e-week-view-event-item.c:
+	* gui/e-week-view.c: adaptated to changes in ECalViewEvent.
+
+	* gui/e-cal-model.[ch] (e_cal_model_get_client_list): new function.
+	(ecm_append_row): fixed usage of icalcomponent variable.
+
+	* gui/e-cal-view.c (e_cal_view_class_init): removed unused variable.
+	(selection_received): use default client for pasting from clipboard.
+	(e_cal_view_cut_clipboard): cut the appointment from its client.
+	(e_cal_view_copy_clipboard, delete_event, on_save_as, om_print_event,
+	e_cal_view_delete_selected_occurrence, on_meeting, on_forward,
+	e_cal_view_create_popup_menu): adapted to changes in ECalViewEvent.
+	(e_cal_view_delete_selected_event, e_cal_view_delete_selected_events):
+	pass the ECalViewEvent to delete_event, so that it knows which
+	CalClient to use.
+	(on_edit_appointment): pass CalClient and icalcomponent to
+	gnome_calendar_edit_object.
+	(on_publish): publish F/B info for all the clients currently loaded
+	in the view.
+	(setup_popup_icons): added missing argument to gtk_image_new_from_stock.
+
+	* gui/calendar-commands.c (publish_freebusy_cmd): publish F/B info
+	for all the clients currently loaded in the view.
+	(sensitize_calendar_commands): use icalcomponent functions.
+
+	* gui/e-day-view.c:
+	* gui/comp-editor-factory.c (impl_editExisting):
+	* gui/calendar-offline-handler.c (backend_cal_opened_online):
+	* gui/e-alarm-list.c (e_alarm_list_finalize):
+	* gui/e-cal-model-tasks.c (ecmt_get_color_for_component):
+	* gui/e-date-time-list.c (e_date_time_list_finalize):
+	* gui/control-factory.c (get_prop): fixed warnings.
+	
 2003-08-12  Hans Petter Jansson  <hpj@ximian.com>
 
 	* gui/calendar-offline-handler.c (impl_dispose): Chain. Prevent
@@ -799,6 +2817,27 @@
 	* cal-client/cal-client-multi.[ch]:
 	* cal-client/Makefile.am: removed obsolete code.
 
+2003-07-30  Ettore Perazzoli  <ettore@ximian.com>
+
+	* gui/main.c (factory): Do not depend on global_shell_client being
+	not NULL for creating the calendar preferences dialog.
+
+	* gui/e-itip-control.c (show_current): Don't call get_servers
+	anymore [to be fixed].
+	(get_servers): #if 0ed out.
+	(object_requested_cb): Don't create the folder selector button.
+
+	* gui/e-cal-view.c (e_cal_view_set_status_message): Don't create
+	an activity client.
+
+	* gui/calendar-model.c (calendar_model_set_status_message): Don't
+	create an activity client.
+
+	* gui/calendar-component.c: Removed global variable
+	global_shell_client.
+	(owner_set_cb): Don't set global_shell_client.
+	(owner_unset_cb): Don't set it here either.
+
 2003-07-29  Rodrigo Moya <rodrigo@ximian.com>
 
 	Fixes all "alarm daemon doesn't start with session"
diff --git a/calendar/cal-client/.cvsignore b/calendar/cal-client/.cvsignore
index 1537e6e01d..f2aa4f92ae 100644
--- a/calendar/cal-client/.cvsignore
+++ b/calendar/cal-client/.cvsignore
@@ -10,6 +10,8 @@ evolution-calendar.h
 evolution-calendar-common.lo
 evolution-calendar-skels.lo
 evolution-calendar-stubs.lo
+cal-marshal.c
+cal-marshal.h
 *.lo
 *.la
 client-test
diff --git a/calendar/cal-client/Makefile.am b/calendar/cal-client/Makefile.am
index 5e48e7db23..5f8b5a3cf1 100644
--- a/calendar/cal-client/Makefile.am
+++ b/calendar/cal-client/Makefile.am
@@ -38,6 +38,8 @@ libcal_clientincludedir = $(privincludedir)/cal-client
 libcal_client_la_SOURCES =	\
 	$(CORBA_GENERATED_C)	\
 	cal-client-types.c	\
+	cal-marshal.c	\
+	cal--marshal.h	\
 	cal-client.c		\
 	cal-listener.c		\
 	cal-listener.h		\
@@ -72,7 +74,10 @@ client_test_LDADD =			\
 	libcal-client.la		\
 	$(EVOLUTION_CALENDAR_LIBS)
 
-BUILT_SOURCES = $(CORBA_GENERATED)
+MARSHAL_GENERATED = cal-marshal.c cal-marshal.h
+@EVO_MARSHAL_RULE@
+
+BUILT_SOURCES = $(CORBA_GENERATED) $(MARSHAL_GENERATED)
 CLEANFILES = $(BUILT_SOURCES)
 
 dist-hook:
diff --git a/calendar/cal-client/cal-client-types.h b/calendar/cal-client/cal-client-types.h
index c160a1fa94..925628337b 100644
--- a/calendar/cal-client/cal-client-types.h
+++ b/calendar/cal-client/cal-client-types.h
@@ -29,6 +29,10 @@ G_BEGIN_DECLS
 
 
 
+#define E_CALENDAR_ERROR e_calendar_error_quark()
+
+GQuark e_calendar_error_quark (void) G_GNUC_CONST;
+
 typedef enum {
 	CAL_CLIENT_CHANGE_ADDED = 1 << 0,
 	CAL_CLIENT_CHANGE_MODIFIED = 1 << 1,
@@ -41,6 +45,28 @@ typedef struct
 	CalClientChangeType type;
 } CalClientChange;
 
+typedef enum {
+	E_CALENDAR_STATUS_OK,
+	E_CALENDAR_STATUS_INVALID_ARG,
+	E_CALENDAR_STATUS_BUSY,
+	E_CALENDAR_STATUS_REPOSITORY_OFFLINE,
+	E_CALENDAR_STATUS_NO_SUCH_CALENDAR,
+	E_CALENDAR_STATUS_OBJECT_NOT_FOUND,
+	E_CALENDAR_STATUS_INVALID_OBJECT,
+	E_CALENDAR_STATUS_URI_NOT_LOADED,
+	E_CALENDAR_STATUS_URI_ALREADY_LOADED,
+	E_CALENDAR_STATUS_PERMISSION_DENIED,
+	E_CALENDAR_STATUS_CARD_NOT_FOUND,
+	E_CALENDAR_STATUS_CARD_ID_ALREADY_EXISTS,
+	E_CALENDAR_STATUS_PROTOCOL_NOT_SUPPORTED,
+	E_CALENDAR_STATUS_CANCELLED,
+	E_CALENDAR_STATUS_COULD_NOT_CANCEL,
+	E_CALENDAR_STATUS_AUTHENTICATION_FAILED,
+	E_CALENDAR_STATUS_AUTHENTICATION_REQUIRED,
+	E_CALENDAR_STATUS_CORBA_EXCEPTION,
+	E_CALENDAR_STATUS_OTHER_ERROR
+} ECalendarStatus;
+
 void cal_client_change_list_free (GList *list);
 
 G_END_DECLS
diff --git a/calendar/cal-client/cal-client.c b/calendar/cal-client/cal-client.c
index e40d405120..95efdd6d5d 100644
--- a/calendar/cal-client/cal-client.c
+++ b/calendar/cal-client/cal-client.c
@@ -22,20 +22,39 @@
 #include <config.h>
 #endif
 
+#include <pthread.h>
 #include <string.h>
 #include <bonobo-activation/bonobo-activation.h>
 #include <bonobo/bonobo-exception.h>
+#include <bonobo/bonobo-i18n.h>
 #include <libgnome/gnome-util.h>
 
 #include "e-util/e-component-listener.h"
 #include "e-util/e-config-listener.h"
+#include "e-util/e-url.h"
+#include "e-util/e-msgport.h"
 #include "cal-util/cal-util-marshal.h"
-#include "cal-client-types.h"
+#include "cal-util/timeutil.h"
 #include "cal-client.h"
 #include "cal-listener.h"
+#include "query-listener.h"
 
 
 
+typedef struct {
+	EMutex *mutex;
+	pthread_cond_t cond;
+	ECalendarStatus status;
+
+	char *uid;
+	GList *list;
+	gboolean bool;
+	char *string;
+
+	CalQuery *query;
+	QueryListener *listener;
+} ECalendarOp;
+
 /* Private part of the CalClient structure */
 struct _CalClientPrivate {
 	/* Load state to avoid multiple loads */
@@ -45,7 +64,12 @@ struct _CalClientPrivate {
 	 * NULL if we are not loaded.
 	 */
 	char *uri;
+	CalObjType type;
+	
+	ECalendarOp *current_op;
 
+	EMutex *mutex;
+	
 	/* Email address associated with this calendar, or NULL */
 	char *cal_address;
 	char *alarm_email_address;
@@ -85,8 +109,6 @@ struct _CalClientPrivate {
 enum {
 	CAL_OPENED,
 	CAL_SET_MODE,
-	OBJ_UPDATED,
-	OBJ_REMOVED,
 	BACKEND_ERROR,
 	CATEGORIES_CHANGED,
 	FORGET_PASSWORD,
@@ -94,10 +116,6 @@ enum {
 	LAST_SIGNAL
 };
 
-static void cal_client_class_init (CalClientClass *klass);
-static void cal_client_init (CalClient *client, CalClientClass *klass);
-static void cal_client_finalize (GObject *object);
-
 static void cal_client_get_object_timezones_cb (icalparameter *param,
 						void *data);
 
@@ -105,36 +123,28 @@ static guint cal_client_signals[LAST_SIGNAL];
 
 static GObjectClass *parent_class;
 
+#define E_CALENDAR_CHECK_STATUS(status,error) G_STMT_START{		\
+	if ((status) == E_CALENDAR_STATUS_OK) {				\
+		return TRUE;						\
+	}								\
+	else {                                                          \
+                const char *msg;                                        \
+                msg = cal_client_get_error_message ((status));          \
+		g_set_error ((error), E_CALENDAR_ERROR, (status), msg, (status));	\
+		return FALSE;						\
+	}				}G_STMT_END
+
 
 
-/**
- * cal_client_get_type:
- *
- * Registers the #CalClient class if necessary, and returns the type ID assigned
- * to it.
- *
- * Return value: The type ID of the #CalClient class.
- **/
-GType
-cal_client_get_type (void)
+/* Error quark */
+GQuark
+e_calendar_error_quark (void)
 {
-	static GType cal_client_type = 0;
-
-	if (!cal_client_type) {
-		static GTypeInfo info = {
-                        sizeof (CalClientClass),
-                        (GBaseInitFunc) NULL,
-                        (GBaseFinalizeFunc) NULL,
-                        (GClassInitFunc) cal_client_class_init,
-                        NULL, NULL,
-                        sizeof (CalClient),
-                        0,
-                        (GInstanceInitFunc) cal_client_init
-                };
-		cal_client_type = g_type_register_static (G_TYPE_OBJECT, "CalClient", &info, 0);
-	}
+  static GQuark q = 0;
+  if (q == 0)
+    q = g_quark_from_static_string ("e-calendar-error-quark");
 
-	return cal_client_type;
+  return q;
 }
 
 GType
@@ -198,118 +208,48 @@ cal_mode_enum_get_type (void)
 	return cal_mode_enum_type;
 }
 
-/* Class initialization function for the calendar client */
-static void
-cal_client_class_init (CalClientClass *klass)
+/* EBookOp calls */
+
+static ECalendarOp*
+e_calendar_new_op (CalClient *client)
 {
-	GObjectClass *object_class;
+	ECalendarOp *op = g_new0 (ECalendarOp, 1);
 
-	object_class = (GObjectClass *) klass;
+	op->mutex = e_mutex_new (E_MUTEX_SIMPLE);
+	pthread_cond_init (&op->cond, 0);
 
-	parent_class = g_type_class_peek_parent (klass);
-
-	cal_client_signals[CAL_OPENED] =
-		g_signal_new ("cal_opened",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalClientClass, cal_opened),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__ENUM,
-			      G_TYPE_NONE, 1,
-			      CAL_CLIENT_OPEN_STATUS_ENUM_TYPE);
-	cal_client_signals[CAL_SET_MODE] =
-		g_signal_new ("cal_set_mode",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalClientClass, cal_set_mode),
-			      NULL, NULL,
-			      cal_util_marshal_VOID__ENUM_ENUM,
-			      G_TYPE_NONE, 2,
-			      CAL_CLIENT_SET_MODE_STATUS_ENUM_TYPE,
-			      CAL_MODE_ENUM_TYPE);
-	cal_client_signals[OBJ_UPDATED] =
-		g_signal_new ("obj_updated",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalClientClass, obj_updated),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__STRING,
-			      G_TYPE_NONE, 1,
-			      G_TYPE_STRING);
-	cal_client_signals[OBJ_REMOVED] =
-		g_signal_new ("obj_removed",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalClientClass, obj_removed),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__STRING,
-			      G_TYPE_NONE, 1,
-			      G_TYPE_STRING);
-	cal_client_signals[BACKEND_ERROR] =
-		g_signal_new ("backend_error",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalClientClass, backend_error),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__STRING,
-			      G_TYPE_NONE, 1,
-			      G_TYPE_STRING);
-	cal_client_signals[CATEGORIES_CHANGED] =
-		g_signal_new ("categories_changed",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalClientClass, categories_changed),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__POINTER,
-			      G_TYPE_NONE, 1,
-			      G_TYPE_POINTER);
-	cal_client_signals[FORGET_PASSWORD] =
-		g_signal_new ("forget_password",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalClientClass, forget_password),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__STRING,
-			      G_TYPE_NONE, 1,
-			      G_TYPE_STRING);
-	cal_client_signals[BACKEND_DIED] =
-		g_signal_new ("backend_died",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalClientClass, backend_died),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__VOID,
-			      G_TYPE_NONE, 0);
+	client->priv->current_op = op;
 
-	klass->cal_opened = NULL;
-	klass->obj_updated = NULL;
-	klass->obj_removed = NULL;
-	klass->categories_changed = NULL;
-	klass->forget_password = NULL;
-	klass->backend_died = NULL;
+	return op;
+}
 
-	object_class->finalize = cal_client_finalize;
+static ECalendarOp*
+e_calendar_get_op (CalClient *client)
+{
+	if (!client->priv->current_op) {
+		g_warning (G_STRLOC ": Unexpected response");
+		return NULL;
+	}
+		
+	return client->priv->current_op;
 }
 
-/* Object initialization function for the calendar client */
 static void
-cal_client_init (CalClient *client, CalClientClass *klass)
+e_calendar_free_op (ECalendarOp *op)
 {
-	CalClientPrivate *priv;
+	/* XXX more stuff here */
+	pthread_cond_destroy (&op->cond);
+	e_mutex_destroy (op->mutex);
+	g_free (op);
+}
 
-	priv = g_new0 (CalClientPrivate, 1);
-	client->priv = priv;
+static void
+e_calendar_remove_op (CalClient *client, ECalendarOp *op)
+{
+	if (client->priv->current_op != op)
+		g_warning (G_STRLOC ": Cannot remove op, it's not current");
 
-	priv->load_state = CAL_CLIENT_LOAD_NOT_LOADED;
-	priv->uri = NULL;
-	priv->cal_address = NULL;
-	priv->alarm_email_address = NULL;
-	priv->ldap_attribute = NULL;
-	priv->capabilities = FALSE;
-	priv->factories = NULL;
-	priv->timezones = g_hash_table_new (g_str_hash, g_str_equal);
-	priv->default_zone = icaltimezone_get_utc_timezone ();
-	priv->comp_listener = NULL;
+	client->priv->current_op = NULL;
 }
 
 /* Gets rid of the factories that a client knows about */
@@ -364,7 +304,7 @@ destroy_cal (CalClient *client)
 	CORBA_exception_init (&ev);
 	result = CORBA_Object_is_nil (priv->cal, &ev);
 	if (BONOBO_EX (&ev)) {
-		g_message ("destroy_cal(): could not see if the "
+		g_message (G_STRLOC ": could not see if the "
 			   "calendar client interface object was nil");
 		priv->cal = CORBA_OBJECT_NIL;
 		CORBA_exception_free (&ev);
@@ -375,19 +315,7 @@ destroy_cal (CalClient *client)
 	if (result)
 		return;
 
-	CORBA_exception_init (&ev);
-	GNOME_Evolution_Calendar_Cal_unref (priv->cal, &ev);
-	if (BONOBO_EX (&ev))
-		g_message ("destroy_cal(): could not unref the calendar client interface object");
-
-	CORBA_exception_free (&ev);
-
-	CORBA_exception_init (&ev);
-	CORBA_Object_release (priv->cal, &ev);
-	if (BONOBO_EX (&ev))
-		g_message ("destroy_cal(): could not release the calendar client interface object");
-
-	CORBA_exception_free (&ev);
+	bonobo_object_release_unref (priv->cal, NULL);	
 	priv->cal = CORBA_OBJECT_NIL;
 
 }
@@ -400,184 +328,541 @@ free_timezone (gpointer key, gpointer value, gpointer data)
 	icaltimezone_free (value, TRUE);
 }
 
-/* Finalize handler for the calendar client */
+
+
 static void
-cal_client_finalize (GObject *object)
+backend_died_cb (EComponentListener *cl, gpointer user_data)
 {
-	CalClient *client;
 	CalClientPrivate *priv;
+	CalClient *client = (CalClient *) user_data;
 
-	g_return_if_fail (object != NULL);
-	g_return_if_fail (IS_CAL_CLIENT (object));
+	g_return_if_fail (IS_CAL_CLIENT (client));
 
-	client = CAL_CLIENT (object);
 	priv = client->priv;
+	priv->load_state = CAL_CLIENT_LOAD_NOT_LOADED;
+	g_signal_emit (G_OBJECT (client), cal_client_signals[BACKEND_DIED], 0);
+}
 
-	if (priv->listener) {
-		cal_listener_stop_notification (priv->listener);
-		bonobo_object_unref (priv->listener);
-		priv->listener = NULL;
+/* Signal handlers for the listener's signals */
+/* Handle the cal_opened notification from the listener */
+
+static void
+cal_read_only_cb (CalListener *listener, ECalendarStatus status, gboolean read_only, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
 	}
 
-	if (priv->comp_listener) {
-		g_signal_handlers_disconnect_matched (G_OBJECT (priv->comp_listener),
-						      G_SIGNAL_MATCH_DATA,
-						      0, 0, NULL, NULL,
-						      client);
-		g_object_unref (G_OBJECT (priv->comp_listener));
-		priv->comp_listener = NULL;
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->bool = read_only;
+
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_cal_address_cb (CalListener *listener, ECalendarStatus status, const char *address, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
 	}
 
-	destroy_factories (client);
-	destroy_cal (client);
+	e_mutex_lock (op->mutex);
 
-	priv->load_state = CAL_CLIENT_LOAD_NOT_LOADED;
+	op->status = status;
+	op->string = g_strdup (address);
 
-	if (priv->uri) {
-		g_free (priv->uri);
-		priv->uri = NULL;
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_alarm_address_cb (CalListener *listener, ECalendarStatus status, const char *address, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
 	}
 
-	if (priv->cal_address) {
-		g_free (priv->cal_address);
-		priv->cal_address = NULL;
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->string = g_strdup (address);
+
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_ldap_attribute_cb (CalListener *listener, ECalendarStatus status, const char *attribute, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
 	}
-	if (priv->alarm_email_address) {
-		g_free (priv->alarm_email_address);
-		priv->alarm_email_address = NULL;
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->string = g_strdup (attribute);
+
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_static_capabilities_cb (CalListener *listener, ECalendarStatus status, const char *capabilities, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
 	}
-	if (priv->ldap_attribute) {
-		g_free (priv->ldap_attribute);
-		priv->ldap_attribute = NULL;
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->string = g_strdup (capabilities);
+
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_opened_cb (CalListener *listener, ECalendarStatus status, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
 	}
-	if (priv->capabilities) {
-		g_free (priv->capabilities);
-		priv->capabilities = NULL;
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_removed_cb (CalListener *listener, ECalendarStatus status, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
 	}
 
-	g_hash_table_foreach (priv->timezones, free_timezone, NULL);
-	g_hash_table_destroy (priv->timezones);
-	priv->timezones = NULL;
+	e_mutex_lock (op->mutex);
 
-	g_free (priv);
-	client->priv = NULL;
+	op->status = status;
 
-	if (G_OBJECT_CLASS (parent_class)->finalize)
-		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
 }
 
-
+static void
+cal_object_created_cb (CalListener *listener, ECalendarStatus status, const char *uid, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->uid = g_strdup (uid);
+	
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
 
 static void
-backend_died_cb (EComponentListener *cl, gpointer user_data)
+cal_object_modified_cb (CalListener *listener, ECalendarStatus status, gpointer data)
 {
-	CalClientPrivate *priv;
-	CalClient *client = (CalClient *) user_data;
+	CalClient *client = data;
+	ECalendarOp *op;
 
-	g_return_if_fail (IS_CAL_CLIENT (client));
+	op = e_calendar_get_op (client);
 
-	priv = client->priv;
-	priv->load_state = CAL_CLIENT_LOAD_NOT_LOADED;
-	g_signal_emit (G_OBJECT (client), cal_client_signals[BACKEND_DIED], 0);
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
 }
 
-/* Signal handlers for the listener's signals */
-/* Handle the cal_opened notification from the listener */
 static void
-cal_opened_cb (CalListener *listener,
-	       GNOME_Evolution_Calendar_Listener_OpenStatus status,
-	       GNOME_Evolution_Calendar_Cal cal,
-	       gpointer data)
+cal_object_removed_cb (CalListener *listener, ECalendarStatus status, gpointer data)
 {
-	CalClient *client;
-	CalClientPrivate *priv;
-	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_Cal cal_copy;
-	CalClientOpenStatus client_status;
+	CalClient *client = data;
+	ECalendarOp *op;
 
-	client = CAL_CLIENT (data);
-	priv = client->priv;
+	op = e_calendar_get_op (client);
 
-	g_assert (priv->load_state == CAL_CLIENT_LOAD_LOADING);
-	g_assert (priv->uri != NULL);
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
 
-	client_status = CAL_CLIENT_OPEN_ERROR;
+	e_mutex_lock (op->mutex);
 
-	switch (status) {
-	case GNOME_Evolution_Calendar_Listener_SUCCESS:
-		CORBA_exception_init (&ev);
-		cal_copy = CORBA_Object_duplicate (cal, &ev);
-		if (BONOBO_EX (&ev)) {
-			g_message ("cal_opened_cb(): could not duplicate the "
-				   "calendar client interface");
-			CORBA_exception_free (&ev);
-			goto error;
-		}
-		CORBA_exception_free (&ev);
+	op->status = status;
 
-		priv->cal = cal_copy;
-		priv->load_state = CAL_CLIENT_LOAD_LOADED;
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
 
-		client_status = CAL_CLIENT_OPEN_SUCCESS;
+static void
+cal_alarm_discarded_cb (CalListener *listener, ECalendarStatus status, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
 
-		/* setup component listener */
-		priv->comp_listener = e_component_listener_new (priv->cal);
-		g_signal_connect (G_OBJECT (priv->comp_listener), "component_died",
-				  G_CALLBACK (backend_died_cb), client);
-		goto out;
+	op = e_calendar_get_op (client);
 
-	case GNOME_Evolution_Calendar_Listener_ERROR:
-		client_status = CAL_CLIENT_OPEN_ERROR;
-		goto error;
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
 
-	case GNOME_Evolution_Calendar_Listener_NOT_FOUND:
-		client_status = CAL_CLIENT_OPEN_NOT_FOUND;
-		goto error;
+	e_mutex_lock (op->mutex);
 
-	case GNOME_Evolution_Calendar_Listener_METHOD_NOT_SUPPORTED:
-		client_status = CAL_CLIENT_OPEN_METHOD_NOT_SUPPORTED;
-		goto error;
+	op->status = status;
 
-	case GNOME_Evolution_Calendar_Listener_PERMISSION_DENIED :
-		client_status = CAL_CLIENT_OPEN_PERMISSION_DENIED;
-		goto error;
+	pthread_cond_signal (&op->cond);
 
-	default:
-		g_assert_not_reached ();
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_objects_received_cb (CalListener *listener, ECalendarStatus status, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
 	}
 
- error:
+	e_mutex_lock (op->mutex);
 
-	bonobo_object_unref (BONOBO_OBJECT (priv->listener));
-	priv->listener = NULL;
+	op->status = status;
 
-	/* We free the priv->uri and set the priv->load_state until after the
-	 * "cal_opened" signal has been emitted so that handlers will be able to
-	 * access this information.
-	 */
+	pthread_cond_signal (&op->cond);
 
- out:
+	e_mutex_unlock (op->mutex);
+}
 
-	/* We are *not* inside a signal handler (this is just a simple callback
-	 * called from the listener), so there is not a temporary reference to
-	 * the client object.  We ref() so that we can safely emit our own
-	 * signal and clean up.
-	 */
+static void
+cal_objects_sent_cb (CalListener *listener, ECalendarStatus status, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
 
-	g_object_ref (G_OBJECT (client));
+	op = e_calendar_get_op (client);
 
-	g_signal_emit (G_OBJECT (client), cal_client_signals[CAL_OPENED],
-		       0, client_status);
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
 
-	if (client_status != CAL_CLIENT_OPEN_SUCCESS) {
-		priv->load_state = CAL_CLIENT_LOAD_NOT_LOADED;
-		g_free (priv->uri);
-		priv->uri = NULL;
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_default_object_requested_cb (CalListener *listener, ECalendarStatus status, const char *object, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
 	}
 
-	g_assert (priv->load_state != CAL_CLIENT_LOAD_LOADING);
+	e_mutex_lock (op->mutex);
 
-	g_object_unref (G_OBJECT (client));
+	op->status = status;
+	op->string = g_strdup (object);
+	
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_object_requested_cb (CalListener *listener, ECalendarStatus status, const char *object, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->string = g_strdup (object);
+	
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_object_list_cb (CalListener *listener, ECalendarStatus status, GList *objects, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+	GList *l;
+	
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->list = g_list_copy (objects);
+	
+	for (l = op->list; l; l = l->next)
+		l->data = icalcomponent_new_clone (l->data);
+	
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_get_timezone_cb (CalListener *listener, ECalendarStatus status, const char *object, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->string = g_strdup (object);
+
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+
+}
+
+static void
+cal_add_timezone_cb (CalListener *listener, ECalendarStatus status, const char *tzid, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->uid = g_strdup (tzid);
+
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+
+}
+
+static void
+cal_set_default_timezone_cb (CalListener *listener, ECalendarStatus status, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_get_changes_cb (CalListener *listener, ECalendarStatus status, GList *changes, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+	GList *l;
+	
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->list = g_list_copy (changes);
+
+	for (l = op->list; l; l = l->next) {
+		CalClientChange *ccc = l->data, *new_ccc;
+
+		new_ccc = g_new (CalClientChange, 1);
+		new_ccc->comp = cal_component_clone (ccc->comp);
+		new_ccc->type = ccc->type;
+		
+		l->data = new_ccc;
+	}
+	
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_get_free_busy_cb (CalListener *listener, ECalendarStatus status, GList *freebusy, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+	GList *l;
+	
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->list = g_list_copy (freebusy);
+
+	for (l = op->list; l; l = l->next)
+		l->data = cal_component_clone (l->data);
+
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);
+}
+
+static void
+cal_query_cb (CalListener *listener, ECalendarStatus status, GNOME_Evolution_Calendar_Query query, gpointer data)
+{
+	CalClient *client = data;
+	ECalendarOp *op;
+	
+	op = e_calendar_get_op (client);
+
+	if (op == NULL) {
+		g_warning (G_STRLOC ": Cannot find operation ");
+		return;
+	}
+
+	e_mutex_lock (op->mutex);
+
+	op->status = status;
+	op->query = cal_query_new (query, op->listener, client);
+	
+	pthread_cond_signal (&op->cond);
+
+	e_mutex_unlock (op->mutex);	
 }
 
 /* Handle the cal_set_mode notification from the listener */
@@ -624,26 +909,6 @@ cal_set_mode_cb (CalListener *listener,
 	g_object_unref (G_OBJECT (client));
 }
 
-/* Handle the obj_updated signal from the listener */
-static void
-obj_updated_cb (CalListener *listener, const CORBA_char *uid, gpointer data)
-{
-	CalClient *client;
-
-	client = CAL_CLIENT (data);
-	g_signal_emit (G_OBJECT (client), cal_client_signals[OBJ_UPDATED], 0, uid);
-}
-
-/* Handle the obj_removed signal from the listener */
-static void
-obj_removed_cb (CalListener *listener, const CORBA_char *uid, gpointer data)
-{
-	CalClient *client;
-
-	client = CAL_CLIENT (data);
-	g_signal_emit (G_OBJECT (client), cal_client_signals[OBJ_REMOVED], 0, uid);
-}
-
 /* Handle the error_occurred signal from the listener */
 static void
 backend_error_cb (CalListener *listener, const char *message, gpointer data)
@@ -678,97 +943,343 @@ categories_changed_cb (CalListener *listener, const GNOME_Evolution_Calendar_Str
 
 
 
-static GList *
-get_factories (void)
+static gboolean 
+get_factories (const char *str_uri, GList **factories)
 {
-	GList *factories = NULL;
 	GNOME_Evolution_Calendar_CalFactory factory;
 	Bonobo_ServerInfoList *servers;
-	CORBA_Environment ev;
+	EUri *uri;
+	char *query;
 	int i;
 
-	CORBA_exception_init (&ev);
 
-	servers = bonobo_activation_query ("repo_ids.has ('IDL:GNOME/Evolution/Calendar/CalFactory:1.0')", NULL, &ev);
-	if (ev._major != CORBA_NO_EXCEPTION) {
-		g_message ("Cannot perform OAF query for Calendar servers.");
-		CORBA_exception_free (&ev);
-		return NULL;
+	/* Determine the protocol and query for factory supporting that */
+	uri = e_uri_new (str_uri);
+	if (!uri) {
+		g_warning (G_STRLOC ": Invalid uri string");
+		
+		return FALSE;
 	}
 
-	if (servers->_length == 0)
-		g_warning ("No Calendar servers installed.");
+	query = g_strdup_printf ("repo_ids.has ('IDL:GNOME/Evolution/Calendar/CalFactory:1.0')"
+				 " AND calendar:supported_protocols.has ('%s')", uri->protocol);
+
+	
+	servers = bonobo_activation_query (query, NULL, NULL);
+
+	g_free (query);
+	e_uri_free (uri);
 
+	if (!servers) {
+		g_warning (G_STRLOC ": Unable to query for calendar factories");
+		
+		return FALSE;
+	}	
+	
+	/* Try to activate the servers for the protocol */
 	for (i = 0; i < servers->_length; i++) {
 		const Bonobo_ServerInfo *info;
 
 		info = servers->_buffer + i;
 
-		factory = (GNOME_Evolution_Calendar_CalFactory)
-			bonobo_activation_activate_from_id (info->iid, 0, NULL, &ev);
-		if (BONOBO_EX (&ev)) {
-#if 0
-			g_warning ("cal_client_construct: Could not activate calendar server %s", info->iid);
-			CORBA_free (servers);
-			CORBA_exception_free (&ev);
-			return NULL;
-#endif
-		}
+		g_message (G_STRLOC ": Activating calendar factory (%s)", info->iid);
+		factory = bonobo_activation_activate_from_id (info->iid, 0, NULL, NULL);
+		
+		if (factory == CORBA_OBJECT_NIL)
+			g_warning (G_STRLOC ": Could not activate calendar factory (%s)", info->iid);
 		else
-		  factories = g_list_prepend (factories, factory);
+			*factories = g_list_append (*factories, factory);
 	}
 
 	CORBA_free (servers);
-	CORBA_exception_free (&ev);
-	return factories;
+
+	return TRUE;
+}
+
+/* Object initialization function for the calendar client */
+static void
+cal_client_init (CalClient *client, CalClientClass *klass)
+{
+	CalClientPrivate *priv;
+
+	priv = g_new0 (CalClientPrivate, 1);
+	client->priv = priv;
+
+	priv->load_state = CAL_CLIENT_LOAD_NOT_LOADED;
+	priv->uri = NULL;
+	priv->mutex = e_mutex_new (E_MUTEX_REC);
+	priv->listener = cal_listener_new (cal_set_mode_cb,
+					   backend_error_cb,
+					   categories_changed_cb,
+					   client);
+
+	priv->cal_address = NULL;
+	priv->alarm_email_address = NULL;
+	priv->ldap_attribute = NULL;
+	priv->capabilities = FALSE;
+	priv->factories = NULL;
+	priv->timezones = g_hash_table_new (g_str_hash, g_str_equal);
+	priv->default_zone = icaltimezone_get_utc_timezone ();
+	priv->comp_listener = NULL;
+
+	g_signal_connect (G_OBJECT (priv->listener), "read_only", G_CALLBACK (cal_read_only_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "cal_address", G_CALLBACK (cal_cal_address_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "alarm_address", G_CALLBACK (cal_alarm_address_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "ldap_attribute", G_CALLBACK (cal_ldap_attribute_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "static_capabilities", G_CALLBACK (cal_static_capabilities_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "open", G_CALLBACK (cal_opened_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "remove", G_CALLBACK (cal_removed_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "create_object", G_CALLBACK (cal_object_created_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "modify_object", G_CALLBACK (cal_object_modified_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "remove_object", G_CALLBACK (cal_object_removed_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "discard_alarm", G_CALLBACK (cal_alarm_discarded_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "receive_objects", G_CALLBACK (cal_objects_received_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "send_objects", G_CALLBACK (cal_objects_sent_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "default_object", G_CALLBACK (cal_default_object_requested_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "object", G_CALLBACK (cal_object_requested_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "object_list", G_CALLBACK (cal_object_list_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "get_timezone", G_CALLBACK (cal_get_timezone_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "add_timezone", G_CALLBACK (cal_add_timezone_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "set_default_timezone", G_CALLBACK (cal_set_default_timezone_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "get_changes", G_CALLBACK (cal_get_changes_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "get_free_busy", G_CALLBACK (cal_get_free_busy_cb), client);
+	g_signal_connect (G_OBJECT (priv->listener), "query", G_CALLBACK (cal_query_cb), client);
+}
+
+/* Finalize handler for the calendar client */
+static void
+cal_client_finalize (GObject *object)
+{
+	CalClient *client;
+	CalClientPrivate *priv;
+
+	g_return_if_fail (object != NULL);
+	g_return_if_fail (IS_CAL_CLIENT (object));
+
+	client = CAL_CLIENT (object);
+	priv = client->priv;
+
+	if (priv->listener) {
+		cal_listener_stop_notification (priv->listener);
+		bonobo_object_unref (priv->listener);
+		priv->listener = NULL;
+	}
+
+	if (priv->comp_listener) {
+		g_signal_handlers_disconnect_matched (G_OBJECT (priv->comp_listener),
+						      G_SIGNAL_MATCH_DATA,
+						      0, 0, NULL, NULL,
+						      client);
+		g_object_unref (G_OBJECT (priv->comp_listener));
+		priv->comp_listener = NULL;
+	}
+
+	destroy_factories (client);
+	destroy_cal (client);
+
+	priv->load_state = CAL_CLIENT_LOAD_NOT_LOADED;
+
+	if (priv->uri) {
+		g_free (priv->uri);
+		priv->uri = NULL;
+	}
+
+	if (priv->mutex) {
+		e_mutex_destroy (priv->mutex);
+		priv->mutex = NULL;
+	}
+	
+	if (priv->cal_address) {
+		g_free (priv->cal_address);
+		priv->cal_address = NULL;
+	}
+	if (priv->alarm_email_address) {
+		g_free (priv->alarm_email_address);
+		priv->alarm_email_address = NULL;
+	}
+	if (priv->ldap_attribute) {
+		g_free (priv->ldap_attribute);
+		priv->ldap_attribute = NULL;
+	}
+	if (priv->capabilities) {
+		g_free (priv->capabilities);
+		priv->capabilities = NULL;
+	}
+
+	g_hash_table_foreach (priv->timezones, free_timezone, NULL);
+	g_hash_table_destroy (priv->timezones);
+	priv->timezones = NULL;
+
+	g_free (priv);
+	client->priv = NULL;
+
+	if (G_OBJECT_CLASS (parent_class)->finalize)
+		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
+}
+
+/* Class initialization function for the calendar client */
+static void
+cal_client_class_init (CalClientClass *klass)
+{
+	GObjectClass *object_class;
+
+	object_class = (GObjectClass *) klass;
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	cal_client_signals[CAL_OPENED] =
+		g_signal_new ("cal_opened",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (CalClientClass, cal_opened),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__ENUM,
+			      G_TYPE_NONE, 1,
+			      CAL_CLIENT_OPEN_STATUS_ENUM_TYPE);
+	cal_client_signals[CAL_SET_MODE] =
+		g_signal_new ("cal_set_mode",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (CalClientClass, cal_set_mode),
+			      NULL, NULL,
+			      cal_util_marshal_VOID__ENUM_ENUM,
+			      G_TYPE_NONE, 2,
+			      CAL_CLIENT_SET_MODE_STATUS_ENUM_TYPE,
+			      CAL_MODE_ENUM_TYPE);
+	cal_client_signals[BACKEND_ERROR] =
+		g_signal_new ("backend_error",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (CalClientClass, backend_error),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__STRING,
+			      G_TYPE_NONE, 1,
+			      G_TYPE_STRING);
+	cal_client_signals[CATEGORIES_CHANGED] =
+		g_signal_new ("categories_changed",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (CalClientClass, categories_changed),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__POINTER,
+			      G_TYPE_NONE, 1,
+			      G_TYPE_POINTER);
+	cal_client_signals[FORGET_PASSWORD] =
+		g_signal_new ("forget_password",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (CalClientClass, forget_password),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__STRING,
+			      G_TYPE_NONE, 1,
+			      G_TYPE_STRING);
+	cal_client_signals[BACKEND_DIED] =
+		g_signal_new ("backend_died",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (CalClientClass, backend_died),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__VOID,
+			      G_TYPE_NONE, 0);
+
+	klass->cal_opened = NULL;
+	klass->categories_changed = NULL;
+	klass->forget_password = NULL;
+	klass->backend_died = NULL;
+
+	object_class->finalize = cal_client_finalize;
 }
 
 /**
- * cal_client_construct:
- * @client: A calendar client.
+ * cal_client_get_type:
  *
- * Constructs a calendar client object by contacting all available
- * calendar factories.
+ * Registers the #CalClient class if necessary, and returns the type ID assigned
+ * to it.
  *
- * Return value: The same object as the @client argument, or NULL if the
- * calendar factory could not be contacted.
+ * Return value: The type ID of the #CalClient class.
  **/
-CalClient *
-cal_client_construct (CalClient *client)
+GType
+cal_client_get_type (void)
 {
-	CalClientPrivate *priv;
+	static GType cal_client_type = 0;
 
-	g_return_val_if_fail (client != NULL, NULL);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), NULL);
+	if (!cal_client_type) {
+		static GTypeInfo info = {
+                        sizeof (CalClientClass),
+                        (GBaseInitFunc) NULL,
+                        (GBaseFinalizeFunc) NULL,
+                        (GClassInitFunc) cal_client_class_init,
+                        NULL, NULL,
+                        sizeof (CalClient),
+                        0,
+                        (GInstanceInitFunc) cal_client_init
+                };
+		cal_client_type = g_type_register_static (G_TYPE_OBJECT, "CalClient", &info, 0);
+	}
 
+	return cal_client_type;
+}
+
+
+static gboolean
+fetch_corba_cal (CalClient *client, const char *str_uri, CalObjType type)
+{
+	CalClientPrivate *priv;
+	GList *f;
+	CORBA_Environment ev;
+	
 	priv = client->priv;
-	priv->factories = get_factories ();
+	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_NOT_LOADED, FALSE);
+	g_assert (priv->uri == NULL);
 
-	return client;
+	g_return_val_if_fail (str_uri != NULL, FALSE);
+
+	if (!get_factories (str_uri, &priv->factories))
+		return FALSE;
+
+	priv->uri = g_strdup (str_uri);
+	priv->type = type;
+
+	for (f = priv->factories; f; f = f->next) {
+		GNOME_Evolution_Calendar_Cal cal;
+
+		CORBA_exception_init (&ev);
+
+		cal = GNOME_Evolution_Calendar_CalFactory_getCal (f->data, priv->uri, priv->type,
+								  BONOBO_OBJREF (priv->listener), &ev);
+		if (BONOBO_EX (&ev))
+			continue;
+		
+		priv->cal = cal;
+
+		return TRUE;
+	}
+
+	return FALSE;
 }
 
 /**
  * cal_client_new:
  *
  * Creates a new calendar client.  It should be initialized by calling
- * cal_client_open_calendar().
+ * cal_client_open().
  *
  * Return value: A newly-created calendar client, or NULL if the client could
  * not be constructed because it could not contact the calendar server.
  **/
 CalClient *
-cal_client_new (void)
+cal_client_new (const char *uri, CalObjType type)
 {
 	CalClient *client;
 
 	client = g_object_new (CAL_CLIENT_TYPE, NULL);
 
-	if (!cal_client_construct (client)) {
-		g_message ("cal_client_new(): could not construct the calendar client");
-		g_object_unref (G_OBJECT (client));
+	if (!fetch_corba_cal (client, uri, type)) {
+		g_object_unref (client);
+
 		return NULL;
 	}
-
+	
 	return client;
 }
 
@@ -800,74 +1311,8 @@ cal_client_set_auth_func (CalClient *client, CalClientAuthFunc func, gpointer da
 	client->priv->auth_user_data = data;
 }
 
-static gboolean
-real_open_calendar (CalClient *client, const char *str_uri, gboolean only_if_exists, gboolean *supported)
-{
-	CalClientPrivate *priv;
-	GNOME_Evolution_Calendar_Listener corba_listener;
-	int unsupported;
-	GList *f;
-	CORBA_Environment ev;
-	
-	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_NOT_LOADED, FALSE);
-	g_assert (priv->uri == NULL);
-
-	g_return_val_if_fail (str_uri != NULL, FALSE);
-
-	priv->listener = cal_listener_new (cal_opened_cb,
-					   cal_set_mode_cb,
-					   obj_updated_cb,
-					   obj_removed_cb,
-					   backend_error_cb,
-					   categories_changed_cb,
-					   client);
-	if (!priv->listener) {
-		g_message ("cal_client_open_calendar(): could not create the listener");
-		return FALSE;
-	}
-
-	corba_listener = (GNOME_Evolution_Calendar_Listener) (BONOBO_OBJREF (priv->listener));
-
-	priv->load_state = CAL_CLIENT_LOAD_LOADING;
-	priv->uri = g_strdup (str_uri);
-
-	unsupported = 0;
-	for (f = priv->factories; f; f = f->next) {
-		CORBA_exception_init (&ev);
-
-		GNOME_Evolution_Calendar_CalFactory_open (f->data, str_uri,
-							  only_if_exists,
-							  corba_listener, &ev);
-		if (!BONOBO_EX (&ev)) {
-			if (supported != NULL)
-				*supported = TRUE;
-			return TRUE;
-		}
-
-		if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_CalFactory_UnsupportedMethod))
-			unsupported++;
-		CORBA_exception_free (&ev);
-	}
-
-	if (supported != NULL) {
-		if (unsupported == g_list_length (priv->factories))
-			*supported = FALSE;
-		else
-			*supported = TRUE;
-	}
-	
-	bonobo_object_unref (BONOBO_OBJECT (priv->listener));
-	priv->listener = NULL;
-	priv->load_state = CAL_CLIENT_LOAD_NOT_LOADED;
-	g_free (priv->uri);
-	priv->uri = NULL;
-
-	return FALSE;
-}
-
 /**
- * cal_client_open_calendar:
+ * cal_client_open
  * @client: A calendar client.
  * @str_uri: URI of calendar to open.
  * @only_if_exists: FALSE if the calendar should be opened even if there
@@ -882,93 +1327,167 @@ real_open_calendar (CalClient *client, const char *str_uri, gboolean only_if_exi
  * Return value: TRUE on success, FALSE on failure to issue the open request.
  **/
 gboolean
-cal_client_open_calendar (CalClient *client, const char *str_uri, gboolean only_if_exists)
+cal_client_open (CalClient *client, gboolean only_if_exists, GError **error)
 {
+	CalClientPrivate *priv;
+	CORBA_Environment ev;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
+	
 	g_return_val_if_fail (client != NULL, FALSE);
 	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
-	return real_open_calendar (client, str_uri, only_if_exists, NULL);
-}
+	priv = client->priv;
+	
+	e_mutex_lock (client->priv->mutex);
 
-static char *
-get_fall_back_uri (gboolean tasks)
-{
-	if (tasks)
-		return g_concat_dir_and_file (g_get_home_dir (),
-					      "evolution/local/"
-					      "Tasks/tasks.ics");
-	else
-		return g_concat_dir_and_file (g_get_home_dir (),
-					      "evolution/local/"
-					      "Calendar/calendar.ics");
-}
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
 
-static char *
-get_default_uri (gboolean tasks)
-{
-	EConfigListener *db;
-	char *uri;
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
+
+	CORBA_exception_init (&ev);
+
+	priv->load_state = CAL_CLIENT_LOAD_LOADING;
+
+	GNOME_Evolution_Calendar_Cal_open (priv->cal, only_if_exists, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		g_signal_emit (G_OBJECT (client), cal_client_signals[CAL_OPENED], 0,
+			       E_CALENDAR_STATUS_CORBA_EXCEPTION);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
+	}
+
+	CORBA_exception_free (&ev);
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
 
-	db = e_config_listener_new ();
+	status = our_op->status;
 	
-	if (tasks)
-		uri = e_config_listener_get_string (db, "/apps/evolution/shell/default_folders/tasks_uri");
-	else
-		uri = e_config_listener_get_string (db, "/apps/evolution/shell/default_folders/calendar_uri");
-	g_object_unref (G_OBJECT (db));
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
 
-	if (!uri || *uri == '\0')
-		uri = get_fall_back_uri (tasks);
+	if (status == E_CALENDAR_STATUS_OK)
+		priv->load_state = CAL_CLIENT_LOAD_LOADED;
 	else
-		uri = cal_util_expand_uri (uri, tasks);
-	
-	return uri;
+		priv->load_state = CAL_CLIENT_LOAD_NOT_LOADED;
+
+	g_signal_emit (G_OBJECT (client), cal_client_signals[CAL_OPENED], 0, status);
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
-gboolean
-cal_client_open_default_calendar (CalClient *client, gboolean only_if_exists)
+typedef struct {
+	CalClient *client;
+	
+	gboolean exists;
+} CalClientAsyncData;
+
+static gboolean
+open_async (gpointer data) 
 {
-	char *default_uri, *fall_back;
-	gboolean result, supported;
+	CalClientAsyncData *ccad = data;
+	GError *error = NULL;
 
-	g_return_val_if_fail (client != NULL, FALSE);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
+	cal_client_open (ccad->client, ccad->exists, &error);
 
-	default_uri = get_default_uri (FALSE);
-	fall_back = get_fall_back_uri (FALSE);
-	
-	result = real_open_calendar (client, default_uri, only_if_exists, &supported);
-	if (!supported && strcmp (fall_back, default_uri))
-		result = real_open_calendar (client, fall_back, only_if_exists, NULL);
+	g_clear_error (&error);
 
-	g_free (default_uri);
-	g_free (fall_back);
+	g_object_unref (ccad);
+	g_free (ccad);
 	
-	return result;
+	return FALSE;	
 }
 
-gboolean
-cal_client_open_default_tasks (CalClient *client, gboolean only_if_exists)
+void
+cal_client_open_async (CalClient *client, gboolean only_if_exists)
 {
-	char *default_uri, *fall_back;
-	gboolean result, supported;
+	CalClientAsyncData *ccad;
+	
+	g_return_if_fail (client != NULL);
+	g_return_if_fail (IS_CAL_CLIENT (client));
+
+	ccad = g_new0 (CalClientAsyncData, 1);
+	ccad->client = g_object_ref (client);
+	ccad->exists = only_if_exists;
 
+	/* FIXME This should really spawn a new thread */
+	g_idle_add (open_async, ccad);
+}
+
+gboolean 
+cal_client_remove_calendar (CalClient *client, GError **error)
+{
+	CalClientPrivate *priv;
+	CORBA_Environment ev;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
+	
 	g_return_val_if_fail (client != NULL, FALSE);
 	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
-	default_uri = get_default_uri (TRUE);
-	fall_back = get_fall_back_uri (TRUE);
+	priv = client->priv;
+	
+	e_mutex_lock (client->priv->mutex);
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
 
-	result = real_open_calendar (client, default_uri, only_if_exists, &supported);
-	if (!supported && strcmp (fall_back, default_uri))
-		result = real_open_calendar (client, fall_back, only_if_exists, NULL);
+	e_mutex_lock (our_op->mutex);
 
-	g_free (default_uri);
-	g_free (fall_back);
+	e_mutex_unlock (client->priv->mutex);
+
+
+	CORBA_exception_init (&ev);
 
-	return result;
+	GNOME_Evolution_Calendar_Cal_remove (priv->cal, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
+	}
+
+	CORBA_exception_free (&ev);
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
+#if 0
 /* Builds an URI list out of a CORBA string sequence */
 static GList *
 build_uri_list (GNOME_Evolution_Calendar_StringSeq *seq)
@@ -981,6 +1500,7 @@ build_uri_list (GNOME_Evolution_Calendar_StringSeq *seq)
 
 	return uris;
 }
+#endif
 
 /**
  * cal_client_uri_list:
@@ -993,6 +1513,7 @@ build_uri_list (GNOME_Evolution_Calendar_StringSeq *seq)
 GList *
 cal_client_uri_list (CalClient *client, CalMode mode)
 {
+#if 0
 	CalClientPrivate *priv;
 	GNOME_Evolution_Calendar_StringSeq *uri_seq;
 	GList *uris = NULL;	
@@ -1026,8 +1547,12 @@ cal_client_uri_list (CalClient *client, CalMode mode)
 	}
 	
 	return uris;	
+#endif
+
+	return NULL;
 }
 
+
 /**
  * cal_client_get_load_state:
  * @client: A calendar client.
@@ -1076,33 +1601,72 @@ cal_client_get_uri (CalClient *client)
  * @client: A calendar client.
  *
  * Queries whether the calendar client can perform modifications
- * on the calendar or not.
+ * on the calendar or not. Whether the backend is read only or not
+ * is specified, on exit, in the @read_only argument.
  *
- * Return value: TRUE if the calendar is read-only, FALSE otherwise.
+ * Return value: TRUE if the call was successful, FALSE if there was an error.
  */
 gboolean
-cal_client_is_read_only (CalClient *client)
+cal_client_is_read_only (CalClient *client, gboolean *read_only, GError **error)
 {
 	CalClientPrivate *priv;
 	CORBA_Environment ev;
-	CORBA_boolean read_only;
-
+	ECalendarStatus status;
+	ECalendarOp *our_op;
+	
 	g_return_val_if_fail (client != NULL, FALSE);
 	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
 	priv = client->priv;
+	
+	e_mutex_lock (client->priv->mutex);
+
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
 
-	if (priv->load_state != CAL_CLIENT_LOAD_LOADED)
-		return FALSE;
 
 	CORBA_exception_init (&ev);
-	read_only = GNOME_Evolution_Calendar_Cal_isReadOnly (priv->cal, &ev);
+
+	GNOME_Evolution_Calendar_Cal_isReadOnly (priv->cal, &ev);
 	if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_is_read_only: could not call isReadOnly method");
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
+
 	CORBA_exception_free (&ev);
 
-	return read_only;
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	*read_only = our_op->bool;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	return status;
 }
 
 /**
@@ -1115,119 +1679,269 @@ cal_client_is_read_only (CalClient *client)
  * is loaded or being loaded, or %NULL if the client has not started a
  * load request yet or the calendar has no associated email address.
  **/
-const char *
-cal_client_get_cal_address (CalClient *client)
+gboolean
+cal_client_get_cal_address (CalClient *client, char **cal_address, GError **error)
 {
 	CalClientPrivate *priv;
-
-	g_return_val_if_fail (client != NULL, NULL);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), NULL);
+	CORBA_Environment ev;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
+	
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
 	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, NULL);
+	
+	e_mutex_lock (client->priv->mutex);
 
-	if (priv->cal_address == NULL) {
-		CORBA_Environment ev;
-		CORBA_char *cal_address;
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
+
+
+	CORBA_exception_init (&ev);
+
+	GNOME_Evolution_Calendar_Cal_getCalAddress (priv->cal, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
 
-		CORBA_exception_init (&ev);
-		cal_address = GNOME_Evolution_Calendar_Cal_getCalAddress (priv->cal, &ev);
-		if (!BONOBO_EX (&ev)) {
-			priv->cal_address = g_strdup (cal_address);
-			CORBA_free (cal_address);
-		}
 		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
 
-	return priv->cal_address;
+	CORBA_exception_free (&ev);
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	*cal_address = our_op->string;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
-const char *
-cal_client_get_alarm_email_address (CalClient *client)
+gboolean
+cal_client_get_alarm_email_address (CalClient *client, char **alarm_address, GError **error)
 {
 	CalClientPrivate *priv;
+	CORBA_Environment ev;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
 
-	g_return_val_if_fail (client != NULL, NULL);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), NULL);
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
 	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, NULL);
 
-	if (priv->alarm_email_address == NULL) {
-		CORBA_Environment ev;
-		CORBA_char *email_address;
+	e_mutex_lock (client->priv->mutex);
+
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
+
+
+	CORBA_exception_init (&ev);
+
+	GNOME_Evolution_Calendar_Cal_getAlarmEmailAddress (priv->cal, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
 
-		CORBA_exception_init (&ev);
-		email_address = GNOME_Evolution_Calendar_Cal_getAlarmEmailAddress (priv->cal, &ev);
-		if (!BONOBO_EX (&ev)) {
-			priv->alarm_email_address = g_strdup (email_address);
-			CORBA_free (email_address);
-		}
 		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
 
-	return priv->alarm_email_address;
+	CORBA_exception_free (&ev);
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	*alarm_address = our_op->string;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
-const char *
-cal_client_get_ldap_attribute (CalClient *client)
+gboolean
+cal_client_get_ldap_attribute (CalClient *client, char **ldap_attribute, GError **error)
 {
 	CalClientPrivate *priv;
+	CORBA_Environment ev;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
 
-	g_return_val_if_fail (client != NULL, NULL);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), NULL);
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
 	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, NULL);
 
-	if (priv->ldap_attribute == NULL) {
-		CORBA_Environment ev;
-		CORBA_char *ldap_attribute;
+	e_mutex_lock (client->priv->mutex);
+
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
+
+
+	CORBA_exception_init (&ev);
+
+	GNOME_Evolution_Calendar_Cal_getLdapAttribute (priv->cal, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
 
-		CORBA_exception_init (&ev);
-		ldap_attribute = GNOME_Evolution_Calendar_Cal_getLdapAttribute (priv->cal, &ev);
-		if (!BONOBO_EX (&ev)) {
-			priv->ldap_attribute = g_strdup (ldap_attribute);
-			CORBA_free (ldap_attribute);
-		}
 		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
 
-	return priv->ldap_attribute;
+	CORBA_exception_free (&ev);
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	*ldap_attribute = our_op->string;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
-static void
-load_static_capabilities (CalClient *client) 
+static gboolean
+load_static_capabilities (CalClient *client, GError **error) 
 {
 	CalClientPrivate *priv;
 	CORBA_Environment ev;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
 	char *cap;
 	
 	priv = client->priv;
 
 	if (priv->capabilities)
-		return;
-	
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_OK, error);
+
+	e_mutex_lock (client->priv->mutex);
+
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
+
+
 	CORBA_exception_init (&ev);
-	cap = GNOME_Evolution_Calendar_Cal_getStaticCapabilities (priv->cal, &ev);
-	if (!BONOBO_EX (&ev))
-		priv->capabilities = g_strdup (cap);
-	else
-		priv->capabilities = g_strdup ("");	
 
-	CORBA_free (cap);
+	GNOME_Evolution_Calendar_Cal_getStaticCapabilities (priv->cal, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
+	}
+
 	CORBA_exception_free (&ev);
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	cap = our_op->string;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
 static gboolean
 check_capability (CalClient *client, const char *cap) 
 {
 	CalClientPrivate *priv;
-	
+
 	priv = client->priv;
 
-	load_static_capabilities (client);
-	if (strstr (priv->capabilities, cap))
+	/* FIXME Check result */
+	load_static_capabilities (client, NULL);
+	if (priv->capabilities && strstr (priv->capabilities, cap))
 		return TRUE;
 	
 	return FALSE;
@@ -1269,15 +1983,6 @@ cal_client_get_save_schedules (CalClient *client)
 	return check_capability (client, CAL_STATIC_CAPABILITY_SAVE_SCHEDULES);
 }
 
-/* Converts our representation of a calendar component type into its CORBA representation */
-static GNOME_Evolution_Calendar_CalObjType
-corba_obj_type (CalObjType type)
-{
-	return (((type & CALOBJ_TYPE_EVENT) ? GNOME_Evolution_Calendar_TYPE_EVENT : 0)
-		| ((type & CALOBJ_TYPE_TODO) ? GNOME_Evolution_Calendar_TYPE_TODO : 0)
-		| ((type & CALOBJ_TYPE_JOURNAL) ? GNOME_Evolution_Calendar_TYPE_JOURNAL : 0));
-}
-
 gboolean
 cal_client_set_mode (CalClient *client, CalMode mode)
 {
@@ -1302,45 +2007,6 @@ cal_client_set_mode (CalClient *client, CalMode mode)
 	return retval;
 }
 
-/**
- * cal_client_get_n_objects:
- * @client: A calendar client.
- * @type: Type of objects that will be counted.
- * 
- * Counts the number of calendar components of the specified @type.  This can be
- * used to count how many events, to-dos, or journals there are, for example.
- * 
- * Return value: Number of components.
- **/
-int
-cal_client_get_n_objects (CalClient *client, CalObjType type)
-{
-	CalClientPrivate *priv;
-	CORBA_Environment ev;
-	int n;
-	int t;
-
-	g_return_val_if_fail (client != NULL, -1);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), -1);
-
-	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, -1);
-
-	t = corba_obj_type (type);
-
-	CORBA_exception_init (&ev);
-	n = GNOME_Evolution_Calendar_Cal_countObjects (priv->cal, t, &ev);
-
-	if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_get_n_objects(): could not get the number of objects");
-		CORBA_exception_free (&ev);
-		return -1;
-	}
-
-	CORBA_exception_free (&ev);
-	return n;
-}
-
 
 /* This is used in the callback which fetches all the timezones needed for an
    object. */
@@ -1348,68 +2014,93 @@ typedef struct _CalClientGetTimezonesData CalClientGetTimezonesData;
 struct _CalClientGetTimezonesData {
 	CalClient *client;
 
-	/* This starts out at CAL_CLIENT_GET_SUCCESS. If an error occurs this
+	/* This starts out at E_CALENDAR_STATUS_OK. If an error occurs this
 	   contains the last error. */
-	CalClientGetStatus status;
+	ECalendarStatus status;
 };
 
-CalClientGetStatus 
-cal_client_get_default_object (CalClient *client, CalObjType type, icalcomponent **icalcomp)
+gboolean
+cal_client_get_default_object (CalClient *client, icalcomponent **icalcomp, GError **error)
 {
 	CalClientPrivate *priv;
 	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_CalObj comp_str;
-	CalClientGetStatus retval;
-	CalClientGetTimezonesData cb_data;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
 
-	g_return_val_if_fail (client != NULL, CAL_CLIENT_GET_NOT_FOUND);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), CAL_CLIENT_GET_NOT_FOUND);
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
 	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, CAL_CLIENT_GET_NOT_FOUND);
 
-	g_return_val_if_fail (icalcomp != NULL, CAL_CLIENT_GET_NOT_FOUND);
+	e_mutex_lock (client->priv->mutex);
 
-	retval = CAL_CLIENT_GET_NOT_FOUND;
-	*icalcomp = NULL;
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
 
 	CORBA_exception_init (&ev);
-	comp_str = GNOME_Evolution_Calendar_Cal_getDefaultObject (priv->cal, type, &ev);
 
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_NotFound))
-		goto out;
-	else if (BONOBO_EX (&ev)) {		
-		g_message ("cal_client_get_default_object(): could not get the object");
-		goto out;
-	}
+	GNOME_Evolution_Calendar_Cal_getDefaultObject (priv->cal, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
 
-	*icalcomp = icalparser_parse_string (comp_str);
-	CORBA_free (comp_str);
+		CORBA_exception_free (&ev);
 
-	if (!*icalcomp) {
-		retval = CAL_CLIENT_GET_SYNTAX_ERROR;
-		goto out;
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
 
-	/* Now make sure we have all timezones needed for this object.
-	   We do this to try to avoid any problems caused by getting a timezone
-	   in the middle of other code. Any calls to ORBit result in a 
-	   recursive call of the GTK+ main loop, which can cause problems for
-	   code that doesn't expect it. Currently GnomeCanvas has problems if
-	   we try to get a timezone in the middle of a redraw, and there is a
-	   resize pending, which leads to an assert failure and an abort. */
-	cb_data.client = client;
-	cb_data.status = CAL_CLIENT_GET_SUCCESS;
-	icalcomponent_foreach_tzid (*icalcomp,
-				    cal_client_get_object_timezones_cb,
-				    &cb_data);
+	CORBA_exception_free (&ev);
 
-	retval = cb_data.status;
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
 
- out:
+	status = our_op->status;
+	*icalcomp = icalparser_parse_string (our_op->string);
+	g_free (our_op->string);
 
-	CORBA_exception_free (&ev);
-	return retval;
+	if (!*icalcomp) {
+		status = E_CALENDAR_STATUS_INVALID_OBJECT;
+	} else {
+		CalClientGetTimezonesData cb_data;
+		
+		/* Now make sure we have all timezones needed for this object.
+		   We do this to try to avoid any problems caused by getting a timezone
+		   in the middle of other code. Any calls to ORBit result in a 
+		   recursive call of the GTK+ main loop, which can cause problems for
+		   code that doesn't expect it. Currently GnomeCanvas has problems if
+		   we try to get a timezone in the middle of a redraw, and there is a
+		   resize pending, which leads to an assert failure and an abort. */
+		cb_data.client = client;
+		cb_data.status = E_CALENDAR_STATUS_OK;
+		icalcomponent_foreach_tzid (*icalcomp,
+					    cal_client_get_object_timezones_cb,
+					    &cb_data);
+		
+		status = cb_data.status;
+	}
+
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
 /**
@@ -1423,64 +2114,89 @@ cal_client_get_default_object (CalClient *client, CalObjType type, icalcomponent
  *
  * Return value: Result code based on the status of the operation.
  **/
-CalClientGetStatus
-cal_client_get_object (CalClient *client, const char *uid, icalcomponent **icalcomp)
+gboolean
+cal_client_get_object (CalClient *client, const char *uid, const char *rid, icalcomponent **icalcomp, GError **error)
 {
+
 	CalClientPrivate *priv;
 	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_CalObj comp_str;
-	CalClientGetStatus retval;
-	CalClientGetTimezonesData cb_data;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
 
-	g_return_val_if_fail (client != NULL, CAL_CLIENT_GET_NOT_FOUND);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), CAL_CLIENT_GET_NOT_FOUND);
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
 	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, CAL_CLIENT_GET_NOT_FOUND);
 
-	g_return_val_if_fail (uid != NULL, CAL_CLIENT_GET_NOT_FOUND);
-	g_return_val_if_fail (icalcomp != NULL, CAL_CLIENT_GET_NOT_FOUND);
+	e_mutex_lock (client->priv->mutex);
+
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
 
-	retval = CAL_CLIENT_GET_NOT_FOUND;
-	*icalcomp = NULL;
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
 
 	CORBA_exception_init (&ev);
-	comp_str = GNOME_Evolution_Calendar_Cal_getObject (priv->cal, (char *) uid, &ev);
 
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_NotFound))
-		goto out;
-	else if (BONOBO_EX (&ev)) {		
-		g_message ("cal_client_get_object(): could not get the object");
-		goto out;
-	}
+	GNOME_Evolution_Calendar_Cal_getObject (priv->cal, uid, rid ? rid : "", &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
 
-	*icalcomp = icalparser_parse_string (comp_str);
-	CORBA_free (comp_str);
+		CORBA_exception_free (&ev);
 
-	if (!*icalcomp) {
-		retval = CAL_CLIENT_GET_SYNTAX_ERROR;
-		goto out;
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
 
-	/* Now make sure we have all timezones needed for this object.
-	   We do this to try to avoid any problems caused by getting a timezone
-	   in the middle of other code. Any calls to ORBit result in a 
-	   recursive call of the GLib main loop, which can cause problems for
-	   code that doesn't expect it. Currently GnomeCanvas has problems if
-	   we try to get a timezone in the middle of a redraw, and there is a
-	   resize pending, which leads to an assert failure and an abort. */
-	cb_data.client = client;
-	cb_data.status = CAL_CLIENT_GET_SUCCESS;
-	icalcomponent_foreach_tzid (*icalcomp,
-				    cal_client_get_object_timezones_cb,
-				    &cb_data);
+	CORBA_exception_free (&ev);
 
-	retval = cb_data.status;
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
 
- out:
+	status = our_op->status;
+	*icalcomp = icalparser_parse_string (our_op->string);
+	g_free (our_op->string);
 
-	CORBA_exception_free (&ev);
-	return retval;
+	if (!*icalcomp) {
+		status = E_CALENDAR_STATUS_INVALID_OBJECT;
+	} else {
+		CalClientGetTimezonesData cb_data;
+		
+		/* Now make sure we have all timezones needed for this object.
+		   We do this to try to avoid any problems caused by getting a timezone
+		   in the middle of other code. Any calls to ORBit result in a 
+		   recursive call of the GTK+ main loop, which can cause problems for
+		   code that doesn't expect it. Currently GnomeCanvas has problems if
+		   we try to get a timezone in the middle of a redraw, and there is a
+		   resize pending, which leads to an assert failure and an abort. */
+		cb_data.client = client;
+		cb_data.status = E_CALENDAR_STATUS_OK;
+		icalcomponent_foreach_tzid (*icalcomp,
+					    cal_client_get_object_timezones_cb,
+					    &cb_data);
+		
+		status = cb_data.status;
+	}
+
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
 
@@ -1491,106 +2207,18 @@ cal_client_get_object_timezones_cb (icalparameter *param,
 	CalClientGetTimezonesData *cb_data = data;
 	const char *tzid;
 	icaltimezone *zone;
-	CalClientGetStatus status;
+	GError *error = NULL;
 
 	tzid = icalparameter_get_tzid (param);
 	if (!tzid) {
-		cb_data->status = CAL_CLIENT_GET_SYNTAX_ERROR;
+		cb_data->status = E_CALENDAR_STATUS_INVALID_OBJECT;
 		return;
 	}
 
-	status = cal_client_get_timezone (cb_data->client, tzid, &zone);
-	if (status != CAL_CLIENT_GET_SUCCESS)
-		cb_data->status = status;
-}
-
-
-CalClientGetStatus
-cal_client_get_timezone (CalClient *client,
-			 const char *tzid,
-			 icaltimezone **zone)
-{
-	CalClientPrivate *priv;
-	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_CalObj comp_str;
-	CalClientGetStatus retval;
-	icalcomponent *icalcomp;
-	icaltimezone *tmp_zone;
-
-	g_return_val_if_fail (client != NULL, CAL_CLIENT_GET_NOT_FOUND);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), CAL_CLIENT_GET_NOT_FOUND);
-
-	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED,
-			      CAL_CLIENT_GET_NOT_FOUND);
-
-	g_return_val_if_fail (zone != NULL, CAL_CLIENT_GET_NOT_FOUND);
-
-	/* If tzid is NULL or "" we return NULL, since it is a 'local time'. */
-	if (!tzid || !tzid[0]) {
-		*zone = NULL;
-		return CAL_CLIENT_GET_SUCCESS;
-	}
-
-	/* If it is UTC, we return the special UTC timezone. */
-	if (!strcmp (tzid, "UTC")) {
-		*zone = icaltimezone_get_utc_timezone ();
-		return CAL_CLIENT_GET_SUCCESS;
-	}
-
-	/* See if we already have it in the cache. */
-	tmp_zone = g_hash_table_lookup (priv->timezones, tzid);
-	if (tmp_zone) {
-		*zone = tmp_zone;
-		return CAL_CLIENT_GET_SUCCESS;
-	}
-
-	retval = CAL_CLIENT_GET_NOT_FOUND;
-	*zone = NULL;
-
-	/* We don't already have it, so we try to get it from the server. */
-	CORBA_exception_init (&ev);
-	comp_str = GNOME_Evolution_Calendar_Cal_getTimezoneObject (priv->cal, (char *) tzid, &ev);
-
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_NotFound))
-		goto out;
-	else if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_get_timezone(): could not get the object");
-		goto out;
-	}
-
-	icalcomp = icalparser_parse_string (comp_str);
-	CORBA_free (comp_str);
-
-	if (!icalcomp) {
-		retval = CAL_CLIENT_GET_SYNTAX_ERROR;
-		goto out;
-	}
-
-	tmp_zone = icaltimezone_new ();
-	if (!tmp_zone) {
-		/* FIXME: Needs better error code - out of memory. Or just
-		   abort like GLib does? */
-		retval = CAL_CLIENT_GET_NOT_FOUND;
-		goto out;
-	}
-
-	if (!icaltimezone_set_component (tmp_zone, icalcomp)) {
-		retval = CAL_CLIENT_GET_SYNTAX_ERROR;
-		goto out;
-	}
-
-	/* Now add it to the cache, to avoid the server call in future. */
-	g_hash_table_insert (priv->timezones, icaltimezone_get_tzid (tmp_zone),
-			     tmp_zone);
-
-	*zone = tmp_zone;
-	retval = CAL_CLIENT_GET_SUCCESS;
-
- out:
-
-	CORBA_exception_free (&ev);
-	return retval;
+	if (!cal_client_get_timezone (cb_data->client, tzid, &zone, &error))
+		cb_data->status = error->code;
+	    
+	g_clear_error (&error);
 }
 
 /* Resolves TZIDs for the recurrence generator. */
@@ -1599,7 +2227,6 @@ cal_client_resolve_tzid_cb (const char *tzid, gpointer data)
 {
 	CalClient *client;
 	icaltimezone *zone = NULL;
-	CalClientGetStatus status;
 
 	g_return_val_if_fail (data != NULL, NULL);
 	g_return_val_if_fail (IS_CAL_CLIENT (data), NULL);
@@ -1607,219 +2234,180 @@ cal_client_resolve_tzid_cb (const char *tzid, gpointer data)
 	client = CAL_CLIENT (data);
 
 	/* FIXME: Handle errors. */
-	status = cal_client_get_timezone (client, tzid, &zone);
+	cal_client_get_timezone (client, tzid, &zone, NULL);
 
 	return zone;
 }
 
-
-/* Builds an UID list out of a CORBA UID sequence */
-static GList *
-build_uid_list (GNOME_Evolution_Calendar_CalObjUIDSeq *seq)
-{
-	GList *uids;
-	int i;
-
-	uids = NULL;
-
-	for (i = 0; i < seq->_length; i++)
-		uids = g_list_prepend (uids, g_strdup (seq->_buffer[i]));
-
-	return uids;
-}
-
-/**
- * cal_client_get_uids:
- * @client: A calendar client.
- * @type: Bitmask with types of objects to return.
- *
- * Queries a calendar for a list of unique identifiers corresponding to calendar
- * objects whose type matches one of the types specified in the @type flags.
- *
- * Return value: A list of strings that are the sought UIDs.  This should be
- * freed using the cal_obj_uid_list_free() function.
- **/
-GList *
-cal_client_get_uids (CalClient *client, CalObjType type)
+gboolean
+cal_client_get_changes (CalClient *client, CalObjType type, const char *change_id, GList **changes, GError **error)
 {
-	CalClientPrivate *priv;
 	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_CalObjUIDSeq *seq;
-	int t;
-	GList *uids;
+	ECalendarOp *our_op;
+	ECalendarStatus status;
 
-	g_return_val_if_fail (client != NULL, NULL);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), NULL);
+	g_return_val_if_fail (client != NULL, E_CALENDAR_STATUS_INVALID_ARG);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), E_CALENDAR_STATUS_INVALID_ARG);
+	g_return_val_if_fail (change_id != NULL, E_CALENDAR_STATUS_INVALID_ARG);
 
-	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, NULL);
+	e_mutex_lock (client->priv->mutex);
 
-	t = corba_obj_type (type);
-
-	CORBA_exception_init (&ev);
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
 
-	seq = GNOME_Evolution_Calendar_Cal_getUIDs (priv->cal, t, &ev);
-	if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_get_uids(): could not get the list of UIDs");
-		CORBA_exception_free (&ev);
-		return NULL;
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
 	}
 
-	CORBA_exception_free (&ev);
+	our_op = e_calendar_new_op (client);
 
-	uids = build_uid_list (seq);
-	CORBA_free (seq);
+	e_mutex_lock (our_op->mutex);
 
-	return uids;
-}
+	e_mutex_unlock (client->priv->mutex);
 
-/* Builds a GList of CalClientChange structures from the CORBA sequence */
-static GList *
-build_change_list (GNOME_Evolution_Calendar_CalObjChangeSeq *seq)
-{
-	GList *list = NULL;
-	icalcomponent *icalcomp;
-	int i;
+	CORBA_exception_init (&ev);
 
-	/* Create the list in reverse order */
-	for (i = 0; i < seq->_length; i++) {
-		GNOME_Evolution_Calendar_CalObjChange *corba_coc;
-		CalClientChange *ccc;
+	GNOME_Evolution_Calendar_Cal_getChanges (client->priv->cal, type, change_id, &ev);
 
-		corba_coc = &seq->_buffer[i];
-		ccc = g_new (CalClientChange, 1);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
 
-		icalcomp = icalparser_parse_string (corba_coc->calobj);
-		if (!icalcomp)
-			continue;
+		CORBA_exception_free (&ev);
 
-		ccc->comp = cal_component_new ();
-		if (!cal_component_set_icalcomponent (ccc->comp, icalcomp)) {
-			icalcomponent_free (icalcomp);
-			g_object_unref (G_OBJECT (ccc->comp));
-			continue;
-		}
-		ccc->type = corba_coc->type;
+		g_warning (G_STRLOC ": Unable to contact backend");
 
-		list = g_list_prepend (list, ccc);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
+	
+	CORBA_exception_free (&ev);
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
 
-	list = g_list_reverse (list);
+	status = our_op->status;
+	*changes = our_op->list;
 
-	return list;
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
-GList *
-cal_client_get_changes (CalClient *client, CalObjType type, const char *change_id)
+
+/**
+ * cal_client_get_object_list:
+ * @client: 
+ * @query: 
+ * 
+ * 
+ * 
+ * Return value: 
+ **/
+gboolean
+cal_client_get_object_list (CalClient *client, const char *query, GList **objects, GError **error)
 {
-	CalClientPrivate *priv;
 	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_CalObjChangeSeq *seq;
-	int t;
-	GList *changes;
+	ECalendarOp *our_op;
+	ECalendarStatus status;
 
-	g_return_val_if_fail (client != NULL, NULL);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), NULL);
+	g_return_val_if_fail (client != NULL, E_CALENDAR_STATUS_INVALID_ARG);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), E_CALENDAR_STATUS_INVALID_ARG);
+	g_return_val_if_fail (query != NULL, E_CALENDAR_STATUS_INVALID_ARG);
 
-	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, NULL);
+	e_mutex_lock (client->priv->mutex);
 
-	t = corba_obj_type (type);
-	CORBA_exception_init (&ev);
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
 
-	seq = GNOME_Evolution_Calendar_Cal_getChanges (priv->cal, t, change_id, &ev);
-	if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_get_changes(): could not get the list of changes");
-		CORBA_exception_free (&ev);
-		return NULL;
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
 	}
 
-	CORBA_exception_free (&ev);
+	our_op = e_calendar_new_op (client);
 
-	changes = build_change_list (seq);
-	CORBA_free (seq);
+	e_mutex_lock (our_op->mutex);
 
-	return changes;
-}
+	e_mutex_unlock (client->priv->mutex);
 
-/* FIXME: Not used? */
-#if 0
-/* Builds a GList of CalObjInstance structures from the CORBA sequence */
-static GList *
-build_object_instance_list (GNOME_Evolution_Calendar_CalObjInstanceSeq *seq)
-{
-	GList *list;
-	int i;
+	CORBA_exception_init (&ev);
 
-	/* Create the list in reverse order */
+	GNOME_Evolution_Calendar_Cal_getObjectList (client->priv->cal, query, &ev);
 
-	list = NULL;
-	for (i = 0; i < seq->_length; i++) {
-		GNOME_Evolution_Calendar_CalObjInstance *corba_icoi;
-		CalObjInstance *icoi;
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
 
-		corba_icoi = &seq->_buffer[i];
-		icoi = g_new (CalObjInstance, 1);
+		CORBA_exception_free (&ev);
 
-		icoi->uid = g_strdup (corba_icoi->uid);
-		icoi->start = corba_icoi->start;
-		icoi->end = corba_icoi->end;
+		g_warning (G_STRLOC ": Unable to contact backend");
 
-		list = g_list_prepend (list, icoi);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
+	
+	CORBA_exception_free (&ev);
 
-	list = g_list_reverse (list);
-	return list;
-}
-#endif
-
-/**
- * cal_client_get_objects_in_range:
- * @client: A calendar client.
- * @type: Bitmask with types of objects to return.
- * @start: Start time for query.
- * @end: End time for query.
- *
- * Queries a calendar for the objects that occur or recur in the specified range
- * of time.
- *
- * Return value: A list of UID strings.  This should be freed using the
- * cal_obj_uid_list_free() function.
- **/
-GList *
-cal_client_get_objects_in_range (CalClient *client, CalObjType type, time_t start, time_t end)
-{
-	CalClientPrivate *priv;
-	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_CalObjUIDSeq *seq;
-	GList *uids;
-	int t;
-
-	g_return_val_if_fail (client != NULL, NULL);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), NULL);
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
 
-	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, NULL);
+	status = our_op->status;
+	*objects = our_op->list;
 
-	g_return_val_if_fail (start != -1 && end != -1, NULL);
-	g_return_val_if_fail (start <= end, NULL);
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
 
-	CORBA_exception_init (&ev);
-
-	t = corba_obj_type (type);
+	E_CALENDAR_CHECK_STATUS (status, error);
+}
 
-	seq = GNOME_Evolution_Calendar_Cal_getObjectsInRange (priv->cal, t, start, end, &ev);
-	if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_get_objects_in_range(): could not get the objects");
-		CORBA_exception_free (&ev);
-		return NULL;
+gboolean
+cal_client_get_object_list_as_comp (CalClient *client, const char *query, GList **objects, GError **error)
+{
+	GList *ical_objects = NULL;
+	GList *l;
+	
+	g_return_val_if_fail (client != NULL, E_CALENDAR_STATUS_INVALID_ARG);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), E_CALENDAR_STATUS_INVALID_ARG);
+	g_return_val_if_fail (query != NULL, E_CALENDAR_STATUS_INVALID_ARG);
+	g_return_val_if_fail (objects != NULL, E_CALENDAR_STATUS_INVALID_ARG);
+	
+	if (!cal_client_get_object_list (client, query, &ical_objects, error))
+		return FALSE;
+		
+	*objects = NULL;
+	for (l = ical_objects; l; l = l->next) {
+		CalComponent *comp;
+			
+		comp = cal_component_new ();
+		cal_component_set_icalcomponent (comp, l->data);
+		*objects = g_list_prepend (*objects, comp);
 	}
-	CORBA_exception_free (&ev);
+			
+	g_list_free (ical_objects);
 
-	uids = build_uid_list (seq);
-	CORBA_free (seq);
+	return TRUE;
+}
+
+void 
+cal_client_free_object_list (GList *objects)
+{
+	GList *l;
+	
+	for (l = objects; l; l = l->next)
+		icalcomponent_free (l->data);
 
-	return uids;
+	g_list_free (objects);
 }
 
 /**
@@ -1833,57 +2421,81 @@ cal_client_get_objects_in_range (CalClient *client, CalObjType type, time_t star
  *
  * Returns: a GList of VFREEBUSY CalComponents
  */
-GList *
-cal_client_get_free_busy (CalClient *client, GList *users,
-			  time_t start, time_t end)
+gboolean
+cal_client_get_free_busy (CalClient *client, GList *users, time_t start, time_t end,
+			  GList **freebusy, GError **error)
 {
-	CalClientPrivate *priv;
 	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_UserList *corba_list;
-	GNOME_Evolution_Calendar_CalObjSeq *calobj_list;
+	ECalendarOp *our_op;
+	ECalendarStatus status;
+	GNOME_Evolution_Calendar_UserList corba_users;
 	GList *l;
-	GList *comp_list = NULL;
-	int len, i;
+	int i, len;
+	
+	g_return_val_if_fail (client != NULL, E_CALENDAR_STATUS_INVALID_ARG);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), E_CALENDAR_STATUS_INVALID_ARG);
 
-	g_return_val_if_fail (client != NULL, NULL);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), NULL);
+	e_mutex_lock (client->priv->mutex);
 
-	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, NULL);
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
 
-	g_return_val_if_fail (start != -1 && end != -1, NULL);
-	g_return_val_if_fail (start <= end, NULL);
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
 
 	/* create the CORBA user list to be passed to the backend */
 	len = g_list_length (users);
 
-	corba_list = GNOME_Evolution_Calendar_UserList__alloc ();
-	CORBA_sequence_set_release (corba_list, TRUE);
-	corba_list->_length = len;
-	corba_list->_buffer = CORBA_sequence_GNOME_Evolution_Calendar_User_allocbuf (len);
+	corba_users._length = len;
+	corba_users._buffer = CORBA_sequence_GNOME_Evolution_Calendar_User_allocbuf (len);
 
-	for (l = g_list_first (users), i = 0; l; l = l->next, i++)
-		corba_list->_buffer[i] = CORBA_string_dup ((CORBA_char *) l->data);
+	for (l = users, i = 0; l; l = l->next, i++)
+		corba_users._buffer[i] = CORBA_string_dup (l->data);
 
-	/* call the method on the backend */
 	CORBA_exception_init (&ev);
 
-	calobj_list = GNOME_Evolution_Calendar_Cal_getFreeBusy (priv->cal, corba_list,
-								start, end, &ev);
-	CORBA_free (corba_list);
-	if (BONOBO_EX (&ev) || !calobj_list) {
-		if (!BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_NotFound))
-			g_message ("cal_client_get_free_busy(): could not get the objects");
+	GNOME_Evolution_Calendar_Cal_getFreeBusy (client->priv->cal, &corba_users, start, end, &ev);
+
+	CORBA_free (corba_users._buffer);
+	
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
 		CORBA_exception_free (&ev);
-		return NULL;
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
+	
+	CORBA_exception_free (&ev);
 
-	for (i = 0; i < calobj_list->_length; i++) {
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+
+	*freebusy = NULL;
+	for (l = our_op->list; l; l = l->next) {
 		CalComponent *comp;
+
 		icalcomponent *icalcomp;
 		icalcomponent_kind kind;
 
-		icalcomp = icalparser_parse_string (calobj_list->_buffer[i]);
+		icalcomp = icalparser_parse_string (l->data);
 		if (!icalcomp)
 			continue;
 
@@ -1896,184 +2508,17 @@ cal_client_get_free_busy (CalClient *client, GList *users,
 				continue;
 			}
 
-			comp_list = g_list_append (comp_list, comp);
+			*freebusy = g_list_append (*freebusy, comp);
 		}
 		else
 			icalcomponent_free (icalcomp);
 	}
 
-	CORBA_exception_free (&ev);
-	CORBA_free (calobj_list);
-
-	return comp_list;
-}
-
-/* Callback used when an object is updated and we must update the copy we have */
-static void
-generate_instances_obj_updated_cb (CalClient *client, const char *uid, gpointer data)
-{
-	GHashTable *uid_comp_hash;
-	CalComponent *comp;
-	icalcomponent *icalcomp;
-	CalClientGetStatus status;
-	const char *comp_uid;
-
-	uid_comp_hash = data;
-
-	comp = g_hash_table_lookup (uid_comp_hash, uid);
-	if (!comp)
-		/* OK, so we don't care about new objects that may indeed be in
-		 * the requested time range.  We only care about the ones that
-		 * were returned by the first query to
-		 * cal_client_get_objects_in_range().
-		 */
-		return;
-
-	g_hash_table_remove (uid_comp_hash, uid);
-	g_object_unref (G_OBJECT (comp));
-
-	status = cal_client_get_object (client, uid, &icalcomp);
-
-	switch (status) {
-	case CAL_CLIENT_GET_SUCCESS:
-		comp = cal_component_new ();
-		if (cal_component_set_icalcomponent (comp, icalcomp)) {
-			/* The hash key comes from the component's internal data */
-			cal_component_get_uid (comp, &comp_uid);
-			g_hash_table_insert (uid_comp_hash, (char *) comp_uid, comp);
-		} else {
-			g_object_unref (comp);
-			icalcomponent_free (icalcomp);
-		}
-		break;
-
-	case CAL_CLIENT_GET_NOT_FOUND:
-		/* No longer in the server, too bad */
-		break;
-
-	case CAL_CLIENT_GET_SYNTAX_ERROR:
-		g_message ("obj_updated_cb(): Syntax error when getting "
-			   "object `%s'; ignoring...", uid);
-		break;
-		
-	}
-}
-
-/* Callback used when an object is removed and we must delete the copy we have */
-static void
-generate_instances_obj_removed_cb (CalClient *client, const char *uid, gpointer data)
-{
-	GHashTable *uid_comp_hash;
-	CalComponent *comp;
-
-	uid_comp_hash = data;
-
-	comp = g_hash_table_lookup (uid_comp_hash, uid);
-	if (!comp)
-		return;
-
-	g_hash_table_remove (uid_comp_hash, uid);
-	g_object_unref (G_OBJECT (comp));
-}
-
-/* Adds a component to the list; called from g_hash_table_foreach() */
-static void
-add_component (gpointer key, gpointer value, gpointer data)
-{
-	CalComponent *comp;
-	GList **list;
-
-	comp = CAL_COMPONENT (value);
-	list = data;
-
-	*list = g_list_prepend (*list, comp);
-}
-
-/* Gets a list of components that recur within the specified range of time.  It
- * ensures that the resulting list of CalComponent objects contains only objects
- * that are actually in the server at the time the initial
- * cal_client_get_objects_in_range() query ends.
- */
-static GList *
-get_objects_atomically (CalClient *client, CalObjType type, time_t start, time_t end)
-{
-	GList *uids;
-	GHashTable *uid_comp_hash;
-	GList *objects;
-	guint obj_updated_id;
-	guint obj_removed_id;
-	GList *l;
-
-	uids = cal_client_get_objects_in_range (client, type, start, end);
-
-	uid_comp_hash = g_hash_table_new (g_str_hash, g_str_equal);
-
-	/* While we are getting the actual object data, keep track of changes */
-
-	obj_updated_id = g_signal_connect (G_OBJECT (client), "obj_updated",
-					   G_CALLBACK (generate_instances_obj_updated_cb),
-					   uid_comp_hash);
-
-	obj_removed_id = g_signal_connect (G_OBJECT (client), "obj_removed",
-					   G_CALLBACK (generate_instances_obj_removed_cb),
-					   uid_comp_hash);
-
-	/* Get the objects */
-
-	for (l = uids; l; l = l->next) {
-		CalComponent *comp;
-		icalcomponent *icalcomp;
-		CalClientGetStatus status;
-		char *uid;
-		const char *comp_uid;
-
-		uid = l->data;
-
-		status = cal_client_get_object (client, uid, &icalcomp);
-
-		switch (status) {
-		case CAL_CLIENT_GET_SUCCESS:
-			comp = cal_component_new ();
-			if (cal_component_set_icalcomponent (comp, icalcomp)) {
-				/* The hash key comes from the component's internal data
-				 * instead of the duped UID from the list of UIDS.
-				 */
-				cal_component_get_uid (comp, &comp_uid);
-				g_hash_table_insert (uid_comp_hash, (char *) comp_uid, comp);
-			} else {
-				g_object_unref (comp);
-				icalcomponent_free (icalcomp);
-			}
-			break;
-
-		case CAL_CLIENT_GET_NOT_FOUND:
-			/* Object disappeared from the server, so don't log it */
-			break;
-
-		case CAL_CLIENT_GET_SYNTAX_ERROR:
-			g_message ("get_objects_atomically(): Syntax error when getting "
-				   "object `%s'; ignoring...", uid);
-			break;
-
-		default:
-			g_assert_not_reached ();
-		}
-	}
-
-	cal_obj_uid_list_free (uids);
-
-	/* Now our state is consistent with the server, so disconnect from the
-	 * notification signals and generate the final list of components.
-	 */
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
 
-	g_signal_handler_disconnect (client, obj_updated_id);
-	g_signal_handler_disconnect (client, obj_removed_id);
-
-	objects = NULL;
-	g_hash_table_foreach (uid_comp_hash, add_component, &objects);
-	g_hash_table_destroy (uid_comp_hash);
-
-	return objects;
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
 struct comp_instance {
@@ -2127,10 +2572,8 @@ compare_comp_instance (gconstpointer a, gconstpointer b)
  * @cb: Callback for each generated instance.
  * @cb_data: Closure data for the callback.
  * 
- * Does a combination of cal_client_get_objects_in_range() and
- * cal_recur_generate_instances().  It fetches the list of objects in an atomic
- * way so that the generated instances are actually in the server at the time
- * the initial cal_client_get_objects_in_range() query ends.
+ * Does a combination of cal_client_get_object_list () and
+ * cal_recur_generate_instances().  
  *
  * The callback function should do a g_object_ref() of the calendar component
  * it gets passed if it intends to keep it around.
@@ -2144,7 +2587,8 @@ cal_client_generate_instances (CalClient *client, CalObjType type,
 	GList *objects;
 	GList *instances;
 	GList *l;
-
+	char *query;
+	
 	g_return_if_fail (client != NULL);
 	g_return_if_fail (IS_CAL_CLIENT (client));
 
@@ -2156,8 +2600,13 @@ cal_client_generate_instances (CalClient *client, CalObjType type,
 	g_return_if_fail (cb != NULL);
 
 	/* Generate objects */
+	query = g_strdup_printf ("(occur-in-time-range? (%lu) (%lu))", start, end);
+	if (!cal_client_get_object_list (client, query, &objects, NULL)) {
+		g_free (query);
+		return;
+	}	
+	g_free (query);
 
-	objects = get_objects_atomically (client, type, start, end);
 	instances = NULL;
 
 	for (l = objects; l; l = l->next) {
@@ -2201,64 +2650,22 @@ cal_client_generate_instances (CalClient *client, CalObjType type,
 	g_list_free (instances);
 }
 
-/* Builds a list of CalAlarmInstance structures */
-static GSList *
-build_alarm_instance_list (CalComponent *comp, GNOME_Evolution_Calendar_CalAlarmInstanceSeq *seq)
-{
-	GSList *alarms;
-	int i;
-
-	alarms = NULL;
-
-	for (i = 0; i < seq->_length; i++) {
-		GNOME_Evolution_Calendar_CalAlarmInstance *corba_instance;
-		CalComponentAlarm *alarm;
-		const char *auid;
-		CalAlarmInstance *instance;
-
-		corba_instance = seq->_buffer + i;
-
-		/* Since we want the in-commponent auid, we look for the alarm
-		 * in the component and fetch its "real" auid.
-		 */
-
-		alarm = cal_component_get_alarm (comp, corba_instance->auid);
-		if (!alarm)
-			continue;
-
-		auid = cal_component_alarm_get_uid (alarm);
-		cal_component_alarm_free (alarm);
-
-		instance = g_new (CalAlarmInstance, 1);
-		instance->auid = auid;
-		instance->trigger = corba_instance->trigger;
-		instance->occur_start = corba_instance->occur_start;
-		instance->occur_end = corba_instance->occur_end;
-
-		alarms = g_slist_prepend (alarms, instance);
-	}
-
-	return g_slist_reverse (alarms);
-}
-
 /* Builds a list of CalComponentAlarms structures */
 static GSList *
-build_component_alarms_list (GNOME_Evolution_Calendar_CalComponentAlarmsSeq *seq)
+build_component_alarms_list (CalClient *client, GList *object_list, time_t start, time_t end)
 {
 	GSList *comp_alarms;
-	int i;
+	GList *l;
 
 	comp_alarms = NULL;
 
-	for (i = 0; i < seq->_length; i++) {
-		GNOME_Evolution_Calendar_CalComponentAlarms *corba_alarms;
+	for (l = object_list; l != NULL; l = l->next) {
 		CalComponent *comp;
 		CalComponentAlarms *alarms;
 		icalcomponent *icalcomp;
+		CalAlarmAction omit[] = {-1};
 
-		corba_alarms = seq->_buffer + i;
-
-		icalcomp = icalparser_parse_string (corba_alarms->calobj);
+		icalcomp = icalparser_parse_string (l->data);
 		if (!icalcomp)
 			continue;
 
@@ -2269,11 +2676,10 @@ build_component_alarms_list (GNOME_Evolution_Calendar_CalComponentAlarmsSeq *seq
 			continue;
 		}
 
-		alarms = g_new (CalComponentAlarms, 1);
-		alarms->comp = comp;
-		alarms->alarms = build_alarm_instance_list (comp, &corba_alarms->alarms);
-
-		comp_alarms = g_slist_prepend (comp_alarms, alarms);
+		alarms = cal_util_generate_alarms_for_comp (comp, start, end, omit, cal_client_resolve_tzid_cb,
+							    icalcomp, client->priv->default_zone);
+		if (alarms)
+			comp_alarms = g_slist_prepend (comp_alarms, alarms);
 	}
 
 	return comp_alarms;
@@ -2297,9 +2703,9 @@ GSList *
 cal_client_get_alarms_in_range (CalClient *client, time_t start, time_t end)
 {
 	CalClientPrivate *priv;
-	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_CalComponentAlarmsSeq *seq;
 	GSList *alarms;
+	char *sexp;
+	GList *object_list = NULL;
 
 	g_return_val_if_fail (client != NULL, NULL);
 	g_return_val_if_fail (IS_CAL_CLIENT (client), NULL);
@@ -2310,18 +2716,20 @@ cal_client_get_alarms_in_range (CalClient *client, time_t start, time_t end)
 	g_return_val_if_fail (start != -1 && end != -1, NULL);
 	g_return_val_if_fail (start <= end, NULL);
 
-	CORBA_exception_init (&ev);
+	/* build the query string */
+	sexp = g_strdup ("(and (has-alarms? #t))");
 
-	seq = GNOME_Evolution_Calendar_Cal_getAlarmsInRange (priv->cal, start, end, &ev);
-	if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_get_alarms_in_range(): could not get the alarm range");
-		CORBA_exception_free (&ev);
+	/* execute the query on the server */
+	if (!cal_client_get_object_list (client, sexp, &object_list, NULL)) {
+		g_free (sexp);
 		return NULL;
 	}
-	CORBA_exception_free (&ev);
 
-	alarms = build_component_alarms_list (seq);
-	CORBA_free (seq);
+	alarms = build_component_alarms_list (client, object_list, start, end);
+
+	g_list_foreach (object_list, (GFunc) g_free, NULL);
+	g_list_free (object_list);
+	g_free (sexp);
 
 	return alarms;
 }
@@ -2371,11 +2779,9 @@ cal_client_get_alarms_for_object (CalClient *client, const char *uid,
 				  CalComponentAlarms **alarms)
 {
 	CalClientPrivate *priv;
-	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_CalComponentAlarms *corba_alarms;
-	gboolean retval;
 	icalcomponent *icalcomp;
 	CalComponent *comp;
+	CalAlarmAction omit[] = {-1};
 
 	g_return_val_if_fail (client != NULL, FALSE);
 	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
@@ -2389,40 +2795,23 @@ cal_client_get_alarms_for_object (CalClient *client, const char *uid,
 	g_return_val_if_fail (alarms != NULL, FALSE);
 
 	*alarms = NULL;
-	retval = FALSE;
-
-	CORBA_exception_init (&ev);
-
-	corba_alarms = GNOME_Evolution_Calendar_Cal_getAlarmsForObject (priv->cal, (char *) uid,
-									start, end, &ev);
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_NotFound))
-		goto out;
-	else if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_get_alarms_for_object(): could not get the alarm range");
-		goto out;
-	}
 
-	icalcomp = icalparser_parse_string (corba_alarms->calobj);
+	if (!cal_client_get_object (client, uid, NULL, &icalcomp, NULL))
+		return FALSE;
 	if (!icalcomp)
-		goto out;
+		return FALSE;
 
 	comp = cal_component_new ();
 	if (!cal_component_set_icalcomponent (comp, icalcomp)) {
 		icalcomponent_free (icalcomp);
 		g_object_unref (G_OBJECT (comp));
-		goto out;
+		return FALSE;
 	}
 
-	retval = TRUE;
-
-	*alarms = g_new (CalComponentAlarms, 1);
-	(*alarms)->comp = comp;
-	(*alarms)->alarms = build_alarm_instance_list (comp, &corba_alarms->alarms);
-	CORBA_free (corba_alarms);
+	*alarms = cal_util_generate_alarms_for_comp (comp, start, end, omit, cal_client_resolve_tzid_cb,
+						     icalcomp, priv->default_zone);
 
- out:
-	CORBA_exception_free (&ev);
-	return retval;
+	return TRUE;
 }
 
 /**
@@ -2439,33 +2828,68 @@ cal_client_get_alarms_for_object (CalClient *client, const char *uid,
  * Return value: a #CalClientResult value indicating the result of the
  * operation.
  */
-CalClientResult
-cal_client_discard_alarm (CalClient *client, CalComponent *comp, const char *auid)
+gboolean
+cal_client_discard_alarm (CalClient *client, CalComponent *comp, const char *auid, GError **error)
 {
 	CalClientPrivate *priv;
-	CalClientResult retval;
 	CORBA_Environment ev;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
 	const char *uid;
-
-	g_return_val_if_fail (IS_CAL_CLIENT (client), CAL_CLIENT_RESULT_NOT_FOUND);
-	g_return_val_if_fail (IS_CAL_COMPONENT (comp), CAL_CLIENT_RESULT_NOT_FOUND);
-	g_return_val_if_fail (auid != NULL, CAL_CLIENT_RESULT_NOT_FOUND);
+	
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
 	priv = client->priv;
 
+	e_mutex_lock (client->priv->mutex);
+
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
+
 	cal_component_get_uid (comp, &uid);
 
 	CORBA_exception_init (&ev);
+
 	GNOME_Evolution_Calendar_Cal_discardAlarm (priv->cal, uid, auid, &ev);
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_NotFound))
-		retval = CAL_CLIENT_RESULT_NOT_FOUND;
-	else if (BONOBO_EX (&ev))
-		retval = CAL_CLIENT_RESULT_CORBA_ERROR;
-	else
-		retval = CAL_CLIENT_RESULT_SUCCESS;
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
+	}
 
 	CORBA_exception_free (&ev);
-	return retval;
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
 typedef struct _ForeachTZIDCallbackData ForeachTZIDCallbackData;
@@ -2500,10 +2924,7 @@ foreach_tzid_callback (icalparameter *param, void *cbdata)
 		return;
 
 	if (data->include_all_timezones) {
-		CalClientGetStatus status;
-
-		status = cal_client_get_timezone (data->client, tzid, &zone);
-		if (status != CAL_CLIENT_GET_SUCCESS) {
+		if (!cal_client_get_timezone (data->client, tzid, &zone, NULL)) {
 			data->success = FALSE;
 			return;
 		}
@@ -2642,163 +3063,192 @@ cal_client_get_component_as_string (CalClient *client, icalcomponent *icalcomp)
 	return cal_client_get_component_as_string_internal (client, icalcomp, TRUE);
 }
 
-CalClientResult
-cal_client_update_object_with_mod (CalClient *client, CalComponent *comp, CalObjModType mod)
+gboolean
+cal_client_create_object (CalClient *client, icalcomponent *icalcomp, char **uid, GError **error)
 {
 	CalClientPrivate *priv;
 	CORBA_Environment ev;
-	CalClientResult retval;
-	char *obj_string;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
 
-	g_return_val_if_fail (client != NULL, CAL_CLIENT_RESULT_INVALID_OBJECT);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), CAL_CLIENT_RESULT_INVALID_OBJECT);
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
 	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, CAL_CLIENT_RESULT_INVALID_OBJECT);
 
-	g_return_val_if_fail (comp != NULL, CAL_CLIENT_RESULT_INVALID_OBJECT);
+	e_mutex_lock (client->priv->mutex);
 
-	cal_component_commit_sequence (comp);
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
 
-	obj_string = cal_client_get_component_as_string_internal (client,
-								  cal_component_get_icalcomponent (comp),
-								  FALSE);
-	if (obj_string == NULL)
-		return CAL_CLIENT_RESULT_INVALID_OBJECT;
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
 
 	CORBA_exception_init (&ev);
-	GNOME_Evolution_Calendar_Cal_updateObjects (priv->cal, obj_string, mod, &ev);
-	g_free (obj_string);
-	
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_InvalidObject))
-		retval = CAL_CLIENT_RESULT_INVALID_OBJECT;
-	else if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_NotFound))
-		retval = CAL_CLIENT_RESULT_NOT_FOUND;
-	else if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_PermissionDenied))
-		retval = CAL_CLIENT_RESULT_PERMISSION_DENIED;
-	else if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_update_object(): could not update the object");
-		retval = CAL_CLIENT_RESULT_CORBA_ERROR;
+
+	GNOME_Evolution_Calendar_Cal_createObject (priv->cal, icalcomponent_as_ical_string (icalcomp), &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
-	else
-		retval = CAL_CLIENT_RESULT_SUCCESS;
 
 	CORBA_exception_free (&ev);
-	return retval;
-}
 
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
 
-/**
- * cal_client_update_object:
- * @client: A calendar client.
- * @comp: A calendar component object.
- *
- * Asks a calendar to update a component.  Any existing component with the
- * specified component's UID will be replaced.  The client program should not
- * assume that the object is actually in the server's storage until it has
- * received the "obj_updated" notification signal.
- *
- * Return value: a #CalClientResult value indicating the result of the
- * operation.
- **/
-CalClientResult
-cal_client_update_object (CalClient *client, CalComponent *comp)
-{
+	status = our_op->status;
+	if (uid)
+		*uid = our_op->uid;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
 
-	return cal_client_update_object_with_mod (client, comp, CALOBJ_MOD_ALL);
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
-/**
- * cal_client_update_objects:
- * @client: A calendar client.
- * @icalcomp: A toplevel VCALENDAR libical component.
- *
- * Asks a calendar to add or update one or more components, possibly including
- * VTIMEZONE data.  Any existing components with the same UIDs will be
- * replaced. The VTIMEZONE data will be compared to existing VTIMEZONEs in
- * the calendar, and the VTIMEZONEs may possibly be renamed, as well as all
- * references to them throughout the VCALENDAR.
- *
- * The client program should not assume that the objects are actually in the
- * server's storage until it has received the "obj_updated" notification
- * signal.
- *
- * Return value: a #CalClientResult value indicating the result of the
- * operation.
- **/
-CalClientResult
-cal_client_update_objects (CalClient *client, icalcomponent *icalcomp)
+gboolean
+cal_client_modify_object (CalClient *client, icalcomponent *icalcomp, CalObjModType mod, GError **error)
 {
 	CalClientPrivate *priv;
 	CORBA_Environment ev;
-	CalClientResult retval;
-	char *obj_string;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
 
-	g_return_val_if_fail (client != NULL, CAL_CLIENT_RESULT_INVALID_OBJECT);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), CAL_CLIENT_RESULT_INVALID_OBJECT);
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
+	g_return_val_if_fail (icalcomp != NULL, FALSE);
 
 	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED,
-			      CAL_CLIENT_RESULT_INVALID_OBJECT);
 
-	g_return_val_if_fail (icalcomp != NULL, CAL_CLIENT_RESULT_INVALID_OBJECT);
+	e_mutex_lock (client->priv->mutex);
 
-	/* Libical owns this memory, using one of its temporary buffers. */
-	obj_string = icalcomponent_as_ical_string (icalcomp);
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
 
 	CORBA_exception_init (&ev);
-	GNOME_Evolution_Calendar_Cal_updateObjects (priv->cal, obj_string, GNOME_Evolution_Calendar_MOD_ALL, &ev);
-
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_InvalidObject))
-		retval = CAL_CLIENT_RESULT_INVALID_OBJECT;
-	else if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_NotFound))
-		retval = CAL_CLIENT_RESULT_NOT_FOUND;
-	else if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_PermissionDenied))
-		retval = CAL_CLIENT_RESULT_PERMISSION_DENIED;
-	else if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_update_objects(): could not update the objects");
-		retval = CAL_CLIENT_RESULT_CORBA_ERROR;
+
+	GNOME_Evolution_Calendar_Cal_modifyObject (priv->cal, icalcomponent_as_ical_string (icalcomp), mod, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
-	else
-		retval = CAL_CLIENT_RESULT_SUCCESS;
 
 	CORBA_exception_free (&ev);
-	return retval;
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
-CalClientResult
-cal_client_remove_object_with_mod (CalClient *client, const char *uid, CalObjModType mod)
+gboolean
+cal_client_remove_object_with_mod (CalClient *client, const char *uid,
+				   const char *rid, CalObjModType mod, GError **error)
 {
 	CalClientPrivate *priv;
 	CORBA_Environment ev;
-	CalClientResult retval;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
 
-	g_return_val_if_fail (client != NULL, CAL_CLIENT_RESULT_INVALID_OBJECT);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), CAL_CLIENT_RESULT_INVALID_OBJECT);
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
 	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, CAL_CLIENT_RESULT_INVALID_OBJECT);
 
-	g_return_val_if_fail (uid != NULL, CAL_CLIENT_RESULT_NOT_FOUND);
+	e_mutex_lock (client->priv->mutex);
+
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
+
 
 	CORBA_exception_init (&ev);
-	GNOME_Evolution_Calendar_Cal_removeObject (priv->cal, (char *) uid, mod, &ev);
-
-	if (BONOBO_USER_EX (&ev,  ex_GNOME_Evolution_Calendar_Cal_InvalidObject))
-		retval = CAL_CLIENT_RESULT_INVALID_OBJECT;
-	else if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_NotFound))
-		retval = CAL_CLIENT_RESULT_NOT_FOUND;
-	else if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_PermissionDenied))
-		retval = CAL_CLIENT_RESULT_PERMISSION_DENIED;
-	else if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_remove_object(): could not remove the object");
-		retval = CAL_CLIENT_RESULT_CORBA_ERROR;
+
+	GNOME_Evolution_Calendar_Cal_removeObject (priv->cal, uid, rid ? rid : "", mod, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
 	}
-	else
-		retval = CAL_CLIENT_RESULT_SUCCESS;
 
 	CORBA_exception_free (&ev);
-	return retval;
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
 /**
@@ -2813,69 +3263,319 @@ cal_client_remove_object_with_mod (CalClient *client, const char *uid, CalObjMod
  * Return value: a #CalClientResult value indicating the result of the
  * operation.
  **/
-CalClientResult
-cal_client_remove_object (CalClient *client, const char *uid)
+gboolean
+cal_client_remove_object (CalClient *client, const char *uid, GError **error)
 {
-	return cal_client_remove_object_with_mod (client, uid, CALOBJ_MOD_ALL);
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
+
+	return cal_client_remove_object_with_mod (client, uid, NULL, CALOBJ_MOD_ALL, error);
 }
 
-CalClientResult
-cal_client_send_object (CalClient *client, icalcomponent *icalcomp, 
-			icalcomponent **new_icalcomp, GList **users,
-			char **error_msg)
+gboolean
+cal_client_receive_objects (CalClient *client, icalcomponent *icalcomp, GError **error)
 {
 	CalClientPrivate *priv;
 	CORBA_Environment ev;
-	CalClientResult retval;
-	GNOME_Evolution_Calendar_UserList *user_list;
-	char *obj_string;
-	int i;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
+
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
+
+	priv = client->priv;
+
+	e_mutex_lock (client->priv->mutex);
+
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
+
+	CORBA_exception_init (&ev);
+
+	GNOME_Evolution_Calendar_Cal_receiveObjects (priv->cal, icalcomponent_as_ical_string (icalcomp), &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
+	}
+
+	CORBA_exception_free (&ev);
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
 	
-	g_return_val_if_fail (client != NULL, CAL_CLIENT_RESULT_INVALID_OBJECT);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), CAL_CLIENT_RESULT_INVALID_OBJECT);
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
+}
+
+gboolean
+cal_client_send_objects (CalClient *client, icalcomponent *icalcomp, GError **error)
+{
+	CalClientPrivate *priv;
+	CORBA_Environment ev;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
+
+	g_return_val_if_fail (client != NULL, FALSE);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 
 	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED,
-			      CAL_CLIENT_RESULT_INVALID_OBJECT);
 
-	g_return_val_if_fail (icalcomp != NULL, CAL_CLIENT_RESULT_INVALID_OBJECT);
+	e_mutex_lock (client->priv->mutex);
 
-	/* Libical owns this memory, using one of its temporary buffers. */
-	obj_string = icalcomponent_as_ical_string (icalcomp);
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
 
 	CORBA_exception_init (&ev);
-	obj_string = GNOME_Evolution_Calendar_Cal_sendObject (priv->cal, obj_string, &user_list, &ev);
-
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_InvalidObject)) {
-		retval = CAL_CLIENT_SEND_INVALID_OBJECT;
-	} else if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_Busy)) {
-		retval = CAL_CLIENT_SEND_BUSY;
-		if (error_msg)
-			*error_msg = g_strdup (((GNOME_Evolution_Calendar_Cal_Busy *)(CORBA_exception_value (&ev)))->errorMsg);
-	} else if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_PermissionDenied)) {
-		retval = CAL_CLIENT_SEND_PERMISSION_DENIED;
-	} else if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_update_objects(): could not send the objects");
-		retval = CAL_CLIENT_SEND_CORBA_ERROR;
+
+	GNOME_Evolution_Calendar_Cal_sendObjects (priv->cal, icalcomponent_as_ical_string (icalcomp), &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
+	}
+
+	CORBA_exception_free (&ev);
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
+}
+
+gboolean
+cal_client_get_timezone (CalClient *client, const char *tzid, icaltimezone **zone, GError **error)
+{
+	CalClientPrivate *priv;
+	CORBA_Environment ev;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
+	icalcomponent *icalcomp;
+
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
+	g_return_val_if_fail (tzid != NULL, FALSE);
+
+	priv = client->priv;
+
+	e_mutex_lock (priv->mutex);
+
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (priv->mutex);
+
+	/* Check for well known zones and in the cache */
+	*zone = NULL;
+	
+	/* If tzid is NULL or "" we return NULL, since it is a 'local time'. */
+	if (!tzid || !tzid[0]) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_OK, error);		
+	}
+
+	/* If it is UTC, we return the special UTC timezone. */
+	if (!strcmp (tzid, "UTC")) {
+		*zone = icaltimezone_get_utc_timezone ();
 	} else {
-		retval = CAL_CLIENT_RESULT_SUCCESS;
-		
-		*new_icalcomp = icalparser_parse_string (obj_string);
-		CORBA_free (obj_string);
-
-		if (*new_icalcomp == NULL) {
-			retval = CAL_CLIENT_RESULT_INVALID_OBJECT;
-		} else {
-			*users = NULL;
-			for (i = 0; i < user_list->_length; i++)
-				*users = g_list_append (*users, g_strdup (user_list->_buffer[i]));
-			CORBA_free (user_list);
-		}
+		/* See if we already have it in the cache. */
+		*zone = g_hash_table_lookup (priv->timezones, tzid);
+	}
+	
+	if (*zone) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_OK, error);	
 	}
 	
+	/* call the backend */
+	CORBA_exception_init (&ev);
+
+	GNOME_Evolution_Calendar_Cal_getTimezone (priv->cal, tzid, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
+	}
+
 	CORBA_exception_free (&ev);
 
-	return retval;
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	
+	icalcomp = icalparser_parse_string (our_op->string);
+	g_free (our_op->string);
+	
+	/* FIXME Invalid object status? */
+	if (!icalcomp)
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_OBJECT_NOT_FOUND, error);
+	
+	*zone = icaltimezone_new ();	
+	if (!icaltimezone_set_component (*zone, icalcomp)) {
+		icaltimezone_free (*zone, 1);
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_OBJECT_NOT_FOUND, error);
+	}
+
+	/* Now add it to the cache, to avoid the server call in future. */
+	g_hash_table_insert (priv->timezones, icaltimezone_get_tzid (*zone), *zone);
+
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
+}
+
+/**
+ * cal_client_add_timezone
+ * @client: A calendar client.
+ * @izone: The timezone to add.
+ * @error: Placeholder for error information.
+ *
+ * Add a VTIMEZONE object to the given calendar.
+ *
+ * Returns: TRUE if successful, FALSE otherwise.
+ */
+gboolean
+cal_client_add_timezone (CalClient *client, icaltimezone *izone, GError **error)
+{
+	CalClientPrivate *priv;
+	CORBA_Environment ev;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
+	const char *tzobj;
+
+	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
+	g_return_val_if_fail (izone != NULL, FALSE);
+
+	priv = client->priv;
+
+	e_mutex_lock (priv->mutex);
+
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
+
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (priv->mutex);
+
+	/* convert icaltimezone into a string */
+	tzobj = icalcomponent_as_ical_string (icaltimezone_get_component (izone));
+
+	/* call the backend */
+	CORBA_exception_init (&ev);
+
+	GNOME_Evolution_Calendar_Cal_addTimezone (priv->cal, tzobj, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
+	}
+
+	CORBA_exception_free (&ev);
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
 /**
@@ -2888,20 +3588,68 @@ cal_client_send_object (CalClient *client, icalcomponent *icalcomp,
  * Return value: A query object that will emit notification signals as calendar
  * components are added and removed from the query in the server.
  **/
-CalQuery *
-cal_client_get_query (CalClient *client, const char *sexp)
+gboolean
+cal_client_get_query (CalClient *client, const char *sexp, CalQuery **query, GError **error)
 {
-	CalClientPrivate *priv;
+	CORBA_Environment ev;
+	ECalendarOp *our_op;
+	ECalendarStatus status;
 
-	g_return_val_if_fail (client != NULL, NULL);
-	g_return_val_if_fail (IS_CAL_CLIENT (client), NULL);
+	g_return_val_if_fail (client != NULL, E_CALENDAR_STATUS_INVALID_ARG);
+	g_return_val_if_fail (IS_CAL_CLIENT (client), E_CALENDAR_STATUS_INVALID_ARG);
+	g_return_val_if_fail (query != NULL, E_CALENDAR_STATUS_INVALID_ARG);
 
-	priv = client->priv;
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, FALSE);
+	e_mutex_lock (client->priv->mutex);
+
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
+	}
 
-	g_return_val_if_fail (sexp != NULL, NULL);
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (client->priv->mutex);
+
+	CORBA_exception_init (&ev);
+
+	our_op->listener = query_listener_new ();
+	GNOME_Evolution_Calendar_Cal_getQuery (client->priv->cal, sexp, BONOBO_OBJREF (our_op->listener), &ev);
 
-	return cal_query_new (client, priv->cal, sexp);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
+	}
+	
+	CORBA_exception_free (&ev);
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+	*query = our_op->query;
+
+	bonobo_object_unref (BONOBO_OBJECT (our_op->listener));
+	
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
 
@@ -2910,19 +3658,16 @@ cal_client_get_query (CalClient *client, const char *sexp)
    DATE-TIME values into specific times. (Most of our IDL interface uses
    time_t values to pass specific times from the server to the client.) */
 static gboolean
-cal_client_ensure_timezone_on_server (CalClient *client, icaltimezone *zone)
+cal_client_ensure_timezone_on_server (CalClient *client, icaltimezone *zone, GError **error)
 {
 	CalClientPrivate *priv;
-	char *tzid, *obj_string;
+	char *tzid;
 	icaltimezone *tmp_zone;
-	GString *vcal_string;
-	gboolean retval = FALSE;
-	icalcomponent *vtimezone_comp;
-	char *vtimezone_as_string;
-	CORBA_Environment ev;
 
 	priv = client->priv;
 
+	/* FIXME This is highly broken since there is no locking */
+
 	/* If the zone is NULL or UTC we don't need to do anything. */
 	if (!zone)
 		return TRUE;
@@ -2940,89 +3685,128 @@ cal_client_ensure_timezone_on_server (CalClient *client, icaltimezone *zone)
 
 	/* Now we have to send it to the server, in case it doesn't already
 	   have it. */
-
-	vcal_string = g_string_new (NULL);
-	g_string_append (vcal_string,
-			 "BEGIN:VCALENDAR\n"
-			 "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
-			 "VERSION:2.0\n");
-
-	/* Convert the timezone to a string and add it. */
-	vtimezone_comp = icaltimezone_get_component (zone);
-	if (!vtimezone_comp) {
-		g_string_free (vcal_string, TRUE);
-		return FALSE;
-	}
-
-	/* We don't need to free this string as libical owns it. */
-	vtimezone_as_string = icalcomponent_as_ical_string (vtimezone_comp);
-	g_string_append (vcal_string, vtimezone_as_string);
-
-	g_string_append (vcal_string, "END:VCALENDAR\n");
-
-	obj_string = vcal_string->str;
-	g_string_free (vcal_string, FALSE);
-
-	CORBA_exception_init (&ev);
-	GNOME_Evolution_Calendar_Cal_updateObjects (priv->cal, obj_string, GNOME_Evolution_Calendar_MOD_ALL, &ev);
-	g_free (obj_string);
-	
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_InvalidObject))
-	    goto out;
-	else if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_ensure_timezone_on_server(): could not add the timezone to the server");
-		goto out;
-	}
-
-	retval = TRUE;
-
- out:
-	CORBA_exception_free (&ev);
-	return retval;
+	return cal_client_add_timezone (client, zone, error);
 }
 
-
 gboolean
-cal_client_set_default_timezone (CalClient *client, icaltimezone *zone)
+cal_client_set_default_timezone (CalClient *client, icaltimezone *zone, GError **error)
 {
 	CalClientPrivate *priv;
-	gboolean retval = FALSE;
 	CORBA_Environment ev;
+	ECalendarStatus status;
+	ECalendarOp *our_op;
 	const char *tzid;
-
-	g_return_val_if_fail (client != NULL, FALSE);
+	
 	g_return_val_if_fail (IS_CAL_CLIENT (client), FALSE);
 	g_return_val_if_fail (zone != NULL, FALSE);
 
 	priv = client->priv;
 
-	g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED,
-			      FALSE);
-
 	/* Make sure the server has the VTIMEZONE data. */
-	if (!cal_client_ensure_timezone_on_server (client, zone))
+	if (!cal_client_ensure_timezone_on_server (client, zone, error))
 		return FALSE;
 
-	/* Now set the default timezone on the server. */
-	CORBA_exception_init (&ev);
-	tzid = icaltimezone_get_tzid (zone);
-	GNOME_Evolution_Calendar_Cal_setDefaultTimezone (priv->cal,
-							 (char *) tzid, &ev);
+	e_mutex_lock (priv->mutex);
 
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_NotFound))
-		goto out;
-	else if (BONOBO_EX (&ev)) {
-		g_message ("cal_client_set_default_timezone(): could not set the default timezone");
-		goto out;
+	if (client->priv->load_state != CAL_CLIENT_LOAD_LOADED) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_URI_NOT_LOADED, error);
 	}
 
-	retval = TRUE;
+	if (client->priv->current_op != NULL) {
+		e_mutex_unlock (client->priv->mutex);
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_BUSY, error);
+	}
+
+	our_op = e_calendar_new_op (client);
+
+	e_mutex_lock (our_op->mutex);
+
+	e_mutex_unlock (priv->mutex);
 
-	priv->default_zone = zone;
+	/* FIXME Adding it to the server to change the tzid */
+	tzid = icaltimezone_get_tzid (zone);
+
+	/* call the backend */
+	CORBA_exception_init (&ev);
 
- out:
+	GNOME_Evolution_Calendar_Cal_setDefaultTimezone (priv->cal, tzid, &ev);
+	if (BONOBO_EX (&ev)) {
+		e_calendar_remove_op (client, our_op);
+		e_mutex_unlock (our_op->mutex);
+		e_calendar_free_op (our_op);
+
+		CORBA_exception_free (&ev);
+
+		g_warning (G_STRLOC ": Unable to contact backend");
+
+		E_CALENDAR_CHECK_STATUS (E_CALENDAR_STATUS_CORBA_EXCEPTION, error);
+	}
 
 	CORBA_exception_free (&ev);
-	return retval;
+
+	/* wait for something to happen (both cancellation and a
+	   successful response will notity us via our cv */
+	e_mutex_cond_wait (&our_op->cond, our_op->mutex);
+
+	status = our_op->status;
+
+	e_calendar_remove_op (client, our_op);
+	e_mutex_unlock (our_op->mutex);
+	e_calendar_free_op (our_op);
+
+	E_CALENDAR_CHECK_STATUS (status, error);
 }
 
+/**
+ * cal_client_get_error_message
+ * @status: A status code.
+ *
+ * Get an error message for the given status code.
+ *
+ * Returns: the error message.
+ */
+const char *
+cal_client_get_error_message (ECalendarStatus status)
+{
+	switch (status) {
+	case E_CALENDAR_STATUS_INVALID_ARG :
+		return _("Invalid argument");
+	case E_CALENDAR_STATUS_BUSY :
+		return _("Backend is busy");
+	case E_CALENDAR_STATUS_REPOSITORY_OFFLINE :
+		return _("Repository is offline");
+	case E_CALENDAR_STATUS_NO_SUCH_CALENDAR :
+		return _("No such calendar");
+	case E_CALENDAR_STATUS_OBJECT_NOT_FOUND :
+		return _("Object not found");
+	case E_CALENDAR_STATUS_INVALID_OBJECT :
+		return _("Invalid object");
+	case E_CALENDAR_STATUS_URI_NOT_LOADED :
+		return _("URI not loaded");
+	case E_CALENDAR_STATUS_URI_ALREADY_LOADED :
+		return _("URI already loaded");
+	case E_CALENDAR_STATUS_PERMISSION_DENIED :
+		return _("Permission denied");
+	case E_CALENDAR_STATUS_CARD_NOT_FOUND :
+		return _("Object not found");
+	case E_CALENDAR_STATUS_CARD_ID_ALREADY_EXISTS :
+		return _("Object ID already exists");
+	case E_CALENDAR_STATUS_PROTOCOL_NOT_SUPPORTED :
+		return _("Protocol not supported");
+	case E_CALENDAR_STATUS_CANCELLED :
+		return _("Operation has been cancelled");
+	case E_CALENDAR_STATUS_COULD_NOT_CANCEL :
+		return _("Could not cancel operation");
+	case E_CALENDAR_STATUS_AUTHENTICATION_FAILED :
+		return _("Authentication failed");
+	case E_CALENDAR_STATUS_AUTHENTICATION_REQUIRED :
+		return _("Authentication required");
+	case E_CALENDAR_STATUS_CORBA_EXCEPTION :
+		return _("A CORBA esception has occurred");
+	case E_CALENDAR_STATUS_OTHER_ERROR :
+		return _("Unknown error");
+	}
+
+	return NULL;
+}
diff --git a/calendar/cal-client/cal-client.h b/calendar/cal-client/cal-client.h
index 961ba5d993..277522f097 100644
--- a/calendar/cal-client/cal-client.h
+++ b/calendar/cal-client/cal-client.h
@@ -25,6 +25,7 @@
 #include <cal-util/cal-recur.h>
 #include <cal-util/cal-util.h>
 #include <cal-client/cal-query.h>
+#include "cal-client-types.h"
 
 G_BEGIN_DECLS
 
@@ -37,6 +38,7 @@ G_BEGIN_DECLS
 #define IS_CAL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CAL_CLIENT_TYPE))
 
 #define CAL_CLIENT_OPEN_STATUS_ENUM_TYPE     (cal_client_open_status_enum_get_type ())
+#define CAL_CLIENT_REMOVE_STATUS_ENUM_TYPE   (cal_client_remove_status_enum_get_type ())
 #define CAL_CLIENT_SET_MODE_STATUS_ENUM_TYPE (cal_client_set_mode_status_enum_get_type ())
 #define CAL_MODE_ENUM_TYPE                   (cal_mode_enum_get_type ())
 
@@ -76,14 +78,6 @@ typedef enum {
 	CAL_CLIENT_RESULT_PERMISSION_DENIED
 } CalClientResult;
 
-typedef enum {
-	CAL_CLIENT_SEND_SUCCESS,
-	CAL_CLIENT_SEND_CORBA_ERROR,
-	CAL_CLIENT_SEND_INVALID_OBJECT,
-	CAL_CLIENT_SEND_BUSY,
-	CAL_CLIENT_SEND_PERMISSION_DENIED
-} CalClientSendResult;
-
 /* Whether the client is not loaded, is being loaded, or is already loaded */
 typedef enum {
 	CAL_CLIENT_LOAD_NOT_LOADED,
@@ -104,10 +98,7 @@ struct _CalClientClass {
 	/* Notification signals */
 
 	void (* cal_opened) (CalClient *client, CalClientOpenStatus status);
-	void (* cal_set_mode) (CalClient *client, CalClientSetModeStatus status, CalMode mode);
-	
-	void (* obj_updated) (CalClient *client, const char *uid);
-	void (* obj_removed) (CalClient *client, const char *uid);
+	void (* cal_set_mode) (CalClient *client, CalClientSetModeStatus status, CalMode mode);	
 
 	void (* backend_error) (CalClient *client, const char *message);
 
@@ -129,21 +120,13 @@ GType cal_client_open_status_enum_get_type (void);
 GType cal_client_set_mode_status_enum_get_type (void);
 GType cal_mode_enum_get_type (void);
 
-CalClient *cal_client_construct (CalClient *client);
-
-CalClient *cal_client_new (void);
+CalClient *cal_client_new (const char *uri, CalObjType type);
 
 void cal_client_set_auth_func (CalClient *client, CalClientAuthFunc func, gpointer data);
 
-/* Sets the default timezone to use to resolve DATE and floating DATE-TIME
-   values. This will typically be from the user's timezone setting. Call this
-   before using any other functions. It will pass the default timezone on to
-   the server. Returns TRUE on success. */
-gboolean cal_client_set_default_timezone (CalClient *client, icaltimezone *zone);
-
-gboolean cal_client_open_calendar (CalClient *client, const char *str_uri, gboolean only_if_exists);
-gboolean cal_client_open_default_calendar (CalClient *client, gboolean only_if_exists);
-gboolean cal_client_open_default_tasks (CalClient *client, gboolean only_if_exists);
+gboolean cal_client_open (CalClient *client, gboolean only_if_exists, GError **error);
+void cal_client_open_async (CalClient *client, gboolean only_if_exists);
+gboolean cal_client_remove_calendar (CalClient *client, GError **error);
 
 GList *cal_client_uri_list (CalClient *client, CalMode mode);
 
@@ -151,11 +134,10 @@ CalClientLoadState cal_client_get_load_state (CalClient *client);
 
 const char *cal_client_get_uri (CalClient *client);
 
-gboolean cal_client_is_read_only (CalClient *client);
-
-const char *cal_client_get_cal_address (CalClient *client);
-const char *cal_client_get_alarm_email_address (CalClient *client);
-const char *cal_client_get_ldap_attribute (CalClient *client);
+gboolean cal_client_is_read_only (CalClient *client, gboolean *read_only, GError **error);
+gboolean cal_client_get_cal_address (CalClient *client, char **cal_address, GError **error);
+gboolean cal_client_get_alarm_email_address (CalClient *client, char **alarm_address, GError **error);
+gboolean cal_client_get_ldap_attribute (CalClient *client, char **ldap_attribute, GError **error);
 
 gboolean cal_client_get_one_alarm_only (CalClient *client);
 gboolean cal_client_get_organizer_must_attend (CalClient *client);
@@ -164,28 +146,23 @@ gboolean cal_client_get_static_capability (CalClient *client, const char *cap);
 
 gboolean cal_client_set_mode (CalClient *client, CalMode mode);
 
-int cal_client_get_n_objects (CalClient *client, CalObjType type);
-
-CalClientGetStatus cal_client_get_default_object (CalClient *client,
-						  CalObjType type,
-						  icalcomponent **icalcomp);
+gboolean cal_client_get_default_object (CalClient *client,
+					icalcomponent **icalcomp, GError **error);
 
-CalClientGetStatus cal_client_get_object (CalClient *client,
-					  const char *uid,
-					  icalcomponent **icalcomp);
+gboolean cal_client_get_object (CalClient *client,
+				const char *uid,
+				const char *rid,
+				icalcomponent **icalcomp,
+				GError **error);
 
-CalClientGetStatus cal_client_get_timezone (CalClient *client,
-					    const char *tzid,
-					    icaltimezone **zone);
+gboolean cal_client_get_changes (CalClient *client, CalObjType type, const char *change_id, GList **changes, GError **error);
 
-GList *cal_client_get_uids (CalClient *client, CalObjType type);
-GList *cal_client_get_changes (CalClient *client, CalObjType type, const char *change_id);
+gboolean cal_client_get_object_list (CalClient *client, const char *query, GList **objects, GError **error);
+gboolean cal_client_get_object_list_as_comp (CalClient *client, const char *query, GList **objects, GError **error);
+void cal_client_free_object_list (GList *objects);
 
-GList *cal_client_get_objects_in_range (CalClient *client, CalObjType type,
-					time_t start, time_t end);
-
-GList *cal_client_get_free_busy (CalClient *client, GList *users,
-				 time_t start, time_t end);
+gboolean cal_client_get_free_busy (CalClient *client, GList *users, time_t start, time_t end, 
+				   GList **freebusy, GError **error);
 
 void cal_client_generate_instances (CalClient *client, CalObjType type,
 				    time_t start, time_t end,
@@ -199,24 +176,25 @@ gboolean cal_client_get_alarms_for_object (CalClient *client, const char *uid,
 					   time_t start, time_t end,
 					   CalComponentAlarms **alarms);
 
-CalClientResult cal_client_discard_alarm (CalClient *client, CalComponent *comp, const char *auid);
-
-/* Add or update a single object. When adding an object only builtin timezones
-   are allowed. To use external VTIMEZONE data call update_objects() instead.*/
-CalClientResult cal_client_update_object (CalClient *client, CalComponent *comp);
-CalClientResult cal_client_update_object_with_mod (CalClient *client, CalComponent *comp, CalObjModType mod);
+gboolean cal_client_create_object (CalClient *client, icalcomponent *icalcomp, char **uid, GError **error);
+gboolean cal_client_modify_object (CalClient *client, icalcomponent *icalcomp, CalObjModType mod, GError **error);
+gboolean cal_client_remove_object (CalClient *client, const char *uid, GError **error);
+gboolean cal_client_remove_object_with_mod (CalClient *client, const char *uid, const char *rid, CalObjModType mod, GError **error);
 
-/* Add or update multiple objects, possibly including VTIMEZONE data. */
-CalClientResult cal_client_update_objects (CalClient *client, icalcomponent *icalcomp);
+gboolean cal_client_discard_alarm (CalClient *client, CalComponent *comp, const char *auid, GError **error);
 
-CalClientResult cal_client_remove_object (CalClient *client, const char *uid);
-CalClientResult cal_client_remove_object_with_mod (CalClient *client, const char *uid, CalObjModType mod);
+gboolean cal_client_receive_objects (CalClient *client, icalcomponent *icalcomp, GError **error);
+gboolean cal_client_send_objects (CalClient *client, icalcomponent *icalcomp, GError **error);
 
-CalClientSendResult cal_client_send_object (CalClient *client, icalcomponent *icalcomp, 
-					    icalcomponent **new_icalcomp, GList **users,
-					    char **error_msg);
+gboolean cal_client_get_timezone (CalClient *client, const char *tzid, icaltimezone **zone, GError **error);
+gboolean cal_client_add_timezone (CalClient *client, icaltimezone *izone, GError **error);
+/* Sets the default timezone to use to resolve DATE and floating DATE-TIME
+   values. This will typically be from the user's timezone setting. Call this
+   before using any other functions. It will pass the default timezone on to
+   the server. Returns TRUE on success. */
+gboolean cal_client_set_default_timezone (CalClient *client, icaltimezone *zone, GError **error);
 
-CalQuery *cal_client_get_query (CalClient *client, const char *sexp);
+gboolean cal_client_get_query (CalClient *client, const char *sexp, CalQuery **query, GError **error);
 
 /* Resolves TZIDs for the recurrence generator. */
 icaltimezone *cal_client_resolve_tzid_cb (const char *tzid, gpointer data);
@@ -225,6 +203,7 @@ icaltimezone *cal_client_resolve_tzid_cb (const char *tzid, gpointer data);
    used by the component. It also includes a 'METHOD:PUBLISH' property. */
 char* cal_client_get_component_as_string (CalClient *client, icalcomponent *icalcomp);
 
+const char * cal_client_get_error_message (ECalendarStatus status);
 
 
 
diff --git a/calendar/cal-client/cal-listener.c b/calendar/cal-client/cal-listener.c
index c7beef8c97..ac04be7c07 100644
--- a/calendar/cal-client/cal-listener.c
+++ b/calendar/cal-client/cal-listener.c
@@ -19,6 +19,9 @@
  */
 
 #include <config.h>
+
+#include <bonobo/bonobo-main.h>
+#include "cal-marshal.h"
 #include "cal-listener.h"
 
 
@@ -26,10 +29,7 @@
 /* Private part of the CalListener structure */
 struct CalListenerPrivate {
 	/* Notification functions and their closure data */
-	CalListenerCalOpenedFn cal_opened_fn;
 	CalListenerCalSetModeFn cal_set_mode_fn;
-	CalListenerObjUpdatedFn obj_updated_fn;
-	CalListenerObjRemovedFn obj_removed_fn;
 	CalListenerErrorOccurredFn error_occurred_fn;
 	CalListenerCategoriesChangedFn categories_changed_fn;
 	gpointer fn_data;
@@ -38,124 +38,178 @@ struct CalListenerPrivate {
 	gboolean notify : 1;
 };
 
-
+/* Signal IDs */
+enum {
+	READ_ONLY,
+	CAL_ADDRESS,
+	ALARM_ADDRESS,
+	LDAP_ATTRIBUTE,
+	STATIC_CAPABILITIES,
+	OPEN,
+	REMOVE,
+	CREATE_OBJECT,
+	MODIFY_OBJECT,
+	REMOVE_OBJECT,
+	DISCARD_ALARM,
+	RECEIVE_OBJECTS,
+	SEND_OBJECTS,
+	DEFAULT_OBJECT,
+	OBJECT,
+	OBJECT_LIST,
+	GET_TIMEZONE,
+	ADD_TIMEZONE,
+	SET_DEFAULT_TIMEZONE,
+	GET_CHANGES,
+	GET_FREE_BUSY,
+	QUERY,
+	LAST_SIGNAL
+};
 
-static void cal_listener_class_init (CalListenerClass *klass);
-static void cal_listener_init (CalListener *listener, CalListenerClass *klass);
-static void cal_listener_finalize (GObject *object);
-
-static void impl_notifyCalOpened (PortableServer_Servant servant,
-				  GNOME_Evolution_Calendar_Listener_OpenStatus status,
-				  GNOME_Evolution_Calendar_Cal cal,
-				  CORBA_Environment *ev);
-static void impl_notifyCalSetMode (PortableServer_Servant servant,
-				   GNOME_Evolution_Calendar_Listener_SetModeStatus status,
-				   GNOME_Evolution_Calendar_CalMode mode,
-				   CORBA_Environment *ev);
-static void impl_notifyObjUpdated (PortableServer_Servant servant,
-				   const CORBA_char *uid,
-				   CORBA_Environment *ev);
-static void impl_notifyObjRemoved (PortableServer_Servant servant,
-				   const CORBA_char *uid,
-				   CORBA_Environment *ev);
-static void impl_notifyErrorOccurred (PortableServer_Servant servant,
-				      const CORBA_char *message,
-				      CORBA_Environment *ev);
-static void impl_notifyCategoriesChanged (PortableServer_Servant servant,
-					  const GNOME_Evolution_Calendar_StringSeq *categories,
-					  CORBA_Environment *ev);
+static guint signals[LAST_SIGNAL] = { 0 };
 
 static BonoboObjectClass *parent_class;
 
-
-
-BONOBO_TYPE_FUNC_FULL (CalListener,
-		       GNOME_Evolution_Calendar_Listener,
-		       BONOBO_TYPE_OBJECT,
-		       cal_listener);
+static ECalendarStatus
+convert_status (const GNOME_Evolution_Calendar_CallStatus status)
+{
+	switch (status) {
+	case GNOME_Evolution_Calendar_Success:
+		return E_CALENDAR_STATUS_OK;
+	case GNOME_Evolution_Calendar_RepositoryOffline:
+		return E_CALENDAR_STATUS_REPOSITORY_OFFLINE;
+	case GNOME_Evolution_Calendar_PermissionDenied:
+		return E_CALENDAR_STATUS_PERMISSION_DENIED;
+	case GNOME_Evolution_Calendar_ObjectNotFound:
+		return E_CALENDAR_STATUS_OBJECT_NOT_FOUND;
+	case GNOME_Evolution_Calendar_InvalidObject:
+		return E_CALENDAR_STATUS_INVALID_OBJECT;
+	case GNOME_Evolution_Calendar_CardIdAlreadyExists:
+		return E_CALENDAR_STATUS_CARD_ID_ALREADY_EXISTS;
+	case GNOME_Evolution_Calendar_AuthenticationFailed:
+		return E_CALENDAR_STATUS_AUTHENTICATION_FAILED;
+	case GNOME_Evolution_Calendar_AuthenticationRequired:
+		return E_CALENDAR_STATUS_AUTHENTICATION_REQUIRED;
+	case GNOME_Evolution_Calendar_OtherError:
+	default:
+		return E_CALENDAR_STATUS_OTHER_ERROR;
+	}
+}
 
-/* Class initialization function for the calendar listener */
 static void
-cal_listener_class_init (CalListenerClass *klass)
+impl_notifyReadOnly (PortableServer_Servant servant,
+		     GNOME_Evolution_Calendar_CallStatus status,
+		     const CORBA_boolean read_only,
+		     CORBA_Environment *ev)
 {
-	GObjectClass *object_class;
-
-	object_class = (GObjectClass *) klass;
+	CalListener *listener;
+	CalListenerPrivate *priv;
 
-	parent_class = g_type_class_peek_parent (klass);
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
 
-	klass->epv.notifyCalOpened = impl_notifyCalOpened;
-	klass->epv.notifyCalSetMode = impl_notifyCalSetMode;
-	klass->epv.notifyObjUpdated = impl_notifyObjUpdated;
-	klass->epv.notifyObjRemoved = impl_notifyObjRemoved;
-	klass->epv.notifyErrorOccurred = impl_notifyErrorOccurred;
-	klass->epv.notifyCategoriesChanged = impl_notifyCategoriesChanged;
+	if (!priv->notify)
+		return;
 
-	object_class->finalize = cal_listener_finalize;
+	g_signal_emit (G_OBJECT (listener), signals[READ_ONLY], 0, convert_status (status), read_only);
 }
 
-/* Object initialization function for the calendar listener */
 static void
-cal_listener_init (CalListener *listener, CalListenerClass *klass)
+impl_notifyCalAddress (PortableServer_Servant servant,
+		       GNOME_Evolution_Calendar_CallStatus status,
+		       const CORBA_char *address,
+		       CORBA_Environment *ev)
 {
+	CalListener *listener;
 	CalListenerPrivate *priv;
 
-	priv = g_new0 (CalListenerPrivate, 1);
-	listener->priv = priv;
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
 
-	priv->cal_opened_fn = NULL;
-	priv->obj_updated_fn = NULL;
-	priv->obj_removed_fn = NULL;
-	priv->error_occurred_fn = NULL;
-	priv->categories_changed_fn = NULL;
+	if (!priv->notify)
+		return;
 
-	priv->notify = TRUE;
+	g_signal_emit (G_OBJECT (listener), signals[CAL_ADDRESS], 0, convert_status (status), address);
 }
 
-/* Finalize handler for the calendar listener */
 static void
-cal_listener_finalize (GObject *object)
+impl_notifyAlarmEmailAddress (PortableServer_Servant servant,
+			      GNOME_Evolution_Calendar_CallStatus status,
+			      const CORBA_char *address,
+			      CORBA_Environment *ev)
 {
 	CalListener *listener;
 	CalListenerPrivate *priv;
 
-	g_return_if_fail (object != NULL);
-	g_return_if_fail (IS_CAL_LISTENER (object));
-
-	listener = CAL_LISTENER (object);
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
 	priv = listener->priv;
 
-	priv->cal_opened_fn = NULL;
-	priv->obj_updated_fn = NULL;
-	priv->obj_removed_fn = NULL;
-	priv->error_occurred_fn = NULL;
-	priv->categories_changed_fn = NULL;
-	priv->fn_data = NULL;
+	if (!priv->notify)
+		return;
 
-	priv->notify = FALSE;
+	g_signal_emit (G_OBJECT (listener), signals[ALARM_ADDRESS], 0, convert_status (status), address);
+}
 
-	g_free (priv);
-	listener->priv = NULL;
+static void
+impl_notifyLDAPAttribute (PortableServer_Servant servant,
+			  GNOME_Evolution_Calendar_CallStatus status,
+			  const CORBA_char *ldap_attribute,
+			  CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
 
-	if (G_OBJECT_CLASS (parent_class)->finalize)
-		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+
+	g_signal_emit (G_OBJECT (listener), signals[LDAP_ATTRIBUTE], 0, convert_status (status), ldap_attribute);
 }
 
-
+static void
+impl_notifyStaticCapabilities (PortableServer_Servant servant,
+			       GNOME_Evolution_Calendar_CallStatus status,
+			       const CORBA_char *capabilities,
+			       CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
 
-/* CORBA servant implementation */
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+
+	g_signal_emit (G_OBJECT (listener), signals[STATIC_CAPABILITIES], 0, convert_status (status));
+}
 
 /* ::notifyCalOpened method */
 static void
 impl_notifyCalOpened (PortableServer_Servant servant,
-		      GNOME_Evolution_Calendar_Listener_OpenStatus status,
-		      GNOME_Evolution_Calendar_Cal cal,
+		      GNOME_Evolution_Calendar_CallStatus status,
+		      CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+
+	g_signal_emit (G_OBJECT (listener), signals[OPEN], 0, convert_status (status));
+}
+
+static void
+impl_notifyCalRemoved (PortableServer_Servant servant,
+		      GNOME_Evolution_Calendar_CallStatus status,
 		      CORBA_Environment *ev)
 {
 	CalListener *listener;
 	CalListenerPrivate *priv;
-	CORBA_Environment aev;
-	GNOME_Evolution_Calendar_Cal cal_copy;
 
 	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
 	priv = listener->priv;
@@ -163,63 +217,388 @@ impl_notifyCalOpened (PortableServer_Servant servant,
 	if (!priv->notify)
 		return;
 
-	CORBA_exception_init (&aev);
-	cal_copy = CORBA_Object_duplicate (cal, &aev);
+	g_signal_emit (G_OBJECT (listener), signals[REMOVE], 0, convert_status (status));
+}
+
+static void
+impl_notifyObjectCreated (PortableServer_Servant servant,
+			  GNOME_Evolution_Calendar_CallStatus status,
+			  const CORBA_char *uid,
+			  CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+
+	g_signal_emit (G_OBJECT (listener), signals[CREATE_OBJECT], 0, convert_status (status), uid);
+}
+
+static void
+impl_notifyObjectModified (PortableServer_Servant servant,
+			   GNOME_Evolution_Calendar_CallStatus status,
+			   CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
 
-	if (aev._major != CORBA_NO_EXCEPTION) {
-		g_message ("Listener_notifyCalOpened(): could not duplicate the calendar");
-		CORBA_exception_free (&aev);
+	if (!priv->notify)
 		return;
+
+	g_signal_emit (G_OBJECT (listener), signals[MODIFY_OBJECT], 0, convert_status (status));
+}
+
+static void
+impl_notifyObjectRemoved (PortableServer_Servant servant,
+			  GNOME_Evolution_Calendar_CallStatus status,
+			  CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+
+	g_signal_emit (G_OBJECT (listener), signals[REMOVE_OBJECT], 0, convert_status (status));
+}
+
+static void
+impl_notifyAlarmDiscarded (PortableServer_Servant servant,
+			   GNOME_Evolution_Calendar_CallStatus status,
+			   CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+
+	g_signal_emit (G_OBJECT (listener), signals[DISCARD_ALARM], 0, convert_status (status));
+}
+
+static void
+impl_notifyObjectsReceived (PortableServer_Servant servant,
+			    GNOME_Evolution_Calendar_CallStatus status,
+			    CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+	
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+
+	g_signal_emit (G_OBJECT (listener), signals[RECEIVE_OBJECTS], 0, convert_status (status));
+}
+
+static void
+impl_notifyObjectsSent (PortableServer_Servant servant,
+			GNOME_Evolution_Calendar_CallStatus status,
+			CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+	
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+
+	g_signal_emit (G_OBJECT (listener), signals[SEND_OBJECTS], 0, convert_status (status));
+}
+
+static void 
+impl_notifyDefaultObjectRequested (PortableServer_Servant servant,
+				   const GNOME_Evolution_Calendar_CallStatus status,
+				   const CORBA_char *object,
+				   CORBA_Environment *ev) 
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+	
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+
+	g_signal_emit (G_OBJECT (listener), signals[DEFAULT_OBJECT], 0, convert_status (status), object);
+}
+
+static void 
+impl_notifyObjectRequested (PortableServer_Servant servant,
+			    const GNOME_Evolution_Calendar_CallStatus status,
+			    const CORBA_char *object,
+			    CORBA_Environment *ev) 
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+	
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+
+	g_signal_emit (G_OBJECT (listener), signals[OBJECT], 0, convert_status (status), object);
+}
+
+static GList *
+build_object_list (const GNOME_Evolution_Calendar_stringlist *seq)
+{
+	GList *list;
+	int i;
+
+	list = NULL;
+	for (i = 0; i < seq->_length; i++) {
+		icalcomponent *comp;
+		
+		comp = icalcomponent_new_from_string (seq->_buffer[i]);
+		if (!comp)
+			continue;
+		
+		list = g_list_prepend (list, comp);
 	}
-	CORBA_exception_free (&aev);
 
-	g_assert (priv->cal_opened_fn != NULL);
-	(* priv->cal_opened_fn) (listener, status, cal, priv->fn_data);
+	return list;
+}
+
+static void 
+impl_notifyObjectListRequested (PortableServer_Servant servant,
+				const GNOME_Evolution_Calendar_CallStatus status,
+				const GNOME_Evolution_Calendar_stringlist *objects,
+				CORBA_Environment *ev) 
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+	GList *object_list, *l;
+	
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+
+	object_list = build_object_list (objects);
+	
+	g_signal_emit (G_OBJECT (listener), signals[OBJECT_LIST], 0, convert_status (status), object_list);
+
+	for (l = object_list; l; l = l->next)
+		icalcomponent_free (l->data);
+	g_list_free (object_list);
 }
 
-/* ::notifyCalSetMode method */
 static void
-impl_notifyCalSetMode (PortableServer_Servant servant,
-		       GNOME_Evolution_Calendar_Listener_SetModeStatus status,
-		       GNOME_Evolution_Calendar_CalMode mode,
-		       CORBA_Environment *ev)
+impl_notifyTimezoneRequested (PortableServer_Servant servant,
+			      const GNOME_Evolution_Calendar_CallStatus status,
+			      const CORBA_char *object,
+			      CORBA_Environment *ev)
 {
 	CalListener *listener;
 	CalListenerPrivate *priv;
+	
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+	
+	g_signal_emit (G_OBJECT (listener), signals[GET_TIMEZONE], 0, convert_status (status), object);
+}
 
+static void
+impl_notifyTimezoneAdded (PortableServer_Servant servant,
+			  const GNOME_Evolution_Calendar_CallStatus status,
+			  const CORBA_char *tzid,
+			  CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+	
 	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
 	priv = listener->priv;
 
 	if (!priv->notify)
 		return;
+	
+	g_signal_emit (G_OBJECT (listener), signals[ADD_TIMEZONE], 0, convert_status (status), tzid);
+}
 
-	g_assert (priv->cal_set_mode_fn != NULL);
-	(* priv->cal_set_mode_fn) (listener, status, mode, priv->fn_data);
+static void
+impl_notifyDefaultTimezoneSet (PortableServer_Servant servant,
+			       const GNOME_Evolution_Calendar_CallStatus status,
+			       CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+	
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+	
+	g_signal_emit (G_OBJECT (listener), signals[SET_DEFAULT_TIMEZONE], 0, convert_status (status));
+}
+
+static GList *
+build_change_list (const GNOME_Evolution_Calendar_CalObjChangeSeq *seq)
+{
+	GList *list = NULL;
+	icalcomponent *icalcomp;
+	int i;
+
+	/* Create the list in reverse order */
+	for (i = 0; i < seq->_length; i++) {
+		GNOME_Evolution_Calendar_CalObjChange *corba_coc;
+		CalClientChange *ccc;
+
+		corba_coc = &seq->_buffer[i];
+		ccc = g_new (CalClientChange, 1);
+
+		icalcomp = icalparser_parse_string (corba_coc->calobj);
+		if (!icalcomp)
+			continue;
+
+		ccc->comp = cal_component_new ();
+		if (!cal_component_set_icalcomponent (ccc->comp, icalcomp)) {
+			icalcomponent_free (icalcomp);
+			g_object_unref (G_OBJECT (ccc->comp));
+			continue;
+		}
+		ccc->type = corba_coc->type;
+
+		list = g_list_prepend (list, ccc);
+	}
+
+	list = g_list_reverse (list);
+
+	return list;
 }
 
-/* ::notifyObjUpdated method */
 static void
-impl_notifyObjUpdated (PortableServer_Servant servant,
-		       const CORBA_char *uid,
-		       CORBA_Environment *ev)
+impl_notifyChanges (PortableServer_Servant servant,
+		    const GNOME_Evolution_Calendar_CallStatus status,
+		    const GNOME_Evolution_Calendar_CalObjChangeSeq *seq,
+		    CORBA_Environment *ev)
 {
 	CalListener *listener;
 	CalListenerPrivate *priv;
+	GList *changes, *l;
+	
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
 
+	if (!priv->notify)
+		return;
+	
+	changes = build_change_list (seq);
+	
+	g_signal_emit (G_OBJECT (listener), signals[GET_CHANGES], 0, convert_status (status), changes);
+
+	for (l = changes; l; l = l->next)
+		g_free (l->data);
+	g_list_free (changes);
+}
+
+static GList *
+build_free_busy_list (const GNOME_Evolution_Calendar_CalObjSeq *seq)
+{
+	GList *list = NULL;
+	int i;
+
+	/* Create the list in reverse order */
+	for (i = 0; i < seq->_length; i++) {
+		CalComponent *comp;
+		icalcomponent *icalcomp;
+		icalcomponent_kind kind;
+
+		icalcomp = icalcomponent_new_from_string (seq->_buffer[i]);
+		if (!icalcomp)
+			continue;
+
+		kind = icalcomponent_isa (icalcomp);
+		if (kind == ICAL_VFREEBUSY_COMPONENT) {
+			comp = cal_component_new ();
+			if (!cal_component_set_icalcomponent (comp, icalcomp)) {
+				icalcomponent_free (icalcomp);
+				g_object_unref (G_OBJECT (comp));
+				continue;
+			}
+			
+			list = g_list_append (list, comp);
+		} else {
+			icalcomponent_free (icalcomp);
+		}
+	}
+
+	return list;
+}
+
+static void
+impl_notifyFreeBusy (PortableServer_Servant servant,
+		     const GNOME_Evolution_Calendar_CallStatus status,
+		     const GNOME_Evolution_Calendar_CalObjSeq *seq,
+		     CORBA_Environment *ev)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+	GList *freebusy, *l;
+	
 	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
 	priv = listener->priv;
 
 	if (!priv->notify)
 		return;
+	
+	freebusy = build_free_busy_list (seq);
+	
+	g_signal_emit (G_OBJECT (listener), signals[GET_FREE_BUSY], 0, convert_status (status), freebusy);
+
+	for (l = freebusy; l; l = l->next)
+		g_free (l->data);
+	g_list_free (freebusy);
+}
 
-	g_assert (priv->obj_updated_fn != NULL);
-	(* priv->obj_updated_fn) (listener, uid, priv->fn_data);
+static void 
+impl_notifyQuery (PortableServer_Servant servant,
+		  const GNOME_Evolution_Calendar_CallStatus status,
+		  const GNOME_Evolution_Calendar_Query query,
+		  CORBA_Environment *ev) 
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+	
+	listener = CAL_LISTENER (bonobo_object_from_servant (servant));
+	priv = listener->priv;
+
+	if (!priv->notify)
+		return;
+	
+	g_signal_emit (G_OBJECT (listener), signals[QUERY], 0, convert_status (status), query);
 }
 
-/* ::notifyObjRemoved method */
+/* ::notifyCalSetMode method */
 static void
-impl_notifyObjRemoved (PortableServer_Servant servant,
-		       const CORBA_char *uid,
+impl_notifyCalSetMode (PortableServer_Servant servant,
+		       GNOME_Evolution_Calendar_Listener_SetModeStatus status,
+		       GNOME_Evolution_Calendar_CalMode mode,
 		       CORBA_Environment *ev)
 {
 	CalListener *listener;
@@ -231,10 +610,13 @@ impl_notifyObjRemoved (PortableServer_Servant servant,
 	if (!priv->notify)
 		return;
 
-	g_assert (priv->obj_removed_fn != NULL);
-	(* priv->obj_removed_fn) (listener, uid, priv->fn_data);
+	g_message ("notify_set_mode");
+
+	g_assert (priv->cal_set_mode_fn != NULL);
+	(* priv->cal_set_mode_fn) (listener, status, mode, priv->fn_data);
 }
 
+
 /* ::notifyErrorOccurred method */
 static void
 impl_notifyErrorOccurred (PortableServer_Servant servant,
@@ -250,6 +632,8 @@ impl_notifyErrorOccurred (PortableServer_Servant servant,
 	if (!priv->notify)
 		return;
 
+	g_message ("notify_error");
+
 	g_assert (priv->error_occurred_fn != NULL);
 	(* priv->error_occurred_fn) (listener, message, priv->fn_data);
 }
@@ -269,21 +653,283 @@ impl_notifyCategoriesChanged (PortableServer_Servant servant,
 	if (!priv->notify)
 		return;
 
+	g_message ("notify_categories");
+
 	g_assert (priv->categories_changed_fn != NULL);
 	(* priv->categories_changed_fn) (listener, categories, priv->fn_data);
 }
 
 
 
+/* Object initialization function for the calendar listener */
+static void
+cal_listener_init (CalListener *listener, CalListenerClass *klass)
+{
+	CalListenerPrivate *priv;
+
+	priv = g_new0 (CalListenerPrivate, 1);
+	listener->priv = priv;
+
+	priv->error_occurred_fn = NULL;
+	priv->categories_changed_fn = NULL;
+
+	priv->notify = TRUE;
+}
+
+/* Finalize handler for the calendar listener */
+static void
+cal_listener_finalize (GObject *object)
+{
+	CalListener *listener;
+	CalListenerPrivate *priv;
+
+	g_return_if_fail (object != NULL);
+	g_return_if_fail (IS_CAL_LISTENER (object));
+
+	listener = CAL_LISTENER (object);
+	priv = listener->priv;
+
+	priv->error_occurred_fn = NULL;
+	priv->categories_changed_fn = NULL;
+	priv->fn_data = NULL;
+
+	priv->notify = FALSE;
+
+	g_free (priv);
+	listener->priv = NULL;
+
+	if (G_OBJECT_CLASS (parent_class)->finalize)
+		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
+}
+
+/* Class initialization function for the calendar listener */
+static void
+cal_listener_class_init (CalListenerClass *klass)
+{
+	GObjectClass *object_class;
+
+	object_class = (GObjectClass *) klass;
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	klass->epv.notifyReadOnly = impl_notifyReadOnly;
+	klass->epv.notifyCalAddress = impl_notifyCalAddress;
+	klass->epv.notifyAlarmEmailAddress = impl_notifyAlarmEmailAddress;
+	klass->epv.notifyLDAPAttribute = impl_notifyLDAPAttribute;
+	klass->epv.notifyStaticCapabilities = impl_notifyStaticCapabilities;
+	klass->epv.notifyCalOpened = impl_notifyCalOpened;
+	klass->epv.notifyCalRemoved = impl_notifyCalRemoved;
+	klass->epv.notifyObjectCreated = impl_notifyObjectCreated;
+	klass->epv.notifyObjectModified = impl_notifyObjectModified;
+	klass->epv.notifyObjectRemoved = impl_notifyObjectRemoved;
+	klass->epv.notifyAlarmDiscarded = impl_notifyAlarmDiscarded;
+	klass->epv.notifyObjectsReceived = impl_notifyObjectsReceived;
+	klass->epv.notifyObjectsSent = impl_notifyObjectsSent;
+	klass->epv.notifyDefaultObjectRequested = impl_notifyDefaultObjectRequested;
+	klass->epv.notifyObjectRequested = impl_notifyObjectRequested;
+	klass->epv.notifyObjectListRequested = impl_notifyObjectListRequested;
+	klass->epv.notifyTimezoneRequested = impl_notifyTimezoneRequested;
+	klass->epv.notifyTimezoneAdded = impl_notifyTimezoneAdded;
+	klass->epv.notifyDefaultTimezoneSet = impl_notifyDefaultTimezoneSet;
+	klass->epv.notifyChanges = impl_notifyChanges;
+	klass->epv.notifyFreeBusy = impl_notifyFreeBusy;
+	klass->epv.notifyQuery = impl_notifyQuery;
+	klass->epv.notifyCalSetMode = impl_notifyCalSetMode;
+	klass->epv.notifyErrorOccurred = impl_notifyErrorOccurred;
+	klass->epv.notifyCategoriesChanged = impl_notifyCategoriesChanged;
+
+	object_class->finalize = cal_listener_finalize;
+
+	signals[READ_ONLY] =
+		g_signal_new ("read_only",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, read_only),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_BOOLEAN,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_BOOLEAN);
+	signals[CAL_ADDRESS] =
+		g_signal_new ("cal_address",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, cal_address),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_STRING,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_STRING);
+	signals[ALARM_ADDRESS] =
+		g_signal_new ("alarm_address",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, alarm_address),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_STRING,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_STRING);
+	signals[LDAP_ATTRIBUTE] =
+		g_signal_new ("ldap_attribute",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, ldap_attribute),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_STRING,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_STRING);	
+	signals[STATIC_CAPABILITIES] =
+		g_signal_new ("static_capabilities",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, static_capabilities),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_STRING,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_STRING);
+	signals[OPEN] =
+		g_signal_new ("open",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, open),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);	
+	signals[REMOVE] =
+		g_signal_new ("remove",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, remove),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);
+	signals[CREATE_OBJECT] =
+		g_signal_new ("create_object",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, create_object),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_STRING,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_STRING);
+	signals[MODIFY_OBJECT] =
+		g_signal_new ("modify_object",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, modify_object),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);	
+	signals[REMOVE_OBJECT] =
+		g_signal_new ("remove_object",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, remove_object),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);
+	signals[DISCARD_ALARM] =
+		g_signal_new ("discard_alarm",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, discard_alarm),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);
+	signals[RECEIVE_OBJECTS] =
+		g_signal_new ("receive_objects",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, receive_objects),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);
+	signals[SEND_OBJECTS] =
+		g_signal_new ("send_objects",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, send_objects),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);
+	signals[DEFAULT_OBJECT] =
+		g_signal_new ("default_object",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, default_object),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_STRING,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_STRING);
+	signals[OBJECT] =
+		g_signal_new ("object",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, object),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_STRING,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_STRING);
+	signals[OBJECT_LIST] =
+		g_signal_new ("object_list",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, object_list),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_POINTER,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_POINTER);
+	signals[GET_TIMEZONE] =
+		g_signal_new ("get_timezone",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, get_timezone),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_STRING,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_STRING);
+	signals[ADD_TIMEZONE] =
+		g_signal_new ("add_timezone",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, add_timezone),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_STRING,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_STRING);
+	signals[SET_DEFAULT_TIMEZONE] =
+		g_signal_new ("set_default_timezone",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, set_default_timezone),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);
+	signals[GET_CHANGES] =
+		g_signal_new ("get_changes",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, get_changes),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_POINTER,
+			      G_TYPE_NONE, 1, G_TYPE_INT, G_TYPE_POINTER);
+	signals[GET_FREE_BUSY] =
+		g_signal_new ("get_free_busy",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, get_free_busy),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_POINTER,
+			      G_TYPE_NONE, 1, G_TYPE_INT, G_TYPE_POINTER);
+	signals[QUERY] =
+		g_signal_new ("query",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (CalListenerClass, query),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT_POINTER,
+			      G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_POINTER);
+}
+
+BONOBO_TYPE_FUNC_FULL (CalListener,
+		       GNOME_Evolution_Calendar_Listener,
+		       BONOBO_TYPE_OBJECT,
+		       cal_listener);
+
 /**
  * cal_listener_construct:
  * @listener: A calendar listener.
  * @cal_opened_fn: Function that will be called to notify that a calendar was
  * opened.
- * @obj_updated_fn: Function that will be called to notify that an object in the
- * calendar was updated.
- * @obj_removed_fn: Function that will be called to notify that an object in the
- * calendar was removed.
+ * @cal_removed_fn: Function that will be called to notify that a calendar was
+ * removed
  * @error_occurred_fn: Function that will be called to notify errors.
  * @categories_changed_fn: Function that will be called to notify that the list
  * of categories that are present in the calendar's objects has changed.
@@ -297,10 +943,7 @@ impl_notifyCategoriesChanged (PortableServer_Servant servant,
  **/
 CalListener *
 cal_listener_construct (CalListener *listener,
-			CalListenerCalOpenedFn cal_opened_fn,
 			CalListenerCalSetModeFn cal_set_mode_fn,
-			CalListenerObjUpdatedFn obj_updated_fn,
-			CalListenerObjRemovedFn obj_removed_fn,
 			CalListenerErrorOccurredFn error_occurred_fn,
 			CalListenerCategoriesChangedFn categories_changed_fn,
 			gpointer fn_data)
@@ -309,19 +952,13 @@ cal_listener_construct (CalListener *listener,
 
 	g_return_val_if_fail (listener != NULL, NULL);
 	g_return_val_if_fail (IS_CAL_LISTENER (listener), NULL);
-	g_return_val_if_fail (cal_opened_fn != NULL, NULL);
  	g_return_val_if_fail (cal_set_mode_fn != NULL, NULL);
-	g_return_val_if_fail (obj_updated_fn != NULL, NULL);
-	g_return_val_if_fail (obj_removed_fn != NULL, NULL);
 	g_return_val_if_fail (error_occurred_fn != NULL, NULL);
 	g_return_val_if_fail (categories_changed_fn != NULL, NULL);
 
 	priv = listener->priv;
 
-	priv->cal_opened_fn = cal_opened_fn;
 	priv->cal_set_mode_fn = cal_set_mode_fn;
-	priv->obj_updated_fn = obj_updated_fn;
-	priv->obj_removed_fn = obj_removed_fn;
 	priv->error_occurred_fn = error_occurred_fn;
 	priv->categories_changed_fn = categories_changed_fn;
 	priv->fn_data = fn_data;
@@ -333,10 +970,6 @@ cal_listener_construct (CalListener *listener,
  * cal_listener_new:
  * @cal_opened_fn: Function that will be called to notify that a calendar was
  * opened.
- * @obj_updated_fn: Function that will be called to notify that an object in the
- * calendar was updated.
- * @obj_removed_fn: Function that will be called to notify that an object in the
- * calendar was removed.
  * @error_occurred_fn: Function that will be called to notify errors.
  * @categories_changed_fn: Function that will be called to notify that the list
  * of categories that are present in the calendar's objects has changed.
@@ -348,28 +981,22 @@ cal_listener_construct (CalListener *listener,
  * Return value: A newly-created #CalListener object.
  **/
 CalListener *
-cal_listener_new (CalListenerCalOpenedFn cal_opened_fn,
-		  CalListenerCalSetModeFn cal_set_mode_fn,
-		  CalListenerObjUpdatedFn obj_updated_fn,
-		  CalListenerObjRemovedFn obj_removed_fn,
+cal_listener_new (CalListenerCalSetModeFn cal_set_mode_fn,
 		  CalListenerErrorOccurredFn error_occurred_fn,
 		  CalListenerCategoriesChangedFn categories_changed_fn,
 		  gpointer fn_data)
 {
 	CalListener *listener;
 
-	g_return_val_if_fail (cal_opened_fn != NULL, NULL);
-	g_return_val_if_fail (obj_updated_fn != NULL, NULL);
-	g_return_val_if_fail (obj_removed_fn != NULL, NULL);
 	g_return_val_if_fail (error_occurred_fn != NULL, NULL);
 	g_return_val_if_fail (categories_changed_fn != NULL, NULL);
 
-	listener = g_object_new (CAL_LISTENER_TYPE, NULL);
+	listener = g_object_new (CAL_LISTENER_TYPE, 
+				 "poa", bonobo_poa_get_threaded (ORBIT_THREAD_HINT_PER_REQUEST, NULL),
+				 NULL);
+
 	return cal_listener_construct (listener,
-				       cal_opened_fn,
 				       cal_set_mode_fn,
-				       obj_updated_fn,
-				       obj_removed_fn,
 				       error_occurred_fn,
 				       categories_changed_fn,
 				       fn_data);
diff --git a/calendar/cal-client/cal-listener.h b/calendar/cal-client/cal-listener.h
index d0f9a718a4..1230104999 100644
--- a/calendar/cal-client/cal-listener.h
+++ b/calendar/cal-client/cal-listener.h
@@ -23,6 +23,7 @@
 
 #include <bonobo/bonobo-object.h>
 #include "evolution-calendar.h"
+#include "cal-client-types.h"
 
 G_BEGIN_DECLS
 
@@ -48,26 +49,46 @@ typedef struct {
 	BonoboObjectClass parent_class;
 
 	POA_GNOME_Evolution_Calendar_Listener__epv epv;
+
+	/* Signals */
+	void (*read_only) (CalListener *listener, ECalendarStatus status, gboolean read_only);
+	void (*cal_address) (CalListener *listener, ECalendarStatus status, const char *address);
+	void (*alarm_address) (CalListener *listener, ECalendarStatus status, const char *address);
+	void (*ldap_attribute) (CalListener *listener, ECalendarStatus status, const char *ldap_attribute);
+	void (*static_capabilities) (CalListener *listener, ECalendarStatus status, const char *capabilities);
+
+	void (*open) (CalListener *listener, ECalendarStatus status);
+	void (*remove) (CalListener *listener, ECalendarStatus status);
+
+	void (*create_object) (CalListener *listener, ECalendarStatus status, const char *id);
+	void (*modify_object) (CalListener *listener, ECalendarStatus status);
+	void (*remove_object) (CalListener *listener, ECalendarStatus status);
+
+	void (*discard_alarm) (CalListener *listener, ECalendarStatus status);
+
+ 	void (*receive_objects) (CalListener *listener, ECalendarStatus status);
+ 	void (*send_objects) (CalListener *listener, ECalendarStatus status);
+
+	void (*default_object) (CalListener *listener, ECalendarStatus status, const char *object);
+	void (*object) (CalListener *listener, ECalendarStatus status, const char *object);
+	void (*object_list) (CalListener *listener, ECalendarStatus status, GList **objects);
+
+	void (*get_timezone) (CalListener *listener, ECalendarStatus status, const char *object);
+	void (*add_timezone) (CalListener *listener, ECalendarStatus status, const char *tzid);
+	void (*set_default_timezone) (CalListener *listener, ECalendarStatus status, const char *tzid);
+
+	void (*get_changes) (CalListener *listener, ECalendarStatus status, GList *changes);
+	void (*get_free_busy) (CalListener *listener, ECalendarStatus status, GList *freebusy);
+	
+	void (*query) (CalListener *listener, ECalendarStatus status, GNOME_Evolution_Calendar_Query query);
 } CalListenerClass;
 
 /* Notification functions */
-typedef void (* CalListenerCalOpenedFn) (CalListener *listener,
-					 GNOME_Evolution_Calendar_Listener_OpenStatus status,
-					 GNOME_Evolution_Calendar_Cal cal,
-					 gpointer data);
-
 typedef void (* CalListenerCalSetModeFn) (CalListener *listener,
 					  GNOME_Evolution_Calendar_Listener_SetModeStatus status,
 					  GNOME_Evolution_Calendar_CalMode mode,
 					  gpointer data);
 
-typedef void (* CalListenerObjUpdatedFn) (CalListener *listener,
-					  const CORBA_char *uid,
-					  gpointer data);
-typedef void (* CalListenerObjRemovedFn) (CalListener *listener,
-					  const CORBA_char *uid,
-					  gpointer data);
-
 typedef void (* CalListenerErrorOccurredFn) (CalListener *listener,
 					     const char *message,
 					     gpointer data);
@@ -80,18 +101,12 @@ typedef void (* CalListenerCategoriesChangedFn) (CalListener *listener,
 GType cal_listener_get_type (void);
 
 CalListener *cal_listener_construct (CalListener *listener,
-				     CalListenerCalOpenedFn cal_opened_fn,
 				     CalListenerCalSetModeFn cal_set_mode_fn,
-				     CalListenerObjUpdatedFn obj_updated_fn,
-				     CalListenerObjRemovedFn obj_removed_fn,
 				     CalListenerErrorOccurredFn error_occurred_fn,
 				     CalListenerCategoriesChangedFn categories_changed_fn,
 				     gpointer fn_data);
 
-CalListener *cal_listener_new (CalListenerCalOpenedFn cal_opened_fn,
-			       CalListenerCalSetModeFn cal_set_mode_fn,
-			       CalListenerObjUpdatedFn obj_updated_fn,
-			       CalListenerObjRemovedFn obj_removed_fn,
+CalListener *cal_listener_new (CalListenerCalSetModeFn cal_set_mode_fn,
 			       CalListenerErrorOccurredFn error_occurred_fn,
 			       CalListenerCategoriesChangedFn categories_changed_fn,
 			       gpointer fn_data);
diff --git a/calendar/cal-client/cal-marshal.list b/calendar/cal-client/cal-marshal.list
new file mode 100644
index 0000000000..e0ca019669
--- /dev/null
+++ b/calendar/cal-client/cal-marshal.list
@@ -0,0 +1,6 @@
+NONE:INT
+NONE:POINTER
+NONE:INT,STRING
+NONE:INT,BOOL
+NONE:INT,POINTER
+NONE:STRING,INT
diff --git a/calendar/cal-client/cal-query.c b/calendar/cal-client/cal-query.c
index 914af5db28..e77f5ad3e9 100644
--- a/calendar/cal-client/cal-query.c
+++ b/calendar/cal-client/cal-query.c
@@ -24,7 +24,8 @@
 
 #include <string.h>
 #include <bonobo/bonobo-exception.h>
-#include "cal-util/cal-util-marshal.h"
+#include "cal-marshal.h"
+#include "cal-client.h"
 #include "cal-query.h"
 #include "query-listener.h"
 
@@ -32,143 +33,88 @@
 
 /* Private part of the CalQuery structure */
 struct _CalQueryPrivate {
-	/* Our query listener implementation */
-	QueryListener *ql;
-
 	/* Handle to the query in the server */
-	GNOME_Evolution_Calendar_Query corba_query;
+	GNOME_Evolution_Calendar_Query query;
+
+	/* Our query listener implementation */
+	QueryListener *listener;
 
 	/* The CalClient associated with this query */
 	CalClient *client;
 };
 
-
-
-static void cal_query_class_init (CalQueryClass *klass);
-static void cal_query_init (CalQuery *query, CalQueryClass *klass);
-static void cal_query_finalize (GObject *object);
+/* Property IDs */
+enum props {
+	PROP_0,
+	PROP_QUERY,
+	PROP_LISTENER,
+	PROP_CLIENT
+};
 
 /* Signal IDs */
 enum {
-	OBJ_UPDATED,
-	OBJ_REMOVED,
+	OBJECTS_ADDED,
+	OBJECTS_MODIFIED,
+	OBJECTS_REMOVED,
+	QUERY_PROGRESS,
 	QUERY_DONE,
-	EVAL_ERROR,
 	LAST_SIGNAL
 };
 
-static guint query_signals[LAST_SIGNAL];
+static guint signals[LAST_SIGNAL];
 
 static GObjectClass *parent_class;
 
 
 
-/**
- * cal_query_get_type:
- * 
- * Registers the #CalQuery class if necessary, and returns the type ID assigned
- * to it.
- * 
- * Return value: The type ID of the #CalQuery class.
- **/
-GType
-cal_query_get_type (void)
+static void
+objects_added_cb (QueryListener *listener, GList *objects, gpointer data)
 {
-	static GType cal_query_type = 0;
+	CalQuery *query;
 
-	if (!cal_query_type) {
-		static GTypeInfo info = {
-                        sizeof (CalQueryClass),
-                        (GBaseInitFunc) NULL,
-                        (GBaseFinalizeFunc) NULL,
-                        (GClassInitFunc) cal_query_class_init,
-                        NULL, NULL,
-                        sizeof (CalQuery),
-                        0,
-                        (GInstanceInitFunc) cal_query_init
-                };
-		cal_query_type = g_type_register_static (G_TYPE_OBJECT, "CalQuery", &info, 0);
-	}
+	query = CAL_QUERY (data);
 
-	return cal_query_type;
+	g_signal_emit (G_OBJECT (query), signals[OBJECTS_ADDED], 0, objects);
 }
 
-GType
-cal_query_done_status_enum_get_type (void)
+static void
+objects_modified_cb (QueryListener *listener, GList *objects, gpointer data)
 {
-	static GType cal_query_done_status_enum_type = 0;
+	CalQuery *query;
 
-	if (!cal_query_done_status_enum_type) {
-		static GEnumValue values [] = {
-		  { CAL_QUERY_DONE_SUCCESS,     "CalQueryDoneSuccess",    "success"     },
-		  { CAL_QUERY_DONE_PARSE_ERROR, "CalQueryDoneParseError", "parse-error" },
-		  { -1,                         NULL,                     NULL          }
-		};
+	query = CAL_QUERY (data);
 
-		cal_query_done_status_enum_type =
-		  g_enum_register_static ("CalQueryDoneStatusEnum", values);
-	}
+	g_signal_emit (G_OBJECT (query), signals[OBJECTS_MODIFIED], 0, objects);
+}
+
+static void
+objects_removed_cb (QueryListener *listener, GList *uids, gpointer data)
+{
+	CalQuery *query;
+
+	query = CAL_QUERY (data);
 
-	return cal_query_done_status_enum_type;
+	g_signal_emit (G_OBJECT (query), signals[OBJECTS_REMOVED], 0, uids);
 }
 
-/* Class initialization function for the calendar query */
 static void
-cal_query_class_init (CalQueryClass *klass)
+query_progress_cb (QueryListener *listener, const char *message, int percent, gpointer data)
 {
-	GObjectClass *object_class;
+	CalQuery *query;
 
-	object_class = (GObjectClass *) klass;
+	query = CAL_QUERY (data);
 
-	parent_class = g_type_class_peek_parent (klass);
+	g_signal_emit (G_OBJECT (query), signals[QUERY_PROGRESS], 0, message, percent);
+}
 
-	query_signals[OBJ_UPDATED] =
-		g_signal_new ("obj_updated",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalQueryClass, obj_updated),
-			      NULL, NULL,
-			      cal_util_marshal_VOID__STRING_BOOLEAN_INT_INT,
-			      G_TYPE_NONE, 4,
-			      G_TYPE_STRING,
-			      G_TYPE_BOOLEAN,
-			      G_TYPE_INT,
-			      G_TYPE_INT);
-	query_signals[OBJ_REMOVED] =
-		g_signal_new ("obj_removed",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalQueryClass, obj_removed),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__STRING,
-			      G_TYPE_NONE, 1,
-			      G_TYPE_STRING);
-	query_signals[QUERY_DONE] =
-		g_signal_new ("query_done",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalQueryClass, query_done),
-			      NULL, NULL,
-			      cal_util_marshal_VOID__ENUM_STRING,
-			      G_TYPE_NONE, 2,
-			      CAL_QUERY_DONE_STATUS_ENUM_TYPE,
-			      G_TYPE_STRING);
-	query_signals[EVAL_ERROR] =
-		g_signal_new ("eval_error",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalQueryClass, eval_error),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__STRING,
-			      G_TYPE_NONE, 1,
-			      G_TYPE_STRING);
+static void
+query_done_cb (QueryListener *listener, ECalendarStatus status, gpointer data)
+{
+	CalQuery *query;
 
-	klass->obj_updated = NULL;
-	klass->obj_removed = NULL;
-	klass->query_done = NULL;
-	klass->eval_error = NULL;
+	query = CAL_QUERY (data);
 
-	object_class->finalize = cal_query_finalize;
+	g_signal_emit (G_OBJECT (query), signals[QUERY_DONE], 0, status);
 }
 
 /* Object initialization function for the calendar query */
@@ -180,191 +126,193 @@ cal_query_init (CalQuery *query, CalQueryClass *klass)
 	priv = g_new0 (CalQueryPrivate, 1);
 	query->priv = priv;
 
-	priv->ql = NULL;
-	priv->corba_query = CORBA_OBJECT_NIL;
+	priv->listener = NULL;
+	priv->query = CORBA_OBJECT_NIL;
 }
 
-/* Finalize handler for the calendar query */
 static void
-cal_query_finalize (GObject *object)
+cal_query_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
 {
 	CalQuery *query;
 	CalQueryPrivate *priv;
-
-	g_return_if_fail (object != NULL);
-	g_return_if_fail (IS_CAL_QUERY (object));
-
+	
 	query = CAL_QUERY (object);
 	priv = query->priv;
-
-	/* The server keeps a copy of the query listener, so we must unref it */
-	query_listener_stop_notification (priv->ql);
-	bonobo_object_unref (BONOBO_OBJECT (priv->ql));
-	priv->ql = NULL;
-
-	if (priv->corba_query != CORBA_OBJECT_NIL) {
-		CORBA_Environment ev;
-
-		CORBA_exception_init (&ev);
-		bonobo_object_release_unref (priv->corba_query, &ev);
-
-		if (BONOBO_EX (&ev))
-			g_message ("cal_query_destroy(): Could not release/unref the query");
-
-		CORBA_exception_free (&ev);
-		priv->corba_query = CORBA_OBJECT_NIL;
+	
+	switch (property_id) {
+	case PROP_QUERY:
+		priv->query = bonobo_object_dup_ref (g_value_get_pointer (value), NULL);
+		break;
+	case PROP_LISTENER:
+		priv->listener = bonobo_object_ref (g_value_get_pointer (value));
+
+		g_signal_connect (G_OBJECT (priv->listener), "objects_added", 
+				  G_CALLBACK (objects_added_cb), query);
+		g_signal_connect (G_OBJECT (priv->listener), "objects_modified", 
+				  G_CALLBACK (objects_modified_cb), query);
+		g_signal_connect (G_OBJECT (priv->listener), "objects_removed", 
+				  G_CALLBACK (objects_removed_cb), query);
+		g_signal_connect (G_OBJECT (priv->listener), "query_progress", 
+				  G_CALLBACK (query_progress_cb), query);
+		g_signal_connect (G_OBJECT (priv->listener), "query_done", 
+				  G_CALLBACK (query_done_cb), query);
+		break;		
+	case PROP_CLIENT:
+		priv->client = CAL_CLIENT (g_value_dup_object (value));
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+		break;
 	}
-
-	g_free (priv);
-	query->priv = NULL;
-
-	if (G_OBJECT_CLASS (parent_class)->finalize)
-		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
 }
 
-
-
-/* Callback used when an object is updated in the query */
 static void
-obj_updated_cb (QueryListener *ql,
-		const GNOME_Evolution_Calendar_CalObjUIDSeq *uids,
-		CORBA_boolean query_in_progress,
-		CORBA_long n_scanned,
-		CORBA_long total,
-		gpointer data)
+cal_query_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
 {
 	CalQuery *query;
-	int n;
-
-	query = CAL_QUERY (data);
+	CalQueryPrivate *priv;
+	
+	query = CAL_QUERY (object);
+	priv = query->priv;
 
-	for (n = 0; n < uids->_length; n++) {
-		g_signal_emit (G_OBJECT (query), query_signals[OBJ_UPDATED], 0,
-			       uids->_buffer[n], query_in_progress,
-			       (int) n_scanned, (int) total);
+	switch (property_id) {
+	case PROP_QUERY:
+		g_value_set_pointer (value, priv->query);
+		break;
+	case PROP_LISTENER:
+		g_value_set_pointer (value, priv->listener);
+		break;
+	case PROP_CLIENT:
+		g_value_set_object (value, priv->client);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+		break;
 	}
 }
 
-/* Callback used when an object is removed from the query */
-static void
-obj_removed_cb (QueryListener *ql,
-		const CORBA_char *uid,
-		gpointer data)
-{
-	CalQuery *query;
-
-	query = CAL_QUERY (data);
-
-	g_signal_emit (G_OBJECT (query), query_signals[OBJ_REMOVED],
-		       0, uid);
-}
 
-/* Callback used when the query terminates */
+/* Finalize handler for the calendar query */
 static void
-query_done_cb (QueryListener *ql,
-	       GNOME_Evolution_Calendar_QueryListener_QueryDoneStatus corba_status,
-	       const CORBA_char *error_str,
-	       gpointer data)
+cal_query_finalize (GObject *object)
 {
 	CalQuery *query;
-	CalQueryDoneStatus status;
+	CalQueryPrivate *priv;
 
-	query = CAL_QUERY (data);
+	g_return_if_fail (object != NULL);
+	g_return_if_fail (IS_CAL_QUERY (object));
 
-	switch (corba_status) {
-	case GNOME_Evolution_Calendar_QueryListener_SUCCESS:
-		status = CAL_QUERY_DONE_SUCCESS;
-		break;
+	query = CAL_QUERY (object);
+	priv = query->priv;
 
-	case GNOME_Evolution_Calendar_QueryListener_PARSE_ERROR:
-		status = CAL_QUERY_DONE_PARSE_ERROR;
-		break;
+	/* The server keeps a copy of the query listener, so we must unref it */
+	g_signal_handlers_disconnect_matched (priv->listener, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, query);
+	bonobo_object_unref (BONOBO_OBJECT (priv->listener));
 
-	default:
-		g_assert_not_reached ();
-		return;
-	}
+	if (priv->query != CORBA_OBJECT_NIL)
+		bonobo_object_release_unref (priv->query, NULL);
 
-	g_signal_emit (G_OBJECT (query), query_signals[QUERY_DONE], 0,
-		       status, error_str);
+	g_free (priv);
+
+	if (G_OBJECT_CLASS (parent_class)->finalize)
+		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
 }
 
-/* Callback used when an error occurs when evaluating the query */
+/* Class initialization function for the calendar query */
 static void
-eval_error_cb (QueryListener *ql,
-	       const CORBA_char *error_str,
-	       gpointer data)
+cal_query_class_init (CalQueryClass *klass)
 {
-	CalQuery *query;
+	GObjectClass *object_class;
+	GParamSpec *param;
+	
+	object_class = (GObjectClass *) klass;
 
-	query = CAL_QUERY (data);
+	parent_class = g_type_class_peek_parent (klass);
+
+	object_class->set_property = cal_query_set_property;
+	object_class->get_property = cal_query_get_property;
+	object_class->finalize = cal_query_finalize;
 
-	g_signal_emit (G_OBJECT (query), query_signals[EVAL_ERROR], 0,
-		       error_str);
+	param =  g_param_spec_pointer ("query", NULL, NULL,
+				      G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
+	g_object_class_install_property (object_class, PROP_QUERY, param);
+	param =  g_param_spec_pointer ("listener", NULL, NULL,
+				      G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
+	g_object_class_install_property (object_class, PROP_LISTENER, param);
+	param =  g_param_spec_object ("client", NULL, NULL, CAL_CLIENT_TYPE,
+				      G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
+	g_object_class_install_property (object_class, PROP_CLIENT, param);
+	
+	signals[OBJECTS_ADDED] =
+		g_signal_new ("objects_added",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (CalQueryClass, objects_added),
+			      NULL, NULL,
+			      cal_marshal_VOID__POINTER,
+			      G_TYPE_NONE, 1, G_TYPE_POINTER);
+	signals[OBJECTS_MODIFIED] =
+		g_signal_new ("objects_modified",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (CalQueryClass, objects_modified),
+			      NULL, NULL,
+			      cal_marshal_VOID__POINTER,
+			      G_TYPE_NONE, 1, G_TYPE_POINTER);
+	signals[OBJECTS_REMOVED] =
+		g_signal_new ("objects_removed",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (CalQueryClass, objects_removed),
+			      NULL, NULL,
+			      cal_marshal_VOID__POINTER,
+			      G_TYPE_NONE, 1, G_TYPE_POINTER);
+	signals[QUERY_PROGRESS] =
+		g_signal_new ("query_progress",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (CalQueryClass, query_progress),
+			      NULL, NULL,
+			      cal_marshal_VOID__POINTER,
+			      G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_INT);
+	signals[QUERY_DONE] =
+		g_signal_new ("query_done",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (CalQueryClass, query_done),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);
 }
 
 /**
- * cal_query_construct:
- * @query: A calendar query.
- * @cal: Handle to an open calendar.
- * @sexp: S-expression that defines the query.
+ * cal_query_get_type:
  * 
- * Constructs a query object by issuing the query creation request to the
- * calendar server.
+ * Registers the #CalQuery class if necessary, and returns the type ID assigned
+ * to it.
  * 
- * Return value: The same value as @query on success, or NULL if the request
- * failed.
+ * Return value: The type ID of the #CalQuery class.
  **/
-CalQuery *
-cal_query_construct (CalQuery *query,
-		     GNOME_Evolution_Calendar_Cal cal,
-		     const char *sexp)
+GType
+cal_query_get_type (void)
 {
-	CalQueryPrivate *priv;
-	GNOME_Evolution_Calendar_QueryListener corba_ql;
-	CORBA_Environment ev;
-
-	g_return_val_if_fail (query != NULL, NULL);
-	g_return_val_if_fail (IS_CAL_QUERY (query), NULL);
-	g_return_val_if_fail (sexp != NULL, NULL);
-
-	priv = query->priv;
-
-	priv->ql = query_listener_new (obj_updated_cb,
-				       obj_removed_cb,
-				       query_done_cb,
-				       eval_error_cb,
-				       query);
-	if (!priv->ql) {
-		g_message ("cal_query_construct(): Could not create the query listener");
-		return NULL;
-	}
+	static GType cal_query_type = 0;
 
-	corba_ql = BONOBO_OBJREF (priv->ql);
-				 
-	CORBA_exception_init (&ev);
-	priv->corba_query = GNOME_Evolution_Calendar_Cal_getQuery (cal, sexp, corba_ql, &ev);
-
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_Cal_CouldNotCreate)) {		
-		g_message ("cal_query_construct(): The server could not create the query");
-		goto error;
-	} else if (BONOBO_EX (&ev)) {
-		g_message ("cal_query_construct(): Could not issue the getQuery() request");
-		goto error;
+	if (!cal_query_type) {
+		static GTypeInfo info = {
+                        sizeof (CalQueryClass),
+                        (GBaseInitFunc) NULL,
+                        (GBaseFinalizeFunc) NULL,
+                        (GClassInitFunc) cal_query_class_init,
+                        NULL, NULL,
+                        sizeof (CalQuery),
+                        0,
+                        (GInstanceInitFunc) cal_query_init
+                };
+		cal_query_type = g_type_register_static (G_TYPE_OBJECT, "CalQuery", &info, 0);
 	}
 
-	CORBA_exception_free (&ev);
-
-	return query;
-
- error:
-
-	CORBA_exception_free (&ev);
-
-	bonobo_object_unref (BONOBO_OBJECT (priv->ql));
-	priv->ql = NULL;
-	priv->corba_query = CORBA_OBJECT_NIL;
-	return NULL;
+	return cal_query_type;
 }
 
 /**
@@ -379,20 +327,12 @@ cal_query_construct (CalQuery *query,
  * Return value: A newly-created query object, or NULL if the request failed.
  **/
 CalQuery *
-cal_query_new (CalClient *client,
-	       GNOME_Evolution_Calendar_Cal cal,
-	       const char *sexp)
+cal_query_new (GNOME_Evolution_Calendar_Query corba_query, QueryListener *listener, CalClient *client)
 {
 	CalQuery *query;
 
-	query = g_object_new (CAL_QUERY_TYPE, NULL);
-
-	if (!cal_query_construct (query, cal, sexp)) {
-		g_object_unref (G_OBJECT (query));
-		return NULL;
-	}
-
-	query->priv->client = client;
+	query = g_object_new (CAL_QUERY_TYPE, "query", corba_query, "listener", 
+			      listener, "client", client, NULL);
 
 	return query;
 }
@@ -412,3 +352,23 @@ cal_query_get_client (CalQuery *query)
 
 	return query->priv->client;
 }
+
+void
+cal_query_start (CalQuery *query)
+{
+	CalQueryPrivate *priv;
+	CORBA_Environment ev;
+
+	g_return_if_fail (query != NULL);
+	g_return_if_fail (IS_CAL_QUERY (query));
+	
+	priv = query->priv;
+	
+	CORBA_exception_init (&ev);
+
+	GNOME_Evolution_Calendar_Query_start (priv->query, &ev);
+	if (BONOBO_EX (&ev)) 
+		g_warning (G_STRLOC ": Unable to start query");
+
+	CORBA_exception_free (&ev);
+}
diff --git a/calendar/cal-client/cal-query.h b/calendar/cal-client/cal-query.h
index 77429035fa..05390dd12a 100644
--- a/calendar/cal-client/cal-query.h
+++ b/calendar/cal-client/cal-query.h
@@ -22,7 +22,8 @@
 #define CAL_QUERY_H
 
 #include <glib-object.h>
-
+#include "cal-client-types.h"
+#include "query-listener.h"
 #include "evolution-calendar.h"
 
 G_BEGIN_DECLS
@@ -37,14 +38,6 @@ typedef struct _CalClient CalClient;
 #define IS_CAL_QUERY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CAL_QUERY_TYPE))
 #define IS_CAL_QUERY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CAL_QUERY_TYPE))
 
-#define CAL_QUERY_DONE_STATUS_ENUM_TYPE (cal_query_done_status_enum_get_type ())
-
-/* Status values when a query terminates */
-typedef enum {
-	CAL_QUERY_DONE_SUCCESS,
-	CAL_QUERY_DONE_PARSE_ERROR
-} CalQueryDoneStatus;
-
 typedef struct _CalQueryPrivate CalQueryPrivate;
 
 typedef struct {
@@ -58,30 +51,18 @@ typedef struct {
 	GObjectClass parent_class;
 
 	/* Notification signals */
-
-	void (* obj_updated) (CalQuery *query, const char *uid,
-			      gboolean query_in_progress, int n_scanned, int total);
-	void (* obj_removed) (CalQuery *query, const char *uid);
-
-	void (* query_done) (CalQuery *query, CalQueryDoneStatus status, const char *error_str);
-
-	void (* eval_error) (CalQuery *query, const char *error_str);
+	void (* objects_added) (CalQuery *query, GList *objects);
+	void (* objects_modified) (CalQuery *query, GList *objects);
+	void (* objects_removed) (CalQuery *query, GList *uids);
+	void (* query_progress) (CalQuery *query, char *message, int percent);
+	void (* query_done) (CalQuery *query, ECalendarStatus status);
 } CalQueryClass;
 
 GType      cal_query_get_type (void);
 
-GType      cal_query_done_status_enum_get_type (void);
-
-CalQuery  *cal_query_construct (CalQuery *query,
-				GNOME_Evolution_Calendar_Cal cal,
-				const char *sexp);
-
-CalQuery  *cal_query_new (CalClient *client,
-			  GNOME_Evolution_Calendar_Cal cal,
-			  const char *sexp);
+CalQuery *cal_query_new (GNOME_Evolution_Calendar_Query corba_query, QueryListener *listener, CalClient *client);
 CalClient *cal_query_get_client (CalQuery *query);
-
-
+void cal_query_start (CalQuery *query);
 
 G_END_DECLS
 
diff --git a/calendar/cal-client/client-test.c b/calendar/cal-client/client-test.c
index cb6eed17b2..48763be50a 100644
--- a/calendar/cal-client/client-test.c
+++ b/calendar/cal-client/client-test.c
@@ -45,24 +45,37 @@ cl_printf (CalClient *client, const char *format, ...)
 	va_end (args);
 }
 
-/* Dumps some interesting data from a component */
 static void
-dump_component (CalComponent *comp)
+objects_added_cb (GObject *object, GList *objects, gpointer data)
 {
-	const char *uid;
-	CalComponentText summary;
+	GList *l;
+	
+	for (l = objects; l; l = l->next)
+		cl_printf (data, "Object added %s\n", icalcomponent_get_uid (l->data));
+}
 
-	cal_component_get_uid (comp, &uid);
+static void
+objects_modified_cb (GObject *object, GList *objects, gpointer data)
+{
+	GList *l;
+	
+	for (l = objects; l; l = l->next)
+		cl_printf (data, "Object modified %s\n", icalcomponent_get_uid (l->data));
+}
 
-	printf ("UID %s\n", uid);
+static void
+objects_removed_cb (GObject *object, GList *objects, gpointer data)
+{
+	GList *l;
+	
+	for (l = objects; l; l = l->next)
+		cl_printf (data, "Object removed %s\n", icalcomponent_get_uid (l->data));
+}
 
-	cal_component_get_summary (comp, &summary);
-	if (summary.value)
-		printf ("\tSummary: `%s', altrep `%s'\n",
-			summary.value,
-			summary.altrep ? summary.altrep : "NONE");
-	else
-		printf ("\tNo summary\n");
+static void
+query_done_cb (GObject *object, ECalendarStatus status, gpointer data)
+{
+	cl_printf (data, "Query done\n");
 }
 
 /* Lists the UIDs of objects in a calendar, called as an idle handler */
@@ -70,47 +83,38 @@ static gboolean
 list_uids (gpointer data)
 {
 	CalClient *client;
-	GList *uids;
+	GList *objects = NULL;
 	GList *l;
-
+	
 	client = CAL_CLIENT (data);
 
-	uids = cal_client_get_uids (client, CALOBJ_TYPE_ANY);
-
-	cl_printf (client, "UIDs: ");
+	g_message ("Blah");
+	
+	if (!cal_client_get_object_list (client, "(contains? \"any\" \"Test4\")", &objects, NULL))
+		return FALSE;
+	
+	cl_printf (client, "UIDS: ");
 
-	if (!uids)
+	if (!objects)
 		printf ("none\n");
 	else {
-		for (l = uids; l; l = l->next) {
-			char *uid;
+		for (l = objects; l; l = l->next) {
+			const char *uid;
 
-			uid = l->data;
+			uid = icalcomponent_get_uid (l->data);
 			printf ("`%s' ", uid);
 		}
 
 		printf ("\n");
 
-		for (l = uids; l; l = l->next) {
-			char *uid;
-			CalComponent *comp;
-			CalClientGetStatus status;
-
-			uid = l->data;
-			status = cal_client_get_object (client, uid, &comp);
-
-			if (status == CAL_CLIENT_GET_SUCCESS) {
-				printf ("------------------------------\n");
-				dump_component (comp);
-				printf ("------------------------------\n");
-				g_object_unref (comp);
-			} else {
-				printf ("FAILED: %d\n", status);
-			}
+		for (l = objects; l; l = l->next) {
+			printf ("------------------------------\n");
+			printf ("%s", icalcomponent_as_ical_string (l->data));
+			printf ("------------------------------\n");
 		}
 	}
 
-	cal_obj_uid_list_free (uids);
+	cal_client_free_object_list (objects);
 
 	g_object_unref (client);
 
@@ -121,6 +125,8 @@ list_uids (gpointer data)
 static void
 cal_opened_cb (CalClient *client, CalClientOpenStatus status, gpointer data)
 {
+	CalQuery *query;
+	
 	cl_printf (client, "Load/create %s\n",
 		   ((status == CAL_CLIENT_OPEN_SUCCESS) ? "success" :
 		    (status == CAL_CLIENT_OPEN_ERROR) ? "error" :
@@ -129,40 +135,29 @@ cal_opened_cb (CalClient *client, CalClientOpenStatus status, gpointer data)
 		    "unknown status value"));
 
 	if (status == CAL_CLIENT_OPEN_SUCCESS) {
-		GList *comp_list;
-
-		/* get free/busy information */
-		comp_list = cal_client_get_free_busy (client, NULL, 0, time (NULL));
-		if (comp_list) {
-			GList *l;
-
-			for (l = comp_list; l; l = l->next) {
-				char *comp_str;
-
-				comp_str = cal_component_get_as_string (CAL_COMPONENT (l->data));
-				g_object_unref (l->data);
-				cl_printf (client, "Free/Busy -> %s\n", comp_str);
-				g_free (comp_str);
-			}
-			g_list_free (comp_list);
-		}
-
+		if (!cal_client_get_query (client, "(contains? \"any\" \"Test4\")", &query, NULL))
+			g_warning (G_STRLOC ": Unable to obtain query");
+
+		g_signal_connect (G_OBJECT (query), "objects_added", 
+				  G_CALLBACK (objects_added_cb), client);
+		g_signal_connect (G_OBJECT (query), "objects_modified", 
+				  G_CALLBACK (objects_modified_cb), client);
+		g_signal_connect (G_OBJECT (query), "objects_removed", 
+				  G_CALLBACK (objects_removed_cb), client);
+		g_signal_connect (G_OBJECT (query), "query_done",
+				  G_CALLBACK (query_done_cb), client);
+
+		cal_query_start (query);
+		
 		g_idle_add (list_uids, client);
 	}
 	else
 		g_object_unref (client);
 }
 
-/* Callback used when an object is updated */
-static void
-obj_updated_cb (CalClient *client, const char *uid, gpointer data)
-{
-	cl_printf (client, "Object updated: %s\n", uid);
-}
-
 /* Callback used when a client is destroyed */
 static void
-client_destroy_cb (GObject *object, gpointer data)
+client_destroy_cb (gpointer data, GObject *object)
 {
 	if (CAL_CLIENT (object) == client1)
 		client1 = NULL;
@@ -177,33 +172,24 @@ client_destroy_cb (GObject *object, gpointer data)
 
 /* Creates a calendar client and tries to load the specified URI into it */
 static void
-create_client (CalClient **client, const char *uri, gboolean only_if_exists)
+create_client (CalClient **client, const char *uri, CalObjType type, gboolean only_if_exists)
 {
-	gboolean result;
-
-	*client = cal_client_new ();
+	*client = cal_client_new (uri, type);
 	if (!*client) {
-		g_message ("create_client(): could not create the client");
+		g_message (G_STRLOC ": could not create the client");
 		exit (1);
 	}
 
-	g_signal_connect (*client, "destroy",
-			  G_CALLBACK (client_destroy_cb),
-			  NULL);
+	g_object_weak_ref (G_OBJECT (*client), client_destroy_cb, NULL);
 
 	g_signal_connect (*client, "cal_opened",
 			  G_CALLBACK (cal_opened_cb),
 			  NULL);
-	g_signal_connect (*client, "obj_updated",
-			  G_CALLBACK (obj_updated_cb),
-			  NULL);
 
 	printf ("Calendar loading `%s'...\n", uri);
 
-	result = cal_client_open_calendar (*client, uri, only_if_exists);
-
-	if (!result) {
-		g_message ("create_client(): failure when issuing calendar open request `%s'",
+	if (!cal_client_open (*client, only_if_exists, NULL)) {
+		g_message (G_STRLOC ": failure when issuing calendar open request `%s'",
 			   uri);
 		exit (1);
 	}
@@ -212,8 +198,6 @@ create_client (CalClient **client, const char *uri, gboolean only_if_exists)
 int
 main (int argc, char **argv)
 {
-	char *dir;
-
 	bindtextdomain (GETTEXT_PACKAGE, EVOLUTION_LOCALEDIR);
 	textdomain (GETTEXT_PACKAGE);
 
@@ -225,10 +209,9 @@ main (int argc, char **argv)
 		exit (1);
 	}
 
-	dir = g_strdup_printf ("%s/evolution/local/Calendar/calendar.ics", g_get_home_dir ());
-	create_client (&client1, dir, FALSE);
-	g_free (dir);
-	create_client (&client2, "/cvs/evolution/calendar/cal-client/test.ics", TRUE);
+	create_client (&client1, "file:///home/gnome24-evolution-new-calendar/evolution/local/Calendar", 
+		       CALOBJ_TYPE_EVENT, FALSE);
+//	create_client (&client2, "file:///tmp/tasks", TRUE);
 
 	bonobo_main ();
 	return 0;
diff --git a/calendar/cal-client/query-listener.c b/calendar/cal-client/query-listener.c
index 6bd7bfc6f7..4c8cbb4fe5 100644
--- a/calendar/cal-client/query-listener.c
+++ b/calendar/cal-client/query-listener.c
@@ -22,6 +22,7 @@
 #include <config.h>
 #endif
 
+#include "cal-marshal.h"
 #include "query-listener.h"
 
 
@@ -29,166 +30,164 @@
 /* Private part of the QueryListener structure */
 
 struct _QueryListenerPrivate {
-	/* Callbacks for notification and their closure data */
-	QueryListenerObjUpdatedFn obj_updated_fn;
-	QueryListenerObjRemovedFn obj_removed_fn;
-	QueryListenerQueryDoneFn query_done_fn;
-	QueryListenerEvalErrorFn eval_error_fn;
-	gpointer fn_data;
-
-	/* Whether notification is desired */
-	gboolean notify : 1;
+	int dummy;
 };
 
-
-
-static void query_listener_class_init (QueryListenerClass *class);
-static void query_listener_init (QueryListener *ql, QueryListenerClass *class);
-static void query_listener_finalize (GObject *object);
-
-static void impl_notifyObjUpdated (PortableServer_Servant servant,
-				   const GNOME_Evolution_Calendar_CalObjUIDSeq *uids,
-				   CORBA_boolean query_in_progress,
-				   CORBA_long n_scanned,
-				   CORBA_long total,
-				   CORBA_Environment *ev);
-
-static void impl_notifyObjRemoved (PortableServer_Servant servant,
-				   const CORBA_char *uid,
-				   CORBA_Environment *ev);
-
-static void impl_notifyQueryDone (PortableServer_Servant servant,
-				  GNOME_Evolution_Calendar_QueryListener_QueryDoneStatus corba_status,
-				  const CORBA_char *error_str,
-				  CORBA_Environment *ev);
+/* Signal IDs */
+enum {
+	OBJECTS_ADDED,
+	OBJECTS_MODIFIED,
+	OBJECTS_REMOVED,
+	QUERY_PROGRESS,
+	QUERY_DONE,
+	LAST_SIGNAL
+};
 
-static void impl_notifyEvalError (PortableServer_Servant servant,
-				  const CORBA_char *error_str,
-				  CORBA_Environment *ev);
+static guint signals[LAST_SIGNAL] = { 0 };
 
 static BonoboObjectClass *parent_class;
 
-
-
-BONOBO_TYPE_FUNC_FULL (QueryListener,
-		       GNOME_Evolution_Calendar_QueryListener,
-		       BONOBO_TYPE_OBJECT,
-		       query_listener);
-
-/* Class initialization function for the live search query listener */
-static void
-query_listener_class_init (QueryListenerClass *class)
+/* CORBA method implementations */
+/* FIXME This is duplicated from cal-listener.c */
+static ECalendarStatus
+convert_status (const GNOME_Evolution_Calendar_CallStatus status)
 {
-	GObjectClass *object_class;
+	switch (status) {
+	case GNOME_Evolution_Calendar_Success:
+		return E_CALENDAR_STATUS_OK;
+	case GNOME_Evolution_Calendar_RepositoryOffline:
+		return E_CALENDAR_STATUS_REPOSITORY_OFFLINE;
+	case GNOME_Evolution_Calendar_PermissionDenied:
+		return E_CALENDAR_STATUS_PERMISSION_DENIED;
+	case GNOME_Evolution_Calendar_ObjectNotFound:
+		return E_CALENDAR_STATUS_OBJECT_NOT_FOUND;
+	case GNOME_Evolution_Calendar_CardIdAlreadyExists:
+		return E_CALENDAR_STATUS_CARD_ID_ALREADY_EXISTS;
+	case GNOME_Evolution_Calendar_AuthenticationFailed:
+		return E_CALENDAR_STATUS_AUTHENTICATION_FAILED;
+	case GNOME_Evolution_Calendar_AuthenticationRequired:
+		return E_CALENDAR_STATUS_AUTHENTICATION_REQUIRED;
+	case GNOME_Evolution_Calendar_OtherError:
+	default:
+		return E_CALENDAR_STATUS_OTHER_ERROR;
+	}
+}
 
-	object_class = (GObjectClass *) class;
+/* FIXME This is duplicated from cal-listener.c */
+static GList *
+build_object_list (const GNOME_Evolution_Calendar_stringlist *seq)
+{
+	GList *list;
+	int i;
+
+	list = NULL;
+	for (i = 0; i < seq->_length; i++) {
+		icalcomponent *comp;
+		
+		comp = icalcomponent_new_from_string (seq->_buffer[i]);
+		if (!comp)
+			continue;
+		
+		list = g_list_prepend (list, comp);
+	}
+
+	return list;
+}
 
-	parent_class = g_type_class_peek_parent (class);
+static GList *
+build_uid_list (const GNOME_Evolution_Calendar_CalObjUIDSeq *seq)
+{
+	GList *list;
+	int i;
 
-	object_class->finalize = query_listener_finalize;
+	list = NULL;
+	for (i = 0; i < seq->_length; i++)
+		list = g_list_prepend (list, g_strdup (seq->_buffer[i]));
 
-	class->epv.notifyObjUpdated = impl_notifyObjUpdated;
-	class->epv.notifyObjRemoved = impl_notifyObjRemoved;
-	class->epv.notifyQueryDone = impl_notifyQueryDone;
-	class->epv.notifyEvalError = impl_notifyEvalError;
+	return list;
 }
 
-/* Object initialization function for the live search query listener */
 static void
-query_listener_init (QueryListener *ql, QueryListenerClass *class)
+impl_notifyObjectsAdded (PortableServer_Servant servant,
+			 const GNOME_Evolution_Calendar_stringlist *objects,
+			 CORBA_Environment *ev)
 {
+	QueryListener *ql;
 	QueryListenerPrivate *priv;
+	GList *object_list, *l;
+	
+	ql = QUERY_LISTENER (bonobo_object_from_servant (servant));
+	priv = ql->priv;
 
-	priv = g_new0 (QueryListenerPrivate, 1);
-	ql->priv = priv;
-
-	priv->obj_updated_fn = NULL;
-	priv->obj_removed_fn = NULL;
-	priv->query_done_fn = NULL;
-	priv->eval_error_fn = NULL;
-	priv->fn_data = NULL;
+	object_list = build_object_list (objects);
+	
+	g_signal_emit (G_OBJECT (ql), signals[OBJECTS_ADDED], 0, object_list);
 
-	priv->notify = TRUE;
+	for (l = object_list; l; l = l->next)
+		icalcomponent_free (l->data);
+	g_list_free (object_list);
 }
 
-/* Finalize handler for the live search query listener */
 static void
-query_listener_finalize (GObject *object)
+impl_notifyObjectsModified (PortableServer_Servant servant,
+			    const GNOME_Evolution_Calendar_stringlist *objects,
+			    CORBA_Environment *ev)
 {
 	QueryListener *ql;
 	QueryListenerPrivate *priv;
-
-	g_return_if_fail (object != NULL);
-	g_return_if_fail (IS_QUERY_LISTENER (object));
-
-	ql = QUERY_LISTENER (object);
+	GList *object_list, *l;
+	
+	ql = QUERY_LISTENER (bonobo_object_from_servant (servant));
 	priv = ql->priv;
 
-	priv->obj_updated_fn = NULL;
-	priv->obj_removed_fn = NULL;
-	priv->query_done_fn = NULL;
-	priv->eval_error_fn = NULL;
-	priv->fn_data = NULL;
-
-	priv->notify = FALSE;
+	object_list = build_object_list (objects);
+	
+	g_signal_emit (G_OBJECT (ql), signals[OBJECTS_MODIFIED], 0, object_list);
 
-	g_free (priv);
-	ql->priv = NULL;
-
-	if (G_OBJECT_CLASS (parent_class)->finalize)
-		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
+	for (l = object_list; l; l = l->next)
+		icalcomponent_free (l->data);
+	g_list_free (object_list);
 }
 
-
-
-/* CORBA method implementations */
-
-/* ::notifyObjUpdated() method */
 static void
-impl_notifyObjUpdated (PortableServer_Servant servant,
-		       const GNOME_Evolution_Calendar_CalObjUIDSeq *uids,
-		       CORBA_boolean query_in_progress,
-		       CORBA_long n_scanned,
-		       CORBA_long total,
-		       CORBA_Environment *ev)
+impl_notifyObjectsRemoved (PortableServer_Servant servant,
+			   const GNOME_Evolution_Calendar_CalObjUIDSeq *uids,
+			   CORBA_Environment *ev)
 {
 	QueryListener *ql;
 	QueryListenerPrivate *priv;
-
+	GList *uid_list, *l;
+	
 	ql = QUERY_LISTENER (bonobo_object_from_servant (servant));
 	priv = ql->priv;
 
-	if (!priv->notify)
-		return;
+	uid_list = build_uid_list (uids);
+	
+	g_signal_emit (G_OBJECT (ql), signals[OBJECTS_REMOVED], 0, uid_list);
 
-	g_assert (priv->obj_updated_fn != NULL);
-	(* priv->obj_updated_fn) (ql, uids, query_in_progress, n_scanned, total, priv->fn_data);
+	for (l = uid_list; l; l = l->next)
+		g_free (l->data);
+	g_list_free (uid_list);
 }
 
-/* ::notifyObjRemoved() method */
 static void
-impl_notifyObjRemoved (PortableServer_Servant servant,
-		       const CORBA_char *uid,
-		       CORBA_Environment *ev)
+impl_notifyQueryProgress (PortableServer_Servant servant,
+			  const CORBA_char *message,
+			  const CORBA_short percent,
+			  CORBA_Environment *ev)
 {
 	QueryListener *ql;
 	QueryListenerPrivate *priv;
 
 	ql = QUERY_LISTENER (bonobo_object_from_servant (servant));
 	priv = ql->priv;
-
-	if (!priv->notify)
-		return;
-
-	g_assert (priv->obj_removed_fn != NULL);
-	(* priv->obj_removed_fn) (ql, uid, priv->fn_data);
+	
+	g_signal_emit (G_OBJECT (ql), signals[QUERY_PROGRESS], 0, message, percent);
 }
 
-/* ::notifyQueryDone() method */
 static void
 impl_notifyQueryDone (PortableServer_Servant servant,
-		      GNOME_Evolution_Calendar_QueryListener_QueryDoneStatus corba_status,
-		      const CORBA_char *error_str,
+		      const GNOME_Evolution_Calendar_CallStatus status,
 		      CORBA_Environment *ev)
 {
 	QueryListener *ql;
@@ -196,126 +195,110 @@ impl_notifyQueryDone (PortableServer_Servant servant,
 
 	ql = QUERY_LISTENER (bonobo_object_from_servant (servant));
 	priv = ql->priv;
+	
+	g_signal_emit (G_OBJECT (ql), signals[QUERY_DONE], 0, convert_status (status));
+}
 
-	if (!priv->notify)
-		return;
+/* Object initialization function for the live search query listener */
+static void
+query_listener_init (QueryListener *ql, QueryListenerClass *class)
+{
+	QueryListenerPrivate *priv;
 
-	g_assert (priv->query_done_fn != NULL);
-	(* priv->query_done_fn) (ql, corba_status, error_str, priv->fn_data);
+	priv = g_new0 (QueryListenerPrivate, 1);
+	ql->priv = priv;
 }
 
-/* ::notifyEvalError() method */
+/* Finalize handler for the live search query listener */
 static void
-impl_notifyEvalError (PortableServer_Servant servant,
-		      const CORBA_char *error_str,
-		      CORBA_Environment *ev)
+query_listener_finalize (GObject *object)
 {
 	QueryListener *ql;
 	QueryListenerPrivate *priv;
 
-	ql = QUERY_LISTENER (bonobo_object_from_servant (servant));
+	g_return_if_fail (object != NULL);
+	g_return_if_fail (IS_QUERY_LISTENER (object));
+
+	ql = QUERY_LISTENER (object);
 	priv = ql->priv;
 
-	if (!priv->notify)
-		return;
+	g_free (priv);
 
-	g_assert (priv->eval_error_fn != NULL);
-	(* priv->eval_error_fn) (ql, error_str, priv->fn_data);
+	if (G_OBJECT_CLASS (parent_class)->finalize)
+		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
 }
 
-
-
-/**
- * query_listener_construct:
- * @ql: A query listener.
- * @obj_updated_fn: Callback to use when a component is updated in the query.
- * @obj_removed_fn: Callback to use when a component is removed from the query.
- * @query_done_fn: Callback to use when a query is done.
- * @eval_error_fn: Callback to use when an evaluation error happens during a query.
- * @fn_data: Closure data to pass to the callbacks.
- * 
- * Constructs a query listener by setting the callbacks it will use for
- * notification from the calendar server.
- * 
- * Return value: The same value as @ql.
- **/
-QueryListener *
-query_listener_construct (QueryListener *ql,
-			  QueryListenerObjUpdatedFn obj_updated_fn,
-			  QueryListenerObjRemovedFn obj_removed_fn,
-			  QueryListenerQueryDoneFn query_done_fn,
-			  QueryListenerEvalErrorFn eval_error_fn,
-			  gpointer fn_data)
+/* Class initialization function for the live search query listener */
+static void
+query_listener_class_init (QueryListenerClass *klass)
 {
-	QueryListenerPrivate *priv;
+	GObjectClass *object_class;
 
-	g_return_val_if_fail (ql != NULL, NULL);
-	g_return_val_if_fail (IS_QUERY_LISTENER (ql), NULL);
-	g_return_val_if_fail (obj_updated_fn != NULL, NULL);
-	g_return_val_if_fail (obj_removed_fn != NULL, NULL);
-	g_return_val_if_fail (query_done_fn != NULL, NULL);
-	g_return_val_if_fail (eval_error_fn != NULL, NULL);
+	object_class = (GObjectClass *) klass;
 
-	priv = ql->priv;
+	parent_class = g_type_class_peek_parent (klass);
 
-	priv->obj_updated_fn = obj_updated_fn;
-	priv->obj_removed_fn = obj_removed_fn;
-	priv->query_done_fn = query_done_fn;
-	priv->eval_error_fn = eval_error_fn;
-	priv->fn_data = fn_data;
+	object_class->finalize = query_listener_finalize;
 
-	return ql;
+	klass->epv.notifyObjectsAdded = impl_notifyObjectsAdded;
+	klass->epv.notifyObjectsModified = impl_notifyObjectsModified;
+	klass->epv.notifyObjectsRemoved = impl_notifyObjectsRemoved;
+	klass->epv.notifyQueryProgress = impl_notifyQueryProgress;
+	klass->epv.notifyQueryDone = impl_notifyQueryDone;
+
+	signals[OBJECTS_ADDED] =
+		g_signal_new ("objects_added",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (QueryListenerClass, objects_added),
+			      NULL, NULL,
+			      cal_marshal_VOID__POINTER,
+			      G_TYPE_NONE, 1, G_TYPE_POINTER);
+	signals[OBJECTS_MODIFIED] =
+		g_signal_new ("objects_modified",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (QueryListenerClass, objects_modified),
+			      NULL, NULL,
+			      cal_marshal_VOID__POINTER,
+			      G_TYPE_NONE, 1, G_TYPE_POINTER);
+	signals[OBJECTS_REMOVED] =
+		g_signal_new ("objects_removed",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (QueryListenerClass, objects_removed),
+			      NULL, NULL,
+			      cal_marshal_VOID__POINTER,
+			      G_TYPE_NONE, 1, G_TYPE_POINTER);
+	signals[QUERY_PROGRESS] =
+		g_signal_new ("query_progress",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (QueryListenerClass, query_progress),
+			      NULL, NULL,
+			      cal_marshal_VOID__POINTER,
+			      G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_INT);
+	signals[QUERY_DONE] =
+		g_signal_new ("query_done",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_FIRST,
+			      G_STRUCT_OFFSET (QueryListenerClass, query_done),
+			      NULL, NULL,
+			      cal_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);
 }
 
-/**
- * query_listener_new:
- * @obj_updated_fn: Callback to use when a component is updated in the query.
- * @obj_removed_fn: Callback to use when a component is removed from the query.
- * @query_done_fn: Callback to use when a query is done.
- * @eval_error_fn: Callback to use when an evaluation error happens during a query.
- * @fn_data: Closure data to pass to the callbacks.
- * 
- * Creates a new query listener object.
- * 
- * Return value: A newly-created query listener object.
- **/
+BONOBO_TYPE_FUNC_FULL (QueryListener,
+		       GNOME_Evolution_Calendar_QueryListener,
+		       BONOBO_TYPE_OBJECT,
+		       query_listener);
+
 QueryListener *
-query_listener_new (QueryListenerObjUpdatedFn obj_updated_fn,
-		    QueryListenerObjRemovedFn obj_removed_fn,
-		    QueryListenerQueryDoneFn query_done_fn,
-		    QueryListenerEvalErrorFn eval_error_fn,
-		    gpointer fn_data)
+query_listener_new (void)
 {
 	QueryListener *ql;
 
 	ql = g_object_new (QUERY_LISTENER_TYPE, NULL);
 
-	return query_listener_construct (ql,
-					 obj_updated_fn,
-					 obj_removed_fn,
-					 query_done_fn,
-					 eval_error_fn,
-					 fn_data);
-}
-
-/**
- * query_listener_stop_notification:
- * @ql: A query listener.
- * 
- * Informs a query listener that no further notification is desired.  The
- * callbacks specified when the listener was created will no longer be invoked
- * after this function is called.
- **/
-void
-query_listener_stop_notification (QueryListener *ql)
-{
-	QueryListenerPrivate *priv;
-
-	g_return_if_fail (ql != NULL);
-	g_return_if_fail (IS_QUERY_LISTENER (ql));
-
-	priv = ql->priv;
-	g_return_if_fail (priv->notify != FALSE);
-
-	priv->notify = FALSE;
+	return ql;
 }
diff --git a/calendar/cal-client/query-listener.h b/calendar/cal-client/query-listener.h
index eeb42afc7e..6a204bbf77 100644
--- a/calendar/cal-client/query-listener.h
+++ b/calendar/cal-client/query-listener.h
@@ -22,6 +22,7 @@
 #define QUERY_LISTENER_H
 
 #include <bonobo/bonobo-object.h>
+#include "cal-client-types.h"
 #include "evolution-calendar.h"
 
 G_BEGIN_DECLS
@@ -48,47 +49,18 @@ typedef struct {
 	BonoboObjectClass parent_class;
 
 	POA_GNOME_Evolution_Calendar_QueryListener__epv epv;
+
+	void (*objects_added) (QueryListener *listener, GList *objects);
+	void (*objects_modified) (QueryListener *listener, GList *objects);
+	void (*objects_removed) (QueryListener *listener, GList *uids);
+	void (*query_progress) (QueryListener *listener, const char *message, int percent);
+	void (*query_done) (QueryListener *listener, ECalendarStatus status);
 } QueryListenerClass;
 
 /* Notification functions */
 
-typedef void (* QueryListenerObjUpdatedFn) (QueryListener *ql,
-					    const GNOME_Evolution_Calendar_CalObjUIDSeq *uids,
-					    CORBA_boolean query_in_progress,
-					    CORBA_long n_scanned,
-					    CORBA_long total,
-					    gpointer data);
-
-typedef void (* QueryListenerObjRemovedFn) (QueryListener *ql,
-					    const CORBA_char *uid,
-					    gpointer data);
-
-typedef void (* QueryListenerQueryDoneFn) (
-	QueryListener *ql,
-	GNOME_Evolution_Calendar_QueryListener_QueryDoneStatus status,
-	const CORBA_char *error_str,
-	gpointer data);
-
-typedef void (* QueryListenerEvalErrorFn) (QueryListener *ql,
-					   const CORBA_char *error_str,
-					   gpointer data);
-
 GType query_listener_get_type (void);
-
-QueryListener *query_listener_construct (QueryListener *ql,
-					 QueryListenerObjUpdatedFn obj_updated_fn,
-					 QueryListenerObjRemovedFn obj_removed_fn,
-					 QueryListenerQueryDoneFn query_done_fn,
-					 QueryListenerEvalErrorFn eval_error_fn,
-					 gpointer fn_data);
-
-QueryListener *query_listener_new (QueryListenerObjUpdatedFn obj_updated_fn,
-				   QueryListenerObjRemovedFn obj_removed_fn,
-				   QueryListenerQueryDoneFn query_done_fn,
-				   QueryListenerEvalErrorFn eval_error_fn,
-				   gpointer fn_data);
-
-void query_listener_stop_notification (QueryListener *ql);
+QueryListener *query_listener_new (void);
 
 
 
diff --git a/calendar/cal-util/cal-util.c b/calendar/cal-util/cal-util.c
index 1e03c86d75..f1c32610c1 100644
--- a/calendar/cal-util/cal-util.c
+++ b/calendar/cal-util/cal-util.c
@@ -584,29 +584,7 @@ cal_util_priority_from_string (const char *string)
 char *
 cal_util_expand_uri (char *uri, gboolean tasks)
 {
-	char *file_uri, *file_name;
-
-	if (!strncmp (uri, "file://", 7)) {
-		file_uri = uri + 7;
-		if (strlen (file_uri) > 4
-		    && !strcmp (file_uri + strlen (file_uri) - 4, ".ics")) {
-			
-			/* it's a .ics file */
-			return g_strdup (uri);
-		}
-
-		/* we assume it's a dir and glom <type>.ics onto the end. */
-		if (tasks)
-			file_name = g_concat_dir_and_file (file_uri, "tasks.ics");
-		else
-			file_name = g_concat_dir_and_file (file_uri, "calendar.ics");
-		file_uri = g_strdup_printf("file://%s", file_name);
-		g_free(file_name);
-	} else {
-		file_uri = g_strdup (uri);
-	}
-
-	return file_uri;
+	return g_strdup (uri);
 }
 
 /* callback for icalcomponent_foreach_tzid */
diff --git a/calendar/conduits/calendar/calendar-conduit.c b/calendar/conduits/calendar/calendar-conduit.c
index 1893e6b34c..05ddde2c7f 100644
--- a/calendar/conduits/calendar/calendar-conduit.c
+++ b/calendar/conduits/calendar/calendar-conduit.c
@@ -253,7 +253,7 @@ struct _ECalConduitContext {
 
 	icaltimezone *timezone;
 	CalComponent *default_comp;
-	GList *uids;
+	GList *comps;
 	GList *changed;
 	GHashTable *changed_hash;
 	GList *locals;
@@ -276,7 +276,7 @@ e_calendar_context_new (guint32 pilot_id)
 	ctxt->client = NULL;
 	ctxt->timezone = NULL;
 	ctxt->default_comp = NULL;
-	ctxt->uids = NULL;
+	ctxt->comps = NULL;
 	ctxt->changed = NULL;
 	ctxt->changed_hash = NULL;
 	ctxt->locals = NULL;
@@ -311,8 +311,11 @@ e_calendar_context_destroy (ECalConduitContext *ctxt)
 		g_object_unref (ctxt->client);
  	if (ctxt->default_comp != NULL)
  		g_object_unref (ctxt->default_comp);	
-	if (ctxt->uids != NULL)
-		cal_obj_uid_list_free (ctxt->uids);
+	if (ctxt->comps != NULL) {
+		for (l = ctxt->comps; l; l = l->next)
+			g_object_unref (l->data);
+		g_list_free (ctxt->comps);
+	}
 	
 	if (ctxt->changed != NULL)
 		cal_client_change_list_free (ctxt->changed);
@@ -404,16 +407,24 @@ start_calendar_server_cb (CalClient *cal_client,
 static int
 start_calendar_server (ECalConduitContext *ctxt)
 {
+	char *uri;
 	gboolean success = FALSE;
 	
 	g_return_val_if_fail (ctxt != NULL, -2);
 
-	ctxt->client = cal_client_new ();
-
+	/* FIXME Need a mechanism for the user to select uri's */
+	/* FIXME Can we use the cal model? */
+	uri = g_strdup_printf ("file://%s/local/Calendar/", g_get_home_dir ());
+	ctxt->client = cal_client_new (uri, CALOBJ_TYPE_EVENT);
+	g_free (uri);
+	
+	if (!ctxt->client)
+		return -1;
+	
 	g_signal_connect (ctxt->client, "cal_opened",
 			  G_CALLBACK (start_calendar_server_cb), &success);
 
-	if (!cal_client_open_default_calendar (ctxt->client, FALSE))
+	if (!cal_client_open (ctxt->client, FALSE, NULL))
 		return -1;
 
 	/* run a sub event loop to turn cal-client's async load
@@ -433,8 +444,8 @@ get_timezone (CalClient *client, const char *tzid)
 	icaltimezone *timezone = NULL;
 
 	timezone = icaltimezone_get_builtin_timezone_from_tzid (tzid);
-	if (timezone == NULL)
-		 cal_client_get_timezone (client, tzid, &timezone);
+	if (timezone == NULL)		 
+		 cal_client_get_timezone (client, tzid, &timezone, NULL);
 	
 	return timezone;
 }
@@ -550,7 +561,7 @@ is_all_day (CalClient *client, CalComponentDateTime *dt_start, CalComponentDateT
 }
 
 static gboolean
-process_multi_day (ECalConduitContext *ctxt, CalClientChange *ccc, GList **multi_uid, GList **multi_ccc)
+process_multi_day (ECalConduitContext *ctxt, CalClientChange *ccc, GList **multi_comp, GList **multi_ccc)
 {
 	CalComponentDateTime dt_start, dt_end;
 	icaltimezone *tz_start, *tz_end;
@@ -562,7 +573,7 @@ process_multi_day (ECalConduitContext *ctxt, CalClientChange *ccc, GList **multi
 	gboolean ret = TRUE;
 
 	*multi_ccc = NULL;
-	*multi_uid = NULL;
+	*multi_comp = NULL;
 	
 	if (ccc->type == CAL_CLIENT_CHANGE_DELETED)
 		return FALSE;
@@ -617,13 +628,14 @@ process_multi_day (ECalConduitContext *ctxt, CalClientChange *ccc, GList **multi
 		dt_end.value = &end_value;
 		cal_component_set_dtend (clone, &dt_end);
 
-		cal_client_update_object (ctxt->client, clone);
+		/* FIXME Error handling */
+		cal_client_create_object (ctxt->client, cal_component_get_icalcomponent (clone), NULL, NULL);
 
 		c->comp = clone;
 		c->type = CAL_CLIENT_CHANGE_ADDED;
 		
 		*multi_ccc = g_list_prepend (*multi_ccc, c);
-		*multi_uid = g_list_prepend (*multi_uid, new_uid);
+		*multi_comp = g_list_prepend (*multi_comp, g_object_ref (c->comp));
 
 		event_start = day_end;
 		day_end = time_day_end_with_zone (event_start, ctxt->timezone);
@@ -632,7 +644,8 @@ process_multi_day (ECalConduitContext *ctxt, CalClientChange *ccc, GList **multi
 	dt_end.value = old_end_value;
 	
 	cal_component_get_uid (ccc->comp, &uid);
-	cal_client_remove_object (ctxt->client, uid);
+	/* FIXME Error handling */
+	cal_client_remove_object (ctxt->client, uid, NULL);
 	ccc->type = CAL_CLIENT_CHANGE_DELETED;
 
  cleanup:
@@ -1007,13 +1020,11 @@ local_record_from_uid (ECalLocalRecord *local,
 {
 	CalComponent *comp;
 	icalcomponent *icalcomp;
-	CalClientGetStatus status;
+	GError *error = NULL;
 
 	g_assert(local!=NULL);
 
-	status = cal_client_get_object (ctxt->client, uid, &icalcomp);
-
-	if (status == CAL_CLIENT_GET_SUCCESS) {
+	if (cal_client_get_object (ctxt->client, uid, NULL, &icalcomp, &error)) {
 		comp = cal_component_new ();
 		if (!cal_component_set_icalcomponent (comp, icalcomp)) {
 			g_object_unref (comp);
@@ -1023,7 +1034,7 @@ local_record_from_uid (ECalLocalRecord *local,
 
 		local_record_from_comp (local, comp, ctxt);
 		g_object_unref (comp);
-	} else if (status == CAL_CLIENT_GET_NOT_FOUND) {
+	} else if (error->code == E_CALENDAR_STATUS_OBJECT_NOT_FOUND) {
 		comp = cal_component_new ();
 		cal_component_set_new_vtype (comp, CAL_COMPONENT_EVENT);
 		cal_component_set_uid (comp, uid);
@@ -1031,7 +1042,9 @@ local_record_from_uid (ECalLocalRecord *local,
 		g_object_unref (comp);
 	} else {
 		INFO ("Object did not exist");
-	}	
+	}
+
+	g_clear_error (&error);
 }
 
 static CalComponent *
@@ -1283,21 +1296,6 @@ comp_from_remote_record (GnomePilotConduitSyncAbs *conduit,
 }
 
 static void
-update_comp (GnomePilotConduitSyncAbs *conduit, CalComponent *comp,
-	     ECalConduitContext *ctxt) 
-{
-	CalClientResult success;
-
-	g_return_if_fail (conduit != NULL);
-	g_return_if_fail (comp != NULL);
-
-	success = cal_client_update_object (ctxt->client, comp);
-
-	if (success != CAL_CLIENT_RESULT_SUCCESS)
-		WARN (_("Error while communicating with calendar server"));
-}
-
-static void
 check_for_slow_setting (GnomePilotConduit *c, ECalConduitContext *ctxt)
 {
 	GnomePilotConduitStandard *conduit = GNOME_PILOT_CONDUIT_STANDARD (c);
@@ -1360,11 +1358,13 @@ pre_sync (GnomePilotConduit *conduit,
 	LOG (g_message ( "  Using timezone: %s", icaltimezone_get_tzid (ctxt->timezone) ));
 	
 	/* Set the default timezone on the backend. */
-	if (ctxt->timezone)
-		cal_client_set_default_timezone (ctxt->client, ctxt->timezone);
+	if (ctxt->timezone) {
+		if (!cal_client_set_default_timezone (ctxt->client, ctxt->timezone, NULL))
+			return -1;
+	}
 
 	/* Get the default component */
-	if (cal_client_get_default_object (ctxt->client, CALOBJ_TYPE_EVENT, &icalcomp) != CAL_CLIENT_GET_SUCCESS)
+	if (!cal_client_get_default_object (ctxt->client, &icalcomp, NULL))
 		return -1;
 
 	ctxt->default_comp = cal_component_new ();
@@ -1374,27 +1374,36 @@ pre_sync (GnomePilotConduit *conduit,
 		return -1;
 	}
 
+	ctxt->default_comp = cal_component_new ();
+	if (!cal_component_set_icalcomponent (ctxt->default_comp, icalcomp)) {
+		g_object_unref (ctxt->default_comp);
+		icalcomponent_free (icalcomp);
+		return -1;
+	}
+
 	/* Load the uid <--> pilot id mapping */
 	filename = map_name (ctxt);
 	e_pilot_map_read (filename, &ctxt->map);
 	g_free (filename);
 
 	/* Get the local database */
-	ctxt->uids = cal_client_get_uids (ctxt->client, CALOBJ_TYPE_EVENT);
+	if (!cal_client_get_object_list_as_comp (ctxt->client, "(#t)", &ctxt->comps, NULL))
+		return -1;
 
 	/* Find the added, modified and deleted items */
 	change_id = g_strdup_printf ("pilot-sync-evolution-calendar-%d", ctxt->cfg->pilot_id);
-	ctxt->changed = cal_client_get_changes (ctxt->client, CALOBJ_TYPE_EVENT, change_id);
+	if (!cal_client_get_changes (ctxt->client, CALOBJ_TYPE_EVENT, change_id, &ctxt->changed, NULL))
+		return -1;
 	ctxt->changed_hash = g_hash_table_new (g_str_hash, g_str_equal);
 	g_free (change_id);
 	
 	/* See if we need to split up any events */
 	for (l = ctxt->changed; l != NULL; l = l->next) {
 		CalClientChange *ccc = l->data;
-		GList *multi_uid = NULL, *multi_ccc = NULL;
+		GList *multi_comp = NULL, *multi_ccc = NULL;
 		
-		if (process_multi_day (ctxt, ccc, &multi_uid, &multi_ccc)) {
-			ctxt->uids = g_list_concat (ctxt->uids, multi_uid);
+		if (process_multi_day (ctxt, ccc, &multi_comp, &multi_ccc)) {
+			ctxt->comps = g_list_concat (ctxt->comps, multi_comp);
 			
 			added = g_list_concat (added, multi_ccc);
 			removed = g_list_prepend (removed, ccc);
@@ -1442,7 +1451,7 @@ pre_sync (GnomePilotConduit *conduit,
 	}
 	
 	/* Set the count information */
-	num_records = cal_client_get_n_objects (ctxt->client, CALOBJ_TYPE_EVENT);
+	num_records = g_list_length (ctxt->comps);
 	gnome_pilot_conduit_sync_abs_set_num_local_records(abs_conduit, num_records);
 	gnome_pilot_conduit_sync_abs_set_num_new_local_records (abs_conduit, add_records);
 	gnome_pilot_conduit_sync_abs_set_num_updated_local_records (abs_conduit, mod_records);
@@ -1492,8 +1501,8 @@ post_sync (GnomePilotConduit *conduit,
 	 * a race condition if anyone changes a record elsewhere during sycnc
          */
 	change_id = g_strdup_printf ("pilot-sync-evolution-calendar-%d", ctxt->cfg->pilot_id);
-	changed = cal_client_get_changes (ctxt->client, CALOBJ_TYPE_EVENT, change_id);
-	cal_client_change_list_free (changed);
+	if (cal_client_get_changes (ctxt->client, CALOBJ_TYPE_EVENT, change_id, &changed, NULL))
+		cal_client_change_list_free (changed);
 	g_free (change_id);
 	
 	LOG (g_message ( "---------------------------------------------------------\n" ));
@@ -1537,7 +1546,7 @@ for_each (GnomePilotConduitSyncAbs *conduit,
 	  ECalLocalRecord **local,
 	  ECalConduitContext *ctxt)
 {
-	static GList *uids, *iterator;
+	static GList *comps, *iterator;
 	static int count;
 
 	g_return_val_if_fail (local != NULL, -1);
@@ -1545,17 +1554,17 @@ for_each (GnomePilotConduitSyncAbs *conduit,
 	if (*local == NULL) {
 		LOG (g_message ( "beginning for_each" ));
 
-		uids = ctxt->uids;
+		comps = ctxt->comps;
 		count = 0;
 		
-		if (uids != NULL) {
-			LOG (g_message ( "iterating over %d records", g_list_length (uids) ));
+		if (comps != NULL) {
+			LOG (g_message ( "iterating over %d records", g_list_length (comps)));
 
 			*local = g_new0 (ECalLocalRecord, 1);
-			local_record_from_uid (*local, uids->data, ctxt);
+			local_record_from_comp (*local, comps->data, ctxt);
 			g_list_prepend (ctxt->locals, *local);
 
-			iterator = uids;
+			iterator = comps;
 		} else {
 			LOG (g_message ( "no events" ));
 			(*local) = NULL;
@@ -1681,8 +1690,10 @@ add_record (GnomePilotConduitSyncAbs *conduit,
 	/* Give it a new UID otherwise it will be the uid of the default comp */
 	uid = cal_component_gen_uid ();
 	cal_component_set_uid (comp, uid);
+	
+	if (!cal_client_create_object (ctxt->client, cal_component_get_icalcomponent (comp), NULL, NULL))
+		return -1;
 
-	update_comp (conduit, comp, ctxt);
 	e_pilot_map_insert (ctxt->map, remote->ID, uid, FALSE);
 
 	g_free (uid);	
@@ -1709,7 +1720,10 @@ replace_record (GnomePilotConduitSyncAbs *conduit,
 	new_comp = comp_from_remote_record (conduit, remote, local->comp, ctxt->client, ctxt->timezone);
 	g_object_unref (local->comp);
 	local->comp = new_comp;
-	update_comp (conduit, local->comp, ctxt);
+
+	if (!cal_client_modify_object (ctxt->client, cal_component_get_icalcomponent (new_comp), 
+				       CALOBJ_MOD_ALL, NULL))
+		return -1;
 
 	return retval;
 }
@@ -1729,7 +1743,8 @@ delete_record (GnomePilotConduitSyncAbs *conduit,
 	LOG (g_message ( "delete_record: deleting %s\n", uid ));
 
 	e_pilot_map_remove_by_uid (ctxt->map, uid);
-	cal_client_remove_object (ctxt->client, uid);
+	/* FIXME Error handling */
+	cal_client_remove_object (ctxt->client, uid, NULL);
 	
         return 0;
 }
diff --git a/calendar/conduits/todo/todo-conduit.c b/calendar/conduits/todo/todo-conduit.c
index 6868368129..35251f4eb6 100644
--- a/calendar/conduits/todo/todo-conduit.c
+++ b/calendar/conduits/todo/todo-conduit.c
@@ -255,7 +255,7 @@ struct _EToDoConduitContext {
 
 	icaltimezone *timezone;
 	CalComponent *default_comp;
-	GList *uids;
+	GList *comps;
 	GList *changed;
 	GHashTable *changed_hash;
 	GList *locals;
@@ -275,7 +275,7 @@ e_todo_context_new (guint32 pilot_id)
 	ctxt->client = NULL;
 	ctxt->timezone = NULL;
 	ctxt->default_comp = NULL;
-	ctxt->uids = NULL;
+	ctxt->comps = NULL;
 	ctxt->changed_hash = NULL;
 	ctxt->changed = NULL;
 	ctxt->locals = NULL;
@@ -311,8 +311,11 @@ e_todo_context_destroy (EToDoConduitContext *ctxt)
 
 	if (ctxt->default_comp != NULL)
 		g_object_unref (ctxt->default_comp);
-	if (ctxt->uids != NULL)
-		cal_obj_uid_list_free (ctxt->uids);
+	if (ctxt->comps != NULL) {
+		for (l = ctxt->comps; l; l = l->next)
+			g_object_unref (l->data);
+		g_list_free (ctxt->comps);
+	}
 
 	if (ctxt->changed_hash != NULL) {
 		g_hash_table_foreach_remove (ctxt->changed_hash, e_todo_context_foreach_change, NULL);
@@ -411,16 +414,24 @@ start_calendar_server_cb (CalClient *cal_client,
 static int
 start_calendar_server (EToDoConduitContext *ctxt)
 {
+	char *uri;
 	gboolean success = FALSE;
 	
 	g_return_val_if_fail (ctxt != NULL, -2);
 
-	ctxt->client = cal_client_new ();
+	/* FIXME Need a mechanism for the user to select uri's */
+	/* FIXME Can we use the cal model? */
+	uri = g_strdup_printf ("file://%s/local/Tasks/", g_get_home_dir ());
+	ctxt->client = cal_client_new (uri, CALOBJ_TYPE_TODO);
+	g_free (uri);
+	
+	if (!ctxt->client)
+		return -1;
 
 	g_signal_connect (ctxt->client, "cal_opened",
 			  G_CALLBACK (start_calendar_server_cb), &success);
 
-	if (!cal_client_open_default_tasks (ctxt->client,  FALSE))
+	if (!cal_client_open (ctxt->client,  FALSE, NULL))
 		return -1;
 
 	/* run a sub event loop to turn cal-client's async load
@@ -441,7 +452,7 @@ get_timezone (CalClient *client, const char *tzid)
 
 	timezone = icaltimezone_get_builtin_timezone_from_tzid (tzid);
 	if (timezone == NULL)
-		 cal_client_get_timezone (client, tzid, &timezone);
+		 cal_client_get_timezone (client, tzid, &timezone, NULL);
 	
 	return timezone;
 }
@@ -676,13 +687,11 @@ local_record_from_uid (EToDoLocalRecord *local,
 {
 	CalComponent *comp;
 	icalcomponent *icalcomp;
-	CalClientGetStatus status;
+	GError *error = NULL;
 
 	g_assert(local!=NULL);
 
-	status = cal_client_get_object (ctxt->client, uid, &icalcomp);
-
-	if (status == CAL_CLIENT_GET_SUCCESS) {
+	if (cal_client_get_object (ctxt->client, uid, NULL, &icalcomp, &error)) {
 		comp = cal_component_new ();
 		if (!cal_component_set_icalcomponent (comp, icalcomp)) {
 			g_object_unref (comp);
@@ -692,7 +701,7 @@ local_record_from_uid (EToDoLocalRecord *local,
 
 		local_record_from_comp (local, comp, ctxt);
 		g_object_unref (comp);
-	} else if (status == CAL_CLIENT_GET_NOT_FOUND) {
+	} else if (error->code == E_CALENDAR_STATUS_OBJECT_NOT_FOUND) {
 		comp = cal_component_new ();
 		cal_component_set_new_vtype (comp, CAL_COMPONENT_TODO);
 		cal_component_set_uid (comp, uid);
@@ -702,7 +711,7 @@ local_record_from_uid (EToDoLocalRecord *local,
 		INFO ("Object did not exist");
 	}
 
-
+	g_clear_error (&error);
 }
 
 
@@ -824,21 +833,6 @@ comp_from_remote_record (GnomePilotConduitSyncAbs *conduit,
 }
 
 static void
-update_comp (GnomePilotConduitSyncAbs *conduit, CalComponent *comp,
-	     EToDoConduitContext *ctxt) 
-{
-	CalClientResult success;
-
-	g_return_if_fail (conduit != NULL);
-	g_return_if_fail (comp != NULL);
-
-	success = cal_client_update_object (ctxt->client, comp);
-
-	if (success != CAL_CLIENT_RESULT_SUCCESS)
-		WARN (_("Error while communicating with calendar server"));
-}
-
-static void
 check_for_slow_setting (GnomePilotConduit *c, EToDoConduitContext *ctxt)
 {
 	GnomePilotConduitStandard *conduit = GNOME_PILOT_CONDUIT_STANDARD (c);
@@ -902,11 +896,13 @@ pre_sync (GnomePilotConduit *conduit,
 	LOG (g_message ( "  Using timezone: %s", icaltimezone_get_tzid (ctxt->timezone) ));
 
 	/* Set the default timezone on the backend. */
-	if (ctxt->timezone)
-		cal_client_set_default_timezone (ctxt->client, ctxt->timezone);
+	if (ctxt->timezone) {
+		if (!cal_client_set_default_timezone (ctxt->client, ctxt->timezone, NULL))
+			return -1;		
+	}
 
 	/* Get the default component */
-	if (cal_client_get_default_object (ctxt->client, CALOBJ_TYPE_TODO, &icalcomp) != CAL_CLIENT_GET_SUCCESS)
+	if (!cal_client_get_default_object (ctxt->client, &icalcomp, NULL))
 		return -1;
 
 	ctxt->default_comp = cal_component_new ();
@@ -916,17 +912,26 @@ pre_sync (GnomePilotConduit *conduit,
 		return -1;
 	}
 
+	ctxt->default_comp = cal_component_new ();
+	if (!cal_component_set_icalcomponent (ctxt->default_comp, icalcomp)) {
+		g_object_unref (ctxt->default_comp);
+		icalcomponent_free (icalcomp);
+		return -1;
+	}
+
 	/* Load the uid <--> pilot id map */
 	filename = map_name (ctxt);
 	e_pilot_map_read (filename, &ctxt->map);
 	g_free (filename);
 
 	/* Get the local database */
-	ctxt->uids = cal_client_get_uids (ctxt->client, CALOBJ_TYPE_TODO);
+	if (!cal_client_get_object_list_as_comp (ctxt->client, "(#t)", &ctxt->comps, NULL))
+		return -1;
 
 	/* Count and hash the changes */
 	change_id = g_strdup_printf ("pilot-sync-evolution-todo-%d", ctxt->cfg->pilot_id);
-	ctxt->changed = cal_client_get_changes (ctxt->client, CALOBJ_TYPE_TODO, change_id);
+	if (!cal_client_get_changes (ctxt->client, CALOBJ_TYPE_TODO, change_id, &ctxt->changed, NULL))
+		return -1;
 	ctxt->changed_hash = g_hash_table_new (g_str_hash, g_str_equal);
 	g_free (change_id);
 	
@@ -956,7 +961,7 @@ pre_sync (GnomePilotConduit *conduit,
 	}
 
 	/* Set the count information */
-	num_records = cal_client_get_n_objects (ctxt->client, CALOBJ_TYPE_TODO);
+	num_records = g_list_length (ctxt->comps);
 	gnome_pilot_conduit_sync_abs_set_num_local_records(abs_conduit, num_records);
 	gnome_pilot_conduit_sync_abs_set_num_new_local_records (abs_conduit, add_records);
 	gnome_pilot_conduit_sync_abs_set_num_updated_local_records (abs_conduit, mod_records);
@@ -1006,8 +1011,8 @@ post_sync (GnomePilotConduit *conduit,
 	 * a race condition if anyone changes a record elsewhere during sycnc
          */
 	change_id = g_strdup_printf ("pilot-sync-evolution-todo-%d", ctxt->cfg->pilot_id);
-	changed = cal_client_get_changes (ctxt->client, CALOBJ_TYPE_TODO, change_id);
-	cal_client_change_list_free (changed);
+	if (cal_client_get_changes (ctxt->client, CALOBJ_TYPE_TODO, change_id, &changed, NULL))
+		cal_client_change_list_free (changed);
 	g_free (change_id);
 	
 	LOG (g_message ( "---------------------------------------------------------\n" ));
@@ -1051,7 +1056,7 @@ for_each (GnomePilotConduitSyncAbs *conduit,
 	  EToDoLocalRecord **local,
 	  EToDoConduitContext *ctxt)
 {
-	static GList *uids, *iterator;
+	static GList *comps, *iterator;
 	static int count;
 
 	g_return_val_if_fail (local != NULL, -1);
@@ -1059,17 +1064,17 @@ for_each (GnomePilotConduitSyncAbs *conduit,
 	if (*local == NULL) {
 		LOG (g_message ( "beginning for_each" ));
 
-		uids = ctxt->uids;
+		comps = ctxt->comps;
 		count = 0;
 		
-		if (uids != NULL) {
-			LOG (g_message ( "iterating over %d records", g_list_length (uids) ));
+		if (comps != NULL) {
+			LOG (g_message ( "iterating over %d records", g_list_length (comps)));
 
 			*local = g_new0 (EToDoLocalRecord, 1);
-			local_record_from_uid (*local, uids->data, ctxt);
+			local_record_from_comp (*local, comps->data, ctxt);
 			g_list_prepend (ctxt->locals, *local);
 			
-			iterator = uids;
+			iterator = comps;
 		} else {
 			LOG (g_message ( "no events" ));
 			(*local) = NULL;
@@ -1196,7 +1201,9 @@ add_record (GnomePilotConduitSyncAbs *conduit,
 	uid = cal_component_gen_uid ();
 	cal_component_set_uid (comp, uid);
 
-	update_comp (conduit, comp, ctxt);
+	if (!cal_client_create_object (ctxt->client, cal_component_get_icalcomponent (comp), NULL, NULL))
+		return -1;
+
 	e_pilot_map_insert (ctxt->map, remote->ID, uid, FALSE);
 
 	g_object_unref (comp);
@@ -1221,7 +1228,10 @@ replace_record (GnomePilotConduitSyncAbs *conduit,
 	new_comp = comp_from_remote_record (conduit, remote, local->comp, ctxt->timezone);
 	g_object_unref (local->comp);
 	local->comp = new_comp;
-	update_comp (conduit, local->comp, ctxt);
+
+	if (!cal_client_modify_object (ctxt->client, cal_component_get_icalcomponent (new_comp), 
+				       CALOBJ_MOD_ALL, NULL))
+		return -1;
 
 	return retval;
 }
@@ -1241,7 +1251,8 @@ delete_record (GnomePilotConduitSyncAbs *conduit,
 	LOG (g_message ( "delete_record: deleting %s\n", uid ));
 
 	e_pilot_map_remove_by_uid (ctxt->map, uid);
-	cal_client_remove_object (ctxt->client, uid);
+	/* FIXME Error handling */
+	cal_client_remove_object (ctxt->client, uid, NULL);
 	
         return 0;
 }
diff --git a/calendar/gui/GNOME_Evolution_Calendar.server.in.in b/calendar/gui/GNOME_Evolution_Calendar.server.in.in
index 801cada120..09f424f69a 100644
--- a/calendar/gui/GNOME_Evolution_Calendar.server.in.in
+++ b/calendar/gui/GNOME_Evolution_Calendar.server.in.in
@@ -1,6 +1,6 @@
 <oaf_info>
 
-<oaf_server iid="OAFIID:GNOME_Evolution_Calendar_Factory"
+<oaf_server iid="OAFIID:GNOME_Evolution_Calendar_Factory_2"
             type="shlib"
             location="@COMPONENTDIR@/libevolution-calendar.so">
 
@@ -15,7 +15,7 @@
 
 <oaf_server iid="OAFIID:GNOME_Evolution_Calendar_iTip_Control"
             type="factory"
-            location="OAFIID:GNOME_Evolution_Calendar_Factory">
+            location="OAFIID:GNOME_Evolution_Calendar_Factory_2">
 
 	<oaf_attribute name="repo_ids" type="stringv">
 		<item value="IDL:Bonobo/Control:1.0"/>
@@ -31,26 +31,20 @@
 		       _value="Evolution Calendar scheduling message viewer"/>
 </oaf_server>
 
-<oaf_server iid="OAFIID:GNOME_Evolution_Calendar_ShellComponent"
+<oaf_server iid="OAFIID:GNOME_Evolution_Calendar_Component"
             type="factory"
-            location="OAFIID:GNOME_Evolution_Calendar_Factory">
+            location="OAFIID:GNOME_Evolution_Calendar_Factory_2">
 
 	<oaf_attribute name="repo_ids" type="stringv">
-		<item value="IDL:GNOME/Evolution/ShellComponent:1.0"/>
+		<item value="IDL:GNOME/Evolution/Component:1.0"/>
 	</oaf_attribute>
 
-	<oaf_attribute name="name" type="string"
-	               _value="Evolution Calendar and Tasks component"/>
-
-	<oaf_attribute name="evolution:shell_component_icon" type="string"
-		       value="evolution-calendar.png"/>
-	<oaf_attribute name="evolution:shell_component_launch_order" type="number"
-		       value="3"/>
+	<oaf_attribute name="name" type="string" _value="Evolution's Calendar component"/>
 </oaf_server>
 
 <oaf_server iid="OAFIID:GNOME_Evolution_Calendar_Control"
             type="factory"
-            location="OAFIID:GNOME_Evolution_Calendar_Factory">
+            location="OAFIID:GNOME_Evolution_Calendar_Factory_2">
 
 	<oaf_attribute name="repo_ids" type="stringv">
 		<item value="IDL:BonoboControl/calendar-control:1.0"/>
@@ -68,7 +62,7 @@
 
 <oaf_server iid="OAFIID:GNOME_Evolution_Tasks_Control"
             type="factory"
-            location="OAFIID:GNOME_Evolution_Calendar_Factory">
+            location="OAFIID:GNOME_Evolution_Calendar_Factory_2">
 
 	<oaf_attribute name="repo_ids" type="stringv">
 		<item value="IDL:BonoboControl/tasks-control:1.0"/>
@@ -86,7 +80,7 @@
 
 <oaf_server iid="OAFIID:GNOME_Evolution_Calendar_CompEditorFactory"
             type="factory"
-            location="OAFIID:GNOME_Evolution_Calendar_Factory">
+            location="OAFIID:GNOME_Evolution_Calendar_Factory_2">
 
 	<oaf_attribute name="repo_ids" type="stringv">
 		<item value="IDL:GNOME/Evolution/Calendar/CompEditorFactory:1.0"/>
@@ -99,7 +93,7 @@
 
 <oaf_server iid="OAFIID:GNOME_Evolution_Calendar_ConfigControl"
 	    type="factory"
-	    location="OAFIID:GNOME_Evolution_Calendar_Factory">
+	    location="OAFIID:GNOME_Evolution_Calendar_Factory_2">
 
 	<oaf_attribute name="repo_ids" type="stringv">
 		<item value="IDL:GNOME/Evolution/ConfigControl:1.0"/>
diff --git a/calendar/gui/Makefile.am b/calendar/gui/Makefile.am
index 3ee9362b65..19edf95953 100644
--- a/calendar/gui/Makefile.am
+++ b/calendar/gui/Makefile.am
@@ -169,6 +169,8 @@ libevolution_calendar_la_SOURCES =		\
 	itip-utils.c				\
 	itip-utils.h				\
 	main.c					\
+	migration.c				\
+	migration.h				\
 	misc.c					\
 	misc.h					\
 	print.c					\
@@ -189,7 +191,8 @@ libevolution_calendar_la_LIBADD =					\
 	$(top_builddir)/calendar/gui/dialogs/libcal-dialogs.la		\
 	$(top_builddir)/widgets/e-timezone-dialog/libetimezonedialog.la	\
 	$(top_builddir)/widgets/misc/libemiscwidgets.la			\
-	$(top_builddir)/a11y/calendar/libevolution-calendar-a11y.la                       \
+	$(top_builddir)/e-util/libeutil.la				\
+	$(top_builddir)/a11y/calendar/libevolution-calendar-a11y.la	\
 	$(EVOLUTION_CALENDAR_LIBS)
 
 libevolution_calendar_la_LDFLAGS = -avoid-version -module
diff --git a/calendar/gui/alarm-notify/alarm-notify.c b/calendar/gui/alarm-notify/alarm-notify.c
index 133448e7cd..006533c6bf 100644
--- a/calendar/gui/alarm-notify/alarm-notify.c
+++ b/calendar/gui/alarm-notify/alarm-notify.c
@@ -31,26 +31,6 @@
 
 
 
-/* A loaded client */
-typedef struct {
-	/* The actual client */
-	CalClient *client;
-
-	/* The URI of the client in gnome-vfs's format.  This *is* the key that
-	 * is stored in the uri_client_hash hash table below.
-	 */
-	EUri *uri;
-
-	/* Number of times clients have requested this URI to be added to the
-	 * alarm notification system.
-	 */
-	int refcount;
-
-	/* the ID of the retry timeout function
-	 */
-	int timeout_id;
-} LoadedClient;
-
 /* Private part of the AlarmNotify structure */
 struct _AlarmNotifyPrivate {
 	/* Mapping from EUri's to LoadedClient structures */
@@ -105,23 +85,7 @@ alarm_notify_init (AlarmNotify *an, AlarmNotifyClass *klass)
 	priv = g_new0 (AlarmNotifyPrivate, 1);
 	an->priv = priv;
 
-	priv->uri_client_hash = g_hash_table_new (g_str_hash, g_str_equal);
-}
-
-/* Callback used from g_hash-table_forach(), used to destroy a loade client */
-static void
-destroy_loaded_client_cb (gpointer key, gpointer value, gpointer data)
-{
-	LoadedClient *lc;
-	char *str_uri;
-
-	str_uri = key;
-	lc = value;
-	
-	g_free (str_uri);
-	g_object_unref (G_OBJECT (lc->client));
-	e_uri_free (lc->uri);
-	g_free (lc);
+	priv->uri_client_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
 }
 
 /* Finalize handler for the alarm notify system */
@@ -137,13 +101,9 @@ alarm_notify_finalize (GObject *object)
 	an = ALARM_NOTIFY (object);
 	priv = an->priv;
 
-	g_hash_table_foreach (priv->uri_client_hash, destroy_loaded_client_cb, NULL);
-
 	g_hash_table_destroy (priv->uri_client_hash);
-	priv->uri_client_hash = NULL;
 
 	g_free (priv);
-	an->priv = NULL;
 
 	if (G_OBJECT_CLASS (parent_class)->finalize)
 		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
@@ -193,21 +153,15 @@ free_uris (GPtrArray *uris)
 
 /* Adds an URI to the list of calendars to load on startup */
 static void
-add_uri_to_load (EUri *uri)
+add_uri_to_load (const char *str_uri)
 {
-	char *str_uri;
 	GPtrArray *loaded_uris;
 	int i;
 
-	/* Canonicalize the URI */
-	str_uri = e_uri_to_string (uri, FALSE);
-	g_assert (str_uri != NULL);
-
 	loaded_uris = get_calendars_to_load ();
 	if (!loaded_uris) {
 		g_message ("add_uri_to_load(): Could not get the list of calendars to load; "
 			   "will not add `%s'", str_uri);
-		g_free (str_uri);
 		return;
 	}
 
@@ -219,12 +173,11 @@ add_uri_to_load (EUri *uri)
 	 * calendars.
 	 */
 	if (i != -1) {
-		g_free (str_uri);
 		free_uris (loaded_uris);
 		return;
 	}
 
-	g_ptr_array_add (loaded_uris, str_uri);
+	g_ptr_array_add (loaded_uris, g_strdup (str_uri));
 	save_calendars_to_load (loaded_uris);
 
 	free_uris (loaded_uris);
@@ -232,29 +185,22 @@ add_uri_to_load (EUri *uri)
 
 /* Removes an URI from the list of calendars to load on startup */
 static void
-remove_uri_to_load (EUri *uri)
+remove_uri_to_load (const char *str_uri)
 {
-	char *str_uri;
 	GPtrArray *loaded_uris;
 	char *loaded_uri;
 	int i;
 
-	/* Canonicalize the URI */
-	str_uri = e_uri_to_string (uri, FALSE);
-	g_assert (str_uri != NULL);
-
 	loaded_uris = get_calendars_to_load ();
 	if (!loaded_uris) {
 		g_message ("remove_uri_to_load(): Could not get the list of calendars to load; "
 			   "will not add `%s'", str_uri);
-		g_free (str_uri);
 		return;
 	}
 
 	/* Look for the URI in the list of calendars to load */
 
 	i = find_uri_index (loaded_uris, str_uri);
-	g_free (str_uri);
 
 	/* If we didn't find it, there is no need to remove it */
 	if (i == -1) {
@@ -291,61 +237,19 @@ AlarmNotify_removeCalendar (PortableServer_Servant servant,
 {
 	AlarmNotify *an;
 	AlarmNotifyPrivate *priv;
-	LoadedClient *lc;
-	EUri *uri;
-	char *orig_str;
-	gpointer lc_ptr, orig_str_ptr;
-	gboolean found;
-
-	lc_ptr = NULL;
-	orig_str_ptr = NULL;
+	CalClient *client;	
 
 	an = ALARM_NOTIFY (bonobo_object_from_servant (servant));
 	priv = an->priv;
 
-	uri = e_uri_new (str_uri);
-	if (!uri) {
-		CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
-				     ex_GNOME_Evolution_Calendar_AlarmNotify_InvalidURI,
-				     NULL);
-		return;
-	}
+	client = g_hash_table_lookup (priv->uri_client_hash, str_uri);
+	if (client) {
+		alarm_queue_remove_client (client);
 
-	remove_uri_to_load (uri);
-
-	found = g_hash_table_lookup_extended (priv->uri_client_hash, str_uri,
-					      &orig_str_ptr,
-					      &lc_ptr);
-	orig_str = orig_str_ptr;
-	lc = lc_ptr;
-
-	e_uri_free (uri);
-
-	if (!lc) {
-		CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
-				     ex_GNOME_Evolution_Calendar_AlarmNotify_NotFound,
-				     NULL);
-		return;
+		g_hash_table_remove (priv->uri_client_hash, str_uri);
 	}
 
-	g_assert (lc->refcount > 0);
-
-	lc->refcount--;
-	if (lc->refcount > 0)
-		return;
-
-	g_hash_table_remove (priv->uri_client_hash, str_uri);
-
-	g_free (orig_str);
-	g_signal_handlers_disconnect_matched (lc->client,
-					      G_SIGNAL_MATCH_DATA,
-					      0, 0, NULL, NULL, lc);
-	if (lc->timeout_id != -1)
-		g_source_remove (lc->timeout_id);
-	alarm_queue_remove_client (lc->client);
-	g_object_unref (G_OBJECT (lc->client));
-	e_uri_free (lc->uri);
-	g_free (lc);
+	remove_uri_to_load (str_uri);
 }
 
 
@@ -367,40 +271,6 @@ alarm_notify_new (void)
 	return an;
 }
 
-static gboolean
-retry_timeout_cb (gpointer data)
-{
-	LoadedClient *lc = data;
-	char *str_uri;
-	
-	if (cal_client_get_load_state (lc->client) != CAL_CLIENT_LOAD_LOADED) {
-		str_uri = e_uri_to_string (lc->uri, FALSE);
-		cal_client_open_calendar (lc->client, str_uri, FALSE);
-
-		g_free (str_uri);
-	}
-
-	return FALSE;
-}
-
-static void
-cal_opened_cb (CalClient *client, CalClientOpenStatus status, gpointer data)
-{
-	LoadedClient *lc = (LoadedClient *) data;
-
-	if (status == CAL_CLIENT_OPEN_SUCCESS) {
-		add_uri_to_load (lc->uri);
-		alarm_queue_add_client (client);
-		lc->timeout_id = -1;
-	}
-	else {
-		remove_uri_to_load (lc->uri);
-
-		/* we set a timeout of 5 mins before retrying */
-		lc->timeout_id = g_timeout_add (300000, (GSourceFunc) retry_timeout_cb, lc);
-	}
-}
-
 /**
  * alarm_notify_add_calendar:
  * @an: An alarm notification service.
@@ -418,10 +288,7 @@ alarm_notify_add_calendar (AlarmNotify *an, const char *str_uri, gboolean load_a
 			   CORBA_Environment *ev)
 {
 	AlarmNotifyPrivate *priv;
-	EUri *uri;
 	CalClient *client;
-	LoadedClient *lc;
-	gpointer lc_ptr, s_ptr;
 
 	g_return_if_fail (an != NULL);
 	g_return_if_fail (IS_ALARM_NOTIFY (an));
@@ -430,49 +297,23 @@ alarm_notify_add_calendar (AlarmNotify *an, const char *str_uri, gboolean load_a
 
 	priv = an->priv;
 
-	uri = e_uri_new (str_uri);
-	if (!uri) {
-		CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
-				     ex_GNOME_Evolution_Calendar_AlarmNotify_InvalidURI,
-				     NULL);
+	/* See if we already know about this uri */
+	if (g_hash_table_lookup (priv->uri_client_hash, str_uri))
 		return;
-	}
 
-	if (g_hash_table_lookup_extended (priv->uri_client_hash, str_uri, &s_ptr, &lc_ptr)) {
-		lc = lc_ptr;
-		lc->refcount++;
-	} else {
-		client = cal_client_new ();
-
-		if (client) {
-			/* we only add the URI to load_afterwards if we open it
-			   correctly */
-			lc = g_new (LoadedClient, 1);
-			lc->client = client;
-			lc->uri = uri;
-			lc->refcount = 1;
-			lc->timeout_id = -1;
-
-
-			g_signal_connect (G_OBJECT (client), "cal_opened",
-					  G_CALLBACK (cal_opened_cb),
-					  lc);
-
-			if (cal_client_open_calendar (client, str_uri, FALSE)) {
-				g_hash_table_insert (priv->uri_client_hash,
-						     g_strdup (str_uri), lc);
-			} else {
-				g_free (lc);
-				g_object_unref (G_OBJECT (client));
-				client = NULL;
-			}
-		} else {
-			e_uri_free (uri);
-
-			CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
-					     ex_GNOME_Evolution_Calendar_AlarmNotify_BackendContactError,
-					     NULL);
-			return;
+	client = cal_client_new (str_uri, CALOBJ_TYPE_EVENT);
+
+	if (client) {
+		if (cal_client_open (client, FALSE, NULL)) {
+			add_uri_to_load (str_uri);
+			
+			g_hash_table_insert (priv->uri_client_hash,
+					     g_strdup (str_uri), client);
 		}
+	} else {
+		CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
+				     ex_GNOME_Evolution_Calendar_AlarmNotify_BackendContactError,
+				     NULL);
+		return;
 	}
 }
diff --git a/calendar/gui/alarm-notify/alarm-queue.c b/calendar/gui/alarm-notify/alarm-queue.c
index cb792e466f..cee17bd97e 100644
--- a/calendar/gui/alarm-notify/alarm-queue.c
+++ b/calendar/gui/alarm-notify/alarm-queue.c
@@ -227,7 +227,7 @@ remove_queued_alarm (CompQueuedAlarms *cqa, gpointer alarm_id,
 	if (remove_alarm) {
 		cqa->expecting_update = TRUE;
 		cal_client_discard_alarm (cqa->parent_client->client, cqa->alarms->comp,
-					  qa->instance->auid);
+					  qa->instance->auid, NULL);
 		cqa->expecting_update = FALSE;
 	}
 
diff --git a/calendar/gui/calendar-commands.c b/calendar/gui/calendar-commands.c
index c0d1b3c589..77305098bc 100644
--- a/calendar/gui/calendar-commands.c
+++ b/calendar/gui/calendar-commands.c
@@ -59,6 +59,7 @@
 #include "goto.h"
 #include "print.h"
 #include "dialogs/cal-prefs-dialog.h"
+#include "dialogs/new-calendar.h"
 #include "itip-utils.h"
 #include "evolution-shell-component-utils.h"
 
@@ -73,6 +74,68 @@ typedef struct {
 	guint taskpad_focused : 1;
 } FocusData;
 
+static void
+file_new_calendar_cb (BonoboUIComponent *uic, gpointer data, const char *path)
+{
+	GnomeCalendar *gcal;
+
+	gcal = GNOME_CALENDAR (data);
+
+	new_calendar_dialog (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (gcal))));
+}
+
+static void
+file_new_appointment_cb (BonoboUIComponent *uic, gpointer data, const char *path)
+{
+	GnomeCalendar *gcal;
+	time_t dtstart, dtend;
+	ECalView *cal_view;
+
+	gcal = GNOME_CALENDAR (data);
+
+	cal_view = (ECalView *) gnome_calendar_get_current_view_widget (gcal);
+	e_cal_view_get_selected_time_range (cal_view, &dtstart, &dtend);
+	e_cal_view_new_appointment_for (cal_view, dtstart, dtend, FALSE, FALSE);
+}
+
+static void
+file_new_event_cb (BonoboUIComponent *uic, gpointer data, const char *path)
+{
+	GnomeCalendar *gcal;
+	time_t dtstart, dtend;
+	ECalView *cal_view;
+
+	gcal = GNOME_CALENDAR (data);
+
+	cal_view = (ECalView *) gnome_calendar_get_current_view_widget (gcal);
+	e_cal_view_get_selected_time_range (cal_view, &dtstart, &dtend);
+	e_cal_view_new_appointment_for (cal_view, dtstart, dtend, TRUE, FALSE);
+}
+
+static void
+file_new_meeting_cb (BonoboUIComponent *uic, gpointer data, const char *path)
+{
+	GnomeCalendar *gcal;
+	time_t dtstart, dtend;
+	ECalView *cal_view;
+
+	gcal = GNOME_CALENDAR (data);
+
+	cal_view = (ECalView *) gnome_calendar_get_current_view_widget (gcal);
+	e_cal_view_get_selected_time_range (cal_view, &dtstart, &dtend);
+	e_cal_view_new_appointment_for (cal_view, dtstart, dtend, FALSE, TRUE);
+}
+
+static void
+file_new_task_cb (BonoboUIComponent *uic, gpointer data, const char *path)
+{
+	GnomeCalendar *gcal;
+
+	gcal = GNOME_CALENDAR (data);
+
+	gnome_calendar_new_task (gcal);
+}
+
 /* Prints the calendar at its current view and time range */
 static void
 print (GnomeCalendar *gcal, gboolean preview)
@@ -335,12 +398,10 @@ publish_freebusy_cmd (BonoboUIComponent *uic, gpointer data, const gchar *path)
 	start = time_day_begin_with_zone (start, utc);
 	end = time_add_week_with_zone (start, 6, utc);
 
+	/* FIXME Should we aggregate the data? */
 	client_list = e_cal_model_get_client_list (gnome_calendar_get_calendar_model (gcal));
 	for (cl = client_list; cl != NULL; cl = cl->next) {
-		GList *tmp_comp_list;
-
-		tmp_comp_list = cal_client_get_free_busy ((CalClient *) cl->data, NULL, start, end);
-		if (tmp_comp_list) {
+		if (cal_client_get_free_busy ((CalClient *) cl->data, NULL, start, end, &comp_list, NULL)) {
 			GList *l;
 
 			for (l = comp_list; l; l = l->next) {
@@ -599,19 +660,42 @@ control_util_show_settings (GnomeCalendar *gcal)
  * is FALSE, all will be disabled.  Otherwise, the currently-selected number of
  * events will be used.
  */
-static void
-sensitize_calendar_commands (GnomeCalendar *gcal, BonoboControl *control, gboolean enable)
+void
+calendar_control_sensitize_calendar_commands (BonoboControl *control, GnomeCalendar *gcal, gboolean enable)
 {
 	BonoboUIComponent *uic;
+	ECalViewEvent *event;
+	GList *list;
 	int n_selected;
-	gboolean read_only, has_recurrences;
+	GtkWidget *view;
+	CalClient *cal_client;
+	gboolean read_only = FALSE, has_recurrences;
 	
 	uic = bonobo_control_get_ui_component (control);
 	g_assert (uic != NULL);
 
-	n_selected = enable ? gnome_calendar_get_num_events_selected (gcal) : 0;
-	read_only = cal_client_is_read_only (e_cal_model_get_default_client (gnome_calendar_get_calendar_model (gcal)));
+	view = gnome_calendar_get_current_view_widget (gcal);
+	list = e_cal_view_get_selected_events (E_CAL_VIEW (view));
+
+	n_selected = enable ? g_list_length (list) : 0;
 
+	event = (ECalViewEvent *) list ? list->data : NULL;
+	if (event) {
+		cal_client_is_read_only (event->comp_data->client, &read_only, NULL);
+	} else {
+		cal_client = e_cal_model_get_default_client (gnome_calendar_get_calendar_model (gcal));
+		if (cal_client)
+			cal_client_is_read_only (cal_client, &read_only, NULL);
+		else
+			read_only = TRUE;
+	}
+
+	bonobo_ui_component_set_prop (uic, "/commands/NewAppointment", "sensitive",
+				      read_only ? "0" : "1", NULL);
+	bonobo_ui_component_set_prop (uic, "/commands/NewAllDayEvent", "sensitive",
+				      read_only ? "0" : "1", NULL);
+	bonobo_ui_component_set_prop (uic, "/commands/NewMeeting", "sensitive",
+				      read_only ? "0" : "1", NULL);
 	bonobo_ui_component_set_prop (uic, "/commands/Cut", "sensitive",
 				      n_selected == 0 || read_only ? "0" : "1",
 				      NULL);
@@ -628,19 +712,8 @@ sensitize_calendar_commands (GnomeCalendar *gcal, BonoboControl *control, gboole
 	/* occurrence-related menu items */
 	has_recurrences = FALSE;
 	if (n_selected > 0 && !read_only) {
-		ECalViewEvent *event;
-		GList *list;
-		GtkWidget *view;
-
-		view = gnome_calendar_get_current_view_widget (gcal);
-		list = e_cal_view_get_selected_events (E_CAL_VIEW (view));
 		if (list) {
 			event = (ECalViewEvent *) list->data;
-			g_list_free (list);
-		} else
-			event = NULL;
-
-		if (event) {
 			if (cal_util_component_has_recurrences (event->comp_data->icalcomp))
 				has_recurrences = TRUE;
 		}
@@ -652,6 +725,10 @@ sensitize_calendar_commands (GnomeCalendar *gcal, BonoboControl *control, gboole
 	bonobo_ui_component_set_prop (uic, "/commands/DeleteAllOccurrences", "sensitive",
 				      has_recurrences ? "1" : "0",
 				      NULL);
+
+	/* free memory */
+	if (list)
+		g_list_free (list);
 }
 
 /* Sensitizes the UI Component menu/toolbar tasks commands based on the number
@@ -663,14 +740,21 @@ sensitize_taskpad_commands (GnomeCalendar *gcal, BonoboControl *control, gboolea
 {
 	BonoboUIComponent *uic;
 	int n_selected;
-	gboolean read_only;
+	CalClient *cal_client;
+	gboolean read_only = TRUE;
 	
 	uic = bonobo_control_get_ui_component (control);
 	g_assert (uic != NULL);
 
 	n_selected = enable ? gnome_calendar_get_num_tasks_selected (gcal) : 0;
-	read_only = cal_client_is_read_only (gnome_calendar_get_task_pad_cal_client (gcal));
-
+	cal_client = gnome_calendar_get_task_pad_cal_client (gcal);
+	if (cal_client)
+		cal_client_is_read_only (cal_client, &read_only, NULL);
+	else
+		read_only = TRUE;
+
+	bonobo_ui_component_set_prop (uic, "/commands/NewTask", "sensitive",
+				      read_only ? "0" : "1", NULL);
 	bonobo_ui_component_set_prop (uic, "/commands/Cut", "sensitive",
 				      n_selected == 0 || read_only ? "0" : "1",
 				      NULL);
@@ -705,7 +789,7 @@ gcal_calendar_selection_changed_cb (GnomeCalendar *gcal, gpointer data)
 
 	control = BONOBO_CONTROL (data);
 
-	sensitize_calendar_commands (gcal, control, TRUE);
+	calendar_control_sensitize_calendar_commands (control, gcal, TRUE);
 }
 
 /* Callback used when the selection in the taskpad changes */
@@ -734,13 +818,13 @@ gcal_calendar_focus_change_cb (GnomeCalendar *gcal, gboolean in, gpointer data)
 	if (in) {
 		g_signal_connect (gcal, "calendar_selection_changed",
 				  G_CALLBACK (gcal_calendar_selection_changed_cb), control);
-		sensitize_calendar_commands (gcal, control, TRUE);
+		calendar_control_sensitize_calendar_commands (control, gcal, TRUE);
 		focus->calendar_focused = TRUE;
 	} else if (focus->calendar_focused) {
 		gtk_signal_disconnect_by_func (GTK_OBJECT (gcal),
 					       G_CALLBACK (gcal_calendar_selection_changed_cb),
 					       control);
-		sensitize_calendar_commands (gcal, control, FALSE);
+		calendar_control_sensitize_calendar_commands (control, gcal, FALSE);
 		focus->calendar_focused = FALSE;
 	}
 }
@@ -779,6 +863,11 @@ gcal_taskpad_focus_change_cb (GnomeCalendar *gcal, gboolean in, gpointer data)
 
 
 static BonoboUIVerb verbs [] = {
+	BONOBO_UI_VERB ("NewCalendar", file_new_calendar_cb),
+	BONOBO_UI_VERB ("NewAppointment", file_new_appointment_cb),
+	BONOBO_UI_VERB ("NewAllDayEvent", file_new_event_cb),
+	BONOBO_UI_VERB ("NewMeeting", file_new_meeting_cb),
+	BONOBO_UI_VERB ("NewTask", file_new_task_cb),
 	BONOBO_UI_VERB ("CalendarPrint", file_print_cb),
 	BONOBO_UI_VERB ("CalendarPrintPreview", file_print_preview_cb),
 
@@ -808,11 +897,15 @@ static BonoboUIVerb verbs [] = {
 
 static EPixmap pixmaps [] =
 {
-	E_PIXMAP ("/Toolbar/DayView",					      "buttons/dayview.xpm"),
-	E_PIXMAP ("/Toolbar/WorkWeekView",				      "buttons/workweekview.xpm"),
-	E_PIXMAP ("/Toolbar/WeekView",					      "buttons/weekview.xpm"),
-	E_PIXMAP ("/Toolbar/MonthView",					      "buttons/monthview.xpm"),
-	E_PIXMAP ("/Toolbar/ListView",					      "buttons/listview.xpm"),
+	E_PIXMAP ("/commands/NewAppointment", "new_appointment.xpm"),
+	E_PIXMAP ("/commands/NewAllDayEvent", "new_all_day_event.png"),
+	E_PIXMAP ("/commands/NewMeeting",     "meeting-request-16.png"),
+	E_PIXMAP ("/commands/NewTask",        "new_task-16.png"),
+	E_PIXMAP ("/Toolbar/DayView",	      "buttons/dayview.xpm"),
+	E_PIXMAP ("/Toolbar/WorkWeekView",    "buttons/workweekview.xpm"),
+	E_PIXMAP ("/Toolbar/WeekView",	      "buttons/weekview.xpm"),
+	E_PIXMAP ("/Toolbar/MonthView",	      "buttons/monthview.xpm"),
+	E_PIXMAP ("/Toolbar/ListView",	      "buttons/listview.xpm"),
 
 	E_PIXMAP_END
 };
@@ -855,7 +948,7 @@ calendar_control_activate (BonoboControl *control,
 	g_signal_connect (gcal, "taskpad_focus_change",
 			  G_CALLBACK (gcal_taskpad_focus_change_cb), control);
 
-	sensitize_calendar_commands (gcal, control, FALSE);
+	calendar_control_sensitize_calendar_commands (control, gcal, FALSE);
 	sensitize_taskpad_commands (gcal, control, FALSE);
 
 	bonobo_ui_component_thaw (uic, NULL);
diff --git a/calendar/gui/calendar-commands.h b/calendar/gui/calendar-commands.h
index 6f418799d2..3e74074140 100644
--- a/calendar/gui/calendar-commands.h
+++ b/calendar/gui/calendar-commands.h
@@ -38,6 +38,8 @@ GnomeCalendar *new_calendar (void);
 void calendar_control_activate (BonoboControl *control, GnomeCalendar *gcal);
 void calendar_control_deactivate (BonoboControl *control, GnomeCalendar *gcal);
 
+void calendar_control_sensitize_calendar_commands (BonoboControl *control, GnomeCalendar *gcal, gboolean enable);
+
 void calendar_goto_today (GnomeCalendar *gcal);
 
 void calendar_set_folder_bar_label (GnomeCalendar *gcal, BonoboControl *control);
diff --git a/calendar/gui/calendar-component.c b/calendar/gui/calendar-component.c
index 98f0964cc4..3e8782f45b 100644
--- a/calendar/gui/calendar-component.c
+++ b/calendar/gui/calendar-component.c
@@ -1,7 +1,7 @@
 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* component-factory.c
+/* calendar-component.c
  *
- * Copyright (C) 2000, 2001, 2002, 2003  Ximian, Inc.
+ * Copyright (C) 2003  Ettore Perazzoli
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
@@ -20,752 +20,269 @@
  * Author: Ettore Perazzoli <ettore@ximian.com>
  */
 
+#ifdef CONFIG_H
 #include <config.h>
+#endif
 
-#include <errno.h>
-#include <libgnome/gnome-util.h>
-#include <libgnomevfs/gnome-vfs-types.h>
-#include <libgnomevfs/gnome-vfs-uri.h>
-#include <libgnomevfs/gnome-vfs-ops.h>
-#include <libgnomevfs/gnome-vfs-directory.h>
-#include <libgnomevfs/gnome-vfs-file-info.h>
-
-#include <bonobo/bonobo-generic-factory.h>
-#include <bonobo/bonobo-context.h>
-#include <bonobo/bonobo-exception.h>
-
-#include "evolution-shell-component.h"
-#include "calendar-offline-handler.h"
 #include "calendar-component.h"
-#include "tasks-control.h"
 #include "control-factory.h"
-#include "calendar-config.h"
-#include "tasks-control.h"
-#include "e-comp-editor-registry.h"
-#include "dialogs/comp-editor.h"
-
-
-/* OAFIID for the component.  */
-#define COMPONENT_ID "OAFIID:GNOME_Evolution_Calendar_ShellComponent"
- 
-/* Folder type IDs */
-#define FOLDER_CALENDAR "calendar"
-#define FOLDER_TASKS "tasks"
-#define FOLDER_PUBLIC_CALENDAR "calendar/public"
-#define FOLDER_PUBLIC_TASKS "tasks/public"
-
-/* IDs for user creatable items */
-#define CREATE_EVENT_ID "event"
-#define CREATE_ALLDAY_EVENT_ID "allday-event"
-#define CREATE_MEETING_ID "meeting"
-#define CREATE_TASK_ID "task"
-
-char *evolution_dir = NULL;
-EvolutionShellClient *global_shell_client = NULL;
-extern ECompEditorRegistry *comp_editor_registry;
-
-static const EvolutionShellComponentFolderType folder_types[] = {
-	{ FOLDER_CALENDAR,
-	  "evolution-calendar.png",
-	  N_("Calendar"),
-	  N_("Folder containing appointments and events"),
-	  TRUE, NULL, NULL },
-	{ FOLDER_PUBLIC_CALENDAR,
-	  "evolution-calendar.png",
-	  N_("Public Calendar"),
-	  N_("Public folder containing appointments and events"),
-	  FALSE, NULL, NULL },
-	{ FOLDER_TASKS,
-	  "evolution-tasks.png",
-	  N_("Tasks"),
-	  N_("Folder containing to-do items"),
-	  TRUE, NULL, NULL },
-	{ FOLDER_PUBLIC_TASKS,
-	  "evolution-tasks.png",
-	  N_("Public Tasks"),
-	  N_("Public folder containing to-do items"),
-	  FALSE, NULL, NULL },
-	{ NULL, NULL }
-};
+#include "gnome-cal.h"
+#include "migration.h"
 
-
-
-static inline gboolean
-type_is_calendar (const char *type)
-{
-	return !strcmp (type, FOLDER_CALENDAR) ||
-		!strcmp (type, FOLDER_PUBLIC_CALENDAR);
-}
+#include "widgets/misc/e-source-selector.h"
 
-static inline gboolean
-type_is_tasks (const char *type)
-{
-	return !strcmp (type, FOLDER_TASKS) ||
-		!strcmp (type, FOLDER_PUBLIC_TASKS);
-}
+#include <bonobo/bonobo-control.h>
+#include <bonobo/bonobo-i18n.h>
+#include <gal/util/e-util.h>
 
-/* EvolutionShellComponent methods and signals.  */
+#include <errno.h>
 
-static EvolutionShellComponentResult
-create_view (EvolutionShellComponent *shell_component,
-	     const char *physical_uri,
-	     const char *type,
-	     const char *view_info,
-	     BonoboControl **control_return,
-	     void *closure)
-{
-	BonoboControl *control;
-
-	if (type_is_calendar (type)) {
-		control = control_factory_new_control ();
-		if (!control)
-			return EVOLUTION_SHELL_COMPONENT_CORBAERROR;
-	} else if (type_is_tasks (type)) {
-		control = tasks_control_new ();
-		if (!control)
-			return EVOLUTION_SHELL_COMPONENT_CORBAERROR;
-	} else {
-		return EVOLUTION_SHELL_COMPONENT_UNSUPPORTEDTYPE;
-	}
 
-	bonobo_control_set_property (control, NULL, "folder_uri", TC_CORBA_string, physical_uri, NULL);
-	if (type_is_calendar (type) && *view_info)
-		bonobo_control_set_property (control, NULL, "view", TC_CORBA_string, view_info, NULL);
+#define PARENT_TYPE bonobo_object_get_type ()
+static BonoboObjectClass *parent_class = NULL;
 
-	*control_return = control;
 
-	return EVOLUTION_SHELL_COMPONENT_OK;
-}
+struct _CalendarComponentPrivate {
+	char *config_directory;
 
-static void
-create_folder (EvolutionShellComponent *shell_component,
-	       const char *physical_uri,
-	       const char *type,
-	       const GNOME_Evolution_ShellComponentListener listener,
-	       void *closure)
-{
-	CORBA_Environment ev;
-	GnomeVFSURI *uri;
+	GConfClient *gconf_client;
+	ESourceList *source_list;
+};
 
-	CORBA_exception_init (&ev);
 
-	if (!type_is_calendar (type) && !type_is_tasks (type)) {
-		GNOME_Evolution_ShellComponentListener_notifyResult (
-			listener,
-			GNOME_Evolution_ShellComponentListener_UNSUPPORTED_TYPE,
-			&ev);
-		CORBA_exception_free (&ev);
-		return;
-	}
+/* Utility functions.  */
 
-	uri = gnome_vfs_uri_new (physical_uri);
-	if (uri) {
-		/* we don't need to do anything */
-		GNOME_Evolution_ShellComponentListener_notifyResult (
-			listener,
-			GNOME_Evolution_ShellComponentListener_OK, &ev);
-		gnome_vfs_uri_unref (uri);
-	}
-	else {
-		GNOME_Evolution_ShellComponentListener_notifyResult (
-			listener,
-			GNOME_Evolution_ShellComponentListener_INVALID_URI,
-			&ev);
-	}
+static void
+load_uri_for_source (ESource *source, BonoboControl *view_control)
+{
+	GnomeCalendar *gcal;
+	char *uri = e_source_get_uri (source);
 
-	CORBA_exception_free (&ev);
+	gcal = (GnomeCalendar *) bonobo_control_get_widget (view_control);
+	gnome_calendar_add_event_uri (gcal, uri);
+	g_free (uri);
 }
 
-/* Asks the alarm daemon to stop monitoring the specified URI */
 static void
-stop_alarms (GnomeVFSURI *uri)
+load_uri_for_selection (ESourceSelector *selector, BonoboControl *view_control)
 {
-	char *str_uri;
-	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_AlarmNotify an;
-
-	/* Activate the alarm notification service */
-
-	CORBA_exception_init (&ev);
-	an = bonobo_activation_activate_from_id ("OAFIID:GNOME_Evolution_Calendar_AlarmNotify", 0, NULL, &ev);
-
-	if (BONOBO_EX (&ev)) {
-		g_message ("stop_alarms(): Could not activate the alarm notification service");
-		CORBA_exception_free (&ev);
-		return;
-	}
-	CORBA_exception_free (&ev);
-
-	/* Ask the service to remove the URI from its list of calendars */
-
-	str_uri = gnome_vfs_uri_to_string (uri, GNOME_VFS_URI_HIDE_NONE);
-	g_assert (str_uri != NULL);
-
-	CORBA_exception_init (&ev);
-	GNOME_Evolution_Calendar_AlarmNotify_removeCalendar (an, str_uri, &ev);
-	g_free (str_uri);
-
-	if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_AlarmNotify_InvalidURI)) {
-		g_message ("stop_alarms(): Invalid URI reported from the alarm notification service");
-	} else if (BONOBO_USER_EX (&ev, ex_GNOME_Evolution_Calendar_AlarmNotify_NotFound)) {
-		/* This is OK; the service may not have loaded that calendar */
-	} else if (BONOBO_EX (&ev)) {
-		g_message ("stop_alarms(): Could not issue the removeCalendar request");
-	}
+	GSList *selection, *l;
 	
-	CORBA_exception_free (&ev);
-
-	/* Get rid of the service */
-
-	CORBA_exception_init (&ev);
-	bonobo_object_release_unref (an, &ev);
-	if (BONOBO_EX (&ev))
-		g_message ("stop_alarms(): Could not unref the alarm notification service");
-	CORBA_exception_free (&ev);
+	selection = e_source_selector_get_selection (selector);
+	for (l = selection; l; l = l->next) {
+		ESource *selected_source = l->data;
+		
+		load_uri_for_source (selected_source, view_control);
+	}	
 }
 
+/* Callbacks.  */
 static void
-remove_folder (EvolutionShellComponent *shell_component,
-	       const char *physical_uri,
-	       const char *type,
-	       const GNOME_Evolution_ShellComponentListener listener,
-	       void *closure)
+source_selection_changed_callback (ESourceSelector *selector,
+				   BonoboControl *view_control)
 {
-	GnomeVFSURI *dir_uri, *data_uri, *backup_uri;
-	GnomeVFSResult data_result, backup_result;
-
-	/* check type */
-	if (!type_is_calendar (type) && !type_is_tasks (type)) {
-		CORBA_Environment ev;
-
-		CORBA_exception_init (&ev);
-		GNOME_Evolution_ShellComponentListener_notifyResult (
-			listener,
-			GNOME_Evolution_ShellComponentListener_UNSUPPORTED_TYPE,
-			&ev);
-
-		if (BONOBO_EX (&ev))
-			g_message ("remove_folder(): Could not notify the listener of "
-				   "an unsupported folder type");
+	
+	load_uri_for_selection (selector, view_control);
+}
 
-		CORBA_exception_free (&ev);
-		return;
-	}
+static void
+primary_source_selection_changed_callback (ESourceSelector *selector,
+					   BonoboControl *view_control)
+{
+	ESource *source;
+	GnomeCalendar *gcal;
+	ECalModel *model;
+	CalClient *client;
 
-	/* check URI */
-	dir_uri = gnome_vfs_uri_new (physical_uri);
-	if (!dir_uri) {
-		CORBA_Environment ev;
-
-		CORBA_exception_init (&ev);
-		GNOME_Evolution_ShellComponentListener_notifyResult (
-			listener,
-			GNOME_Evolution_ShellComponentListener_INVALID_URI,
-			&ev);
-		CORBA_exception_free (&ev);
+	source = e_source_selector_peek_primary_selection (selector);
+	if (!source)
 		return;
-	}
 
-	/* Compute the URIs of the appropriate files */
-
-	if (type_is_calendar (type)) {
-		data_uri = gnome_vfs_uri_append_file_name (dir_uri, "calendar.ics");
-		backup_uri = gnome_vfs_uri_append_file_name (dir_uri, "calendar.ics~");
-	} else if (type_is_tasks (type)) {
-		data_uri = gnome_vfs_uri_append_file_name (dir_uri, "tasks.ics");
-		backup_uri = gnome_vfs_uri_append_file_name (dir_uri, "tasks.ics~");
-	} else {
-		g_assert_not_reached ();
+	/* set the default client on the GnomeCalendar */
+	gcal = (GnomeCalendar *) bonobo_control_get_widget (view_control);
+	if (!GNOME_IS_CALENDAR (gcal))
 		return;
-	}
-
-	if (!data_uri || !backup_uri) {
-		CORBA_Environment ev;
-
-		g_message ("remove_folder(): Could not generate the data/backup URIs");
-
-		CORBA_exception_init (&ev);
-		GNOME_Evolution_ShellComponentListener_notifyResult (
-			listener,
-			GNOME_Evolution_ShellComponentListener_INVALID_URI,
-			&ev);
-
-		if (BONOBO_EX (&ev))
-			g_message ("remove_folder(): Could not notify the listener "
-				   "of an invalid URI");
-
-		CORBA_exception_free (&ev);
-
-		goto out;
-	}
-
-	/* Ask the alarm daemon to stop monitoring this URI */
-
-	stop_alarms (data_uri);
-
-	/* Delete the data and backup files; the shell will take care of the rest */
-
-	data_result = gnome_vfs_unlink_from_uri (data_uri);
-	backup_result = gnome_vfs_unlink_from_uri (backup_uri);
-
-	if ((data_result == GNOME_VFS_OK || data_result == GNOME_VFS_ERROR_NOT_FOUND)
-	    && (backup_result == GNOME_VFS_OK || backup_result == GNOME_VFS_ERROR_NOT_FOUND)) {
-		CORBA_Environment ev;
-
-		CORBA_exception_init (&ev);
-		GNOME_Evolution_ShellComponentListener_notifyResult (
-			listener,
-			GNOME_Evolution_ShellComponentListener_OK,
-			&ev);
-
-		if (BONOBO_EX (&ev))
-			g_message ("remove_folder(): Could not notify the listener about success");
-
-		CORBA_exception_free (&ev);
-	} else {
-		CORBA_Environment ev;
-
-		CORBA_exception_init (&ev);
-		GNOME_Evolution_ShellComponentListener_notifyResult (
-			listener,
-			GNOME_Evolution_ShellComponentListener_PERMISSION_DENIED,
-			&ev);
-
-		if (BONOBO_EX (&ev))
-			g_message ("remove_folder(): Could not notify the listener about failure");
-
-		CORBA_exception_free (&ev);
-	}
 
- out:
-
-	gnome_vfs_uri_unref (dir_uri);
-
-	if (data_uri)
-		gnome_vfs_uri_unref (data_uri);
-
-	if (backup_uri)
-		gnome_vfs_uri_unref (backup_uri);
+	model = gnome_calendar_get_calendar_model (gcal);
+	client = e_cal_model_get_client_for_uri (model, e_source_get_uri (source));
+	if (client)
+		gnome_calendar_set_default_client (gcal, client);
 }
 
-static GNOME_Evolution_ShellComponentListener_Result
-xfer_file (GnomeVFSURI *base_src_uri,
-	   GnomeVFSURI *base_dest_uri,
-	   const char *file_name,
-	   int remove_source)
-{
-	GnomeVFSURI *src_uri, *dest_uri;
-	GnomeVFSHandle *hin, *hout;
-	GnomeVFSResult result;
-	GnomeVFSFileInfo file_info;
-	GnomeVFSFileSize size;
-	char *buffer;
-
-	src_uri = gnome_vfs_uri_append_file_name (base_src_uri, file_name);
-
-	result = gnome_vfs_open_uri (&hin, src_uri, GNOME_VFS_OPEN_READ);
-	if (result == GNOME_VFS_ERROR_NOT_FOUND) {
-		gnome_vfs_uri_unref (src_uri);
-		return GNOME_Evolution_ShellComponentListener_OK; /* No need to xfer anything.  */
-	}
-	if (result != GNOME_VFS_OK) {
-		gnome_vfs_uri_unref (src_uri);
-		return GNOME_Evolution_ShellComponentListener_PERMISSION_DENIED;
-	}
-
-	result = gnome_vfs_get_file_info_uri (src_uri, &file_info, GNOME_VFS_FILE_INFO_DEFAULT);
-	if (result != GNOME_VFS_OK) {
-		gnome_vfs_uri_unref (src_uri);
-		return GNOME_Evolution_ShellComponentListener_PERMISSION_DENIED;
-	}
-
-	dest_uri = gnome_vfs_uri_append_file_name (base_dest_uri, file_name);
-
-	result = gnome_vfs_create_uri (&hout, dest_uri, GNOME_VFS_OPEN_WRITE, FALSE, 0600);
-	if (result != GNOME_VFS_OK) {
-		gnome_vfs_close (hin);
-		gnome_vfs_uri_unref (src_uri);
-		gnome_vfs_uri_unref (dest_uri);
-		return GNOME_Evolution_ShellComponentListener_PERMISSION_DENIED;
-	}
+/* GObject methods.  */
 
-	/* write source file to destination file */
-	buffer = g_malloc (file_info.size);
-	result = gnome_vfs_read (hin, buffer, file_info.size, &size);
-	if (result != GNOME_VFS_OK) {
-		gnome_vfs_close (hin);
-		gnome_vfs_close (hout);
-		gnome_vfs_uri_unref (src_uri);
-		gnome_vfs_uri_unref (dest_uri);
-		g_free (buffer);
-		return GNOME_Evolution_ShellComponentListener_PERMISSION_DENIED;
-	}
+static void
+impl_dispose (GObject *object)
+{
+	CalendarComponentPrivate *priv = CALENDAR_COMPONENT (object)->priv;
 
-	result = gnome_vfs_write (hout, buffer, file_info.size, &size);
-	if (result != GNOME_VFS_OK) {
-		gnome_vfs_close (hin);
-		gnome_vfs_close (hout);
-		gnome_vfs_uri_unref (src_uri);
-		gnome_vfs_uri_unref (dest_uri);
-		g_free (buffer);
-		return GNOME_Evolution_ShellComponentListener_PERMISSION_DENIED;
+	if (priv->source_list != NULL) {
+		g_object_unref (priv->source_list);
+		priv->source_list = NULL;
 	}
 
-	if (remove_source) {
-		char *text_uri;
-
-		/* Sigh, we have to do this as there is no gnome_vfs_unlink_uri(). :-(  */
-
-		text_uri = gnome_vfs_uri_to_string (src_uri, GNOME_VFS_URI_HIDE_NONE);
-		result = gnome_vfs_unlink (text_uri);
-		g_free (text_uri);
+	if (priv->gconf_client != NULL) {
+		g_object_unref (priv->gconf_client);
+		priv->gconf_client = NULL;
 	}
 
-	gnome_vfs_close (hin);
-	gnome_vfs_close (hout);
-	gnome_vfs_uri_unref (src_uri);
-	gnome_vfs_uri_unref (dest_uri);
-	g_free (buffer);
-
-	return GNOME_Evolution_ShellComponentListener_OK;
+	(* G_OBJECT_CLASS (parent_class)->dispose) (object);
 }
 
 static void
-xfer_folder (EvolutionShellComponent *shell_component,
-	     const char *source_physical_uri,
-	     const char *destination_physical_uri,
-	     const char *type,
-	     gboolean remove_source,
-	     const GNOME_Evolution_ShellComponentListener listener,
-	     void *closure)
+impl_finalize (GObject *object)
 {
-	CORBA_Environment ev;
-	GnomeVFSURI *src_uri;
-	GnomeVFSURI *dest_uri;
-	GnomeVFSResult result;
-	char *filename, *backup_filename;
-
-	CORBA_exception_init (&ev);
-
-	/* check type */
-	if (!type_is_calendar (type) && !type_is_tasks (type)) {
-		GNOME_Evolution_ShellComponentListener_notifyResult (
-			listener,
-			GNOME_Evolution_ShellComponentListener_UNSUPPORTED_TYPE,
-			&ev);
-		CORBA_exception_free (&ev);
-		return;
-	}
-
-	/* check URIs */
-	src_uri = gnome_vfs_uri_new (source_physical_uri);
-	dest_uri = gnome_vfs_uri_new (destination_physical_uri);
-	if (!src_uri || ! dest_uri) {
-		GNOME_Evolution_ShellComponentListener_notifyResult (
-			listener,
-			GNOME_Evolution_ShellComponentListener_INVALID_URI,
-			&ev);
-		gnome_vfs_uri_unref (src_uri);
-		gnome_vfs_uri_unref (dest_uri);
-		CORBA_exception_free (&ev);
-		return;
-	}
-
-	if (type_is_calendar (type)) {
-		filename = "calendar.ics";
-		backup_filename = "calendar.ics~";
-	} else if (type_is_tasks (type)) {
-		filename = "tasks.ics";
-		backup_filename = "tasks.ics~";
-	} else {
-		g_assert_not_reached ();
-		return;
-	}
-
-	result = xfer_file (src_uri, dest_uri, filename, remove_source);
-	if (result == GNOME_Evolution_ShellComponentListener_OK)
-		result = xfer_file (src_uri, dest_uri, backup_filename, remove_source);
-	
-	GNOME_Evolution_ShellComponentListener_notifyResult (listener, result, &ev);
+	CalendarComponentPrivate *priv = CALENDAR_COMPONENT (object)->priv;
 
-	gnome_vfs_uri_unref (src_uri);
-	gnome_vfs_uri_unref (dest_uri);
+	g_free (priv->config_directory);
+	g_free (priv);
 
-        CORBA_exception_free (&ev);	
+	(* G_OBJECT_CLASS (parent_class)->finalize) (object);
 }
 
-static gboolean
-request_quit (EvolutionShellComponent *shell_component, void *closure)
-{
-	return e_comp_editor_registry_close_all (comp_editor_registry);
-}
 
-static void
-owner_set_cb (EvolutionShellComponent *shell_component,
-	      EvolutionShellClient *shell_client,
-	      const char *evolution_homedir,
-	      gpointer user_data)
-{
-	if (evolution_dir)
-		g_free (evolution_dir);
-	evolution_dir = g_strdup (evolution_homedir);
-	global_shell_client = shell_client;
-}
+/* Evolution::Component CORBA methods.  */
 
 static void
-owner_unset_cb (EvolutionShellComponent *shell_component,
-		gpointer user_data)
+impl_createControls (PortableServer_Servant servant,
+		     Bonobo_Control *corba_sidebar_control,
+		     Bonobo_Control *corba_view_control,
+		     CORBA_Environment *ev)
 {
-	global_shell_client = NULL;
-}
+	CalendarComponent *calendar_component = CALENDAR_COMPONENT (bonobo_object_from_servant (servant));
+	GtkWidget *selector;
+	GtkWidget *selector_scrolled_window;
+	BonoboControl *sidebar_control;
+	BonoboControl *view_control;
 
-/* Computes the final URI for a calendar component */
-static char *
-get_data_uri (const char *uri, CalComponentVType vtype)
-{
-	if (uri) {
-		if (*uri != '/' && strncmp (uri, "file:", 5) != 0)
-			return g_strdup (uri);
-
-		if (vtype == CAL_COMPONENT_EVENT)
-			return cal_util_expand_uri ((char *) uri, FALSE);
-		else if (vtype == CAL_COMPONENT_TODO)
-			return cal_util_expand_uri ((char *) uri, TRUE);
-		else
-			g_assert_not_reached ();
-	} else {
-		if (vtype == CAL_COMPONENT_EVENT)
-			return g_concat_dir_and_file (g_get_home_dir (),
-						      "evolution/local/Calendar/calendar.ics");
-		else if (vtype == CAL_COMPONENT_TODO)
-			return g_concat_dir_and_file (g_get_home_dir (),
-						      "evolution/local/Tasks/tasks.ics");
-		else
-			g_assert_not_reached ();
-	}
+	selector = e_source_selector_new (calendar_component->priv->source_list);
+	gtk_widget_show (selector);
 
-	return NULL;
-}
+	selector_scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+	gtk_container_add (GTK_CONTAINER (selector_scrolled_window), selector);
+	gtk_widget_show (selector_scrolled_window);
 
-/* Creates a calendar component at a specified URI.  If the URI is NULL then it
- * uses the default folder for that type of component.
- */
-static void
-create_component (const char *uri, GNOME_Evolution_Calendar_CompEditorFactory_CompEditorMode type)
-{
-	char *real_uri;
-	CORBA_Environment ev;
-	GNOME_Evolution_Calendar_CompEditorFactory factory;
-	CalComponentVType vtype;
-
-	switch (type) {
-	case GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_EVENT:
-	case GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_ALLDAY_EVENT:
-	case GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_MEETING:
-		vtype = CAL_COMPONENT_EVENT;
-		break;
-	case GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_TODO:
-		vtype = CAL_COMPONENT_TODO;
-		break;
-	default:
-		g_assert_not_reached ();
-		return;
-	}
+	sidebar_control = bonobo_control_new (selector_scrolled_window);
 
-	real_uri = get_data_uri (uri, vtype);
+	view_control = control_factory_new_control ();
 
-	/* Get the factory */
+	g_signal_connect_object (selector, "selection_changed",
+				 G_CALLBACK (source_selection_changed_callback), 
+				 G_OBJECT (view_control), 0);
+	g_signal_connect_object (selector, "primary_selection_changed",
+				 G_CALLBACK (primary_source_selection_changed_callback), 
+				 G_OBJECT (view_control), 0);
 
-	CORBA_exception_init (&ev);
-	factory = bonobo_activation_activate_from_id ("OAFIID:GNOME_Evolution_Calendar_CompEditorFactory",
-						      0, NULL, &ev);
+	load_uri_for_selection (E_SOURCE_SELECTOR (selector), view_control);
 
-	if (BONOBO_EX (&ev)) {
-		g_message ("create_component(): Could not activate the component editor factory");
-		CORBA_exception_free (&ev);
-		g_free (real_uri);
-		return;
-	}
-	CORBA_exception_free (&ev);
+	*corba_sidebar_control = CORBA_Object_duplicate (BONOBO_OBJREF (sidebar_control), ev);
+	*corba_view_control = CORBA_Object_duplicate (BONOBO_OBJREF (view_control), ev);
+}
 
-	/* Create the item */
 
-	CORBA_exception_init (&ev);
-	GNOME_Evolution_Calendar_CompEditorFactory_editNew (factory, real_uri, type, &ev);
+/* Initialization.  */
 
-	if (BONOBO_EX (&ev))
-		g_message ("create_component(): Exception while creating the component");
+static void
+calendar_component_class_init (CalendarComponentClass *class)
+{
+	POA_GNOME_Evolution_Component__epv *epv = &class->epv;
+	GObjectClass *object_class = G_OBJECT_CLASS (class);
 
-	CORBA_exception_free (&ev);
-	g_free (real_uri);
+	parent_class = g_type_class_peek_parent (class);
 
-	/* Get rid of the factory */
+	epv->createControls = impl_createControls;
 
-	CORBA_exception_init (&ev);
-	bonobo_object_release_unref (factory, &ev);
-	if (BONOBO_EX (&ev))
-		g_message ("create_component(): Could not unref the calendar component factory");
+	object_class->dispose = impl_dispose;
+	object_class->finalize = impl_finalize;
 
-	CORBA_exception_free (&ev);
+	epv->createControls = impl_createControls;
 }
 
-/* Callback used when we must create a user-creatable item */
 static void
-sc_user_create_new_item_cb (EvolutionShellComponent *shell_component,
-			    const char *id,
-			    const char *parent_folder_physical_uri,
-			    const char *parent_folder_type)
+calendar_component_init (CalendarComponent *component)
 {
-	char *tmp_uri;
-
-	if (strcmp (id, CREATE_EVENT_ID) == 0) {
-		if (type_is_calendar (parent_folder_type))
-			create_component (parent_folder_physical_uri, 
-					  GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_EVENT);
-		else {
-			tmp_uri = calendar_config_default_calendar_folder ();
-			create_component (tmp_uri,
-					  GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_EVENT);
-			g_free (tmp_uri);
-		}
- 	} else if (strcmp (id, CREATE_ALLDAY_EVENT_ID) == 0) {
-		if (type_is_calendar (parent_folder_type))
-			create_component (parent_folder_physical_uri, 
-					  GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_ALLDAY_EVENT);
-		else {
-			tmp_uri = calendar_config_default_calendar_folder ();
-			create_component (tmp_uri,
-					  GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_ALLDAY_EVENT);
-			g_free (tmp_uri);
-		}
-	} else if (strcmp (id, CREATE_MEETING_ID) == 0) {
-		if (type_is_calendar (parent_folder_type))
-			create_component (parent_folder_physical_uri,
-					  GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_MEETING);
-		else {
-			tmp_uri = calendar_config_default_calendar_folder ();
-			create_component (tmp_uri,
-					  GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_MEETING);
-			g_free (tmp_uri);
+	CalendarComponentPrivate *priv;
+	GSList *groups;
+
+	priv = g_new0 (CalendarComponentPrivate, 1);
+
+	priv->config_directory = g_build_filename (g_get_home_dir (),
+						   ".evolution", "calendar", "config",
+						   NULL);
+
+	/* EPFIXME: Should use a custom one instead?  Also we should add
+	 * calendar_component_peek_gconf_client().  */
+	priv->gconf_client = gconf_client_get_default ();
+
+	priv->source_list = e_source_list_new_for_gconf (priv->gconf_client,
+							 "/apps/evolution/calendar/sources");
+
+	/* create default calendars if there are no groups */
+	groups = e_source_list_peek_groups (priv->source_list);
+	if (!groups) {
+		ESourceGroup *group;
+		ESource *source;
+		char *base_uri, *new_dir;
+
+		/* create the source group */
+		base_uri = g_build_filename (g_get_home_dir (),
+					     "/.evolution/calendar/local/OnThisComputer/",
+					     NULL);
+		group = e_source_group_new (_("On This Computer"), base_uri);
+		e_source_list_add_group (priv->source_list, group, -1);
+
+		/* migrate calendars from older setup */
+		if (!migrate_old_calendars (group)) {
+			/* create default calendars */
+			new_dir = g_build_filename (base_uri, "Personal/", NULL);
+			if (!e_mkdir_hier (new_dir, 0700)) {
+				source = e_source_new (_("Personal"), "Personal");
+				e_source_group_add_source (group, source, -1);
+			}
+			g_free (new_dir);
+
+			new_dir = g_build_filename (base_uri, "Work/", NULL);
+			if (!e_mkdir_hier (new_dir, 0700)) {
+				source = e_source_new (_("Work"), "Work");
+				e_source_group_add_source (group, source, -1);
+			}
+			g_free (new_dir);
 		}
-	} else if (strcmp (id, CREATE_TASK_ID) == 0) {
-		if (type_is_tasks (parent_folder_type))
-			create_component (parent_folder_physical_uri,
-					  GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_TODO);
-		else {
-			tmp_uri = calendar_config_default_tasks_folder ();
-			create_component (tmp_uri, 
-					  GNOME_Evolution_Calendar_CompEditorFactory_EDITOR_MODE_TODO);
-			g_free (tmp_uri);
-		}
-	} else
-		g_assert_not_reached ();
-}
 
-
-/* The factory function.  */
-
-static void
-add_creatable_item (EvolutionShellComponent *shell_component,
-		    const char *id,
-		    const char *description,
-		    const char *menu_description,
-		    const char *tooltip,
-		    const char *folder_type,
-		    char menu_shortcut,
-		    const char *icon_name)
-{
-	char *icon_path;
-	GdkPixbuf *icon;
-
-	if (icon_name == NULL) {
-		icon_path = NULL;
-		icon = NULL;
-	} else {
-		icon_path = g_concat_dir_and_file (EVOLUTION_IMAGESDIR, icon_name);
-		icon = gdk_pixbuf_new_from_file (icon_path, NULL);
+		g_free (base_uri);
 	}
 
-	evolution_shell_component_add_user_creatable_item (shell_component,
-							   id,
-							   description,
-							   menu_description,
-							   tooltip,
-							   folder_type,
-							   menu_shortcut,
-							   icon);
-
-	if (icon != NULL)
-		gdk_pixbuf_unref (icon);
-	g_free (icon_path);
+	component->priv = priv;
 }
 
-static BonoboObject *
-create_object (void)
-{
-	EvolutionShellComponent *shell_component;
-	CalendarOfflineHandler *offline_handler;	
-
-	shell_component = evolution_shell_component_new (folder_types,
-							 NULL,
-							 create_view,
-							 create_folder,
-							 remove_folder,
-							 xfer_folder,
-							 NULL, /* populate_folder_context_menu_fn */
-							 NULL, /* unpopulate_folder_context_menu_fn */
-							 NULL, /* get_dnd_selection_fn */
-							 request_quit,
-							 NULL  /* closure */);
-
-	/* Offline handler */
-	offline_handler = calendar_offline_handler_new ();
-	bonobo_object_add_interface (BONOBO_OBJECT (shell_component), 
-				     BONOBO_OBJECT (offline_handler));
-	
-	g_signal_connect (shell_component, "owner_set", G_CALLBACK (owner_set_cb), NULL);
-	g_signal_connect (shell_component, "owner_unset", G_CALLBACK (owner_unset_cb), NULL);
-
-	/* User creatable items */
 
-	add_creatable_item (shell_component, CREATE_EVENT_ID,
-			    _("New appointment"), _("_Appointment"),
-			    _("Create a new appointment"),
-			    FOLDER_CALENDAR, 'a', "new_appointment.xpm");
+/* Public API.  */
 
-	add_creatable_item (shell_component, CREATE_MEETING_ID,
-			    _("New meeting"), _("M_eeting"),
-			    _("Create a new meeting request"),
-			    FOLDER_CALENDAR, 'e', "meeting-request-16.png");
-
-	add_creatable_item (shell_component, CREATE_TASK_ID,
-			    _("New task"), _("_Task"),
-			    _("Create a new task"),
-			    FOLDER_TASKS, 't', "new_task-16.png");
+CalendarComponent *
+calendar_component_peek (void)
+{
+	static CalendarComponent *component = NULL;
 
-	add_creatable_item (shell_component, CREATE_ALLDAY_EVENT_ID,
-			    _("New All Day Appointment"), _("All _Day Appointment"),
-			    _("Create a new all-day appointment"),
-			    FOLDER_CALENDAR, 'd', "new_all_day_event.png");
+	if (component == NULL) {
+		component = g_object_new (calendar_component_get_type (), NULL);
 
-	g_signal_connect (shell_component, "user_create_new_item",
-			  G_CALLBACK (sc_user_create_new_item_cb), NULL);
+		if (e_mkdir_hier (calendar_component_peek_config_directory (component), 0777) != 0) {
+			g_warning ("Cannot create directory %s: %s",
+				   calendar_component_peek_config_directory (component),
+				   g_strerror (errno));
+			g_object_unref (component);
+			component = NULL;
+		}
+	}
 
-	return BONOBO_OBJECT (shell_component);
+	return component;
 }
 
-
-BonoboObject *
-calendar_component_get_object (void)
+const char *
+calendar_component_peek_config_directory (CalendarComponent *component)
 {
-	static BonoboObject *object = NULL;
+	return component->priv->config_directory;
+}
 
-	if (object != NULL) {
-		bonobo_object_ref (BONOBO_OBJECT (object));
-	} else {
-		object = create_object ();
-		g_object_add_weak_pointer (G_OBJECT (object), (void *) &object);
-	}
 
-	return object;
-}
+BONOBO_TYPE_FUNC_FULL (CalendarComponent, GNOME_Evolution_Component, PARENT_TYPE, calendar_component)
diff --git a/calendar/gui/calendar-component.h b/calendar/gui/calendar-component.h
index 2d94920adc..96630add5f 100644
--- a/calendar/gui/calendar-component.h
+++ b/calendar/gui/calendar-component.h
@@ -1,7 +1,7 @@
 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* component-factory.h
+/* calendar-component.h
  *
- * Copyright (C) 2000, 2001, 2002, 2003  Ximian, Inc.
+ * Copyright (C) 2003  Ettore Perazzoli
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
@@ -20,13 +20,47 @@
  * Author: Ettore Perazzoli <ettore@ximian.com>
  */
 
-#ifndef _COMPONENT_FACTORY_H_
-#define _COMPONENT_FACTORY_H_
+#ifndef _CALENDAR_COMPONENT_H_
+#define _CALENDAR_COMPONENT_H_
+
 
 #include <bonobo/bonobo-object.h>
 
-extern char *evolution_dir;
+#include "Evolution.h"
+#include "e-util/e-source-list.h"
+
+
+#define CALENDAR_TYPE_COMPONENT			(calendar_component_get_type ())
+#define CALENDAR_COMPONENT(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), CALENDAR_TYPE_COMPONENT, CalendarComponent))
+#define CALENDAR_COMPONENT_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), CALENDAR_TYPE_COMPONENT, CalendarComponentClass))
+#define CALENDAR_IS_COMPONENT(obj)			(G_TYPE_CHECK_INSTANCE_TYPE ((obj), CALENDAR_TYPE_COMPONENT))
+#define CALENDAR_IS_COMPONENT_CLASS(klass)		(G_TYPE_CHECK_CLASS_TYPE ((obj), CALENDAR_TYPE_COMPONENT))
+
+
+typedef struct _CalendarComponent        CalendarComponent;
+typedef struct _CalendarComponentPrivate CalendarComponentPrivate;
+typedef struct _CalendarComponentClass   CalendarComponentClass;
+
+struct _CalendarComponent {
+	BonoboObject parent;
+
+	CalendarComponentPrivate *priv;
+};
+
+struct _CalendarComponentClass {
+	BonoboObjectClass parent_class;
+
+	POA_GNOME_Evolution_Component__epv epv;
+};
+
+
+GType calendar_component_get_type  (void);
+
+CalendarComponent *calendar_component_peek  (void);
+
+const char *calendar_component_peek_config_directory  (CalendarComponent *component);
+
+ESourceList *calendar_component_peek_source_list (CalendarComponent *component);
 
-BonoboObject *calendar_component_get_object (void);
 
-#endif /* _COMPONENT_FACTORY_H_ */
+#endif /* _CALENDAR_COMPONENT_H_ */
diff --git a/calendar/gui/calendar-offline-handler.c b/calendar/gui/calendar-offline-handler.c
index 458f951d9a..ff30299746 100644
--- a/calendar/gui/calendar-offline-handler.c
+++ b/calendar/gui/calendar-offline-handler.c
@@ -29,6 +29,7 @@
 #include <gtk/gtkmain.h>
 #include <gtk/gtksignal.h>
 #include <bonobo/bonobo-exception.h>
+#include <bonobo/bonobo-i18n.h>
 #include <gal/util/e-util.h>
 #include "e-util/e-url.h"
 #include <cal-client/cal-client.h>
@@ -180,13 +181,16 @@ backend_go_offline (gpointer data, gpointer user_data)
 	char *uri = data;
 	CalClient *client;
 	gboolean success;
+	GError *error = NULL;
 	
-	client = cal_client_new ();
+	client = cal_client_new (uri, CALOBJ_TYPE_ANY);
 	g_signal_connect (client, "cal_opened", G_CALLBACK (backend_cal_opened_offline), offline_handler);
-	success = cal_client_open_calendar (client, uri, TRUE);
+	success = cal_client_open (client, TRUE, &error);
 	if (!success) {
+		g_warning (_("backend_go_offline(): %s"), error->message);
 		update_offline (offline_handler);
 		g_object_unref (client);
+		g_error_free (error);
 		return;		
 	}
 }
@@ -198,13 +202,16 @@ backend_go_online (gpointer data, gpointer user_data)
 	char *uri = data;
 	CalClient *client;
 	gboolean success;
+	GError *error = NULL;
 	
-	client = cal_client_new ();
+	client = cal_client_new (uri, CALOBJ_TYPE_ANY);
 	g_signal_connect (G_OBJECT (client), "cal_opened", 
 			  G_CALLBACK (backend_cal_opened_online), offline_handler);
-	success = cal_client_open_calendar (client, uri, TRUE);
+	success = cal_client_open (client, TRUE, &error);
 	if (!success) {
+		g_warning (_("backend_go_online(): %s"), error->message);
 		g_object_unref (G_OBJECT (client));
+		g_error_free (error);
 		return;		
 	}	
 }
@@ -319,7 +326,8 @@ calendar_offline_handler_init (CalendarOfflineHandler *offline_handler)
 	priv = g_new (CalendarOfflineHandlerPrivate, 1);
 	offline_handler->priv = priv;
 
-	priv->client = cal_client_new ();
+	/* FIXME: what URI to use? */
+	priv->client = cal_client_new ("", CALOBJ_TYPE_ANY);
 	priv->listener_interface = CORBA_OBJECT_NIL;
 	priv->is_offline = FALSE;
 }
diff --git a/calendar/gui/comp-editor-factory.c b/calendar/gui/comp-editor-factory.c
index f76e0d4f03..7b7dcb4c87 100644
--- a/calendar/gui/comp-editor-factory.c
+++ b/calendar/gui/comp-editor-factory.c
@@ -241,39 +241,26 @@ edit_existing (OpenClient *oc, const char *uid)
 {
 	CalComponent *comp;
 	icalcomponent *icalcomp;
-	CalClientGetStatus status;
 	CompEditor *editor;
 	CalComponentVType vtype;
 
 	g_assert (oc->open);
 
 	/* Get the object */
+	if (!cal_client_get_object (oc->client, uid, NULL, &icalcomp, NULL)) {
+		/* FIXME Better error handling */
+		g_warning (G_STRLOC ": Syntax error while getting component `%s'", uid);
 
-	status = cal_client_get_object (oc->client, uid, &icalcomp);
-
-	switch (status) {
-	case CAL_CLIENT_GET_SUCCESS:
-		comp = cal_component_new ();
-		if (!cal_component_set_icalcomponent (comp, icalcomp)) {
-			g_object_unref (comp);
-			icalcomponent_free (icalcomp);
-			return;
-		}
-		break;
-
-	case CAL_CLIENT_GET_NOT_FOUND:
-		/* The object disappeared from the server */
-		return;
-
-	case CAL_CLIENT_GET_SYNTAX_ERROR:
-		g_message ("edit_exiting(): Syntax error while getting component `%s'", uid);
 		return;
-
-	default:
-		g_assert_not_reached ();
+	}
+	
+	comp = cal_component_new ();
+	if (!cal_component_set_icalcomponent (comp, icalcomp)) {
+		g_object_unref (comp);
+		icalcomponent_free (icalcomp);
 		return;
 	}
-
+	
 	/* Create the appropriate type of editor */
 	
 	vtype = cal_component_get_vtype (comp);
@@ -405,13 +392,15 @@ resolve_pending_requests (OpenClient *oc)
 	factory = oc->factory;
 	priv = factory->priv;
 
-	g_assert (oc->pending != NULL);
+	if (!oc->pending)
+		return;
 
 	/* Set the default timezone in the backend. */
 	location = calendar_config_get_timezone ();
 	zone = icaltimezone_get_builtin_timezone (location);
 	if (zone)
-		cal_client_set_default_timezone (oc->client, zone);
+		/* FIXME Error handling? */
+		cal_client_set_default_timezone (oc->client, zone, NULL);
 
 	for (l = oc->pending; l; l = l->next) {
 		Request *request;
@@ -501,10 +490,11 @@ open_client (CompEditorFactory *factory, const char *uristr)
 	CompEditorFactoryPrivate *priv;
 	CalClient *client;
 	OpenClient *oc;
+	GError *error = NULL;
 
 	priv = factory->priv;
 
-	client = cal_client_new ();
+	client = cal_client_new (uristr, CALOBJ_TYPE_ANY);
 	if (!client)
 		return NULL;
 
@@ -522,10 +512,12 @@ open_client (CompEditorFactory *factory, const char *uristr)
 
 	g_hash_table_insert (priv->uri_client_hash, oc->uri, oc);
 
-	if (!cal_client_open_calendar (oc->client, uristr, FALSE)) {
+	if (!cal_client_open (oc->client, FALSE, &error)) {
+		g_warning (_("open_client(): %s"), error->message);
 		g_free (oc->uri);
 		g_object_unref (oc->client);
 		g_free (oc);
+		g_error_free (error);
 
 		return NULL;
 	}
diff --git a/calendar/gui/comp-util.c b/calendar/gui/comp-util.c
index 28bc66bd54..aceff667c2 100644
--- a/calendar/gui/comp-util.c
+++ b/calendar/gui/comp-util.c
@@ -95,7 +95,6 @@ cal_comp_util_compare_event_timezones (CalComponent *comp,
 				       CalClient *client,
 				       icaltimezone *zone)
 {
-	CalClientGetStatus status;
 	CalComponentDateTime start_datetime, end_datetime;
 	const char *tzid;
 	gboolean retval = FALSE;
@@ -143,10 +142,8 @@ cal_comp_util_compare_event_timezones (CalComponent *comp,
 		/* If the TZIDs differ, we have to compare the UTC offsets
 		   of the start and end times, using their own timezones and
 		   the given timezone. */
-		status = cal_client_get_timezone (client,
-						  start_datetime.tzid,
-						  &start_zone);
-		if (status != CAL_CLIENT_GET_SUCCESS)
+		if (!cal_client_get_timezone (client, start_datetime.tzid,
+					      &start_zone, NULL))
 			goto out;
 
 		if (start_datetime.value) {
@@ -160,10 +157,8 @@ cal_comp_util_compare_event_timezones (CalComponent *comp,
 				goto out;
 		}
 
-		status = cal_client_get_timezone (client,
-						  end_datetime.tzid,
-						  &end_zone);
-		if (status != CAL_CLIENT_GET_SUCCESS)
+		if (!cal_client_get_timezone (client, end_datetime.tzid,
+					      &end_zone, NULL))
 			goto out;
 
 		if (end_datetime.value) {
@@ -210,8 +205,8 @@ gboolean
 cal_comp_is_on_server (CalComponent *comp, CalClient *client)
 {
 	const char *uid;
-	CalClientGetStatus status;
 	icalcomponent *icalcomp;
+	GError *error = NULL;
 
 	g_return_val_if_fail (comp != NULL, FALSE);
 	g_return_val_if_fail (IS_CAL_COMPONENT (comp), FALSE);
@@ -226,24 +221,15 @@ cal_comp_is_on_server (CalComponent *comp, CalClient *client)
 	 */
 	cal_component_get_uid (comp, &uid);
 
-	status = cal_client_get_object (client, uid, &icalcomp);
-
-	switch (status) {
-	case CAL_CLIENT_GET_SUCCESS:
+	if (cal_client_get_object (client, uid, NULL, &icalcomp, &error)) {
 		icalcomponent_free (icalcomp);
-		return TRUE;
 
-	case CAL_CLIENT_GET_SYNTAX_ERROR:
-		g_message ("confirm_delete_empty_appointment(): Syntax error when getting "
-			   "object `%s'",
-			   uid);
 		return TRUE;
+	}
 
-	case CAL_CLIENT_GET_NOT_FOUND:
-		return FALSE;
-
-	default:
-		g_assert_not_reached ();
+	if (error) {
+		g_warning ("cal_comp_is_on_server(): %s", error->message);
+		g_error_free (error);
 	}
 	
 	return FALSE;
@@ -268,7 +254,7 @@ cal_comp_event_new_with_defaults (CalClient *client)
 	icalproperty *icalprop;
 	CalAlarmTrigger trigger;
 
-	if (cal_client_get_default_object (client, CALOBJ_TYPE_EVENT, &icalcomp) != CAL_CLIENT_GET_SUCCESS)
+	if (!cal_client_get_default_object (client, &icalcomp, NULL))
 		return NULL;
 
 	comp = cal_component_new ();
@@ -334,8 +320,16 @@ cal_comp_task_new_with_defaults (CalClient *client)
 	CalComponent *comp;
 	icalcomponent *icalcomp;
 
-	if (cal_client_get_default_object (client, CALOBJ_TYPE_TODO, &icalcomp) != CAL_CLIENT_GET_SUCCESS)
+	if (!cal_client_get_default_object (client, &icalcomp, NULL))
+		return NULL;
+
+	comp = cal_component_new ();
+	if (!cal_component_set_icalcomponent (comp, icalcomp)) {
+		g_object_unref (comp);
+		icalcomponent_free (icalcomp);
+
 		return NULL;
+	}
 
 	comp = cal_component_new ();
 	if (!cal_component_set_icalcomponent (comp, icalcomp)) {
diff --git a/calendar/gui/control-factory.c b/calendar/gui/control-factory.c
index 191a8d85ea..7adc5e83df 100644
--- a/calendar/gui/control-factory.c
+++ b/calendar/gui/control-factory.c
@@ -69,8 +69,11 @@ get_prop (BonoboPropertyBag *bag,
 	  CORBA_Environment *ev,
 	  gpointer           user_data)
 {
-	GnomeCalendar *gcal = user_data;
+	GnomeCalendar *gcal;
 	const char *uri;
+	BonoboControl *control = user_data;
+
+	gcal = (GnomeCalendar *) bonobo_control_get_widget (control);
 
 	switch (arg_id) {
 
@@ -96,6 +99,7 @@ get_prop (BonoboPropertyBag *bag,
 		case GNOME_CAL_LIST_VIEW:
 			BONOBO_ARG_SET_STRING (arg, "list");
 			break;
+		default:
 		}
 		break;
 
@@ -104,7 +108,6 @@ get_prop (BonoboPropertyBag *bag,
 	}
 }
 
-
 static void
 set_prop (BonoboPropertyBag *bag,
 	  const BonoboArg   *arg,
@@ -112,14 +115,19 @@ set_prop (BonoboPropertyBag *bag,
 	  CORBA_Environment *ev,
 	  gpointer           user_data)
 {
-	GnomeCalendar *gcal = user_data;
+	GnomeCalendar *gcal;
 	char *string;
 	GnomeCalendarViewType view;
+	BonoboControl *control = user_data;
+
+	gcal = (GnomeCalendar *) bonobo_control_get_widget (control);
 
 	switch (arg_id) {
 	case PROPERTY_CALENDAR_URI_IDX:
 		string = BONOBO_ARG_GET_STRING (arg);
-		if (!gnome_calendar_open (gcal, string)) {
+		if (gnome_calendar_add_event_uri (gcal, string)) {
+			calendar_control_sensitize_calendar_commands (control, gcal, TRUE);
+		} else {
 			char *msg;
 
 			msg = g_strdup_printf (_("Could not open the folder in '%s'"), string);
@@ -161,7 +169,7 @@ calendar_properties_init (GnomeCalendar *gcal, BonoboControl *control)
 {
 	BonoboPropertyBag *pbag;
 
-	pbag = bonobo_property_bag_new (get_prop, set_prop, gcal);
+	pbag = bonobo_property_bag_new (get_prop, set_prop, control);
 
 	bonobo_property_bag_add (pbag,
 				 PROPERTY_CALENDAR_URI,
diff --git a/calendar/gui/control-factory.h b/calendar/gui/control-factory.h
index f599f7b3b8..bab1611c03 100644
--- a/calendar/gui/control-factory.h
+++ b/calendar/gui/control-factory.h
@@ -23,6 +23,8 @@
 #ifndef _CONTROL_FACTORY_H_
 #define _CONTROL_FACTORY_H_
 
+#include <bonobo/bonobo-control.h>
+
 BonoboControl *control_factory_new_control  (void);
 
 #endif /* _CONTROL_FACTORY_H_ */
diff --git a/calendar/gui/dialogs/Makefile.am b/calendar/gui/dialogs/Makefile.am
index 2466ffaa14..84424f8cc0 100644
--- a/calendar/gui/dialogs/Makefile.am
+++ b/calendar/gui/dialogs/Makefile.am
@@ -61,6 +61,8 @@ libcal_dialogs_la_SOURCES =	\
 	event-page.h		\
 	meeting-page.c		\
 	meeting-page.h		\
+	new-calendar.c		\
+	new-calendar.h		\
 	recurrence-page.c	\
 	recurrence-page.h	\
 	recur-comp.c		\
@@ -85,6 +87,7 @@ glade_DATA =				\
 	e-delegate-dialog.glade		\
 	event-page.glade		\
 	meeting-page.glade		\
+	new-calendar.glade		\
 	recurrence-page.glade		\
 	schedule-page.glade		\
 	task-details-page.glade		\
diff --git a/calendar/gui/dialogs/alarm-options.c b/calendar/gui/dialogs/alarm-options.c
index ef13b78b13..b105dc3c23 100644
--- a/calendar/gui/dialogs/alarm-options.c
+++ b/calendar/gui/dialogs/alarm-options.c
@@ -39,7 +39,7 @@
 #include <bonobo/bonobo-widget.h>
 #include <libgnomeui/gnome-file-entry.h>
 #include <glade/glade.h>
-#include <ebook/e-destination.h>
+#include <addressbook/util/eab-destination.h>
 #include "Evolution-Addressbook-SelectNames.h"
 #include "e-util/e-dialog-widgets.h"
 #include "alarm-options.h"
@@ -307,7 +307,7 @@ alarm_to_malarm_widgets (Dialog *dialog, CalComponentAlarm *alarm)
 	CalComponentText description;
 	GtkTextBuffer *text_buffer;	
 	GSList *attendee_list, *l;
-	EDestination **destv;
+	EABDestination **destv;
 	int len, i;
 	
 	/* Recipients */
@@ -315,22 +315,22 @@ alarm_to_malarm_widgets (Dialog *dialog, CalComponentAlarm *alarm)
 	len = g_slist_length (attendee_list);
 
 	if (len <= 0) {
-		destv = g_new0 (EDestination *, 2);
-		destv[0] = e_destination_new ();
-		e_destination_set_email (destv[0], dialog->email);
+		destv = g_new0 (EABDestination *, 2);
+		destv[0] = eab_destination_new ();
+		eab_destination_set_email (destv[0], dialog->email);
 		destv[1] = NULL;
 		len = 1;
 	} else {
-		destv = g_new0 (EDestination *, len + 1);
+		destv = g_new0 (EABDestination *, len + 1);
 		for (l = attendee_list, i = 0; l != NULL; l = l->next, i++) {
 			CalComponentAttendee *a = l->data;
-			EDestination *dest;
+			EABDestination *dest;
 			
-			dest = e_destination_new ();
+			dest = eab_destination_new ();
 			if (a->cn != NULL && *a->cn)
-				e_destination_set_name (dest, a->cn);
+				eab_destination_set_name (dest, a->cn);
 			if (a->value != NULL && *a->value)
-				e_destination_set_email (dest, a->value);
+				eab_destination_set_email (dest, a->value);
 			
 			destv[i] = dest;
 		}
@@ -338,7 +338,7 @@ alarm_to_malarm_widgets (Dialog *dialog, CalComponentAlarm *alarm)
 	}
 	
 	bonobo_widget_set_property (BONOBO_WIDGET (dialog->malarm_addresses), 
-				    "destinations", e_destination_exportv (destv), NULL);
+				    "destinations", eab_destination_exportv (destv), NULL);
 
 	for (i = 0; i < len; i++)
 		g_object_unref (GTK_OBJECT (destv[i]));
@@ -617,7 +617,7 @@ malarm_widgets_to_alarm (Dialog *dialog, CalComponentAlarm *alarm)
 	char *str;
 	CalComponentText description;
 	GSList *attendee_list = NULL;
-	EDestination **destv;
+	EABDestination **destv;
 	GtkTextBuffer *text_buffer;
 	GtkTextIter text_iter_start, text_iter_end;
 	icalcomponent *icalcomp;
@@ -627,18 +627,18 @@ malarm_widgets_to_alarm (Dialog *dialog, CalComponentAlarm *alarm)
 	/* Attendees */
 	bonobo_widget_get_property (BONOBO_WIDGET (dialog->malarm_addresses), "destinations", 
 				    TC_CORBA_string, &str, NULL);
-	destv = e_destination_importv (str);
+	destv = eab_destination_importv (str);
 	g_free (str);
 	
 	for (i = 0; destv[i] != NULL; i++) {
-		EDestination *dest;
+		EABDestination *dest;
 		CalComponentAttendee *a;
 
 		dest = destv[i];
 		
 		a = g_new0 (CalComponentAttendee, 1);
-		a->value = e_destination_get_email (dest);
-		a->cn = e_destination_get_name (dest);
+		a->value = eab_destination_get_email (dest);
+		a->cn = eab_destination_get_name (dest);
 
 		attendee_list = g_slist_append (attendee_list, a);
 	}
@@ -646,7 +646,7 @@ malarm_widgets_to_alarm (Dialog *dialog, CalComponentAlarm *alarm)
 	cal_component_alarm_set_attendee_list (alarm, attendee_list);
 
 	cal_component_free_attendee_list (attendee_list);
-	e_destination_freev (destv);	
+	eab_destination_freev (destv);	
 
 	/* Description */
 	text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (dialog->dalarm_description));
diff --git a/calendar/gui/e-cal-model-calendar.c b/calendar/gui/e-cal-model-calendar.c
index 82de4e6d5a..593d342e70 100644
--- a/calendar/gui/e-cal-model-calendar.c
+++ b/calendar/gui/e-cal-model-calendar.c
@@ -129,7 +129,7 @@ get_dtend (ECalModelComponent *comp_data)
 		/* FIXME: handle errors */
 		cal_client_get_timezone (comp_data->client,
 					 icaltime_get_tzid (tt_end),
-					 &zone);
+					 &zone, NULL);
 		comp_data->dtend->zone = zone;
 	}
 
@@ -308,8 +308,12 @@ ecmc_set_value_at (ETableModel *etm, int col, int row, const void *value)
 		break;
 	}
 
-	if (cal_client_update_objects (comp_data->client, comp_data->icalcomp) != CAL_CLIENT_RESULT_SUCCESS)
-		g_message ("ecmc_set_value_at(): Could not update the object!");
+	/* FIXME ask about mod type */
+	if (!cal_client_modify_object (comp_data->client, comp_data->icalcomp, CALOBJ_MOD_ALL, NULL)) {
+		g_warning (G_STRLOC ": Could not modify the object!");
+		
+		/* FIXME Show error dialog */
+	}
 }
 
 static gboolean
diff --git a/calendar/gui/e-cal-model-tasks.c b/calendar/gui/e-cal-model-tasks.c
index 6bca52586c..76e2e140f3 100644
--- a/calendar/gui/e-cal-model-tasks.c
+++ b/calendar/gui/e-cal-model-tasks.c
@@ -223,7 +223,7 @@ get_completed (ECalModelComponent *comp_data)
 		/* FIXME: handle errors */
 		cal_client_get_timezone (comp_data->client,
 					 icaltime_get_tzid (tt_completed),
-					 &zone);
+					 &zone, NULL);
 		comp_data->completed->zone = zone;
 	}
 
@@ -253,7 +253,7 @@ get_due (ECalModelComponent *comp_data)
 		/* FIXME: handle errors */
 		cal_client_get_timezone (comp_data->client,
 					 icaltime_get_tzid (tt_due),
-					 &zone);
+					 &zone, NULL);
 		comp_data->due->zone = zone;
 	}
 
@@ -399,7 +399,7 @@ get_due_status (ECalModelTasks *model, ECalModelComponent *comp_data)
 			/* Get the current time in the same timezone as the DUE date.*/
 			status = cal_client_get_timezone (comp_data->client,
 							  icaltime_get_tzid (due_tt),
-							  &zone);
+							  &zone, NULL);
 			if (status != CAL_CLIENT_GET_SUCCESS)
 				return E_CAL_MODEL_TASKS_DUE_FUTURE;
 			
@@ -756,8 +756,12 @@ ecmt_set_value_at (ETableModel *etm, int col, int row, const void *value)
 		break;
 	}
 
-	if (cal_client_update_objects (comp_data->client, comp_data->icalcomp) != CAL_CLIENT_RESULT_SUCCESS)
-		g_message ("ecmt_set_value_at(): Could not update the object!");
+	/* FIXME ask about mod type */
+	if (!cal_client_modify_object (comp_data->client, comp_data->icalcomp, CALOBJ_MOD_ALL, NULL)) {
+		g_warning (G_STRLOC ": Could not modify the object!");
+		
+		/* FIXME Show error dialog */
+	}
 }
 
 static gboolean
diff --git a/calendar/gui/e-cal-model.c b/calendar/gui/e-cal-model.c
index 1c231f9c72..c8b706c66e 100644
--- a/calendar/gui/e-cal-model.c
+++ b/calendar/gui/e-cal-model.c
@@ -41,6 +41,9 @@ struct _ECalModelPrivate {
 	/* The list of clients we are managing. Each element is of type ECalModelClient */
 	GList *clients;
 
+	/* The default client in the list */
+	CalClient *default_client;
+	
 	/* Array for storing the objects. Each element is of type ECalModelComponent */
 	GPtrArray *objects;
 
@@ -352,7 +355,7 @@ get_dtstart (ECalModel *model, ECalModelComponent *comp_data)
 		/* FIXME: handle errors */
 		cal_client_get_timezone (comp_data->client,
 					 icaltime_get_tzid (tt_start),
-					 &zone);
+					 &zone, NULL);
 		comp_data->dtstart->zone = zone;
 	}
 
@@ -609,8 +612,12 @@ ecm_set_value_at (ETableModel *etm, int col, int row, const void *value)
 		break;
 	}
 
-	if (cal_client_update_objects (comp_data->client, comp_data->icalcomp) != CAL_CLIENT_RESULT_SUCCESS)
-		g_message ("ecm_set_value_at(): Could not update the object!");
+	/* FIXME ask about mod type */
+	if (!cal_client_modify_object (comp_data->client, comp_data->icalcomp, CALOBJ_MOD_ALL, NULL)) {
+		g_warning (G_STRLOC ": Could not modify the object!");
+		
+		/* FIXME Show error dialog */
+	}
 }
 
 static gboolean
@@ -673,7 +680,10 @@ ecm_append_row (ETableModel *etm, ETableModel *source, int row)
 		model_class->fill_component_from_model (model, &comp_data, source_model, row);
 	}
 
-	if (cal_client_update_objects (comp_data.client, comp_data.icalcomp) != CAL_CLIENT_RESULT_SUCCESS) {
+
+	if (!cal_client_create_object (comp_data.client, comp_data.icalcomp, NULL, NULL)) {
+		g_warning (G_STRLOC ": Could not create the object!");
+
 		/* FIXME: show error dialog */
 	}
 
@@ -987,46 +997,53 @@ CalClient *
 e_cal_model_get_default_client (ECalModel *model)
 {
 	ECalModelPrivate *priv;
-	GList *l;
-	gchar *default_uri = NULL;
-	EConfigListener *db;
 	ECalModelClient *client_data;
 
+	g_return_val_if_fail (model != NULL, NULL);
 	g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
-
+	
 	priv = model->priv;
 
+	/* we always return a valid CalClient, since we rely on it in many places */
+	if (priv->default_client)
+		return priv->default_client;
+
 	if (!priv->clients)
 		return NULL;
 
-	db = e_config_listener_new ();
+	client_data = (ECalModelClient *) priv->clients->data;
 
-	/* look at the configuration and return the real default calendar if we've got it loaded */
-	if (priv->kind == ICAL_VEVENT_COMPONENT)
-		default_uri = e_config_listener_get_string (db, "/apps/evolution/shell/default_folders/calendar_uri");
-	else if (priv->kind == ICAL_VTODO_COMPONENT)
-		default_uri = e_config_listener_get_string (db, "/apps/evolution/shell/default_folders/tasks_uri");
+	return client_data ? client_data->client : NULL;
+}
 
-	g_object_unref (db);
+void
+e_cal_model_set_default_client (ECalModel *model, CalClient *client)
+{
+	ECalModelPrivate *priv;
+	GList *l;
+	gboolean found = FALSE;
+	
+	g_return_if_fail (model != NULL);
+	g_return_if_fail (E_IS_CAL_MODEL (model));
+	g_return_if_fail (client != NULL);
+	g_return_if_fail (IS_CAL_CLIENT (client));
 
-	if (!default_uri) {
-		client_data = (ECalModelClient *) priv->clients->data;
-		return client_data->client;
-	}
+	priv = model->priv;
 
+	/* See if we already know about the client */
 	for (l = priv->clients; l != NULL; l = l->next) {
-		client_data = (ECalModelClient *) l->data;
+		ECalModelClient *client_data = l->data;
 
-		if (!strcmp (default_uri, cal_client_get_uri (client_data->client))) {
-			g_free (default_uri);
-			return client_data->client;
-		}
+		if (client == client_data->client)
+			found = TRUE;
 	}
 
-	g_free (default_uri);
-
-	client_data = (ECalModelClient *) priv->clients->data;
-	return client_data->client;
+	/* If its not found, add it */
+	if (!found)
+		e_cal_model_add_client (model, client);
+	
+	/* Store the default client */
+	priv->default_client = client;
 }
 
 /**
@@ -1048,6 +1065,29 @@ e_cal_model_get_client_list (ECalModel *model)
 	return list;
 }
 
+/**
+ * e_cal_model_get_client_for_uri
+ * @model: A calendar model.
+ * @uri: Uri for the client to get.
+ */
+CalClient *
+e_cal_model_get_client_for_uri (ECalModel *model, const char *uri)
+{
+	GList *l;
+
+	g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
+	g_return_val_if_fail (uri != NULL, NULL);
+
+	for (l = model->priv->clients; l != NULL; l = l->next) {
+		ECalModelClient *client_data = (ECalModelClient *) l->data;
+
+		if (!strcmp (uri, cal_client_get_uri (client_data->client)))
+			return client_data->client;
+	}
+
+	return NULL;
+}
+
 static ECalModelComponent *
 search_by_uid_and_client (ECalModelPrivate *priv, CalClient *client, const char *uid)
 {
@@ -1084,124 +1124,119 @@ get_position_in_array (GPtrArray *objects, gpointer item)
 }
 
 static void
-query_obj_updated_cb (CalQuery *query, const char *uid,
-		      gboolean query_in_progress,
-		      int n_scanned, int total,
-		      gpointer user_data)
+query_objects_added_cb (CalQuery *query, GList *objects, gpointer user_data)
 {
-	ECalModelPrivate *priv;
-	icalcomponent *new_icalcomp;
-	CalClientGetStatus status;
-	ECalModelComponent *comp_data;
-	gint pos;
 	ECalModel *model = (ECalModel *) user_data;
-
-	g_return_if_fail (E_IS_CAL_MODEL (model));
-
+	ECalModelPrivate *priv;
+	GList *l;
+	int start_row;
+	
 	priv = model->priv;
 
 	e_table_model_pre_change (E_TABLE_MODEL (model));
 
-	comp_data = search_by_uid_and_client (priv, cal_query_get_client (query), uid);
-	status = cal_client_get_object (cal_query_get_client (query), uid, &new_icalcomp);
-	switch (status) {
-	case CAL_CLIENT_GET_SUCCESS :
-		if (comp_data) {
-			if (comp_data->icalcomp)
-				icalcomponent_free (comp_data->icalcomp);
-			if (comp_data->dtstart) {
-				g_free (comp_data->dtstart);
-				comp_data->dtstart = NULL;
-			}
-			if (comp_data->dtend) {
-				g_free (comp_data->dtend);
-				comp_data->dtend = NULL;
-			}
-			if (comp_data->due) {
-				g_free (comp_data->due);
-				comp_data->due = NULL;
-			}
-			if (comp_data->completed) {
-				g_free (comp_data->completed);
-				comp_data->completed = NULL;
-			}
+	start_row = priv->objects->len ? priv->objects->len - 1 : 0;
+	
+	for (l = objects; l; l = l->next) {
+		ECalModelComponent *comp_data;
 
-			comp_data->icalcomp = new_icalcomp;
+		comp_data = g_new0 (ECalModelComponent, 1);
+		comp_data->client = cal_query_get_client (query);
+		comp_data->icalcomp = icalcomponent_new_clone (l->data);
 
-			e_table_model_row_changed (E_TABLE_MODEL (model), get_position_in_array (priv->objects, comp_data));
-		} else {
-			comp_data = g_new0 (ECalModelComponent, 1);
-			comp_data->client = cal_query_get_client (query);
-			comp_data->icalcomp = new_icalcomp;
+		g_ptr_array_add (priv->objects, comp_data);
+	}
 
-			g_ptr_array_add (priv->objects, comp_data);
-			e_table_model_row_inserted (E_TABLE_MODEL (model), priv->objects->len - 1);
-		}
-		break;
-	case CAL_CLIENT_GET_NOT_FOUND :
-	case CAL_CLIENT_GET_SYNTAX_ERROR :
-		if (comp_data) {
-			/* Nothing; the object may have been removed from the server. We just
-			   notify that the old object was deleted.
-			*/
-			pos = get_position_in_array (priv->objects, comp_data);
+	e_table_model_rows_inserted (E_TABLE_MODEL (model), start_row, priv->objects->len - start_row);
+}
 
-			g_ptr_array_remove (priv->objects, comp_data);
-			free_comp_data (comp_data);
+static void
+query_objects_modified_cb (CalQuery *query, GList *objects, gpointer user_data)
+{
+	ECalModelPrivate *priv;
+	ECalModel *model = (ECalModel *) user_data;
+	GList *l;
+	
+	priv = model->priv;
 
-			e_table_model_row_deleted (E_TABLE_MODEL (model), pos);
-		} else
-			e_table_model_no_change (E_TABLE_MODEL (model));
-		break;
-	default :
-		g_assert_not_reached ();
+	for (l = objects; l; l = l->next) {
+		ECalModelComponent *comp_data;
+
+		e_table_model_pre_change (E_TABLE_MODEL (model));
+
+		comp_data = search_by_uid_and_client (priv, cal_query_get_client (query), icalcomponent_get_uid (l->data));
+		g_assert (comp_data);
+	
+		if (comp_data->icalcomp)
+			icalcomponent_free (comp_data->icalcomp);
+		if (comp_data->dtstart) {
+			g_free (comp_data->dtstart);
+			comp_data->dtstart = NULL;
+		}
+		if (comp_data->dtend) {
+			g_free (comp_data->dtend);
+			comp_data->dtend = NULL;
+		}
+		if (comp_data->due) {
+			g_free (comp_data->due);
+			comp_data->due = NULL;
+		}
+		if (comp_data->completed) {
+			g_free (comp_data->completed);
+			comp_data->completed = NULL;
+		}
+		     
+		comp_data->icalcomp = icalcomponent_new_clone (l->data);
+
+		e_table_model_row_changed (E_TABLE_MODEL (model), get_position_in_array (priv->objects, comp_data));
 	}
 }
 
 static void
-query_obj_removed_cb (CalQuery *query, const char *uid, gpointer user_data)
+query_objects_removed_cb (CalQuery *query, GList *uids, gpointer user_data)
 {
-	ECalModelComponent *comp_data;
 	ECalModelPrivate *priv;
 	ECalModel *model = (ECalModel *) user_data;
-
-	g_return_if_fail (E_IS_CAL_MODEL (model));
-
+	GList *l;
+	
 	priv = model->priv;
 
-	e_table_model_pre_change (E_TABLE_MODEL (model));
-
-	comp_data = search_by_uid_and_client (priv, cal_query_get_client (query), uid);
-	if (comp_data) {
-		gint pos = get_position_in_array (priv->objects, comp_data);
+	for (l = uids; l; l = l->next) {
+		ECalModelComponent *comp_data;
+		int pos;
 
+		e_table_model_pre_change (E_TABLE_MODEL (model));
+		
+		comp_data = search_by_uid_and_client (priv, cal_query_get_client (query), l->data);
+		g_assert (comp_data);
+		
+		pos = get_position_in_array (priv->objects, comp_data);
+			
 		g_ptr_array_remove (priv->objects, comp_data);
 		free_comp_data (comp_data);
-
+		
 		e_table_model_row_deleted (E_TABLE_MODEL (model), pos);
-	} else
-		e_table_model_no_change (E_TABLE_MODEL (model));
+	}
 }
 
 static void
-query_done_cb (CalQuery *query, CalQueryDoneStatus status, const char *error_str, gpointer user_data)
+query_progress_cb (CalQuery *query, const char *message, int percent, gpointer user_data)
 {
 	ECalModel *model = (ECalModel *) user_data;
 
 	g_return_if_fail (E_IS_CAL_MODEL (model));
 
-	if (status != CAL_QUERY_DONE_SUCCESS)
-		g_warning ("query done: %s\n", error_str);
+	/* FIXME Update status bar */
 }
 
 static void
-query_eval_error_cb (CalQuery *query, const char *error_str, gpointer user_data)
+query_done_cb (CalQuery *query, ECalendarStatus status, gpointer user_data)
 {
-	ECalModel *model = (ECalModel *) user_data;
+ 	ECalModel *model = (ECalModel *) user_data;
 
 	g_return_if_fail (E_IS_CAL_MODEL (model));
 
-	g_warning ("eval error: %s\n", error_str);
+	/* FIXME Clear status bar */
 }
 
 /* Builds a complete query sexp for the calendar model by adding the predicates
@@ -1248,24 +1283,28 @@ update_query_for_client (ECalModel *model, ECalModelClient *client_data)
 		g_signal_handlers_disconnect_matched (client_data->query, G_SIGNAL_MATCH_DATA,
 						      0, 0, NULL, NULL, model);
 		g_object_unref (client_data->query);
+		client_data->query = NULL;
 	}
 
 	/* prepare the query */
 	g_assert (priv->sexp != NULL);
 	real_sexp = adjust_query_sexp (model, priv->sexp);
 
-	client_data->query = cal_client_get_query (client_data->client, real_sexp);
-	g_free (real_sexp);
+	if (!cal_client_get_query (client_data->client, real_sexp, &client_data->query, NULL)) {
+		g_warning (G_STRLOC ": Unable to get query");
+		g_free (real_sexp);
 
-	if (!client_data->query) {
-		g_message ("update_query_for_client(): Could not create the query");
 		return;
-	}
+	}	
+	g_free (real_sexp);
 
-	g_signal_connect (client_data->query, "obj_updated", G_CALLBACK (query_obj_updated_cb), model);
-	g_signal_connect (client_data->query, "obj_removed", G_CALLBACK (query_obj_removed_cb), model);
+	g_signal_connect (client_data->query, "objects_added", G_CALLBACK (query_objects_added_cb), model);
+	g_signal_connect (client_data->query, "objects_modified", G_CALLBACK (query_objects_modified_cb), model);
+	g_signal_connect (client_data->query, "objects_removed", G_CALLBACK (query_objects_removed_cb), model);
+	g_signal_connect (client_data->query, "query_progress", G_CALLBACK (query_progress_cb), model);
 	g_signal_connect (client_data->query, "query_done", G_CALLBACK (query_done_cb), model);
-	g_signal_connect (client_data->query, "eval_error", G_CALLBACK (query_eval_error_cb), model);
+
+	cal_query_start (client_data->query);
 }
 
 static void
@@ -1465,9 +1504,22 @@ e_cal_model_create_component_with_defaults (ECalModel *model)
 		return NULL;
 	}
 
+	if (!comp)
+		return icalcomponent_new (priv->kind);
+
 	icalcomp = icalcomponent_new_clone (cal_component_get_icalcomponent (comp));
 	g_object_unref (comp);
 
+	/* make sure the component has an UID */
+	if (!icalcomponent_get_uid (icalcomp)) {
+		char *uid;
+
+		uid = cal_component_gen_uid ();
+		icalcomponent_set_uid (icalcomp, uid);
+
+		g_free (uid);
+	}
+
 	return icalcomp;
 }
 
diff --git a/calendar/gui/e-cal-model.h b/calendar/gui/e-cal-model.h
index ec8ab36c44..9c673ca439 100644
--- a/calendar/gui/e-cal-model.h
+++ b/calendar/gui/e-cal-model.h
@@ -88,7 +88,9 @@ void                e_cal_model_set_default_category (ECalModel *model, const gc
 void                e_cal_model_set_use_24_hour_format (ECalModel *model, gboolean use24);
 
 CalClient          *e_cal_model_get_default_client (ECalModel *model);
+void                e_cal_model_set_default_client (ECalModel *model, CalClient *client);
 GList              *e_cal_model_get_client_list (ECalModel *model);
+CalClient          *e_cal_model_get_client_for_uri (ECalModel *model, const char *uri);
 void                e_cal_model_add_client (ECalModel *model, CalClient *client);
 void                e_cal_model_remove_client (ECalModel *model, CalClient *client);
 void                e_cal_model_remove_all_clients (ECalModel *model);
diff --git a/calendar/gui/e-cal-view.c b/calendar/gui/e-cal-view.c
index 381dca2542..869c8001a3 100644
--- a/calendar/gui/e-cal-view.c
+++ b/calendar/gui/e-cal-view.c
@@ -37,9 +37,11 @@
 #include "comp-util.h"
 #include "e-cal-model-calendar.h"
 #include "e-cal-view.h"
+#include "e-comp-editor-registry.h"
 #include "itip-utils.h"
 #include "dialogs/delete-comp.h"
 #include "dialogs/delete-error.h"
+#include "dialogs/event-editor.h"
 #include "dialogs/send-comp.h"
 #include "dialogs/cancel-comp.h"
 #include "dialogs/recur-comp.h"
@@ -70,15 +72,28 @@ struct _ECalViewPrivate {
 
 	/* The timezone. */
 	icaltimezone *zone;
+
+	/* The default category */
+	char *default_category;
 };
 
 static void e_cal_view_class_init (ECalViewClass *klass);
 static void e_cal_view_init (ECalView *cal_view, ECalViewClass *klass);
+static void e_cal_view_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec);
+static void e_cal_view_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec);
 static void e_cal_view_destroy (GtkObject *object);
 
 static GObjectClass *parent_class = NULL;
 static GdkAtom clipboard_atom = GDK_NONE;
+extern ECompEditorRegistry *comp_editor_registry;
+
+/* Property IDs */
+enum props {
+	PROP_0,
+	PROP_MODEL,
+};
 
+/* FIXME Why are we emitting these event signals here? Can't the model just be listened to? */
 /* Signal IDs */
 enum {
 	SELECTION_CHANGED,
@@ -91,12 +106,71 @@ enum {
 static guint e_cal_view_signals[LAST_SIGNAL] = { 0 };
 
 static void
+e_cal_view_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
+{
+	ECalView *cal_view;
+	ECalViewPrivate *priv;
+
+	cal_view = E_CAL_VIEW (object);
+	priv = cal_view->priv;
+	
+	switch (property_id) {
+	case PROP_MODEL:
+		e_cal_view_set_model (cal_view, E_CAL_MODEL (g_value_get_object (value)));
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+		break;
+	}
+}
+
+static void
+e_cal_view_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
+{
+	ECalView *cal_view;
+	ECalViewPrivate *priv;
+
+	cal_view = E_CAL_VIEW (object);
+	priv = cal_view->priv;
+
+	switch (property_id) {
+	case PROP_MODEL:
+		g_value_set_object (value, e_cal_view_get_model (cal_view));
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+		break;
+	}
+}
+
+static void
 e_cal_view_class_init (ECalViewClass *klass)
 {
+	GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 	GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
 
 	parent_class = g_type_class_peek_parent (klass);
 
+	/* Method override */
+	gobject_class->set_property = e_cal_view_set_property;
+	gobject_class->get_property = e_cal_view_get_property;
+	object_class->destroy = e_cal_view_destroy;
+
+	klass->selection_changed = NULL;
+	klass->event_changed = NULL;
+	klass->event_added = NULL;
+
+	klass->get_selected_events = NULL;
+	klass->get_selected_time_range = NULL;
+	klass->set_selected_time_range = NULL;
+	klass->get_visible_time_range = NULL;
+	klass->update_query = NULL;
+
+	g_object_class_install_property (gobject_class, PROP_MODEL, 
+					 g_param_spec_object ("model", NULL, NULL, E_TYPE_CAL_MODEL,
+							      G_PARAM_READABLE | G_PARAM_WRITABLE
+							      | G_PARAM_CONSTRUCT));
+
 	/* Create class' signals */
 	e_cal_view_signals[SELECTION_CHANGED] =
 		g_signal_new ("selection_changed",
@@ -135,19 +209,6 @@ e_cal_view_class_init (ECalViewClass *klass)
 			      G_TYPE_NONE, 1,
 			      G_TYPE_POINTER);
 
-	/* Method override */
-	object_class->destroy = e_cal_view_destroy;
-
-	klass->selection_changed = NULL;
-	klass->event_changed = NULL;
-	klass->event_added = NULL;
-
-	klass->get_selected_events = NULL;
-	klass->get_selected_time_range = NULL;
-	klass->set_selected_time_range = NULL;
-	klass->get_visible_time_range = NULL;
-	klass->update_query = NULL;
-
 	/* clipboard atom */
 	if (!clipboard_atom)
 		clipboard_atom = gdk_atom_intern ("CLIPBOARD", FALSE);
@@ -208,6 +269,45 @@ selection_clear_event (GtkWidget *invisible,
 }
 
 static void
+selection_received_add_event (ECalView *cal_view, CalClient *client, time_t selected_time_start, 
+			      icaltimezone *default_zone, icalcomponent *icalcomp) 
+{
+	CalComponent *comp;
+	struct icaltimetype itime;
+	time_t tt_start, tt_end;
+	struct icaldurationtype ic_dur;
+	char *uid;
+
+	tt_start = icaltime_as_timet (icalcomponent_get_dtstart (icalcomp));
+	tt_end = icaltime_as_timet (icalcomponent_get_dtend (icalcomp));
+	ic_dur = icaldurationtype_from_int (tt_end - tt_start);
+	itime = icaltime_from_timet_with_zone (selected_time_start, FALSE, default_zone);
+
+	icalcomponent_set_dtstart (icalcomp, itime);
+	itime = icaltime_add (itime, ic_dur);
+	icalcomponent_set_dtend (icalcomp, itime);
+
+	/* FIXME The new uid stuff can go away once we actually set it in the backend */
+	uid = cal_component_gen_uid ();
+	comp = cal_component_new ();
+	cal_component_set_icalcomponent (
+		comp, icalcomponent_new_clone (icalcomp));
+	cal_component_set_uid (comp, uid);
+
+	/* FIXME Error handling */
+	cal_client_create_object (client, cal_component_get_icalcomponent (comp), NULL, NULL);
+	if (itip_organizer_is_user (comp, client) &&
+	    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (cal_view)),
+				   client, comp, TRUE)) {
+		itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp,
+				client, NULL);
+	}
+
+	free (uid);
+	g_object_unref (comp);
+}
+
+static void
 selection_received (GtkWidget *invisible,
 		    GtkSelectionData *selection_data,
 		    guint time,
@@ -216,12 +316,7 @@ selection_received (GtkWidget *invisible,
 	char *comp_str, *default_tzid;
 	icalcomponent *icalcomp;
 	icalcomponent_kind kind;
-	CalComponent *comp;
 	time_t selected_time_start, selected_time_end;
-	struct icaltimetype itime;
-	time_t tt_start, tt_end;
-	struct icaldurationtype ic_dur;
-	char *uid;
 	icaltimezone *default_zone;
 	CalClient *client;
 
@@ -238,21 +333,21 @@ selection_received (GtkWidget *invisible,
 		return;
 
 	default_tzid = calendar_config_get_timezone ();
+
 	client = e_cal_model_get_default_client (cal_view->priv->model);
-	cal_client_get_timezone (client, default_tzid, &default_zone);
+	/* FIXME Error checking */
+	cal_client_get_timezone (client, default_tzid, &default_zone, NULL);
 
 	/* check the type of the component */
+	/* FIXME An error dialog if we return? */
 	kind = icalcomponent_isa (icalcomp);
-	if (kind != ICAL_VCALENDAR_COMPONENT &&
-	    kind != ICAL_VEVENT_COMPONENT &&
-	    kind != ICAL_VTODO_COMPONENT &&
-	    kind != ICAL_VJOURNAL_COMPONENT) {
+	if (kind != ICAL_VCALENDAR_COMPONENT && kind != ICAL_VEVENT_COMPONENT)
 		return;
-	}
 
 	e_cal_view_set_status_message (cal_view, _("Updating objects"));
 	e_cal_view_get_selected_time_range (cal_view, &selected_time_start, &selected_time_end);
 
+	/* FIXME Timezone handling */
 	if (kind == ICAL_VCALENDAR_COMPONENT) {
 		icalcomponent_kind child_kind;
 		icalcomponent *subcomp;
@@ -260,69 +355,27 @@ selection_received (GtkWidget *invisible,
 		subcomp = icalcomponent_get_first_component (icalcomp, ICAL_ANY_COMPONENT);
 		while (subcomp) {
 			child_kind = icalcomponent_isa (subcomp);
-			if (child_kind == ICAL_VEVENT_COMPONENT ||
-			    child_kind == ICAL_VTODO_COMPONENT ||
-			    child_kind == ICAL_VJOURNAL_COMPONENT) {
-				tt_start = icaltime_as_timet (icalcomponent_get_dtstart (subcomp));
-				tt_end = icaltime_as_timet (icalcomponent_get_dtend (subcomp));
-				ic_dur = icaldurationtype_from_int (tt_end - tt_start);
-				itime = icaltime_from_timet_with_zone (selected_time_start,
-								       FALSE, default_zone);
-
-				icalcomponent_set_dtstart (subcomp, itime);
-				itime = icaltime_add (itime, ic_dur);
-				icalcomponent_set_dtend (subcomp, itime);
-
-				uid = cal_component_gen_uid ();
-				comp = cal_component_new ();
-				cal_component_set_icalcomponent (
-					comp, icalcomponent_new_clone (subcomp));
-				cal_component_set_uid (comp, uid);
-
-				cal_client_update_object (client, comp);
-				if (itip_organizer_is_user (comp, client) &&
-				    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (cal_view)),
-							   client, comp, TRUE)) {
-					itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp,
-							client, NULL);
-				}
-
-				free (uid);
-				g_object_unref (comp);
+			if (child_kind == ICAL_VEVENT_COMPONENT)
+				selection_received_add_event (cal_view, client, selected_time_start, 
+							      default_zone, subcomp);
+			else if (child_kind == ICAL_VTIMEZONE_COMPONENT) {
+				icaltimezone *zone;
+
+				zone = icaltimezone_new ();
+				icaltimezone_set_component (zone, subcomp);
+				cal_client_add_timezone (client, zone, NULL);
+				
+				icaltimezone_free (zone, 1);
 			}
+			
 			subcomp = icalcomponent_get_next_component (
 				icalcomp, ICAL_ANY_COMPONENT);
 		}
 
 		icalcomponent_free (icalcomp);
 
-	}
-	else {
-		tt_start = icaltime_as_timet (icalcomponent_get_dtstart (icalcomp));
-		tt_end = icaltime_as_timet (icalcomponent_get_dtend (icalcomp));
-		ic_dur = icaldurationtype_from_int (tt_end - tt_start);
-		itime = icaltime_from_timet_with_zone (selected_time_start, FALSE, default_zone);
-
-		icalcomponent_set_dtstart (icalcomp, itime);
-		itime = icaltime_add (itime, ic_dur);
-		icalcomponent_set_dtend (icalcomp, itime);
-
-		uid = cal_component_gen_uid ();
-		comp = cal_component_new ();
-		cal_component_set_icalcomponent (
-			comp, icalcomponent_new_clone (icalcomp));
-		cal_component_set_uid (comp, uid);
-
-		cal_client_update_object (client, comp);
-		if (itip_organizer_is_user (comp, client) &&
-		    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (cal_view)),
-					   client, comp, TRUE)) {
-			itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp,
-					client, NULL);
-		}
-
-		free (uid);
-		g_object_unref (comp);
+	} else {
+		selection_received_add_event (cal_view, client, selected_time_start, default_zone, icalcomp);
 	}
 
 	e_cal_view_set_status_message (cal_view, NULL);
@@ -334,6 +387,14 @@ e_cal_view_init (ECalView *cal_view, ECalViewClass *klass)
 	cal_view->priv = g_new0 (ECalViewPrivate, 1);
 
 	cal_view->priv->model = (ECalModel *) e_cal_model_calendar_new ();
+	g_signal_connect (G_OBJECT (cal_view->priv->model), "model_changed",
+			  G_CALLBACK (model_changed_cb), cal_view);
+	g_signal_connect (G_OBJECT (cal_view->priv->model), "model_row_changed",
+			  G_CALLBACK (model_row_changed_cb), cal_view);
+	g_signal_connect (G_OBJECT (cal_view->priv->model), "model_rows_inserted",
+			  G_CALLBACK (model_rows_changed_cb), cal_view);
+	g_signal_connect (G_OBJECT (cal_view->priv->model), "model_rows_deleted",
+			  G_CALLBACK (model_rows_changed_cb), cal_view);
 
 	/* Set up the invisible widget for the clipboard selections */
 	cal_view->priv->invisible = gtk_invisible_new ();
@@ -380,6 +441,11 @@ e_cal_view_destroy (GtkObject *object)
 			cal_view->priv->clipboard_selection = NULL;
 		}
 
+		if (cal_view->priv->default_category) {
+			g_free (cal_view->priv->default_category);
+			cal_view->priv->default_category = NULL;
+		}
+
 		g_free (cal_view->priv);
 		cal_view->priv = NULL;
 	}
@@ -460,11 +526,35 @@ e_cal_view_set_timezone (ECalView *cal_view, icaltimezone *zone)
 		       old_zone, cal_view->priv->zone);
 }
 
+const char *
+e_cal_view_get_default_category (ECalView *cal_view)
+{
+	g_return_val_if_fail (E_IS_CAL_VIEW (cal_view), NULL);
+	return (const char *) cal_view->priv->default_category;
+}
+
+/**
+ * e_cal_view_set_default_category
+ * @cal_view: A calendar view.
+ * @category: Default category name or NULL for no category.
+ *
+ * Sets the default category that will be used when creating new calendar
+ * components from the given calendar view.
+ */
 void
-e_cal_view_set_status_message (ECalView *cal_view, const gchar *message)
+e_cal_view_set_default_category (ECalView *cal_view, const char *category)
 {
-	extern EvolutionShellClient *global_shell_client; /* ugly */
+	g_return_if_fail (E_IS_CAL_VIEW (cal_view));
+
+	if (cal_view->priv->default_category)
+		g_free (cal_view->priv->default_category);
+
+	cal_view->priv->default_category = g_strdup (category);
+}
 
+void
+e_cal_view_set_status_message (ECalView *cal_view, const gchar *message)
+{
 	g_return_if_fail (E_IS_CAL_VIEW (cal_view));
 
 	if (!message || !*message) {
@@ -473,14 +563,19 @@ e_cal_view_set_status_message (ECalView *cal_view, const gchar *message)
 			cal_view->priv->activity = NULL;
 		}
 	} else if (!cal_view->priv->activity) {
+#if 0
 		int display;
+#endif
 		char *client_id = g_strdup_printf ("%p", cal_view);
 
 		if (progress_icon[0] == NULL)
 			progress_icon[0] = gdk_pixbuf_new_from_file (EVOLUTION_IMAGESDIR "/" EVOLUTION_CALENDAR_PROGRESS_IMAGE, NULL);
+
+#if 0
 		cal_view->priv->activity = evolution_activity_client_new (
 			global_shell_client, client_id,
 			progress_icon, message, TRUE, &display);
+#endif
 
 		g_free (client_id);
 	} else
@@ -564,9 +659,9 @@ e_cal_view_cut_clipboard (ECalView *cal_view)
 	e_cal_view_copy_clipboard (cal_view);
 	for (l = selected; l != NULL; l = l->next) {
 		CalComponent *comp;
-
 		ECalViewEvent *event = (ECalViewEvent *) l->data;
-
+		GError *error = NULL;
+		
 		if (!event)
 			continue;
 
@@ -580,9 +675,11 @@ e_cal_view_cut_clipboard (ECalView *cal_view)
 					event->comp_data->client, NULL);
 
 		cal_component_get_uid (comp, &uid);
-		delete_error_dialog (cal_client_remove_object (event->comp_data->client, uid),
-				     CAL_COMPONENT_EVENT);
+		cal_client_remove_object (event->comp_data->client, uid, &error);
+		delete_error_dialog (error, CAL_COMPONENT_EVENT);
 
+		g_clear_error (&error);
+		
 		g_object_unref (comp);
 	}
 
@@ -657,7 +754,8 @@ delete_event (ECalView *cal_view, ECalViewEvent *event)
 
 	if (delete_component_dialog (comp, FALSE, 1, vtype, GTK_WIDGET (cal_view))) {
 		const char *uid;
-
+		GError *error = NULL;
+		
 		if (itip_organizer_is_user (comp, event->comp_data->client) 
 		    && cancel_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (cal_view)),
 						event->comp_data->client,
@@ -670,9 +768,10 @@ delete_event (ECalView *cal_view, ECalViewEvent *event)
 			g_object_unref (comp);
 			return;
 		}
-
-		delete_error_dialog (
-			cal_client_remove_object (event->comp_data->client, uid), CAL_COMPONENT_EVENT);
+		
+		cal_client_remove_object (event->comp_data->client, uid, &error);
+		delete_error_dialog (error, CAL_COMPONENT_EVENT);
+		g_clear_error (&error);
 	}
 
 	g_object_unref (comp);
@@ -719,35 +818,21 @@ e_cal_view_delete_selected_occurrence (ECalView *cal_view)
 {
 	ECalViewEvent *event;
 	GList *selected;
-
+	const char *uid;
+	GError *error = NULL;
+		
 	selected = e_cal_view_get_selected_events (cal_view);
 	if (!selected)
 		return;
 
 	event = (ECalViewEvent *) selected->data;
 
-	if (cal_util_component_is_instance (event->comp_data->icalcomp)) {
-		const char *uid;
-
-		uid = icalcomponent_get_uid (event->comp_data->icalcomp);
-		delete_error_dialog (
-			cal_client_remove_object_with_mod (event->comp_data->client, uid, CALOBJ_MOD_THIS),
-			CAL_COMPONENT_EVENT);
-	} else {
-		CalComponent *comp;
+	uid = icalcomponent_get_uid (event->comp_data->icalcomp);
+	/* FIXME: use 'rid' argument */
+	cal_client_remove_object_with_mod (event->comp_data->client, uid, NULL, CALOBJ_MOD_THIS, &error);
 
-		/* we must duplicate the CalComponent, or we won't know it has changed
-		   when we get the "update_event" signal */
-		comp = cal_component_new ();
-		cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
-		cal_comp_util_add_exdate (comp, event->start, cal_view->priv->zone);
-
-		if (cal_client_update_object (event->comp_data->client, comp)
-		    != CAL_CLIENT_RESULT_SUCCESS)
-			g_message ("e_cal_view_delete_selected_occurrence(): Could not update the object!");
-
-		g_object_unref (comp);
-	}
+	delete_error_dialog (error, CAL_COMPONENT_EVENT);
+	g_clear_error (&error);
 
 	/* free memory */
 	g_list_free (selected);
@@ -756,11 +841,9 @@ e_cal_view_delete_selected_occurrence (ECalView *cal_view)
 static void
 on_new_appointment (GtkWidget *widget, gpointer user_data)
 {
-	time_t dtstart, dtend;
 	ECalView *cal_view = (ECalView *) user_data;
 
-	e_cal_view_get_selected_time_range (cal_view, &dtstart, &dtend);
-	gnome_calendar_new_appointment_for (cal_view->priv->calendar, dtstart, dtend, FALSE, FALSE);
+	e_cal_view_new_appointment (cal_view);
 }
 
 static void
@@ -770,7 +853,7 @@ on_new_event (GtkWidget *widget, gpointer user_data)
 	ECalView *cal_view = (ECalView *) user_data;
 
 	e_cal_view_get_selected_time_range (cal_view, &dtstart, &dtend);
-	gnome_calendar_new_appointment_for (cal_view->priv->calendar, dtstart, dtend, TRUE, FALSE);
+	e_cal_view_new_appointment_for (cal_view, dtstart, dtend, TRUE, FALSE);
 }
 
 static void
@@ -780,7 +863,7 @@ on_new_meeting (GtkWidget *widget, gpointer user_data)
 	ECalView *cal_view = (ECalView *) user_data;
 
 	e_cal_view_get_selected_time_range (cal_view, &dtstart, &dtend);
-	gnome_calendar_new_appointment_for (cal_view->priv->calendar, dtstart, dtend, FALSE, TRUE);
+	e_cal_view_new_appointment_for (cal_view, dtstart, dtend, FALSE, TRUE);
 }
 
 static void
@@ -817,8 +900,8 @@ on_edit_appointment (GtkWidget *widget, gpointer user_data)
 		ECalViewEvent *event = (ECalViewEvent *) selected->data;
 
 		if (event)
-			gnome_calendar_edit_object (cal_view->priv->calendar, event->comp_data->client,
-						    event->comp_data->icalcomp, FALSE);
+			e_cal_view_edit_appointment (cal_view, event->comp_data->client,
+						     event->comp_data->icalcomp, FALSE);
 
 		g_list_free (selected);
 	}
@@ -834,7 +917,7 @@ on_print (GtkWidget *widget, gpointer user_data)
 
 	cal_view = E_CAL_VIEW (user_data);
 
-	gnome_calendar_get_current_time_range (cal_view->priv->calendar, &start, NULL);
+	e_cal_view_get_visible_time_range (cal_view, &start, NULL);
 	view_type = gnome_calendar_get_view (cal_view->priv->calendar);
 
 	switch (view_type) {
@@ -930,7 +1013,7 @@ on_meeting (GtkWidget *widget, gpointer user_data)
 	selected = e_cal_view_get_selected_events (cal_view);
 	if (selected) {
 		ECalViewEvent *event = (ECalViewEvent *) selected->data;
-		gnome_calendar_edit_object (cal_view->priv->calendar, event->comp_data->client, event->comp_data->icalcomp, TRUE);
+		e_cal_view_edit_appointment (cal_view, event->comp_data->client, event->comp_data->icalcomp, TRUE);
 
 		g_list_free (selected);
 	}
@@ -962,7 +1045,7 @@ on_publish (GtkWidget *widget, gpointer user_data)
 	ECalView *cal_view;
 	icaltimezone *utc;
 	time_t start = time (NULL), end;
-	GList *comp_list, *client_list, *cl;
+	GList *comp_list = NULL, *client_list, *cl;
 
 	cal_view = E_CAL_VIEW (user_data);
 
@@ -972,8 +1055,7 @@ on_publish (GtkWidget *widget, gpointer user_data)
 
 	client_list = e_cal_model_get_client_list (cal_view->priv->model);
 	for (cl = client_list; cl != NULL; cl = cl->next) {
-		comp_list = cal_client_get_free_busy ((CalClient *) cl->data, NULL, start, end);
-		if (comp_list) {
+		if (cal_client_get_free_busy ((CalClient *) cl->data, NULL, start, end, &comp_list, NULL)) {
 			GList *l;
 
 			for (l = comp_list; l; l = l->next) {
@@ -1041,14 +1123,6 @@ on_paste (GtkWidget *widget, gpointer user_data)
 	e_cal_view_paste_clipboard (cal_view);
 }
 
-static void
-on_unrecur_appointment (GtkWidget *widget, gpointer user_data)
-{
-	ECalView *cal_view = E_CAL_VIEW (user_data);
-
-	gnome_calendar_unrecur_selection (cal_view->priv->calendar);
-}
-
 enum {
 	/*
 	 * This is used to "flag" events that can not be editted
@@ -1142,7 +1216,6 @@ static EPopupMenu child_items [] = {
 	E_POPUP_SEPARATOR,
 
 	E_POPUP_ITEM (N_("_Delete"), GTK_SIGNAL_FUNC (on_delete_appointment), MASK_EDITABLE | MASK_SINGLE | MASK_EDITING),
-	E_POPUP_ITEM (N_("Make this Occurrence _Movable"), GTK_SIGNAL_FUNC (on_unrecur_appointment), MASK_RECURRING | MASK_EDITING | MASK_EDITABLE | MASK_INSTANCE),
 	E_POPUP_ITEM (N_("Delete this _Occurrence"), GTK_SIGNAL_FUNC (on_delete_occurrence), MASK_RECURRING | MASK_EDITING | MASK_EDITABLE),
 	E_POPUP_ITEM (N_("Delete _All Occurrences"), GTK_SIGNAL_FUNC (on_delete_appointment), MASK_RECURRING | MASK_EDITING | MASK_EDITABLE),
 
@@ -1209,21 +1282,18 @@ setup_popup_icons (EPopupMenu *context_menu)
 GtkMenu *
 e_cal_view_create_popup_menu (ECalView *cal_view)
 {
-	gboolean being_edited, have_selection;
 	GList *selected;
 	EPopupMenu *context_menu;
 	guint32 disable_mask = 0, hide_mask = 0;
 	GtkMenu *popup;
 	CalClient *client = NULL;
-
+	gboolean read_only = TRUE;
+	
 	g_return_val_if_fail (E_IS_CAL_VIEW (cal_view), NULL);
 
 	/* get the selection */
-	being_edited = FALSE;
 	selected = e_cal_view_get_selected_events (cal_view);
 
-	have_selection = GTK_WIDGET_HAS_FOCUS (cal_view) && selected != NULL;
-
 	if (selected == NULL) {
 		cal_view->priv->view_menu = gnome_calendar_setup_view_popup (cal_view->priv->calendar);
 		main_items[9].submenu = cal_view->priv->view_menu;
@@ -1260,15 +1330,158 @@ e_cal_view_create_popup_menu (ECalView *cal_view)
 		client = event->comp_data->client;
 	}
 
-	if (cal_client_is_read_only (client))
+	cal_client_is_read_only (client, &read_only, NULL);
+	if (read_only)
 		disable_mask |= MASK_EDITABLE;
 
-	if (being_edited)
-		disable_mask |= MASK_EDITING;
-
 	setup_popup_icons (context_menu);
 	popup = e_popup_menu_create (context_menu, disable_mask, hide_mask, cal_view);
 	g_signal_connect (popup, "selection-done", G_CALLBACK (free_view_popup), cal_view);
 
 	return popup;
 }
+
+/**
+ * e_cal_view_new_appointment_for
+ * @cal_view: A calendar view.
+ * @dtstart: A Unix time_t that marks the beginning of the appointment.
+ * @dtend: A Unix time_t that marks the end of the appointment.
+ * @all_day: If TRUE, the dtstart and dtend are expanded to cover
+ * the entire day, and the event is set to TRANSPARENT.
+ * @meeting: Whether the appointment is a meeting or not.
+ *
+ * Opens an event editor dialog for a new appointment.
+ */
+void
+e_cal_view_new_appointment_for (ECalView *cal_view,
+				time_t dtstart, time_t dtend,
+				gboolean all_day,
+				gboolean meeting)
+{
+	ECalViewPrivate *priv;
+	struct icaltimetype itt;
+	CalComponentDateTime dt;
+	CalComponent *comp;
+	icalcomponent *icalcomp;
+	CalComponentTransparency transparency;
+
+	g_return_if_fail (E_IS_CAL_VIEW (cal_view));
+
+	priv = cal_view->priv;
+
+	dt.value = &itt;
+	if (all_day)
+		dt.tzid = NULL;
+	else
+		dt.tzid = icaltimezone_get_tzid (priv->zone);
+
+	icalcomp = e_cal_model_create_component_with_defaults (priv->model);
+	comp = cal_component_new ();
+	cal_component_set_icalcomponent (comp, icalcomp);
+
+	/* DTSTART, DTEND */
+	itt = icaltime_from_timet_with_zone (dtstart, FALSE, priv->zone);
+	if (all_day) {
+		itt.hour = itt.minute = itt.second = 0;
+		itt.is_date = TRUE;
+	}
+	cal_component_set_dtstart (comp, &dt);
+
+	itt = icaltime_from_timet_with_zone (dtend, FALSE, priv->zone);
+	if (all_day) {
+		/* We round it up to the end of the day, unless it is
+		   already set to midnight */
+		if (itt.hour != 0 || itt.minute != 0 || itt.second != 0) {
+			icaltime_adjust (&itt, 1, 0, 0, 0);
+		}
+		itt.hour = itt.minute = itt.second = 0;
+		itt.is_date = TRUE;
+	}
+	cal_component_set_dtend (comp, &dt);
+
+	/* TRANSPARENCY */
+	transparency = all_day ? CAL_COMPONENT_TRANSP_TRANSPARENT
+		: CAL_COMPONENT_TRANSP_OPAQUE;
+	cal_component_set_transparency (comp, transparency);
+
+	/* CATEGORY */
+	cal_component_set_categories (comp, priv->default_category);
+
+	/* edit the object */
+	cal_component_commit_sequence (comp);
+
+	e_cal_view_edit_appointment (cal_view,
+				     e_cal_model_get_default_client (priv->model),
+				     icalcomp, meeting);
+
+	g_object_unref (comp);
+}
+
+/**
+ * e_cal_view_new_appointment
+ * @cal_view: A calendar view.
+ *
+ * Opens an event editor dialog for a new appointment. The appointment's
+ * start and end times are set to the currently selected time range in
+ * the calendar view.
+ */
+void
+e_cal_view_new_appointment (ECalView *cal_view)
+{
+	time_t dtstart, dtend;
+
+	g_return_if_fail (E_IS_CAL_VIEW (cal_view));
+
+	e_cal_view_get_selected_time_range (cal_view, &dtstart, &dtend);
+	e_cal_view_new_appointment_for (cal_view, dtstart, dtend, FALSE, FALSE);
+}
+
+/**
+ * e_cal_view_edit_appointment
+ * @cal_view: A calendar view.
+ * @client: Calendar client.
+ * @icalcomp: The object to be edited.
+ * @meeting: Whether the appointment is a meeting or not.
+ *
+ * Opens an editor window to allow the user to edit the selected
+ * object.
+ */
+void
+e_cal_view_edit_appointment (ECalView *cal_view,
+			     CalClient *client,
+			     icalcomponent *icalcomp,
+			     gboolean meeting)
+{
+	ECalViewPrivate *priv;
+	CompEditor *ce;
+	const char *uid;
+	CalComponent *comp;
+
+	g_return_if_fail (E_IS_CAL_VIEW (cal_view));
+	g_return_if_fail (IS_CAL_CLIENT (client));
+	g_return_if_fail (icalcomp != NULL);
+
+	priv = cal_view->priv;
+
+	uid = icalcomponent_get_uid (icalcomp);
+
+	ce = e_comp_editor_registry_find (comp_editor_registry, uid);
+	if (!ce) {
+		EventEditor *ee;
+
+		ee = event_editor_new (client);
+		ce = COMP_EDITOR (ee);
+
+		comp = cal_component_new ();
+		cal_component_set_icalcomponent (comp, icalcomponent_new_clone (icalcomp));
+		comp_editor_edit_comp (ce, comp);
+		if (meeting)
+			event_editor_show_meeting (ee);
+
+		e_comp_editor_registry_add (comp_editor_registry, ce, FALSE);
+
+		g_object_unref (comp);
+	}
+
+	comp_editor_focus (ce);
+}
diff --git a/calendar/gui/e-cal-view.h b/calendar/gui/e-cal-view.h
index ea7c11a00d..9a09a5236a 100644
--- a/calendar/gui/e-cal-view.h
+++ b/calendar/gui/e-cal-view.h
@@ -96,6 +96,8 @@ ECalModel     *e_cal_view_get_model (ECalView *cal_view);
 void           e_cal_view_set_model (ECalView *cal_view, ECalModel *model);
 icaltimezone  *e_cal_view_get_timezone (ECalView *cal_view);
 void           e_cal_view_set_timezone (ECalView *cal_view, icaltimezone *zone);
+const char    *e_cal_view_get_default_category (ECalView *cal_view);
+void           e_cal_view_set_default_category (ECalView *cal_view, const char *category);
 
 void           e_cal_view_set_status_message (ECalView *cal_view, const gchar *message);
 
@@ -114,6 +116,17 @@ void           e_cal_view_delete_selected_occurrence (ECalView *cal_view);
 
 GtkMenu       *e_cal_view_create_popup_menu (ECalView *cal_view);
 
+void           e_cal_view_new_appointment_for (ECalView *cal_view,
+					       time_t dtstart,
+					       time_t dtend,
+					       gboolean all_day,
+					       gboolean meeting);
+void           e_cal_view_new_appointment (ECalView *cal_view);
+void           e_cal_view_edit_appointment (ECalView *cal_view,
+					    CalClient *client,
+					    icalcomponent *icalcomp,
+					    gboolean meeting);
+
 G_END_DECLS
 
 #endif
diff --git a/calendar/gui/e-calendar-table.c b/calendar/gui/e-calendar-table.c
index 5b3f98f373..fdea4d33bb 100644
--- a/calendar/gui/e-calendar-table.c
+++ b/calendar/gui/e-calendar-table.c
@@ -725,10 +725,12 @@ delete_selected_components (ECalendarTable *cal_table)
 
 	for (l = objs; l; l = l->next) {
 		ECalModelComponent *comp_data = (ECalModelComponent *) l->data;
-
-		delete_error_dialog (cal_client_remove_object (comp_data->client,
-							       icalcomponent_get_uid (comp_data->icalcomp)),
-				     CAL_COMPONENT_TODO);
+		GError *error = NULL;
+		
+		cal_client_remove_object (comp_data->client, 
+					  icalcomponent_get_uid (comp_data->icalcomp), &error);
+		delete_error_dialog (error, CAL_COMPONENT_TODO);
+		g_clear_error (&error);
 	}
 
 	e_calendar_table_set_status_message (cal_table, NULL);
@@ -1052,7 +1054,8 @@ e_calendar_table_show_popup_menu (ETable *table,
 	GtkMenu *gtk_menu;
 	icalproperty *prop;
 	ECalModelComponent *comp_data;
-
+	gboolean read_only = TRUE;
+	
 	n_selected = e_table_selected_count (table);
 	if (n_selected <= 0)
 		return TRUE;
@@ -1071,7 +1074,8 @@ e_calendar_table_show_popup_menu (ETable *table,
 	} else
 		hide_mask = MASK_SINGLE;
 
-	if (cal_client_is_read_only (comp_data->client))
+	cal_client_is_read_only (comp_data->client, &read_only, NULL);
+	if (!read_only)
 		disable_mask |= MASK_EDITABLE;
 
 	if (cal_client_get_static_capability (comp_data->client, CAL_STATIC_CAPABILITY_NO_TASK_ASSIGNMENT))
@@ -1315,6 +1319,7 @@ selection_received (GtkWidget *invisible,
 	icalcomponent *icalcomp;
 	char *uid;
 	CalComponent *comp;
+	CalClient *client;
 	icalcomponent_kind kind;
 
 	g_return_if_fail (E_IS_CALENDAR_TABLE (cal_table));
@@ -1338,6 +1343,8 @@ selection_received (GtkWidget *invisible,
 		return;
 	}
 
+	client = e_cal_model_get_default_client (cal_table->model);
+	
 	e_calendar_table_set_status_message (cal_table, _("Updating objects"));
 
 	if (kind == ICAL_VCALENDAR_COMPONENT) {
@@ -1360,11 +1367,12 @@ selection_received (GtkWidget *invisible,
 				cal_component_set_icalcomponent (
 					tmp_comp, icalcomponent_new_clone (subcomp));
 				cal_component_set_uid (tmp_comp, uid);
-
-				cal_client_update_object (
-					e_cal_model_get_default_client (cal_table->model),
-					tmp_comp);
 				free (uid);
+
+				/* FIXME should we convert start/due/complete times? */
+				/* FIXME Error handling */
+				cal_client_create_object (client, cal_component_get_icalcomponent (tmp_comp), NULL, NULL);
+
 				g_object_unref (tmp_comp);
 			}
 			subcomp = icalcomponent_get_next_component (
@@ -1378,9 +1386,8 @@ selection_received (GtkWidget *invisible,
 		cal_component_set_uid (comp, (const char *) uid);
 		free (uid);
 
-		cal_client_update_object (
-			e_cal_model_get_default_client (cal_table->model),
-			comp);
+		cal_client_create_object (client, cal_component_get_icalcomponent (comp), NULL, NULL);
+
 		g_object_unref (comp);
 	}
 
@@ -1433,8 +1440,6 @@ static GdkPixbuf *progress_icon[2] = { NULL, NULL };
 void
 e_calendar_table_set_status_message (ECalendarTable *cal_table, const gchar *message)
 {
-	extern EvolutionShellClient *global_shell_client; /* ugly */
-
         g_return_if_fail (E_IS_CALENDAR_TABLE (cal_table));
                                                                                 
         if (!message || !*message) {
@@ -1448,9 +1453,12 @@ e_calendar_table_set_status_message (ECalendarTable *cal_table, const gchar *mes
                                                                                 
                 if (progress_icon[0] == NULL)
                         progress_icon[0] = gdk_pixbuf_new_from_file (EVOLUTION_IMAGESDIR "/" EVOLUTION_TASKS_PROGRESS_IMAGE, NULL);
+
+#if 0				/* EPFIXME */
                 cal_table->activity = evolution_activity_client_new (
                         global_shell_client, client_id,
                         progress_icon, message, TRUE, &display);
+#endif
 
                 g_free (client_id);
         } else
diff --git a/calendar/gui/e-calendar-view.c b/calendar/gui/e-calendar-view.c
index 381dca2542..869c8001a3 100644
--- a/calendar/gui/e-calendar-view.c
+++ b/calendar/gui/e-calendar-view.c
@@ -37,9 +37,11 @@
 #include "comp-util.h"
 #include "e-cal-model-calendar.h"
 #include "e-cal-view.h"
+#include "e-comp-editor-registry.h"
 #include "itip-utils.h"
 #include "dialogs/delete-comp.h"
 #include "dialogs/delete-error.h"
+#include "dialogs/event-editor.h"
 #include "dialogs/send-comp.h"
 #include "dialogs/cancel-comp.h"
 #include "dialogs/recur-comp.h"
@@ -70,15 +72,28 @@ struct _ECalViewPrivate {
 
 	/* The timezone. */
 	icaltimezone *zone;
+
+	/* The default category */
+	char *default_category;
 };
 
 static void e_cal_view_class_init (ECalViewClass *klass);
 static void e_cal_view_init (ECalView *cal_view, ECalViewClass *klass);
+static void e_cal_view_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec);
+static void e_cal_view_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec);
 static void e_cal_view_destroy (GtkObject *object);
 
 static GObjectClass *parent_class = NULL;
 static GdkAtom clipboard_atom = GDK_NONE;
+extern ECompEditorRegistry *comp_editor_registry;
+
+/* Property IDs */
+enum props {
+	PROP_0,
+	PROP_MODEL,
+};
 
+/* FIXME Why are we emitting these event signals here? Can't the model just be listened to? */
 /* Signal IDs */
 enum {
 	SELECTION_CHANGED,
@@ -91,12 +106,71 @@ enum {
 static guint e_cal_view_signals[LAST_SIGNAL] = { 0 };
 
 static void
+e_cal_view_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
+{
+	ECalView *cal_view;
+	ECalViewPrivate *priv;
+
+	cal_view = E_CAL_VIEW (object);
+	priv = cal_view->priv;
+	
+	switch (property_id) {
+	case PROP_MODEL:
+		e_cal_view_set_model (cal_view, E_CAL_MODEL (g_value_get_object (value)));
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+		break;
+	}
+}
+
+static void
+e_cal_view_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
+{
+	ECalView *cal_view;
+	ECalViewPrivate *priv;
+
+	cal_view = E_CAL_VIEW (object);
+	priv = cal_view->priv;
+
+	switch (property_id) {
+	case PROP_MODEL:
+		g_value_set_object (value, e_cal_view_get_model (cal_view));
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+		break;
+	}
+}
+
+static void
 e_cal_view_class_init (ECalViewClass *klass)
 {
+	GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 	GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
 
 	parent_class = g_type_class_peek_parent (klass);
 
+	/* Method override */
+	gobject_class->set_property = e_cal_view_set_property;
+	gobject_class->get_property = e_cal_view_get_property;
+	object_class->destroy = e_cal_view_destroy;
+
+	klass->selection_changed = NULL;
+	klass->event_changed = NULL;
+	klass->event_added = NULL;
+
+	klass->get_selected_events = NULL;
+	klass->get_selected_time_range = NULL;
+	klass->set_selected_time_range = NULL;
+	klass->get_visible_time_range = NULL;
+	klass->update_query = NULL;
+
+	g_object_class_install_property (gobject_class, PROP_MODEL, 
+					 g_param_spec_object ("model", NULL, NULL, E_TYPE_CAL_MODEL,
+							      G_PARAM_READABLE | G_PARAM_WRITABLE
+							      | G_PARAM_CONSTRUCT));
+
 	/* Create class' signals */
 	e_cal_view_signals[SELECTION_CHANGED] =
 		g_signal_new ("selection_changed",
@@ -135,19 +209,6 @@ e_cal_view_class_init (ECalViewClass *klass)
 			      G_TYPE_NONE, 1,
 			      G_TYPE_POINTER);
 
-	/* Method override */
-	object_class->destroy = e_cal_view_destroy;
-
-	klass->selection_changed = NULL;
-	klass->event_changed = NULL;
-	klass->event_added = NULL;
-
-	klass->get_selected_events = NULL;
-	klass->get_selected_time_range = NULL;
-	klass->set_selected_time_range = NULL;
-	klass->get_visible_time_range = NULL;
-	klass->update_query = NULL;
-
 	/* clipboard atom */
 	if (!clipboard_atom)
 		clipboard_atom = gdk_atom_intern ("CLIPBOARD", FALSE);
@@ -208,6 +269,45 @@ selection_clear_event (GtkWidget *invisible,
 }
 
 static void
+selection_received_add_event (ECalView *cal_view, CalClient *client, time_t selected_time_start, 
+			      icaltimezone *default_zone, icalcomponent *icalcomp) 
+{
+	CalComponent *comp;
+	struct icaltimetype itime;
+	time_t tt_start, tt_end;
+	struct icaldurationtype ic_dur;
+	char *uid;
+
+	tt_start = icaltime_as_timet (icalcomponent_get_dtstart (icalcomp));
+	tt_end = icaltime_as_timet (icalcomponent_get_dtend (icalcomp));
+	ic_dur = icaldurationtype_from_int (tt_end - tt_start);
+	itime = icaltime_from_timet_with_zone (selected_time_start, FALSE, default_zone);
+
+	icalcomponent_set_dtstart (icalcomp, itime);
+	itime = icaltime_add (itime, ic_dur);
+	icalcomponent_set_dtend (icalcomp, itime);
+
+	/* FIXME The new uid stuff can go away once we actually set it in the backend */
+	uid = cal_component_gen_uid ();
+	comp = cal_component_new ();
+	cal_component_set_icalcomponent (
+		comp, icalcomponent_new_clone (icalcomp));
+	cal_component_set_uid (comp, uid);
+
+	/* FIXME Error handling */
+	cal_client_create_object (client, cal_component_get_icalcomponent (comp), NULL, NULL);
+	if (itip_organizer_is_user (comp, client) &&
+	    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (cal_view)),
+				   client, comp, TRUE)) {
+		itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp,
+				client, NULL);
+	}
+
+	free (uid);
+	g_object_unref (comp);
+}
+
+static void
 selection_received (GtkWidget *invisible,
 		    GtkSelectionData *selection_data,
 		    guint time,
@@ -216,12 +316,7 @@ selection_received (GtkWidget *invisible,
 	char *comp_str, *default_tzid;
 	icalcomponent *icalcomp;
 	icalcomponent_kind kind;
-	CalComponent *comp;
 	time_t selected_time_start, selected_time_end;
-	struct icaltimetype itime;
-	time_t tt_start, tt_end;
-	struct icaldurationtype ic_dur;
-	char *uid;
 	icaltimezone *default_zone;
 	CalClient *client;
 
@@ -238,21 +333,21 @@ selection_received (GtkWidget *invisible,
 		return;
 
 	default_tzid = calendar_config_get_timezone ();
+
 	client = e_cal_model_get_default_client (cal_view->priv->model);
-	cal_client_get_timezone (client, default_tzid, &default_zone);
+	/* FIXME Error checking */
+	cal_client_get_timezone (client, default_tzid, &default_zone, NULL);
 
 	/* check the type of the component */
+	/* FIXME An error dialog if we return? */
 	kind = icalcomponent_isa (icalcomp);
-	if (kind != ICAL_VCALENDAR_COMPONENT &&
-	    kind != ICAL_VEVENT_COMPONENT &&
-	    kind != ICAL_VTODO_COMPONENT &&
-	    kind != ICAL_VJOURNAL_COMPONENT) {
+	if (kind != ICAL_VCALENDAR_COMPONENT && kind != ICAL_VEVENT_COMPONENT)
 		return;
-	}
 
 	e_cal_view_set_status_message (cal_view, _("Updating objects"));
 	e_cal_view_get_selected_time_range (cal_view, &selected_time_start, &selected_time_end);
 
+	/* FIXME Timezone handling */
 	if (kind == ICAL_VCALENDAR_COMPONENT) {
 		icalcomponent_kind child_kind;
 		icalcomponent *subcomp;
@@ -260,69 +355,27 @@ selection_received (GtkWidget *invisible,
 		subcomp = icalcomponent_get_first_component (icalcomp, ICAL_ANY_COMPONENT);
 		while (subcomp) {
 			child_kind = icalcomponent_isa (subcomp);
-			if (child_kind == ICAL_VEVENT_COMPONENT ||
-			    child_kind == ICAL_VTODO_COMPONENT ||
-			    child_kind == ICAL_VJOURNAL_COMPONENT) {
-				tt_start = icaltime_as_timet (icalcomponent_get_dtstart (subcomp));
-				tt_end = icaltime_as_timet (icalcomponent_get_dtend (subcomp));
-				ic_dur = icaldurationtype_from_int (tt_end - tt_start);
-				itime = icaltime_from_timet_with_zone (selected_time_start,
-								       FALSE, default_zone);
-
-				icalcomponent_set_dtstart (subcomp, itime);
-				itime = icaltime_add (itime, ic_dur);
-				icalcomponent_set_dtend (subcomp, itime);
-
-				uid = cal_component_gen_uid ();
-				comp = cal_component_new ();
-				cal_component_set_icalcomponent (
-					comp, icalcomponent_new_clone (subcomp));
-				cal_component_set_uid (comp, uid);
-
-				cal_client_update_object (client, comp);
-				if (itip_organizer_is_user (comp, client) &&
-				    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (cal_view)),
-							   client, comp, TRUE)) {
-					itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp,
-							client, NULL);
-				}
-
-				free (uid);
-				g_object_unref (comp);
+			if (child_kind == ICAL_VEVENT_COMPONENT)
+				selection_received_add_event (cal_view, client, selected_time_start, 
+							      default_zone, subcomp);
+			else if (child_kind == ICAL_VTIMEZONE_COMPONENT) {
+				icaltimezone *zone;
+
+				zone = icaltimezone_new ();
+				icaltimezone_set_component (zone, subcomp);
+				cal_client_add_timezone (client, zone, NULL);
+				
+				icaltimezone_free (zone, 1);
 			}
+			
 			subcomp = icalcomponent_get_next_component (
 				icalcomp, ICAL_ANY_COMPONENT);
 		}
 
 		icalcomponent_free (icalcomp);
 
-	}
-	else {
-		tt_start = icaltime_as_timet (icalcomponent_get_dtstart (icalcomp));
-		tt_end = icaltime_as_timet (icalcomponent_get_dtend (icalcomp));
-		ic_dur = icaldurationtype_from_int (tt_end - tt_start);
-		itime = icaltime_from_timet_with_zone (selected_time_start, FALSE, default_zone);
-
-		icalcomponent_set_dtstart (icalcomp, itime);
-		itime = icaltime_add (itime, ic_dur);
-		icalcomponent_set_dtend (icalcomp, itime);
-
-		uid = cal_component_gen_uid ();
-		comp = cal_component_new ();
-		cal_component_set_icalcomponent (
-			comp, icalcomponent_new_clone (icalcomp));
-		cal_component_set_uid (comp, uid);
-
-		cal_client_update_object (client, comp);
-		if (itip_organizer_is_user (comp, client) &&
-		    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (cal_view)),
-					   client, comp, TRUE)) {
-			itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp,
-					client, NULL);
-		}
-
-		free (uid);
-		g_object_unref (comp);
+	} else {
+		selection_received_add_event (cal_view, client, selected_time_start, default_zone, icalcomp);
 	}
 
 	e_cal_view_set_status_message (cal_view, NULL);
@@ -334,6 +387,14 @@ e_cal_view_init (ECalView *cal_view, ECalViewClass *klass)
 	cal_view->priv = g_new0 (ECalViewPrivate, 1);
 
 	cal_view->priv->model = (ECalModel *) e_cal_model_calendar_new ();
+	g_signal_connect (G_OBJECT (cal_view->priv->model), "model_changed",
+			  G_CALLBACK (model_changed_cb), cal_view);
+	g_signal_connect (G_OBJECT (cal_view->priv->model), "model_row_changed",
+			  G_CALLBACK (model_row_changed_cb), cal_view);
+	g_signal_connect (G_OBJECT (cal_view->priv->model), "model_rows_inserted",
+			  G_CALLBACK (model_rows_changed_cb), cal_view);
+	g_signal_connect (G_OBJECT (cal_view->priv->model), "model_rows_deleted",
+			  G_CALLBACK (model_rows_changed_cb), cal_view);
 
 	/* Set up the invisible widget for the clipboard selections */
 	cal_view->priv->invisible = gtk_invisible_new ();
@@ -380,6 +441,11 @@ e_cal_view_destroy (GtkObject *object)
 			cal_view->priv->clipboard_selection = NULL;
 		}
 
+		if (cal_view->priv->default_category) {
+			g_free (cal_view->priv->default_category);
+			cal_view->priv->default_category = NULL;
+		}
+
 		g_free (cal_view->priv);
 		cal_view->priv = NULL;
 	}
@@ -460,11 +526,35 @@ e_cal_view_set_timezone (ECalView *cal_view, icaltimezone *zone)
 		       old_zone, cal_view->priv->zone);
 }
 
+const char *
+e_cal_view_get_default_category (ECalView *cal_view)
+{
+	g_return_val_if_fail (E_IS_CAL_VIEW (cal_view), NULL);
+	return (const char *) cal_view->priv->default_category;
+}
+
+/**
+ * e_cal_view_set_default_category
+ * @cal_view: A calendar view.
+ * @category: Default category name or NULL for no category.
+ *
+ * Sets the default category that will be used when creating new calendar
+ * components from the given calendar view.
+ */
 void
-e_cal_view_set_status_message (ECalView *cal_view, const gchar *message)
+e_cal_view_set_default_category (ECalView *cal_view, const char *category)
 {
-	extern EvolutionShellClient *global_shell_client; /* ugly */
+	g_return_if_fail (E_IS_CAL_VIEW (cal_view));
+
+	if (cal_view->priv->default_category)
+		g_free (cal_view->priv->default_category);
+
+	cal_view->priv->default_category = g_strdup (category);
+}
 
+void
+e_cal_view_set_status_message (ECalView *cal_view, const gchar *message)
+{
 	g_return_if_fail (E_IS_CAL_VIEW (cal_view));
 
 	if (!message || !*message) {
@@ -473,14 +563,19 @@ e_cal_view_set_status_message (ECalView *cal_view, const gchar *message)
 			cal_view->priv->activity = NULL;
 		}
 	} else if (!cal_view->priv->activity) {
+#if 0
 		int display;
+#endif
 		char *client_id = g_strdup_printf ("%p", cal_view);
 
 		if (progress_icon[0] == NULL)
 			progress_icon[0] = gdk_pixbuf_new_from_file (EVOLUTION_IMAGESDIR "/" EVOLUTION_CALENDAR_PROGRESS_IMAGE, NULL);
+
+#if 0
 		cal_view->priv->activity = evolution_activity_client_new (
 			global_shell_client, client_id,
 			progress_icon, message, TRUE, &display);
+#endif
 
 		g_free (client_id);
 	} else
@@ -564,9 +659,9 @@ e_cal_view_cut_clipboard (ECalView *cal_view)
 	e_cal_view_copy_clipboard (cal_view);
 	for (l = selected; l != NULL; l = l->next) {
 		CalComponent *comp;
-
 		ECalViewEvent *event = (ECalViewEvent *) l->data;
-
+		GError *error = NULL;
+		
 		if (!event)
 			continue;
 
@@ -580,9 +675,11 @@ e_cal_view_cut_clipboard (ECalView *cal_view)
 					event->comp_data->client, NULL);
 
 		cal_component_get_uid (comp, &uid);
-		delete_error_dialog (cal_client_remove_object (event->comp_data->client, uid),
-				     CAL_COMPONENT_EVENT);
+		cal_client_remove_object (event->comp_data->client, uid, &error);
+		delete_error_dialog (error, CAL_COMPONENT_EVENT);
 
+		g_clear_error (&error);
+		
 		g_object_unref (comp);
 	}
 
@@ -657,7 +754,8 @@ delete_event (ECalView *cal_view, ECalViewEvent *event)
 
 	if (delete_component_dialog (comp, FALSE, 1, vtype, GTK_WIDGET (cal_view))) {
 		const char *uid;
-
+		GError *error = NULL;
+		
 		if (itip_organizer_is_user (comp, event->comp_data->client) 
 		    && cancel_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (cal_view)),
 						event->comp_data->client,
@@ -670,9 +768,10 @@ delete_event (ECalView *cal_view, ECalViewEvent *event)
 			g_object_unref (comp);
 			return;
 		}
-
-		delete_error_dialog (
-			cal_client_remove_object (event->comp_data->client, uid), CAL_COMPONENT_EVENT);
+		
+		cal_client_remove_object (event->comp_data->client, uid, &error);
+		delete_error_dialog (error, CAL_COMPONENT_EVENT);
+		g_clear_error (&error);
 	}
 
 	g_object_unref (comp);
@@ -719,35 +818,21 @@ e_cal_view_delete_selected_occurrence (ECalView *cal_view)
 {
 	ECalViewEvent *event;
 	GList *selected;
-
+	const char *uid;
+	GError *error = NULL;
+		
 	selected = e_cal_view_get_selected_events (cal_view);
 	if (!selected)
 		return;
 
 	event = (ECalViewEvent *) selected->data;
 
-	if (cal_util_component_is_instance (event->comp_data->icalcomp)) {
-		const char *uid;
-
-		uid = icalcomponent_get_uid (event->comp_data->icalcomp);
-		delete_error_dialog (
-			cal_client_remove_object_with_mod (event->comp_data->client, uid, CALOBJ_MOD_THIS),
-			CAL_COMPONENT_EVENT);
-	} else {
-		CalComponent *comp;
+	uid = icalcomponent_get_uid (event->comp_data->icalcomp);
+	/* FIXME: use 'rid' argument */
+	cal_client_remove_object_with_mod (event->comp_data->client, uid, NULL, CALOBJ_MOD_THIS, &error);
 
-		/* we must duplicate the CalComponent, or we won't know it has changed
-		   when we get the "update_event" signal */
-		comp = cal_component_new ();
-		cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
-		cal_comp_util_add_exdate (comp, event->start, cal_view->priv->zone);
-
-		if (cal_client_update_object (event->comp_data->client, comp)
-		    != CAL_CLIENT_RESULT_SUCCESS)
-			g_message ("e_cal_view_delete_selected_occurrence(): Could not update the object!");
-
-		g_object_unref (comp);
-	}
+	delete_error_dialog (error, CAL_COMPONENT_EVENT);
+	g_clear_error (&error);
 
 	/* free memory */
 	g_list_free (selected);
@@ -756,11 +841,9 @@ e_cal_view_delete_selected_occurrence (ECalView *cal_view)
 static void
 on_new_appointment (GtkWidget *widget, gpointer user_data)
 {
-	time_t dtstart, dtend;
 	ECalView *cal_view = (ECalView *) user_data;
 
-	e_cal_view_get_selected_time_range (cal_view, &dtstart, &dtend);
-	gnome_calendar_new_appointment_for (cal_view->priv->calendar, dtstart, dtend, FALSE, FALSE);
+	e_cal_view_new_appointment (cal_view);
 }
 
 static void
@@ -770,7 +853,7 @@ on_new_event (GtkWidget *widget, gpointer user_data)
 	ECalView *cal_view = (ECalView *) user_data;
 
 	e_cal_view_get_selected_time_range (cal_view, &dtstart, &dtend);
-	gnome_calendar_new_appointment_for (cal_view->priv->calendar, dtstart, dtend, TRUE, FALSE);
+	e_cal_view_new_appointment_for (cal_view, dtstart, dtend, TRUE, FALSE);
 }
 
 static void
@@ -780,7 +863,7 @@ on_new_meeting (GtkWidget *widget, gpointer user_data)
 	ECalView *cal_view = (ECalView *) user_data;
 
 	e_cal_view_get_selected_time_range (cal_view, &dtstart, &dtend);
-	gnome_calendar_new_appointment_for (cal_view->priv->calendar, dtstart, dtend, FALSE, TRUE);
+	e_cal_view_new_appointment_for (cal_view, dtstart, dtend, FALSE, TRUE);
 }
 
 static void
@@ -817,8 +900,8 @@ on_edit_appointment (GtkWidget *widget, gpointer user_data)
 		ECalViewEvent *event = (ECalViewEvent *) selected->data;
 
 		if (event)
-			gnome_calendar_edit_object (cal_view->priv->calendar, event->comp_data->client,
-						    event->comp_data->icalcomp, FALSE);
+			e_cal_view_edit_appointment (cal_view, event->comp_data->client,
+						     event->comp_data->icalcomp, FALSE);
 
 		g_list_free (selected);
 	}
@@ -834,7 +917,7 @@ on_print (GtkWidget *widget, gpointer user_data)
 
 	cal_view = E_CAL_VIEW (user_data);
 
-	gnome_calendar_get_current_time_range (cal_view->priv->calendar, &start, NULL);
+	e_cal_view_get_visible_time_range (cal_view, &start, NULL);
 	view_type = gnome_calendar_get_view (cal_view->priv->calendar);
 
 	switch (view_type) {
@@ -930,7 +1013,7 @@ on_meeting (GtkWidget *widget, gpointer user_data)
 	selected = e_cal_view_get_selected_events (cal_view);
 	if (selected) {
 		ECalViewEvent *event = (ECalViewEvent *) selected->data;
-		gnome_calendar_edit_object (cal_view->priv->calendar, event->comp_data->client, event->comp_data->icalcomp, TRUE);
+		e_cal_view_edit_appointment (cal_view, event->comp_data->client, event->comp_data->icalcomp, TRUE);
 
 		g_list_free (selected);
 	}
@@ -962,7 +1045,7 @@ on_publish (GtkWidget *widget, gpointer user_data)
 	ECalView *cal_view;
 	icaltimezone *utc;
 	time_t start = time (NULL), end;
-	GList *comp_list, *client_list, *cl;
+	GList *comp_list = NULL, *client_list, *cl;
 
 	cal_view = E_CAL_VIEW (user_data);
 
@@ -972,8 +1055,7 @@ on_publish (GtkWidget *widget, gpointer user_data)
 
 	client_list = e_cal_model_get_client_list (cal_view->priv->model);
 	for (cl = client_list; cl != NULL; cl = cl->next) {
-		comp_list = cal_client_get_free_busy ((CalClient *) cl->data, NULL, start, end);
-		if (comp_list) {
+		if (cal_client_get_free_busy ((CalClient *) cl->data, NULL, start, end, &comp_list, NULL)) {
 			GList *l;
 
 			for (l = comp_list; l; l = l->next) {
@@ -1041,14 +1123,6 @@ on_paste (GtkWidget *widget, gpointer user_data)
 	e_cal_view_paste_clipboard (cal_view);
 }
 
-static void
-on_unrecur_appointment (GtkWidget *widget, gpointer user_data)
-{
-	ECalView *cal_view = E_CAL_VIEW (user_data);
-
-	gnome_calendar_unrecur_selection (cal_view->priv->calendar);
-}
-
 enum {
 	/*
 	 * This is used to "flag" events that can not be editted
@@ -1142,7 +1216,6 @@ static EPopupMenu child_items [] = {
 	E_POPUP_SEPARATOR,
 
 	E_POPUP_ITEM (N_("_Delete"), GTK_SIGNAL_FUNC (on_delete_appointment), MASK_EDITABLE | MASK_SINGLE | MASK_EDITING),
-	E_POPUP_ITEM (N_("Make this Occurrence _Movable"), GTK_SIGNAL_FUNC (on_unrecur_appointment), MASK_RECURRING | MASK_EDITING | MASK_EDITABLE | MASK_INSTANCE),
 	E_POPUP_ITEM (N_("Delete this _Occurrence"), GTK_SIGNAL_FUNC (on_delete_occurrence), MASK_RECURRING | MASK_EDITING | MASK_EDITABLE),
 	E_POPUP_ITEM (N_("Delete _All Occurrences"), GTK_SIGNAL_FUNC (on_delete_appointment), MASK_RECURRING | MASK_EDITING | MASK_EDITABLE),
 
@@ -1209,21 +1282,18 @@ setup_popup_icons (EPopupMenu *context_menu)
 GtkMenu *
 e_cal_view_create_popup_menu (ECalView *cal_view)
 {
-	gboolean being_edited, have_selection;
 	GList *selected;
 	EPopupMenu *context_menu;
 	guint32 disable_mask = 0, hide_mask = 0;
 	GtkMenu *popup;
 	CalClient *client = NULL;
-
+	gboolean read_only = TRUE;
+	
 	g_return_val_if_fail (E_IS_CAL_VIEW (cal_view), NULL);
 
 	/* get the selection */
-	being_edited = FALSE;
 	selected = e_cal_view_get_selected_events (cal_view);
 
-	have_selection = GTK_WIDGET_HAS_FOCUS (cal_view) && selected != NULL;
-
 	if (selected == NULL) {
 		cal_view->priv->view_menu = gnome_calendar_setup_view_popup (cal_view->priv->calendar);
 		main_items[9].submenu = cal_view->priv->view_menu;
@@ -1260,15 +1330,158 @@ e_cal_view_create_popup_menu (ECalView *cal_view)
 		client = event->comp_data->client;
 	}
 
-	if (cal_client_is_read_only (client))
+	cal_client_is_read_only (client, &read_only, NULL);
+	if (read_only)
 		disable_mask |= MASK_EDITABLE;
 
-	if (being_edited)
-		disable_mask |= MASK_EDITING;
-
 	setup_popup_icons (context_menu);
 	popup = e_popup_menu_create (context_menu, disable_mask, hide_mask, cal_view);
 	g_signal_connect (popup, "selection-done", G_CALLBACK (free_view_popup), cal_view);
 
 	return popup;
 }
+
+/**
+ * e_cal_view_new_appointment_for
+ * @cal_view: A calendar view.
+ * @dtstart: A Unix time_t that marks the beginning of the appointment.
+ * @dtend: A Unix time_t that marks the end of the appointment.
+ * @all_day: If TRUE, the dtstart and dtend are expanded to cover
+ * the entire day, and the event is set to TRANSPARENT.
+ * @meeting: Whether the appointment is a meeting or not.
+ *
+ * Opens an event editor dialog for a new appointment.
+ */
+void
+e_cal_view_new_appointment_for (ECalView *cal_view,
+				time_t dtstart, time_t dtend,
+				gboolean all_day,
+				gboolean meeting)
+{
+	ECalViewPrivate *priv;
+	struct icaltimetype itt;
+	CalComponentDateTime dt;
+	CalComponent *comp;
+	icalcomponent *icalcomp;
+	CalComponentTransparency transparency;
+
+	g_return_if_fail (E_IS_CAL_VIEW (cal_view));
+
+	priv = cal_view->priv;
+
+	dt.value = &itt;
+	if (all_day)
+		dt.tzid = NULL;
+	else
+		dt.tzid = icaltimezone_get_tzid (priv->zone);
+
+	icalcomp = e_cal_model_create_component_with_defaults (priv->model);
+	comp = cal_component_new ();
+	cal_component_set_icalcomponent (comp, icalcomp);
+
+	/* DTSTART, DTEND */
+	itt = icaltime_from_timet_with_zone (dtstart, FALSE, priv->zone);
+	if (all_day) {
+		itt.hour = itt.minute = itt.second = 0;
+		itt.is_date = TRUE;
+	}
+	cal_component_set_dtstart (comp, &dt);
+
+	itt = icaltime_from_timet_with_zone (dtend, FALSE, priv->zone);
+	if (all_day) {
+		/* We round it up to the end of the day, unless it is
+		   already set to midnight */
+		if (itt.hour != 0 || itt.minute != 0 || itt.second != 0) {
+			icaltime_adjust (&itt, 1, 0, 0, 0);
+		}
+		itt.hour = itt.minute = itt.second = 0;
+		itt.is_date = TRUE;
+	}
+	cal_component_set_dtend (comp, &dt);
+
+	/* TRANSPARENCY */
+	transparency = all_day ? CAL_COMPONENT_TRANSP_TRANSPARENT
+		: CAL_COMPONENT_TRANSP_OPAQUE;
+	cal_component_set_transparency (comp, transparency);
+
+	/* CATEGORY */
+	cal_component_set_categories (comp, priv->default_category);
+
+	/* edit the object */
+	cal_component_commit_sequence (comp);
+
+	e_cal_view_edit_appointment (cal_view,
+				     e_cal_model_get_default_client (priv->model),
+				     icalcomp, meeting);
+
+	g_object_unref (comp);
+}
+
+/**
+ * e_cal_view_new_appointment
+ * @cal_view: A calendar view.
+ *
+ * Opens an event editor dialog for a new appointment. The appointment's
+ * start and end times are set to the currently selected time range in
+ * the calendar view.
+ */
+void
+e_cal_view_new_appointment (ECalView *cal_view)
+{
+	time_t dtstart, dtend;
+
+	g_return_if_fail (E_IS_CAL_VIEW (cal_view));
+
+	e_cal_view_get_selected_time_range (cal_view, &dtstart, &dtend);
+	e_cal_view_new_appointment_for (cal_view, dtstart, dtend, FALSE, FALSE);
+}
+
+/**
+ * e_cal_view_edit_appointment
+ * @cal_view: A calendar view.
+ * @client: Calendar client.
+ * @icalcomp: The object to be edited.
+ * @meeting: Whether the appointment is a meeting or not.
+ *
+ * Opens an editor window to allow the user to edit the selected
+ * object.
+ */
+void
+e_cal_view_edit_appointment (ECalView *cal_view,
+			     CalClient *client,
+			     icalcomponent *icalcomp,
+			     gboolean meeting)
+{
+	ECalViewPrivate *priv;
+	CompEditor *ce;
+	const char *uid;
+	CalComponent *comp;
+
+	g_return_if_fail (E_IS_CAL_VIEW (cal_view));
+	g_return_if_fail (IS_CAL_CLIENT (client));
+	g_return_if_fail (icalcomp != NULL);
+
+	priv = cal_view->priv;
+
+	uid = icalcomponent_get_uid (icalcomp);
+
+	ce = e_comp_editor_registry_find (comp_editor_registry, uid);
+	if (!ce) {
+		EventEditor *ee;
+
+		ee = event_editor_new (client);
+		ce = COMP_EDITOR (ee);
+
+		comp = cal_component_new ();
+		cal_component_set_icalcomponent (comp, icalcomponent_new_clone (icalcomp));
+		comp_editor_edit_comp (ce, comp);
+		if (meeting)
+			event_editor_show_meeting (ee);
+
+		e_comp_editor_registry_add (comp_editor_registry, ce, FALSE);
+
+		g_object_unref (comp);
+	}
+
+	comp_editor_focus (ce);
+}
diff --git a/calendar/gui/e-calendar-view.h b/calendar/gui/e-calendar-view.h
index ea7c11a00d..9a09a5236a 100644
--- a/calendar/gui/e-calendar-view.h
+++ b/calendar/gui/e-calendar-view.h
@@ -96,6 +96,8 @@ ECalModel     *e_cal_view_get_model (ECalView *cal_view);
 void           e_cal_view_set_model (ECalView *cal_view, ECalModel *model);
 icaltimezone  *e_cal_view_get_timezone (ECalView *cal_view);
 void           e_cal_view_set_timezone (ECalView *cal_view, icaltimezone *zone);
+const char    *e_cal_view_get_default_category (ECalView *cal_view);
+void           e_cal_view_set_default_category (ECalView *cal_view, const char *category);
 
 void           e_cal_view_set_status_message (ECalView *cal_view, const gchar *message);
 
@@ -114,6 +116,17 @@ void           e_cal_view_delete_selected_occurrence (ECalView *cal_view);
 
 GtkMenu       *e_cal_view_create_popup_menu (ECalView *cal_view);
 
+void           e_cal_view_new_appointment_for (ECalView *cal_view,
+					       time_t dtstart,
+					       time_t dtend,
+					       gboolean all_day,
+					       gboolean meeting);
+void           e_cal_view_new_appointment (ECalView *cal_view);
+void           e_cal_view_edit_appointment (ECalView *cal_view,
+					    CalClient *client,
+					    icalcomponent *icalcomp,
+					    gboolean meeting);
+
 G_END_DECLS
 
 #endif
diff --git a/calendar/gui/e-day-view.c b/calendar/gui/e-day-view.c
index a2a4f09d56..b4ec9faea0 100644
--- a/calendar/gui/e-day-view.c
+++ b/calendar/gui/e-day-view.c
@@ -65,6 +65,7 @@
 #include "calendar-commands.h"
 #include "calendar-config.h"
 #include "goto.h"
+#include "e-cal-model-calendar.h"
 #include "e-day-view-time-item.h"
 #include "e-day-view-top-item.h"
 #include "e-day-view-layout.h"
@@ -592,8 +593,6 @@ e_day_view_init (EDayView *day_view)
 
 	day_view->auto_scroll_timeout_id = 0;
 
-	day_view->default_category = NULL;
-
 	day_view->large_font_desc = NULL;
 
 	/* String to use in 12-hour time format for times in the morning. */
@@ -850,8 +849,11 @@ GtkWidget *
 e_day_view_new (void)
 {
 	GtkWidget *day_view;
+	ECalModel *model;
+	
+	model = E_CAL_MODEL (e_cal_model_calendar_new ());
 
-	day_view = GTK_WIDGET (g_object_new (e_day_view_get_type (), NULL));
+	day_view = GTK_WIDGET (g_object_new (e_day_view_get_type (), "model", model, NULL));
 
 	return day_view;
 }
@@ -881,12 +883,6 @@ e_day_view_destroy (GtkObject *object)
 		day_view->large_font_desc = NULL;
 	}
 
-	if (day_view->default_category) {
-		g_free (day_view->default_category);
-		day_view->default_category = NULL;
-	}
-
-	
 	if (day_view->normal_cursor) {
 		gdk_cursor_unref (day_view->normal_cursor);
 		day_view->normal_cursor = NULL;
@@ -1429,26 +1425,6 @@ e_day_view_focus_out (GtkWidget *widget, GdkEventFocus *event)
 	return FALSE;
 }
 
-/**
- * e_day_view_set_default_category:
- * @day_view: A day view.
- * @category: Default category name or NULL for no category.
- * 
- * Sets the default category that will be used when creating new calendar
- * components from the day view.
- **/
-void
-e_day_view_set_default_category (EDayView *day_view, const char *category)
-{
-	g_return_if_fail (day_view != NULL);
-	g_return_if_fail (E_IS_DAY_VIEW (day_view));
-
-	if (day_view->default_category)
-		g_free (day_view->default_category);
-
-	day_view->default_category = g_strdup (category);
-}
-
 static gboolean
 e_day_view_update_event_cb (EDayView *day_view,
 			    gint day,
@@ -1794,6 +1770,9 @@ e_day_view_find_event_from_uid (EDayView *day_view,
 	gint day, event_num;
 	const char *u;
 
+	if (!uid)
+		return FALSE;
+
 	for (day = 0; day < day_view->days_shown; day++) {
 		for (event_num = 0; event_num < day_view->events[day]->len;
 		     event_num++) {
@@ -2048,7 +2027,6 @@ e_day_view_find_work_week_start		(EDayView	*day_view,
 	return icaltime_as_timet_with_zone (tt, e_cal_view_get_timezone (E_CAL_VIEW (day_view)));
 }
 
-
 /* Returns the selected time range. */
 static void
 e_day_view_get_selected_time_range (ECalView *cal_view, time_t *start_time, time_t *end_time)
@@ -2123,6 +2101,8 @@ e_day_view_recalc_day_starts (EDayView *day_view,
 
 	day_view->lower = start_time;
 	day_view->upper = day_view->day_starts[day_view->days_shown];
+
+	e_day_view_update_query (day_view);
 }
 
 
@@ -2588,9 +2568,9 @@ e_day_view_on_top_canvas_button_press (GtkWidget *widget,
 			time_t dtstart, dtend;
 
 			e_day_view_get_selected_time_range ((ECalView *) day_view, &dtstart, &dtend);
-			gnome_calendar_new_appointment_for (e_cal_view_get_calendar (E_CAL_VIEW (day_view)),
-							    dtstart, dtend,
-							    TRUE, FALSE);
+			e_cal_view_new_appointment_for (E_CAL_VIEW (day_view),
+							dtstart, dtend,
+							TRUE, FALSE);
 			return TRUE;
 		}
 
@@ -2709,9 +2689,9 @@ e_day_view_on_main_canvas_button_press (GtkWidget *widget,
 			time_t dtstart, dtend;
 
 			e_day_view_get_selected_time_range ((ECalView *) day_view, &dtstart, &dtend);
-			gnome_calendar_new_appointment_for (e_cal_view_get_calendar (E_CAL_VIEW (day_view)),
-							    dtstart, dtend,
-							    FALSE, FALSE);
+			e_cal_view_new_appointment_for (E_CAL_VIEW (day_view),
+							dtstart, dtend,
+							FALSE, FALSE);
 			return TRUE;
 		}
 
@@ -3101,7 +3081,6 @@ e_day_view_on_event_double_click (EDayView *day_view,
 				  gint event_num)
 {
 	EDayViewEvent *event;
-	GnomeCalendar *calendar;
 
 	if (day == -1)
 		event = &g_array_index (day_view->long_events, EDayViewEvent,
@@ -3112,11 +3091,9 @@ e_day_view_on_event_double_click (EDayView *day_view,
 
 	e_day_view_stop_editing_event (day_view);
 
-	calendar = e_cal_view_get_calendar (E_CAL_VIEW (day_view));
-	if (calendar)
-		gnome_calendar_edit_object (calendar, event->comp_data->client, event->comp_data->icalcomp, FALSE);
-	else
-		g_warning ("Calendar not set");
+	e_cal_view_edit_appointment (E_CAL_VIEW (day_view),
+				     event->comp_data->client, 
+				     event->comp_data->icalcomp, FALSE);
 }
 
 static void
@@ -3207,7 +3184,6 @@ process_component (EDayView *day_view, ECalModelComponent *comp_data)
 						EDayViewEvent, event_num);
 
 		if (!cal_util_component_has_recurrences (comp_data->icalcomp)
-		    && !cal_component_has_recurrences (event->comp_data->icalcomp)
 		    && cal_util_event_dates_match (event->comp_data->icalcomp, comp_data->icalcomp)) {
 #if 0
 			g_print ("updated object's dates unchanged\n");
@@ -3228,17 +3204,18 @@ process_component (EDayView *day_view, ECalModelComponent *comp_data)
 						   NULL);
 	}
 
-	/* Add the occurrences of the event. */
+	/* Add the occurrences of the event */
 	comp = cal_component_new ();
 	cal_component_set_icalcomponent (comp, icalcomponent_new_clone (comp_data->icalcomp));
+
 	add_event_data.day_view = day_view;
 	add_event_data.comp_data = comp_data;
 	cal_recur_generate_instances (comp, day_view->lower,
 				      day_view->upper,
 				      e_day_view_add_event, &add_event_data,
-				      cal_client_resolve_tzid_cb,
-				      comp_data->client,
+				      cal_client_resolve_tzid_cb, comp_data->client,
 				      e_cal_view_get_timezone (E_CAL_VIEW (day_view)));
+
 	g_object_unref (comp);
 
 	e_day_view_queue_layout (day_view);
@@ -3258,8 +3235,6 @@ e_day_view_update_query (ECalView *cal_view)
 	e_day_view_free_events (day_view);
 	e_day_view_queue_layout (day_view);
 
-	e_cal_view_set_status_message (E_CAL_VIEW (day_view), _("Searching"));
-
 	rows = e_table_model_row_count (E_TABLE_MODEL (e_cal_view_get_model (E_CAL_VIEW (day_view))));
 	for (r = 0; r < rows; r++) {
 		ECalModelComponent *comp_data;
@@ -3268,8 +3243,6 @@ e_day_view_update_query (ECalView *cal_view)
 		g_assert (comp_data != NULL);
 		process_component (day_view, comp_data);
 	}
-
-	e_cal_view_set_status_message (E_CAL_VIEW (day_view), NULL);
 }
 
 static void
@@ -3282,67 +3255,6 @@ e_day_view_on_event_right_click (EDayView *day_view,
 				    day, event_num);
 }
 
-void
-e_day_view_unrecur_appointment (EDayView *day_view)
-{
-	EDayViewEvent *event;
-	CalComponent *comp, *new_comp;
-	CalComponentDateTime date;
-	struct icaltimetype itt;
-
-	event = e_day_view_get_popup_menu_event (day_view);
-	if (event == NULL)
-		return;
-
-	date.value = &itt;
-	date.tzid = NULL;
-
-	/* For the recurring object, we add an exception to get rid of the
-	   instance. */
-
-	comp = cal_component_new ();
-	cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
-	cal_comp_util_add_exdate (comp, event->start, e_cal_view_get_timezone (E_CAL_VIEW (day_view)));
-
-	/* For the unrecurred instance we duplicate the original object,
-	   create a new uid for it, get rid of the recurrence rules, and set
-	   the start & end times to the instances times. */
-	new_comp = cal_component_new ();
-	cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
-	cal_component_set_uid (new_comp, cal_component_gen_uid ());
-	cal_component_set_rdate_list (new_comp, NULL);
-	cal_component_set_rrule_list (new_comp, NULL);
-	cal_component_set_exdate_list (new_comp, NULL);
-	cal_component_set_exrule_list (new_comp, NULL);
-
-	date.value = &itt;
-	date.tzid = icaltimezone_get_tzid (e_cal_view_get_timezone (E_CAL_VIEW (day_view)));
-
-	*date.value = icaltime_from_timet_with_zone (event->start, FALSE,
-						     e_cal_view_get_timezone (E_CAL_VIEW (day_view)));
-	cal_component_set_dtstart (new_comp, &date);
-	*date.value = icaltime_from_timet_with_zone (event->end, FALSE,
-						     e_cal_view_get_timezone (E_CAL_VIEW (day_view)));
-	cal_component_set_dtend (new_comp, &date);
-
-
-	/* Now update both CalComponents. Note that we do this last since at
-	 * present the updates happen synchronously so our event may disappear.
-	 */
-	if (cal_client_update_object (event->comp_data->client, comp)
-	    != CAL_CLIENT_RESULT_SUCCESS)
-		g_message ("e_day_view_on_unrecur_appointment(): Could not update the object!");
-
-	g_object_unref (comp);
-
-	if (cal_client_update_object (event->comp_data->client, new_comp)
-	    != CAL_CLIENT_RESULT_SUCCESS)
-		g_message ("e_day_view_on_unrecur_appointment(): Could not update the object!");
-
-	g_object_unref (new_comp);
-}
-
-
 static EDayViewEvent*
 e_day_view_get_popup_menu_event (EDayView *day_view)
 {
@@ -3841,7 +3753,9 @@ e_day_view_finish_long_event_resize (EDayView *day_view)
 	struct icaltimetype itt;
 	time_t dt;
 	CalClient *client;
-
+	CalObjModType mod = CALOBJ_MOD_ALL;
+	GtkWindow *toplevel;
+	
 	event_num = day_view->resize_event_num;
 	event = &g_array_index (day_view->long_events, EDayViewEvent,
 				event_num);
@@ -3870,31 +3784,26 @@ e_day_view_finish_long_event_resize (EDayView *day_view)
 							     e_cal_view_get_timezone (E_CAL_VIEW (day_view)));
 		cal_component_set_dtend (comp, &date);
 	}
-
- 	if (cal_component_is_instance (comp)) {
- 		CalObjModType mod;
- 
- 		if (recur_component_dialog (comp, &mod, NULL)) {
- 			if (cal_client_update_object_with_mod (client, comp, mod) == CAL_CLIENT_RESULT_SUCCESS) {
- 				if (itip_organizer_is_user (comp, client) &&
-				    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (day_view)),
-							   client, comp, FALSE))
- 					itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, client, NULL);
- 			} else {
- 				g_message ("e_day_view_finish_resize(): Could not update the object!");
- 			}
- 		} else {
+	
+ 	if (cal_component_has_recurrences (comp)) {
+ 		if (!recur_component_dialog (comp, &mod, NULL)) {
  			gtk_widget_queue_draw (day_view->top_canvas);
- 		}		
- 	} else if (cal_client_update_object (client, comp) == CAL_CLIENT_RESULT_SUCCESS) {
- 		if (itip_organizer_is_user (comp, client) &&
-		    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (day_view)),
-					   client, comp, TRUE))
-  			itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, client, NULL);
-  	} else {
-  		g_message ("e_day_view_finish_long_event_resize(): Could not update the object!");
-  	}
-  
+			goto out;
+ 		}
+	}
+	
+	toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (day_view)));
+	
+ 	if (cal_client_modify_object (client, cal_component_get_icalcomponent (comp), mod, NULL)) {
+		if (itip_organizer_is_user (comp, client) &&
+		    send_component_dialog (toplevel, client, comp, TRUE)) {
+			itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, client, NULL);
+		} else {
+			g_message (G_STRLOC ": Could not update the object!");
+		}
+	}
+	
+ out:
  	gnome_canvas_item_hide (day_view->resize_long_event_rect_item);
  
  	day_view->resize_drag_pos = E_CAL_VIEW_POS_NONE;
@@ -3915,6 +3824,8 @@ e_day_view_finish_resize (EDayView *day_view)
 	struct icaltimetype itt;
 	time_t dt;
 	CalClient *client;
+	CalObjModType mod = CALOBJ_MOD_ALL;
+	GtkWindow *toplevel;
 
 	day = day_view->resize_event_day;
 	event_num = day_view->resize_event_num;
@@ -3957,29 +3868,26 @@ e_day_view_finish_resize (EDayView *day_view)
 
 	day_view->resize_drag_pos = E_CAL_VIEW_POS_NONE;
 
-	if (cal_component_is_instance (comp)) {
-		CalObjModType mod;
+ 	if (cal_component_has_recurrences (comp)) {
+ 		if (!recur_component_dialog (comp, &mod, NULL)) {
+ 			gtk_widget_queue_draw (day_view->top_canvas);
+			goto out;
+ 		}
+	}
+	
+	toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (day_view)));
 
-		if (recur_component_dialog (comp, &mod, NULL)) {
-			if (cal_client_update_object_with_mod (client, comp, mod) == CAL_CLIENT_RESULT_SUCCESS) {
-				if (itip_organizer_is_user (comp, client) &&
-				    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (day_view)),
-							   client, comp, FALSE))
-					itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, client, NULL);
-			} else {
-				g_message ("e_day_view_finish_resize(): Could not update the object!");
-			}
-		} else {
-			gtk_widget_queue_draw (day_view->main_canvas);
-		}		
-	} else if (cal_client_update_object (client, comp) == CAL_CLIENT_RESULT_SUCCESS) {
+	cal_component_commit_sequence (comp);
+ 	if (cal_client_modify_object (client, cal_component_get_icalcomponent (comp), mod, NULL)) {
 		if (itip_organizer_is_user (comp, client) &&
-		    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (day_view)), client, comp, FALSE))
+		    send_component_dialog (toplevel, client, comp, TRUE)) {
 			itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, client, NULL);
-	} else {
-		g_message ("e_day_view_finish_resize(): Could not update the object!");
-	}
-	
+		} else {
+			g_message (G_STRLOC ": Could not update the object!");
+		}
+	}	
+
+ out:	
 	g_object_unref (comp);
 }
 
@@ -4774,6 +4682,8 @@ e_day_view_do_key_press (GtkWidget *widget, GdkEventKey *event)
 	/* Add a new event covering the selected range */
 
 	icalcomp = e_cal_model_create_component_with_defaults (e_cal_view_get_model (E_CAL_VIEW (day_view)));
+	if (!icalcomp)
+		return FALSE;
 	uid = icalcomponent_get_uid (icalcomp);
 
 	comp = cal_component_new ();
@@ -4801,7 +4711,8 @@ e_day_view_do_key_press (GtkWidget *widget, GdkEventKey *event)
 	cal_component_set_dtstart (comp, &start_dt);
 	cal_component_set_dtend (comp, &end_dt);
 
-	cal_component_set_categories (comp, day_view->default_category);
+	cal_component_set_categories (
+		comp, e_cal_view_get_default_category (E_CAL_VIEW (day_view)));
 
 	/* We add the event locally and start editing it. We don't send it
 	   to the server until the user finishes editing it. */
@@ -5777,7 +5688,8 @@ e_day_view_on_editing_stopped (EDayView *day_view,
 	gchar *text = NULL;
 	CalComponentText summary;
 	CalComponent *comp;
-
+	gboolean on_server;
+	
 	/* Note: the item we are passed here isn't reliable, so we just stop
 	   the edit of whatever item was being edited. We also receive this
 	   event twice for some reason. */
@@ -5822,8 +5734,9 @@ e_day_view_on_editing_stopped (EDayView *day_view,
 	comp = cal_component_new ();
 	cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
 
-	if (string_is_empty (text) &&
-	    !cal_comp_is_on_server (comp, event->comp_data->client)) {
+	on_server = cal_comp_is_on_server (comp, event->comp_data->client);
+	
+	if (string_is_empty (text) && !on_server) {
 		const char *uid;
 		
 		cal_component_get_uid (comp, &uid);
@@ -5845,34 +5758,34 @@ e_day_view_on_editing_stopped (EDayView *day_view,
 			e_day_view_update_event_label (day_view, day,
 						       event_num);
 	} else if (summary.value || !string_is_empty (text)) {
+		icalcomponent *icalcomp = cal_component_get_icalcomponent (comp);
+
 		summary.value = text;
 		summary.altrep = NULL;
 		cal_component_set_summary (comp, &summary);
 
-		if (cal_component_is_instance (comp)) {
-			CalObjModType mod;
-			
-			if (recur_component_dialog (comp, &mod, NULL)) {
-				if (cal_client_update_object_with_mod (event->comp_data->client, comp, mod)
-				    == CAL_CLIENT_RESULT_SUCCESS) {
-					if (itip_organizer_is_user (comp, event->comp_data->client) 
-					    && send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (day_view)),
-								      event->comp_data->client, comp, FALSE))
-						itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, 
-								event->comp_data->client, NULL);
-				} else {
-					g_message ("e_day_view_on_editing_stopped(): Could not update the object!");
+		if (!on_server) {
+			if (!cal_client_create_object (event->comp_data->client, icalcomp, NULL, NULL))
+				g_message (G_STRLOC ": Could not create the object!");
+		} else {
+			CalObjModType mod = CALOBJ_MOD_ALL;
+			GtkWindow *toplevel;
+			if (cal_component_has_recurrences (comp)) {
+				if (!recur_component_dialog (comp, &mod, NULL)) {
+					goto out;
 				}
 			}
-		} else if (cal_client_update_object (event->comp_data->client, comp) == CAL_CLIENT_RESULT_SUCCESS) {
-			if (itip_organizer_is_user (comp, event->comp_data->client) &&
-			    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (day_view)),
-						   event->comp_data->client, comp, FALSE))
-				itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp,
-						event->comp_data->client, NULL);
-		} else {
-			g_message ("e_day_view_on_editing_stopped(): Could not update the object!");
+			
+			/* FIXME When sending here, what exactly should we send? */
+			toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (day_view)));
+			if (cal_client_modify_object (event->comp_data->client, icalcomp, mod, NULL)) {
+				if (itip_organizer_is_user (comp, event->comp_data->client) 
+				    && send_component_dialog (toplevel, event->comp_data->client, comp, FALSE))
+					itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, 
+							event->comp_data->client, NULL);
+			}
 		}
+		
 	}
 
  out:
@@ -6881,7 +6794,10 @@ e_day_view_on_top_canvas_drag_data_received  (GtkWidget          *widget,
 								 x, y, &day,
 								 NULL);
 		if (pos != E_CAL_VIEW_POS_OUTSIDE) {
+			CalObjModType mod = CALOBJ_MOD_ALL;
+			GtkWindow *toplevel;
 			const char *uid;
+
 			num_days = 1;
 			start_offset = 0;
 			end_offset = 0;
@@ -6972,33 +6888,20 @@ e_day_view_on_top_canvas_drag_data_received  (GtkWidget          *widget,
 			if (event->canvas_item)
 				gnome_canvas_item_show (event->canvas_item);
 
-			if (cal_component_is_instance (comp)) {
-				CalObjModType mod;
-				
-				if (recur_component_dialog (comp, &mod, NULL)) {
-					if (cal_client_update_object_with_mod (client, comp, mod) == CAL_CLIENT_RESULT_SUCCESS) {
-						if (itip_organizer_is_user (comp, client) 
-						    && send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (day_view)),
-									      client, comp, FALSE))
-							itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, 
-									client, NULL);
-					} else {
-						g_message ("e_day_view_on_top_canvas_drag_data_received(): Could "
-							   "not update the object!");
-					}
-				}
-			} else if (cal_client_update_object (client, comp)
-			    == CAL_CLIENT_RESULT_SUCCESS) {
-				if (itip_organizer_is_user (comp, client) &&
-				    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (day_view)),
-							   client, comp, FALSE))
-					itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp,
-							client, NULL);
-			} else {
-				g_message ("e_day_view_on_top_canvas_drag_data_received(): Could "
-					   "not update the object!");
+			if (cal_component_has_recurrences (comp)) {
+				if (!recur_component_dialog (comp, &mod, NULL))
+					return;
 			}
 
+			toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (day_view)));
+	
+			if (cal_client_modify_object (client, cal_component_get_icalcomponent (comp), mod, NULL)) {
+				if (itip_organizer_is_user (comp, client) 
+				    && send_component_dialog (toplevel, client, comp, FALSE))
+					itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, 
+							client, NULL);
+			}
+			
 			g_object_unref (comp);
 
 			return;
@@ -7044,7 +6947,10 @@ e_day_view_on_main_canvas_drag_data_received  (GtkWidget          *widget,
 								  x, y, &day,
 								  &row, NULL);
 		if (pos != E_CAL_VIEW_POS_OUTSIDE) {
+			CalObjModType mod = CALOBJ_MOD_ALL;
+			GtkWindow *toplevel;
 			const char *uid;
+
 			num_rows = 1;
 			start_offset = 0;
 			end_offset = 0;
@@ -7109,30 +7015,20 @@ e_day_view_on_main_canvas_drag_data_received  (GtkWidget          *widget,
 			if (event->canvas_item)
 				gnome_canvas_item_show (event->canvas_item);
 
-			if (cal_component_is_instance (comp)) {
-				CalObjModType mod;
-				
-				if (recur_component_dialog (comp, &mod, NULL)) {
-					if (cal_client_update_object_with_mod (client, comp, mod) == CAL_CLIENT_RESULT_SUCCESS) {
-						if (itip_organizer_is_user (comp, client) 
-						    && send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (day_view)),
-									      client, comp, FALSE))
-							itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, 
-									client, NULL);
-					} else {
-						g_message ("e_day_view_on_top_canvas_drag_data_received(): Could "
-							   "not update the object!");
-					}
+			if (cal_component_has_recurrences (comp)) {
+				if (!recur_component_dialog (comp, &mod, NULL)) {
+					g_object_unref (comp);
+					return;
 				}
-			} else if (cal_client_update_object (client, comp) == CAL_CLIENT_RESULT_SUCCESS) {
-				if (itip_organizer_is_user (comp, client) &&
-				    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (day_view)),
-							   client, comp, FALSE))
-					itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp,
+			}
+
+			toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (day_view)));
+	
+			if (cal_client_modify_object (client, cal_component_get_icalcomponent (comp), mod, NULL)) {
+				if (itip_organizer_is_user (comp, client) 
+				    && send_component_dialog (toplevel, client, comp, FALSE))
+					itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, 
 							client, NULL);
-			} else {
-				g_message ("e_day_view_on_main_canvas_drag_data_received(): "
-					   "Could not update the object!");
 			}
 
 			g_object_unref (comp);
diff --git a/calendar/gui/e-day-view.h b/calendar/gui/e-day-view.h
index 1c39fd5844..decd281127 100644
--- a/calendar/gui/e-day-view.h
+++ b/calendar/gui/e-day-view.h
@@ -453,9 +453,6 @@ struct _EDayView
 	gint am_string_width;
 	gint pm_string_width;
 
-	/* The default category for new events */
-	char *default_category;
-
 	/* The activity client used to show messages on the status bar. */
 	EvolutionActivityClient *activity;
 };
@@ -472,9 +469,6 @@ GtkWidget* e_day_view_new			(void);
 void       e_day_view_set_query			(EDayView	*day_view,
 						 const char	*sexp);
 
-void       e_day_view_set_default_category	(EDayView	*day_view,
-						 const char	*category);
-
 /* Whether we are displaying a work-week, in which case the display always
    starts on the first day of the working week. */
 gboolean   e_day_view_get_work_week_view	(EDayView	*day_view);
@@ -528,7 +522,6 @@ void	   e_day_view_set_week_start_day	(EDayView	*day_view,
 						 gint		 week_start_day);
 
 void       e_day_view_delete_occurrence         (EDayView       *day_view);
-void       e_day_view_unrecur_appointment       (EDayView *day_view);
 
 /* Returns the number of selected events (0 or 1 at present). */
 gint	   e_day_view_get_num_events_selected	(EDayView	*day_view);
diff --git a/calendar/gui/e-itip-control.c b/calendar/gui/e-itip-control.c
index 8b39b82b8c..d5e24c8936 100644
--- a/calendar/gui/e-itip-control.c
+++ b/calendar/gui/e-itip-control.c
@@ -94,8 +94,6 @@ struct _EItipControlPrivate {
 #define HTML_BODY_END   "</body>"
 #define HTML_FOOTER     "</html>"
 
-extern EvolutionShellClient *global_shell_client;	
-
 /* We intentionally use "calendar" instead of "calendar / *" here. We
  * don't want public calendars.
  */
@@ -132,63 +130,26 @@ class_init (EItipControlClass *klass)
 	object_class->finalize = finalize;
 }
 
-
-/* Calendar Server routines */
-static void
-start_calendar_server_cb (CalClient *cal_client,
-			  CalClientOpenStatus status,
-			  gpointer data)
-{
-	int *success = data;
-	int orig = *success;
-	
-	if (status == CAL_CLIENT_OPEN_SUCCESS)
-		*success = 1;
-	else
-		*success = 0;
-
-	if (orig != -1)
-		gtk_main_quit (); /* end the sub event loop */
-}
-
 static CalClient *
 start_calendar_server (EItipControl *itip, char *uri)
 {
 	CalClient *client;
-	int success = -1;
-
-	client = cal_client_new ();
-
-	g_signal_connect (client, "cal_opened", G_CALLBACK (start_calendar_server_cb), &success);
-
-	if (!cal_client_open_calendar (client, uri, TRUE))
- 		goto error;
-	
-	/* run a sub event loop to turn cal-client's async load
-	   notification into a synchronous call */
- 	if (success == -1 && !itip->priv->destroyed) {
-		success = 0;
-		
- 		gtk_signal_connect (GTK_OBJECT (itip), "destroy",
- 				    gtk_main_quit, NULL);
-	
-		gtk_main ();
-	
- 		gtk_signal_disconnect_by_func (GTK_OBJECT (itip),
- 					       gtk_main_quit, NULL);
- 	}
+	GError *error = NULL;
 
-	if (success == 1)
-		return client;
+	client = cal_client_new (uri, CALOBJ_TYPE_EVENT);
 
-error:
-	g_object_unref (client);
+	if (!cal_client_open (client, TRUE, &error)) {
+		g_warning (_("start_calendar_server(): %s"), error->message);
+		g_error_free (error);
+ 		g_object_unref (client);
+		return NULL;
+	}
 	
-	return NULL;
+	return client;
 }
 
 static gboolean
-start_default_server_async (EItipControl *itip, CalClient *client, gboolean tasks)
+start_default_server (EItipControl *itip, CalClient *client, gboolean tasks)
 {
 	if (tasks)
 		return cal_client_open_default_tasks (client, FALSE);
@@ -196,6 +157,7 @@ start_default_server_async (EItipControl *itip, CalClient *client, gboolean task
 		return cal_client_open_default_calendar (client, FALSE);
 }
 
+#if 0				/* EPFIXME, rewrite this */
 static GPtrArray *
 get_servers (EItipControl *itip, EvolutionShellClient *shell_client, const char *possible_types[], gboolean tasks)
 {
@@ -263,6 +225,7 @@ get_servers (EItipControl *itip, EvolutionShellClient *shell_client, const char
 
 	return servers;
 }
+#endif
 
 static CalClient *
 find_server (GPtrArray *servers, CalComponent *comp)
@@ -274,11 +237,9 @@ find_server (GPtrArray *servers, CalComponent *comp)
 	for (i = 0; i < servers->len; i++) {
 		CalClient *client;
 		icalcomponent *icalcomp;
-		CalClientGetStatus status;
 		
 		client = g_ptr_array_index (servers, i);
-		status = cal_client_get_object (client, uid, &icalcomp);
-		if (status == CAL_CLIENT_GET_SUCCESS) {
+		if (cal_client_get_object (client, uid, NULL, &icalcomp, NULL)) {
 			icalcomponent_free (icalcomp);
 			g_object_ref (client);
 
@@ -540,8 +501,7 @@ find_attendee (icalcomponent *ical_comp, const char *address)
 
 	for (prop = icalcomponent_get_first_property (ical_comp, ICAL_ATTENDEE_PROPERTY);
 	     prop != NULL;
-	     prop = icalcomponent_get_next_property (ical_comp, ICAL_ATTENDEE_PROPERTY))
-	{
+	     prop = icalcomponent_get_next_property (ical_comp, ICAL_ATTENDEE_PROPERTY)) {
 		icalvalue *value;
 		const char *attendee;
 		char *text;
@@ -762,6 +722,7 @@ write_recurrence_piece (EItipControl *itip, CalComponent *comp,
 	} else if (!icaltime_is_null_time (r->until)) {
 		CalComponentDateTime dt;
 
+		/* FIXME This should get the tzid id, not the whole zone */
 		dt.value = &r->until;
 		dt.tzid = r->until.zone;
 
@@ -1220,7 +1181,7 @@ get_real_item (EItipControl *itip)
 	CalComponent *comp;
 	icalcomponent *icalcomp;
 	CalComponentVType type;
-	CalClientGetStatus status = CAL_CLIENT_GET_NOT_FOUND;
+	gboolean found = FALSE;
 	const char *uid;
 	
 	priv = itip->priv;
@@ -1231,17 +1192,17 @@ get_real_item (EItipControl *itip)
 	switch (type) {
 	case CAL_COMPONENT_EVENT:
 		if (priv->event_client != NULL)
-			status = cal_client_get_object (priv->event_client, uid, &icalcomp);
+			found = cal_client_get_object (priv->event_client, uid, NULL, &icalcomp, NULL);
 		break;
 	case CAL_COMPONENT_TODO:
 		if (priv->task_client != NULL)
-			status = cal_client_get_object (priv->task_client, uid, &icalcomp);
+			found = cal_client_get_object (priv->task_client, uid, NULL, &icalcomp, NULL);
 		break;
 	default:
-		status = CAL_CLIENT_GET_NOT_FOUND;
+		found = FALSE;
 	}
 
-	if (status != CAL_CLIENT_GET_SUCCESS)
+	if (!found)
 		return NULL;
 
 	comp = cal_component_new ();
@@ -1568,13 +1529,18 @@ show_current (EItipControl *itip)
 
 	switch (type) {
 	case CAL_COMPONENT_EVENT:
-		if (!priv->event_clients)
-			priv->event_clients = get_servers (itip, global_shell_client, calendar_types, FALSE);
+		if (!priv->event_clients) {
+			priv->event_clients = g_ptr_array_new ();
+			/* EPFIXME */
+			/* priv->event_clients = get_servers (itip, global_shell_client, calendar_types, FALSE); */
+		}
 		show_current_event (itip);
 		break;
 	case CAL_COMPONENT_TODO:
-		if (!priv->task_clients)
-			priv->task_clients = get_servers (itip, global_shell_client, tasks_types, TRUE);
+		if (!priv->task_clients) {
+			/* EPFIXME */
+			/* priv->task_clients = get_servers (itip, global_shell_client, tasks_types, TRUE); */
+		}
 		show_current_todo (itip);
 		break;
 	case CAL_COMPONENT_FREEBUSY:
@@ -1853,7 +1819,6 @@ update_item (EItipControl *itip)
 	CalClient *client;
 	CalComponentVType type;
 	GtkWidget *dialog;
-	CalClientResult result;
 
 	priv = itip->priv;
 
@@ -1881,32 +1846,18 @@ update_item (EItipControl *itip)
 	icalcomponent_add_component (priv->top_level, clone);
 	icalcomponent_set_method (priv->top_level, priv->method);
 
-	result = cal_client_update_objects (client, priv->top_level);
-	switch (result) {
-	case CAL_CLIENT_RESULT_INVALID_OBJECT :
-		dialog = gnome_warning_dialog (_("Object is invalid and cannot be updated\n"));
-		break;
-	case CAL_CLIENT_RESULT_CORBA_ERROR :
-		dialog = gnome_warning_dialog (_("There was an error on the CORBA system\n"));
-		break;
-	case CAL_CLIENT_RESULT_NOT_FOUND :
-		dialog = gnome_warning_dialog (_("Object could not be found\n"));
-		break;
-	case CAL_CLIENT_RESULT_PERMISSION_DENIED :
-		dialog = gnome_warning_dialog (_("You do not have the right permissions to update the calendar\n"));
-		break;
-	case CAL_CLIENT_RESULT_SUCCESS :
-		dialog = gnome_ok_dialog (_("Update complete\n"));
-		break;
-	default :
+	/* FIXME Better error dialog */
+	if (!cal_client_receive_objects (client, priv->top_level, NULL)) {
 		dialog = gnome_warning_dialog (_("Calendar file could not be updated!\n"));
-		break;
+	} else {
+		dialog = gnome_ok_dialog (_("Update complete\n"));
 	}
 	gnome_dialog_run_and_close (GNOME_DIALOG (dialog));
 
 	icalcomponent_remove_component (priv->top_level, clone);
 }
 
+#if 0
 static void
 update_attendee_status (EItipControl *itip)
 {
@@ -1936,7 +1887,7 @@ update_attendee_status (EItipControl *itip)
 	
 	/* Obtain our version */
 	cal_component_get_uid (priv->comp, &uid);
-	status = cal_client_get_object (client, uid, &icalcomp);
+	status = cal_client_get_object (client, uid, NULL, &icalcomp);
 
 	if (status == CAL_CLIENT_GET_SUCCESS) {
 		GSList *attendees;
@@ -2010,6 +1961,7 @@ update_attendee_status (EItipControl *itip)
 		g_object_unref (comp);
 	gnome_dialog_run_and_close (GNOME_DIALOG (dialog));
 }
+#endif
 
 static void
 remove_item (EItipControl *itip)
@@ -2019,7 +1971,7 @@ remove_item (EItipControl *itip)
 	CalComponentVType type;
 	const char *uid;
 	GtkWidget *dialog;
-	CalClientResult result;
+	GError *error = NULL;
 	
 	priv = itip->priv;
 
@@ -2033,13 +1985,15 @@ remove_item (EItipControl *itip)
 		return;
 	
 	cal_component_get_uid (priv->comp, &uid);
-	result = cal_client_remove_object (client, uid);
-	if (result == CAL_CLIENT_RESULT_SUCCESS || result == CAL_CLIENT_RESULT_NOT_FOUND) {
+	cal_client_remove_object (client, uid, &error);
+	if (!error || error->code == E_CALENDAR_STATUS_OBJECT_NOT_FOUND) {
 		dialog = gnome_ok_dialog (_("Removal Complete"));
 		gnome_dialog_run_and_close (GNOME_DIALOG (dialog));
 	} else {
-		delete_error_dialog (result, type);
-	}	
+		delete_error_dialog (error, type);
+	}
+	
+	g_clear_error (&error);
 }
 
 static void
@@ -2081,7 +2035,7 @@ send_freebusy (EItipControl *itip)
 	CalComponentDateTime datetime;
 	time_t start, end;
 	GtkWidget *dialog;
-	GList *comp_list;
+	GList *comp_list = NULL;
 	icaltimezone *zone;
 
 	priv = itip->priv;
@@ -2106,9 +2060,7 @@ send_freebusy (EItipControl *itip)
 	end = icaltime_as_timet_with_zone (*datetime.value, zone);
 	cal_component_free_datetime (&datetime);
 
-	comp_list = cal_client_get_free_busy (priv->event_client, NULL, start, end);
-
-	if (comp_list) {
+	if (cal_client_get_free_busy (priv->event_client, NULL, start, end, &comp_list, NULL)) {
 		GList *l;
 
 		for (l = comp_list; l; l = l->next) {
@@ -2210,6 +2162,7 @@ default_server_started_cb (CalClient *client, CalClientOpenStatus status, gpoint
 	vtype = cal_component_get_vtype (priv->comp);
 
 	switch (vtype) {
+#if 0				/* EPFIXME */
 	case CAL_COMPONENT_EVENT:
 		button = evolution_folder_selector_button_new (
 			global_shell_client, _("Select Calendar Folder"),
@@ -2222,6 +2175,7 @@ default_server_started_cb (CalClient *client, CalClientOpenStatus status, gpoint
 			calendar_config_default_tasks_folder (), 
 			tasks_types);
 		break;
+#endif
 	default:
 		button = NULL;
 	}
@@ -2251,29 +2205,30 @@ object_requested_cb (GtkHTML *html, GtkHTMLEmbedded *eb, gpointer data)
 	context = g_new0 (ObjectRequestContext, 1);
 	context->itip   = itip;
 	context->eb     = eb;
-	context->client = cal_client_new ();
-
-	g_object_ref (itip);
-	g_signal_connect (context->client, "cal_opened",
-			  G_CALLBACK (default_server_started_cb), context);
 
+	/* FIXME: use the default URIs */
 	switch (vtype) {
 	case CAL_COMPONENT_EVENT:
-		success = start_default_server_async (itip, context->client, FALSE);
+		context->client = cal_client_new ("", CALOBJ_TYPE_EVENT);
+		success = start_default_server (itip, context->client, FALSE);
 		break;
 	case CAL_COMPONENT_TODO:
-		success = start_default_server_async (itip, context->client, TRUE);
+		context->client = cal_client_new ("", CALOBJ_TYPE_TODO);
+		success = start_default_server (itip, context->client, TRUE);
 		break;
 	default:
-		success = FALSE;
+		g_free (context);
+		return FALSE;
 	}
 
 	if (!success) {
-		g_object_unref (itip);
 		g_object_unref (context->client);
 		g_free (context);
+		return FALSE;
 	}
 
+	g_object_ref (itip);
+
 	return TRUE;
 }
 
@@ -2330,7 +2285,8 @@ ok_clicked_cb (GtkHTML *html, const gchar *method, const gchar *url, const gchar
 				send_freebusy (itip);
 				break;
 			case 'R':
-				update_attendee_status (itip);
+				/* FIXME Make sure this does the right thing in the backend */
+				update_item (itip);
 				break;
 			case 'S':
 				send_item (itip);
diff --git a/calendar/gui/e-meeting-list-view.c b/calendar/gui/e-meeting-list-view.c
index 7d3a4ce6c6..64463fdcb6 100644
--- a/calendar/gui/e-meeting-list-view.c
+++ b/calendar/gui/e-meeting-list-view.c
@@ -35,11 +35,7 @@
 #include <libgnome/gnome-util.h>
 #include <libgnomevfs/gnome-vfs.h>
 #include <ebook/e-book.h>
-#include <ebook/e-book-util.h>
-#include <ebook/e-card-types.h>
-#include <ebook/e-card-cursor.h>
-#include <ebook/e-card.h>
-#include <ebook/e-card-simple.h>
+#include <ebook/e-vcard.h>
 #include <cal-util/cal-component.h>
 #include <cal-util/cal-util.h>
 #include <cal-util/timeutil.h>
@@ -47,6 +43,7 @@
 #include "calendar-config.h"
 #include "e-meeting-list-view.h"
 #include <misc/e-cell-renderer-combo.h>
+#include <addressbook/util/eab-destination.h>
 #include "e-select-names-renderer.h"
 
 #define SELECT_NAMES_OAFID "OAFIID:GNOME_Evolution_Addressbook_SelectNames"
@@ -56,8 +53,6 @@ struct _EMeetingListViewPrivate
 	EMeetingStore *store;
 
 	EBook *ebook;
-	gboolean book_loaded;
-	gboolean book_load_wait;
 
         GNOME_Evolution_Addressbook_SelectNames corba_select_names;
 };
@@ -78,26 +73,17 @@ static icalparameter_role roles[] = {ICAL_ROLE_CHAIR,
 static GtkTreeViewClass *parent_class = NULL;
 
 static void
-book_open_cb (EBook *book, EBookStatus status, gpointer data)
-{
-	EMeetingListView *view = E_MEETING_LIST_VIEW (data);
-	
-	if (status == E_BOOK_STATUS_SUCCESS)
-		view->priv->book_loaded = TRUE;
-	else
-		g_warning ("Book not loaded");
-	
-	if (view->priv->book_load_wait) {
-		view->priv->book_load_wait = FALSE;
-		gtk_main_quit ();
-	}
-}
-
-static void
 start_addressbook_server (EMeetingListView *view)
 {
+	GError *error = NULL;
+
 	view->priv->ebook = e_book_new ();
-	e_book_load_default_book (view->priv->ebook, book_open_cb, view);
+	if (!e_book_load_local_addressbook (view->priv->ebook, &error)) {
+		g_warning ("start_addressbook_server(): %s", error->message);
+		g_error_free (error);
+
+		return;
+	}
 }
 
 static void
@@ -319,49 +305,41 @@ e_meeting_list_view_column_set_visible (EMeetingListView *view, const gchar *col
 }
 
 static void
-process_section (EMeetingListView *view, GNOME_Evolution_Addressbook_SimpleCardList *cards, icalparameter_role role)
+process_section (EMeetingListView *view, EABDestination **cards, icalparameter_role role)
 {
 	EMeetingListViewPrivate *priv;
 	int i;
 
 	priv = view->priv;
-	for (i = 0; i < cards->_length; i++) {
-		const char *name, *attendee = NULL, *attr;
-		GNOME_Evolution_Addressbook_SimpleCard card;
-		CORBA_Environment ev;
+	for (i = 0; i < G_N_ELEMENTS (cards); i++) {
+		const char *name, *attendee = NULL;
+		char *attr = NULL;
 
-		card = cards->_buffer[i];
-
-		CORBA_exception_init (&ev);
-
-		/* Get the CN */
-		name = GNOME_Evolution_Addressbook_SimpleCard_get (card, GNOME_Evolution_Addressbook_SimpleCard_FullName, &ev);
-		if (BONOBO_EX (&ev)) {
-			CORBA_exception_free (&ev);
-			continue;
-		}
+		name = eab_destination_get_name (cards[i]);
 
 		/* Get the field as attendee from the backend */
-		attr = cal_client_get_ldap_attribute (e_meeting_store_get_cal_client (priv->store));
-		if (attr) {
+		if (cal_client_get_ldap_attribute (e_meeting_store_get_cal_client (priv->store),
+						   &attr, NULL)) {
 			/* FIXME this should be more general */
-			if (!g_ascii_strcasecmp (attr, "icscalendar"))
-				attendee = GNOME_Evolution_Addressbook_SimpleCard_get (card, GNOME_Evolution_Addressbook_SimpleCard_Icscalendar, &ev);
+			if (!g_ascii_strcasecmp (attr, "icscalendar")) {
+				EContact *contact;
+
+				/* FIXME: this does not work, have to use first
+				   eab_destination_use_contact() */
+				contact = eab_destination_get_contact (cards[i]);
+				if (contact) {
+					attendee = e_contact_get (contact, E_CONTACT_FREEBUSY_URL);
+					if (!attendee)
+						attendee = e_contact_get (contact, E_CONTACT_CALENDAR_URI);
+				}
+			}
 		}
 
-		CORBA_exception_init (&ev);
-
 		/* If we couldn't get the attendee prior, get the email address as the default */
 		if (attendee == NULL || *attendee == '\0') {
-			attendee = GNOME_Evolution_Addressbook_SimpleCard_get (card, GNOME_Evolution_Addressbook_SimpleCard_Email, &ev);
-			if (BONOBO_EX (&ev)) {
-				CORBA_exception_free (&ev);
-				continue;
-			}
+			attendee = eab_destination_get_email (cards[i]);
 		}
 		
-		CORBA_exception_free (&ev);
-
 		if (attendee == NULL || *attendee == '\0')
 			continue;
 		
@@ -381,22 +359,21 @@ static void
 select_names_ok_cb (BonoboListener *listener, const char *event_name, const CORBA_any *arg, CORBA_Environment *ev, gpointer data)
 {
 	EMeetingListView *view = E_MEETING_LIST_VIEW (data);
-	BonoboArg *card_arg;
 	int i;
 	
 	for (i = 0; sections[i] != NULL; i++) {
+		EABDestination **destv;
+		char *string = NULL;
 		Bonobo_Control corba_control = GNOME_Evolution_Addressbook_SelectNames_getEntryBySection 
 			(view->priv->corba_select_names, sections[i], ev);
 		GtkWidget *control_widget = bonobo_widget_new_control_from_objref (corba_control, CORBA_OBJECT_NIL);
- 		BonoboControlFrame *control_frame = bonobo_widget_get_control_frame (BONOBO_WIDGET (control_widget));
-		Bonobo_PropertyBag pb = bonobo_control_frame_get_control_property_bag (control_frame, NULL);
- 		card_arg = bonobo_property_bag_client_get_value_any (pb, "simple_card_list", NULL);
- 		if (card_arg != NULL) {
-			GNOME_Evolution_Addressbook_SimpleCardList cards;
- 			cards = BONOBO_ARG_GET_GENERAL (card_arg, TC_GNOME_Evolution_Addressbook_SimpleCardList, 
-					                GNOME_Evolution_Addressbook_SimpleCardList, NULL);
- 			process_section (view, &cards, roles[i]);
- 			bonobo_arg_release (card_arg);
+
+		bonobo_widget_get_property (BONOBO_WIDGET (control_widget), "destinations",
+					    TC_CORBA_string, &string, NULL);
+		destv = eab_destination_importv (string);
+ 		if (destv) {
+ 			process_section (view, destv, roles[i]);
+ 			g_free (destv);
  		}
 	}
 }
diff --git a/calendar/gui/e-meeting-model.c b/calendar/gui/e-meeting-model.c
new file mode 100644
index 0000000000..4742116cf2
--- /dev/null
+++ b/calendar/gui/e-meeting-model.c
@@ -0,0 +1,1780 @@
+/* -*- Mod:e C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* itip-model.c
+ *
+ * Copyright (C) 2001  Ximian, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * Author: JP Rosevear
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+#include <bonobo/bonobo-control.h>
+#include <bonobo/bonobo-widget.h>
+#include <bonobo/bonobo-exception.h>
+#include <libgnome/gnome-i18n.h>
+#include <libgnome/gnome-util.h>
+#include <libgnomevfs/gnome-vfs.h>
+#include <gal/e-table/e-table-without.h>
+#include <gal/e-table/e-cell-text.h>
+#include <gal/e-table/e-cell-popup.h>
+#include <gal/e-table/e-cell-combo.h>
+#include <addressbook/util/eab-destination.h>
+#include <ebook/e-book.h>
+#include <ebook/e-book-async.h>
+#include <ebook/e-contact.h>
+#include <cal-util/cal-component.h>
+#include <cal-util/cal-util.h>
+#include <cal-util/timeutil.h>
+#include "Evolution-Addressbook-SelectNames.h"
+#include "calendar-config.h"
+#include "itip-utils.h"
+#include "e-meeting-utils.h"
+#include "e-meeting-attendee.h"
+#include "e-meeting-model.h"
+
+#define SELECT_NAMES_OAFID "OAFIID:GNOME_Evolution_Addressbook_SelectNames"
+
+struct _EMeetingModelPrivate 
+{
+	GPtrArray *attendees;
+
+	GList *tables;
+	
+	CalClient *client;
+	icaltimezone *zone;
+	
+	EBook *ebook;
+	gboolean book_loaded;
+	gboolean book_load_wait;
+
+	GPtrArray *refresh_queue;
+	GHashTable *refresh_data;
+	guint refresh_idle_id;
+
+	/* For invite others dialogs */
+        GNOME_Evolution_Addressbook_SelectNames corba_select_names;
+};
+
+#define BUF_SIZE 1024
+
+static char *sections[] = {N_("Chair Persons"), 
+			   N_("Required Participants"), 
+			   N_("Optional Participants"), 
+			   N_("Resources"),
+			   NULL};
+static icalparameter_role roles[] = {ICAL_ROLE_CHAIR,
+				     ICAL_ROLE_REQPARTICIPANT,
+				     ICAL_ROLE_OPTPARTICIPANT,
+				     ICAL_ROLE_NONPARTICIPANT,
+				     ICAL_ROLE_NONE};
+
+typedef struct _EMeetingModelQueueData EMeetingModelQueueData;
+struct _EMeetingModelQueueData {
+	EMeetingModel *im;
+	EMeetingAttendee *ia;
+
+	gboolean refreshing;
+	
+	EMeetingTime start;
+	EMeetingTime end;
+
+	char buffer[BUF_SIZE];
+	GString *string;
+	
+	GPtrArray *call_backs;
+	GPtrArray *data;
+};
+
+
+static void class_init	(EMeetingModelClass	 *klass);
+static void init	(EMeetingModel		 *model);
+static void finalize	(GObject *obj);
+
+static void refresh_queue_add (EMeetingModel *im, int row,
+			       EMeetingTime *start,
+			       EMeetingTime *end,
+			       EMeetingModelRefreshCallback call_back,
+			       gpointer data);
+static void refresh_queue_remove (EMeetingModel *im,
+				  EMeetingAttendee *ia);
+static gboolean refresh_busy_periods (gpointer data);
+
+static void attendee_changed_cb (EMeetingAttendee *ia, gpointer data);
+static void select_names_ok_cb (BonoboListener    *listener,
+				const char        *event_name,
+				const CORBA_any   *arg,
+				CORBA_Environment *ev,
+				gpointer           data);
+
+static void table_destroy_state_cb (ETableScrolled *etable, gpointer data);
+static void table_destroy_list_cb (ETableScrolled *etable, gpointer data);
+
+static ETableModelClass *parent_class = NULL;
+
+E_MAKE_TYPE (e_meeting_model, "EMeetingModel", EMeetingModel,
+	     class_init, init, E_TABLE_MODEL_TYPE);
+
+static void
+book_open_cb (EBook *book, EBookStatus status, gpointer data)
+{
+	EMeetingModel *im = E_MEETING_MODEL (data);
+	EMeetingModelPrivate *priv;
+	
+	priv = im->priv;
+
+	priv->ebook = book;
+
+	if (status == E_BOOK_ERROR_OK)
+		priv->book_loaded = TRUE;
+	else
+		g_warning ("Book not loaded");
+	
+	if (priv->book_load_wait) {
+		priv->book_load_wait = FALSE;
+		gtk_main_quit ();
+	}
+}
+
+static void
+start_addressbook_server (EMeetingModel *im)
+{
+	e_book_async_get_default_addressbook (book_open_cb, im);
+}
+
+static EMeetingAttendee *
+find_match (EMeetingModel *im, const char *address, int *pos)
+{
+	EMeetingModelPrivate *priv;
+	EMeetingAttendee *ia;
+	const gchar *ia_address;
+	int i;
+	
+	priv = im->priv;
+	
+	if (address == NULL)
+		return NULL;
+	
+	/* Make sure we can add the new delegatee person */
+	for (i = 0; i < priv->attendees->len; i++) {
+		ia = g_ptr_array_index (priv->attendees, i);
+
+		ia_address = e_meeting_attendee_get_address (ia);
+		if (ia_address != NULL && !g_strcasecmp (itip_strip_mailto (ia_address), itip_strip_mailto (address))) {
+			if (pos != NULL)
+				*pos = i;
+			return ia;
+		}
+	}
+
+	return NULL;
+}
+
+static icalparameter_cutype
+text_to_type (const char *type)
+{
+	if (!g_strcasecmp (type, _("Individual")))
+		return ICAL_CUTYPE_INDIVIDUAL;
+	else if (!g_strcasecmp (type, _("Group")))
+		return ICAL_CUTYPE_GROUP;
+	else if (!g_strcasecmp (type, _("Resource")))
+		return ICAL_CUTYPE_RESOURCE;
+	else if (!g_strcasecmp (type, _("Room")))
+		return ICAL_CUTYPE_ROOM;
+	else
+		return ICAL_CUTYPE_NONE;
+}
+
+static char *
+type_to_text (icalparameter_cutype type)
+{
+	switch (type) {
+	case ICAL_CUTYPE_INDIVIDUAL:
+		return _("Individual");
+	case ICAL_CUTYPE_GROUP:
+		return _("Group");
+	case ICAL_CUTYPE_RESOURCE:
+		return _("Resource");
+	case ICAL_CUTYPE_ROOM:
+		return _("Room");
+	default:
+		return _("Unknown");
+	}
+
+	return NULL;
+
+}
+
+static icalparameter_role
+text_to_role (const char *role)
+{
+	if (!g_strcasecmp (role, _("Chair")))
+		return ICAL_ROLE_CHAIR;
+	else if (!g_strcasecmp (role, _("Required Participant")))
+		return ICAL_ROLE_REQPARTICIPANT;
+	else if (!g_strcasecmp (role, _("Optional Participant")))
+		return ICAL_ROLE_OPTPARTICIPANT;
+	else if (!g_strcasecmp (role, _("Non-Participant")))
+		return ICAL_ROLE_NONPARTICIPANT;
+	else
+		return ICAL_ROLE_NONE;
+}
+
+static char *
+role_to_text (icalparameter_role role) 
+{
+	switch (role) {
+	case ICAL_ROLE_CHAIR:
+		return _("Chair");
+	case ICAL_ROLE_REQPARTICIPANT:
+		return _("Required Participant");
+	case ICAL_ROLE_OPTPARTICIPANT:
+		return _("Optional Participant");
+	case ICAL_ROLE_NONPARTICIPANT:
+		return _("Non-Participant");
+	default:
+		return _("Unknown");
+	}
+
+	return NULL;
+}
+
+static gboolean
+text_to_boolean (const char *role)
+{
+	if (!g_strcasecmp (role, _("Yes")))
+		return TRUE;
+	else
+		return FALSE;
+}
+
+static char *
+boolean_to_text (gboolean b) 
+{
+	if (b)
+		return _("Yes");
+	else
+		return _("No");
+}
+
+static icalparameter_partstat
+text_to_partstat (const char *partstat)
+{
+	if (!g_strcasecmp (partstat, _("Needs Action")))
+		return ICAL_PARTSTAT_NEEDSACTION;
+	else if (!g_strcasecmp (partstat, _("Accepted")))
+		return ICAL_PARTSTAT_ACCEPTED;
+	else if (!g_strcasecmp (partstat, _("Declined")))
+		return ICAL_PARTSTAT_DECLINED;
+	else if (!g_strcasecmp (partstat, _("Tentative")))
+		return ICAL_PARTSTAT_TENTATIVE;
+	else if (!g_strcasecmp (partstat, _("Delegated")))
+		return ICAL_PARTSTAT_DELEGATED;
+	else if (!g_strcasecmp (partstat, _("Completed")))
+		return ICAL_PARTSTAT_COMPLETED;
+	else if (!g_strcasecmp (partstat, _("In Process")))
+		return ICAL_PARTSTAT_INPROCESS;
+	else
+		return ICAL_PARTSTAT_NONE;
+}
+
+static char *
+partstat_to_text (icalparameter_partstat partstat) 
+{
+	switch (partstat) {
+	case ICAL_PARTSTAT_NEEDSACTION:
+		return _("Needs Action");
+	case ICAL_PARTSTAT_ACCEPTED:
+		return _("Accepted");
+	case ICAL_PARTSTAT_DECLINED:
+		return _("Declined");
+	case ICAL_PARTSTAT_TENTATIVE:
+		return _("Tentative");
+	case ICAL_PARTSTAT_DELEGATED:
+		return _("Delegated");
+	case ICAL_PARTSTAT_COMPLETED:
+		return _("Completed");
+	case ICAL_PARTSTAT_INPROCESS:
+		return _("In Process");
+	case ICAL_PARTSTAT_NONE:
+	default:
+		return _("Unknown");
+	}
+
+	return NULL;
+}
+
+static int
+column_count (ETableModel *etm)
+{
+	return E_MEETING_MODEL_COLUMN_COUNT;
+}
+
+static int
+row_count (ETableModel *etm)
+{
+	EMeetingModel *im;
+	EMeetingModelPrivate *priv;
+
+	im = E_MEETING_MODEL (etm);	
+	priv = im->priv;
+
+	return (priv->attendees->len);
+}
+
+static void
+append_row (ETableModel *etm, ETableModel *source, int row)
+{	
+	EMeetingModel *im;
+	EMeetingModelPrivate *priv;
+	EMeetingAttendee *ia;
+	char *address;
+	
+	im = E_MEETING_MODEL (etm);	
+	priv = im->priv;
+	
+	address = (char *) e_table_model_value_at (source, E_MEETING_MODEL_ADDRESS_COL, row);
+	if (find_match (im, address, NULL) != NULL) {
+		return;
+	}
+	
+	ia = E_MEETING_ATTENDEE (e_meeting_attendee_new ());
+	
+	e_meeting_attendee_set_address (ia, g_strdup_printf ("MAILTO:%s", address));
+	e_meeting_attendee_set_member (ia, g_strdup (e_table_model_value_at (source, E_MEETING_MODEL_MEMBER_COL, row)));
+	e_meeting_attendee_set_cutype (ia, text_to_type (e_table_model_value_at (source, E_MEETING_MODEL_TYPE_COL, row)));
+	e_meeting_attendee_set_role (ia, text_to_role (e_table_model_value_at (source, E_MEETING_MODEL_ROLE_COL, row)));
+	e_meeting_attendee_set_rsvp (ia, text_to_boolean (e_table_model_value_at (source, E_MEETING_MODEL_RSVP_COL, row)));
+	e_meeting_attendee_set_delto (ia, g_strdup (e_table_model_value_at (source, E_MEETING_MODEL_DELTO_COL, row)));
+	e_meeting_attendee_set_delfrom (ia, g_strdup (e_table_model_value_at (source, E_MEETING_MODEL_DELFROM_COL, row)));
+	e_meeting_attendee_set_status (ia, text_to_partstat (e_table_model_value_at (source, E_MEETING_MODEL_STATUS_COL, row)));
+	e_meeting_attendee_set_cn (ia, g_strdup (e_table_model_value_at (source, E_MEETING_MODEL_CN_COL, row)));
+	e_meeting_attendee_set_language (ia, g_strdup (e_table_model_value_at (source, E_MEETING_MODEL_LANGUAGE_COL, row)));
+
+	e_meeting_model_add_attendee (E_MEETING_MODEL (etm), ia);
+	g_object_unref (ia);
+}
+
+static void *
+value_at (ETableModel *etm, int col, int row)
+{
+	EMeetingModel *im;
+	EMeetingModelPrivate *priv;
+	EMeetingAttendee *ia;
+
+	im = E_MEETING_MODEL (etm);	
+	priv = im->priv;
+
+	ia = g_ptr_array_index (priv->attendees, row);
+	
+	switch (col) {
+	case E_MEETING_MODEL_ADDRESS_COL:
+		return (void *)itip_strip_mailto (e_meeting_attendee_get_address (ia));
+	case E_MEETING_MODEL_MEMBER_COL:
+		return (void *)e_meeting_attendee_get_member (ia);
+	case E_MEETING_MODEL_TYPE_COL:
+		return type_to_text (e_meeting_attendee_get_cutype (ia));
+	case E_MEETING_MODEL_ROLE_COL:
+		return role_to_text (e_meeting_attendee_get_role (ia));
+	case E_MEETING_MODEL_RSVP_COL:
+		return boolean_to_text (e_meeting_attendee_get_rsvp (ia));
+	case E_MEETING_MODEL_DELTO_COL:
+		return (void *)itip_strip_mailto (e_meeting_attendee_get_delto (ia));
+	case E_MEETING_MODEL_DELFROM_COL:
+		return (void *)itip_strip_mailto (e_meeting_attendee_get_delfrom (ia));
+	case E_MEETING_MODEL_STATUS_COL:
+		return partstat_to_text (e_meeting_attendee_get_status (ia));
+	case E_MEETING_MODEL_CN_COL:
+		return (void *)e_meeting_attendee_get_cn (ia);
+	case E_MEETING_MODEL_LANGUAGE_COL:
+		return (void *)e_meeting_attendee_get_language (ia);
+	}
+	
+	return NULL;
+}
+
+static void
+set_value_at (ETableModel *etm, int col, int row, const void *val)
+{
+	EMeetingModel *im;
+	EMeetingModelPrivate *priv;
+	EMeetingAttendee *ia;
+	icalparameter_cutype type;
+	
+	im = E_MEETING_MODEL (etm);	
+	priv = im->priv;
+
+	ia = g_ptr_array_index (priv->attendees, row);
+
+	e_table_model_pre_change (etm);
+	
+	switch (col) {
+	case E_MEETING_MODEL_ADDRESS_COL:
+		if (val != NULL && *((char *)val))
+			e_meeting_attendee_set_address (ia, g_strdup_printf ("MAILTO:%s", (char *) val));
+		break;
+	case E_MEETING_MODEL_MEMBER_COL:
+		e_meeting_attendee_set_member (ia, g_strdup (val));
+		break;
+	case E_MEETING_MODEL_TYPE_COL:
+		type = text_to_type (val);
+		e_meeting_attendee_set_cutype (ia, text_to_type (val));
+		if (type == ICAL_CUTYPE_RESOURCE) {
+			e_meeting_attendee_set_role (ia, ICAL_ROLE_NONPARTICIPANT);
+			e_table_model_cell_changed (etm, E_MEETING_MODEL_ROLE_COL, row);
+		}		
+		break;
+	case E_MEETING_MODEL_ROLE_COL:
+		e_meeting_attendee_set_role (ia, text_to_role (val));
+		break;
+	case E_MEETING_MODEL_RSVP_COL:
+		e_meeting_attendee_set_rsvp (ia, text_to_boolean (val));
+		break;
+	case E_MEETING_MODEL_DELTO_COL:
+		e_meeting_attendee_set_delto (ia, g_strdup (val));
+		break;
+	case E_MEETING_MODEL_DELFROM_COL:
+		e_meeting_attendee_set_delfrom (ia, g_strdup (val));
+		break;
+	case E_MEETING_MODEL_STATUS_COL:
+		e_meeting_attendee_set_status (ia, text_to_partstat (val));
+		break;
+	case E_MEETING_MODEL_CN_COL:
+		e_meeting_attendee_set_cn (ia, g_strdup (val));
+		break;
+	case E_MEETING_MODEL_LANGUAGE_COL:
+		e_meeting_attendee_set_language (ia, g_strdup (val));
+		break;
+	}
+
+	e_table_model_cell_changed (etm, col, row);
+}
+
+static gboolean
+is_cell_editable (ETableModel *etm, int col, int row)
+{
+	EMeetingModel *im;
+	EMeetingModelPrivate *priv;
+	EMeetingAttendee *ia;
+	EMeetingAttendeeEditLevel level;
+	
+	im = E_MEETING_MODEL (etm);	
+	priv = im->priv;
+	
+	if (col == E_MEETING_MODEL_DELTO_COL
+	    || col == E_MEETING_MODEL_DELFROM_COL)
+		return FALSE;
+	
+	if (row == -1)
+		return TRUE;
+	if (row >= priv->attendees->len)
+		return TRUE;
+	
+	ia = g_ptr_array_index (priv->attendees, row);
+	level = e_meeting_attendee_get_edit_level (ia);
+
+	switch (level) {
+	case E_MEETING_ATTENDEE_EDIT_FULL:
+		return TRUE;
+	case E_MEETING_ATTENDEE_EDIT_STATUS:
+		return col == E_MEETING_MODEL_STATUS_COL;
+	case E_MEETING_ATTENDEE_EDIT_NONE:
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static void *
+duplicate_value (ETableModel *etm, int col, const void *val)
+{
+	return g_strdup (val);
+}
+
+static void
+free_value (ETableModel *etm, int col, void *val)
+{
+	g_free (val);
+}
+
+static void *
+init_value (ETableModel *etm, int col)
+{
+	switch (col) {
+	case E_MEETING_MODEL_ADDRESS_COL:
+		return g_strdup ("");
+	case E_MEETING_MODEL_MEMBER_COL:
+		return g_strdup ("");
+	case E_MEETING_MODEL_TYPE_COL:
+		return g_strdup (_("Individual"));
+	case E_MEETING_MODEL_ROLE_COL:
+		return g_strdup (_("Required Participant"));
+	case E_MEETING_MODEL_RSVP_COL:
+		return g_strdup (_("Yes"));
+	case E_MEETING_MODEL_DELTO_COL:
+		return g_strdup ("");
+	case E_MEETING_MODEL_DELFROM_COL:
+		return g_strdup ("");
+	case E_MEETING_MODEL_STATUS_COL:
+		return g_strdup (_("Needs Action"));
+	case E_MEETING_MODEL_CN_COL:
+		return g_strdup ("");
+	case E_MEETING_MODEL_LANGUAGE_COL:
+		return g_strdup ("en");
+	}
+	
+	return g_strdup ("");
+}
+
+static gboolean
+value_is_empty (ETableModel *etm, int col, const void *val)
+{
+	
+	switch (col) {
+	case E_MEETING_MODEL_ADDRESS_COL:
+	case E_MEETING_MODEL_MEMBER_COL:
+	case E_MEETING_MODEL_DELTO_COL:
+	case E_MEETING_MODEL_DELFROM_COL:
+	case E_MEETING_MODEL_CN_COL:
+		if (val && !g_strcasecmp (val, ""))
+			return TRUE;
+		else
+			return FALSE;
+	default:
+		;
+	}
+	
+	return TRUE;
+}
+
+static char *
+value_to_string (ETableModel *etm, int col, const void *val)
+{
+	return g_strdup (val);
+}
+
+static void
+class_init (EMeetingModelClass *klass)
+{
+	GObjectClass *gobject_class;
+	ETableModelClass *etm_class;
+	
+	gobject_class = G_OBJECT_CLASS (klass);
+	etm_class = E_TABLE_MODEL_CLASS (klass);
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	gobject_class->finalize = finalize;
+
+	etm_class->column_count = column_count;
+	etm_class->row_count = row_count;
+	etm_class->value_at = value_at;
+	etm_class->set_value_at = set_value_at;
+	etm_class->is_cell_editable = is_cell_editable;
+	etm_class->append_row = append_row;
+	etm_class->duplicate_value = duplicate_value;
+	etm_class->free_value = free_value;
+	etm_class->initialize_value = init_value;
+	etm_class->value_is_empty = value_is_empty;
+	etm_class->value_to_string = value_to_string;
+}
+
+
+static void
+init (EMeetingModel *im)
+{
+	EMeetingModelPrivate *priv;
+
+	priv = g_new0 (EMeetingModelPrivate, 1);
+
+	im->priv = priv;
+
+	priv->attendees = g_ptr_array_new ();
+	
+	priv->tables = NULL;
+
+	priv->client = NULL;
+	priv->zone = icaltimezone_get_builtin_timezone (calendar_config_get_timezone ());
+	
+	priv->ebook = NULL;
+	priv->book_loaded = FALSE;
+	priv->book_load_wait = FALSE;
+
+	priv->refresh_queue = g_ptr_array_new ();
+	priv->refresh_data = g_hash_table_new (g_direct_hash, g_direct_equal);
+	priv->refresh_idle_id = 0;
+	
+	priv->corba_select_names = CORBA_OBJECT_NIL;
+	
+	start_addressbook_server (im);
+}
+
+static void
+finalize (GObject *obj)
+{
+	EMeetingModel *im = E_MEETING_MODEL (obj);
+	EMeetingModelPrivate *priv;
+	GList *l;
+	int i;
+	
+	priv = im->priv;
+
+	for (i = 0; i < priv->attendees->len; i++)
+		g_object_unref (g_ptr_array_index (priv->attendees, i));
+	g_ptr_array_free (priv->attendees, TRUE); 
+
+	for (l = priv->tables; l != NULL; l = l->next)
+		g_signal_handlers_disconnect_matched (G_OBJECT (l->data), G_SIGNAL_MATCH_DATA,
+						      0, 0, NULL, NULL, im);
+	g_list_free (priv->tables);
+	
+	if (priv->client != NULL)
+		g_object_unref (priv->client);
+
+	if (priv->ebook != NULL)
+		g_object_unref (priv->ebook);
+
+	if (priv->corba_select_names != CORBA_OBJECT_NIL) {
+		CORBA_Environment ev;
+		CORBA_exception_init (&ev);
+		bonobo_object_release_unref (priv->corba_select_names, &ev);
+		CORBA_exception_free (&ev);
+	}
+
+ 	while (priv->refresh_queue->len > 0)
+ 		refresh_queue_remove (im, g_ptr_array_index (priv->refresh_queue, 0));
+ 	g_ptr_array_free (priv->refresh_queue, TRUE);
+ 	g_hash_table_destroy (priv->refresh_data);
+ 	
+ 	if (priv->refresh_idle_id)
+ 		g_source_remove (priv->refresh_idle_id);
+ 		
+	g_free (priv);
+
+	if (G_OBJECT_CLASS (parent_class)->finalize)
+ 		(* G_OBJECT_CLASS (parent_class)->finalize) (obj);
+}
+
+GtkObject *
+e_meeting_model_new (void)
+{
+	return g_object_new (E_TYPE_MEETING_MODEL, NULL);
+}
+
+
+CalClient *
+e_meeting_model_get_cal_client (EMeetingModel *im)
+{
+	EMeetingModelPrivate *priv;
+	
+	priv = im->priv;
+
+	return priv->client;
+}
+
+void
+e_meeting_model_set_cal_client (EMeetingModel *im, CalClient *client)
+{
+	EMeetingModelPrivate *priv;
+	
+	priv = im->priv;
+
+	if (priv->client != NULL)
+		g_object_unref (priv->client);
+	
+	if (client != NULL)
+		g_object_ref (client);
+	priv->client = client;
+}
+
+icaltimezone *
+e_meeting_model_get_zone (EMeetingModel *im)
+{
+	EMeetingModelPrivate *priv;
+	
+	g_return_val_if_fail (im != NULL, NULL);
+	g_return_val_if_fail (E_IS_MEETING_MODEL (im), NULL);
+
+	priv = im->priv;
+	
+	return priv->zone;
+}
+
+void
+e_meeting_model_set_zone (EMeetingModel *im, icaltimezone *zone)
+{
+	EMeetingModelPrivate *priv;
+	
+	g_return_if_fail (im != NULL);
+	g_return_if_fail (E_IS_MEETING_MODEL (im));
+
+	priv = im->priv;
+	
+	priv->zone = zone;
+}
+
+static ETableScrolled *
+build_etable (ETableModel *model, const gchar *spec_file, const gchar *state_file)
+{
+	GtkWidget *etable;
+	ETable *real_table;
+	ETableExtras *extras;
+	GList *strings;
+	ECell *popup_cell, *cell;
+	
+	extras = e_table_extras_new ();
+
+	/* For type */
+	cell = e_cell_text_new (NULL, GTK_JUSTIFY_LEFT);
+	popup_cell = e_cell_combo_new ();
+	e_cell_popup_set_child (E_CELL_POPUP (popup_cell), cell);
+	g_object_unref (cell);
+	
+	strings = NULL;
+	strings = g_list_append (strings, (char*) _("Individual"));
+	strings = g_list_append (strings, (char*) _("Group"));
+	strings = g_list_append (strings, (char*) _("Resource"));
+	strings = g_list_append (strings, (char*) _("Room"));
+	strings = g_list_append (strings, (char*) _("Unknown"));
+
+	e_cell_combo_set_popdown_strings (E_CELL_COMBO (popup_cell), strings);
+	e_table_extras_add_cell (extras, "typeedit", popup_cell);
+	
+	/* For role */
+	cell = e_cell_text_new (NULL, GTK_JUSTIFY_LEFT);
+	popup_cell = e_cell_combo_new ();
+	e_cell_popup_set_child (E_CELL_POPUP (popup_cell), cell);
+	g_object_unref (cell);
+	
+	strings = NULL;
+	strings = g_list_append (strings, (char*) _("Chair"));
+	strings = g_list_append (strings, (char*) _("Required Participant"));
+	strings = g_list_append (strings, (char*) _("Optional Participant"));
+	strings = g_list_append (strings, (char*) _("Non-Participant"));
+	strings = g_list_append (strings, (char*) _("Unknown"));
+
+	e_cell_combo_set_popdown_strings (E_CELL_COMBO (popup_cell), strings);
+	e_table_extras_add_cell (extras, "roleedit", popup_cell);
+
+	/* For rsvp */
+	cell = e_cell_text_new (NULL, GTK_JUSTIFY_LEFT);
+	popup_cell = e_cell_combo_new ();
+	e_cell_popup_set_child (E_CELL_POPUP (popup_cell), cell);
+	g_object_unref (cell);
+
+	strings = NULL;
+	strings = g_list_append (strings, (char*) _("Yes"));
+	strings = g_list_append (strings, (char*) _("No"));
+
+	e_cell_combo_set_popdown_strings (E_CELL_COMBO (popup_cell), strings);
+	e_table_extras_add_cell (extras, "rsvpedit", popup_cell);
+
+	/* For status */
+	cell = e_cell_text_new (NULL, GTK_JUSTIFY_LEFT);
+	popup_cell = e_cell_combo_new ();
+	e_cell_popup_set_child (E_CELL_POPUP (popup_cell), cell);
+	g_object_unref (cell);
+
+	strings = NULL;
+	strings = g_list_append (strings, (char*) _("Needs Action"));
+	strings = g_list_append (strings, (char*) _("Accepted"));
+	strings = g_list_append (strings, (char*) _("Declined"));
+	strings = g_list_append (strings, (char*) _("Tentative"));
+	strings = g_list_append (strings, (char*) _("Delegated"));
+
+	e_cell_combo_set_popdown_strings (E_CELL_COMBO (popup_cell), strings);
+	e_table_extras_add_cell (extras, "statusedit", popup_cell);
+
+	etable = e_table_scrolled_new_from_spec_file (model, extras, spec_file, NULL);
+	real_table = e_table_scrolled_get_table (E_TABLE_SCROLLED (etable));
+	g_object_set (G_OBJECT (real_table), "uniform_row_height", TRUE, NULL);
+	e_table_load_state (real_table, state_file);
+
+#if 0
+	g_signal_connect (real_table, "right_click", G_CALLBACK (right_click_cb), mpage);
+#endif
+
+	g_signal_connect (etable, "destroy", G_CALLBACK (table_destroy_state_cb), g_strdup (state_file));
+
+	g_object_unref (extras);
+	
+	return E_TABLE_SCROLLED (etable);
+}
+
+void
+e_meeting_model_add_attendee (EMeetingModel *im, EMeetingAttendee *ia)
+{
+	EMeetingModelPrivate *priv;
+	
+	priv = im->priv;
+	
+	e_table_model_pre_change (E_TABLE_MODEL (im));
+
+	g_object_ref (ia);
+	g_ptr_array_add (priv->attendees, ia);
+
+	g_signal_connect (ia, "changed", G_CALLBACK (attendee_changed_cb), im);
+
+	e_table_model_row_inserted (E_TABLE_MODEL (im), row_count (E_TABLE_MODEL (im)) - 1);
+}
+
+EMeetingAttendee *
+e_meeting_model_add_attendee_with_defaults (EMeetingModel *im)
+{
+	EMeetingAttendee *ia;
+	char *str;
+	
+	ia = E_MEETING_ATTENDEE (e_meeting_attendee_new ());
+
+	e_meeting_attendee_set_address (ia, init_value (E_TABLE_MODEL (im), E_MEETING_MODEL_ADDRESS_COL));
+	e_meeting_attendee_set_member (ia, init_value (E_TABLE_MODEL (im), E_MEETING_MODEL_MEMBER_COL));
+
+	str = init_value (E_TABLE_MODEL (im), E_MEETING_MODEL_TYPE_COL);
+	e_meeting_attendee_set_cutype (ia, text_to_type (str));
+	g_free (str);
+	str = init_value (E_TABLE_MODEL (im), E_MEETING_MODEL_ROLE_COL);
+	e_meeting_attendee_set_role (ia, text_to_role (str));
+	g_free (str);	
+	str = init_value (E_TABLE_MODEL (im), E_MEETING_MODEL_RSVP_COL);
+	e_meeting_attendee_set_rsvp (ia, text_to_boolean (str));
+	g_free (str);
+	
+	e_meeting_attendee_set_delto (ia, init_value (E_TABLE_MODEL (im), E_MEETING_MODEL_DELTO_COL));
+	e_meeting_attendee_set_delfrom (ia, init_value (E_TABLE_MODEL (im), E_MEETING_MODEL_DELFROM_COL));
+
+	str = init_value (E_TABLE_MODEL (im), E_MEETING_MODEL_STATUS_COL);
+	e_meeting_attendee_set_status (ia, text_to_partstat (str));
+	g_free (str);
+
+	e_meeting_attendee_set_cn (ia, init_value (E_TABLE_MODEL (im), E_MEETING_MODEL_CN_COL));
+	e_meeting_attendee_set_language (ia, init_value (E_TABLE_MODEL (im), E_MEETING_MODEL_LANGUAGE_COL));
+
+	e_meeting_model_add_attendee (im, ia);
+
+	return ia;
+}
+
+void
+e_meeting_model_remove_attendee (EMeetingModel *im, EMeetingAttendee *ia)
+{
+	EMeetingModelPrivate *priv;
+	gint i, row = -1;
+	
+	priv = im->priv;
+
+	for (i = 0; i < priv->attendees->len; i++) {
+		if (ia == g_ptr_array_index (priv->attendees, i)) {
+			row = i;
+			break;
+		}
+	}	
+	
+	if (row != -1) {
+		e_table_model_pre_change (E_TABLE_MODEL (im));
+
+		g_ptr_array_remove_index (priv->attendees, row);		
+		g_object_unref (ia);
+
+		e_table_model_row_deleted (E_TABLE_MODEL (im), row);
+	}
+}
+
+void
+e_meeting_model_remove_all_attendees (EMeetingModel *im)
+{
+	EMeetingModelPrivate *priv;
+	gint i, len;
+	
+	priv = im->priv;
+	
+	e_table_model_pre_change (E_TABLE_MODEL (im));
+
+	len = priv->attendees->len;
+
+	for (i = 0; i < len; i++) {
+		EMeetingAttendee *ia = g_ptr_array_index (priv->attendees, i);
+		g_object_unref (ia);
+	}
+	g_ptr_array_set_size (priv->attendees, 0);
+
+	e_table_model_rows_deleted (E_TABLE_MODEL (im), 0, len);
+}
+
+EMeetingAttendee *
+e_meeting_model_find_attendee (EMeetingModel *im, const gchar *address, gint *row)
+{
+	EMeetingModelPrivate *priv;
+	EMeetingAttendee *ia;
+	int i;
+	
+	priv = im->priv;
+	
+	if (address == NULL)
+		return NULL;
+	
+	for (i = 0; i < priv->attendees->len; i++) {
+		const gchar *ia_address;
+		
+		ia = g_ptr_array_index (priv->attendees, i);
+			
+		ia_address = e_meeting_attendee_get_address (ia);
+		if (ia_address && !g_strcasecmp (itip_strip_mailto (ia_address), itip_strip_mailto (address))) {
+			if (row != NULL)
+				*row = i;
+
+			return ia;
+		}
+	}
+
+	return NULL;
+}
+
+EMeetingAttendee *
+e_meeting_model_find_attendee_at_row (EMeetingModel *im, gint row)
+{
+	EMeetingModelPrivate *priv;
+
+	g_return_val_if_fail (im != NULL, NULL);
+	g_return_val_if_fail (E_IS_MEETING_MODEL (im), NULL);
+	g_return_val_if_fail (row >= 0, NULL);
+
+	priv = im->priv;
+	g_return_val_if_fail (row < priv->attendees->len, NULL);
+
+	return g_ptr_array_index (priv->attendees, row);
+}
+
+gint 
+e_meeting_model_count_actual_attendees (EMeetingModel *im)
+{
+	EMeetingModelPrivate *priv;
+	
+	priv = im->priv;
+
+	return e_table_model_row_count (E_TABLE_MODEL (im));	
+}
+
+const GPtrArray *
+e_meeting_model_get_attendees (EMeetingModel *im)
+{
+	EMeetingModelPrivate *priv;
+	
+	priv = im->priv;
+	
+	return priv->attendees;
+}
+
+static icaltimezone *
+find_zone (icalproperty *ip, icalcomponent *tz_top_level)
+{
+	icalparameter *param;
+	icalcomponent *sub_comp;
+	const char *tzid;
+	icalcompiter iter;
+
+	if (tz_top_level == NULL)
+		return NULL;
+	
+	param = icalproperty_get_first_parameter (ip, ICAL_TZID_PARAMETER);
+	if (param == NULL)
+		return NULL;
+	tzid = icalparameter_get_tzid (param);
+
+	iter = icalcomponent_begin_component (tz_top_level, ICAL_VTIMEZONE_COMPONENT);
+	while ((sub_comp = icalcompiter_deref (&iter)) != NULL) {
+		icalcomponent *clone;
+		const char *tz_tzid;
+
+		/* FIXME We aren't passing a property here */
+		tz_tzid = icalproperty_get_tzid (sub_comp);
+		if (!strcmp (tzid, tz_tzid)) {
+			icaltimezone *zone;
+
+			zone = icaltimezone_new ();
+			clone = icalcomponent_new_clone (sub_comp);
+			icaltimezone_set_component (zone, clone);
+			
+			return zone;
+		}
+		
+		icalcompiter_next (&iter);
+	}
+
+	return NULL;
+}
+
+
+static void
+refresh_queue_add (EMeetingModel *im, int row,
+		   EMeetingTime *start,
+		   EMeetingTime *end,
+		   EMeetingModelRefreshCallback call_back,
+		   gpointer data) 
+{
+	EMeetingModelPrivate *priv;
+	EMeetingAttendee *ia;
+	EMeetingModelQueueData *qdata;
+
+	priv = im->priv;
+	
+	ia = g_ptr_array_index (priv->attendees, row);
+	if (ia == NULL)
+		return;
+
+	qdata = g_hash_table_lookup (priv->refresh_data, ia);
+	if (qdata == NULL) {
+		qdata = g_new0 (EMeetingModelQueueData, 1);
+
+		qdata->im = im;
+		qdata->ia = ia;
+		e_meeting_attendee_clear_busy_periods (ia);
+		e_meeting_attendee_set_has_calendar_info (ia, FALSE);
+
+	        qdata->start = *start;
+	        qdata->end = *end;
+		qdata->string = g_string_new (NULL);
+		qdata->call_backs = g_ptr_array_new ();
+		qdata->data = g_ptr_array_new ();
+		g_ptr_array_add (qdata->call_backs, call_back);
+		g_ptr_array_add (qdata->data, data);
+
+		g_hash_table_insert (priv->refresh_data, ia, qdata);
+	} else {
+		if (e_meeting_time_compare_times (start, &qdata->start) == -1)
+			qdata->start = *start;
+		if (e_meeting_time_compare_times (end, &qdata->end) == 1)
+			qdata->end = *end;
+		g_ptr_array_add (qdata->call_backs, call_back);
+		g_ptr_array_add (qdata->data, data);
+	}
+
+	g_object_ref (ia);
+	g_ptr_array_add (priv->refresh_queue, ia);
+
+	if (priv->refresh_idle_id == 0)
+		priv->refresh_idle_id = g_idle_add (refresh_busy_periods, im);
+}
+
+static void
+refresh_queue_remove (EMeetingModel *im, EMeetingAttendee *ia) 
+{
+	EMeetingModelPrivate *priv;
+	EMeetingModelQueueData *qdata;
+	
+	priv = im->priv;
+	
+	/* Free the queue data */
+	qdata = g_hash_table_lookup (priv->refresh_data, ia);
+	g_assert (qdata != NULL);
+
+	g_hash_table_remove (priv->refresh_data, ia);
+	g_ptr_array_free (qdata->call_backs, TRUE);
+	g_ptr_array_free (qdata->data, TRUE);
+	g_free (qdata);
+
+	/* Unref the attendee */
+	g_ptr_array_remove (priv->refresh_queue, ia);
+	g_object_unref (ia);
+}
+
+static void
+process_callbacks (EMeetingModelQueueData *qdata) 
+{
+	EMeetingModel *im;
+	int i;
+
+	for (i = 0; i < qdata->call_backs->len; i++) {
+		EMeetingModelRefreshCallback call_back;
+		gpointer *data;
+
+		call_back = g_ptr_array_index (qdata->call_backs, i);
+		data = g_ptr_array_index (qdata->data, i);
+
+		call_back (data);
+	}
+
+	im = qdata->im;
+	refresh_queue_remove (qdata->im, qdata->ia);
+	g_object_unref (im);
+}
+
+static void
+process_free_busy_comp (EMeetingAttendee *ia,
+			icalcomponent *fb_comp,
+			icaltimezone *zone,
+			icalcomponent *tz_top_level)
+{
+	icalproperty *ip;
+	
+	ip = icalcomponent_get_first_property (fb_comp, ICAL_DTSTART_PROPERTY);
+	if (ip != NULL) {
+		struct icaltimetype dtstart;
+		icaltimezone *ds_zone;
+		
+		dtstart = icalproperty_get_dtstart (ip);
+		if (!dtstart.is_utc)
+			ds_zone = find_zone (ip, tz_top_level);
+		else
+			ds_zone = icaltimezone_get_utc_timezone ();
+		icaltimezone_convert_time (&dtstart, ds_zone, zone);
+		e_meeting_attendee_set_start_busy_range (ia,
+							 dtstart.year,
+							 dtstart.month,
+							 dtstart.day,
+							 dtstart.hour,
+							 dtstart.minute);
+	}
+	
+	ip = icalcomponent_get_first_property (fb_comp, ICAL_DTEND_PROPERTY);
+	if (ip != NULL) {
+		struct icaltimetype dtend;
+		icaltimezone *de_zone;
+		
+		dtend = icalproperty_get_dtend (ip);
+		if (!dtend.is_utc)
+			de_zone = find_zone (ip, tz_top_level);
+		else
+			de_zone = icaltimezone_get_utc_timezone ();
+		icaltimezone_convert_time (&dtend, de_zone, zone);
+		e_meeting_attendee_set_end_busy_range (ia,
+						       dtend.year,
+						       dtend.month,
+						       dtend.day,
+						       dtend.hour,
+						       dtend.minute);
+	}
+	
+	ip = icalcomponent_get_first_property (fb_comp, ICAL_FREEBUSY_PROPERTY);
+	while (ip != NULL) {
+		icalparameter *param;
+		struct icalperiodtype fb;
+		EMeetingFreeBusyType busy_type = E_MEETING_FREE_BUSY_LAST;
+		icalparameter_fbtype fbtype = ICAL_FBTYPE_BUSY;
+			
+		fb = icalproperty_get_freebusy (ip);
+		param = icalproperty_get_first_parameter (ip, ICAL_FBTYPE_PARAMETER);
+		if (param != NULL)
+			fbtype =  icalparameter_get_fbtype (param);
+			
+		switch (fbtype) {
+		case ICAL_FBTYPE_BUSY:
+			busy_type = E_MEETING_FREE_BUSY_BUSY;
+			break;
+
+		case ICAL_FBTYPE_BUSYUNAVAILABLE:
+			busy_type = E_MEETING_FREE_BUSY_OUT_OF_OFFICE;
+			break;
+
+		case ICAL_FBTYPE_BUSYTENTATIVE:
+			busy_type = E_MEETING_FREE_BUSY_TENTATIVE;
+			break;
+
+		default:
+			break;
+		}
+			
+		if (busy_type != E_MEETING_FREE_BUSY_LAST) {
+			icaltimezone *utc_zone = icaltimezone_get_utc_timezone ();
+
+			icaltimezone_convert_time (&fb.start, utc_zone, zone);
+			icaltimezone_convert_time (&fb.end, utc_zone, zone);
+			e_meeting_attendee_add_busy_period (ia,
+							    fb.start.year,
+							    fb.start.month,
+							    fb.start.day,
+							    fb.start.hour,
+							    fb.start.minute,
+							    fb.end.year,
+							    fb.end.month,
+							    fb.end.day,
+							    fb.end.hour,
+							    fb.end.minute,
+							    busy_type);
+		}
+		
+		ip = icalcomponent_get_next_property (fb_comp, ICAL_FREEBUSY_PROPERTY);
+	}
+}
+
+static void
+process_free_busy (EMeetingModelQueueData *qdata, char *text)
+{
+ 	EMeetingModel *im = qdata->im;
+ 	EMeetingModelPrivate *priv;
+ 	EMeetingAttendee *ia = qdata->ia;
+	icalcomponent *main_comp;
+	icalcomponent_kind kind = ICAL_NO_COMPONENT;
+
+	priv = im->priv;
+
+	main_comp = icalparser_parse_string (text);
+ 	if (main_comp == NULL) {
+ 		process_callbacks (qdata);
+  		return;
+ 	}
+
+	kind = icalcomponent_isa (main_comp);
+	if (kind == ICAL_VCALENDAR_COMPONENT) {	
+		icalcompiter iter;
+		icalcomponent *tz_top_level, *sub_comp;
+
+		tz_top_level = cal_util_new_top_level ();
+		
+		iter = icalcomponent_begin_component (main_comp, ICAL_VTIMEZONE_COMPONENT);
+		while ((sub_comp = icalcompiter_deref (&iter)) != NULL) {
+			icalcomponent *clone;
+			
+			clone = icalcomponent_new_clone (sub_comp);
+			icalcomponent_add_component (tz_top_level, clone);
+			
+			icalcompiter_next (&iter);
+		}
+
+		iter = icalcomponent_begin_component (main_comp, ICAL_VFREEBUSY_COMPONENT);
+		while ((sub_comp = icalcompiter_deref (&iter)) != NULL) {
+			process_free_busy_comp (ia, sub_comp, priv->zone, tz_top_level);
+
+			icalcompiter_next (&iter);
+		}
+		icalcomponent_free (tz_top_level);
+	} else if (kind == ICAL_VFREEBUSY_COMPONENT) {
+		process_free_busy_comp (ia, main_comp, priv->zone, NULL);
+	}
+	
+	icalcomponent_free (main_comp);
+
+	process_callbacks (qdata);
+}
+
+static void
+async_close (GnomeVFSAsyncHandle *handle,
+	     GnomeVFSResult result,
+	     gpointer data)
+{
+	EMeetingModelQueueData *qdata = data;
+
+	process_free_busy (qdata, qdata->string->str);
+}
+
+static void
+async_read (GnomeVFSAsyncHandle *handle,
+	    GnomeVFSResult result,
+	    gpointer buffer,
+	    GnomeVFSFileSize requested,
+	    GnomeVFSFileSize read,
+	    gpointer data)
+{
+	EMeetingModelQueueData *qdata = data;
+	GnomeVFSFileSize buf_size = BUF_SIZE - 1;
+
+	if (result != GNOME_VFS_OK && result != GNOME_VFS_ERROR_EOF) {
+		gnome_vfs_async_close (handle, async_close, qdata);
+		return;
+	}
+	
+	((char *)buffer)[read] = '\0';
+	qdata->string = g_string_append (qdata->string, buffer);
+	
+	if (result == GNOME_VFS_ERROR_EOF) {
+		gnome_vfs_async_close (handle, async_close, qdata);
+		return;
+	}
+
+	gnome_vfs_async_read (handle, qdata->buffer, buf_size, async_read, qdata);	
+}
+
+static void
+async_open (GnomeVFSAsyncHandle *handle,
+	    GnomeVFSResult result,
+	    gpointer data)
+{
+	EMeetingModelQueueData *qdata = data;
+	GnomeVFSFileSize buf_size = BUF_SIZE - 1;
+
+	if (result != GNOME_VFS_OK) {
+		gnome_vfs_async_close (handle, async_close, qdata);
+		return;
+	}
+
+	gnome_vfs_async_read (handle, qdata->buffer, buf_size, async_read, qdata);
+}
+
+static void
+contacts_cb (EBook *book, EBookStatus status, GList *contacts, gpointer data)
+{
+	EMeetingModelQueueData *qdata = data;
+	GList *l;
+
+	if (status != E_BOOK_ERROR_OK)
+		return;
+
+	for (l = contacts; l; l = l->next) {
+		GnomeVFSAsyncHandle *handle;
+		EContact *contact = E_CONTACT (l->data);
+		const char *fburl = e_contact_get_const (contact, E_CONTACT_FREEBUSY_URL);
+
+		if (!fburl || !*fburl)
+			continue;
+
+		/* Read in free/busy data from the url */
+		gnome_vfs_async_open (&handle, fburl, GNOME_VFS_OPEN_READ, 
+				      GNOME_VFS_PRIORITY_DEFAULT, async_open, qdata);
+
+		e_free_object_list (contacts);
+		return;
+	}
+
+	process_callbacks (qdata);
+	e_free_object_list (contacts);
+}
+
+static gboolean
+refresh_busy_periods (gpointer data)
+{	
+	EMeetingModel *im = E_MEETING_MODEL (data);
+	EMeetingModelPrivate *priv;
+	EMeetingAttendee *ia = NULL;
+	EMeetingModelQueueData *qdata = NULL;
+	char *query;
+	int i;
+	
+	priv = im->priv;
+
+	/* Check to see if there are any remaining attendees in the queue */
+	for (i = 0; i < priv->refresh_queue->len; i++) {
+		ia = g_ptr_array_index (priv->refresh_queue, i);
+		g_assert (ia != NULL);
+
+		qdata = g_hash_table_lookup (priv->refresh_data, ia);
+		g_assert (qdata != NULL);
+
+		if (!qdata->refreshing)
+			break;
+	}
+
+	/* The everything in the queue is being refreshed */
+	if (i >= priv->refresh_queue->len) {
+		priv->refresh_idle_id = 0;
+		return FALSE;
+	}
+	
+	/* Indicate we are trying to refresh it */
+	qdata->refreshing = TRUE;
+
+	/* We take a ref in case we get destroyed in the gui during a callback */
+	g_object_ref (qdata->im);
+	
+	/* Check the server for free busy data */	
+	if (priv->client) {
+		GList *fb_data = NULL, *users = NULL;
+		struct icaltimetype itt;
+		time_t startt, endt;
+		const char *user;
+		
+		itt = icaltime_null_time ();
+		itt.year = g_date_year (&qdata->start.date);
+		itt.month = g_date_month (&qdata->start.date);
+		itt.day = g_date_day (&qdata->start.date);
+		itt.hour = qdata->start.hour;
+		itt.minute = qdata->start.minute;
+		startt = icaltime_as_timet_with_zone (itt, priv->zone);
+
+		itt = icaltime_null_time ();
+		itt.year = g_date_year (&qdata->end.date);
+		itt.month = g_date_month (&qdata->end.date);
+		itt.day = g_date_day (&qdata->end.date);
+		itt.hour = qdata->end.hour;
+		itt.minute = qdata->end.minute;
+		endt = icaltime_as_timet_with_zone (itt, priv->zone);
+
+		user = itip_strip_mailto (e_meeting_attendee_get_address (ia));
+		users = g_list_append (users, g_strdup (user));
+
+		/* FIXME Error checking */
+		cal_client_get_free_busy (priv->client, users, startt, endt, &fb_data, NULL);
+
+		g_list_foreach (users, (GFunc)g_free, NULL);
+		g_list_free (users);
+
+		if (fb_data != NULL) {
+			CalComponent *comp = fb_data->data;
+			char *comp_str;
+				
+			comp_str = cal_component_get_as_string (comp);
+			process_free_busy (qdata, comp_str);
+			g_free (comp_str);
+			return TRUE;
+		}
+	}
+
+	/* Look for fburl's of attendee with no free busy info on server */
+	if (!priv->book_loaded) {
+		priv->book_load_wait = TRUE;
+		gtk_main ();
+	}
+
+	if (!e_meeting_attendee_is_set_address (ia)) {
+		process_callbacks (qdata);
+		return TRUE;
+	}
+	
+	query = g_strdup_printf ("(is \"email\" \"%s\")", 
+				 itip_strip_mailto (e_meeting_attendee_get_address (ia)));
+	if (!e_book_async_get_contacts (priv->ebook, query, contacts_cb, qdata))
+		process_callbacks (qdata);
+	g_free (query);
+
+	return TRUE;
+}
+		
+void
+e_meeting_model_refresh_all_busy_periods (EMeetingModel *im,
+					  EMeetingTime *start,
+					  EMeetingTime *end,
+					  EMeetingModelRefreshCallback call_back,
+					  gpointer data)
+{
+	EMeetingModelPrivate *priv;
+	int i;
+	
+	g_return_if_fail (im != NULL);
+	g_return_if_fail (E_IS_MEETING_MODEL (im));
+
+	priv = im->priv;
+	
+	for (i = 0; i < priv->attendees->len; i++)
+		refresh_queue_add (im, i, start, end, call_back, data);
+}
+
+void 
+e_meeting_model_refresh_busy_periods (EMeetingModel *im,
+				      int row,
+				      EMeetingTime *start,
+				      EMeetingTime *end,
+				      EMeetingModelRefreshCallback call_back,
+				      gpointer data)
+{
+	EMeetingModelPrivate *priv;
+	
+	g_return_if_fail (im != NULL);
+	g_return_if_fail (E_IS_MEETING_MODEL (im));
+
+	priv = im->priv;
+
+	refresh_queue_add (im, row, start, end, call_back, data);
+}
+
+ETableScrolled *
+e_meeting_model_etable_from_model (EMeetingModel *im, const gchar *spec_file, const gchar *state_file)
+{
+	EMeetingModelPrivate *priv;
+	ETableScrolled *ets;
+	
+	g_return_val_if_fail (im != NULL, NULL);
+	g_return_val_if_fail (E_IS_MEETING_MODEL (im), NULL);
+
+	priv = im->priv;
+	
+	ets = build_etable (E_TABLE_MODEL (im), spec_file, state_file);
+
+	priv->tables = g_list_prepend (priv->tables, ets);
+
+	g_signal_connect (ets, "destroy", G_CALLBACK (table_destroy_list_cb), im);
+	
+	return ets;
+}
+
+void
+e_meeting_model_etable_click_to_add (EMeetingModel *im, gboolean click_to_add)
+{
+	EMeetingModelPrivate *priv;
+	GList *l;
+	
+	g_return_if_fail (im != NULL);
+	g_return_if_fail (E_IS_MEETING_MODEL (im));
+
+	priv = im->priv;
+
+	for (l = priv->tables; l != NULL; l = l->next) {
+		ETableScrolled *ets;
+		ETable *real_table;
+		
+		ets = l->data;
+		real_table = e_table_scrolled_get_table (ets);
+
+		g_object_set (G_OBJECT (real_table), "use_click_to_add", click_to_add, NULL);
+	}
+}
+
+int
+e_meeting_model_etable_model_to_view_row (ETable *et, EMeetingModel *im, int model_row)
+{
+	EMeetingModelPrivate *priv;
+	
+	g_return_val_if_fail (im != NULL, -1);
+	g_return_val_if_fail (E_IS_MEETING_MODEL (im), -1);
+	
+	priv = im->priv;
+	
+	return e_table_model_to_view_row (et, model_row);
+}
+
+int
+e_meeting_model_etable_view_to_model_row (ETable *et, EMeetingModel *im, int view_row)
+{
+	EMeetingModelPrivate *priv;
+	
+	g_return_val_if_fail (im != NULL, -1);
+	g_return_val_if_fail (E_IS_MEETING_MODEL (im), -1);
+	
+	priv = im->priv;
+	
+	return e_table_view_to_model_row (et, view_row);
+}
+
+
+static void
+add_section (GNOME_Evolution_Addressbook_SelectNames corba_select_names, const char *name)
+{
+	CORBA_Environment ev;
+
+	CORBA_exception_init (&ev);
+
+	GNOME_Evolution_Addressbook_SelectNames_addSection (corba_select_names,
+							    name, 
+							    gettext (name),
+							    &ev);
+
+	CORBA_exception_free (&ev);
+}
+
+static gboolean
+get_select_name_dialog (EMeetingModel *im) 
+{
+	EMeetingModelPrivate *priv;
+	CORBA_Environment ev;
+	int i;
+	
+	priv = im->priv;
+
+	if (priv->corba_select_names != CORBA_OBJECT_NIL) {
+		Bonobo_Control corba_control;
+		GtkWidget *control_widget;
+		int i;
+		
+		CORBA_exception_init (&ev);
+		for (i = 0; sections[i] != NULL; i++) {			
+			corba_control = GNOME_Evolution_Addressbook_SelectNames_getEntryBySection 
+				(priv->corba_select_names, sections[i], &ev);
+			if (BONOBO_EX (&ev)) {
+				CORBA_exception_free (&ev);
+				return FALSE;				
+			}
+			
+			control_widget = bonobo_widget_new_control_from_objref (corba_control, CORBA_OBJECT_NIL);
+			
+			bonobo_widget_set_property (BONOBO_WIDGET (control_widget), "text", TC_CORBA_string, "", NULL);		
+		}
+		CORBA_exception_free (&ev);
+
+		return TRUE;
+	}
+	
+	CORBA_exception_init (&ev);
+
+	priv->corba_select_names = bonobo_activation_activate_from_id (SELECT_NAMES_OAFID, 0, NULL, &ev);
+
+	for (i = 0; sections[i] != NULL; i++)
+		add_section (priv->corba_select_names, sections[i]);
+
+	bonobo_event_source_client_add_listener (priv->corba_select_names,
+						 (BonoboListenerCallbackFn) select_names_ok_cb,
+						 "GNOME/Evolution:ok:dialog",
+						 NULL, im);
+	
+	if (BONOBO_EX (&ev)) {
+		CORBA_exception_free (&ev);
+		return FALSE;
+	}
+
+	CORBA_exception_free (&ev);
+
+	return TRUE;
+}
+
+void
+e_meeting_model_invite_others_dialog (EMeetingModel *im)
+{
+	EMeetingModelPrivate *priv;
+	CORBA_Environment ev;
+
+	priv = im->priv;
+	
+	if (!get_select_name_dialog (im))
+		return;
+
+	CORBA_exception_init (&ev);
+
+	GNOME_Evolution_Addressbook_SelectNames_activateDialog (
+		priv->corba_select_names, _("Required Participants"), &ev);
+
+	CORBA_exception_free (&ev);
+}
+
+static void
+process_section (EMeetingModel *im, EABDestination **destv, icalparameter_role role)
+{
+	EMeetingModelPrivate *priv;
+	int i;
+
+	if (!destv)
+	  return;
+
+	priv = im->priv;
+	for (i = 0; destv[i]; i++) {
+		EMeetingAttendee *ia;
+		const char *name, *attendee = NULL;
+		char *attr;
+		CORBA_Environment ev;
+		EABDestination *dest = destv[i];
+
+		CORBA_exception_init (&ev);
+
+		/* Get the CN */
+		name = eab_destination_get_name (dest);
+
+		/* Get the field as attendee from the backend */
+		if (cal_client_get_ldap_attribute (priv->client, &attr, NULL) && attr) {
+			/* FIXME this should be more general */
+			if (!strcmp (attr, "icscalendar")) {
+				EContact *contact = eab_destination_get_contact (dest);
+				if (contact)
+					attendee = e_contact_get_const (contact, E_CONTACT_ICS_CALENDAR);
+			}
+		
+			g_free (attr);
+		}
+
+		CORBA_exception_init (&ev);
+
+		/* If we couldn't get the attendee prior, get the email address as the default */
+		if (attendee == NULL || *attendee == '\0') {
+			attendee = eab_destination_get_email (dest);
+		}
+		
+		CORBA_exception_free (&ev);
+
+		if (attendee == NULL || *attendee == '\0')
+			continue;
+		
+		if (e_meeting_model_find_attendee (im, attendee, NULL) == NULL) {
+			ia = e_meeting_model_add_attendee_with_defaults (im);
+
+			e_meeting_attendee_set_address (ia, g_strdup_printf ("MAILTO:%s", attendee));
+			e_meeting_attendee_set_role (ia, role);
+			if (role == ICAL_ROLE_NONPARTICIPANT)
+				e_meeting_attendee_set_cutype (ia, ICAL_CUTYPE_RESOURCE);
+			e_meeting_attendee_set_cn (ia, g_strdup (name));
+		}
+	}
+}
+
+static void
+select_names_ok_cb (BonoboListener    *listener,
+		    const char        *event_name,
+		    const CORBA_any   *arg,
+		    CORBA_Environment *ev,
+		    gpointer           data)
+{
+	EMeetingModel *im = data;
+	EMeetingModelPrivate *priv;
+	Bonobo_Control corba_control;
+	GtkWidget *control_widget;
+	BonoboControlFrame *control_frame;
+	Bonobo_PropertyBag pb;
+	char *dest_str;
+	EABDestination **dest;
+	int i;
+	
+	priv = im->priv;
+
+	for (i = 0; sections[i] != NULL; i++) {
+		corba_control = GNOME_Evolution_Addressbook_SelectNames_getEntryBySection 
+			(priv->corba_select_names, sections[i], ev);
+		control_widget = bonobo_widget_new_control_from_objref
+			(corba_control, CORBA_OBJECT_NIL);
+
+ 		control_frame = bonobo_widget_get_control_frame (BONOBO_WIDGET (control_widget));
+ 		pb = bonobo_control_frame_get_control_property_bag (control_frame, NULL);
+ 		dest_str = bonobo_pbclient_get_string (pb, "destinations", NULL);
+		dest = eab_destination_importv (dest_str);
+		process_section (im, dest, roles[i]);
+		eab_destination_freev (dest);
+	}
+}
+
+static void
+attendee_changed_cb (EMeetingAttendee *ia, gpointer data) 
+{
+	EMeetingModel *im = E_MEETING_MODEL (data);
+	EMeetingModelPrivate *priv;
+	gint row = -1, i;
+	
+	priv = im->priv;
+
+	/* FIXME: Ideally I think you are supposed to call pre_change() before
+	   the data structures are changed. */
+	e_table_model_pre_change (E_TABLE_MODEL (im));
+
+	for (i = 0; i < priv->attendees->len; i++) {
+		if (ia == g_ptr_array_index (priv->attendees, i)) {
+			row = i;
+			break;
+		}
+	}
+	
+	if (row == -1)
+		e_table_model_no_change (E_TABLE_MODEL (im));
+	else
+		e_table_model_row_changed (E_TABLE_MODEL (im), row);
+}
+
+static void
+table_destroy_state_cb (ETableScrolled *etable, gpointer data)
+{
+	ETable *real_table;
+	char *filename = data;
+	
+	real_table = e_table_scrolled_get_table (etable);
+	e_table_save_state (real_table, filename);
+
+	g_free (data);
+}
+
+static void
+table_destroy_list_cb (ETableScrolled *etable, gpointer data)
+{
+	EMeetingModel *im = E_MEETING_MODEL (data);
+	EMeetingModelPrivate *priv;
+
+	priv = im->priv;
+	
+	priv->tables = g_list_remove (priv->tables, etable);
+}
+
diff --git a/calendar/gui/e-meeting-model.h b/calendar/gui/e-meeting-model.h
new file mode 100644
index 0000000000..50fba6c7a6
--- /dev/null
+++ b/calendar/gui/e-meeting-model.h
@@ -0,0 +1,116 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* e-model.h
+ *
+ * Copyright (C) 2001  Ximian, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * Author: JP Rosevear
+ */
+
+#ifndef _E_MEETING_MODEL_H_
+#define _E_MEETING_MODEL_H_
+
+#include <gtk/gtk.h>
+#include <gal/e-table/e-table-scrolled.h>
+#include <gal/e-table/e-table-model.h>
+#include <cal-client/cal-client.h>
+#include "e-meeting-attendee.h"
+
+G_BEGIN_DECLS
+
+#define E_TYPE_MEETING_MODEL			(e_meeting_model_get_type ())
+#define E_MEETING_MODEL(obj)			(GTK_CHECK_CAST ((obj), E_TYPE_MEETING_MODEL, EMeetingModel))
+#define E_MEETING_MODEL_CLASS(klass)		(GTK_CHECK_CLASS_CAST ((klass), E_TYPE_MEETING_MODEL, EMeetingModelClass))
+#define E_IS_MEETING_MODEL(obj)			(GTK_CHECK_TYPE ((obj), E_TYPE_MEETING_MODEL))
+#define E_IS_MEETING_MODEL_CLASS(klass)		(GTK_CHECK_CLASS_TYPE ((obj), E_TYPE_MEETING_MODEL))
+
+
+typedef struct _EMeetingModel        EMeetingModel;
+typedef struct _EMeetingModelPrivate EMeetingModelPrivate;
+typedef struct _EMeetingModelClass   EMeetingModelClass;
+
+typedef enum {
+	E_MEETING_MODEL_ADDRESS_COL,
+	E_MEETING_MODEL_MEMBER_COL,
+	E_MEETING_MODEL_TYPE_COL,
+	E_MEETING_MODEL_ROLE_COL,
+	E_MEETING_MODEL_RSVP_COL,
+	E_MEETING_MODEL_DELTO_COL,
+	E_MEETING_MODEL_DELFROM_COL,
+	E_MEETING_MODEL_STATUS_COL,
+	E_MEETING_MODEL_CN_COL,
+	E_MEETING_MODEL_LANGUAGE_COL,
+	E_MEETING_MODEL_COLUMN_COUNT
+} EMeetingModelColumns;
+
+struct _EMeetingModel {
+	ETableModel parent;
+
+	EMeetingModelPrivate *priv;
+};
+
+struct _EMeetingModelClass {
+	ETableModelClass parent_class;
+};
+
+typedef void	(* EMeetingModelRefreshCallback) (gpointer data);
+
+
+GtkType    e_meeting_model_get_type (void);
+GtkObject *e_meeting_model_new      (void);
+
+CalClient *e_meeting_model_get_cal_client (EMeetingModel *im);
+void e_meeting_model_set_cal_client (EMeetingModel *im, CalClient *client);
+
+icaltimezone *e_meeting_model_get_zone (EMeetingModel *im);
+void e_meeting_model_set_zone (EMeetingModel *im, icaltimezone *zone);
+
+void e_meeting_model_add_attendee (EMeetingModel *im, EMeetingAttendee *ia);
+EMeetingAttendee *e_meeting_model_add_attendee_with_defaults (EMeetingModel *im);
+
+void e_meeting_model_remove_attendee (EMeetingModel *im, EMeetingAttendee *ia);
+void e_meeting_model_remove_all_attendees (EMeetingModel *im);
+
+EMeetingAttendee *e_meeting_model_find_attendee (EMeetingModel *im, const gchar *address, gint *row);
+EMeetingAttendee *e_meeting_model_find_attendee_at_row (EMeetingModel *im, gint row);
+
+gint e_meeting_model_count_actual_attendees (EMeetingModel *im);
+const GPtrArray *e_meeting_model_get_attendees (EMeetingModel *im);
+
+void e_meeting_model_refresh_all_busy_periods (EMeetingModel *im,
+					       EMeetingTime *start,
+					       EMeetingTime *end,
+					       EMeetingModelRefreshCallback call_back,
+					       gpointer data);
+void e_meeting_model_refresh_busy_periods (EMeetingModel *im,
+					   int row,
+					   EMeetingTime *start,
+					   EMeetingTime *end,
+					   EMeetingModelRefreshCallback call_back,
+					   gpointer data);
+
+
+/* Helpful functions */
+ETableScrolled    *e_meeting_model_etable_from_model (EMeetingModel *im, const gchar *spec_file, const gchar *state_file);
+void e_meeting_model_etable_click_to_add (EMeetingModel *im, gboolean click_to_add);
+int e_meeting_model_etable_model_to_view_row (ETable *et, EMeetingModel *im, int model_row);
+int e_meeting_model_etable_view_to_model_row (ETable *et, EMeetingModel *im, int view_row);
+
+void e_meeting_model_invite_others_dialog (EMeetingModel *im);
+
+G_END_DECLS
+
+#endif
diff --git a/calendar/gui/e-meeting-store.c b/calendar/gui/e-meeting-store.c
index 0129756e7c..6064971d9f 100644
--- a/calendar/gui/e-meeting-store.c
+++ b/calendar/gui/e-meeting-store.c
@@ -30,7 +30,6 @@
 #include <libgnome/gnome-util.h>
 #include <libgnomevfs/gnome-vfs.h>
 #include <ebook/e-book.h>
-#include <ebook/e-book-util.h>
 #include <cal-util/cal-component.h>
 #include <cal-util/cal-util.h>
 #include <cal-util/timeutil.h>
@@ -50,8 +49,6 @@ struct _EMeetingStorePrivate {
 	icaltimezone *zone;
 	
 	EBook *ebook;
-	gboolean book_loaded;
-	gboolean book_load_wait;
 
 	GPtrArray *refresh_queue;
 	GHashTable *refresh_data;
@@ -81,26 +78,10 @@ struct _EMeetingStoreQueueData {
 static GObjectClass *parent_class = NULL;
 
 static void
-book_open_cb (EBook *book, EBookStatus status, gpointer data)
-{
-	EMeetingStore *store = E_MEETING_STORE (data);
-
-	if (status == E_BOOK_STATUS_SUCCESS)
-		store->priv->book_loaded = TRUE;
-	else
-		g_warning ("Book not loaded");
-
-	if (store->priv->book_load_wait) {
-		store->priv->book_load_wait = FALSE;
-		gtk_main_quit ();
-	}
-}
-
-static void
 start_addressbook_server (EMeetingStore *store)
 {
 	store->priv->ebook = e_book_new ();
-	e_book_load_default_book (store->priv->ebook, book_open_cb, store);
+	e_book_load_local_addressbook (store->priv->ebook, NULL);
 }
 
 static icalparameter_cutype
@@ -914,9 +895,11 @@ find_zone (icalproperty *ip, icalcomponent *tz_top_level)
 	iter = icalcomponent_begin_component (tz_top_level, ICAL_VTIMEZONE_COMPONENT);
 	while ((sub_comp = icalcompiter_deref (&iter)) != NULL) {
 		icalcomponent *clone;
+		icalproperty *prop;
 		const char *tz_tzid;
-		
-		tz_tzid = icalproperty_get_tzid (sub_comp);
+
+		prop = icalcomponent_get_first_property (sub_comp, ICAL_TZID_PROPERTY);
+		tz_tzid = icalproperty_get_tzid (prop);
 		if (!strcmp (tzid, tz_tzid)) {
 			icaltimezone *zone;
 
@@ -1141,7 +1124,7 @@ refresh_busy_periods (gpointer data)
 	
 	/* Check the server for free busy data */	
 	if (priv->client) {
-		GList *fb_data, *users = NULL;
+		GList *fb_data = NULL, *users = NULL;
 		struct icaltimetype itt;
 		time_t startt, endt;
 		const char *user;
@@ -1164,7 +1147,7 @@ refresh_busy_periods (gpointer data)
 
 		user = itip_strip_mailto (e_meeting_attendee_get_address (attendee));
 		users = g_list_append (users, g_strdup (user));
-		fb_data = cal_client_get_free_busy (priv->client, users, startt, endt);
+		cal_client_get_free_busy (priv->client, users, startt, endt, &fb_data, NULL);
 
 		g_list_foreach (users, (GFunc)g_free, NULL);
 		g_list_free (users);
@@ -1181,11 +1164,6 @@ refresh_busy_periods (gpointer data)
 	}
 
 	/* Look for fburl's of attendee with no free busy info on server */
-	if (!priv->book_loaded) {
-		priv->book_load_wait = TRUE;
-		gtk_main ();
-	}
-
 	if (!e_meeting_attendee_is_set_address (attendee)) {
 		process_callbacks (qdata);
 		return TRUE;
diff --git a/calendar/gui/e-meeting-time-sel.c b/calendar/gui/e-meeting-time-sel.c
index 157320ef16..91d915a4d7 100644
--- a/calendar/gui/e-meeting-time-sel.c
+++ b/calendar/gui/e-meeting-time-sel.c
@@ -265,6 +265,7 @@ e_meeting_time_selector_init (EMeetingTimeSelector * mts)
 void
 e_meeting_time_selector_construct (EMeetingTimeSelector * mts, EMeetingStore *ems)
 {
+	char *filename;
 	GtkWidget *hbox, *vbox, *separator, *button, *label, *table;
 	GtkWidget *alignment, *child_hbox, *arrow, *menuitem;
 	GSList *group;
@@ -313,7 +314,12 @@ e_meeting_time_selector_construct (EMeetingTimeSelector * mts, EMeetingStore *em
 	gtk_box_pack_start (GTK_BOX (vbox), mts->attendees_vbox, TRUE, TRUE, 0);
 	gtk_widget_show (mts->attendees_vbox);
 
+
+	/* build the etable */
+	filename = g_build_filename (calendar_component_peek_config_directory (calendar_component_peek ()),
+				     "config", "et-header-meeting-time-sel", NULL);
 	mts->model = ems;
+
 	if (mts->model)
 		g_object_ref (mts->model);
 
diff --git a/calendar/gui/e-select-names-editable.c b/calendar/gui/e-select-names-editable.c
index 2fcc93397a..29c54c7979 100644
--- a/calendar/gui/e-select-names-editable.c
+++ b/calendar/gui/e-select-names-editable.c
@@ -25,7 +25,7 @@
 #include <gtk/gtkcelleditable.h>
 #include <bonobo/bonobo-exception.h>
 #include <bonobo/bonobo-widget.h>
-#include <ebook/e-destination.h>
+#include <addressbook/util/eab-destination.h>
 
 #include "e-select-names-editable.h"
 #include "Evolution-Addressbook-SelectNames.h"
@@ -187,16 +187,16 @@ e_select_names_editable_new ()
 gchar *
 e_select_names_editable_get_address (ESelectNamesEditable *esne)
 {
-	EDestination **dest;
+	EABDestination **dest;
 	gchar *dest_str;
 	gchar *result;
 
 	g_return_val_if_fail (E_SELECT_NAMES_EDITABLE (esne), NULL);
 
 	dest_str = bonobo_pbclient_get_string (esne->priv->bag, "destinations", NULL);
-	dest = e_destination_importv (dest_str);
-	result = g_strdup (e_destination_get_email (*dest));
-	e_destination_freev (dest);
+	dest = eab_destination_importv (dest_str);
+	result = g_strdup (eab_destination_get_email (*dest));
+	eab_destination_freev (dest);
 
 	return result;
 }
@@ -204,16 +204,16 @@ e_select_names_editable_get_address (ESelectNamesEditable *esne)
 gchar *
 e_select_names_editable_get_name (ESelectNamesEditable *esne)
 {
-	EDestination **dest;
+	EABDestination **dest;
 	gchar *dest_str;
 	gchar *result;
 
 	g_return_val_if_fail (E_SELECT_NAMES_EDITABLE (esne), NULL);
 
 	dest_str = bonobo_pbclient_get_string (esne->priv->bag, "destinations", NULL);
-	dest = e_destination_importv (dest_str);
-	result = g_strdup (e_destination_get_name (*dest));
-	e_destination_freev (dest);
+	dest = eab_destination_importv (dest_str);
+	result = g_strdup (eab_destination_get_name (*dest));
+	eab_destination_freev (dest);
 
 	return result;
 }
diff --git a/calendar/gui/e-tasks.c b/calendar/gui/e-tasks.c
index b441aee09d..768b2e587c 100644
--- a/calendar/gui/e-tasks.c
+++ b/calendar/gui/e-tasks.c
@@ -572,7 +572,6 @@ GtkWidget *
 e_tasks_construct (ETasks *tasks)
 {
 	ETasksPrivate *priv;
-	ECalModel *model;
 
 	g_return_val_if_fail (tasks != NULL, NULL);
 	g_return_val_if_fail (E_IS_TASKS (tasks), NULL);
@@ -581,24 +580,6 @@ e_tasks_construct (ETasks *tasks)
 
 	setup_widgets (tasks);
 
-	priv->client = cal_client_new ();
-	if (!priv->client)
-		return NULL;
-
-	g_signal_connect (priv->client, "cal_opened",
-			  G_CALLBACK (cal_opened_cb), tasks);
-	g_signal_connect (priv->client, "backend_error",
-			  G_CALLBACK (backend_error_cb), tasks);
-	g_signal_connect (priv->client, "categories_changed",
-			  G_CALLBACK (client_categories_changed_cb), tasks);
-	g_signal_connect (priv->client, "obj_updated",
-			  G_CALLBACK (client_obj_updated_cb), tasks);
-
-	model = e_calendar_table_get_model (E_CALENDAR_TABLE (priv->tasks_view));
-	g_assert (model != NULL);
-
-	e_cal_model_add_client (model, priv->client);
-
 	return GTK_WIDGET (tasks);
 }
 
@@ -685,6 +666,8 @@ e_tasks_open			(ETasks		*tasks,
 	EUri *uri;
 	char *real_uri;
 	char *urinopwd;
+       	ECalModel *model;
+	GError *error = NULL;
 
 	g_return_val_if_fail (tasks != NULL, FALSE);
 	g_return_val_if_fail (E_IS_TASKS (tasks), FALSE);
@@ -704,10 +687,30 @@ e_tasks_open			(ETasks		*tasks,
 	g_free (message);
 	g_free (urinopwd);
 
-	if (!cal_client_open_calendar (priv->client, real_uri, FALSE)) {
-		g_message ("e_tasks_open(): Could not issue the request");
+	/* create the CalClient */
+	priv->client = cal_client_new (real_uri, CALOBJ_TYPE_TODO);
+	if (!priv->client)
+		return NULL;
+
+	g_signal_connect (priv->client, "cal_opened",
+			  G_CALLBACK (cal_opened_cb), tasks);
+	g_signal_connect (priv->client, "backend_error",
+			  G_CALLBACK (backend_error_cb), tasks);
+	g_signal_connect (priv->client, "categories_changed",
+			  G_CALLBACK (client_categories_changed_cb), tasks);
+	g_signal_connect (priv->client, "obj_updated",
+			  G_CALLBACK (client_obj_updated_cb), tasks);
+
+	model = e_calendar_table_get_model (E_CALENDAR_TABLE (priv->tasks_view));
+	g_assert (model != NULL);
+
+	e_cal_model_add_client (model, priv->client);
+
+	if (cal_client_open (priv->client, FALSE, &error)) {
+		g_message ("e_tasks_open(): %s", error->message);
 		g_free (real_uri);
 		e_uri_free (uri);
+		g_error_free (error);
 
 		return FALSE;
 	}
@@ -787,7 +790,8 @@ cal_opened_cb				(CalClient	*client,
 		location = calendar_config_get_timezone ();
 		zone = icaltimezone_get_builtin_timezone (location);
 		if (zone)
-			cal_client_set_default_timezone (client, zone);
+			/* FIXME Error checking */
+			cal_client_set_default_timezone (client, zone, NULL);
 		return;
 
 	case CAL_CLIENT_OPEN_ERROR:
@@ -937,60 +941,6 @@ create_sexp (void)
 	return sexp;
 }
 
-/* Callback used when a component is updated in the live query */
-static void
-query_obj_updated_cb (CalQuery *query, const char *uid,
-		      gboolean query_in_progress, int n_scanned, int total,
-		      gpointer data)
-{
-	ETasks *tasks;
-	ETasksPrivate *priv;
-	
-	tasks = E_TASKS (data);
-	priv = tasks->priv;
-	
-	delete_error_dialog (cal_client_remove_object (priv->client, uid), CAL_COMPONENT_TODO);
-}
-
-/* Callback used when an evaluation error occurs when running a query */
-static void
-query_eval_error_cb (CalQuery *query, const char *error_str, gpointer data)
-{
-	ETasks *tasks;
-	ETasksPrivate *priv;
-	
-	tasks = E_TASKS (data);
-	priv = tasks->priv;
-	
-	g_warning ("eval error: %s\n", error_str);
-
-	set_status_message (tasks, NULL);
-
-	g_signal_handlers_disconnect_matched (priv->query, G_SIGNAL_MATCH_DATA,
-					      0, 0, NULL, NULL, tasks);
-	g_object_unref (priv->query);
-	priv->query = NULL;
-}
-
-static void
-query_query_done_cb (CalQuery *query, CalQueryDoneStatus status, const char *error_str, gpointer data)
-{
-	ETasks *tasks;
-	ETasksPrivate *priv;
-	
-	tasks = E_TASKS (data);
-	priv = tasks->priv;
-	
-	if (status != CAL_QUERY_DONE_SUCCESS)
-		g_warning ("query done: %s\n", error_str);
-
-	set_status_message (tasks, NULL);
-
-	g_signal_handlers_disconnect_matched (priv->query, G_SIGNAL_MATCH_DATA,
-					      0, 0, NULL, NULL, tasks);
-	g_object_unref (priv->query);
-	priv->query = NULL;
-}
 /**
  * e_tasks_expunge:
  * @tasks: A tasks control widget
@@ -1002,31 +952,32 @@ e_tasks_delete_completed (ETasks *tasks)
 {
 	ETasksPrivate *priv;
 	char *sexp;
+	GList *objects, *l;
 	
 	g_return_if_fail (tasks != NULL);
 	g_return_if_fail (E_IS_TASKS (tasks));
 
 	priv = tasks->priv;
 
-	/* If we have a query, we are already expunging */
-	if (priv->query)
-		return;
+	/* FIXME Confirm expunge */
 
 	sexp = create_sexp ();
 
 	set_status_message (tasks, _("Expunging"));
-	priv->query = cal_client_get_query (priv->client, sexp);
-	g_free (sexp);
-
-	if (!priv->query) {
+	
+	if (!cal_client_get_object_list (priv->client, sexp, &objects, NULL)) {
 		set_status_message (tasks, NULL);
-		g_message ("update_query(): Could not create the query");
+		g_warning (G_STRLOC ": Could not get the objects");
+
 		return;
 	}
+	
+	for (l = objects; l; l = l->next) {
+		/* FIXME Better error handling */
+		cal_client_remove_object (priv->client, icalcomponent_get_uid (l->data), NULL);
+	}
 
-	g_signal_connect (priv->query, "obj_updated", G_CALLBACK (query_obj_updated_cb), tasks);
-	g_signal_connect (priv->query, "query_done", G_CALLBACK (query_query_done_cb), tasks);
-	g_signal_connect (priv->query, "eval_error", G_CALLBACK (query_eval_error_cb), tasks);
+	set_status_message (tasks, NULL);
 }
 
 /* Callback used from the view collection when we need to display a new view */
@@ -1181,6 +1132,7 @@ e_tasks_update_all_config_settings	(void)
 		calendar_config_configure_e_calendar_table (E_CALENDAR_TABLE (priv->tasks_view));
 
 		if (zone)
-			cal_client_set_default_timezone (priv->client, zone);
+			/* FIXME Error checking */
+			cal_client_set_default_timezone (priv->client, zone, NULL);
 	}
 }
diff --git a/calendar/gui/e-week-view-event-item.c b/calendar/gui/e-week-view-event-item.c
index 139f28bb13..fd68130bc5 100644
--- a/calendar/gui/e-week-view-event-item.c
+++ b/calendar/gui/e-week-view-event-item.c
@@ -890,7 +890,6 @@ e_week_view_event_item_double_click (EWeekViewEventItem *wveitem,
 	EWeekView *week_view;
 	EWeekViewEvent *event;
 	GnomeCanvasItem *item;
-	GnomeCalendar *calendar;
 
 	item = GNOME_CANVAS_ITEM (wveitem);
 
@@ -902,11 +901,7 @@ e_week_view_event_item_double_click (EWeekViewEventItem *wveitem,
 
 	e_week_view_stop_editing_event (week_view);
 
-	calendar = e_cal_view_get_calendar (E_CAL_VIEW (week_view));
-	if (calendar)
-		gnome_calendar_edit_object (calendar, event->comp_data->client, event->comp_data->icalcomp, FALSE);
-	else
-		g_warning ("Calendar not set");
+	e_cal_view_edit_appointment (E_CAL_VIEW (week_view), event->comp_data->client, event->comp_data->icalcomp, FALSE);
 
 	return TRUE;
 }
diff --git a/calendar/gui/e-week-view.c b/calendar/gui/e-week-view.c
index 8028bf13e6..1be94fc1de 100644
--- a/calendar/gui/e-week-view.c
+++ b/calendar/gui/e-week-view.c
@@ -62,6 +62,7 @@
 #include "calendar-config.h"
 #include "print.h"
 #include "goto.h"
+#include "e-cal-model-calendar.h"
 #include "e-week-view-event-item.h"
 #include "e-week-view-layout.h"
 #include "e-week-view-main-item.h"
@@ -312,8 +313,6 @@ e_week_view_init (EWeekView *week_view)
 
 	week_view->main_gc = NULL;
 
-	week_view->default_category = NULL;
-
 	/* Create the small font. */
 	week_view->use_small_font = TRUE;
 
@@ -423,8 +422,11 @@ GtkWidget *
 e_week_view_new (void)
 {
 	GtkWidget *week_view;
+	ECalModel *model;
+	
+	model = E_CAL_MODEL (e_cal_model_calendar_new ());
 
-	week_view = GTK_WIDGET (g_object_new (e_week_view_get_type (), NULL));
+	week_view = GTK_WIDGET (g_object_new (e_week_view_get_type (), "model", model, NULL));
 
 	return week_view;
 }
@@ -457,11 +459,6 @@ e_week_view_destroy (GtkObject *object)
 		week_view->small_font_desc = NULL;
 	}
 
-	if (week_view->default_category) {
-		g_free (week_view->default_category);
-		week_view->default_category = NULL;
-	}
-
 	if (week_view->normal_cursor) {
 		gdk_cursor_unref (week_view->normal_cursor);
 		week_view->normal_cursor = NULL;
@@ -1149,7 +1146,7 @@ process_component (EWeekView *week_view, ECalModelComponent *comp_data)
 		g_object_unref (tmp_comp);
 	}
 
-	/* Add the occurrences of the event. */
+	/* Add the occurrences of the event */
 	num_days = week_view->multi_week_view ? week_view->weeks_shown * 7 : 7;
 
 	add_event_data.week_view = week_view;
@@ -1158,8 +1155,7 @@ process_component (EWeekView *week_view, ECalModelComponent *comp_data)
 				      week_view->day_starts[0],
 				      week_view->day_starts[num_days],
 				      e_week_view_add_event, &add_event_data,
-				      cal_client_resolve_tzid_cb,
-				      comp_data->client,
+				      cal_client_resolve_tzid_cb, comp_data->client,
 				      e_cal_view_get_timezone (E_CAL_VIEW (week_view)));
 
 	g_object_unref (comp);
@@ -1178,8 +1174,6 @@ e_week_view_update_query (ECalView *cal_view)
 	e_week_view_free_events (week_view);
 	e_week_view_queue_layout (week_view);
 
-	e_cal_view_set_status_message (E_CAL_VIEW (week_view), _("Searching"));
-
 	rows = e_table_model_row_count (E_TABLE_MODEL (e_cal_view_get_model (E_CAL_VIEW (week_view))));
 	for (r = 0; r < rows; r++) {
 		ECalModelComponent *comp_data;
@@ -1188,8 +1182,6 @@ e_week_view_update_query (ECalView *cal_view)
 		g_assert (comp_data != NULL);
 		process_component (week_view, comp_data);
 	}
-
-	e_cal_view_set_status_message (E_CAL_VIEW (week_view), NULL);
 }
 
 static void
@@ -1217,27 +1209,6 @@ e_week_view_draw_shadow (EWeekView *week_view)
 	gdk_draw_line (window, light_gc, x1, y2, x2, y2);
 }
 
-/**
- * e_week_view_set_default_category:
- * @week_view: A week view.
- * @category: Default category name or NULL for no category.
- *
- * Sets the default category that will be used when creating new calendar
- * components from the week view.
- **/
-void
-e_week_view_set_default_category (EWeekView *week_view, const char *category)
-{
-	g_return_if_fail (week_view != NULL);
-	g_return_if_fail (E_IS_WEEK_VIEW (week_view));
-
-	if (week_view->default_category)
-		g_free (week_view->default_category);
-
-	week_view->default_category = g_strdup (category);
-}
-
-
 /* This sets the selected time range. The EWeekView will show the corresponding
    month and the days between start_time and end_time will be selected.
    To select a single day, use the same value for start_time & end_time. */
@@ -2015,7 +1986,7 @@ e_week_view_on_button_press (GtkWidget *widget,
 		return FALSE;
 
 	if (event->button == 1 && event->type == GDK_2BUTTON_PRESS) {
-		gnome_calendar_new_appointment (e_cal_view_get_calendar (E_CAL_VIEW (week_view)));
+		e_cal_view_new_appointment (E_CAL_VIEW (week_view));
 		return TRUE;
 	}
 
@@ -2876,14 +2847,11 @@ e_week_view_on_text_item_event (GnomeCanvasItem *item,
 {
 	EWeekViewEvent *event;
 	gint event_num, span_num;
-	GnomeCalendar *calendar;
 
 #if 0
 	g_print ("In e_week_view_on_text_item_event\n");
 #endif
 
-	calendar = e_cal_view_get_calendar (E_CAL_VIEW (week_view));
-
 	switch (gdkevent->type) {
 	case GDK_KEY_PRESS:
 		if (gdkevent && gdkevent->key.keyval == GDK_Return) {
@@ -2912,10 +2880,9 @@ e_week_view_on_text_item_event (GnomeCanvasItem *item,
 		event = &g_array_index (week_view->events, EWeekViewEvent,
 					event_num);
 
-		if (calendar)
-			gnome_calendar_edit_object (calendar, event->comp_data->client, event->comp_data->icalcomp, FALSE);
-		else
-			g_warning ("Calendar not set");
+		e_cal_view_edit_appointment (E_CAL_VIEW (week_view),
+					     event->comp_data->client,
+					     event->comp_data->icalcomp, FALSE);
 
 		gtk_signal_emit_stop_by_name (GTK_OBJECT (item), "event");
 		return TRUE;
@@ -3049,7 +3016,8 @@ e_week_view_on_editing_stopped (EWeekView *week_view,
 	CalComponent *comp;
 	CalComponentText summary;
 	const char *uid;
-
+	gboolean on_server;
+	
 	/* Note: the item we are passed here isn't reliable, so we just stop
 	   the edit of whatever item was being edited. We also receive this
 	   event twice for some reason. */
@@ -3079,8 +3047,9 @@ e_week_view_on_editing_stopped (EWeekView *week_view,
 	comp = cal_component_new ();
 	cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
 
-	if (string_is_empty (text) &&
-	    !cal_comp_is_on_server (comp, event->comp_data->client)) {
+	on_server = cal_comp_is_on_server (comp, event->comp_data->client);
+	
+	if (string_is_empty (text) && !on_server) {
 		const char *uid;
 		
 		cal_component_get_uid (comp, &uid);
@@ -3099,33 +3068,33 @@ e_week_view_on_editing_stopped (EWeekView *week_view,
 			e_week_view_reshape_event_span (week_view, event_num,
 							span_num);
 	} else if (summary.value || !string_is_empty (text)) {
+		icalcomponent *icalcomp = cal_component_get_icalcomponent (comp);
+		
 		summary.value = text;
 		summary.altrep = NULL;
 		cal_component_set_summary (comp, &summary);
-
-		if (cal_component_is_instance (comp)) {
-			CalObjModType mod;
-
-			if (recur_component_dialog (comp, &mod, NULL)) {
-				if (cal_client_update_object_with_mod (event->comp_data->client, comp, mod)
-				    == CAL_CLIENT_RESULT_SUCCESS) {
-					if (itip_organizer_is_user (comp, event->comp_data->client) 
-					    && send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (week_view)),
-								      event->comp_data->client, comp, FALSE))
-						itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, 
-								event->comp_data->client, NULL);
-				} else {
-					g_message ("e_week_view_on_editing_stopped(): Could not update the object!");
+		
+		if (!on_server) {
+			if (!cal_client_create_object (event->comp_data->client, icalcomp, NULL, NULL))
+				g_message (G_STRLOC ": Could not create the object!");
+		} else {
+			CalObjModType mod = CALOBJ_MOD_ALL;
+			GtkWindow *toplevel;
+			
+			if (cal_component_has_recurrences (comp)) {
+				if (!recur_component_dialog (comp, &mod, NULL)) {
+					goto out;
 				}
 			}
-		} else if (cal_client_update_object (event->comp_data->client, comp) == CAL_CLIENT_RESULT_SUCCESS) {
-			if (itip_organizer_is_user (comp, event->comp_data->client) &&
-			    send_component_dialog ((GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (week_view)),
-						   event->comp_data->client, comp, FALSE))
-				itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp,
-						event->comp_data->client, NULL);
-		} else {
-			g_message ("e_week_view_on_editing_stopped(): Could not update the object!");
+			
+			/* FIXME When sending here, what exactly should we send? */
+			toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (week_view)));
+			if (cal_client_modify_object (event->comp_data->client, icalcomp, mod, NULL)) {
+				if (itip_organizer_is_user (comp, event->comp_data->client) 
+				    && send_component_dialog (toplevel, event->comp_data->client, comp, FALSE))
+					itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, 
+							event->comp_data->client, NULL);
+			}
 		}
 	}
 
@@ -3182,6 +3151,10 @@ e_week_view_find_event_from_uid (EWeekView	  *week_view,
 	EWeekViewEvent *event;
 	gint event_num, num_events;
 
+	*event_num_return = -1;
+	if (!uid)
+		return FALSE;
+
 	num_events = week_view->events->len;
 	for (event_num = 0; event_num < num_events; event_num++) {
 		const char *u;
@@ -3291,6 +3264,8 @@ e_week_view_do_key_press (GtkWidget *widget, GdkEventKey *event)
 
 	/* Add a new event covering the selected range. */
 	icalcomp = e_cal_model_create_component_with_defaults (e_cal_view_get_model (E_CAL_VIEW (week_view)));
+	if (!icalcomp)
+		return FALSE;
 	uid = icalcomponent_get_uid (icalcomp);
 
 	comp = cal_component_new ();
@@ -3313,7 +3288,8 @@ e_week_view_do_key_press (GtkWidget *widget, GdkEventKey *event)
 						     e_cal_view_get_timezone (E_CAL_VIEW (week_view)));
 	cal_component_set_dtend (comp, &date);
 
-	cal_component_set_categories (comp, week_view->default_category);
+	cal_component_set_categories (
+		comp, e_cal_view_get_default_category (E_CAL_VIEW (week_view)));
 
 	/* We add the event locally and start editing it. We don't send it
 	   to the server until the user finishes editing it. */
@@ -3546,63 +3522,6 @@ e_week_view_popup_menu (GtkWidget *widget)
 }
 
 void
-e_week_view_unrecur_appointment (EWeekView *week_view)
-{
-	EWeekViewEvent *event;
-	CalComponent *comp, *new_comp;
-	CalComponentDateTime date;
-	struct icaltimetype itt;
-
-	if (week_view->popup_event_num == -1)
-		return;
-
-	event = &g_array_index (week_view->events, EWeekViewEvent,
-				week_view->popup_event_num);
-
-	/* For the recurring object, we add a exception to get rid of the
-	   instance. */
-	comp = cal_component_new ();
-	cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
-	cal_comp_util_add_exdate (comp, event->start, e_cal_view_get_timezone (E_CAL_VIEW (week_view)));
-
-	/* For the unrecurred instance we duplicate the original object,
-	   create a new uid for it, get rid of the recurrence rules, and set
-	   the start & end times to the instances times. */
-	new_comp = cal_component_new ();
-	cal_component_set_icalcomponent (new_comp, icalcomponent_new_clone (event->comp_data->icalcomp));
-	cal_component_set_uid (new_comp, cal_component_gen_uid ());
-	cal_component_set_rdate_list (new_comp, NULL);
-	cal_component_set_rrule_list (new_comp, NULL);
-	cal_component_set_exdate_list (new_comp, NULL);
-	cal_component_set_exrule_list (new_comp, NULL);
-
-	date.value = &itt;
-	date.tzid = icaltimezone_get_tzid (e_cal_view_get_timezone (E_CAL_VIEW (week_view)));
-
-	*date.value = icaltime_from_timet_with_zone (event->start, FALSE,
-						     e_cal_view_get_timezone (E_CAL_VIEW (week_view)));
-	cal_component_set_dtstart (new_comp, &date);
-	*date.value = icaltime_from_timet_with_zone (event->end, FALSE,
-						     e_cal_view_get_timezone (E_CAL_VIEW (week_view)));
-	cal_component_set_dtend (new_comp, &date);
-
-	/* Now update both CalComponents. Note that we do this last since at
-	   present the updates happen synchronously so our event may disappear.
-	*/
-	if (cal_client_update_object (event->comp_data->client, comp)
-	    != CAL_CLIENT_RESULT_SUCCESS)
-		g_message ("e_week_view_on_unrecur_appointment(): Could not update the object!");
-
-	g_object_unref (comp);
-
-	if (cal_client_update_object (event->comp_data->client, new_comp)
-	    != CAL_CLIENT_RESULT_SUCCESS)
-		g_message ("e_week_view_on_unrecur_appointment(): Could not update the object!");
-
-	g_object_unref (new_comp);
-}
-
-void
 e_week_view_jump_to_button_item (EWeekView *week_view, GnomeCanvasItem *item)
 {
 	gint day;
diff --git a/calendar/gui/e-week-view.h b/calendar/gui/e-week-view.h
index c24470155d..0296c19c42 100644
--- a/calendar/gui/e-week-view.h
+++ b/calendar/gui/e-week-view.h
@@ -331,9 +331,6 @@ struct _EWeekView
 	gchar *pm_string;
 	gint am_string_width;
 	gint pm_string_width;
-
-	/* The default category for new events */
-	char *default_category;
 };
 
 struct _EWeekViewClass
@@ -353,9 +350,6 @@ void	   e_week_view_get_first_day_shown	(EWeekView	*week_view,
 void	   e_week_view_set_first_day_shown	(EWeekView	*week_view,
 						 GDate		*date);
 
-void       e_week_view_set_default_category	(EWeekView	*week_view,
-						 const char	*category);
-
 /* The selected time range. The EWeekView will show the corresponding
    month and the days between start_time and end_time will be selected.
    To select a single day, use the same value for start_time & end_time. */
@@ -396,8 +390,6 @@ void	   e_week_view_set_24_hour_format	(EWeekView	*week_view,
 
 void       e_week_view_delete_occurrence        (EWeekView      *week_view);
 
-void       e_week_view_unrecur_appointment      (EWeekView *week_view);
-
 /* Returns the number of selected events (0 or 1 at present). */
 gint	   e_week_view_get_num_events_selected	(EWeekView	*week_view);
 
diff --git a/calendar/gui/gnome-cal.c b/calendar/gui/gnome-cal.c
index c2a0c2c61e..bcefd8eeee 100644
--- a/calendar/gui/gnome-cal.c
+++ b/calendar/gui/gnome-cal.c
@@ -61,8 +61,6 @@
 #include "misc.h"
 #include "ea-calendar.h"
 
-extern ECompEditorRegistry *comp_editor_registry;
-
 
 
 /* Private part of the GnomeCalendar structure */
@@ -71,6 +69,8 @@ struct _GnomeCalendarPrivate {
 	 * The Calendar Folder.
 	 */
 
+	GHashTable *clients;
+	
 	/* Set of categories from the calendar client */
 	GPtrArray *cal_categories;
 
@@ -119,6 +119,7 @@ struct _GnomeCalendarPrivate {
 	/* This is the view currently shown. We use it to keep track of the
 	   positions of the panes. range_selected is TRUE if a range of dates
 	   was selected in the date navigator to show the view. */
+	ECalView    *views[GNOME_CAL_LAST_VIEW];
 	GnomeCalendarViewType current_view_type;
 	gboolean range_selected;
 
@@ -145,10 +146,6 @@ struct _GnomeCalendarPrivate {
 	   'dates-shown-changed' signal.*/
 	time_t visible_start;
 	time_t visible_end;
-
-	/* Calendar query for purging old events */
-	GList *exp_queries;
-	time_t exp_older_than;
 };
 
 /* Signal IDs */
@@ -361,97 +358,70 @@ gnome_calendar_class_init (GnomeCalendarClass *class)
 
 /* Callback used when the calendar query reports of an updated object */
 static void
-dn_query_obj_updated_cb (CalQuery *query, const char *uid,
-			 gboolean query_in_progress, int n_scanned, int total,
-			 gpointer data)
+dn_query_objects_added_cb (CalQuery *query, GList *objects, gpointer data)
 {
 	GnomeCalendar *gcal;
 	GnomeCalendarPrivate *priv;
-	CalComponent *comp = NULL;
-	icalcomponent *icalcomp;
-	CalClientGetStatus status;
-
+	GList *l;
+	
 	gcal = GNOME_CALENDAR (data);
 	priv = gcal->priv;
 
-	/* If this is an update that is not part of an ongoing query, we have to
-	 * retag the whole thing:  an event may change dates and the
-	 * tag_calendar_by_comp() below would not know how to untag the old
-	 * dates.
-	 */
-	if (!query_in_progress) {
-		update_query (gcal);
-		return;
-	}
+	for (l = objects; l; l = l->next) {
+		CalComponent *comp = NULL;
 
-	status = cal_client_get_object (cal_query_get_client (query), uid, &icalcomp);
-
-	switch (status) {
-	case CAL_CLIENT_GET_SUCCESS:
 		comp = cal_component_new ();
-		if (!cal_component_set_icalcomponent (comp, icalcomp)) {
+		if (!cal_component_set_icalcomponent (comp, icalcomponent_new_clone (l->data))) {
 			g_object_unref (comp);
-			icalcomponent_free (icalcomp);
-			return;
+			
+			continue;
 		}
-		break;
-
-	case CAL_CLIENT_GET_SYNTAX_ERROR:
-		g_message ("dn_query_obj_updated_cb(): Syntax error while getting object `%s'", uid);
-		return;
-
-	case CAL_CLIENT_GET_NOT_FOUND:
-		/* The object is no longer in the server, so do nothing */
-		return;
 
-	default:
-		g_assert_not_reached ();
-		return;
+		tag_calendar_by_comp (priv->date_navigator, comp, cal_query_get_client (query), NULL,
+				      FALSE, TRUE);
+		g_object_unref (comp);
 	}
-
-	tag_calendar_by_comp (priv->date_navigator, comp, cal_query_get_client (query), NULL,
-			      FALSE, TRUE);
-	g_object_unref (comp);
 }
 
-/* Callback used when the calendar query reports of a removed object */
 static void
-dn_query_obj_removed_cb (CalQuery *query, const char *uid, gpointer data)
+dn_query_objects_modified_cb (CalQuery *query, GList *objects, gpointer data)
 {
 	GnomeCalendar *gcal;
+	GnomeCalendarPrivate *priv;
 
 	gcal = GNOME_CALENDAR (data);
+	priv = gcal->priv;
 
-	/* Just retag the whole thing */
+	/* We have to retag the whole thing: an event may change dates
+	 * and the tag_calendar_by_comp() below would not know how to
+	 * untag the old dates.
+	 */
 	update_query (gcal);
 }
 
-/* Callback used when the calendar query is done */
+/* Callback used when the calendar query reports of a removed object */
 static void
-dn_query_query_done_cb (CalQuery *query, CalQueryDoneStatus status, const char *error_str,
-			gpointer data)
+dn_query_objects_removed_cb (CalQuery *query, GList *uids, gpointer data)
 {
 	GnomeCalendar *gcal;
 
 	gcal = GNOME_CALENDAR (data);
 
-	/* FIXME */
-
-	if (status != CAL_QUERY_DONE_SUCCESS)
-		fprintf (stderr, "query done: %s\n", error_str);
+	/* Just retag the whole thing */
+	update_query (gcal);
 }
 
-/* Callback used when the calendar query reports an evaluation error */
+/* Callback used when the calendar query is done */
 static void
-dn_query_eval_error_cb (CalQuery *query, const char *error_str, gpointer data)
+dn_query_done_cb (CalQuery *query, ECalendarStatus status, gpointer data)
 {
 	GnomeCalendar *gcal;
 
 	gcal = GNOME_CALENDAR (data);
 
-	/* FIXME */
-
-	fprintf (stderr, "eval error: %s\n", error_str);
+	/* FIXME Better error reporting */
+	if (status != E_CALENDAR_STATUS_OK)
+		g_warning (G_STRLOC ": Query did not successfully complete");
 }
 
 /* Returns the current view widget, an EDayView, EWeekView or ECalListView. */
@@ -603,6 +573,7 @@ adjust_query_sexp (GnomeCalendar *gcal, const char *sexp)
 				    start, end,
 				    sexp);
 
+
 	g_free (start);
 	g_free (end);
 
@@ -649,22 +620,24 @@ update_query (GnomeCalendar *gcal)
 	/* create queries for each loaded client */
 	client_list = e_cal_model_get_client_list (e_cal_view_get_model (E_CAL_VIEW (priv->day_view)));
 	for (l = client_list; l != NULL; l = l->next) {
-		old_query = cal_client_get_query ((CalClient *) l->data, real_sexp);
-		if (!old_query) {
-			g_message ("update_query(): Could not create the query");
+		if (!cal_client_get_query ((CalClient *) l->data, real_sexp, &old_query, NULL)) {
+			g_warning (G_STRLOC ": Could not create the query");
+
 			continue;
 		}
 
-		g_signal_connect (old_query, "obj_updated",
-				  G_CALLBACK (dn_query_obj_updated_cb), gcal);
-		g_signal_connect (old_query, "obj_removed",
-				  G_CALLBACK (dn_query_obj_removed_cb), gcal);
+		g_signal_connect (old_query, "objects_added",
+				  G_CALLBACK (dn_query_objects_added_cb), gcal);
+		g_signal_connect (old_query, "objects_modified",
+				  G_CALLBACK (dn_query_objects_modified_cb), gcal);
+		g_signal_connect (old_query, "objects_removed",
+				  G_CALLBACK (dn_query_objects_removed_cb), gcal);
 		g_signal_connect (old_query, "query_done",
-				  G_CALLBACK (dn_query_query_done_cb), gcal);
-		g_signal_connect (old_query, "eval_error",
-				  G_CALLBACK (dn_query_eval_error_cb), gcal);
+				  G_CALLBACK (dn_query_done_cb), gcal);
 
 		priv->dn_queries = g_list_append (priv->dn_queries, old_query);
+
+		cal_query_start (old_query);
 	}
 
 	g_list_free (client_list);
@@ -673,6 +646,30 @@ update_query (GnomeCalendar *gcal)
 	e_cal_view_set_status_message (E_CAL_VIEW (priv->week_view), NULL);
 }
 
+static void
+adjust_query_for_view (ECalView *cal_view, const char *sexp)
+{
+	char *real_sexp, *start, *end;
+	time_t ttstart, ttend;
+
+	e_cal_view_get_visible_time_range (cal_view, &ttstart, &ttend);
+
+	start = isodate_from_time_t (ttstart);
+	end = isodate_from_time_t (ttend);
+
+	real_sexp = g_strdup_printf (
+		"(and (occur-in-time-range? (make-time \"%s\")"
+		"                           (make-time \"%s\"))"
+		" %s)",
+		start, end, sexp);
+
+	e_cal_model_set_query (e_cal_view_get_model (cal_view), real_sexp);
+
+	g_free (start);
+	g_free (end);
+	g_free (real_sexp);
+}
+
 /**
  * gnome_calendar_set_query:
  * @gcal: A calendar.
@@ -685,6 +682,7 @@ gnome_calendar_set_query (GnomeCalendar *gcal, const char *sexp)
 {
 	GnomeCalendarPrivate *priv;
 	ECalModel *model;
+	int i;
 
 	g_return_if_fail (gcal != NULL);
 	g_return_if_fail (GNOME_IS_CALENDAR (gcal));
@@ -701,9 +699,9 @@ gnome_calendar_set_query (GnomeCalendar *gcal, const char *sexp)
 
 	update_query (gcal);
 
-	/* Set the query on the main view */
-	model = e_cal_view_get_model (E_CAL_VIEW (gnome_calendar_get_current_view_widget (gcal)));
-	e_cal_model_set_query (model, sexp);
+	/* Set the query on the views */
+	for (i = 0; i < GNOME_CAL_LAST_VIEW; i++)
+		adjust_query_for_view (E_CAL_VIEW (priv->views[i]), sexp);
 
 	/* Set the query on the task pad */
 	model = e_calendar_table_get_model (E_CALENDAR_TABLE (priv->todo));
@@ -747,14 +745,15 @@ search_bar_category_changed_cb (CalSearchBar *cal_search, const char *category,
 	GnomeCalendar *gcal;
 	GnomeCalendarPrivate *priv;
 	ECalModel *model;
+	int i;
 
 	gcal = GNOME_CALENDAR (data);
 	priv = gcal->priv;
 
-	e_day_view_set_default_category (E_DAY_VIEW (priv->day_view), category);
-	e_day_view_set_default_category (E_DAY_VIEW (priv->work_week_view), category);
-	e_week_view_set_default_category (E_WEEK_VIEW (priv->week_view), category);
-	e_week_view_set_default_category (E_WEEK_VIEW (priv->month_view), category);
+	for (i = 0; i < GNOME_CAL_LAST_VIEW; i++) {
+		e_cal_view_set_default_category (E_CAL_VIEW (priv->views[i]),
+						 category);
+	}
 
 	model = e_calendar_table_get_model (E_CALENDAR_TABLE (priv->todo));
 	e_cal_model_set_default_category (model, category);
@@ -853,7 +852,6 @@ setup_widgets (GnomeCalendar *gcal)
 	GtkWidget *w;
 	gchar *filename;
 	ETable *etable;
-	ECalModel *model;
 
 	priv = gcal->priv;
 
@@ -915,7 +913,8 @@ setup_widgets (GnomeCalendar *gcal)
 	gtk_paned_pack2 (GTK_PANED (priv->vpane), priv->todo, TRUE, TRUE);
 	gtk_widget_show (priv->todo);
 
-	filename = g_strdup_printf ("%s/config/TaskPad", evolution_dir);
+	filename = g_build_filename (calendar_component_peek_config_directory (calendar_component_peek ()),
+				     "TaskPad", NULL);
 	e_calendar_table_load_state (E_CALENDAR_TABLE (priv->todo), filename);
 	g_free (filename);
 
@@ -977,7 +976,7 @@ setup_widgets (GnomeCalendar *gcal)
 	connect_week_view_focus (gcal, E_WEEK_VIEW (priv->month_view));
 
 	/* The List View. */
-	filename = g_strdup_printf ("%s/config/CalListView", evolution_dir);
+	filename = g_strdup_printf (".evolution/config/CalListView");
 	priv->list_view = e_cal_list_view_new (filename);
 	g_free (filename);
 
@@ -988,14 +987,12 @@ setup_widgets (GnomeCalendar *gcal)
 
 	connect_list_view_focus (gcal, E_CAL_LIST_VIEW (priv->list_view));
 
-	model = (ECalModel *) e_cal_model_calendar_new ();
-	e_cal_view_set_model (E_CAL_VIEW (priv->day_view), model);
-	e_cal_view_set_model (E_CAL_VIEW (priv->work_week_view), model);
-	e_cal_view_set_model (E_CAL_VIEW (priv->week_view), model);
-	e_cal_view_set_model (E_CAL_VIEW (priv->month_view), model);
-	e_cal_view_set_model (E_CAL_VIEW (priv->list_view), model);
+	priv->views[GNOME_CAL_DAY_VIEW] = E_CAL_VIEW (priv->day_view);
+	priv->views[GNOME_CAL_WORK_WEEK_VIEW] = E_CAL_VIEW (priv->work_week_view);
+	priv->views[GNOME_CAL_WEEK_VIEW] = E_CAL_VIEW (priv->week_view);
+	priv->views[GNOME_CAL_MONTH_VIEW] = E_CAL_VIEW (priv->month_view);
+	priv->views[GNOME_CAL_LIST_VIEW] = E_CAL_VIEW (priv->list_view);
 
-	g_object_unref (model);
 	gnome_calendar_update_config_settings (gcal, TRUE);
 }
 
@@ -1008,6 +1005,8 @@ gnome_calendar_init (GnomeCalendar *gcal)
 	priv = g_new0 (GnomeCalendarPrivate, 1);
 	gcal->priv = priv;
 
+	priv->clients = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
+	
 	priv->cal_categories = NULL;
 	priv->tasks_categories = NULL;
 
@@ -1027,8 +1026,6 @@ gnome_calendar_init (GnomeCalendar *gcal)
 
 	priv->visible_start = -1;
 	priv->visible_end = -1;
-
-	priv->exp_queries = NULL;
 }
 
 /* Frees a set of categories */
@@ -1062,6 +1059,8 @@ gnome_calendar_destroy (GtkObject *object)
 	if (priv) {
 		GList *l, *client_list;
 
+		g_hash_table_destroy (priv->clients);
+
 		free_categories (priv->cal_categories);
 		priv->cal_categories = NULL;
 
@@ -1078,7 +1077,8 @@ gnome_calendar_destroy (GtkObject *object)
 		g_list_free (client_list);
 		
 		/* Save the TaskPad layout. */
-		filename = g_strdup_printf ("%s/config/TaskPad", evolution_dir);
+		filename = g_build_filename (calendar_component_peek_config_directory (calendar_component_peek ()),
+					     "TaskPad", NULL);
 		e_calendar_table_save_state (E_CALENDAR_TABLE (priv->todo), filename);
 		g_free (filename);
 
@@ -1120,19 +1120,6 @@ gnome_calendar_destroy (GtkObject *object)
 			priv->view_menus = NULL;
 		}
 
-		if (priv->exp_queries) {
-			GList *l;
-
-			for (l = priv->exp_queries; l != NULL; l = l->next) {
-				g_signal_handlers_disconnect_matched ((CalQuery *) l->data, G_SIGNAL_MATCH_DATA,
-								      0, 0, NULL, NULL, gcal);
-				g_object_unref (l->data);
-			}
-
-			g_list_free (priv->exp_queries);
-			priv->exp_queries = NULL;
-		}
-
 		g_free (priv);
 		gcal->priv = NULL;
 	}
@@ -1764,7 +1751,8 @@ client_cal_opened_cb (CalClient *client, CalClientOpenStatus status, gpointer da
 	case CAL_CLIENT_OPEN_SUCCESS:
 		/* Set the client's default timezone, if we have one. */
 		if (priv->zone) {
-			cal_client_set_default_timezone (client, priv->zone);
+			/* FIXME Error checking */
+			cal_client_set_default_timezone (client, priv->zone, NULL);
 		}
 
 		/* add the alarms for this client */
@@ -1996,7 +1984,7 @@ gnome_calendar_construct (GnomeCalendar *gcal)
 	/*
 	 * TaskPad Folder Client.
 	 */
-	priv->task_pad_client = cal_client_new ();
+	priv->task_pad_client = cal_client_new ("", CALOBJ_TYPE_TODO); /* FIXME: use default tasks */
 	if (!priv->task_pad_client)
 		return NULL;
 
@@ -2063,7 +2051,8 @@ gnome_calendar_get_calendar_model (GnomeCalendar *gcal)
 
 	priv = gcal->priv;
 
-	return e_cal_view_get_model (E_CAL_VIEW (priv->week_view));
+	return e_cal_view_get_model (
+		gnome_calendar_get_current_view_widget (gcal));
 }
 
 /**
@@ -2078,6 +2067,28 @@ gnome_calendar_get_default_client (GnomeCalendar *gcal)
 }
 
 /**
+ * gnome_calendar_set_default_client
+ * @gcal: A calendar view.
+ * @client: The client to use as default.
+ *
+ * Set the default client on the given calendar view. The default calendar will
+ * be used as the default when creating events in the view.
+ */
+void
+gnome_calendar_set_default_client (GnomeCalendar *gcal, CalClient *client)
+{
+	int i;
+
+	g_return_if_fail (GNOME_IS_CALENDAR (gcal));
+
+	for (i = 0; i < GNOME_CAL_LAST_VIEW; i++) {
+		e_cal_model_set_default_client (
+			e_cal_view_get_model (E_CAL_VIEW (gcal->priv->views[i])),
+			client);
+	}
+}
+
+/**
  * gnome_calendar_get_task_pad_cal_client:
  * @gcal: A calendar view.
  *
@@ -2145,67 +2156,56 @@ add_alarms (const char *uri)
 	CORBA_exception_free (&ev);
 }
 
+/**
+ * gnome_calendar_add_event_uri:
+ * @gcal: A GnomeCalendar.
+ * @str_uri: URI to add to the calendar views.
+ *
+ * Adds the given calendar URI to the calendar views.
+ *
+ * Returns: TRUE if successful, FALSE if error.
+ */
 gboolean
-gnome_calendar_open (GnomeCalendar *gcal, const char *str_uri)
+gnome_calendar_add_event_uri (GnomeCalendar *gcal, const char *str_uri)
 {
 	GnomeCalendarPrivate *priv;
-	gboolean success;
-	EUri *uri;
-	char *message;
-	char *real_uri;
-	char *urinopwd;
 	CalClient *client;
-
+	int i;
+	
 	g_return_val_if_fail (gcal != NULL, FALSE);
 	g_return_val_if_fail (GNOME_IS_CALENDAR (gcal), FALSE);
 	g_return_val_if_fail (str_uri != NULL, FALSE);
 
 	priv = gcal->priv;
 
-	g_return_val_if_fail (
-		cal_client_get_load_state (priv->task_pad_client) == CAL_CLIENT_LOAD_NOT_LOADED,
-		FALSE);
-
-	uri = e_uri_new (str_uri);
-        if (!uri || !g_strncasecmp (uri->protocol, "file", 4))
-                real_uri = g_concat_dir_and_file (str_uri, "calendar.ics");
-        else
-                real_uri = g_strdup (str_uri);
-
-	urinopwd = get_uri_without_password (str_uri);
-	message = g_strdup_printf (_("Opening calendar at %s"), urinopwd);
-	g_free (urinopwd);
-	e_cal_view_set_status_message (E_CAL_VIEW (priv->week_view), message);
-	g_free (message);
-
-	client = cal_client_new ();
-	g_signal_connect (G_OBJECT (client), "cal_opened", G_CALLBACK (client_cal_opened_cb), gcal);
+	client = g_hash_table_lookup (priv->clients, str_uri);
+	if (client)
+		return TRUE;
+	
+	client = cal_client_new (str_uri, CALOBJ_TYPE_EVENT);
+	g_hash_table_insert (priv->clients, g_strdup (str_uri), g_object_ref (client));
+	
 	g_signal_connect (G_OBJECT (client), "backend_error", G_CALLBACK (backend_error_cb), gcal);
 	g_signal_connect (G_OBJECT (client), "categories_changed", G_CALLBACK (client_categories_changed_cb), gcal);
 	g_signal_connect (G_OBJECT (client), "backend_died", G_CALLBACK (backend_died_cb), gcal);
 
-	if (!cal_client_open_calendar (client, real_uri, FALSE)) {
-		g_warning (G_STRLOC ": Could not issue the request to open the calendar folder");
+	if (!cal_client_open (client, FALSE, NULL)) {
+		g_hash_table_remove (priv->clients, str_uri);
 		g_object_unref (client);
-		e_cal_view_set_status_message (E_CAL_VIEW (priv->week_view), NULL);
 
 		return FALSE;
 	}
 
-	/* Open the appropriate Tasks folder to show in the TaskPad */
-	e_calendar_table_set_status_message (E_CALENDAR_TABLE (priv->todo),
-					     _("Opening default tasks folder"));
-	success = cal_client_open_default_tasks (priv->task_pad_client, FALSE);
-
-	g_free (real_uri);
-        e_uri_free (uri);
-
-	if (!success) {
-		g_message ("gnome_calendar_open(): Could not issue the request to open the tasks folder");
-		e_calendar_table_set_status_message (E_CALENDAR_TABLE (priv->todo), NULL);
-		return FALSE;
+	for (i = 0; i < GNOME_CAL_LAST_VIEW; i++) {
+		ECalModel *model;
+		
+		model = e_cal_view_get_model (priv->views[i]);
+		e_cal_model_add_client (model, client);
 	}
 
+	/* update date navigator query */
+	update_query (gcal);
+
 	return TRUE;
 }
 
@@ -2308,7 +2308,8 @@ gnome_calendar_update_config_settings (GnomeCalendar *gcal,
 			CalClient *client = l->data;
 
 			if (cal_client_get_load_state (client) == CAL_CLIENT_LOAD_LOADED)
-				cal_client_set_default_timezone (client, priv->zone);
+				/* FIXME Error checking */
+				cal_client_set_default_timezone (client, priv->zone, NULL);
 		}
 
 		g_list_free (client_list);
@@ -2316,8 +2317,9 @@ gnome_calendar_update_config_settings (GnomeCalendar *gcal,
 
 	if (priv->task_pad_client
 	    && cal_client_get_load_state (priv->task_pad_client) == CAL_CLIENT_LOAD_LOADED) {
+		/* FIXME Error Checking */
 		cal_client_set_default_timezone (priv->task_pad_client,
-						 priv->zone);
+						 priv->zone, NULL);
 	}
 
 	e_cal_view_set_timezone (E_CAL_VIEW (priv->day_view), priv->zone);
@@ -2383,147 +2385,6 @@ gnome_calendar_get_selected_time_range (GnomeCalendar *gcal,
 		*end_time = priv->selection_end_time;
 }
 
-void
-gnome_calendar_edit_object (GnomeCalendar *gcal, CalClient *client, icalcomponent *icalcomp, gboolean meeting)
-{
-	GnomeCalendarPrivate *priv;
-	CompEditor *ce;
-	const char *uid;
-	CalComponent *comp;
-
-	g_return_if_fail (GNOME_IS_CALENDAR (gcal));
-	g_return_if_fail (IS_CAL_CLIENT (client));
-	g_return_if_fail (icalcomp != NULL);
-
-	priv = gcal->priv;
-
-	uid = icalcomponent_get_uid (icalcomp);
-
-	ce = e_comp_editor_registry_find (comp_editor_registry, uid);
-	if (!ce) {
-		EventEditor *ee;
-
-		ee = event_editor_new (client);
-		if (!ee) {
-			g_message ("gnome_calendar_edit_object(): Could not create the event editor");
-			return;
-		}
-		ce = COMP_EDITOR (ee);
-
-		comp = cal_component_new ();
-		cal_component_set_icalcomponent (comp, icalcomponent_new_clone (icalcomp));
-
-		comp_editor_edit_comp (ce, comp);
-		if (meeting)
-			event_editor_show_meeting (ee);
-
-		e_comp_editor_registry_add (comp_editor_registry, ce, FALSE);
-
-		g_object_unref (comp);
-	}
-
-	comp_editor_focus (ce);
-}
-
-/**
- * gnome_calendar_new_appointment_for:
- * @gcal: An Evolution calendar.
- * @dtstart: a Unix time_t that marks the beginning of the appointment.
- * @dtend: a Unix time_t that marks the end of the appointment.
- * @all_day: if true, the dtstart and dtend are expanded to cover the entire
- * day, and the event is set to TRANSPARENT.
- *
- * Opens an event editor dialog for a new appointment.
- *
- **/
-void
-gnome_calendar_new_appointment_for (GnomeCalendar *cal,
-				    time_t dtstart, time_t dtend,
-				    gboolean all_day,
-				    gboolean meeting)
-{
-	GnomeCalendarPrivate *priv;
-	struct icaltimetype itt;
-	CalComponentDateTime dt;
-	CalComponent *comp;
-	icalcomponent *icalcomp;
-	CalComponentTransparency transparency;
-	const char *category;
-
-	g_return_if_fail (cal != NULL);
-	g_return_if_fail (GNOME_IS_CALENDAR (cal));
-
-	priv = cal->priv;
-
-	dt.value = &itt;
-	if (all_day)
-		dt.tzid = NULL;
-	else
-		dt.tzid = icaltimezone_get_tzid (priv->zone);
-
-	icalcomp = e_cal_model_create_component_with_defaults (e_cal_view_get_model (E_CAL_VIEW (priv->week_view)));
-	comp = cal_component_new ();
-	cal_component_set_icalcomponent (comp, icalcomp);
-
-	/* DTSTART, DTEND */
-
-	itt = icaltime_from_timet_with_zone (dtstart, FALSE, priv->zone);
-	if (all_day) {
-		itt.hour = itt.minute = itt.second = 0;
-		itt.is_date = TRUE;
-	}
-	cal_component_set_dtstart (comp, &dt);
-
-	itt = icaltime_from_timet_with_zone (dtend, FALSE, priv->zone);
-	if (all_day) {
-		/* We round it up to the end of the day, unless it is already
-		   set to midnight. */
-		if (itt.hour != 0 || itt.minute != 0 || itt.second != 0) {
-			icaltime_adjust (&itt, 1, 0, 0, 0);
-		}
-		itt.hour = itt.minute = itt.second = 0;
-		itt.is_date = TRUE;
-	}
-	cal_component_set_dtend (comp, &dt);
-
-	transparency = all_day ? CAL_COMPONENT_TRANSP_TRANSPARENT
-		: CAL_COMPONENT_TRANSP_OPAQUE;
-	cal_component_set_transparency (comp, transparency);
-
-
-	/* Category */
-
-	category = cal_search_bar_get_category (CAL_SEARCH_BAR (priv->search_bar));
-	cal_component_set_categories (comp, category);
-
-	/* Edit! */
-
-	cal_component_commit_sequence (comp);
-
-	gnome_calendar_edit_object (cal, gnome_calendar_get_default_client (cal), icalcomp, meeting);
-	g_object_unref (comp);
-}
-
-/**
- * gnome_calendar_new_appointment:
- * @gcal: An Evolution calendar.
- *
- * Opens an event editor dialog for a new appointment.  The appointment's start
- * and end times are set to the currently selected time range in the calendar
- * views.
- **/
-void
-gnome_calendar_new_appointment (GnomeCalendar *gcal)
-{
-	time_t dtstart, dtend;
-
-	g_return_if_fail (gcal != NULL);
-	g_return_if_fail (GNOME_IS_CALENDAR (gcal));
-
-	gnome_calendar_get_current_time_range (gcal, &dtstart, &dtend);
-	gnome_calendar_new_appointment_for (gcal, dtstart, dtend, FALSE, FALSE);
-}
-
 /**
  * gnome_calendar_new_task:
  * @gcal: An Evolution calendar.
@@ -3020,136 +2881,17 @@ gnome_calendar_delete_selected_occurrence (GnomeCalendar *gcal)
 	}
 }
 
-void
-gnome_calendar_unrecur_selection (GnomeCalendar *gcal)
-{
-	GnomeCalendarPrivate *priv;
-	FocusLocation location;
-	GtkWidget *view;
-
-	g_return_if_fail (GNOME_IS_CALENDAR (gcal));
-
-	priv = gcal->priv;
-
-	location = get_focus_location (gcal);
-
-	if (location == FOCUS_CALENDAR) {
-
-		view = gnome_calendar_get_current_view_widget (gcal);
-
-		if (E_IS_DAY_VIEW (view))
-			e_day_view_unrecur_appointment (E_DAY_VIEW (view));
-		else
-			e_week_view_unrecur_appointment (E_WEEK_VIEW (view));
-	}
-}
-
-typedef struct {
-	gboolean remove;
-	GnomeCalendar *gcal;
-} obj_updated_closure;
-
 static gboolean
 check_instance_cb (CalComponent *comp,
 		   time_t instance_start,
 		   time_t instance_end,
 		   gpointer data)
 {
-	obj_updated_closure *closure = data;
-
-	if (instance_start >= closure->gcal->priv->exp_older_than ||
-	    instance_end >= closure->gcal->priv->exp_older_than) {
-		closure->remove = FALSE;
-		return FALSE;
-	}
-
-	closure->remove = TRUE;
-	return TRUE;
-}
-
-static void
-purging_obj_updated_cb (CalQuery *query, const char *uid,
-			gboolean query_in_progress, int n_scanned, int total,
-			gpointer data)
-{
-	GnomeCalendarPrivate *priv;
-	GnomeCalendar *gcal = data;
-	CalComponent *comp;
-	icalcomponent *icalcomp;
-	obj_updated_closure closure;
-	gchar *msg;
-
-	priv = gcal->priv;
-
-	if (cal_client_get_object (cal_query_get_client (query), uid, &icalcomp) != CAL_CLIENT_GET_SUCCESS)
-		return;
-
-	comp = cal_component_new ();
-	if (!cal_component_set_icalcomponent (comp, icalcomp)) {
-		g_object_unref (comp);
-		icalcomponent_free (icalcomp);
-		return;
-	}
-
-	msg = g_strdup_printf (_("Purging event %s"), uid);
-
-	/* further filter the event, to check the last recurrence end date */
-	if (cal_component_has_recurrences (comp)) {
-		closure.remove = TRUE;
-		closure.gcal = gcal;
-
-		cal_recur_generate_instances (comp, priv->exp_older_than, -1,
-					      (CalRecurInstanceFn) check_instance_cb,
-					      &closure,
-					      (CalRecurResolveTimezoneFn) cal_client_resolve_tzid_cb,
-					      cal_query_get_client (query), priv->zone);
-
-		if (closure.remove) {
-			e_cal_view_set_status_message (E_CAL_VIEW (priv->week_view), msg);
-			delete_error_dialog (cal_client_remove_object (cal_query_get_client (query), uid),
-					     CAL_COMPONENT_EVENT);
-		}
-	} else {
-		e_cal_view_set_status_message (E_CAL_VIEW (priv->week_view), msg);
-		delete_error_dialog (cal_client_remove_object (cal_query_get_client (query), uid), CAL_COMPONENT_EVENT);
-	}
-
-	g_object_unref (comp);
-	g_free (msg);
-}
-
-static void
-purging_eval_error_cb (CalQuery *query, const char *error_str, gpointer data)
-{
-	GnomeCalendarPrivate *priv;
-	GnomeCalendar *gcal = data;
-
-	priv = gcal->priv;
-
-	e_cal_view_set_status_message (E_CAL_VIEW (priv->week_view), NULL);
-
-	g_signal_handlers_disconnect_matched (query, G_SIGNAL_MATCH_DATA,
-					      0, 0, NULL, NULL, gcal);
-
-	priv->exp_queries = g_list_remove (priv->exp_queries, query);
-	g_object_unref (query);
-}
+	gboolean *remove = data;
 
-static void
-purging_query_done_cb (CalQuery *query, CalQueryDoneStatus status, const char *error_str, gpointer data)
-{
-	GnomeCalendarPrivate *priv;
-	GnomeCalendar *gcal = data;
-
-	priv = gcal->priv;
-
-	e_cal_view_set_status_message (E_CAL_VIEW (priv->week_view), NULL);
+	*remove = FALSE;
 
-	g_signal_handlers_disconnect_matched (query, G_SIGNAL_MATCH_DATA,
-					      0, 0, NULL, NULL, gcal);
-
-	priv->exp_queries = g_list_remove (priv->exp_queries, query);
-	g_object_unref (query);
+	return FALSE;
 }
 
 void
@@ -3163,11 +2905,6 @@ gnome_calendar_purge (GnomeCalendar *gcal, time_t older_than)
 
 	priv = gcal->priv;
 
-	/* if we have a query, we are already purging */
-	if (priv->exp_queries)
-		return;
-
-	priv->exp_older_than = older_than;
 	start = isodate_from_time_t (0);
 	end = isodate_from_time_t (older_than);
 	sexp = g_strdup_printf ("(and (= (get-vtype) \"VEVENT\")"
@@ -3177,27 +2914,47 @@ gnome_calendar_purge (GnomeCalendar *gcal, time_t older_than)
 
 	e_cal_view_set_status_message (E_CAL_VIEW (priv->week_view), _("Purging"));
 
+	/* FIXME Confirm expunge */
+
 	client_list = e_cal_model_get_client_list (e_cal_view_get_model (E_CAL_VIEW (priv->week_view)));
 	for (l = client_list; l != NULL; l = l->next) {
-		CalQuery *exp_query;
-
-		if (cal_client_is_read_only ((CalClient *) l->data))
+		CalClient *client = l->data;
+		GList *objects, *l;
+		gboolean read_only = TRUE;
+		
+		cal_client_is_read_only (client, &read_only, NULL);
+		if (!read_only)
 			continue;
-
-		exp_query = cal_client_get_query ((CalClient *) l->data, sexp);
-		if (!exp_query) {
-			e_cal_view_set_status_message (E_CAL_VIEW (priv->week_view), NULL);
-			g_message ("gnome_calendar_purge(): Could not create the query");
+		
+		if (!cal_client_get_object_list (client, sexp, &objects, NULL)) {
+			g_warning (G_STRLOC ": Could not get the objects");
+			
 			continue;
 		}
-	
-		g_signal_connect (exp_query, "obj_updated", G_CALLBACK (purging_obj_updated_cb), gcal);
-		g_signal_connect (exp_query, "query_done", G_CALLBACK (purging_query_done_cb), gcal);
-		g_signal_connect (exp_query, "eval_error", G_CALLBACK (purging_eval_error_cb), gcal);
-
-		priv->exp_queries = g_list_append (priv->exp_queries, exp_query);
+		
+		for (l = objects; l; l = l->next) {
+			CalComponent *comp;
+			gboolean remove = TRUE;
+
+			comp = cal_component_new ();
+			cal_component_set_icalcomponent (comp, icalcomponent_new_clone (l->data));
+			
+			cal_recur_generate_instances (comp, older_than, -1,
+						      (CalRecurInstanceFn) check_instance_cb,
+						      &remove,
+						      (CalRecurResolveTimezoneFn) cal_client_resolve_tzid_cb,
+						      client, priv->zone);
+
+			/* FIXME Better error handling */
+			if (remove)
+				cal_client_remove_object (client, icalcomponent_get_uid (l->data), NULL);
+			
+			g_object_unref (comp);
+		}
 	}
 
+	e_cal_view_set_status_message (E_CAL_VIEW (priv->week_view), NULL);
+
 	g_list_free (client_list);
 	g_free (sexp);
 	g_free (start);
diff --git a/calendar/gui/gnome-cal.h b/calendar/gui/gnome-cal.h
index c9bbcbaff4..f56ec69211 100644
--- a/calendar/gui/gnome-cal.h
+++ b/calendar/gui/gnome-cal.h
@@ -55,7 +55,8 @@ typedef enum {
 	GNOME_CAL_WORK_WEEK_VIEW,
 	GNOME_CAL_WEEK_VIEW,
 	GNOME_CAL_MONTH_VIEW,
-	GNOME_CAL_LIST_VIEW
+	GNOME_CAL_LIST_VIEW,
+	GNOME_CAL_LAST_VIEW
 } GnomeCalendarViewType;
 
 typedef enum
@@ -106,9 +107,10 @@ ECalendarTable *gnome_calendar_get_task_pad	(GnomeCalendar *gcal);
 
 ECalModel *gnome_calendar_get_calendar_model    (GnomeCalendar *gcal);
 CalClient *gnome_calendar_get_default_client    (GnomeCalendar *gcal);
+void       gnome_calendar_set_default_client    (GnomeCalendar *gcal, CalClient *client);
 CalClient *gnome_calendar_get_task_pad_cal_client(GnomeCalendar *gcal);
 
-gboolean   gnome_calendar_open                  (GnomeCalendar *gcal, const char *str_uri);
+gboolean   gnome_calendar_add_event_uri         (GnomeCalendar *gcal, const char *str_uri);
 
 void gnome_calendar_set_query (GnomeCalendar *gcal, const char *sexp);
 
@@ -145,17 +147,6 @@ void	   gnome_calendar_get_selected_time_range (GnomeCalendar *gcal,
 						   time_t	 *start_time,
 						   time_t	 *end_time);
 
-void       gnome_calendar_edit_object           (GnomeCalendar *gcal,
-						 CalClient     *client,
-						 icalcomponent *icalcomp,
-						 gboolean       meeting);
-
-void       gnome_calendar_new_appointment       (GnomeCalendar *gcal);
-void       gnome_calendar_new_appointment_for   (GnomeCalendar *cal,
-						 time_t dtstart, time_t dtend,
-						 gboolean all_day,
-						 gboolean meeting);
-
 void       gnome_calendar_new_task		(GnomeCalendar *gcal);
 
 /* Returns the selected time range for the current view. Note that this may be
@@ -193,7 +184,6 @@ void       gnome_calendar_paste_clipboard       (GnomeCalendar  *gcal);
 
 void       gnome_calendar_delete_selection	(GnomeCalendar  *gcal);
 void       gnome_calendar_delete_selected_occurrence (GnomeCalendar *gcal);
-void       gnome_calendar_unrecur_selection     (GnomeCalendar *gcal);
 void       gnome_calendar_purge                 (GnomeCalendar  *gcal,
 						 time_t older_than);
 
diff --git a/calendar/gui/itip-utils.c b/calendar/gui/itip-utils.c
index f5baa8bb05..e2640f01f4 100644
--- a/calendar/gui/itip-utils.c
+++ b/calendar/gui/itip-utils.c
@@ -70,8 +70,11 @@ static EAccountList *accounts = NULL;
 EAccountList *
 itip_addresses_get (void)
 {
-	if (accounts == NULL)
-		accounts = e_account_list_new(gconf_client_get_default());
+	if (accounts == NULL) {
+		GConfClient *gconf_client = gconf_client_get_default ();
+		accounts = e_account_list_new (gconf_client);
+		g_object_unref (gconf_client);
+	}
 
 	return accounts;
 }
@@ -98,12 +101,14 @@ itip_organizer_is_user (CalComponent *comp, CalClient *client)
   		strip = itip_strip_mailto (organizer.value);
   
  		if (cal_client_get_static_capability (client, CAL_STATIC_CAPABILITY_ORGANIZER_NOT_EMAIL_ADDRESS)) { 
- 			const char *email;
+ 			char *email;
  			
- 			email = cal_client_get_cal_address (client);
- 			if (email && !g_strcasecmp (email, strip))
+  			if (cal_client_get_cal_address (client, &email, NULL) && !g_strcasecmp (email, strip)) {
+				g_free (email);
+				
  				return TRUE;
- 
+			}
+			
  			return FALSE;
  		}
  	
@@ -185,8 +190,8 @@ foreach_tzid_callback (icalparameter *param, gpointer data)
 		zone = icalcomponent_get_timezone (tz_data->zones, tzid);
 	if (zone == NULL)
 		zone = icaltimezone_get_builtin_timezone_from_tzid (tzid);
-	if (zone == NULL && tz_data->client != NULL)
-		cal_client_get_timezone (tz_data->client, tzid, &zone);
+	if (zone == NULL && tz_data->client != NULL)		
+		cal_client_get_timezone (tz_data->client, tzid, &zone, NULL);
 	if (zone == NULL)
 		return;
 
@@ -528,28 +533,23 @@ static gboolean
 comp_server_send (CalComponentItipMethod method, CalComponent *comp, CalClient *client, 
 		  icalcomponent *zones, GList **users)
 {
-	CalClientSendResult result;
-	icalcomponent *top_level, *new_top_level = NULL;
-	char *error_msg;
+	icalcomponent *top_level;
 	gboolean retval = TRUE;
+	GError *error = NULL;
 	
 	top_level = comp_toplevel_with_zones (method, comp, client, zones);
-	result = cal_client_send_object (client, top_level, &new_top_level, users, &error_msg);
-
-	if (result == CAL_CLIENT_SEND_SUCCESS) {
-		icalcomponent *ical_comp;
-		
-		ical_comp = icalcomponent_get_inner (new_top_level);
-		icalcomponent_remove_component (new_top_level, ical_comp);
-		cal_component_set_icalcomponent (comp, ical_comp);
-		icalcomponent_free (new_top_level);
-	} else if (result == CAL_CLIENT_SEND_BUSY) {
-		e_notice (NULL, GTK_MESSAGE_ERROR, error_msg);
-
-		g_free (error_msg);
-		retval = FALSE;
+	if (!cal_client_send_objects (client, top_level, &error)) {
+		/* FIXME Really need a book problem status code */
+		if (error->code != E_CALENDAR_STATUS_OK) {
+			/* FIXME Better error message */
+			e_notice (NULL, GTK_MESSAGE_ERROR, "Unable to book");
+			
+			retval = FALSE;
+		}
 	}
 
+	g_clear_error (&error);
+	
 	icalcomponent_free (top_level);
 
 	return retval;
@@ -755,7 +755,8 @@ comp_compliant (CalComponentItipMethod method, CalComponent *comp, CalClient *cl
 				if (from_zone == NULL)
 					from_zone = icaltimezone_get_builtin_timezone_from_tzid (dt.tzid);
 				if (from_zone == NULL && client != NULL)
-					cal_client_get_timezone (client, dt.tzid, &from_zone);
+					/* FIXME Error checking */
+					cal_client_get_timezone (client, dt.tzid, &from_zone, NULL);
 			}
 			
 			to_zone = icaltimezone_get_utc_timezone ();
diff --git a/calendar/gui/main.c b/calendar/gui/main.c
index a15c0ef846..681417f1df 100644
--- a/calendar/gui/main.c
+++ b/calendar/gui/main.c
@@ -49,9 +49,9 @@
 #include "tasks-control.h"
 
 
-#define FACTORY_ID "OAFIID:GNOME_Evolution_Calendar_Factory"
+#define FACTORY_ID "OAFIID:GNOME_Evolution_Calendar_Factory_2"
 
-#define CALENDAR_COMPONENT_ID  "OAFIID:GNOME_Evolution_Calendar_ShellComponent"
+#define CALENDAR_COMPONENT_ID  "OAFIID:GNOME_Evolution_Calendar_Component"
 #define CALENDAR_CONTROL_ID    "OAFIID:GNOME_Evolution_Calendar_Control"
 #define TASKS_CONTROL_ID       "OAFIID:GNOME_Evolution_Tasks_Control"
 #define ITIP_CONTROL_ID        "OAFIID:GNOME_Evolution_Calendar_iTip_Control"
@@ -155,23 +155,19 @@ factory (BonoboGenericFactory *factory,
 		initialized = TRUE;
 	}
 
-	if (strcmp (component_id, CALENDAR_COMPONENT_ID) == 0)
-		return calendar_component_get_object ();
-	if (strcmp (component_id, CALENDAR_CONTROL_ID) == 0)
+	if (strcmp (component_id, CALENDAR_COMPONENT_ID) == 0) {
+		BonoboObject *object = BONOBO_OBJECT (calendar_component_peek ());
+		bonobo_object_ref (object);
+		return object;
+	} else if (strcmp (component_id, CALENDAR_CONTROL_ID) == 0)
 		return BONOBO_OBJECT (control_factory_new_control ());
-	if (strcmp (component_id, TASKS_CONTROL_ID) == 0)
+	else if (strcmp (component_id, TASKS_CONTROL_ID) == 0)
 		return BONOBO_OBJECT (tasks_control_new ());
-	if (strcmp (component_id, ITIP_CONTROL_ID) == 0)
+	else if (strcmp (component_id, ITIP_CONTROL_ID) == 0)
 		return BONOBO_OBJECT (itip_bonobo_control_new ());
-	if (strcmp (component_id, CONFIG_CONTROL_ID) == 0) {
-		extern EvolutionShellClient *global_shell_client; /* FIXME ugly */
-
-		if (global_shell_client == NULL)
-			return NULL;
-		else
-			return BONOBO_OBJECT (cal_prefs_dialog_new ());
-	}
-	if (strcmp (component_id, COMP_EDITOR_FACTORY_ID) == 0)
+	else if (strcmp (component_id, CONFIG_CONTROL_ID) == 0)
+		return BONOBO_OBJECT (cal_prefs_dialog_new ());
+	else if (strcmp (component_id, COMP_EDITOR_FACTORY_ID) == 0)
 		return BONOBO_OBJECT (comp_editor_factory_fn ());
 
 	g_warning (FACTORY_ID ": Don't know what to do with %s", component_id);
diff --git a/calendar/gui/migration.c b/calendar/gui/migration.c
new file mode 100644
index 0000000000..be93309f1f
--- /dev/null
+++ b/calendar/gui/migration.c
@@ -0,0 +1,126 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* calendar-component.c
+ *
+ * Copyright (C) 2003  Ximian, Inc
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * Author: Rodrigo Moya <rodrigo@ximian.com>
+ */
+
+#include <bonobo/bonobo-i18n.h>
+#include <libgnomevfs/gnome-vfs-uri.h>
+#include <libgnomevfs/gnome-vfs-xfer.h>
+#include <gal/util/e-util.h>
+#include "migration.h"
+
+static gboolean
+process_calendar_dir (ESourceGroup *source_group, const char *path,
+		      const char *name, const char *base_uri)
+{
+	char *s;
+	GnomeVFSURI *from, *to;
+	GnomeVFSResult vres;
+	ESource *source;
+	GDir *dir;
+	gboolean retval = TRUE;
+
+	s = g_build_filename (path, "calendar.ics", NULL);
+	if (!g_file_test (s, G_FILE_TEST_EXISTS)) {
+		g_free (s);
+		return FALSE;
+	}
+
+	/* transfer the old file to its new location */
+	from = gnome_vfs_uri_new (s);
+	g_free (s);
+	if (!from)
+		return FALSE;
+
+	s = g_build_filename (e_source_group_peek_base_uri (source_group), base_uri,
+			      "calendar.ics", NULL);
+	if (e_mkdir_hier (s, 0700) != 0) {
+		gnome_vfs_uri_unref (from);
+		g_free (s);
+		return FALSE;
+	}
+	to = gnome_vfs_uri_new (s);
+	g_free (s);
+	if (!to) {
+		gnome_vfs_uri_unref (from);
+		return FALSE;
+	}
+
+	vres = gnome_vfs_xfer_uri ((const GnomeVFSURI *) from,
+				   (const GnomeVFSURI *) to,
+				   GNOME_VFS_XFER_DEFAULT,
+				   GNOME_VFS_XFER_ERROR_MODE_ABORT,
+				   GNOME_VFS_XFER_OVERWRITE_MODE_REPLACE,
+				   NULL, NULL);
+	gnome_vfs_uri_unref (from);
+	gnome_vfs_uri_unref (to);
+
+	if (vres != GNOME_VFS_OK)
+		return FALSE;
+
+	/* create the new source */
+	source = e_source_new (name, base_uri);
+	e_source_group_add_source (source_group, source, -1);
+
+	/* process subfolders */
+	s = g_build_filename (path, "subfolders", NULL);
+	dir = g_dir_open (s, 0, NULL);
+	if (dir) {
+		const char *name, *tmp_s;
+
+		while ((name = g_dir_read_name (dir))) {
+			tmp_s = g_build_filename (s, name, NULL);
+			if (g_file_test (tmp_s, G_FILE_TEST_IS_DIR)) {
+				retval = process_calendar_dir (source_group, tmp_s, name, name);
+			}
+
+			g_free (tmp_s);
+		}
+
+		g_dir_close (dir);
+	}
+
+	g_free (s);
+
+	return retval;
+}
+
+gboolean
+migrate_old_calendars (ESourceGroup *source_group)
+{
+	char *path;
+	gboolean retval;
+
+	g_return_val_if_fail (E_IS_SOURCE_GROUP (source_group), FALSE);
+
+	path = g_build_filename (g_get_home_dir (), "evolution", NULL);
+        if (!g_file_test (path, G_FILE_TEST_IS_DIR)) {
+		g_free (path);
+                return FALSE;
+	}
+	g_free (path);
+
+	/* look for the top-level calendar */
+	path = g_build_filename (g_get_home_dir (), "evolution/local/Calendar", NULL);
+	retval = process_calendar_dir (source_group, path, _("Personal"), "Personal");
+	g_free (path);
+	
+        return retval;
+}
diff --git a/calendar/gui/migration.h b/calendar/gui/migration.h
new file mode 100644
index 0000000000..2453d47abd
--- /dev/null
+++ b/calendar/gui/migration.h
@@ -0,0 +1,30 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* calendar-component.c
+ *
+ * Copyright (C) 2003  Ximian, Inc
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * Author: Rodrigo Moya <rodrigo@ximian.com>
+ */
+
+#ifndef MIGRATION_H
+#define MIGRATION_H
+
+#include <e-util/e-source-group.h>
+
+gboolean migrate_old_calendars (ESourceGroup *source_group);
+
+#endif
diff --git a/calendar/gui/print.c b/calendar/gui/print.c
index 6aeb9f6566..0c0fa44886 100644
--- a/calendar/gui/print.c
+++ b/calendar/gui/print.c
@@ -522,6 +522,16 @@ format_date(time_t time, int flags, char *buffer, int bufflen)
 	return buffer;
 }
 
+static gboolean 
+instance_cb (CalComponent *comp, time_t instance_start, time_t instance_end, gpointer data)
+{
+	gboolean *found = data;
+	
+	*found = TRUE;
+	
+	return FALSE;
+}
+
 
 /*
   print out the month small, embolden any days with events.
@@ -625,16 +635,16 @@ print_month_small (GnomePrintContext *pc, GnomeCalendar *gcal, time_t month,
 
 			day = days[y * 7 + x];
 			if (day != 0) {
-				GList *uids;
+				gboolean found = FALSE;
 
 				sprintf (buf, "%d", day);
 
 				/* this is a slow messy way to do this ... but easy ... */
-				uids = cal_client_get_objects_in_range (client,
-									CALOBJ_TYPE_EVENT,
-									now, time_day_end_with_zone (now, zone));
-				font = uids ? font_bold : font_normal;
-				cal_obj_uid_list_free (uids);
+				cal_client_generate_instances (client, now, CALOBJ_TYPE_EVENT, 
+							       time_day_end_with_zone (now, zone),
+							       instance_cb, &found);
+				
+				font = found ? font_bold : font_normal;
 
 				next = time_add_day_with_zone (now, 1, zone);
 				if ((now >= greystart && now < greyend)
@@ -1805,7 +1815,7 @@ print_todo_details (GnomePrintContext *pc, GnomeCalendar *gcal,
 		comp = cal_component_new ();
 		cal_component_set_icalcomponent (comp, icalcomponent_new_clone (comp_data->icalcomp));
 
-		cal_component_get_summary (comp_data->icalcomp, &summary);
+		cal_component_get_summary (comp, &summary);
 		if (!summary.value) {
 			g_object_unref (comp);
 			continue;
@@ -2161,11 +2171,8 @@ get_zone_from_tzid (CalClient *client, const char *tzid)
 	   the builtin timezone with the TZID first. */
 	zone = icaltimezone_get_builtin_timezone_from_tzid (tzid);
 	if (!zone) {
-		CalClientGetStatus status;
-
-		status = cal_client_get_timezone (client, tzid, &zone);
-		/* FIXME: Handle error better. */
-		if (status != CAL_CLIENT_GET_SUCCESS)
+		if (!cal_client_get_timezone (client, tzid, &zone, NULL)) 
+			/* FIXME: Handle error better. */
 			g_warning ("Couldn't get timezone from server: %s",
 				   tzid ? tzid : "");
 	}
diff --git a/calendar/gui/tag-calendar.c b/calendar/gui/tag-calendar.c
index 03e0b3dee4..147a69f246 100644
--- a/calendar/gui/tag-calendar.c
+++ b/calendar/gui/tag-calendar.c
@@ -162,7 +162,6 @@ resolve_tzid_cb (const char *tzid, gpointer data)
 {
 	CalClient *client;
 	icaltimezone *zone = NULL;
-	CalClientGetStatus status;
 
 	g_return_val_if_fail (data != NULL, NULL);
 	g_return_val_if_fail (IS_CAL_CLIENT (data), NULL);
@@ -174,7 +173,7 @@ resolve_tzid_cb (const char *tzid, gpointer data)
 
 	if (!zone) {
 		/* FIXME: Handle errors. */
-		status = cal_client_get_timezone (client, tzid, &zone);
+		cal_client_get_timezone (client, tzid, &zone, NULL);
 	}
 
 	return zone;
diff --git a/calendar/gui/tasks-control.c b/calendar/gui/tasks-control.c
index 5ed9faa0d6..d97ed2d585 100644
--- a/calendar/gui/tasks-control.c
+++ b/calendar/gui/tasks-control.c
@@ -235,12 +235,12 @@ static void
 sensitize_commands (ETasks *tasks, BonoboControl *control, int n_selected)
 {
 	BonoboUIComponent *uic;
-	gboolean read_only;
+	gboolean read_only = TRUE;
 
 	uic = bonobo_control_get_ui_component (control);
 	g_assert (uic != NULL);
 
-	read_only = cal_client_is_read_only (e_tasks_get_cal_client (tasks));
+	cal_client_is_read_only (e_tasks_get_cal_client (tasks), &read_only, NULL);
 
 	bonobo_ui_component_set_prop (uic, "/commands/TasksCut", "sensitive",
 				      n_selected == 0 || read_only ? "0" : "1",