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 & backgroundColor 
    = 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:
    DomainDrawMode myDomainDrawMode;

    bool myDrawObjectAdjacencies;

    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)