PlotterBase.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */

#ifndef _PlotterBase_H_
#define _PlotterBase_H_

#include "axes/AxesType.h"
#include "graphics/Rectangle.h"

#include "pattern/Observable.h"
#include "pattern/Observer.h"

namespace hippodraw {

class AxisModelBase;
class AxisTick;
class BinToColor;
class Color;
class DataRep;
class NTuple;
class ProjectorBase;
class Range;
class RepBase;
class TupleCut;
class TransformBase;
class ViewBase;
class FontBase;

class MDL_HIPPOPLOT_API PlotterBase :
  public Observer, public Observable
{

private:

  virtual void setScaling ( Axes::Type  axis, bool on = true );

   void setPlotterId();

protected:
  
  double m_aspect_ratio;
  
  std::string m_name;
  
  /* The three following fields (m_title, m_x_label, m_y_label) have
      default values. The PlotterBase object gets them from the
      ProjectorBase object, and the ProjectorBase object gets them
      from the DataSource object. */
  
  std::string m_title;
  
  double m_crossX;
  
  double m_crossY;
  
  Rect m_user_rect;

  Rect m_raw_rect;

  PlotterBase* m_parent_plotter;
  
  int m_parent_datarep_index;

   PlotterBase ();

  PlotterBase ( const std::string & name );

  PlotterBase ( const PlotterBase & plotter );

  bool hasAutoScaled () const;


  bool current_range_saved;

   int m_plotterId;

   std::vector< std::vector<double> > m_views;

   int m_currentView;

   static int s_plotters;

public:

  virtual ~PlotterBase();

  virtual PlotterBase * clone() = 0;

  const std::string & name () const;

  virtual void setScaleFactor ( Axes::Type  axis, double factor );

  virtual bool isAxisScaled ( Axes::Type axis ) const;

  virtual void  update ( const Observable * );

  virtual void update () = 0;

  virtual bool hasNTupleBindings () const = 0;


  virtual bool hasZoomY () const ;

  virtual void setBinWidth ( Axes::Type axis, double width );

  virtual void setBinWidth ( const std::string & axis, double width );

  virtual void setBinWidth ( Axes::Type axis,
                             int parameter, bool dragging );

  virtual void setOffset ( Axes::Type axis, double offset );

  virtual void setOffset ( const std::string & axis, double offset );

  virtual void setNumberOfBins ( const std::string & axis, 
                                 unsigned int number );

  virtual void setNumberOfBins ( Axes::Type axis, 
                                 unsigned int number );

  virtual AxisModelBase * getAxisModel ( Axes::Type axis ) const;

  virtual void addDataRep ( DataRep * rep );

  virtual void setActivePlot ( int index, bool redraw );

  virtual int activePlotIndex ( ) const;
  
  virtual int getParentDataRepIndex ( ) const;
  
  virtual void setParentDataRepIndex ( int index );

  virtual PlotterBase* getParentPlotter ( ) const;
  
  virtual void setParentPlotter( PlotterBase* plotter );
  
  virtual void reset ( );

  virtual ProjectorBase * activeProjector () const;
  
  virtual DataRep * selectedDataRep () const;

  virtual ProjectorBase * getProjector (int i) const;

  virtual int getNumDataReps() const;

  virtual DataRep * getDataRep ( int index ) const;

  virtual void removeDataRep ( DataRep * );

  virtual void prepareToDraw ();

  virtual void drawIn ( ViewBase * view ) = 0;

  virtual void drawCrossHairs ( ViewBase * view );

  virtual void setRepresentation ( RepBase * pointrep ) = 0;

  virtual RepBase * representation ( ) const = 0;

  virtual const BinToColor * getValueRep () const;

  virtual void setValueRep ( BinToColor * rep );

  virtual void setTransform ( TransformBase * );

  virtual void setFitsTransform ( const std::string & );

  virtual TransformBase * getTransform () const;

  virtual TransformBase * getFitsTransform () const;

  virtual void setAxisModel ( AxisModelBase * , Axes::Type ) = 0;

  virtual void setAutoRanging ( const std::string &  axis, bool flag );

  virtual void setAutoRanging ( Axes::Type axis, bool flag );

  virtual void setAutoRanging ( bool flag );

  virtual void setReverse ( bool flag );

  virtual void setShowGrid ( bool flag );

  virtual void setBoxEdge (bool flag );

  virtual bool getBoxEdge ();

  virtual bool getShowGrid ();

  virtual bool isAutoRanging ( Axes::Type axis ) const;

  virtual bool isReverse () const;


  virtual void autoScale();

  void setTitle( const std::string & title );

  const std::string & getTitle() const;

  virtual void setLabel ( const std::string & axis, 
                          const std::string & label );

  virtual void setLabel ( Axes::Type, const std::string & value );

  virtual const std::string & getLabel ( Axes::Type ) const;


  virtual const std::string &
  getInternalTitle ( ) const;

  virtual const std::string &
  getInternalLabel ( Axes::Type axis ) const;

  virtual void checkAxisScaling ();

  virtual double getBinWidth (Axes::Type axis) const;

  double getBinWidth ( const std::string & axis ) const;

  virtual double getOffset (Axes::Type axis) const;

  double getOffset ( const std::string & axis ) const;

  virtual int getNumberOfEntries () const;

  int getNumOfEntries () const;

  virtual void setErrorDisplay ( Axes::Type axis, bool ) = 0;

  virtual bool errorDisplay ( Axes::Type axis ) const = 0;

  virtual void setRange ( Axes::Type axis, const Range & range,
                          bool scaled = false, bool adjust_width = true );

  void setRange ( const std::string & axis, double low, double high );

  virtual const Range & getRange ( Axes::Type axis, 
                                   bool scaled ) const;

  virtual Range getDataRange ( Axes::Type axis );

  virtual double getPosRange ( Axes::Type axis ) const;

  virtual void setLowRange ( Axes::Type axis, int parm, 
                             bool dragging );

  virtual void setHighRange ( Axes::Type axis, int parm, 
                              bool dragging );

  virtual void setRepColor ( const Color & ) = 0;

  virtual const Color & repColor () const = 0;

  const Rect & getUserRect () const;

  const Rect & getRawRect () const;

  virtual NTuple * createPickTuple ();

  virtual void fillPickedPointFrom ( double mx, double my, 
                                     std::vector < double > & picked ) const;

  virtual double getZValue ( double x, double y, bool scaled = true ) const;

  virtual bool hasAxis ( Axes::Type axis ) const;

  void setCrossX ( double val );

  void setCrossY ( double val );

  virtual void addValues ( const std::vector < double > & v );

  virtual double getAspectRatio () const;

  void setAspectRatio ( double ratio );

  virtual NTuple * createNTuple () const = 0;

  virtual bool wantsPixmap ( ) const;

  virtual void setOffsets( double xoffset, double yoffset );

  virtual void setEnableZ ( bool yes = true );

  virtual void setAutoTicks ( Axes::Type axis, bool yes );

  virtual void setTicks ( Axes::Type axis, 
                          const std::vector < AxisTick > & ticks );

  virtual void setAutoTicks ( const std::string &, bool on );

  virtual void setAutoTicksOnX ( bool yes );

  virtual void setTicksOnX ( const std::vector < double > & values,
                             const std::vector < std::string > & labels );

  virtual void setTicks ( const std::string & axis,
                          const std::vector < double > & values,
                          const std::vector < std::string > & labels );

  virtual double getLowRangeOnX ( ) const;

  virtual double getHighRangeOnX () const;

  virtual void matrixTranspose ( bool yes );

  virtual bool isTargetable () const;

  virtual DataRep * getTarget () const;

  virtual int indexOf ( const DataRep * rep ) const;

  void toggleActivePlot ();

   virtual int plotterId () const;

   int saveView ( const std::vector<double> & range_values );

  
 int saveViewAtIndex(const std::vector<double>& range_values,unsigned int i ); 

   void setView ( int index );

   int nextView (bool stepForward=true);


   int numViews () const;

   void deleteView ( int index );

   int currentView () const;

  virtual void fillCutList ( std::vector < const TupleCut * > & cuts ) const;

  virtual void setCutRangeAt ( const Range & range, unsigned int i );

  virtual void setCurrentRangeSaved( bool flag );

  virtual bool getCurrentRangeSaved( );

  virtual const std::vector <double> & getZValues();
  virtual const std::vector <unsigned int> & getShape();

  virtual void setMinEntries( int entries );

  
  virtual int getMinEntries ();

  virtual FontBase* labelFont ( Axes::Type axes ) const;

  virtual const FontBase * titleFont ( ) const;

  virtual bool isImageConvertable () const;

  virtual bool isTextPlotter() const;


  virtual void setTopMargin( double top );
  virtual void setBottomMargin( double bottom );
  virtual void setLeftMargin( double left );
  virtual void setZMargin( double z );
  virtual double getTopMargin();
  virtual double getBottomMargin();
  virtual double getLeftMargin();
  virtual double getZMargin();

  virtual void setNeedUpdate(bool isChanged);

  virtual double getScaleFactor ( Axes::Type axis ) const;

};

} // namespace hippodraw

#endif // _PlotterBase_H_