pencils.hpp

#ifndef PENCILS_H_WATCH
#define PENCILS_H_WATCH

#include "rectangle.hpp"
#include <memory>

#include "iterators.hpp"
#include "my_mkl.hpp"

class Bild;

class image_slice_coloring{
public:

    image_slice_coloring(const Rectangle::const_ref&,
             const size_t drawing_layer,
             const complex*,
                     Bild* b);
    
    template <class Pencil>
    void coloring( Pencil& );
    template <class Pencil>
    void color_one_slice( const Pencil& );

    bool working() const { return (pos.position() != end);};

    const geometry_const_Iterator current() const { return pos.position();};

    void forward_to_specific_slice( const geometry_const_Iterator&);

private:

    slice_Position pos;

    int drawing_layer_;

    geometry_const_Iterator end;

    Bild* bild;

    size_t bild_nx;
    size_t bild_ny;

    const complex* wv;

    void advance_slice();

    template <class Pencil>
    void paint_slice( Pencil&);

};

class loadable_Object;

class pencil{
public:
    typedef std::unique_ptr<pencil> ref;

    pencil(){};
    virtual ~pencil(){};

    void init_params( const STD_TR1::shared_ptr<const loadable_Object>& o)
    {  init_params_(o);};

    void coloring( image_slice_coloring& isc, 
           double min_x = -1., 
           double max_x = -1.)
    {  coloring_(isc);};

    const std::string& name() const { return name_();};

    bool should_draw( int point_layer, int drawing_layer) const { 
    return should_draw_( point_layer, drawing_layer );};

    size_t number_of_drawing_layers() const { 
    return number_of_drawing_layers_();};

    template <class pencil_impl>
    static std::unique_ptr<pencil>  get_pencil(const pencil_impl& p);

private:

    virtual void init_params_( const STD_TR1::shared_ptr<const loadable_Object>& o ) = 0;
    
    virtual void coloring_( image_slice_coloring& ) = 0;
    virtual const std::string& name_() const = 0;

    virtual bool should_draw_( int point_layer, 
                   int drawing_layer) const = 0;

    virtual size_t number_of_drawing_layers_() const = 0;

};



template <class pencil_impl>
class concrete_pencil: public pencil{

    friend class pencil;

private:

    pencil_impl pen;

    void coloring_( image_slice_coloring& isc ){
    isc.coloring<pencil_impl>( pen );
    };

    void init_params_( const STD_TR1::shared_ptr<const loadable_Object>& o ){
        pen.init_params(o);
    };

// default: we draw if point_layer equals drawing layer
    bool should_draw_( int point_layer, int drawing_layer) const
    {
        return pen.should_draw( point_layer, drawing_layer);
    };

    size_t number_of_drawing_layers_() const
    {
        return pen.number_of_drawing_layers();
    };

    const std::string& name_() const { return pen.name();};

    concrete_pencil( const pencil_impl& p ) : pen( p ) {};
    concrete_pencil();
    concrete_pencil( const concrete_pencil&);

};

template <class pencil_impl>
std::unique_ptr<pencil> pencil::get_pencil(const pencil_impl& p){
    return std::unique_ptr<pencil>(new concrete_pencil<pencil_impl>(p));
}

#endif