root/trunk/FRII/gui/AlignedPairSequenceView.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 <iostream>
#include "AlignedPairSequenceView.hh"
#include "math.h"

#define ARROW_SCROLL_BY 5

using namespace gui;

AlignedPairSequenceView::AlignedPairSequenceView(int _x, int _y,
                                                 unsigned int _w,
                                                 std::string top_aln,
                                                 std::string bot_aln) :
  SequenceView(_x, _y, _w, height, top_aln.length()), 
  _top_aln(top_aln), _bot_aln(bot_aln)
{
  // get character width
  fl_font(FL_COURIER, font_size);
  ch_width = fl_width('A');

  set_visible_bases(0, 50);
  fgcolor(FL_RED);
}

//
// _resize_view -- make sure that the view size is sensible.
//

void AlignedPairSequenceView::_resize_view(unsigned int& start,
                                           unsigned int& end)
{
  int new_start, new_end;

  // width of drawing field, in characters
  unsigned int half_draw_width = (unsigned int) \
                    ((float)get_width() / ch_width / 2.);

#ifdef _DEBUG_TEXT_DRAW
  printf("half draw width: %d\n", half_draw_width);
#endif // _DEBUG_TEXT_DRAW

  //
  // pick the substring to draw:
  //

  new_start = start;
  new_end = end;

  new_end = new_start + 2*half_draw_width;
  if ((unsigned int) new_end >= _top_aln.length()) {
    new_end = _top_aln.length();
    new_start = new_end - 2*half_draw_width;

    if (new_start < 0) { new_start = 0; }
  }

  start = new_start;
  end = new_end;
}

void AlignedPairSequenceView::draw()
{
  // clear any overlay...
  fl_overlay_clear();

  // draw background
  fl_color(color());
  fl_rectf(x(), y(), w(), h());

  fl_push_clip(x(), y(), w(), h());

  fl_font(FL_COURIER, font_size);
  fl_color(_fg_color);

  // draw the two strings centered vertically.
  int y_pos_a = height / 2 + fl_descent() + y() - fl_height();
  int y_pos_b = height / 2 + fl_descent() + y() + 6;

  std::string sub = _top_aln.substr(_start, _end - _start);
  fl_draw(sub.c_str(), border, y_pos_a);

  sub = _bot_aln.substr(_start, _end - _start);
  fl_draw(sub.c_str(), border, y_pos_b);

  //
  // Now draw features.
  //

  FeaturesContainer * c;
  const FeatureList * list;
  Fl_Color color;
  char tmp[5000];
  assert((_end - _start) < 4999); // put an absurd upper bound on things.

  for (unsigned int i = 0; i < _featureLists.size(); i++) {
    c = _featureLists[i];

    if (!c->visible()) { continue; }

    list = c->getFeatureList();
    color = c->color();

    fl_color(color);

    for (unsigned int j = 0; j < list->n_features(); j++) {
      const Feature * f;

      f = list->get(j);
      if (f->start < _end && f->end > _start) { // draw it
        int start_base = f->start > _start ? f->start : _start;
        int end_base = f->end < _end ? f->end : _end;

        // figure out where to start it!
        std::string tst = sub.substr(0, start_base - _start);

        int w = 0, h = 0;
        fl_measure(tst.c_str(), w, h); // width --> w

        // get new substr
        int len = end_base - start_base;
        strncpy(tmp, _top_aln.c_str() + start_base, len);
        tmp[len] = 0;

        // now draw!
        fl_draw(tmp, border + w, y_pos_a);

        strncpy(tmp, _bot_aln.c_str() + start_base, len);
        tmp[len] = 0;
        fl_draw(tmp, border + w, y_pos_b);
      }
    }
  }  

  // handle other stuff: labels.
  draw_labels();

  fl_pop_clip();

  return;
}

//
// handle -- deal with events
//

int AlignedPairSequenceView::handle(int event)
{
  int key, ret;

  switch(event) {
  case FL_FOCUS:
  case FL_UNFOCUS:
    return 1;
  case FL_KEYDOWN:              // scroll left/right given arrow key.
    key = Fl::event_key();
    if (key == FL_Left) {
      scroll_left(ARROW_SCROLL_BY);
      ret = 1;
    } else if (key == FL_Right) {
      scroll_right(ARROW_SCROLL_BY);
      ret = 1;
    }
    break;
  default:
    // pass the event on up the widget stack.
    ret = Fl_Widget::handle(event);
  }
  return ret;
}

//
// base_to_pos -- convert base coordinates to canvas positions.
//

unsigned int AlignedPairSequenceView::base_to_pos(int base)
{
  float seq_width = (_end - _start);
  float canvas_width = (float) get_width();

  base = constrain_base(base);

  float convert = canvas_width / seq_width * (float) (base - _start);

  return (int) (convert + border + (ch_width / 2.) + 0.5);
}

//
// pos_to_base -- convert canvas positions to base locations.
//

unsigned int AlignedPairSequenceView::pos_to_base(int pos)
{
  float seq_width = (_end - _start);
  float canvas_width = w() - 2*border;

  if (pos < (int) border) pos = border;
  float convert = seq_width / canvas_width * (float) (pos - border - ch_width);

  return constrain_base((int) (convert + _start + 0.5));
}

//
// get_left -- get the left-most part of the sequence line
//

unsigned int AlignedPairSequenceView::get_left()
{
  return x() + border;
}

//
// get_width -- get the width of the sequence line
//

unsigned int AlignedPairSequenceView::get_width()
{
  return w() - 2*border;
}

//
// get_mid -- get the midline of the sequence line.
//

unsigned int AlignedPairSequenceView::get_mid()
{
  return (unsigned int) (y() + ((float)(h() / 2.) + .5));
}

//
// draw_labels -- draw start/end labels.
//

void AlignedPairSequenceView::draw_labels()
{
  fl_color(FL_BLACK);
  fl_font(FL_TIMES, 2*half_label_height);

  std::string left, right;
  _round_coords_for_display(left, right);

  // left label
  fl_draw((const char *)left.c_str(),
          x(),
          get_mid() - half_label_height + 4, label_width,
          2*half_label_height, FL_ALIGN_CENTER);

  // right label
  fl_draw((const char*)right.c_str(),
          x() + w() - border,
          get_mid() - half_label_height + 6, label_width,
          2*half_label_height, FL_ALIGN_CENTER);
  
}

void AlignedPairSequenceView::scroll_left(unsigned int n)
{
  if (_start != 0) {
    if (_start >= n) {
      _start -= n;
    } else {
      _start = 0;
    }
    notify_view();
    _resize_view(_start, _end);
    redraw();
  }
}

void AlignedPairSequenceView::scroll_right(unsigned int n)
{
  _start += n;
  _resize_view(_start, _end);
  notify_view();
  redraw();
}