ViewBase.sip

Go to the documentation of this file.

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

class ViewBase : Observer
{
%TypeHeaderCode
#include "hippoplot/ViewBase.h"
%End


public:

  ViewBase();

  ViewBase ( PlotterBase *  );

  ViewBase ( const ViewBase & );

  virtual ~ViewBase();

  virtual void setPlotter ( PlotterBase *  );

  PlotterBase * getPlotter () const;

  PlotterBase * getPlotter ();

  virtual void update ( const Observable * ) = 0;

  virtual void drawSelf();

  virtual void initPlot ( double ) = 0;

  virtual void endPlot () = 0;

//   /** Draws multiple line segments - that is, a line between x0,y0 and
//       x1,y2, another between x2,y2 and x3,y3 and so on. 
//       @p x pairs of coordinates in user space on the X axis for the beginning 
//          and the end of the line segment.  
//       @p y pairs of coordinates in user space on the Y axis for the beginning 
//          and the end of the line segment.  
//       @p style the line style.  
//       @p color The color 
//       @p size The thickness of the line. */
//   virtual void drawLines ( const std::vector< double > & ,
//                         const std::vector< double > & ,
//                         hippodraw::Line::Style ,
//                         const Color & ,
//                         float ) = 0;

//   /** Draws multiple line segments, each with a different color - that
//       is, a line between x0,y0 and x1,y1, with color[0] =color[1]
//       another between x2,y2 and x3,y3 with color[2]=color[3] and so
//       on.  

//       @p x pairs of coordinates in user space on the X axis for the
//       beginning and the end of the line segment.

//       @p y pairs of coordinates in user space on the Y axis for the
//       beginning and the end of the line segment.

//       @p style the line style.  

//       @p color The RGB values for the color of the line.

//       @p size The thickness of the line.

//       @bug Could call drawPolyLine for each contour with same color.

//   */
//   virtual void drawColorLines ( const std::vector< double > & ,
//                              const std::vector< double > & ,
//                              hippodraw::Line::Style ,
//                              const std::vector < Color > & ,
//                              float ) = 0;

//   /** Draws multiple line segments.  
//       @p x pairs of coordinates in view space on the X axis for the beginning 
//          and the end of the line segment.  
//       @p y pairs of coordinates in view space on the Y axis for the beginning 
//          and the end of the line segment.  
//       @p style the line style.  
//       @p color if @c true, use the display's point color; otherwise, use 
//          the default color. 
//       @p size The thickness of the line. */
//   virtual void drawViewLines ( const std::vector< double > & ,
//                             const std::vector< double > & ,
//                             hippodraw::Line::Style ,
//                             bool ,
//                             float  ) = 0;

//    /** Draws multiple line segments.  
//       @p x pairs of coordinates in view space on the X axis for the beginning 
//          and the end of the line segment.  
//       @p y pairs of coordinates in view space on the Y axis for the beginning 
//          and the end of the line segment.  
//       @p style the line style.  
//       @p color The color
//       @p size The thickness of the line. */
//   virtual void drawViewLines ( const std::vector< double > & ,
//                             const std::vector< double > & ,
//                             hippodraw::Line::Style ,
//                             const Color & ,
//                             float ) = 0;
//  /** Draws a polyline.  
//       @p xpoints points along the X axis.
//       @p ypoints points along the Y axis.
//       @p style the line style. 
//       @p color The color.
//       @p size The thickness of the line. */
//   virtual void drawPolyLine ( const std::vector< double > & ,
//                            const std::vector< double > & , 
//                            hippodraw::Line::Style ,
//                            const Color & ,
//                            float  ) = 0;

//   /** Draws a text string at a point in the view's coordinate system.
      
//       @param s The string to be drawn.  
      
//       @param x The x coordinate in the view's coordinate system.
      
//       @param y The y coordinate in the view's coordinate system.
      
//       @param fontsize The font size.  If zero, then taken from the
//       font object.
    
//       @param angle The angle to draw.  90 degrees is vertical with the
//       beginning of the text towards the bottom.

//       @param xp The horizontal alignment with respect to the
//       coordinate.  'r' means the coordinate is on the right side of
//       the text, 'c' means centered, and 'l' for the left side.

//       @param yp The vertical alignment with respect to the
//       coordinate. 't' means toward the top, 'c' means centered, and
//       'b' means bottom.

//       @param resize If @c true, the bounding rectangle of the view
//       should be resized to fit the text string.

//       @param font If not a null pointer, then the font object to be
//       used, otherwise the default font will be used.

//   */
//   virtual void drawText ( const std::string & , float , float ,
//                        float , float angle = 0.0,
//                        char xp = 'l', char yp = 't',
//                        bool resize = false,
//                        const FontBase * font = 0 ) = 0;

  virtual void drawUserText ( const std::string & , float , float ,
                              float , float ,
                              char , char  ) = 0;

  virtual void drawMag ( float , float , int , float ) = 0;

//   /** Draws symbol points.  @a x and @a y are the coordinates, @a type
//       is the type of symbol, and @a sym_size is the size. All symbols
//       are draw in the same color. */
//   virtual void drawPoints ( const std::vector<double> & ,
//                          const std::vector<double> & ,
//                          hippodraw::Symbol::Type , 
//                          float , const Color & ) = 0;

//   /** Draws symbol points.  @a x and @a y are the coordinates, @a type
//       is the type of symbol, and @a sym_size is the size. @a hue is
//       the hue parameters for each point.  The saturation and brightness
//       are set to 1.0. 
//   */
//   virtual void drawPoints ( const std::vector< double > & ,
//                          const std::vector< double > & , 
//                          const std::vector< Color > & ,
//                          hippodraw::Symbol::Type , float  ) = 0;

  virtual void drawSquare ( double , double , double , double ,
                            int , int, int ) = 0;

  virtual void drawViewSquare ( float , float , float , float ,
                                int , int , int ) = 0;

//   /** Returns the range of the data space on specified axis. 
//    */
//   const Range & getRange ( hippodraw::Axes::Type ) const;

//   /** Is called by the AxisRepBase object (or one of its derived
//    *  objects), and returns the rectangle where the drawing is
//    *  made. */
//   const HippoRectangle & getUserRect () const;

//   /** Returns the drawing Rectangle in the devices coordinate system.
//       Must be implemented in derived class. */
//   virtual HippoRectangle getDrawRect() const = 0;

  virtual void setDrawRect ( float , float , float , float  ) = 0;

//   /** Returns the Rectangle within which points representations are
//       draw.  

//       @todo It might be better to maintain insets instead of separate
//       Rectangle.  In that way, only one rectangle would move with
//       respect to canvas. 
//   */
//   virtual HippoRectangle getMarginRect() const;

  virtual float userToDrawX ( double ) const = 0;

  virtual float userToDrawY ( double  ) const = 0;

  virtual float userToDrawColor ( double ) const = 0;

  virtual double getAspectRatio () const;

};

---