sync_ui.cxx

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

	abortButton->hide();
	okButton->show();
	first_app = true;

	printf("STATE -> SYNC_WAIT\n");
	pThis->syncState = SYNC_WAIT;
	return;
      }
      
      printf("STATE -> SYNC_CONNECT\n");
      pThis->syncState = SYNC_CONNECT;
      break;

    case SYNC_CONNECT:
      break;           
      
    case SYNC_START: {
      char *service = pThis->get_next_app();

      printf("~~~ SYNCING [%s] ~~~~\n", service);
      if (service) {
	pThis->sync(service);
	printf("STATE -> SYNC_PENDING\n");
	pThis->syncState = SYNC_PENDING;
	break;
      }
      else {
	sprintf(msg, "Synchronization complete");
	statusMsg->value(msg);

	printf("STATE -> SYNC_DISCONNECT\n");
	pThis->syncState = SYNC_DISCONNECT;
	abortButton->hide();
	okButton->show();

	first_app = true;
	break;
      }
    }

    case SYNC_EXE:
      //if (pThis->msgState == SYNC_EXE)
      pThis->send_update_status(pThis->cur_app);

      timeout = 0.3;
      return;

    case SYNC_ERROR:
      printf("ERROR! ERROR! ERROR!\n");
      pThis->sync_error();
      printf("STATE -> SYNC_DISCONNECT\n");
      pThis->syncState = SYNC_DISCONNECT;
      break;

    case SYNC_ABORT:
      printf("ABORT! ABORT! ABORT!\n");
      pThis->sync_abort();
      printf("STATE -> SYNC_DISCONNECT\n");
      pThis->syncState = SYNC_DISCONNECT;
      break;

    case SYNC_DONE:
      printf("STATE -> SYNC_START\n");
      pThis->syncState = SYNC_START;  /* Start the next one */
      break;

    case SYNC_DISCONNECT:
      printf("DISCONNECTING AGENT\n");
      pThis->agent_disconnect();
      printf("STATE -> SYNC_WAIT\n");
      pThis->syncState = SYNC_WAIT;
      return;
    }

    Fl::add_timeout(timeout, timer_callback);
}

int
Sync::begin_app()
{


    char *msg = new char[CL_MAX_MSG_LEN];

    strcpy(msg,
	   coder.BeginPimSync(((SyncData *) curNode->user_data())->nxAppName).
	   c_str());
    cur_app = ((SyncData *) curNode->user_data())->nxAppName;
    DPRINT("begin_app [%s]\n", cur_app.c_str());

    //int ret = Write_Fd(sync_id, msg, strlen(msg));
    int ret = 100;

    delete[]msg;
    msg = 0;

    return ret;
}

int
Sync::initiate_sync()
{
  printf("---- initiate_sync() ----\n");

  int ret = 0;
  
  ret = start_app();
  if (ret <= 0) return -1;
    
  DPRINT("initiate_sync() sync_id [%d]\n", sync_id);
    
  char *msg = new char[CL_MAX_MSG_LEN];
  sprintf(msg, "nxsync^INITIATE^0^");
  ret = Write_Fd(sync_id, msg, strlen(msg));

  if (ret < 0) 
    do_error("Unable to initiate sync!");

  delete[]msg;
  msg = 0;

  printf(" ---- return %d ----\n", ret);
  return ret;
}

int
Sync::start_sync()
{

  printf("---- start_sync() ----\n");

  char *msg = new char[CL_MAX_MSG_LEN];

  strcpy(msg,
	 coder.BeginSync(((SyncData *) curNode->user_data())->nxAppName).
	 c_str());
  
  //msgState = SYNC_START;
  
  int ret = Write_Fd(sync_id, msg, strlen(msg));

  delete[]msg;
  msg = 0;
  return ret;
}

void
Sync::sync(char *service)
{

    char msg[255];
    int ret = 0;

    DPRINT("sync() [%s]\n", service);
    if (first_app == false) {
	first_app = true;
	DPRINT("service [%s]\n", service);
	statusMsg->value("Starting Synchronization");
	statusMsg->redraw();
	//statusSlider->value(0.0);
	//statusSlider->redraw();
	sprintf(msg, "Synchronizing %s",
		((SyncData *) curNode->user_data())->appName);
	ret = initiate_sync();
	DPRINT("initiate_sync() ret [%d]\n", ret);
	if (0 > ret) {
	    return;
	}
	ret = start_sync();
	if (0 != ret) {
	    DPRINT("Unable to start!\n");
	    do_error("Unable to start!");
	    return;
	};
	statusMsg->value(msg);
	statusMsg->redraw();
	DPRINT("Fisrt app is FALSE\n");
	begin_app();
    } else {
      //statusSlider->value(0.0);
      //statusSlider->redraw();
	sprintf(msg, "Synchronizing %s",
		((SyncData *) curNode->user_data())->appName);
	DPRINT("first_app is true\n");
	ret = initiate_sync();
	DPRINT("initiate_sync() ret [%d]\n", ret);
	if (0 > ret) {
	    return;
	}
	ret = start_sync();
	if (0 != ret) {
	    DPRINT("Unable to start sync!\n");
	    do_error("Unable to start sync!");
	    return;
	};
	begin_app();
    }
}

void
Sync::sync_abort()
{
    string msg = coder.Abort();

    Write_Fd(sync_id, (char *) msg.c_str(), msg.length());
}

void
Sync::sync_error()
{
    // recover from error
    DPRINT("need to send error to sync agent\n");
}

int
Sync::send_update_status(string app_id)
{
    static double s_value = 0;
    s_value += 10;
    //statusSlider->value(s_value);
    if (s_value >= 100)
	s_value = 0;
    //statusSlider->redraw();
}

void
Sync::update_error(vector < string > &vmessages)
{
    DPRINT("should do update_error!\n");
}

void
Sync::get_update_status(vector < string > &vmessages)
{
    DPRINT("Get Update Status start\n");
    //get sync status
    double value = 0;
    static double slider_value = 0;
    string svalue;
    char msg[CL_MAX_MSG_LEN];

    svalue = vmessages[2];
    value = strtod(svalue.c_str(), NULL);
    DPRINT("Set value to [%s]\n", svalue.c_str());
    slider_value += 25;
    //statusSlider->value(slider_value);
    if (slider_value >= 100)
	slider_value = 0;
    //statusSlider->redraw();
    if (value >= 100) {
	DPRINT("Set syncState SYNC_DONE\n");
	//statusSlider->value(value);
	//statusSlider->redraw();
	printf("STATE -> SYNC_DONE\n");
	syncState = SYNC_DONE;
	//msgState = SYNC_DONE;
	sprintf(msg, "%s Synchronization Complete",
		((SyncData *) curNode->user_data())->appName);
	statusMsg->value(msg);
	//strcpy(msg, coder.EndSync(((SyncData*)curNode->user_data())->nxAppName).c_str());
	//ret = Write_Fd(sync_id, msg, strlen(msg));
    }
}

int
Sync::start_app()
{

  printf("---- start_app() ----\n");
  string msg;
  
  msg = "Synchronizing ";
  msg.append(((SyncData *) curNode->user_data())->appName);
  
  statusMsg->value(msg.c_str());
  sync_id = StartApp(((SyncData *) curNode->user_data())->nxAppName, 0, 2);

  DPRINT("start_app() sync_id [%d]\n", sync_id);
  
  if (sync_id < 0) {
    msg = "Unable to start ";
    msg.append(((SyncData *) curNode->user_data())->appName);
    do_error(msg);
  }
 
  printf("---- return %d ----\n", sync_id);
  return sync_id;
}

char *
Sync::get_next_app()
{

    if (NULL == curNode)
	curNode = syncTree->traverse_start();
    else
	curNode = syncTree->traverse_forward();

    while (curNode) {
	if (true == ((SyncData *) curNode->user_data())->appSync)
	    return ((SyncData *) curNode->user_data())->nxAppName;
	else
	    curNode = syncTree->traverse_forward();
    }
    return NULL;
}

void
Sync::checkIt_callback(Fl_Widget * fl, void *l)
{

    Fl_Toggle_Node *node = syncTree->selected();

    if (node) {
	if ((Fl::event_x() >= 17) && (Fl::event_x() <= 29)) {
	    syncTree->unselect();
	    if (node->pixmap() == echeckPixmap) {
		((SyncData *) node->user_data())->appSync = true;
		node->pixmap(checkPixmap);
	    } else if (node->pixmap() == checkPixmap) {
		((SyncData *) node->user_data())->appSync = false;
		node->pixmap(echeckPixmap);
	    }
	}
    }
    if (syncTree->selection_count() > 0)
	syncTree->unselect();
}

void
Sync::exit_callback(Fl_Widget * fl, void *l)
{

    mainWindow->hide();
    exit(0);
}

Fl_Window *
Sync::get_main_window()
{
    if (mainWindow)
	return mainWindow;
    else
	return 0;
}

void
Sync::show_default_window()
{
    show_window(syncWindow->GetWindowPtr());
}

void
Sync::do_error(string err)
{
  if (err.c_str()) 
    statusMsg->value(err.c_str());
  
  statusMsg->redraw();
  abortButton->do_callback();
  printf("STATE -> SYNC_ERROR\n");
  syncState = SYNC_ERROR;
  
  first_app = false;
}

void
Sync::do_abort(void)
{
  printf("**** ABORTING ****\n");

  statusMsg->value("Synchronization aborted");
  statusMsg->redraw();

  abortButton->do_callback();
  printf("STATE -> SYNC_ABORT\n");
  syncState = SYNC_ABORT;

  first_app = false;
}

void
Sync::add_apps(Fl_Toggle_Tree * syncTree)
{

    int size;
    int count, i;

    db_handle *db;
    char *searchList, *l;

    db = db_openDB(db_getDefaultDB(), PAR_DB_MODE_RDONLY);

    if (!db) {
	printf("Error - Couldn't open the par database %s\n",
	       db_getDefaultDB());
	return;
    }
    //FIXME this may need to be changed!
    size = par_getCapability(db, "nxsync", (void **) &searchList);

    if (size <= 0) {
	db_closeDB(db);
	return;
    }

    count = par_getStringListCount(searchList, ' ');
    l = searchList;

    for (i = 0; i < count; i++) {
	Fl_Toggle_Node *appNode;
	char title[50];

	char *application = par_parseStringList(&l, ' ');

	if (par_getAppTitle(db, application, title, sizeof(title)) <= 0)
	    continue;

	appNode = syncTree->add_next(title, 0, echeckPixmap);

	if (appNode) {
	    SyncData *data = new SyncData;
	    strcpy(data->appName, title);
	    strcpy(data->nxAppName, application);
	    data->appSync = false;
	    appNode->user_data(data);
	    syncTree->traverse_up();
	}
    }
    db_closeDB(db);

}