Board2D.h

 
#pragma once
 
#if defined(Board2D_RECURSES)
#error Recursive header files inclusion detected in Board2D.h
#else // defined(Board2D_RECURSES)
#define Board2D_RECURSES
 
#if !defined Board2D_h
#define Board2D_h
 
// Inclusions
#include <iostream>
#include "Board/Board.h"
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/io/Color.h"
 
 
 
namespace DGtal
{
  enum DomainDrawMode { GRID = 0, PAVING = 1 };
 
 
  // class Board2D
  class Board2D : public LibBoard::Board
  {
    // ----------------------- local types ------------------------------
  public:
    typedef std::map< std::string,CountedPtr<DrawableWithBoard2D> > StyleMapping;
 
    typedef std::map< std::string, std::string > ModeMapping;
 
    typedef LibBoard::Shape Shape;
 
    // ----------------------- Standard services ------------------------------
  public:
    
    ~Board2D();
    
    Board2D( const Color & aBackgroundColor = Color::None );
 
    Board2D( const Board2D & other );
 
    Board2D & operator= ( const Board2D & other );
 
    std::string getMode( const std::string & objectName ) const;
 
    template <typename TDrawableWithBoard2D>
    Board2D & operator<<( const TDrawableWithBoard2D & object );
 
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Public Datas ------------------------------
  public:
    StyleMapping myStyles;
 
    ModeMapping myModes;
    // ------------------------- Private Datas --------------------------------
  private:
 
  }; // end of class Board2D
 
 
  std::ostream&
  operator<< ( std::ostream & out, const Board2D & object );
 
  struct DrawWithBoardModifier {
    std::string className() const
    {
      return "DrawWithBoardModifier";
    }
 
    /*DrawableWithBoard2D* defaultStyle( std::string = "" ) const
    {
      return 0;
    }*/
 
    /*virtual void setStyle( Board2D &  ) const 
    {}*/
  };
 
 
  struct CustomStyle : public DrawWithBoardModifier {
    CustomStyle( std::string classname, DrawableWithBoard2D* style )
      : myClassname( classname ), myStyle( style )
    {}
 
    std::string className() const
    {
      return "CustomStyle";
    }
 
    /*void setStyle( Board2D & board ) const
    {
      board.myStyles[ myClassname ] = myStyle;
    }*/
 
    std::string myClassname;
    CountedPtr<DrawableWithBoard2D> myStyle;
  };
 
  struct SetMode : public DrawWithBoardModifier {
    SetMode( std::string classname, std::string mode )
      : myClassname( classname ), myMode( mode )
    {}
    
    /*void setStyle( Board2D & board ) const
    {
      board.myModes[ myClassname ] = myMode;
    }*/
    
    std::string myClassname;
    std::string myMode;
  };
 
  struct CustomColors : public DrawableWithBoard2D
  {
    Color myPenColor;
    Color myFillColor;
 
    CustomColors( const Color & penColor,
      const Color & fillColor )
      : myPenColor( penColor ), myFillColor( fillColor )
    {}
    
    virtual void setStyle( Board2D & aboard) const
    {
      aboard.setFillColor( myFillColor);
      aboard.setPenColor( myPenColor );
    }
  };
 
  struct CustomPenColor : public DrawableWithBoard2D
  {
    Color myPenColor;
 
    CustomPenColor( const Color & penColor )
      : myPenColor( penColor )
    {}
    
    virtual void setStyle( Board2D & aboard) const
    {
      aboard.setPenColor( myPenColor );
    }
  };
 
  struct CustomFillColor : public DrawableWithBoard2D
  {
    Color myFillColor;
 
    CustomFillColor( const Color & fillColor )
      : myFillColor( fillColor )
    {}
    
    virtual void setStyle( Board2D & aboard) const
    {
      aboard.setFillColor( myFillColor );
    }
  };
 
  struct CustomPen : public DrawableWithBoard2D
  {
    Color myPenColor;
    Color myFillColor;
    double myLineWidth;
    Board2D::Shape::LineStyle myLineStyle; 
    Board2D::Shape::LineCap myLineCap; 
    Board2D::Shape::LineJoin myLineJoin; 
    int myDepth;        
    CustomPen( const Color & penColor,
         const Color & fillColor,
         double lineWidth = 1.0,
         Board2D::Shape::LineStyle lineStyle = Board2D::Shape::SolidStyle,
         Board2D::Shape::LineCap lineCap = Board2D::Shape::ButtCap,
         Board2D::Shape::LineJoin lineJoin = Board2D::Shape::MiterJoin )
      : myPenColor( penColor ), myFillColor( fillColor ),
  myLineWidth( lineWidth ), 
  myLineStyle( lineStyle ), myLineCap ( lineCap ), myLineJoin( lineJoin )
    {}
    
    virtual void setStyle( Board2D & aboard) const
    {
      aboard.setPenColor( myPenColor );
      aboard.setFillColor( myFillColor );
      aboard.setLineWidth( myLineWidth );
      aboard.setLineStyle( myLineStyle );
      aboard.setLineCap( myLineCap );
      aboard.setLineJoin( myLineJoin );
    }
  };
 
} // namespace DGtal
 
 
// Includes inline functions.
 
#include "DGtal/io/Display2DFactory.h"
#include "DGtal/io/Style2DFactory.h"
#include "DGtal/io/boards/Board2D.ih"
 
//                                                                           //
 
#endif // !defined Board2D_h
 
#undef Board2D_RECURSES
#endif // else defined(Board2D_RECURSES)