TreeDrawing.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_GRAPHICS_TREEDRAWING_H
#define BPP_PHYL_GRAPHICS_TREEDRAWING_H
 
#include <Bpp/Clonable.h>
#include <Bpp/Graphics/Font/Font.h>
#include <Bpp/Graphics/GraphicDevice.h>
#include <Bpp/Graphics/Point2D.h>
 
 
// From PhylLib:
#include "../Tree/Tree.h"
 
namespace bpp
{
// Forward declarations:
class TreeDrawing;
class TreeDrawingListener;
 
class TreeDrawingSettings
{
public:
  Font fontLeafNames;
  Font fontBranchLengths;
  Font fontBootstrapValues;
  Font fontNodesId;
  unsigned int pointSize;
  double pointArea; // this specifies the radius of the point area
  // More options will be added in the future...
 
public:
  TreeDrawingSettings() :
    fontLeafNames("Courier", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12),
    fontBranchLengths("Courier", Font::STYLE_ITALIC, Font::WEIGHT_NORMAL, 10),
    fontBootstrapValues("Courier", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 10),
    fontNodesId("Courier", Font::STYLE_NORMAL, Font::WEIGHT_BOLD, 12),
    pointSize(1),
    pointArea(5)
  {}
};
 
 
class Cursor
{
private:
  double x_;
  double y_;
  double angle_;
  short hpos_;
  short vpos_;
 
public:
  Cursor(double x, double y, double angle = 0, short hpos = GraphicDevice::TEXT_HORIZONTAL_CENTER, short vpos = GraphicDevice::TEXT_VERTICAL_CENTER) :
    x_(x), y_(y), angle_(angle), hpos_(hpos), vpos_(vpos) {}
 
public:
  double getX() const { return x_; }
  double getY() const { return y_; }
  double getAngle() const { return angle_; }
  short getHPos() const { return hpos_; }
  short getVPos() const { return vpos_; }
  double addX(double increment) { return x_ += increment; }
  double addY(double increment) { return y_ += increment; }
 
  Cursor getTranslation(double x, double y) const
  {
    Cursor c = *this;
    c.addX(x);
    c.addY(y);
    return c;
  }
};
 
 
class DrawNodeEvent
{
private:
  const TreeDrawing* td_;
  GraphicDevice* gd_;
  int id_;
  Cursor cursor_;
 
public:
  DrawNodeEvent(const TreeDrawing* source, GraphicDevice* gd, int nodeId, const Cursor& cursor) :
    td_(source), gd_(gd), id_(nodeId), cursor_(cursor)
  {}
 
  DrawNodeEvent(const DrawNodeEvent& dne) :
    td_(dne.td_), gd_(dne.gd_), id_(dne.id_), cursor_(dne.cursor_)
  {}
 
  DrawNodeEvent& operator=(const DrawNodeEvent& dne)
  {
    td_     = dne.td_;
    gd_     = dne.gd_;
    id_     = dne.id_;
    cursor_ = dne.cursor_;
    return *this;
  }
 
  virtual ~DrawNodeEvent() {}
 
public:
  virtual const TreeDrawing* getTreeDrawing() const { return td_; }
  virtual GraphicDevice* getGraphicDevice() const { return gd_; }
  virtual int getNodeId() const { return id_; }
  virtual const Cursor& getCursor() const { return cursor_; }
};
 
 
class DrawBranchEvent
{
private:
  const TreeDrawing* td_;
  GraphicDevice* gd_;
  int id_;
  Cursor cursor_;
 
public:
  DrawBranchEvent(const TreeDrawing* source, GraphicDevice* gd, int nodeId, const Cursor& cursor) :
    td_(source), gd_(gd), id_(nodeId), cursor_(cursor)
  {}
 
  DrawBranchEvent(const DrawBranchEvent& dne) :
    td_(dne.td_), gd_(dne.gd_), id_(dne.id_), cursor_(dne.cursor_)
  {}
 
  DrawBranchEvent& operator=(const DrawBranchEvent& dne)
  {
    td_     = dne.td_;
    gd_     = dne.gd_;
    id_     = dne.id_;
    cursor_ = dne.cursor_;
    return *this;
  }
 
  virtual ~DrawBranchEvent() {}
 
public:
  virtual const TreeDrawing* getTreeDrawing() const { return td_; }
  virtual GraphicDevice* getGraphicDevice() const { return gd_; }
  virtual int getNodeId() const { return id_; }
  virtual const Cursor& getCursor() const { return cursor_; }
  virtual Cursor getBranchCursor(double position) const = 0;
};
 
 
class DrawTreeEvent
{
private:
  const TreeDrawing* td_;
  GraphicDevice* gd_;
 
public:
  DrawTreeEvent(const TreeDrawing* source, GraphicDevice* gd) :
    td_(source), gd_(gd)
  {}
 
  DrawTreeEvent(const DrawTreeEvent& dne) :
    td_(dne.td_), gd_(dne.gd_)
  {}
 
  DrawTreeEvent& operator=(const DrawTreeEvent& dte)
  {
    td_     = dte.td_;
    gd_     = dte.gd_;
    return *this;
  }
 
  virtual ~DrawTreeEvent() {}
 
public:
  virtual const TreeDrawing* getTreeDrawing() const { return td_; }
  virtual GraphicDevice* getGraphicDevice() const { return gd_; }
};
 
 
class TreeDrawing :
  public virtual Clonable
{
public:
  TreeDrawing() {}
  virtual ~TreeDrawing() {}
 
  TreeDrawing* clone() const = 0;
 
public:
  virtual std::string getName() const = 0;
 
  virtual bool hasTree() const = 0;
 
  virtual const Tree* getTree() const = 0;
 
  virtual void setTree(const Tree* tree) = 0;
 
  virtual void setXUnit(double xu) = 0;
 
  virtual void setYUnit(double yu) = 0;
 
  virtual double getXUnit() const = 0;
 
  virtual double getYUnit() const = 0;
 
  virtual double getWidth() const = 0;
 
  virtual double getHeight() const = 0;
 
  virtual void plot(GraphicDevice& gDevice) const = 0;
 
  virtual Point2D<double> getNodePosition(int nodeId) const = 0;
 
  virtual int getNodeAt(const Point2D<double>& position) const = 0;
 
  virtual void collapseNode(int nodeId, bool yn) = 0;
  virtual bool isNodeCollapsed(int nodeId) const = 0;
  virtual void setDisplaySettings(const TreeDrawingSettings* tds) = 0;
  virtual const TreeDrawingSettings& getDisplaySettings() const = 0;
  virtual void addTreeDrawingListener(TreeDrawingListener* listener) = 0;
 
  virtual void removeTreeDrawingListener(TreeDrawingListener* listener) = 0;
};
} // end of namespace bpp.
#endif // BPP_PHYL_GRAPHICS_TREEDRAWING_H