nxaddress.cxx

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

    file_fields[0] = 32;
    SyncRegisterDB(db, cFields, CONTACTS, 1, file_fields, 1);

    // Open or Create info database
    if (!db->Open((string) INFO, &iFile, iFields, 0)) {

	if (db->Create((string) INFO, &iFile, iFields, 0)) {

	    if (!db->Open((string) INFO, &iFile, iFields, 0)) {
		exit(-1);
	    }

	    char *record1 = 0;
	    record1 = Record(0, "Home", 0);
	    db->Insert(INFO, record1);
	    delete[]record1;

	    char *record2 = 0;
	    record2 = Record(1, "Work", 0);
	    db->Insert(INFO, record2);
	    delete[]record2;

	    char *record3 = 0;
	    record3 = Record(2, "Fax", 0);
	    db->Insert(INFO, record3);
	    delete[]record3;

	    char *record4 = 0;
	    record4 = Record(3, "Mobile", 0);
	    db->Insert(INFO, record4);
	    delete[]record4;

	    char *record5 = 0;
	    record5 = Record(4, "Pager", 0);
	    db->Insert(INFO, record5);
	    delete[]record5;

	    char *record6 = 0;
	    record6 = Record(5, "E-Mail", 0);
	    db->Insert(INFO, record6);
	    delete[]record6;

	    char *record7 = 0;
	    record7 = Record(6, "Web", 0);
	    db->Insert(INFO, record7);
	    delete[]record7;

	} else {

	    exit(-1);

	}

    }
    // Register DB for Synchronization

    /* FIXME:  Temporarly commented out since crappy sync
       can't handle it (yet) */

    //SyncRegisterDB(db, iFields, INFO, 3, NULL, 0);

    // Open or Create category database
    if (!db->Open((string) CATEGORY, &catFile, catFields, 0)) {

	if (db->Create((string) CATEGORY, &catFile, catFields, 0)) {

	    if (!db->Open((string) CATEGORY, &catFile, catFields, 0)) {
		exit(-1);
	    }

	    char *record1 = 0;
	    record1 = Record(0, "Unfiled");
	    db->Insert(CATEGORY, record1);
	    delete[]record1;

	    char *record2 = 0;
	    record2 = Record(1, "Business");
	    db->Insert(CATEGORY, record2);
	    delete[]record2;

	    char *record3 = 0;
	    record3 = Record(2, "Personal");
	    db->Insert(CATEGORY, record3);
	    delete[]record3;

	} else {

	    exit(-1);

	}

    }
    // Register DB for Synchronization
    /* FIXME: Same thing - sync can't handle this DB yet */
    //SyncRegisterDB(db, catFields, CATEGORY, 0);

// Op en or Create custom fields database
    if (!db->Open((string) CUSTFIELDS, &custFile, custFields, 0)) {

	if (db->Create((string) CUSTFIELDS, &custFile, custFields, 0)) {

	    if (!db->Open((string) CUSTFIELDS, &custFile, custFields, 0)) {
		exit(-1);
	    }

	    char *record1 = 0;
	    record1 = CustRecord(0, "Custom1");
	    db->Insert(CUSTFIELDS, record1);
	    delete[]record1;

	    char *record2 = 0;
	    record2 = CustRecord(1, "Custom2");
	    db->Insert(CUSTFIELDS, record2);
	    delete[]record2;

	    char *record3 = 0;
	    record3 = CustRecord(2, "Custom3");
	    db->Insert(CUSTFIELDS, record3);
	    delete[]record3;

	    char *record4 = 0;
	    record4 = CustRecord(3, "Custom4");
	    db->Insert(CUSTFIELDS, record4);
	    delete[]record4;

	} else {

	    exit(-1);

	}

    }
    // Register DB for Synchronization

    /* FIXME:  Ditto, ditto */
    //SyncRegisterDB(db, custFields, CUSTFIELDS, 2);

    g_PasteTarget = 0;

    ////////////////////////////////////////////////////////////////////////////////
    // Instantiate ALL Windows

    main_window = new NxWindow(W_W, W_H, APP);
    make_list_window();
    make_edit_window();
    make_view_window();
    make_details_window();
    make_note_window();
    make_dellist_window();
    make_deledit_window();
    make_delview_window();
    make_lookup_window();
    make_results_window();
    make_custom_window();
    main_window->end();

    note_category = addr_list_window->category_list;
    note_category->select(category_callback);
    edit_category_list = addr_edit_window->category_list;
    edit_category_list->select(list_callback);
    view_category_list = addr_view_window->category_list;
    view_category_list->select(list_callback);

    address_pixmap = new Fl_Pixmap(address_xpm);
    table->set_image(address_pixmap, -1, 0, 1);

    cat_list[0] = note_category;
    cat_list[1] = edit_category_list;
    cat_list[2] = view_category_list;
    fill_categories();

    add_items(table, "All");
    set_catlist_window((Fl_Window *) addr_list_window->
		       GetEditCategoryWindowPtr());

    ////////////////////////////////////////////////////////////////////////////////
    // FLNX-Colosseum IPC

    set_shown_window(addr_list_window->GetWindowPtr());

#ifdef CONFIG_COLOSSEUM
    Add_Fd("nxaddress", _ClientIPCHandler);
#else
    ExecuteShow();
#endif
}

NxAddress::~NxAddress()
{
    db->Close(CONTACTS);
    db->Close(INFO);
    db->Close(CATEGORY);
    delete db;
    db = 0;
}

void
NxAddress::Refresh()
{
    set_category(view_category_list->label());
}

char *
NxAddress::strup(const char *str1, int size)
{

    char *str2 = new char[size + 1];
    memset(str2, 0, size);

    char c;

    for (int i = 0; i < size + 1; i++) {
	c = str1[i];
	str2[i] = (char) toupper(c);
    }

    return str2;

}

int
NxAddress::compar(NxTodo ** rec1, NxTodo ** rec2)
{

    NxTodo *record1 = *rec1;
    NxTodo *record2 = *rec2;

    char *cmpStr1 = strup(record1->szLastName, TEXT);
    char *cmpStr2 = strup(record2->szLastName, TEXT);

    ////////////////////////////////////////////////////////////////////////////////
    // If both lastnames exist and both lastnames are equal
    // compare off firstname.

    if ((!(cmpStr1[0] == 0) && !(cmpStr2[0] == 0))) {
	if (strcmp(cmpStr1, cmpStr2) == 0) {
	    cmpStr1 = strup(record1->szFirstName, TEXT);
	    cmpStr2 = strup(record2->szFirstName, TEXT);
	}
    }

    if (cmpStr1[0] == 0)
	cmpStr1 = strup(record1->szFirstName, TEXT);
    if (cmpStr1[0] == 0)
	cmpStr1 = strup(record1->szCompany, TEXT);

    if (cmpStr2[0] == 0)
	cmpStr2 = strup(record2->szFirstName, TEXT);
    if (cmpStr2[0] == 0)
	cmpStr2 = strup(record2->szCompany, TEXT);

    return (strcmp(cmpStr1, cmpStr2));

}

////////////////////////////////////////////////////////////////////////////////
// FLNX-Colosseum IPC Methods

#ifdef CONFIG_COLOSSEUM

void
NxAddress::ClientIPCHandler(int fd, void *o, int ipc_id)
{


    DPRINT("ClientIPCHandler(): ipc_id = %d, msg %s.\n", ipc_id, (char *) o);

    char *tokenMsg = new char[MAX_LENGTH];
    memset(tokenMsg, 0, MAX_LENGTH);
    char *passMsg = new char[MAX_LENGTH];
    memset(passMsg, 0, MAX_LENGTH);

    if (o == NULL) {

	int length = MAX_LENGTH - 1;

	printf("ClientIPCHandler(): Read_Fd() called.\n");
	DPRINT("ClientIPCHandler(): passMsg(%p), length(%p)\n", passMsg,
	       &length);
	DPRINT("ClientIPCHandler(): passMsg(%s), length(%i)\n", passMsg,
	       length);
	ipc_id = NxApp::Instance()->Read_Fd(passMsg, &length);
	printf
	    ("ClientIPCHandler(): And this is the message... %s, %d bytes.\n",
	     passMsg, length);

	if ((passMsg == NULL) || (passMsg[0] == 0))
	    return;
	else
	    strcpy(tokenMsg, passMsg);

    } else if (ipc_id == -1) {

	strcpy(tokenMsg, (char *) o);
	strcpy(passMsg, (char *) o);
	DPRINT("ClientIPCHandler(): Find Address Book ipcId.\n");
	ipc_id = NxApp::Instance()->Find_Fd("nxaddress");
	DPRINT
	    ("ClientIPCHandler(): ipc_id = %d, And this is the message... %s.\n",
	     ipc_id, passMsg);

    } else {

	strcpy(tokenMsg, (char *) o);
	strcpy(passMsg, (char *) o);

    }

    // Explode Message
    char *service = new char[MAX_LENGTH];
    char *msg_cmd = new char[MAX_LENGTH];
    char *data_item = new char[MAX_LENGTH];

    // SERVICE
    char *tmp = strtok(tokenMsg, TOKEN);
    if (NULL != tmp)
	strcpy(service, tmp);

    // MSG_CMD
    tmp = strtok(NULL, TOKEN);
    if (NULL != tmp)
	strcpy(msg_cmd, tmp);

    // DATA_ITEM
    tmp = strtok(NULL, TOKEN);
    if (NULL != tmp)
	strcpy(data_item, tmp);

    DPRINT("ClientIPCHandler(): Expoding Message... %s, %s, %s.\n", service,
	   msg_cmd, data_item);

    if (strcmp(msg_cmd, "EXECUTE") == 0) {

	if (!NxApp::Instance()->VerifyClient(service))
	    return;

	if (strcmp(data_item, "datesearch") == 0) {
	    char *msg = new char[MAX_LENGTH];
	    strcpy(msg, "nxaddress^ACK^DATA^search^");
	    DPRINT("*** Write_Fd\n");
	    NxApp::Instance()->Write_Fd(ipc_id, msg, strlen(msg));
	    delete[]msg;
	    return;
	}

	if (strcmp(data_item, "search") == 0) {

	    DPRINT("Searching %s, %s, %s\n", service, msg_cmd, data_item);

	    char *searchStr = new char[MAX_LENGTH];
	    char *width = new char[4];

	    char *data = strtok(NULL, TOKEN);
	    strcpy(searchStr, data);
	    data = strtok(NULL, TOKEN);
	    strcpy(width, data);

	    ExecuteSearch(ipc_id, searchStr, atoi(width));

	    delete[]searchStr;
	    delete[]width;
	    searchStr = width = NULL;

	}

	if (strcmp(data_item, "showrecord") == 0) {

	    int recno = 0;
	    char *data = strtok(NULL, TOKEN);

	    DPRINT("showrecord: data[%s]\n", data);
	    recno = atoi(data);
	    DPRINT("^^^^ start viewRecord\n");
	    viewRecord(recno);
	    DPRINT("^^^^ pass viewRecord\n");
	}

    }
    // Memory Mangement
    delete[]service;
    delete[]msg_cmd;
    delete[]data_item;
    delete[]tokenMsg;
    service = msg_cmd = data_item = tokenMsg = NULL;

    NxApp::Instance()->ServerIPCHandler(fd, ipc_id, (char *) passMsg);

    delete[]passMsg;
    passMsg = NULL;

}
#endif /* CONFIG_COLOSSEUM */

/* IPC is required to do a search */

#ifdef CONFIG_COLOSSEUM

void
NxAddress::ExecuteSearch(int ipc_id, char *searchStr, int width)
{

    if (searchStr == NULL)
	return;

    DPRINT("ExecuteSearch has now been started: \"%s\"\n", searchStr);

    char *searchString = new char[MAX_LENGTH];
    strcpy(searchString, searchStr);

    char *msg = new char[MAX_LENGTH];
    NxTodo *note;

    while ((note = search(searchString)) != NULL) {

	char *result = formatString(note, width);

	// Send DATA message to client
	// (e.g. "nxaddress^DATA^1^Century *Software* is neato^")

	DPRINT("ExecuteSearch has found a result.\n");

	char szId[4];
	strcpy(msg, "nxaddress^DATA^search^");
	sprintf(szId, "%d", note->nId);
	strcat(msg, szId);
	strcat(msg, "^");
	strcat(msg, result);
	strcat(msg, "^");

	DPRINT
	    ("Write_Fd ipc_id: %dnxaddress^DATA^search^ ... ExecuteSearch... %s\n",
	     ipc_id, msg);
	NxApp::Instance()->Write_Fd(ipc_id, msg, strlen(msg));

    }

    strcpy(msg, "nxaddress^ACK^DATA^search^");
    DPRINT("Write_Fd nxaddress^ACK^DATA^search^\n");
    NxApp::Instance()->Write_Fd(ipc_id, msg, strlen(msg));

    delete[]msg;
    delete[]searchString;
    msg = searchString = NULL;

}

#endif /* CONFIG_COLOSSEUM */


void
NxAddress::exit_callback(Fl_Widget * fl, void *l)
{
    exit_flag = 1;
    NxApp::Instance()->hide_all_windows();
    main_window->hide();
}

////////////////////////////////////////////////////////////////////////////////
// Database Methods

char *
NxAddress::Record(int id, int cat_id, int show_id,
		  string last_name, string first_name, string company,
		  string title, int dep1id, int dep2id, int dep3id,
		  int dep4id, int dep5id, int dep6id, int dep7id, string dep1,
		  string dep2, string dep3, string dep4, string dep5,
		  string dep6, string dep7, string address, string city,
		  string region, string postalCode, string country,
		  string bday, string anniv, string custom1, string custom2,
		  string custom3, string custom4, string note)
{

    char *rec = new char[MAXRECSIZ];
    memset(rec, 0, MAXRECSIZ);

    //char szId[ID];
    //char szCategory[ID];
    //sprintf(szId, "%d", id);
    //sprintf(szCategory, "%d", cat_id);
    //strcpy (&rec[cFields[RECNO].offset], szId);
    //strcpy (&rec[cFields[CAT].offset], szCategory);

    put16(&rec[cFields[RECNO].offset], id);
    put16(&rec[cFields[CAT].offset], cat_id);
    put16(&rec[cFields[SHOW].offset], show_id);
    strcpy(&rec[cFields[LASTNAME].offset], last_name.c_str());
    strcpy(&rec[cFields[FIRSTNAME].offset], first_name.c_str());
    strcpy(&rec[cFields[COMPANY].offset], company.c_str());
    strcpy(&rec[cFields[TITLE].offset], title.c_str());
    put16(&rec[cFields[DEP1ID].offset], dep1id);
    put16(&rec[cFields[DEP2ID].offset], dep2id);
    put16(&rec[cFields[DEP3ID].offset], dep3id);
    put16(&rec[cFields[DEP4ID].offset], dep4id);
    put16(&rec[cFields[DEP5ID].offset], dep5id);
    put16(&rec[cFields[DEP6ID].offset], dep6id);
    put16(&rec[cFields[DEP7ID].offset], dep7id);
    strcpy(&rec[cFields[DEP1].offset], dep1.c_str());
    strcpy(&rec[cFields[DEP2].offset], dep2.c_str());
    strcpy(&rec[cFields[DEP3].offset], dep3.c_str());
    strcpy(&rec[cFields[DEP4].offset], dep4.c_str());
    strcpy(&rec[cFields[DEP5].offset], dep5.c_str());
    strcpy(&rec[cFields[DEP6].offset], dep6.c_str());
    strcpy(&rec[cFields[DEP7].offset], dep7.c_str());
    strcpy(&rec[cFields[ADDRESS].offset], address.c_str());
    strcpy(&rec[cFields[CITY].offset], city.c_str());
    strcpy(&rec[cFields[REGION].offset], region.c_str());
    strcpy(&rec[cFields[POSTALCODE].offset], postalCode.c_str());
    strcpy(&rec[cFields[COUNTRY].offset], country.c_str());
    strcpy(&rec[cFields[BDAY].offset], bday.c_str());
    strcpy(&rec[cFields[ANNIV].offset], anniv.c_str());
    strcpy(&rec[cFields[CUST1].offset], custom1.c_str());
    strcpy(&rec[cFields[CUST2].offset], custom2.c_str());
    strcpy(&rec[cFields[CUST3].offset], custom3.c_str());
    strcpy(&rec[cFields[CUST4].offset], custom4.c_str());

    //cout << "Record(): note = " << note << endl;

    strcpy(&rec[cFields[NOTE].offset], note.c_str());

    return rec;

}

char *
NxAddress::Record(int infoid, string info_type, int dummy)
{

    char *rec = new char[MAXRECSIZ];

    memset(rec, 0, MAXRECSIZ);
    put16(&rec[iFields[0].offset], infoid);
    strcpy(&rec[iFields[1].offset], info_type.c_str());