root/trunk/FRII/gui/MappingContainer.hh

/*
 * 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.
 *
 */

// Base class for things that contain features between two sequences. All
// subclasses must support:
//   * change notification;
//   * a basic (very simple) drawing function.
//
// See SeqcompMappingContainer.hh for a specific subclass.

#ifndef MAPPING_CONTAINER_HH
#define MAPPING_CONTAINER_HH

#include <vector>
#include <FL/Fl_Widget.H>
#include "_Canvas.hh"
#include "ColorPatch.hh"
#include "FeaturesContainer.hh"

namespace gui {
  //
  // A virtual base class for things that listen to MappingContainer changes.
  //

  class MappingContainerChanged_ {
    friend class MappingContainer;
  protected:
    virtual void notify() = 0;
    virtual ~MappingContainerChanged_() { }
  };

  //
  // A container for sequence-to-sequence mappings.
  //

  class _FeaturesToMapChangeNotify;
  class MappingContainer {
    friend class _FeaturesToMapChangeNotify;
  protected:
    Fl_Color _color;
    bool _visible;

    std::vector<MappingContainerChanged_*> _to_notify_list;

    // Responsible for notifying change listeners of a change.
    void notify_changed() {
      for (unsigned int i = 0; i < _to_notify_list.size(); i++) {
        _to_notify_list[i]->notify();
      }
    }

    MappingContainer() : _color(FL_BLACK), _visible(true) { };
  public:
    // Adds a change listener to the list.
    void add_change_listener(MappingContainerChanged_* l) {
      _to_notify_list.push_back(l);
    }

    bool visible() { return _visible; }
    void visible(bool t) { _visible = t; notify_changed(); }

    Fl_Color color() const { return _color; }
    void color(Fl_Color c) { _color = c; notify_changed(); }

    //
    // Override in subclasses.
    //

    virtual void draw_on_canvas(_Canvas * canvas, bool is_closeup = false) = 0;
    virtual ~MappingContainer() {
      for (unsigned int i = 0; i < _to_notify_list.size(); i++) {
        delete _to_notify_list[i];
      }
    }
  };

  //
  // A specific subclass that redraws Fl_Widgets.
  //

  class MappingContainerChanged_Redrawer : public MappingContainerChanged_ {
  private:
    Fl_Widget * to_redraw;
  public:
    MappingContainerChanged_Redrawer(Fl_Widget * r) : to_redraw(r) { }
    void notify() { to_redraw->redraw(); }
    ~MappingContainerChanged_Redrawer() { }
  };

  //
  // A specific class that links colors to mappings.
  //

  class ColorChangeListener_MappingContainer : public ColorChangeListener_ {
  protected:
    MappingContainer * _map;
  public:
    ColorChangeListener_MappingContainer(MappingContainer * m) {
      _map = m;
    }

    void notify(Fl_Color c) { _map->color(c); }
  };

  //
  // _FeaturesToMapChangeNotify -- take change notifications from the
  // PercentFeaturesContainer and pass them to the MappingContainer class.
  //

  class _FeaturesToMapChangeNotify : public FeaturesContainerChanged_ {
  private:
    MappingContainer * map; // the map to be notified
  public:
    // constructor -- store the map
    _FeaturesToMapChangeNotify(MappingContainer* m) { map = m; }

    // notify() -- notify the map of the change.
    void notify() { map->notify_changed(); }
  };
}

#endif // MAPPING_CONTAINER_HH