/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include GnomePilotConduit * conduit_get_gpilot_conduit (guint32); void conduit_destroy_gpilot_conduit (GnomePilotConduit*); void local_record_from_compobject (GCalLocalRecord *local, CalComponent *comp); #define CONDUIT_VERSION "0.8.11" #ifdef G_LOG_DOMAIN #undef G_LOG_DOMAIN #endif #define G_LOG_DOMAIN "todoconduit" #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) /* debug spew DELETE ME */ static char *print_local (GCalLocalRecord *local) { static char buff[ 4096 ]; if (local == NULL) { sprintf (buff, "[NULL]"); return buff; } if (local->todo && local->todo->description) { sprintf (buff, "[%d %ld %d %d '%s' '%s']", local->todo->indefinite, mktime (& local->todo->due), local->todo->priority, local->todo->complete, local->todo->description, local->todo->note); return buff; } return cal_component_get_as_string (local->comp); } /* debug spew DELETE ME */ static char *print_remote (PilotRecord *remote) { static char buff[ 4096 ]; struct ToDo todo; if (remote == NULL) { sprintf (buff, "[NULL]"); return buff; } memset (&todo, 0, sizeof (struct ToDo)); unpack_ToDo (&todo, remote->record, remote->length); sprintf (buff, "[%d %ld %d %d '%s' '%s']", todo.indefinite, mktime (& todo.due), todo.priority, todo.complete, todo.description, todo.note); return buff; } /* Given a GCalConduitContxt*, allocates the structure */ static void e_todo_context_new (EToDoConduitContext **ctxt, guint32 pilotId) { *ctxt = g_new0 (EToDoConduitContext,1); g_assert (ctxt!=NULL); todoconduit_load_configuration (&(*ctxt)->cfg, pilotId); } /* Destroys any data allocated by gcalconduit_new_context and deallocates its data. */ static void e_todo_context_destroy (EToDoConduitContext **ctxt) { g_return_if_fail (ctxt!=NULL); g_return_if_fail (*ctxt!=NULL); if ((*ctxt)->client != NULL) gtk_object_unref (GTK_OBJECT ((*ctxt)->client)); if ((*ctxt)->cfg != NULL) todoconduit_destroy_configuration (&(*ctxt)->cfg); g_free (*ctxt); *ctxt = NULL; } static void gnome_calendar_load_cb (GtkWidget *cal_client, CalClientLoadStatus status, EToDoConduitContext *ctxt) { CalClient *client = CAL_CLIENT (cal_client); LOG (" todo-conduit entering gnome_calendar_load_cb, tried=%d\n", ctxt->calendar_load_tried); if (status == CAL_CLIENT_LOAD_SUCCESS) { ctxt->calendar_load_success = TRUE; LOG (" success\n"); gtk_main_quit (); /* end the sub event loop */ } else { if (ctxt->calendar_load_tried) { LOG (" load and create of calendar failed\n"); gtk_main_quit (); /* end the sub event loop */ return; } cal_client_create_calendar (client, ctxt->calendar_file); ctxt->calendar_load_tried = 1; } } static int start_calendar_server (GnomePilotConduitStandardAbs *conduit, EToDoConduitContext *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->calendar_file = g_concat_dir_and_file (g_get_home_dir (), "evolution/local/Calendar/calendar.ics"); gtk_signal_connect (GTK_OBJECT (ctxt->client), "cal_loaded", gnome_calendar_load_cb, ctxt); LOG (" calling cal_client_load_calendar\n"); cal_client_load_calendar (ctxt->client, ctxt->calendar_file); /* run a sub event loop to turn cal-client's async load notification into a synchronous call */ gtk_main (); if (ctxt->calendar_load_success) return 0; return -1; } static GSList * get_calendar_objects(GnomePilotConduitStandardAbs *conduit, gboolean *status, EToDoConduitContext *ctxt) { 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_TODO); LOG ("got %d todo 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; } static void local_record_from_comp_uid (GCalLocalRecord *local, char *uid, EToDoConduitContext *ctxt) { CalComponent *comp; CalClientGetStatus status; g_assert(local!=NULL); status = cal_client_get_object (ctxt->client, uid, &comp); if (status == CAL_CLIENT_GET_SUCCESS) local_record_from_compobject (local, comp); else INFO ("Object did not exist"); } static char *gnome_pilot_status_to_string (gint status) { switch(status) { case GnomePilotRecordPending: return "GnomePilotRecordPending"; case GnomePilotRecordNothing: return "GnomePilotRecordNothing"; case GnomePilotRecordDeleted: return "GnomePilotRecordDeleted"; case GnomePilotRecordNew: return "GnomePilotRecordNew"; case GnomePilotRecordModified: return "GnomePilotRecordModified"; } return "Unknown"; } /* * converts a CalComponent object to a GCalLocalRecord */ void local_record_from_compobject(GCalLocalRecord *local, CalComponent *comp) { unsigned long *pilot_id; unsigned long *pilot_status; CalComponentClassification classif; g_return_if_fail (local!=NULL); g_return_if_fail (comp!=NULL); local->comp = comp; local->todo = NULL; /* ??? */ cal_component_get_pilot_id (comp, &pilot_id); cal_component_get_pilot_status (comp, &pilot_status); /* Records without a pilot_id are new */ if (!pilot_id) { local->local.attr = GnomePilotRecordNew; } else { local->local.ID = *pilot_id; local->local.attr = *pilot_status; } cal_component_get_classification (comp, &classif); if (classif == CAL_COMPONENT_CLASS_PRIVATE) local->local.secret = 1; else local->local.secret = 0; local->local.archived = 0; } /* * Given a PilotRecord, find the matching record in * the calendar repository. If no match, return NULL */ static GCalLocalRecord * find_record_in_repository(GnomePilotConduitStandardAbs *conduit, PilotRecord *remote, EToDoConduitContext *ctxt) { char *uid = NULL; GCalLocalRecord *loc; CalClientGetStatus status; CalComponent *obj; g_return_val_if_fail(conduit!=NULL,NULL); g_return_val_if_fail(remote!=NULL,NULL); LOG ("find_record_in_repository: remote=%s... ", print_remote (remote)); 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 %s\n", cal_component_get_as_string (obj)); loc = g_new0(GCalLocalRecord,1); /* memory allocated in new_from_string is freed in free_match */ local_record_from_compobject (loc, obj); return loc; } } INFO ("Object did not exist"); LOG ("not found\n"); return NULL; } /* * updates an given CalComponent in the repository */ static void update_calendar_entry_in_repository(GnomePilotConduitStandardAbs *conduit, CalComponent *obj, EToDoConduitContext *ctxt) { gboolean success; g_return_if_fail (conduit!=NULL); g_return_if_fail (obj!=NULL); LOG (" update_calendar_entry_in_repository " "saving %s to desktop\n", cal_component_get_as_string (obj)); success = cal_client_update_object (ctxt->client, obj); if (!success) { WARN (_("Error while communicating with calendar server")); } } static CalComponent * comp_from_remote_record (GnomePilotConduitStandardAbs *conduit, PilotRecord *remote, CalComponent *in_comp) { CalComponent *comp; struct ToDo todo; struct icaltimetype now = icaltime_from_timet (time (NULL), FALSE, FALSE); unsigned long pilot_status = GnomePilotRecordNothing; CalComponentText summary = {NULL, NULL}; CalComponentText comment = {NULL, NULL}; CalComponentDateTime dt = {NULL, NULL}; struct icaltimetype due; GSList *comment_list; g_return_val_if_fail(remote!=NULL,NULL); memset (&todo, 0, sizeof (struct ToDo)); unpack_ToDo (&todo, remote->record, remote->length); LOG (" comp_from_remote_record: " "merging remote %s into local %s\n", print_remote (remote), cal_component_get_as_string (in_comp)); if (in_comp == NULL) { comp = cal_component_new (); cal_component_set_new_vtype (comp, CAL_COMPONENT_TODO); } else { comp = cal_component_clone (in_comp); } cal_component_set_created (comp, &now); cal_component_set_last_modified (comp, &now); summary.value = todo.description; cal_component_set_summary (comp, &summary); comment.value = todo.note; comment_list = g_slist_append (NULL, &comment); cal_component_set_comment_list (comp, comment_list); g_slist_free (comment_list); if (todo.complete) { int percent = 100; cal_component_set_completed (comp, &now); cal_component_set_percent (comp, &percent); } due = icaltime_from_timet (mktime (& todo.due), FALSE, FALSE); dt.value = &due; cal_component_set_due (comp, &dt); cal_component_set_priority (comp, &todo.priority); cal_component_set_transparency (comp, CAL_COMPONENT_TRANSP_NONE); if (remote->attr & dlpRecAttrSecret) cal_component_set_classification (comp, CAL_COMPONENT_CLASS_PRIVATE); else cal_component_set_classification (comp, CAL_COMPONENT_CLASS_PUBLIC); cal_component_set_pilot_id (comp, &remote->ID); cal_component_set_pilot_status (comp, &pilot_status); free_ToDo(&todo); return comp; } /* Code blatantly stolen from * calendar-pilot-sync.c: * * (C) 1999 International GNOME Support * * Author: * Miguel de Icaza (miguel@gnome-support.com) * * store a copy of a pilot record in the desktop database * */ static gint update_record (GnomePilotConduitStandardAbs *conduit, PilotRecord *remote, EToDoConduitContext *ctxt) { CalComponent *comp; CalClientGetStatus status; struct ToDo todo; unsigned long pilot_status = GnomePilotRecordNothing; char *uid; CalComponentText summary = {NULL, NULL}; CalComponentText comment = {NULL, NULL}; GSList *comment_list; g_return_val_if_fail (remote!=NULL,-1); memset (&todo, 0, sizeof (struct ToDo)); unpack_ToDo (&todo, remote->record, remote->length); LOG (" cal_client_get_uid_by_pilot_id... "); status = cal_client_get_uid_by_pilot_id (ctxt->client, remote->ID, &uid); if (status == CAL_CLIENT_GET_SUCCESS) { LOG (" succeeded with '%s'\n", uid); LOG (" cal_client_get_object... "); status = cal_client_get_object (ctxt->client, uid, &comp); } if (status != CAL_CLIENT_GET_SUCCESS) { struct icaltimetype now = icaltime_from_timet (time (NULL), FALSE, FALSE); LOG ("failed, making a new one.\n"); comp = cal_component_new (); cal_component_set_new_vtype (comp, CAL_COMPONENT_TODO); summary.value = todo.description; cal_component_set_summary (comp, &summary); comment.value = todo.note; comment_list = g_slist_append (NULL, &comment); cal_component_set_comment_list (comp, comment_list); g_slist_free (comment_list); cal_component_set_created (comp, &now); cal_component_set_last_modified (comp, &now); cal_component_set_priority (comp, &todo.priority); cal_component_set_transparency (comp, CAL_COMPONENT_TRANSP_NONE); cal_component_set_pilot_id (comp, &remote->ID); cal_component_set_pilot_status (comp, &pilot_status); } else { CalComponent *new_comp; LOG ("succeeded %s\n", cal_component_get_as_string (comp)); new_comp = comp_from_remote_record (conduit, remote, comp); comp = new_comp; } /* update record on server */ { const char *uid; unsigned long *pilot_id; cal_component_get_uid (comp, &uid); cal_component_get_pilot_id (comp, &pilot_id); update_calendar_entry_in_repository (conduit, comp, ctxt); cal_client_update_pilot_id (ctxt->client, (char *) uid, *pilot_id, pilot_status); } /* * Shutdown */ gtk_object_unref (GTK_OBJECT (comp)); free_ToDo(&todo); return 0; } static void check_for_slow_setting (GnomePilotConduit *c, EToDoConduitContext *ctxt) { GList *uids; unsigned long int entry_number; uids = cal_client_get_uids (ctxt->client, CALOBJ_TYPE_TODO); entry_number = g_list_length (uids); /* If the local base is empty, do a slow sync */ if (entry_number == 0) { GnomePilotConduitStandard *conduit; LOG (" doing slow sync\n"); conduit = GNOME_PILOT_CONDUIT_STANDARD (c); gnome_pilot_conduit_standard_set_slow (conduit); } else { LOG (" doing fast sync\n"); } } static gint pre_sync (GnomePilotConduit *c, GnomePilotDBInfo *dbi, EToDoConduitContext *ctxt) { int l; unsigned char *buf; GnomePilotConduitStandardAbs *conduit; gint num_records; /* g_log_set_always_fatal (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING); */ conduit = GNOME_PILOT_CONDUIT_STANDARD_ABS(c); LOG ("---------------------------------------------------------\n"); LOG ("pre_sync: ToDo Conduit v.%s", CONDUIT_VERSION); g_message ("ToDo Conduit v.%s", CONDUIT_VERSION); ctxt->client = NULL; if (start_calendar_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; } num_records = cal_client_get_n_objects (ctxt->client, CALOBJ_TYPE_TODO); gnome_pilot_conduit_standard_abs_set_num_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records); /* FIX ME How are we going to fill in these fields? */ num_records = 0; gnome_pilot_conduit_standard_abs_set_num_updated_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records); gnome_pilot_conduit_standard_abs_set_num_new_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records); gnome_pilot_conduit_standard_abs_set_num_deleted_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records); gtk_object_set_data (GTK_OBJECT(c), "dbinfo", dbi); /* load_records(c); */ buf = (unsigned char*)g_malloc (0xffff); l = dlp_ReadAppBlock (dbi->pilot_socket, dbi->db_handle, 0, (unsigned char *)buf, 0xffff); if (l < 0) { WARN(_("Could not read pilot's ToDo application block")); WARN("dlp_ReadAppBlock(...) = %d",l); gnome_pilot_conduit_error(GNOME_PILOT_CONDUIT(c), _("Could not read pilot's ToDo application block")); return -1; } unpack_ToDoAppInfo (&(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, EToDoConduitContext *ctxt) { LOG ("match_record: looking for local copy of %s\n", print_remote (remote)); 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) LOG (" match_record: not found.\n"); else LOG (" match_record: found, %s\n", print_local (*local)); 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, EToDoConduitContext *ctxt) { LOG ("free_match: %s\n", print_local (*local)); g_return_val_if_fail (local != NULL, -1); g_return_val_if_fail (*local != NULL, -1); gtk_object_unref (GTK_OBJECT ((*local)->comp)); g_free (*local); *local = NULL; return 0; } /* Move to archive and set status to Nothing */ static gint archive_local (GnomePilotConduitStandardAbs *conduit, GCalLocalRecord *local, EToDoConduitContext *ctxt) { LOG ("archive_local: doing nothing with %s\n", print_local (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, EToDoConduitContext *ctxt) { LOG ("archive_remote: doing nothing with %s\n", print_local (local)); /* 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, EToDoConduitContext *ctxt) { LOG ("store_remote: copying pilot record %s to desktop\n", print_remote (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, EToDoConduitContext *ctxt) { LOG ("clear_status_archive_local: doing nothing\n"); g_return_val_if_fail(local!=NULL,-1); return -1; } static gint iterate (GnomePilotConduitStandardAbs *conduit, GCalLocalRecord **local, EToDoConduitContext *ctxt) { static GSList *events,*iterator; static int hest; g_return_val_if_fail(local!=NULL,-1); if(*local==NULL) { /* LOG ("beginning iteration"); */ events = get_calendar_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_comp_uid(*local,(gchar*)events->data,ctxt); iterator = events; } else { /* LOG ("no events"); */ (*local) = NULL; } } else { /* LOG ("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_comp_uid(*local,(gchar*)(iterator->data),ctxt); } } return 1; } static gint iterate_specific (GnomePilotConduitStandardAbs *conduit, GCalLocalRecord **local, gint flag, gint archived, EToDoConduitContext *ctxt) { (*local) = NULL; /* ??? */ /* debugging */ { gchar *tmp; switch (flag) { case GnomePilotRecordNothing: tmp = g_strdup("RecordNothing"); break; case GnomePilotRecordModified: tmp = g_strdup("RecordModified"); break; case GnomePilotRecordDeleted: tmp = g_strdup("RecordDeleted"); break; case GnomePilotRecordNew: tmp = g_strdup("RecordNew"); break; default: tmp = g_strdup_printf("0x%x",flag); break; } LOG ("\niterate_specific: (flag = %s)... ", tmp); g_free(tmp); } 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; } if ((*local)) { LOG (" found %s\n", print_local (*local)); } else { LOG (" no more found.\n"); } return (*local)==NULL?0:1; } static gint purge (GnomePilotConduitStandardAbs *conduit, EToDoConduitContext *ctxt) { LOG ("purge: doing nothing\n"); /* HEST, gem posterne her */ return -1; } static gint set_status (GnomePilotConduitStandardAbs *conduit, GCalLocalRecord *local, gint status, EToDoConduitContext *ctxt) { gboolean success; LOG ("set_status: %s status is now '%s'\n", print_local (local), gnome_pilot_status_to_string (status)); g_return_val_if_fail(local!=NULL,-1); g_assert(local->comp!=NULL); local->local.attr = status; if (status == GnomePilotRecordDeleted) { const char *uid; cal_component_get_uid (local->comp, &uid); success = cal_client_remove_object (ctxt->client, uid); } else { const char *uid; unsigned long *pilot_id; cal_component_get_uid (local->comp, &uid); cal_component_get_pilot_id (local->comp, &pilot_id); success = cal_client_update_object (ctxt->client, local->comp); cal_client_update_pilot_id (ctxt->client, (char *) uid, *pilot_id, status); } if (!success) { WARN (_("Error while communicating with calendar server")); } return 0; } static gint set_archived (GnomePilotConduitStandardAbs *conduit, GCalLocalRecord *local, gint archived, EToDoConduitContext *ctxt) { LOG ("set_archived: %s archived flag is now '%d'\n", print_local (local), archived); g_return_val_if_fail(local!=NULL,-1); g_assert(local->comp!=NULL); local->local.archived = archived; update_calendar_entry_in_repository(conduit,local->comp,ctxt); /* FIXME: This should move the entry into a speciel calendar file, eg. Archive, or (by config option), simply delete it */ return 0; } static gint set_pilot_id (GnomePilotConduitStandardAbs *conduit, GCalLocalRecord *local, guint32 ID, EToDoConduitContext *ctxt) { const char *uid; unsigned long *pilot_status; LOG ("set_pilot_id: %s pilot ID is now '%d'\n", print_local (local), ID); g_return_val_if_fail(local!=NULL,-1); g_assert(local->comp!=NULL); local->local.ID = ID; cal_component_set_pilot_id (local->comp, (unsigned long *)&ID); cal_component_get_uid (local->comp, &uid); cal_component_get_pilot_status (local->comp, &pilot_status); cal_client_update_pilot_id (ctxt->client, (char *) uid, local->local.ID, *pilot_status); return 0; } static gint transmit (GnomePilotConduitStandardAbs *conduit, GCalLocalRecord *local, PilotRecord **remote, EToDoConduitContext *ctxt) { PilotRecord *p; /* priority; FIX ME */ struct icaltimetype *completed; CalComponentText summary; GSList *comment_list = NULL; CalComponentText *comment; LOG ("transmit: encoding local %s\n", print_local (local)); g_return_val_if_fail(local!=NULL,-1); g_return_val_if_fail(remote!=NULL,-1); g_assert(local->comp!=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->todo = g_new0(struct ToDo,1); { CalComponentDateTime dtend; time_t dtend_time_t; cal_component_get_dtend (local->comp, &dtend); dtend_time_t = icaltime_as_timet (*dtend.value); local->todo->due = *localtime (&dtend_time_t); local->todo->indefinite = (dtend.value->year == 0); } /* local->todo->priority = local->comp->priority; */ /* local->todo->priority = 1; */ /* FIX ME */ cal_component_get_completed (local->comp, &completed); if (completed->year > 0) local->todo->complete = 1; /* FIX ME */ /* STOP: don't replace these with g_strdup, since free_ToDo uses free to deallocte */ cal_component_get_summary (local->comp, &summary); local->todo->description = /* local->comp->summary == NULL ? NULL : strdup (summary.value); */ strdup ((char *) summary.value); cal_component_get_comment_list (local->comp, &comment_list); if (comment_list) { comment = (CalComponentText *) comment_list->data; if (comment && comment->value) local->todo->note = strdup (comment->value); else local->todo->note = NULL; } else { local->todo->note = NULL; } /* LOG ("transmitting todo to pilot [%s] complete=%d/%ld\n", local->comp->summary==NULL?"NULL":local->comp->summary, local->todo->complete, local->comp->completed); */ /* Generate pilot record structure */ p->record = g_new0(char,0xffff); p->length = pack_ToDo(local->todo,p->record,0xffff); *remote = p; return 0; } static gint free_transmit (GnomePilotConduitStandardAbs *conduit, GCalLocalRecord *local, PilotRecord **remote, EToDoConduitContext *ctxt) { LOG ("free_transmit: freeing %s\n", print_local (local)); g_return_val_if_fail(local!=NULL,-1); g_return_val_if_fail(remote!=NULL,-1); /* free_ToDo(local->todo); */ /* FIX ME is this needed? */ g_free((*remote)->record); *remote = NULL; return 0; } static gint compare (GnomePilotConduitStandardAbs *conduit, GCalLocalRecord *local, PilotRecord *remote, EToDoConduitContext *ctxt) { /* used by the quick compare */ PilotRecord *remoteOfLocal; int err; int retval; LOG ("compare: local=%s remote=%s...\n", print_local (local), print_remote (remote)); 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) { LOG (" compare failed on contents\n"); retval = 1; } } else { LOG(" compare failed on length\n"); retval = 1; } if (retval == 0) { LOG (" match.\n"); } else { /* debug spew */ LOG (" local:%s\n", print_remote (remoteOfLocal)); LOG (" remote:%s\n", print_remote (remote)); } free_transmit(conduit,local,&remoteOfLocal,ctxt); return retval; } static gint compare_backup (GnomePilotConduitStandardAbs *conduit, GCalLocalRecord *local, PilotRecord *remote, EToDoConduitContext *ctxt) { LOG ("compare_backup: doing nothing\n"); g_return_val_if_fail(local!=NULL,-1); g_return_val_if_fail(remote!=NULL,-1); return -1; } static gint delete_all (GnomePilotConduitStandardAbs *conduit, EToDoConduitContext *ctxt) { GSList *events,*it; gboolean error; gboolean success; events = get_calendar_objects(conduit,&error,ctxt); LOG ("delete_all: deleting all objects from desktop\n"); 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 0; } static ORBit_MessageValidationResult accept_all_cookies (CORBA_unsigned_long request_id, CORBA_Principal *principal, CORBA_char *operation) { /* allow ALL cookies */ return ORBIT_MESSAGE_ALLOW_ALL; } GnomePilotConduit * conduit_get_gpilot_conduit (guint32 pilotId) { GtkObject *retval; EToDoConduitContext *ctxt; LOG ("in todo's conduit_get_gpilot_conduit\n"); /* we need to find wombat with oaf, so make sure oaf is initialized here. once the desktop is converted to oaf and gpilotd is built with oaf, this can go away */ if (!oaf_is_initialized ()) { char *argv[ 1 ] = {"hi"}; oaf_init (1, argv); if (bonobo_init (CORBA_OBJECT_NIL, CORBA_OBJECT_NIL, CORBA_OBJECT_NIL) == FALSE) g_error (_("Could not initialize Bonobo")); ORBit_set_request_validation_handler (accept_all_cookies); } retval = gnome_pilot_conduit_standard_abs_new ("ToDoDB", 0x746F646F); g_assert (retval != NULL); gnome_pilot_conduit_construct (GNOME_PILOT_CONDUIT (retval), "ToDoConduit"); e_todo_context_new (&ctxt, pilotId); gtk_object_set_data (GTK_OBJECT (retval), "todoconduit_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) { EToDoConduitContext *ctxt; ctxt = gtk_object_get_data (GTK_OBJECT (conduit), "todoconduit_context"); e_todo_context_destroy (&ctxt); gtk_object_destroy (GTK_OBJECT (conduit)); }