root/trunk/FRII/cartwheel-interface/ParsedBlastPairwiseAnalysis.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.
 *
 */

#include <assert.h>
#include "ParsedBlastPairwiseAnalysis.hh"
#include "BlastThresholdSlider.hh"
#include "AlignmentCloseupView.hh"

#define DEFAULT_BLAST_THRESHOLD 1e-6

#include <FL/Fl_Pack.H>
#include <FL/Fl_Button.H>
#include <FL/Fl_Check_Button.H>

#include "TextLabel.hh"
#include "ColorPatch.hh"

#include "PercentFeaturesContainer.hh"

// sole constructor.

ParsedBlastPairwiseAnalysis::ParsedBlastPairwiseAnalysis(iff::FeatureList * fl,
                                                         gui::MappingView * v)
{
  _view = v;

  name = fl->name();

  //
  // transfer all of the features into a BlastFeaturesContainer.
  //

  std::vector<gui::BlastFeature*> new_features;

  for (unsigned int j = 0; j < fl->n_features(); j++) {
    iff::Feature * iff_f = fl->get(j);
    gui::BlastFeature * f = new gui::BlastFeature(iff_f->start(),
                                                  iff_f->end(),
                                                  iff_f->orientation(),
                                                  iff_f->score());

    // add info
    f->add_information(iff_f->information());

    // put in the pair-match stuff.
    iff::Feature * other_iff_f = iff_f->pair_match();
    assert(other_iff_f);

    f->other(other_iff_f->start(), other_iff_f->end());

    std::string a, b;
    a = iff_f->get_aln();
    b = other_iff_f->get_aln();
    if (a.length() && b.length()) {
      assert(a.length() == b.length());

      f->set_alignment(a, b);
    }

    new_features.push_back(f);
  }

  float initial_threshold = DEFAULT_BLAST_THRESHOLD;
  std::string iff_threshold = fl->initial_threshold();
  if (iff_threshold.length()) {
    initial_threshold = atof(iff_threshold.c_str());
  }

  _blast_features = new gui::BlastFeaturesContainer(new_features,
                                                    initial_threshold);

  _map_cont = new gui::BlastMappingContainer(_blast_features);
}

static void map_show_toggle_cb(Fl_Widget * w, void * p)
{
  gui::MappingContainer * map = (gui::MappingContainer *) p;
  Fl_Button * b = (Fl_Button *) w;

  map->visible(b->value());
}

// class to contain passthrough data for the view alignments callback.
class alignment_closeup_passthru {
public:
  const gui::BlastMappingContainer * map;
  const gui::MappingView * view;
  const std::string name;
  alignment_closeup_passthru(gui::BlastMappingContainer * m,
                             gui::MappingView * v,
                             std::string n) 
    : map(m), view(v), name(n) { };
};

// callback function for "view alignment" button on simple pairwise views:

static void alignment_closeup_cb(Fl_Widget * w, void * p)
{
  alignment_closeup_passthru * container = (alignment_closeup_passthru *)p;

  // extract stuff from the passthru data
  const gui::MappingView * view = container->view;
  const gui::BlastMappingContainer * map = container->map;
  const std::string name = container->name;

  gui::SimpleMappingContainer * simple;
  simple = new gui::SimpleMappingContainer(map->get_features_container()->copy_me());

  AlignmentCloseupView * new_view = new \
    AlignmentCloseupView(simple, view, 600, 600);

  std::string label = "Close-up of BLAST matches from '" + name + "'";
  new_view->label(label.c_str());

  new_view->show();
}

void ParsedBlastPairwiseAnalysis::add_control_panel(Fl_Group * container,
                                                    int &x, int &y,
                                                    const int width)
{
  const unsigned int height = 30;
  const int start_y = y;

  gui::TextLabel * label = new gui::TextLabel(x + 5, y + 5, width - 10, height, name.c_str());
  label->bold(true);
  label->box(FL_DOWN_BOX);
  y += height + 10;
  
  gui::BlastThresholdSlider * slider;
  slider = new gui::BlastThresholdSlider(x + 5, y + 5, width - 10, height, 1,
                                         _blast_features);

  y += height + 10;

  //
  // add a 'view alignments' button.
  //

  Fl_Button * b = NULL;
  if (_blast_features->contains_alignments()) {
    b = new Fl_Button(x + 15, y + 5, 120, 25, "View alignments...");
  
    b->color(FL_WHITE);
    b->labelsize(12);
    b->callback(alignment_closeup_cb,
                new alignment_closeup_passthru(_map_cont, _view, name));
    y += height + 10;
  }

  //
  // add a display toggle.
  //

  Fl_Pack * p = new Fl_Pack(x + 5, y + 5, width, height);

  Fl_Check_Button * check_b = new Fl_Check_Button(x + 5, y + 5, width - 10,
                                                  height);
  check_b->callback(map_show_toggle_cb, _map_cont);
  check_b->label("show comparison");
  check_b->value(1);
  p->add(check_b);

  y += height + 10;

  // finally, add a color patch.
  gui::TextLabel * cl = new gui::TextLabel(x + 5,
                                           y + 5, (width - 10) / 2,
                                           30, "Set color:");
  gui::ColorPatch * c = new gui::ColorPatch(x + 5 + (width - 10) / 2,
                                            y + 5, (width - 10) / 2,
                                            height,
                                            _map_cont->color());

  gui::ColorChangeListener_MappingContainer * listener = new
    gui::ColorChangeListener_MappingContainer(_map_cont);
      
  c->add_change_listener(listener);

  y += height + 10;

  Fl_Box * surround = new Fl_Box(x, start_y, width, y - start_y);
  surround->box(FL_DOWN_BOX);
  surround->color(FL_WHITE);
  container->add(surround);

  container->add(label);
  container->add(slider);
  if (b) {
    container->add(b);
  }
  container->add(p);
  container->add(cl);
  container->add(c);
}