diff options
Diffstat (limited to 'addressbook')
| -rw-r--r-- | addressbook/conduit/Makefile.am | 81 | ||||
| -rw-r--r-- | addressbook/conduit/address-conduit-control-applet.c | 387 | ||||
| -rw-r--r-- | addressbook/conduit/address-conduit-control-applet.desktop | 10 | ||||
| -rw-r--r-- | addressbook/conduit/address-conduit.c | 1069 | ||||
| -rw-r--r-- | addressbook/conduit/address-conduit.h | 87 | ||||
| -rw-r--r-- | addressbook/conduit/address.conduit.in | 8 |
6 files changed, 1642 insertions, 0 deletions
diff --git a/addressbook/conduit/Makefile.am b/addressbook/conduit/Makefile.am new file mode 100644 index 0000000000..64a1103bce --- /dev/null +++ b/addressbook/conduit/Makefile.am @@ -0,0 +1,81 @@ +# +# +# + +INCLUDES = \ + -I$(top_srcdir)/calendar \ + $(GNOME_PILOT_CFLAGS) + +file_conduitsdir=$(libdir)/gnome-pilot/conduits + +bin_PROGRAMS = address-conduit-control-applet + +address_conduit_control_applet_SOURCES = address-conduit-control-applet.c + +address_conduit_control_applet_LDADD = \ + $(CAPPLET_LIBS) \ + $(GNOME_LIBDIR) \ + -lgpilotdcm \ + -lgpilotd \ + -lgpilotdconduit \ + $(GNOME_CAPPLET_LIBS) \ + $(BONOBO_VFS_GNOME_LIBS) \ + $(GNOME_XML_LIB) \ + $(GNOMEUI_LIBS) \ + $(PISOCK_LIBDIR) $(PISOCK_LIBS) \ + $(INTLLIBS) + + +# $(top_builddir)/libgpilotdCM/libgpilotdcm.la \ +# $(top_builddir)/gpilotd/libgpilotd.la \ +# $(top_builddir)/gpilotd/libgpilotdconduit.la \ + + +# address_conduit +address_conduitsdir=$(libdir)/gnome-pilot/conduits +address_conduits_LTLIBRARIES = libaddress_conduit.la + +libaddress_conduit_la_SOURCES = \ + address-conduit.c + +# address-conduit.c: my_gnomecal_idl + +address.conduit: address.conduit.in Makefile + sed -e 's^\@prefix\@^$(prefix)^g' < $(srcdir)/address.conduit.in > address.conduit.tmp \ + && mv address.conduit.tmp address.conduit + +# +# conduit +# + +libaddress_conduit_la_LDFLAGS = \ + -rpath $(libdir) + +libaddress_conduit_la_LIBADD = \ + $(top_builddir)/calendar/cal-client/libcal-client-static.la \ + $(top_builddir)/calendar/cal-util/libcal-util-static.la \ + $(top_builddir)/libversit/libversit.la \ + $(top_builddir)/libical/src/libical/libical-static.la \ + $(BONOBO_VFS_GNOME_LIBS) \ + $(PISOCK_LIBDIR) $(PISOCK_LIBS) \ + $(GNOME_LIBDIR) \ + $(GNOME_LIBS) + +ccenterdir = $(datadir)/control-center +ccenterPalmPilotdir = $(ccenterdir)/Peripherals +ccenterConduitsdir = $(ccenterPalmPilotdir)/Conduits +ccenterConduits_DATA = address-conduit-control-applet.desktop + +panelConduitsdir = $(datadir)/gnome/apps/Settings/Peripherals/Conduits +panelConduits_DATA = $(ccenterConduits_DATA) + +Conduitdir = $(datadir)/gnome-pilot/conduits/ +Conduit_DATA = address.conduit + +EXTRA_DIST = \ + address.conduit.in \ + $(ccenterConduits_DATA) + +install-data-local: + $(mkinstalldirs) $(ccenterConduitsdir) + $(mkinstalldirs) $(Conduitdir) diff --git a/addressbook/conduit/address-conduit-control-applet.c b/addressbook/conduit/address-conduit-control-applet.c new file mode 100644 index 0000000000..79a43fe5c6 --- /dev/null +++ b/addressbook/conduit/address-conduit-control-applet.c @@ -0,0 +1,387 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* Control applet ("capplet") for the gnome-pilot address conduit, */ +/* based on */ +/* gpilotd control applet ('capplet') for use with the GNOME control center */ + +#include <pwd.h> +#include <sys/types.h> +#include <signal.h> +#include <gnome.h> + +#include <config.h> +#include <capplet-widget.h> + +#include <libgpilotdCM/gnome-pilot-conduit-management.h> +#include <libgpilotdCM/gnome-pilot-conduit-config.h> +#include <gpilotd/gnome-pilot-client.h> + +#include "address-conduit.h" + + +/* tell changes callbacks to ignore changes or not */ +static gboolean ignore_changes=FALSE; + +/* capplet widget */ +static GtkWidget *capplet=NULL; + +/* host/device/pilot configuration windows */ +GtkWidget *cfgOptionsWindow=NULL; +GtkWidget *cfgStateWindow=NULL; +GtkWidget *dialogWindow=NULL; + +gboolean activated,org_activation_state; +GnomePilotConduitManagement *conduit; +GnomePilotConduitConfig *conduit_config; +GCalConduitCfg *origState = NULL; +GCalConduitCfg *curState = NULL; + +static void doTrySettings(GtkWidget *widget, GCalConduitCfg *GCalConduitCfg); +static void doRevertSettings(GtkWidget *widget, GCalConduitCfg *GCalConduitCfg); +static void doSaveSettings(GtkWidget *widget, GCalConduitCfg *GCalConduitCfg); + +//static void readStateCfg (GtkWidget *w, GCalConduitCfg *c); +static void setStateCfg (GtkWidget *w, GCalConduitCfg *c); + +gint pilotId; +CORBA_Environment ev; +static GnomePilotClient *gpc; + + + +/* This array must be in the same order as enumerations + in GnomePilotConduitSyncType as they are used as index. + Custom type implies Disabled state. +*/ +static gchar* sync_options[] ={ N_("Disabled"), + N_("Synchronize"), + N_("Copy From Pilot"), + N_("Copy To Pilot"), + N_("Merge From Pilot"), + N_("Merge To Pilot")}; +#define SYNC_OPTIONS_COUNT 6 + + + + +/* Saves the configuration data. */ +static void +gcalconduit_save_configuration(GCalConduitCfg *c) +{ + gchar prefix[256]; + + g_snprintf(prefix,255,"/gnome-pilot.d/address-conduit/Pilot_%u/",c->pilotId); + + gnome_config_push_prefix(prefix); + gnome_config_set_bool ("open_secret", c->open_secret); + gnome_config_pop_prefix(); + + gnome_config_sync(); + gnome_config_drop_all(); +} + +/* Creates a duplicate of the configuration data */ +static GCalConduitCfg* +gcalconduit_dupe_configuration(GCalConduitCfg *c) { + GCalConduitCfg *retval; + g_return_val_if_fail(c!=NULL,NULL); + retval = g_new0(GCalConduitCfg,1); + retval->sync_type = c->sync_type; + retval->open_secret = c->open_secret; + retval->pilotId = c->pilotId; + return retval; +} + + +static void +doTrySettings(GtkWidget *widget, GCalConduitCfg *c) +{ + /* + readStateCfg (cfgStateWindow, curState); + if (activated) + gnome_pilot_conduit_config_enable (conduit_config, GnomePilotConduitSyncTypeCustom); + else + gnome_pilot_conduit_config_disable (conduit_config); + */ + + if (c->sync_type!=GnomePilotConduitSyncTypeCustom) + gnome_pilot_conduit_config_enable_with_first_sync (conduit_config, + c->sync_type, + c->sync_type, + TRUE); + else + gnome_pilot_conduit_config_disable (conduit_config); + + gcalconduit_save_configuration (c); +} + + +static void +doSaveSettings(GtkWidget *widget, GCalConduitCfg *GCalConduitCfg) +{ + doTrySettings(widget, GCalConduitCfg); + gcalconduit_save_configuration(GCalConduitCfg); +} + + +static void +doCancelSettings(GtkWidget *widget, GCalConduitCfg *c) +{ + doSaveSettings (widget, c); +} + + +static void +doRevertSettings(GtkWidget *widget, GCalConduitCfg *GCalConduitCfg) +{ + activated = org_activation_state; + setStateCfg (cfgStateWindow, curState); +} + +static void +about_cb (GtkWidget *widget, gpointer data) +{ + GtkWidget *about; + const gchar *authors[] = {_("Eskil Heyn Olsen <deity@eskil.dk>"),NULL}; + + about = gnome_about_new (_("Gpilotd address conduit"), VERSION, + _("(C) 1998 the Free Software Foundation"), + authors, + _("Configuration utility for the address conduit.\n"), + _("gnome-unknown.xpm")); + gtk_widget_show (about); + + return; +} + + +/* called by the sync_type GtkOptionMenu */ +static void +sync_action_selection(GtkMenuShell *widget, gpointer unused) +{ + if (!ignore_changes) { + capplet_widget_state_changed(CAPPLET_WIDGET (capplet), TRUE); + } +} + + +/* called by the sync_type GtkOptionMenu */ +static void +activate_sync_type(GtkMenuItem *widget, gpointer data) +{ + curState->sync_type = GPOINTER_TO_INT(data); + if(!ignore_changes) + capplet_widget_state_changed(CAPPLET_WIDGET(capplet), TRUE); +} + + +static GtkWidget +*createStateCfgWindow(void) +{ + GtkWidget *vbox, *table; + GtkWidget *label; + GtkWidget *optionMenu,*menuItem; + GtkMenu *menu; + gint i; + + vbox = gtk_vbox_new(FALSE, GNOME_PAD); + + table = gtk_hbox_new(FALSE, 0); + gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, GNOME_PAD); + + label = gtk_label_new(_("Synchronize Action")); + gtk_box_pack_start(GTK_BOX(table), label, FALSE, FALSE, GNOME_PAD); + + optionMenu=gtk_option_menu_new(); + gtk_object_set_data(GTK_OBJECT(vbox), "conduit_state", optionMenu); + menu = GTK_MENU(gtk_menu_new()); + + for (i=0; i<SYNC_OPTIONS_COUNT;i++) { + sync_options[i]=_(sync_options[i]); + menuItem = gtk_menu_item_new_with_label(sync_options[i]); + gtk_widget_show(menuItem); + gtk_signal_connect(GTK_OBJECT(menuItem),"activate", + GTK_SIGNAL_FUNC(activate_sync_type), + GINT_TO_POINTER(i)); + gtk_menu_append(menu,menuItem); + } + + gtk_option_menu_set_menu(GTK_OPTION_MENU(optionMenu),GTK_WIDGET(menu)); + gtk_signal_connect(GTK_OBJECT(menu), "selection-done", + GTK_SIGNAL_FUNC(sync_action_selection), + NULL); + + gtk_box_pack_start(GTK_BOX(table), optionMenu, FALSE, FALSE, 0); + + return vbox; +} + + +static void +setStateCfg (GtkWidget *w, GCalConduitCfg *c) +{ + GtkOptionMenu *optionMenu; + GtkMenu *menu; + + optionMenu = gtk_object_get_data (GTK_OBJECT(w), "conduit_state"); + g_assert (optionMenu != NULL); + menu = GTK_MENU (gtk_option_menu_get_menu (optionMenu)); + + ignore_changes = TRUE; + /* Here were are relying on the items in menu being the same + order as in GnomePilotConduitSyncType. */ + gtk_option_menu_set_history (optionMenu, (int) c->sync_type); + ignore_changes = FALSE; +} + + +#if 0 +static void +readStateCfg (GtkWidget *w, GCalConduitCfg *c) +{ + /* + GtkWidget *button; + button = gtk_object_get_data(GTK_OBJECT(cfg), "conduit_on_off"); + g_assert(button!=NULL); + activated = GTK_TOGGLE_BUTTON(button)->active; + */ +} +#endif /* 0 */ + + +static void +pilot_capplet_setup(void) +{ + GtkWidget *frame, *table; + + capplet = capplet_widget_new(); + + table = gtk_table_new(1, 2, FALSE); + gtk_container_border_width(GTK_CONTAINER(table), GNOME_PAD); + gtk_container_add(GTK_CONTAINER(capplet), table); + + frame = gtk_frame_new(_("Conduit state")); + gtk_container_border_width(GTK_CONTAINER(frame), GNOME_PAD_SMALL); + gtk_table_attach_defaults(GTK_TABLE(table), frame, 0, 1, 0, 1); + cfgStateWindow = createStateCfgWindow(); + gtk_container_add(GTK_CONTAINER(frame), cfgStateWindow); + + gtk_signal_connect(GTK_OBJECT(capplet), "try", + GTK_SIGNAL_FUNC(doTrySettings), curState); + gtk_signal_connect(GTK_OBJECT(capplet), "revert", + GTK_SIGNAL_FUNC(doRevertSettings), curState); + gtk_signal_connect(GTK_OBJECT(capplet), "ok", + GTK_SIGNAL_FUNC(doSaveSettings), curState); + gtk_signal_connect(GTK_OBJECT(capplet), "cancel", + GTK_SIGNAL_FUNC(doCancelSettings), curState); + gtk_signal_connect(GTK_OBJECT(capplet), "help", + GTK_SIGNAL_FUNC(about_cb), NULL); + + + setStateCfg (cfgStateWindow, curState); + + gtk_widget_show_all (capplet); +} + + +static void +run_error_dialog(gchar *mesg,...) +{ + char tmp[80]; + va_list ap; + + va_start(ap,mesg); + vsnprintf(tmp,79,mesg,ap); + dialogWindow = gnome_message_box_new(mesg,GNOME_MESSAGE_BOX_ERROR,GNOME_STOCK_BUTTON_OK,NULL); + gnome_dialog_run_and_close(GNOME_DIALOG(dialogWindow)); + va_end(ap); +} + + +static gint +get_pilot_id_from_gpilotd() +{ + GList *pilots=NULL; + gint pilot; + int i,err; + + i=0; + /* we don't worry about leaking here, so pilots isn't freed */ + switch(err = gnome_pilot_client_get_pilots(gpc,&pilots)) { + case GPILOTD_OK: { + if(pilots) { + for(i=0;i<g_list_length(pilots);i++) { + g_message("pilot %d = \"%s\"",i,(gchar*)g_list_nth(pilots,i)->data); + } + if(i==0) { + run_error_dialog(_("No pilot configured, please choose the\n'Pilot Link Properties' capplet first.")); + return -1; + } else { + gnome_pilot_client_get_pilot_id_by_name(gpc, + pilots->data, /* this is the first pilot */ + &pilot); + if(i>1) { + g_message("too many pilots..."); + /* need a choose here */ + } + return pilot; + } + } else { + run_error_dialog(_("No pilot configured, please choose the\n'Pilot Link Properties' capplet first.")); + return -1; + } + break; + } + case GPILOTD_ERR_NOT_CONNECTED: + run_error_dialog(_("Not connected to the gnome-pilot daemon")); + return -1; + break; + default: + g_warning("gnome_pilot_client_get_pilot_ids(...) = %d",err); + run_error_dialog(_("An error occured when trying to fetch\npilot list from the gnome-pilot daemon")); + return -1; + break; + } +} + + +int +main (int argc, char *argv[]) +{ + g_log_set_always_fatal (G_LOG_LEVEL_ERROR | + G_LOG_LEVEL_CRITICAL | + G_LOG_LEVEL_WARNING); + + /* we're a capplet */ + gnome_capplet_init ("address conduit control applet", NULL, argc, argv, + NULL, 0, NULL); + + + gpc = gnome_pilot_client_new(); + gnome_pilot_client_connect_to_daemon(gpc); + pilotId = get_pilot_id_from_gpilotd(); + if(!pilotId) return -1; + + /* put all code to set things up in here */ + gcalconduit_load_configuration (&origState, pilotId); + + conduit = gnome_pilot_conduit_management_new ("address_conduit", GNOME_PILOT_CONDUIT_MGMT_ID); + if (conduit == NULL) return -1; + conduit_config = gnome_pilot_conduit_config_new (conduit, pilotId); + org_activation_state = gnome_pilot_conduit_config_is_enabled (conduit_config, + &origState->sync_type); + activated = org_activation_state; + + //gpilotd_conduit_mgmt_get_sync_type (conduit, pilotId, &origState->sync_type); + + curState = gcalconduit_dupe_configuration(origState); + + pilot_capplet_setup (); + + + /* done setting up, now run main loop */ + capplet_gtk_main(); + + gnome_pilot_conduit_management_destroy(conduit); + + return 0; +} diff --git a/addressbook/conduit/address-conduit-control-applet.desktop b/addressbook/conduit/address-conduit-control-applet.desktop new file mode 100644 index 0000000000..d4941e44fe --- /dev/null +++ b/addressbook/conduit/address-conduit-control-applet.desktop @@ -0,0 +1,10 @@ +[Desktop Entry] +Name=Address conduit +Name[da]=Udstĺende +Name[no]=Oppgaver +Comment=Configure the address conduit +Comment[da]=Konfigurér Udstĺende +Comment[no]=Konfigurér oppgavelisten +Exec=address-conduit-control-applet --cap-id=1 +Terminal=0 +Type=Application diff --git a/addressbook/conduit/address-conduit.c b/addressbook/conduit/address-conduit.c new file mode 100644 index 0000000000..e954bbb4b0 --- /dev/null +++ b/addressbook/conduit/address-conduit.c @@ -0,0 +1,1069 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ + +#include <config.h> +#include <sys/stat.h> +#include <utime.h> +#include <unistd.h> +#include <pwd.h> +#include <signal.h> +#include <errno.h> + +#include <cal-client/cal-client.h> +#include <cal-util/calobj.h> +#include <cal-util/timeutil.h> +#include <pi-source.h> +#include <pi-socket.h> +#include <pi-file.h> +#include <pi-dlp.h> +#include <libgnorba/gnorba.h> +#include <libgnorba/gnome-factory.h> +#include <pi-version.h> +#include <gpilotd/gnome-pilot-conduit.h> +#include <gpilotd/gnome-pilot-conduit-standard-abs.h> +#include <address-conduit.h> + +//#include "GnomeCal.h" + +GnomePilotConduit * conduit_get_gpilot_conduit (guint32); +void conduit_destroy_gpilot_conduit (GnomePilotConduit*); +void local_record_from_icalobject (GCalLocalRecord *local, iCalObject *obj); + +#define CONDUIT_VERSION "0.8.11" +#ifdef G_LOG_DOMAIN +#undef G_LOG_DOMAIN +#endif +#define G_LOG_DOMAIN "addressconduit" + +#define DEBUG_CALCONDUIT 1 +/* #undef DEBUG_CALCONDUIT */ + +#ifdef DEBUG_CALCONDUIT +#define show_exception(e) g_warning ("Exception: %s\n", CORBA_exception_id (e)) +#define LOG(e...) g_log(G_LOG_DOMAIN,G_LOG_LEVEL_MESSAGE, e) +#else +#define show_exception(e) +#define LOG(e...) +#endif + +#define WARN(e...) g_log(G_LOG_DOMAIN,G_LOG_LEVEL_WARNING, e) +#define INFO(e...) g_log(G_LOG_DOMAIN,G_LOG_LEVEL_MESSAGE, e) + +#define catch_ret_val(_env,ret) \ + if (_env._major != CORBA_NO_EXCEPTION) { \ + g_log(G_LOG_DOMAIN,G_LOG_LEVEL_MESSAGE,"%s:%d: Caught exception",__FILE__,__LINE__); \ + g_warning ("Exception: %s\n", CORBA_exception_id (&(_env))); \ + CORBA_exception_free(&(_env)); \ + return ret; \ + } + + + + +/* Destroys any data allocated by gcalconduit_load_configuration + and deallocates the given configuration. */ +static void +gcalconduit_destroy_configuration(GCalConduitCfg **c) +{ + g_return_if_fail(c!=NULL); + g_return_if_fail(*c!=NULL); + g_free(*c); + *c = NULL; +} + + +/* Given a GCalConduitContxt*, allocates the structure */ +static void +gcalconduit_new_context(GCalConduitContext **ctxt, + GCalConduitCfg *c) +{ + *ctxt = g_new0(GCalConduitContext,1); + g_assert(ctxt!=NULL); + (*ctxt)->cfg = c; + CORBA_exception_init (&((*ctxt)->ev)); +} + + +/* Destroys any data allocated by gcalconduit_new_context + and deallocates its data. */ +static void +gcalconduit_destroy_context(GCalConduitContext **ctxt) +{ + g_return_if_fail(ctxt!=NULL); + g_return_if_fail(*ctxt!=NULL); +/* + if ((*ctxt)->cfg!=NULL) + gcalconduit_destroy_configuration(&((*ctxt)->cfg)); +*/ + g_free(*ctxt); + *ctxt = NULL; +} + + +static void +gnome_address_load_cb (GtkWidget *cal_client, + CalClientLoadStatus status, + GCalConduitContext *ctxt) +{ + //CalClient *client = CAL_CLIENT (cal_client); + + printf ("entering gnome_address_load_cb, tried=%d\n", + ctxt->address_load_tried); + + if (status == CAL_CLIENT_LOAD_SUCCESS) { + ctxt->address_load_success = TRUE; + printf (" success\n"); + gtk_main_quit (); /* end the sub event loop */ + } else { + if (ctxt->address_load_tried) { + printf ("load and create of address failed\n"); + gtk_main_quit (); /* end the sub event loop */ + return; + } + + // cal_client_create_address (client, ctxt->address_file); + ctxt->address_load_tried = 1; + } +} + + + + + +static int +start_address_server (GnomePilotConduitStandardAbs *conduit, + GCalConduitContext *ctxt) +{ + + g_return_val_if_fail(conduit!=NULL,-2); + g_return_val_if_fail(ctxt!=NULL,-2); + + ctxt->client = cal_client_new (); + + /* FIX ME */ + ctxt->address_file = g_concat_dir_and_file (g_get_home_dir (), + "evolution/local/something"); + + gtk_signal_connect (GTK_OBJECT (ctxt->client), "cal_loaded", + gnome_address_load_cb, ctxt); + + printf ("calling cal_client_load_address\n"); + //cal_client_load_address (ctxt->client, ctxt->address_file); + + /* run a sub event loop to turn cal-client's async load + notification into a synchronous call */ + gtk_main (); + + if (ctxt->address_load_success) + return 0; + + return -1; +} + + + +static GSList * +get_address_objects(GnomePilotConduitStandardAbs *conduit, + gboolean *status, + GCalConduitContext *ctxt) +{ +#if 0 + GList *uids; + GSList *result = NULL; + + g_return_val_if_fail (conduit != NULL, NULL); + g_return_val_if_fail (ctxt != NULL, NULL); + + uids = cal_client_get_uids (ctxt->client, CALOBJ_TYPE_ADDRESS); + + printf ("got %d address entries from cal server\n", g_list_length (uids)); + + if (status != NULL) + (*status) = TRUE; + + if (! uids) + INFO ("No entries found"); + else { + GList *c; + for (c=uids; c; c=c->next) + result = g_slist_prepend (result, (gchar *) c->data); + /* FIX ME free uids */ + } + + return result; +#endif /* 0 */ + return NULL; +} + + +static void +local_record_from_ical_uid (GCalLocalRecord *local, + char *uid, + GCalConduitContext *ctxt) +{ + iCalObject *obj; + CalClientGetStatus status; + + g_assert(local!=NULL); + + status = cal_client_get_object (ctxt->client, uid, &obj); + + if (status == CAL_CLIENT_GET_SUCCESS) + local_record_from_icalobject(local,obj); + else + INFO ("Object did not exist"); +} + + +/* + * converts a iCalObject to a GCalLocalRecord + */ + +void +local_record_from_icalobject(GCalLocalRecord *local, + iCalObject *obj) +{ + g_return_if_fail(local!=NULL); + g_return_if_fail(obj!=NULL); + + local->ical = obj; + local->local.ID = local->ical->pilot_id; +/* + LOG ("local->Id = %ld [%s], status = %d", + local->local.ID,obj->summary,local->ical->pilot_status); +*/ + switch(local->ical->pilot_status) { + case ICAL_PILOT_SYNC_NONE: + local->local.attr = GnomePilotRecordNothing; + break; + case ICAL_PILOT_SYNC_MOD: + local->local.attr = GnomePilotRecordModified; + break; + case ICAL_PILOT_SYNC_DEL: + local->local.attr = GnomePilotRecordDeleted; + break; + } + + /* Records without a pilot_id are new */ + if(local->local.ID == 0) + local->local.attr = GnomePilotRecordNew; + + local->local.secret = 0; + if(obj->class!=NULL) + if(strcmp(obj->class,"PRIVATE")==0) + local->local.secret = 1; + + local->local.archived = 0; +} + + +/* + * Given a PilotRecord, find the matching record in + * the address repository. If no match, return NULL + */ +static GCalLocalRecord * +find_record_in_repository(GnomePilotConduitStandardAbs *conduit, + PilotRecord *remote, + GCalConduitContext *ctxt) +{ + char *uid = NULL; + GCalLocalRecord *loc; + CalClientGetStatus status; + iCalObject *obj; + + g_return_val_if_fail(conduit!=NULL,NULL); + g_return_val_if_fail(remote!=NULL,NULL); + + LOG ("requesting %ld", remote->ID); + + + status = cal_client_get_uid_by_pilot_id (ctxt->client, remote->ID, &uid); + + if (status == CAL_CLIENT_GET_SUCCESS) { + status = cal_client_get_object (ctxt->client, uid, &obj); + if (status == CAL_CLIENT_GET_SUCCESS) { + LOG ("Found"); + loc = g_new0(GCalLocalRecord,1); + /* memory allocated in new_from_string is freed in free_match */ + local_record_from_icalobject (loc, obj); + return loc; + } + } + + INFO ("Object did not exist"); + return NULL; +} + + +/* + * updates an given iCalObject in the repository + */ +static void +update_address_entry_in_repository(GnomePilotConduitStandardAbs *conduit, + iCalObject *obj, + GCalConduitContext *ctxt) +{ + gboolean success; + + g_return_if_fail(conduit!=NULL); + g_return_if_fail(obj!=NULL); + + success = cal_client_update_object (ctxt->client, obj); +} + + +static iCalObject * +ical_from_remote_record(GnomePilotConduitStandardAbs *conduit, + PilotRecord *remote, + iCalObject *in_obj) +{ +#if 0 + iCalObject *obj; + struct Address address; + time_t now; + + now = time (NULL); + + g_return_val_if_fail(remote!=NULL,NULL); + memset (&address, 0, sizeof (struct Address)); + unpack_Address (&address, remote->record, remote->length); + + if (in_obj == NULL) + obj = ical_new (address.note ? address.note : "", + g_get_user_name (), + address.description ? address.description : ""); + else + obj = in_obj; + + if (address.note) { + g_free (obj->comment); + obj->comment = g_strdup (address.note); + } + if (address.description) { + g_free (obj->summary); + obj->summary = g_strdup (address.description); + } + + obj->type = ICAL_ADDRESS; + obj->new = TRUE; + obj->created = now; + obj->last_mod = now; + obj->priority = 0; + obj->transp = 0; + obj->related = NULL; + obj->pilot_id = remote->ID; + obj->pilot_status = ICAL_PILOT_SYNC_NONE; + + /* + * Begin and end + */ + + obj->dtend = mktime (& address.due); + + if (address.complete) + obj->completed = now-5; /* FIX ME */ + + printf ("[%s] from pilot, complete=%d/%ld\n", + address.description, + address.complete, + obj->completed); + + obj->priority = address.priority; + + g_free (obj->class); + + if (remote->attr & dlpRecAttrSecret) + obj->class = g_strdup ("PRIVATE"); + else + obj->class = g_strdup ("PUBLIC"); + + + free_Address(&address); + + return obj; +#endif /* 0 */ + return NULL; +} + + +static gint +update_record (GnomePilotConduitStandardAbs *conduit, + PilotRecord *remote, + GCalConduitContext *ctxt) +{ +#if 0 + iCalObject *obj; + struct Address address; + CalClientGetStatus status; + char *uid; + + g_return_val_if_fail(remote!=NULL,-1); + + memset (&address, 0, sizeof (struct Address)); + unpack_Address (&address, remote->record, remote->length); + + LOG ("requesting %ld [%s]", remote->ID, address.description); + printf ("requesting %ld [%s]\n", remote->ID, address.description); + + status = cal_client_get_uid_by_pilot_id(ctxt->client, remote->ID, &uid); + if (status == CAL_CLIENT_GET_SUCCESS) + status = cal_client_get_object (ctxt->client, uid, &obj); + + if (status != CAL_CLIENT_GET_SUCCESS) { + time_t now = time (NULL); + + LOG ("Object did not exist, creating a new one"); + printf ("Object did not exist, creating a new one\n"); + + obj = ical_new (address.note ? address.note : "", + g_get_user_name (), + address.description ? address.description : ""); + + obj->type = ICAL_ADDRESS; + obj->new = TRUE; + obj->created = now; + obj->last_mod = now; + obj->priority = 0; + obj->transp = 0; + obj->related = NULL; + obj->pilot_id = remote->ID; + obj->pilot_status = ICAL_PILOT_SYNC_NONE; + } else { + iCalObject *new_obj; + LOG ("Found"); + printf ("Found\n"); + new_obj = ical_from_remote_record (conduit, remote, obj); + obj = new_obj; + } + + /* update record on server */ + + update_address_entry_in_repository (conduit, obj, ctxt); + cal_client_update_pilot_id (ctxt->client, obj->uid, obj->pilot_id, + ICAL_PILOT_SYNC_NONE); + + /* + * Shutdown + */ + ical_object_unref (obj); + free_Address(&address); + +#endif /* 0 */ + + return 0; +} + +static void +check_for_slow_setting (GnomePilotConduit *c, GCalConduitContext *ctxt) +{ +#if 0 + GList *uids; + unsigned long int entry_number; + + uids = cal_client_get_uids (ctxt->client, CALOBJ_TYPE_ADDRESS); + + entry_number = g_list_length (uids); + + LOG (_("Address holds %ld address entries"), entry_number); + /* If the local base is empty, do a slow sync */ + if (entry_number == 0) { + GnomePilotConduitStandard *conduit; + conduit = GNOME_PILOT_CONDUIT_STANDARD (c); + gnome_pilot_conduit_standard_set_slow (conduit); + } +#endif /* 0 */ +} + +static gint +pre_sync (GnomePilotConduit *c, + GnomePilotDBInfo *dbi, + GCalConduitContext *ctxt) +{ + int l; + unsigned char *buf; + GnomePilotConduitStandardAbs *conduit; + /* gint num_records; */ + //GList *uids; + + /* + g_log_set_always_fatal (G_LOG_LEVEL_ERROR | + G_LOG_LEVEL_CRITICAL | + G_LOG_LEVEL_WARNING); + */ + + + conduit = GNOME_PILOT_CONDUIT_STANDARD_ABS(c); + + g_message ("GnomeCal Conduit v.%s",CONDUIT_VERSION); + + ctxt->client = NULL; + + if (start_address_server (GNOME_PILOT_CONDUIT_STANDARD_ABS(c), ctxt) != 0) { + WARN(_("Could not start gnomecal server")); + gnome_pilot_conduit_error(GNOME_PILOT_CONDUIT(c), + _("Could not start gnomecal server")); + return -1; + } + + +#if 0 + /* Set the counters for the progress bar crap */ + num_records = GNOME_Calendar_Repository_get_number_of_objects (ctxt->calendar, GNOME_Calendar_Repository_ANY, &(ctxt->ev)); + + catch_ret_val (ctxt->ev, -1); + gnome_pilot_conduit_standard_abs_set_num_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records); + num_records = GNOME_Calendar_Repository_get_number_of_objects (ctxt->calendar, GNOME_Calendar_Repository_MODIFIED, &(ctxt->ev)); + catch_ret_val (ctxt->ev, -1); + gnome_pilot_conduit_standard_abs_set_num_updated_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records); + num_records = GNOME_Calendar_Repository_get_number_of_objects (ctxt->calendar, GNOME_Calendar_Repository_NEW, &(ctxt->ev)); + catch_ret_val (ctxt->ev, -1); + gnome_pilot_conduit_standard_abs_set_num_new_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records); + num_records = GNOME_Calendar_Repository_get_number_of_objects (ctxt->calendar, GNOME_Calendar_Repository_DELETED, &(ctxt->ev)); + catch_ret_val (ctxt->ev, -1); + gnome_pilot_conduit_standard_abs_set_num_deleted_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records); +#endif /* 0 */ + + gtk_object_set_data(GTK_OBJECT(c),"dbinfo",dbi); + + /* load_records(c); */ + + buf = (unsigned char*)g_malloc(0xffff); + if((l=dlp_ReadAppBlock(dbi->pilot_socket,dbi->db_handle,0,(unsigned char *)buf,0xffff)) < 0) { + WARN(_("Could not read pilot's DateBook application block")); + WARN("dlp_ReadAppBlock(...) = %d",l); + gnome_pilot_conduit_error(GNOME_PILOT_CONDUIT(c), + _("Could not read pilot's DateBook application block")); + return -1; + } + unpack_AddressAppInfo(&(ctxt->ai),buf,l); + g_free(buf); + + check_for_slow_setting(c,ctxt); + + return 0; +} + +/** + * Find (if possible) the local record which matches + * the given PilotRecord. + * if successfull, return non-zero and set *local to + * a non-null value (the located local record), + * otherwise return 0 and set *local = NULL; + */ + +static gint +match_record (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord **local, + PilotRecord *remote, + GCalConduitContext *ctxt) +{ + LOG ("in match_record"); + + g_return_val_if_fail(local!=NULL,-1); + g_return_val_if_fail(remote!=NULL,-1); + + *local = find_record_in_repository(conduit,remote,ctxt); + + if (*local==NULL) return -1; + return 0; +} + +/** + * Free the data allocated by a previous match_record call. + * If successfull, return non-zero and ser *local=NULL, otherwise + * return 0. + */ +static gint +free_match (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord **local, + GCalConduitContext *ctxt) +{ + LOG ("entering free_match"); + + g_return_val_if_fail(local!=NULL,-1); + g_return_val_if_fail(*local!=NULL,-1); + + ical_object_unref (GCAL_LOCALRECORD(*local)->ical); + g_free(*local); + + *local = NULL; + return 0; +} + +/* + Move to archive and set status to Nothing + */ +static gint +archive_local (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord *local, + GCalConduitContext *ctxt) +{ + LOG ("entering archive_local"); + + g_return_val_if_fail(local!=NULL,-1); + + return -1; +} + +/* + Store in archive and set status to Nothing + */ +static gint +archive_remote (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord *local, + PilotRecord *remote, + GCalConduitContext *ctxt) +{ + LOG ("entering archive_remote"); + + //g_return_val_if_fail(remote!=NULL,-1); + //g_return_val_if_fail(local!=NULL,-1); + + return -1; +} + +/* + Store and set status to Nothing + */ +static gint +store_remote (GnomePilotConduitStandardAbs *conduit, + PilotRecord *remote, + GCalConduitContext *ctxt) +{ + LOG ("entering store_remote"); + + g_return_val_if_fail(remote!=NULL,-1); + remote->attr = GnomePilotRecordNothing; + + return update_record(conduit,remote,ctxt); +} + +static gint +clear_status_archive_local (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord *local, + GCalConduitContext *ctxt) +{ + LOG ("entering clear_status_archive_local"); + + g_return_val_if_fail(local!=NULL,-1); + + return -1; +} + +static gint +iterate (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord **local, + GCalConduitContext *ctxt) +{ + static GSList *events,*iterator; + static int hest; + + g_return_val_if_fail(local!=NULL,-1); + + if(*local==NULL) { + LOG ("beginning iteration"); + + events = get_address_objects (conduit, NULL, ctxt); + hest = 0; + + if(events!=NULL) { + LOG ("iterating over %d records", g_slist_length (events)); + *local = g_new0(GCalLocalRecord,1); + + local_record_from_ical_uid(*local,(gchar*)events->data,ctxt); + iterator = events; + } else { + LOG ("no events"); + (*local) = NULL; + } + } else { + /* printf ("continuing iteration\n"); */ + hest++; + if(g_slist_next(iterator)==NULL) { + GSList *l; + + LOG ("ending"); + /** free stuff allocated for iteration */ + g_free((*local)); + + LOG ("iterated over %d records", hest); + for(l=events;l;l=l->next) + g_free(l->data); + + g_slist_free(events); + + /* ends iteration */ + (*local) = NULL; + return 0; + } else { + iterator = g_slist_next(iterator); + local_record_from_ical_uid(*local,(gchar*)(iterator->data),ctxt); + } + } + return 1; +} + + +static gint +iterate_specific (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord **local, + gint flag, + gint archived, + GCalConduitContext *ctxt) +{ +#ifdef DEBUG_CALCONDUIT + { + gchar *tmp; + switch (flag) { + case GnomePilotRecordNothing: tmp = g_strdup("RecordNothing"); break; + case GnomePilotRecordModified: tmp = g_strdup("RecordModified"); break; + case GnomePilotRecordNew: tmp = g_strdup("RecordNew"); break; + default: tmp = g_strdup_printf("0x%x",flag); break; + } + printf ("entering iterate_specific(flag = %s)\n", tmp); + g_free(tmp); + } +#endif + g_return_val_if_fail(local!=NULL,-1); + + /* iterate until a record meets the criteria */ + while(gnome_pilot_conduit_standard_abs_iterate(conduit,(LocalRecord**)local)) { + if((*local)==NULL) break; + if(archived && ((*local)->local.archived==archived)) break; + if(((*local)->local.attr == flag)) break; + } + + return (*local)==NULL?0:1; +} + +static gint +purge (GnomePilotConduitStandardAbs *conduit, + GCalConduitContext *ctxt) +{ + LOG ("entering purge"); + + /* HEST, gem posterne her */ + + return -1; +} + + +static gint +set_status (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord *local, + gint status, + GCalConduitContext *ctxt) +{ + gboolean success; + LOG ("entering set_status(status=%d)",status); + + g_return_val_if_fail(local!=NULL,-1); + + g_assert(local->ical!=NULL); + + local->local.attr = status; + switch(status) { + case GnomePilotRecordPending: + case GnomePilotRecordNothing: + local->ical->pilot_status = ICAL_PILOT_SYNC_NONE; + break; + case GnomePilotRecordDeleted: + break; + case GnomePilotRecordNew: + case GnomePilotRecordModified: + local->ical->pilot_status = ICAL_PILOT_SYNC_MOD; + break; + } + + if (status == GnomePilotRecordDeleted) { + success = cal_client_remove_object (ctxt->client, local->ical->uid); + } else { + success = cal_client_update_object (ctxt->client, local->ical); + cal_client_update_pilot_id (ctxt->client, local->ical->uid, + local->local.ID, + local->ical->pilot_status); + } + + if (! success) { + WARN (_("Error while communicating with address server")); + } + + return 0; +} + +static gint +set_archived (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord *local, + gint archived, + GCalConduitContext *ctxt) +{ + LOG ("entering set_archived"); + + g_return_val_if_fail(local!=NULL,-1); + g_assert(local->ical!=NULL); + + local->local.archived = archived; + update_address_entry_in_repository (conduit, local->ical, ctxt); + return 0; +} + +static gint +set_pilot_id (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord *local, + guint32 ID, + GCalConduitContext *ctxt) +{ + LOG ("entering set_pilot_id(id=%d)",ID); + + g_return_val_if_fail(local!=NULL,-1); + g_assert(local->ical!=NULL); + + local->local.ID = ID; + local->ical->pilot_id = ID; + + cal_client_update_pilot_id (ctxt->client, + local->ical->uid, + local->local.ID, + local->ical->pilot_status); + + return 0; +} + +static gint +transmit (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord *local, + PilotRecord **remote, + GCalConduitContext *ctxt) +{ +#if 0 + PilotRecord *p; + + LOG ("entering transmit"); + + g_return_val_if_fail(local!=NULL,-1); + g_return_val_if_fail(remote!=NULL,-1); + g_assert(local->ical!=NULL); + + p = g_new0(PilotRecord,1); + + p->ID = local->local.ID; + p->attr = local->local.attr; + p->archived = local->local.archived; + p->secret = local->local.secret; + + local->address = g_new0(struct Address,1); + + local->address->indefinite = 0; /* FIX ME */ + local->address->due = *localtime (&local->ical->dtend); + local->address->priority = local->ical->priority; + + if (local->ical->completed > 0) + local->address->complete = 1; /* FIX ME */ + + /* STOP: don't replace these with g_strdup, since free_Address + uses free to deallocte */ + local->address->description = + local->ical->summary==NULL?NULL:strdup(local->ical->summary); + local->address->note = + local->ical->comment==NULL?NULL:strdup(local->ical->comment); + + printf ("transmitting address to pilot [%s] complete=%d/%ld\n", + local->ical->summary==NULL?"NULL":local->ical->summary, + local->address->complete, local->ical->completed); + + /* Generate pilot record structure */ + p->record = g_new0(char,0xffff); + p->length = pack_Address(local->address,p->record,0xffff); + + *remote = p; + +#endif /* 0 */ + + return 0; +} + +static gint +free_transmit (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord *local, + PilotRecord **remote, + GCalConduitContext *ctxt) +{ + LOG ("entering free_transmit"); + + g_return_val_if_fail(local!=NULL,-1); + g_return_val_if_fail(remote!=NULL,-1); + + free_Address(local->address); + g_free((*remote)->record); + *remote = NULL; + return 0; +} + +static gint +compare (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord *local, + PilotRecord *remote, + GCalConduitContext *ctxt) +{ +#if 0 + /* used by the quick compare */ + PilotRecord *remoteOfLocal; + int err; + int retval; + + g_message ("entering compare"); + printf ("entering compare\n"); + + g_return_val_if_fail (local!=NULL,-1); + g_return_val_if_fail (remote!=NULL,-1); + + err = transmit(conduit,local,&remoteOfLocal,ctxt); + if (err != 0) return err; + + retval = 0; + if (remote->length == remoteOfLocal->length) { + if (memcmp(remoteOfLocal->record,remote->record,remote->length)!=0) { + g_message("compare failed on contents"); + printf ("compare failed on contents\n"); + retval = 1; + + /* debug spew */ + { + struct Address foolocal; + struct Address fooremote; + + unpack_Address (&foolocal, + remoteOfLocal->record, + remoteOfLocal->length); + unpack_Address (&fooremote, + remote->record, + remote->length); + + printf (" local:[%d %ld %d %d '%s' '%s']\n", + foolocal.indefinite, + mktime (& foolocal.due), + foolocal.priority, + foolocal.complete, + foolocal.description, + foolocal.note); + + printf ("remote:[%d %ld %d %d '%s' '%s']\n", + fooremote.indefinite, + mktime (& fooremote.due), + fooremote.priority, + fooremote.complete, + fooremote.description, + fooremote.note); + } + } + } else { + g_message("compare failed on length"); + printf("compare failed on length\n"); + retval = 1; + } + + free_transmit(conduit,local,&remoteOfLocal,ctxt); + return retval; +#endif /* 0 */ + return 0; +} + +static gint +compare_backup (GnomePilotConduitStandardAbs *conduit, + GCalLocalRecord *local, + PilotRecord *remote, + GCalConduitContext *ctxt) +{ + LOG ("entering compare_backup"); + + g_return_val_if_fail(local!=NULL,-1); + g_return_val_if_fail(remote!=NULL,-1); + + return -1; +} + + +static gint +delete_all (GnomePilotConduitStandardAbs *conduit, + GCalConduitContext *ctxt) +{ + GSList *events,*it; + gboolean error; + gboolean success; + + events = get_address_objects (conduit, &error, ctxt); + + if (error == FALSE) return -1; + for (it=events; it; it = g_slist_next (it)) { + success = cal_client_remove_object (ctxt->client, it->data); + + if (!success) + INFO ("Object did not exist"); + + g_free (it->data); + } + + g_slist_free (events); + return -1; +} + + +GnomePilotConduit * +conduit_get_gpilot_conduit (guint32 pilotId) +{ + GtkObject *retval; + GCalConduitCfg *cfg; + GCalConduitContext *ctxt; + + printf ("in address's conduit_get_gpilot_conduit\n"); + + retval = gnome_pilot_conduit_standard_abs_new ("AddressDB", 0x746F646F); + g_assert (retval != NULL); + gnome_pilot_conduit_construct(GNOME_PILOT_CONDUIT(retval),"AddressConduit"); + + gcalconduit_load_configuration(&cfg,pilotId); + gtk_object_set_data(retval,"addressconduit_cfg",cfg); + + gcalconduit_new_context(&ctxt,cfg); + gtk_object_set_data(GTK_OBJECT(retval),"addressconduit_context",ctxt); + + gtk_signal_connect (retval, "match_record", (GtkSignalFunc) match_record, ctxt); + gtk_signal_connect (retval, "free_match", (GtkSignalFunc) free_match, ctxt); + gtk_signal_connect (retval, "archive_local", (GtkSignalFunc) archive_local, ctxt); + gtk_signal_connect (retval, "archive_remote", (GtkSignalFunc) archive_remote, ctxt); + gtk_signal_connect (retval, "store_remote", (GtkSignalFunc) store_remote, ctxt); + gtk_signal_connect (retval, "clear_status_archive_local", (GtkSignalFunc) clear_status_archive_local, ctxt); + gtk_signal_connect (retval, "iterate", (GtkSignalFunc) iterate, ctxt); + gtk_signal_connect (retval, "iterate_specific", (GtkSignalFunc) iterate_specific, ctxt); + gtk_signal_connect (retval, "purge", (GtkSignalFunc) purge, ctxt); + gtk_signal_connect (retval, "set_status", (GtkSignalFunc) set_status, ctxt); + gtk_signal_connect (retval, "set_archived", (GtkSignalFunc) set_archived, ctxt); + gtk_signal_connect (retval, "set_pilot_id", (GtkSignalFunc) set_pilot_id, ctxt); + gtk_signal_connect (retval, "compare", (GtkSignalFunc) compare, ctxt); + gtk_signal_connect (retval, "compare_backup", (GtkSignalFunc) compare_backup, ctxt); + gtk_signal_connect (retval, "free_transmit", (GtkSignalFunc) free_transmit, ctxt); + gtk_signal_connect (retval, "delete_all", (GtkSignalFunc) delete_all, ctxt); + gtk_signal_connect (retval, "transmit", (GtkSignalFunc) transmit, ctxt); + gtk_signal_connect (retval, "pre_sync", (GtkSignalFunc) pre_sync, ctxt); + + return GNOME_PILOT_CONDUIT (retval); +} + +void +conduit_destroy_gpilot_conduit (GnomePilotConduit *conduit) +{ + GCalConduitCfg *cc; + GCalConduitContext *ctxt; + + cc = GET_GCALCONFIG(conduit); + ctxt = GET_GCALCONTEXT(conduit); + + if (ctxt->client != NULL) { + gtk_object_unref (GTK_OBJECT (ctxt->client)); + } + + gcalconduit_destroy_configuration (&cc); + + gcalconduit_destroy_context (&ctxt); + + gtk_object_destroy (GTK_OBJECT (conduit)); +} diff --git a/addressbook/conduit/address-conduit.h b/addressbook/conduit/address-conduit.h new file mode 100644 index 0000000000..ec22e6631c --- /dev/null +++ b/addressbook/conduit/address-conduit.h @@ -0,0 +1,87 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ + +#ifndef __ADDRESS_CONDUIT_H__ +#define __ADDRESS_CONDUIT_H__ + +#include <sys/types.h> +#include <fcntl.h> +#include <unistd.h> +#include <gnome.h> +#include <pi-address.h> +#include <gpilotd/gnome-pilot-conduit.h> +#include <gpilotd/gnome-pilot-conduit-standard-abs.h> +#include <cal-client/cal-client.h> +#include <cal-util/calobj.h> +#include <cal-util/timeutil.h> + +#ifdef USING_OAF +#include <liboaf/liboaf.h> +#else +#include <libgnorba/gnorba.h> +#endif + + +/* This is the local record structure for the GnomeCal conduit. */ +typedef struct _GCalLocalRecord GCalLocalRecord; +struct _GCalLocalRecord { + /* The stuff from gnome-pilot-conduit-standard-abs.h + Must be first in the structure, or instances of this + structure cannot be used by gnome-pilot-conduit-standard-abs. + */ + LocalRecord local; + /* The corresponding iCal object, as found by GnomeCal. */ + iCalObject *ical; + /* pilot-link address structure, used for implementing Transmit. */ + struct Address *address; +}; +#define GCAL_LOCALRECORD(s) ((GCalLocalRecord*)(s)) + +/* This is the configuration of the GnomeCal conduit. */ +typedef struct _GCalConduitCfg GCalConduitCfg; +struct _GCalConduitCfg { + gboolean open_secret; + guint32 pilotId; + GnomePilotConduitSyncType sync_type; /* only used by capplet */ +}; +#define GET_GCALCONFIG(c) ((GCalConduitCfg*)gtk_object_get_data(GTK_OBJECT(c),"addressconduit_cfg")) + +/* This is the context for all the GnomeCal conduit methods. */ +typedef struct _GCalConduitContext GCalConduitContext; +struct _GCalConduitContext { + struct AddressAppInfo ai; + GCalConduitCfg *cfg; + CalClient *client; + CORBA_Environment ev; + CORBA_ORB orb; + gboolean address_load_tried; + gboolean address_load_success; + + char *address_file; +}; +#define GET_GCALCONTEXT(c) ((GCalConduitContext*)gtk_object_get_data(GTK_OBJECT(c),"addressconduit_context")) + + +/* Given a GCalConduitCfg*, allocates the structure and + loads the configuration data for the given pilot. + this is defined in the header file because it is used by + both address-conduit and address-conduit-control-applet, + and we don't want to export any symbols we don't have to. */ +static void +gcalconduit_load_configuration(GCalConduitCfg **c, + guint32 pilotId) +{ + gchar prefix[256]; + g_snprintf(prefix,255,"/gnome-pilot.d/address-conduit/Pilot_%u/",pilotId); + + *c = g_new0(GCalConduitCfg,1); + g_assert(*c != NULL); + gnome_config_push_prefix(prefix); + (*c)->open_secret = gnome_config_get_bool("open_secret=FALSE"); + (*c)->sync_type = GnomePilotConduitSyncTypeCustom; /* set in capplets main */ + gnome_config_pop_prefix(); + + (*c)->pilotId = pilotId; +} + + +#endif __ADDRESS_CONDUIT_H__ diff --git a/addressbook/conduit/address.conduit.in b/addressbook/conduit/address.conduit.in new file mode 100644 index 0000000000..3a0416fac8 --- /dev/null +++ b/addressbook/conduit/address.conduit.in @@ -0,0 +1,8 @@ +<gnome-pilot-conduit version="1.0"> +<conduit id="address_conduit" type="shlib" location="@prefix@/lib/gnome-pilot/conduits/libaddress_conduit.so"/> +<name value="address"/> +<conduit-attribute name="description" value="Synchronizes with Evolution"/> +<conduit-attribute name="default-synctype" value="synchronize"/> +<conduit-attribute name="icon" value="@prefix@/share/pixmaps/gnome-calendar-conduit.png"/> +<conduit-attribute name="settings" value="TRUE"/> +</gnome-pilot-conduit> |