TreeDrawingListener.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_GRAPHICS_TREEDRAWINGLISTENER_H
#define BPP_PHYL_GRAPHICS_TREEDRAWINGLISTENER_H
 
#include <Bpp/Clonable.h>
 
#include "TreeDrawing.h"
 
namespace bpp
{
class TreeDrawingListener :
  public virtual Clonable
{
public:
  TreeDrawingListener* clone() const = 0;
 
  virtual void beforeDrawTree(const DrawTreeEvent& event) = 0;
  virtual void afterDrawTree(const DrawTreeEvent& event) = 0;
  virtual void beforeDrawNode(const DrawNodeEvent& event) = 0;
  virtual void afterDrawNode(const DrawNodeEvent& event) = 0;
  virtual void beforeDrawBranch(const DrawBranchEvent& event) = 0;
  virtual void afterDrawBranch(const DrawBranchEvent& event) = 0;
 
  virtual bool isAutonomous() const = 0;
 
  virtual bool isEnabled() const = 0;
  virtual void enable(bool tf) = 0;
};
 
 
class TreeDrawingListenerAdapter :
  public virtual TreeDrawingListener
{
private:
  bool autonomous_;
  bool enabled_;
 
public:
  TreeDrawingListenerAdapter(bool autonomous) : autonomous_(autonomous), enabled_(true) {}
 
public:
  void beforeDrawTree(const DrawTreeEvent& event) {}
  void afterDrawTree(const DrawTreeEvent& event) {}
  void beforeDrawNode(const DrawNodeEvent& event) {}
  void afterDrawNode(const DrawNodeEvent& event) {}
  void beforeDrawBranch(const DrawBranchEvent& event) {}
  void afterDrawBranch(const DrawBranchEvent& event) {}
  bool isAutonomous() const { return autonomous_; }
  bool isEnabled() const { return enabled_; }
  void enable(bool tf) { enabled_ = tf; }
};
 
 
class NodesIdTreeDrawingListener :
  public TreeDrawingListenerAdapter
{
private:
  const TreeDrawingSettings* settings_;
 
public:
  NodesIdTreeDrawingListener(const TreeDrawingSettings* settings, bool autonomous = false) :
    TreeDrawingListenerAdapter(autonomous),
    settings_(settings)
  {}
 
  NodesIdTreeDrawingListener(const NodesIdTreeDrawingListener& lntdl) :
    TreeDrawingListenerAdapter(lntdl),
    settings_(lntdl.settings_) {}
 
  NodesIdTreeDrawingListener& operator=(const NodesIdTreeDrawingListener& lntdl)
  {
    TreeDrawingListenerAdapter::operator=(lntdl);
    settings_ = lntdl.settings_;
    return *this;
  }
 
  NodesIdTreeDrawingListener* clone() const { return new NodesIdTreeDrawingListener(*this); }
 
public:
  void afterDrawNode(const DrawNodeEvent& event);
};
 
 
class LeafNamesTreeDrawingListener :
  public TreeDrawingListenerAdapter
{
private:
  const TreeDrawingSettings* settings_;
 
public:
  LeafNamesTreeDrawingListener(const TreeDrawingSettings* settings, bool autonomous = false) :
    TreeDrawingListenerAdapter(autonomous),
    settings_(settings)
  {}
 
  LeafNamesTreeDrawingListener(const LeafNamesTreeDrawingListener& lntdl) :
    TreeDrawingListenerAdapter(lntdl),
    settings_(lntdl.settings_)
  {}
 
  LeafNamesTreeDrawingListener& operator=(const LeafNamesTreeDrawingListener& lntdl)
  {
    TreeDrawingListenerAdapter::operator=(lntdl);
    settings_   = lntdl.settings_;
    return *this;
  }
 
  LeafNamesTreeDrawingListener* clone() const { return new LeafNamesTreeDrawingListener(*this); }
 
public:
  void afterDrawNode(const DrawNodeEvent& event);
};
 
 
class BranchLengthsTreeDrawingListener :
  public TreeDrawingListenerAdapter
{
private:
  const TreeDrawingSettings* settings_;
 
public:
  BranchLengthsTreeDrawingListener(const TreeDrawingSettings* settings, bool autonomous = false) :
    TreeDrawingListenerAdapter(autonomous),
    settings_(settings)
  {}
 
  BranchLengthsTreeDrawingListener(const BranchLengthsTreeDrawingListener& lntdl) :
    TreeDrawingListenerAdapter(lntdl),
    settings_(lntdl.settings_)
  {}
 
  BranchLengthsTreeDrawingListener& operator=(const BranchLengthsTreeDrawingListener& lntdl)
  {
    TreeDrawingListenerAdapter::operator=(lntdl);
    settings_   = lntdl.settings_;
    return *this;
  }
 
  BranchLengthsTreeDrawingListener* clone() const { return new BranchLengthsTreeDrawingListener(*this); }
 
public:
  void afterDrawBranch(const DrawBranchEvent& event);
};
 
 
class BootstrapValuesTreeDrawingListener :
  public TreeDrawingListenerAdapter
{
private:
  const TreeDrawingSettings* settings_;
 
public:
  BootstrapValuesTreeDrawingListener(const TreeDrawingSettings* settings, bool autonomous = false) :
    TreeDrawingListenerAdapter(autonomous),
    settings_(settings)
  {}
 
  BootstrapValuesTreeDrawingListener(const BootstrapValuesTreeDrawingListener& lntdl) :
    TreeDrawingListenerAdapter(lntdl),
    settings_(lntdl.settings_) {}
 
  BootstrapValuesTreeDrawingListener& operator=(const BootstrapValuesTreeDrawingListener& lntdl)
  {
    TreeDrawingListenerAdapter::operator=(lntdl);
    settings_   = lntdl.settings_;
    return *this;
  }
 
  BootstrapValuesTreeDrawingListener* clone() const { return new BootstrapValuesTreeDrawingListener(*this); }
 
public:
  void afterDrawBranch(const DrawBranchEvent& event);
};
 
 
class LabelInnerNodesTreeDrawingListener :
  public TreeDrawingListenerAdapter
{
public:
  LabelInnerNodesTreeDrawingListener(bool autonomous = false) :
    TreeDrawingListenerAdapter(autonomous) {}
 
  LabelInnerNodesTreeDrawingListener* clone() const { return new LabelInnerNodesTreeDrawingListener(*this); }
 
public:
  void afterDrawNode(const DrawNodeEvent& event);
};
 
 
class LabelCollapsedNodesTreeDrawingListener :
  public TreeDrawingListenerAdapter
{
public:
  LabelCollapsedNodesTreeDrawingListener(bool autonomous = false) :
    TreeDrawingListenerAdapter(autonomous) {}
 
  LabelCollapsedNodesTreeDrawingListener* clone() const { return new LabelCollapsedNodesTreeDrawingListener(*this); }
 
public:
  void afterDrawNode(const DrawNodeEvent& event);
};
} // end of namespace bpp
#endif // BPP_PHYL_GRAPHICS_TREEDRAWINGLISTENER_H