root/trunk/FRII/cartwheel-interface/CanalPopulator.cc

/*
 * This file is part of the FamilyRelations II source distribution.
 *
 * FamilyRelations II is part of the FamilyJewels package for comparative
 * sequence analysis: http://family.caltech.edu/.
 *
 * Contact author: C. Titus Brown, titus@caltech.edu.
 *
 * This program and all associated source code files are Copyright (C) 2003,
 * 2004 the California Institute of Technology, Pasadena, CA, 91125 USA.  It
 * is under the Lesser GNU Public License; please see the included
 * LICENSE.txt file for more information, or contact Titus directly.
 *
 */

// Implementation file for a collection of classes that link 'Fl_Toggle_Tree's
// to a Cartwheel analysis server (canal) via the canal XML-RPC API.

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include <xmlrpcAPI.hh>         // cartwheel-clients/canal.c++

#include "load_sister.hh"
#include <iff.hh>               // cartwheel-clients/sister.c++
#include <sister.hh>            // cartwheel-clients/sister.c++

#include <FL/Fl_Box.H>
#include "../ext/flek/Fl_Toggle_Tree.H"
#include "CanalPopulator.hh"
#include "load_canal.hh"

using namespace canal;

class waiting_box : public Fl_Box {
protected:
  void draw() {
    fl_color(FL_WHITE);
    fl_rectf(x(), y(), w(), h());
    fl_color(FL_BLACK);
    fl_font(FL_TIMES, 15);

    fl_draw("Loading... please wait.", w() / 2, h() / 2, 0, 0, FL_ALIGN_CENTER);
    
  }
public:
  waiting_box(int _x, int _y, int _w, int _h) : Fl_Box(FL_THIN_DOWN_FRAME, _x, _y, _w, _h, "Waiting...") { }

};

//
// AnalysisGroupOpener
//

class AnalysisGroupOpener : public CanalPopulator {
protected:
  xmlrpcAnalysisGroup * group;
  xmlrpcFolder * parent;
  int group_id;
public:
  AnalysisGroupOpener(Fl_Toggle_Tree* t, Fl_Toggle_Node* n,
                      xmlrpcFolder * p, int id) : CanalPopulator(t, n) {
    parent = p;
    group = NULL;
    group_id = id;
  };

  //
  // open -- when called, grab the analysis data & call the appropriate
  //    loading function.
  //

  void open() {
    if (group == NULL) {
      group = (xmlrpcAnalysisGroup *) parent->get_analysis_group(group_id);
    }

    std::string type = group->get_type();
    std::string buf;
    Fl_Window * top_chooser = (Fl_Window *) tree->user_data();

    if (type == "single") {
      top_chooser->hide();
      Fl::wait(.1);             // give the event loop a chance to hide the win

      // bring up a "waiting" window...
      Fl_Window w(150, 50, "");
      waiting_box b(0, 0, 150, 50);
      w.end();

      w.show();
      Fl::wait(.1);
      Fl::wait(.1);
      Fl::wait(.1);
      Fl::wait(.1);
      
      printf("Loading sister XML...\n");
      buf = group->get_sister_xml(true);

      printf("Parsing...\n");
      iff::SingleAnalysisGroup * g;
      g = (iff::SingleAnalysisGroup*) sister::parse_buf(buf);

      printf("Creating gui...\n");
      load_single(g, this->tree->window());

      w.hide();
      Fl::wait(.1);
    } else if (type == "pair") {
      top_chooser->hide();
      Fl::wait(.1);             // give the event loop a chance to hide the win

      // bring up a "waiting" window...
      Fl_Window w(150, 50, "");
      waiting_box b(0, 0, 150, 50);
      w.end();

      w.show();
      Fl::wait(.1);
      Fl::wait(.1);
      Fl::wait(.1);
      Fl::wait(.1);
      
      printf("Loading sister XML...\n");
      buf = group->get_sister_xml(true);

      printf("Parsing...\n");
      iff::PairAnalysisGroup * g;
      g = (iff::PairAnalysisGroup*) sister::parse_buf(buf);

      printf("Creating gui...\n");
      load_pair(g, this->tree->window());

      w.hide();
    } else if (type == "triple") {
      top_chooser->hide();
      Fl::wait(.1);             // give the event loop a chance to hide the win

      // bring up a "waiting" window...
      Fl_Window w(150, 50, "");
      waiting_box b(0, 0, 150, 50);
      w.end();

      w.show();
      Fl::wait(.1);
      Fl::wait(.1);
      Fl::wait(.1);
      Fl::wait(.1);
      
      printf("Loading triple comparison...\n");

      xmlrpcAnalysisGroup * g = (xmlrpcAnalysisGroup *) group;
      xmlrpcTripleAnalysisGroup * triple = g->get_as_triple_analysis_group();

      printf("Creating gui...\n");

      bool success = load_triple(triple, this->tree->window());

      w.hide();
      if (!success) {
        top_chooser->show();
      }
    } else {
      printf("unknown type: %s.  ignoring.\n", type.c_str());
    }
  }
};

//
// FolderListPopulator
//

class FolderListPopulator : public CanalPopulator {
protected:
  xmlrpcFolder * parent;
  xmlrpcFolder * folder;
  int folder_id;
  bool parent_is_lab;
public:
  FolderListPopulator(Fl_Toggle_Tree* t, Fl_Toggle_Node* n, xmlrpcFolder* p, int id, bool p_is_lab=false) :
    CanalPopulator(t, n) {
    parent = p;
    folder = NULL;
    folder_id = id;
    parent_is_lab = p_is_lab;
  }

  void populate() {
    if (folder == NULL) {
      if (parent_is_lab) {      // @CTB hack hack hack
        folder = (xmlrpcFolder *) ((xmlrpcLab *)parent)->get_folder(folder_id);
      } else {
        folder = (xmlrpcFolder *) parent->get_folder(folder_id);
      }
    }

    if (!_did_populate) {
      if (folder->get_type() == "leaf") {
        Fl_Toggle_Node* new_node;
        CanalPopulator * p;

        _did_populate = true;
        tree->traverse_start(node);

        IdNamePairList* groups = folder->get_analysis_group_list();
        for (unsigned int i = 0; i < groups->size(); i++) {
          int id = groups->at(i).id();
          std::string n = groups->at(i).name();
          
          new_node = tree->add_sub((char *)n.c_str(), 0, fileSmall);
          p = new AnalysisGroupOpener(tree, new_node, folder, id);
          new_node->user_data(p);
          tree->close(new_node);
          tree->traverse_up();
        }
      } else {
        Fl_Toggle_Node* new_node;

        _did_populate = true;
        tree->traverse_start(node);

        IdNamePairList* folders = folder->get_folder_list();
        for (unsigned int i = 0; i < folders->size(); i++) {
          int id = folders->at(i).id();
          std::string n = folders->at(i).name();

          new_node = tree->add_sub((char *)n.c_str(), 1, folderSmall);
          new_node->user_data(new FolderListPopulator(tree, new_node, folder, id));
          tree->close(new_node);
          tree->traverse_up();
        }
      }

      tree->sort_tree(Fl_Toggle_Tree::sort_by_label);
      tree->redraw();
    }
  }
};

//
// LabTopFolderListPopulator
//

class LabTopFolderListPopulator : public CanalPopulator {
protected:
  xmlrpcLab * lab;
public:
  LabTopFolderListPopulator(Fl_Toggle_Tree* t, Fl_Toggle_Node* n, xmlrpcLab* l) :
    CanalPopulator(t, n) {
    lab = l;
  }

  void populate() {
    if (!_did_populate) {
      Fl_Toggle_Node* new_node;

      _did_populate = true;
      tree->traverse_start(node);

      IdNamePairList* folders = lab->get_folder_list();
      for (unsigned int i = 0; i < folders->size(); i++) {
        int id = folders->at(i).id();
        std::string n = folders->at(i).name();

        new_node = tree->add_sub((char *)n.c_str(), 1, folderSmall);
        
        new_node->user_data(new FolderListPopulator(tree, new_node, (xmlrpcFolder *) lab, id, true));

        tree->close(new_node);
        tree->traverse_up();
      }
      tree->sort_tree(Fl_Toggle_Tree::sort_by_label);
      tree->redraw();
    }
  }
};

//
// LabListPopulator
//

void LabListPopulator::populate() {
  if (!_did_populate) {
    xmlrpcLab * lab, * current;
    CanalPopulator * p;
    Fl_Toggle_Node * new_node;
    
    _did_populate = true;
    tree->traverse_start(node);

    current = (xmlrpcLab *) api->get_current_lab();

    IdNamePairList* labs = api->get_lab_list();
    for (unsigned int i = 0; i < labs->size(); i++) {
      int id = labs->at(i).id();
      std::string n = labs->at(i).name();
      lab = (xmlrpcLab*) api->get_lab(id);

      new_node = tree->add_sub((char *)n.c_str(), 1, folderSmall);
      p = new LabTopFolderListPopulator(tree,new_node,lab);
      new_node->user_data(p);

      // leave the current lab open & populate it
      if (current->id() != id) {
        tree->close(new_node);
      } else {
        p->populate();
      }
      tree->traverse_up();
    }
    tree->sort_tree(Fl_Toggle_Tree::sort_by_label);
    tree->redraw();
  }
}