Canvas.hpp

Go to the documentation of this file.

#pragma ident "$Id: Canvas.hpp 1644 2009-01-27 19:26:14Z ckiesch $"


//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 2.1 of the License, or
//  any later version.
//
//  The GPSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

#ifndef VDRAW_CANVAS_H
#define VDRAW_CANVAS_H

#include <vector>
#include "VGState.hpp"
#include "Path.hpp"
#include "StrokeStyle.hpp"
#include "Line.hpp"
#include "Rectangle.hpp"
#include "Circle.hpp"
#include "Polygon.hpp"
#include "Text.hpp"
#include "Marker.hpp"
#include "Comment.hpp"
#include "Bitmap.hpp"

namespace vdraw
{

  class Canvas 
  {
    friend Canvas& operator<<(Canvas& canvas, const StrokeStyle& style)
    {
      canvas.setLineStyle(style);
      return canvas;
    }

    friend Canvas& operator<<(Canvas& canvas, const Marker& marker)
    {
      canvas.setMarker(marker);
      return canvas;
    }

    friend Canvas& operator<<(Canvas& canvas, const TextStyle& style)
    {
      canvas.setTextStyle(style);
      return canvas;
    }

    friend Canvas& operator<<(Canvas& canvas, const Color& color)
    {
      canvas.setFillColor(color);
      return canvas;
    }

    friend Canvas& operator<<(Canvas& canvas, const Line& line)
    {
      canvas.line(line);
      return canvas;
    }

    friend Canvas& operator<<(Canvas& canvas, const char *comment)
    {
      canvas.comment(Comment(comment));
      return canvas;
    }

    friend Canvas& operator<<(Canvas& canvas, const Comment& comment)
    {
      canvas.comment(comment);
      return canvas;
    }

    friend Canvas& operator<<(Canvas& canvas, const Rectangle& rect)
    {
      canvas.rectangle(rect);
      return canvas;
    }

    friend Canvas& operator<<(Canvas& canvas, const Circle& circle)
    {
      canvas.circle(circle);
      return canvas;
    }

    friend Canvas& operator<<(Canvas& canvas, const Text& text)
    {
      canvas.text(text);
      return canvas;
    }

    friend Canvas& operator<<(Canvas& canvas, const Polygon& polygon)
    {
      canvas.polygon(polygon);
      return canvas;
    }

    friend Canvas& operator<<(Canvas& canvas, const Bitmap& bitmap)
    {
      canvas.bitmap(bitmap);
      return canvas;
    }


    public:
    Canvas();

    ~Canvas();

    void setLineStyle( const StrokeStyle& newStyle ) 
    {defaults->setSS(newStyle);}

    void removeLineStyle(void) 
    {defaults->setSS();}

    virtual void setMarker( const Marker& newMarker ) 
    {defaults->setM(newMarker);}

    virtual void removeMarker(void) 
    {defaults->setM();}

    void setTextStyle( const TextStyle& newStyle ) 
    {defaults->setTS(newStyle);}

    void removeTextStyle(void) 
    {defaults->setTS();}

    void setFillColor( const Color& newColor ) 
    {defaults->setFC(newColor);}

    void removeFillColor(void) 
    {defaults->setFC();}

    virtual void line (double x1, double y1, double x2, double y2)
    {
      line(Line(x1,y1,x2,y2));
    };

    virtual void line (const Line& line)=0;

    virtual void rectangle (const Rectangle& rect)=0;

    virtual void circle (const Circle& circle)=0;

    virtual void text (const Text& text)=0;

    virtual void polygon(const Polygon& polygon)=0;

    virtual void bitmap(const Bitmap& bitmap)=0;

    virtual void comment(const Comment& comment)=0;

    virtual void comment(const char * format, ...)
    {
      va_list ap;
      va_start(ap,format);
      comment(Comment(format,ap));
      va_end(ap);
    }

    void push_state()
    {
      stateStack.push_back(defaults);
      defaults = new VGState();
    }

    void pop_state()
    {
      if(stateStack.size() > 0)
      {
        delete defaults;
        defaults = stateStack.back();
        stateStack.pop_back();
      }
      else
        defaults = new VGState();
    }

    inline double up() { return (isLL()?1:-1); }

    virtual bool isLL()=0;

    std::vector<VGState*> stateStack;

    VGState *defaults;

    private:

  }; // class Canvas


} // namespace vdraw

#endif //VDRAW_CANVAS_H

---