int get_contact_app_info(struct ContactAppInfo *ai)
{
int num, r;
int rec_size;
unsigned char *buf;
pi_buffer_t pi_buf;
long char_set;
memset(ai, 0, sizeof(*ai));
/* Put at least one entry in there */
strcpy(ai->category.name[0], "Unfiled");
r = jp_get_app_info("ContactsDB-PAdd", &buf, &rec_size);
if ((r != EXIT_SUCCESS) || (rec_size<=0)) {
jp_logf(JP_LOG_WARN, _("%s:%d Error reading application info %s\n"), __FILE__, __LINE__, "ContactsDB-PAdd");
if (buf) {
free(buf);
}
return EXIT_FAILURE;
}
pi_buf.data = buf;
pi_buf.used = rec_size;
pi_buf.allocated = rec_size;
num = jp_unpack_ContactAppInfo(ai, &pi_buf);
if (buf) {
free(buf);
}
if ((num<0) || (rec_size<=0)) {
jp_logf(JP_LOG_WARN, _("Error reading file: %s\n"), "ContactsDB-PAdd.pdb");
return EXIT_FAILURE;
}
get_pref(PREF_CHAR_SET, &char_set, NULL);
if (char_set != CHAR_SET_LATIN1) {
/* Convert to host character set */
int i;
for (i = 0; i < 49 + 3; i++)
if (ai->labels[i][0] != '\0') {
charset_p2j(ai->labels[i], 16, char_set);
}
for (i = 0; i < 8; i++)
if (ai->phoneLabels[i][0] != '\0') {
charset_p2j(ai->phoneLabels[i], 16, char_set);
}
for (i = 0; i < 3; i++)
if (ai->addrLabels[i][0] != '\0') {
charset_p2j(ai->addrLabels[i], 16, char_set);
}
for (i = 0; i < 5; i++)
if (ai->IMLabels[i][0] != '\0') {
charset_p2j(ai->IMLabels[i], 16, char_set);
}
}
return EXIT_SUCCESS;
}
/* Allocates memory and returns pointer, or NULL */
static char *jp_user_or_whoami(void)
{
struct passwd *pw_ent;
uid_t uid;
const char *svalue;
long char_set;
get_pref(PREF_CHAR_SET, &char_set, NULL);
get_pref(PREF_USER, NULL, &svalue);
if ((svalue) && (svalue[0])) {
/* Convert User Name stored in Palm character set */
return charset_p2newj(svalue, -1, char_set);
}
uid = geteuid();
pw_ent = getpwuid(uid);
if ((pw_ent) && (pw_ent->pw_name)) {
return strdup(pw_ent->pw_name);
}
return NULL;
}
int install_user_gui(GtkWidget *main_window)
{
int r;
char user[MAX_PREF_LEN];
unsigned long user_id;
const char *svalue;
long old_user_id;
char *old_user;
r = dialog_install_user(GTK_WINDOW(main_window), user, MAX_PREF_LEN, &user_id);
if (r == DIALOG_SAID_1) {
/* Temporarily set the user and user ID */
get_pref(PREF_USER, NULL, &svalue);
get_pref(PREF_USER_ID, &old_user_id, NULL);
if (svalue) {
old_user = strdup(svalue);
} else {
old_user = strdup("");
}
set_pref(PREF_USER, 0, user, FALSE);
set_pref(PREF_USER_ID, user_id, NULL, TRUE);
jp_logf(JP_LOG_DEBUG, "user is %s\n", user);
jp_logf(JP_LOG_DEBUG, "user id is %ld\n", user_id);
r = setup_sync(SYNC_NO_PLUGINS | SYNC_INSTALL_USER);
jp_logf(JP_LOG_DEBUG, "old user is %s\n", old_user);
jp_logf(JP_LOG_DEBUG, "old user id is %ld\n", old_user_id);
set_pref(PREF_USER, 0, old_user, FALSE);
set_pref(PREF_USER_ID, old_user_id, NULL, TRUE);
free(old_user);
return r;
}
return -1;
}
int pc_contact_write(struct Contact *cont, PCRecType rt, unsigned char attrib,
unsigned int *unique_id)
{
pi_buffer_t *RecordBuffer;
int i;
buf_rec br;
long char_set;
get_pref(PREF_CHAR_SET, &char_set, NULL);
if (char_set != CHAR_SET_LATIN1) {
for (i = 0; i < 39; i++) {
if (cont->entry[i])
charset_j2p(cont->entry[i], strlen(cont->entry[i])+1, char_set);
}
}
RecordBuffer = pi_buffer_new(0);
jp_pack_Contact(cont, RecordBuffer);
if (!RecordBuffer->used) {
PRINT_FILE_LINE;
jp_logf(JP_LOG_WARN, "jp_pack_Contact %s\n", _("error"));
pi_buffer_free(RecordBuffer);
return EXIT_FAILURE;
}
br.rt=rt;
br.attrib = attrib;
br.buf = RecordBuffer->data;
br.size = RecordBuffer->used;
/* Keep unique ID intact */
if (unique_id) {
br.unique_id = *unique_id;
} else {
br.unique_id = 0;
}
jp_pc_write("ContactsDB-PAdd", &br);
if (unique_id) {
*unique_id = br.unique_id;
}
pi_buffer_free(RecordBuffer);
return EXIT_SUCCESS;
}
int install_gui(GtkWidget *main_window, int w, int h, int x, int y)
{
GtkWidget *scrolled_window;
GtkWidget *button;
GtkWidget *label;
GtkWidget *pixmapwid;
GdkPixmap *pixmap;
GdkBitmap *mask;
char temp_str[256];
const char *svalue;
gchar *titles[] = {"", _("Files to install")};
if (filew) {
return EXIT_SUCCESS;
}
clist_row_selected = 0;
g_snprintf(temp_str, sizeof(temp_str), "%s %s", PN, _("Install"));
filew = gtk_widget_new(GTK_TYPE_FILE_SELECTION,
"type", GTK_WINDOW_TOPLEVEL,
"title", temp_str,
NULL);
gtk_window_set_default_size(GTK_WINDOW(filew), w, h);
gtk_widget_set_uposition(filew, x, y);
gtk_window_set_modal(GTK_WINDOW(filew), TRUE);
gtk_window_set_transient_for(GTK_WINDOW(filew), GTK_WINDOW(main_window));
get_pref(PREF_INSTALL_PATH, NULL, &svalue);
if (svalue && svalue[0]) {
gtk_file_selection_set_filename(GTK_FILE_SELECTION(filew), svalue);
}
gtk_file_selection_hide_fileop_buttons((gpointer) filew);
gtk_widget_hide((GTK_FILE_SELECTION(filew)->cancel_button));
gtk_signal_connect(GTK_OBJECT(filew), "destroy",
GTK_SIGNAL_FUNC(cb_destroy), filew);
/* Even though I hide the ok button I still want to connect its signal */
/* because a double click on the file name also calls this callback */
gtk_widget_hide(GTK_WIDGET(GTK_FILE_SELECTION(filew)->ok_button));
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filew)->ok_button),
"clicked", GTK_SIGNAL_FUNC(cb_add), filew);
clist = gtk_clist_new_with_titles(2, titles);
gtk_widget_set_usize(GTK_WIDGET(clist), 0, 166);
gtk_clist_column_titles_passive(GTK_CLIST(clist));
gtk_clist_set_column_auto_resize(GTK_CLIST(clist), INST_SDCARD_COLUMN, TRUE);
gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_BROWSE);
get_pixmaps(clist, PIXMAP_SDCARD, &pixmap, &mask);
#ifdef __APPLE__
mask = NULL;
#endif
pixmapwid = gtk_pixmap_new(pixmap, mask);
gtk_clist_set_column_widget(GTK_CLIST(clist), INST_SDCARD_COLUMN, pixmapwid);
gtk_clist_set_column_justification(GTK_CLIST(clist), INST_SDCARD_COLUMN, GTK_JUSTIFY_CENTER);
gtk_signal_connect(GTK_OBJECT(clist), "select_row",
GTK_SIGNAL_FUNC(cb_clist_selection), NULL);
/* Scrolled Window for file list */
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(clist));
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_set_border_width(GTK_CONTAINER(scrolled_window), 5);
gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->action_area),
scrolled_window, TRUE, TRUE, 0);
label = gtk_label_new(_("To change to a hidden directory type it below and hit TAB"));
gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->main_vbox),
label, FALSE, FALSE, 0);
/* Add/Remove/Quit buttons */
button = gtk_button_new_from_stock(GTK_STOCK_ADD);
gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->ok_button->parent),
button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(button),
"clicked", GTK_SIGNAL_FUNC(cb_add), filew);
button = gtk_button_new_from_stock(GTK_STOCK_REMOVE);
gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->ok_button->parent),
button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(button),
"clicked", GTK_SIGNAL_FUNC(cb_remove), filew);
button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->ok_button->parent),
button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(button),
"clicked", GTK_SIGNAL_FUNC(cb_quit), filew);
/**********************************************************************/
gtk_widget_show_all(filew);
/* Hide default buttons not used by Jpilot file selector */
gtk_widget_hide(GTK_FILE_SELECTION(filew)->cancel_button);
gtk_widget_hide(GTK_FILE_SELECTION(filew)->ok_button);
install_update_clist();
gtk_main();
return EXIT_SUCCESS;
}
void import_gui(GtkWidget *main_window, GtkWidget *main_pane,
char *type_desc[], int type_int[],
int (*import_callback)(GtkWidget *parent_window,
const char *file_path, int type))
{
GtkWidget *button;
GtkWidget *vbox, *hbox;
GtkWidget *label;
char title[256];
const char *svalue;
GSList *group;
int i;
int pw, ph, px, py;
if (filew) return;
line_selected = -1;
gdk_window_get_size(main_window->window, &pw, &ph);
gdk_window_get_root_origin(main_window->window, &px, &py);
pw = gtk_paned_get_position(GTK_PANED(main_pane));
px+=40;
g_snprintf(title, sizeof(title), "%s %s", PN, _("Import"));
filew = gtk_widget_new(GTK_TYPE_FILE_SELECTION,
"type", GTK_WINDOW_TOPLEVEL,
"title", title,
NULL);
gtk_window_set_default_size(GTK_WINDOW(filew), pw, ph);
gtk_widget_set_uposition(filew, px, py);
gtk_window_set_modal(GTK_WINDOW(filew), TRUE);
gtk_window_set_transient_for(GTK_WINDOW(filew), GTK_WINDOW(main_window));
get_pref(PREF_MEMO_IMPORT_PATH, NULL, &svalue);
if (svalue && svalue[0]) {
gtk_file_selection_set_filename(GTK_FILE_SELECTION(filew), svalue);
}
glob_import_callback=import_callback;
/* Set the type to match the first button, which will be set */
glob_type_selected=type_int[0];
gtk_widget_hide((GTK_FILE_SELECTION(filew)->cancel_button));
gtk_signal_connect(GTK_OBJECT(filew), "destroy",
GTK_SIGNAL_FUNC(cb_destroy), filew);
/* Even though I hide the ok button I still want to connect its signal */
/* because a double click on the file name also calls this callback */
gtk_widget_hide(GTK_WIDGET(GTK_FILE_SELECTION(filew)->ok_button));
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filew)->ok_button),
"clicked", GTK_SIGNAL_FUNC(cb_import), filew);
label = gtk_label_new(_("To change to a hidden directory type it below and hit TAB"));
gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->main_vbox),
label, FALSE, FALSE, 0);
gtk_widget_show(label);
/* Quit/Import buttons */
button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->ok_button->parent),
button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(button),
"clicked", GTK_SIGNAL_FUNC(cb_quit), filew);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Import"));
gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->ok_button->parent),
button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(button),
"clicked", GTK_SIGNAL_FUNC(cb_import), filew);
gtk_widget_show(button);
/* File Type radio buttons */
vbox=gtk_vbox_new(FALSE, 0);
hbox=gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->action_area),
vbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
label = gtk_label_new(_("Import File Type"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
group = NULL;
for (i=0; i<MAX_IMPORT_TYPES; i++) {
if (type_desc[i]==NULL) break;
radio_types[i] = gtk_radio_button_new_with_label(group, _(type_desc[i]));
radio_file_types[i] = type_int[i];
group = gtk_radio_button_group(GTK_RADIO_BUTTON(radio_types[i]));
gtk_box_pack_start(GTK_BOX(vbox), radio_types[i], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(radio_types[i]), "clicked",
GTK_SIGNAL_FUNC(cb_type), GINT_TO_POINTER(type_int[i]));
}
radio_types[i]=NULL;
radio_file_types[i]=0;
/* This callback is for a file guess algorithm and to pre-push
* the type buttons */
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filew)->file_list),
"cursor_changed", GTK_SIGNAL_FUNC(cb_import_select_row), NULL);
gtk_widget_show_all(vbox);
gtk_widget_show(filew);
}
/*
* Import record display and choice.
* Put up the record for viewing and ask if it should be imported.
*/
int import_record_ask(GtkWidget *main_window, GtkWidget *pane,
char *text, struct CategoryAppInfo *cai,
char *old_cat_name,
int priv, int suggested_cat_num, int *new_cat_num)
{
GtkWidget *button;
GtkWidget *vbox;
GtkWidget *temp_hbox;
GtkWidget *textw;
GObject *textw_buffer;
GtkWidget *label;
GtkWidget *scrolled_window;
int pw, ph;
gint px, py;
char str[100];
char *l;
long char_set;
/* There is no support yet for changing the suggested category */
/* A menu for selecting cat to be imported into is desirable */
*new_cat_num = suggested_cat_num;
glob_import_record_ask_button_pressed = DIALOG_SAID_IMPORT_QUIT;
gdk_window_get_size(main_window->window, &pw, &ph);
gdk_window_get_root_origin(main_window->window, &px, &py);
pw = gtk_paned_get_position(GTK_PANED(pane));
px+=40;
import_record_ask_window = gtk_widget_new(GTK_TYPE_WINDOW,
"type", GTK_WINDOW_TOPLEVEL,
"title", _("Import"),
NULL);
gtk_window_set_default_size(GTK_WINDOW(import_record_ask_window), pw, ph);
gtk_widget_set_uposition(GTK_WIDGET(import_record_ask_window), px, py);
gtk_container_set_border_width(GTK_CONTAINER(import_record_ask_window), 5);
gtk_window_set_modal(GTK_WINDOW(import_record_ask_window), TRUE);
gtk_window_set_transient_for(GTK_WINDOW(import_record_ask_window), GTK_WINDOW(main_window));
gtk_signal_connect(GTK_OBJECT(import_record_ask_window), "destroy",
GTK_SIGNAL_FUNC(cb_import_record_ask_destroy),
import_record_ask_window);
vbox=gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(import_record_ask_window), vbox);
/* Private */
if (priv) {
g_snprintf(str, sizeof(str), _("Record was marked as private"));
} else {
g_snprintf(str, sizeof(str), _("Record was not marked as private"));
}
label = gtk_label_new(str);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
/* Category */
get_pref(PREF_CHAR_SET, &char_set, NULL);
l = charset_p2newj(old_cat_name, 16, char_set);
g_snprintf(str, sizeof(str), _("Category before import was: [%s]"), l);
g_free(l);
label = gtk_label_new(str);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
l = charset_p2newj(cai->name[suggested_cat_num], 16, char_set);
g_snprintf(str, sizeof(str), _("Record will be put in category [%s]"), l);
g_free(l);
label = gtk_label_new(str);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
/* Text window with scrollbar to display record */
temp_hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), temp_hbox, TRUE, TRUE, 0);
textw = gtk_text_view_new();
textw_buffer = G_OBJECT(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textw)));
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textw), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textw), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textw), GTK_WRAP_WORD);
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_set_border_width(GTK_CONTAINER(scrolled_window), 1);
gtk_container_add(GTK_CONTAINER(scrolled_window), textw);
gtk_box_pack_start_defaults(GTK_BOX(temp_hbox), scrolled_window);
if (text) {
gtk_text_buffer_set_text(GTK_TEXT_BUFFER(textw_buffer), text, -1);
}
temp_hbox = gtk_hbutton_box_new();
gtk_button_box_set_spacing(GTK_BUTTON_BOX(temp_hbox), 6);
gtk_container_set_border_width(GTK_CONTAINER(temp_hbox), 6);
gtk_box_pack_start(GTK_BOX(vbox), temp_hbox, FALSE, FALSE, 0);
/* Import button */
button = gtk_button_new_with_label(_("Import"));
gtk_box_pack_start(GTK_BOX(temp_hbox), button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(cb_import_record_ask_quit),
GINT_TO_POINTER(DIALOG_SAID_IMPORT_YES));
/* Import All button */
button = gtk_button_new_with_label(_("Import All"));
gtk_box_pack_start(GTK_BOX(temp_hbox), button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(cb_import_record_ask_quit),
GINT_TO_POINTER(DIALOG_SAID_IMPORT_ALL));
/* Skip button */
button = gtk_button_new_with_label(_("Skip"));
gtk_box_pack_start(GTK_BOX(temp_hbox), button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(cb_import_record_ask_quit),
GINT_TO_POINTER(DIALOG_SAID_IMPORT_SKIP));
/* Quit button */
button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
gtk_box_pack_start(GTK_BOX(temp_hbox), button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(cb_import_record_ask_quit),
GINT_TO_POINTER(DIALOG_SAID_IMPORT_QUIT));
gtk_widget_show_all(import_record_ask_window);
gtk_main();
return glob_import_record_ask_button_pressed;
}
static int get_language(sc_card_t *card)
{
sc_apdu_t apdu;
u8 prefs[240], *lg_value;
u8 path[] = { 0x3F, 0x00, 0xDF, 0x01, 0x40, 0x39 };
int r, i, len;
/* Get the language from the card's preferences file */
assert(card != NULL);
sc_format_apdu(card, &apdu, SC_APDU_CASE_3_SHORT, 0xA4, 0x08, 0x0C);
apdu.lc = sizeof(path);
apdu.data = path;
apdu.datalen = sizeof(path);
apdu.resplen = 0;
apdu.le = 0;
r = sc_lock(card);
if (r < 0)
goto prefs_error;
r = sc_transmit_apdu(card, &apdu);
if (r < 0) {
sc_debug(card->ctx, SC_LOG_DEBUG_NORMAL, "Select_File[prefs_file] command failed: %d\n", r);
sc_unlock(card);
goto prefs_error;
}
r = sc_check_sw(card, apdu.sw1, apdu.sw2);
if (r < 0) {
sc_debug(card->ctx, SC_LOG_DEBUG_NORMAL, "Select_File[prefs_file]: card returned %d\n", r);
sc_unlock(card);
goto prefs_error;
}
r = iso_ops->read_binary(card, 0, prefs, sizeof(prefs), 0);
sc_unlock(card);
if (r <= 0) {
sc_debug(card->ctx, SC_LOG_DEBUG_NORMAL, "Read_Binary[prefs_file] returned %d\n", r);
goto prefs_error;
}
#if 0
dumphex("Prefs: ", prefs, r);
#endif
i = get_pref(prefs, r, "[gen]", "lg", &len);
if (i <= 0 || len < 2) {
sc_debug(card->ctx, SC_LOG_DEBUG_NORMAL, "Couldn't find language in prefs file: %d\n", i);
goto prefs_error;
}
lg_value = prefs + i; /* language code(s) found, starts here */
i = 0;
while (1) {
while (i <= len - 2 && (lg_value[i] == ' ' || lg_value[i] == '|'))
i++;
if (i > len - 2)
goto prefs_error;
r = str2lang(card->ctx, lg_value + i);
if (r >= 0)
return r;
i += 2;
}
prefs_error:
/* If troubles with the card's prefs file, get the language from the OS */
#ifdef _WIN32
switch (GetUserDefaultLangID() & 0x00FF) {
case 0x13:
return LNG_DUTCH;
case 0x0C:
return LNG_FRENCH;
case 0x07:
return LNG_GERMAN;
default:
return LNG_ENG;
}
#endif
return LNG_ENG; /* default */
}
/*
* sort_order: SORT_ASCENDING | SORT_DESCENDING
* modified, deleted, private: 0 for no, 1 for yes, 2 for use prefs
*/
int get_contacts2(ContactList **contact_list, int sort_order,
int modified, int deleted, int privates, int category)
{
GList *records;
GList *temp_list;
int recs_returned, i, num;
struct Contact cont;
ContactList *temp_c_list;
long keep_modified, keep_deleted;
int keep_priv;
long char_set;
buf_rec *br;
char *buf;
pi_buffer_t pi_buf;
jp_logf(JP_LOG_DEBUG, "get_contacts2()\n");
if (modified==2) {
get_pref(PREF_SHOW_MODIFIED, &keep_modified, NULL);
} else {
keep_modified = modified;
}
if (deleted==2) {
get_pref(PREF_SHOW_DELETED, &keep_deleted, NULL);
} else {
keep_deleted = deleted;
}
if (privates==2) {
keep_priv = show_privates(GET_PRIVATES);
} else {
keep_priv = privates;
}
get_pref(PREF_CHAR_SET, &char_set, NULL);
*contact_list=NULL;
recs_returned = 0;
num = jp_read_DB_files("ContactsDB-PAdd", &records);
if (-1 == num)
return 0;
for (temp_list = records; temp_list; temp_list = temp_list->next) {
if (temp_list->data) {
br=temp_list->data;
} else {
continue;
}
if (!br->buf) {
continue;
}
if ( ((br->rt==DELETED_PALM_REC) && (!keep_deleted)) ||
((br->rt==DELETED_PC_REC) && (!keep_deleted)) ||
((br->rt==MODIFIED_PALM_REC) && (!keep_modified)) ) {
continue;
}
if ((keep_priv != SHOW_PRIVATES) &&
(br->attrib & dlpRecAttrSecret)) {
continue;
}
//#ifndef PILOT_LINK_0_12
/* This is kind of a hack to set the pi_buf directly, but its faster */
pi_buf.data = br->buf;
pi_buf.used = br->size;
pi_buf.allocated = br->size;
//num = jp_unpack_Contact(&cont, br->buf, br->size);
num = jp_unpack_Contact(&cont, &pi_buf);
//#else /* PILOT_LINK_0_12 */
// RecordBuffer = pi_buffer_new(br->size);
// memcpy(RecordBuffer->data, br->buf, br->size);
// RecordBuffer->used = br->size;
//#endif /* PILOT_LINK_0_12 */
//#ifndef PILOT_LINK_0_12
if (num <= 0) {
continue;
}
//#else /* PILOT_LINK_0_12 */
// if (jp_unpack_Contact(&cont, RecordBuffer, contact_v1) == -1) {
// pi_buffer_free(RecordBuffer);
// continue;
// }
// pi_buffer_free(RecordBuffer);
//#endif /* PILOT_LINK_0_12 */
if ( ((br->attrib & 0x0F) != category) && category != CATEGORY_ALL) {
jp_free_Contact(&cont);
continue;
}
buf = NULL;
if (char_set != CHAR_SET_LATIN1) {
for (i = 0; i < 39; i++) {
if ((cont.entry[i] != NULL) && (cont.entry[i][0] != '\0')) {
buf = charset_p2newj(cont.entry[i], -1, char_set);
if (buf) {
free(cont.entry[i]);
cont.entry[i] = buf;
}
}
}
}
temp_c_list = malloc(sizeof(ContactList));
if (!temp_c_list) {
jp_logf(JP_LOG_WARN, "get_contacts2(): %s\n", _("Out of memory"));
break;
}
memcpy(&(temp_c_list->mcont.cont), &cont, sizeof(struct Contact));
temp_c_list->app_type = CONTACTS;
temp_c_list->mcont.rt = br->rt;
temp_c_list->mcont.attrib = br->attrib;
temp_c_list->mcont.unique_id = br->unique_id;
temp_c_list->next = *contact_list;
*contact_list = temp_c_list;
recs_returned++;
}
jp_free_DB_records(&records);
contacts_sort(contact_list, sort_order);
jp_logf(JP_LOG_DEBUG, "Leaving get_contacts2()\n");
return recs_returned;
}
/*
* sort_order: SORT_ASCENDING | SORT_DESCENDING
*/
static int contacts_sort(ContactList **cl, int sort_order)
{
ContactList *temp_cl;
ContactList **sort_cl;
int count, i;
long use_jos, char_set;
/* Count the entries in the list */
for (count=0, temp_cl=*cl; temp_cl; temp_cl=temp_cl->next, count++) {}
if (count<2) {
/* No need to sort 0 or 1 items */
return EXIT_SUCCESS;
}
glob_sort_rule = addr_sort_order;
get_pref(PREF_CHAR_SET, &char_set, NULL);
if (char_set == CHAR_SET_JAPANESE || char_set == CHAR_SET_SJIS_UTF) {
glob_sort_rule = glob_sort_rule | SORT_JAPANESE;
} else {
glob_sort_rule = glob_sort_rule & (SORT_JAPANESE-1);
}
get_pref(PREF_USE_JOS, &use_jos, NULL);
if (use_jos) {
glob_sort_rule = glob_sort_rule | SORT_JOS;
} else {
glob_sort_rule = glob_sort_rule & (SORT_JOS-1);
}
/* Allocate an array to be qsorted */
sort_cl = calloc(count, sizeof(ContactList *));
if (!sort_cl) {
jp_logf(JP_LOG_WARN, "contacts_sort(): %s\n", _("Out of memory"));
return EXIT_FAILURE;
}
/* Set our array to be a list of pointers to the nodes in the linked list */
for (i=0, temp_cl=*cl; temp_cl; temp_cl=temp_cl->next, i++) {
sort_cl[i] = temp_cl;
}
/* qsort them */
qsort(sort_cl, count, sizeof(ContactList *), contact_compare);
/* Put the linked list in the order of the array */
if (sort_order==SORT_ASCENDING) {
sort_cl[count-1]->next = NULL;
for (i=count-1; i>0; i--) {
sort_cl[i-1]->next=sort_cl[i];
}
*cl = sort_cl[0];
} else {
/* Descending order */
for (i=count-1; i>0; i--) {
sort_cl[i]->next=sort_cl[i-1];
}
sort_cl[0]->next = NULL;
*cl = sort_cl[count-1];
}
free(sort_cl);
return EXIT_SUCCESS;
}
