PlotterBase.sip

Go to the documentation of this file.

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

class AxisModelBase;
class RepBase;
class ViewBase;

class PlotterBase : Observer, Observable
{
%TypeHeaderCode
#include "plotters/PlotterBase.h"
%End


public:
  virtual ~PlotterBase();

  const std::string & name () const;

  PlotterBase ( const std::string & );
  virtual PlotterBase * clone () = 0;

  virtual void update () = 0;

  virtual void update ( const Observable * );

  virtual void setTitle ( const std::string & );
 
  const std::string & getTitle() const;

  void setLabel ( const std::string &, const std::string & );

// /** Sets the label of the specified @a axis to @a value.  The
//       implementation in this base class does nothing.
//    */
//   virtual void setLabel ( hippodraw::Axes::Type, const std::string & );

//   /** Returns the label for the specified axis.  The implementation in
//       this base class returns an empty string.
//   */
//   virtual const std::string & getLabel ( hippodraw::Axes::Type ) const;

//   /** Returns the internal label.  The internal label is either the
//       string set y a client, or one of @em %x, @em %y, or @em %z for
//       the corresponding axis.  The implementation in this base class
//       returns an empty string.
//   */
//  virtual const std::string &
//   getInternalLabel ( hippodraw::Axes::Type  ) const;

//   /** Sets the display of the error bars on or off. 
//       @todo Remove this function when no longer in use.
//   */
//   virtual void setErrorDisplay ( hippodraw::Axes::Type , bool ) = 0;

//   /** Returns the state of error bar display on specified @a axis. */
//   virtual bool errorDisplay ( hippodraw::Axes::Type  ) const = 0;

// /** @brief Sets the range on the specified axis.  

//       Sets the Range on the axis @a axis to @a range.  The
//       TransformBase object contained by this object may ajust the
//       range to fall within its limits.  If @a scaled is @c true, then
//       the Range object's value is a scaled range, otherwise it is the
//       true range.  if @a adjust_width is @c true, the bin width, if
//       applicable, is adjusts so one has the same number of bins after
//       the range is set, otherwise, the bin width is not changed.  The
//       implementation in this base class does nothing.

//       @bug Setting an range to 0, 100M on plot with empty NTuple causes
//       unknown exception.   Probably calculating too many bins.
  
//   */
//   virtual void setRange ( hippodraw::Axes::Type , const Range & ,
//                        bool = false, bool = true );

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

//  /** Returns the range on the specified axis.  Returns the range of
//       the data being plotted on the axis @a axis. If @a scaled is @c
//       true, uses the scaled range.  @sa AxisModelBase::getRange.  The
//       implemenation in this base class returns an empty Range.
//   */
//   virtual const Range & getRange ( hippodraw::Axes::Type , bool ) const;

//   /** Returns the smallest positive number from the data.   */
//   virtual double getPosRange ( hippodraw::Axes::Type ) const;

//   /** Sets the low end of the Range of data displayed.  The
//       implementation in this base class does nothing.
//    */
//   virtual void setLowRange ( hippodraw::Axes::Type , int , bool );

//   /** Sets the high end of the Range of data displayed.  The
//       implementation is this base class does nothing.
//    */
//   virtual void setHighRange ( hippodraw::Axes::Type , int , bool );


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

// /** Sets the number of bins.  Sets the number of bins of the
//       contained ProjectorBase objects to @a number along the axis @a
//       axis.  The implementation in this class does nothing. @sa
//       ProbjectorBase::setNumberOfBins.
//    */
//   virtual void setNumberOfBins ( hippodraw::Axes::Type axis, 
//                               unsigned int  );


//  /** Sets the offset.  Sets the edges of the bins to be offset from
//       its current value by the amount @a offset along the axis @a
//       axis. The implementation in this class does nothing. 
//   */
//   virtual void setOffset ( hippodraw::Axes::Type , double );

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

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

  virtual void setOffsets ( double, double );

  virtual bool wantsPixmap ( ) const;


  virtual double getLowRangeOnX ( );
  virtual double getHighRangeOnX ( );

  virtual void matrixTranspose ( bool );


//  /** Sets the bin width.  Sets the bin width of the contained
//       ProjectorBase objects to @a width along axis @a axis. The
//       implementation in this class does nothing.  The @sa
//       PrjectorBase::setBinWidth.
//   */
//   virtual void setBinWidth ( hippodraw::Axes::Type , double );

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

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

//  /** Returns the bin width.  The implementation in the base class
//       does nothing.  It is declared as a convenience to the developer
//       since bin width is a common attribute. */
//   virtual double getBinWidth (hippodraw::Axes::Type ) const;

//  /** Returns the offset on designated axis, similarly to
//       getBinWidth. */
//   virtual double getOffset (hippodraw::Axes::Type ) const;

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

//   /** Returns the number of entries in the contained DataRep.
//   */
//   virtual int getNumOfEntries () const;

  int getNumOfEntries () const;


  virtual void checkAxisScaling ();

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

//   /** Sets the auto-ranging.  Sets auto-ranging status for the @a axis
//       to @a flag and auto-ranges all axis which has that status
//       set. The implementation in this base class does nothing.
//   */
//   virtual void setAutoRanging ( hippodraw::Axes::Type , bool );

  virtual void setAutoRanging ( bool );


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

  virtual int getNumDataReps () const = 0;
  virtual DataRep * getDataRep ( int ) = 0;

  virtual void removeDataRep ( DataRep * );

  virtual void drawIn ( ViewBase *  ) = 0;

  virtual void drawCrossHairs ( ViewBase * );

  virtual NTuple * createNTuple () const = 0 /Factory/;
 
  virtual void setEnableZ ( bool = true );

//   /** Sets automatic generation of axis ticks.  This base class does
//       nothing.  Derived classes may interpret this function.
//    */
//   virtual void setAutoTicks ( hippodraw::Axes::Type , bool );
  
//   /** Sets the ticks for the specified axis.
//    */
//   virtual void setTicks ( hippodraw::Axes::Type , 
//                        const std::vector < AxisTick > &  );

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

  virtual void setAutoTicksOnX ( bool );

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

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

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

  virtual double getAspectRatio () const;

  void setAspectRatio ( double );

//  /** Returns the AxisModelBase derived class for the specified @a
//       axis. The implementation in this base class returns a null
//       pointer.
//   */
//   virtual AxisModelBase * getAxisModel ( hippodraw::Axes::Type  ) const;

  virtual void addDataRep ( DataRep *  );


  virtual void setActivePlot ( int , bool );

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

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

//   /** Returns the active projector.  That is, the one that should
//       receive commands to it. */
//   virtual ProjectorBase * activeProjector () const;
  
  virtual DataRep * selectedDataRep () const;

//   /** Returns the projector at index @a i. 

//       @todo Remove this method when no longer used.
//    */
//   virtual ProjectorBase * getProjector (int ) const;

//  /** Returns the value to color represenatation.  If the Z value is
//       represented graphically, then return the object that controls
//       the binary value to graphic attribute.  This base class
//       implementation returns a null pointer.
//   */
//   virtual const BinToColor * getValueRep () const;

//   /** Sets the object that will do the value to color transform, if
//       any.  The implemenation is this base class does nothing.
//    */
//   virtual void setValueRep ( BinToColor *  );

//   /** Sets the transform object.  A copy of the transform object is
//       made by calling TransformBase#clone(), and the previous
//       transform object is deleted. By doing it this way, a controller
//       in an application does not need to keep track of how many
//       references to a particular transform object are active.  Derived
//       classes may override this function in order to check if the
//       concrete type of transform object is one appropriate for them.
//       @sa #m_transform.  The implementation in this base class does
//       nothing.
//   */
//   virtual void setTransform ( TransformBase * );

//   /** Returns the transform object used by the plotter. @sa
//       #m_transform.  The implementation in this base class returns a
//       null pointer.
//   */
//   virtual TransformBase * getTransform () const;

//   /** Sets the AxisModel on the specified axis. */
//   virtual void setAxisModel ( AxisModelBase * , hippodraw::Axes::Type ) = 0;

//   /** Returns @c true if auto-ranging is enabled, otherwise returns @c
//       false. The implemenation in this base class always returns
//       false.
//   */
//   virtual bool isAutoRanging ( hippodraw::Axes::Type  ) const;

  virtual void autoScale();

//   /** Returns the data space rectangle. */
//   const HippoRectangle & getUserRect () const;

//   /** Returns the margin space where drawing takes place. */
//   HippoRectangle getMarginRect () const;

  virtual void marginToUserXY ( double , double , bool , 
                                double & , double &  ) const = 0;

  virtual NTuple * createPickTuple () /Factory/;

  virtual void fillPickedPoint ( double , double , 
                                 std::vector < double > & ) const;

  virtual float userToMarginColor ( double  ) const;

  virtual double getZValue ( double , double , bool = true ) const;

//   /** Returns @c true if the plotter has an axis of specified type.
//       The implementation in this base class always returns #c false.
//   */
//   virtual bool hasAxis ( hippodraw::Axes::Type  ) const;

  void setCrossX ( double  );

  void setCrossY ( double  );

  virtual bool isTargetable () const;

  virtual DataRep * getTarget () const;

  virtual int indexOf ( const DataRep * ) const;

  void toggleActivePlot ();

   virtual int plotterId () const;



// private to hide from Doxygen
private:
// Declare the pure virtual functions to keep SIP happy

  virtual bool hasNTupleBindings () const = 0;
  
  virtual void setRepresentation ( RepBase * ) = 0;

  virtual RepBase * representation ( ) const = 0;

  virtual void setRepColor ( const Color & ) = 0;

  virtual const Color & repColor () const = 0;

  virtual float userToMarginX ( double  ) const = 0;

  virtual float userToMarginY ( double  ) const = 0;

  virtual float userToInvertedMarginY ( double  ) const = 0;

  virtual bool hasZAxis() const = 0;

};

---