background_wnd/painters/layout_painter.hpp

// layout_painter.hpp

// Copyright (C) 2004 Steven Weiß (steven11@gmx.de)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.


#pragma once
#include <background_wnd/detail/include.hpp>
#include <background_wnd/painter_base.hpp>
#include <background_wnd/detail/table.hpp>


namespace win32 { namespace gui {

template <class Key = int>
class layout_painter : public painter_base, 
                            public bg_wnd::table<Key>
{
private:  
     typedef boost::shared_ptr<painter_base> PainterPtr;
     typedef std::map<Key, PainterPtr> PainterMap;
     typedef bg_wnd::table<Key> Table;
     
     typedef layout_painter<Key> self;  
public:   
     // typedef's
     typedef Key key_type;
     typedef const key_type& param0;

     // exceptions
     typedef bg_wnd::general_exception<self, 0> key_already_used;
     typedef bg_wnd::general_exception<self, 1> key_invalid;
     typedef bg_wnd::general_exception<self, 2> invalid_painter_cast;

     
     // c'tor
     layout_painter(const key_type& empty_field) : Table(empty_field), horz_margin_(0), vert_margin_(0), bOuterMargin_(true)
     {}
     
     layout_painter* clone() const
     {
          return new layout_painter(*this);
     }

     void margin(unsigned horz_margin, unsigned vert_margin, bool bOuterMargin = true)
     {
          horz_margin_ = horz_margin;
          vert_margin_ = vert_margin;
          bOuterMargin_ = bOuterMargin;
     }

     POINT margin() const
     {
          POINT pt = { horz_margin_, vert_margin_ };
          return pt;
     }

          
     void add_painter(const key_type& key, const painter_base& painter)
     {
          add_painter_impl(key, painter.clone());
     }

    template <class Painter>
    void add_painter(const key_type& key)
    {     
          add_painter_impl(key, new Painter());        
    }

    template <class Painter>
    void add_painter(const key_type& key, typename Painter::param0 param)
    {
          add_painter_impl(key, new Painter(param));        
    }

    template <class Painter>
    void add_painter(const key_type& key, typename Painter::param0 param0, typename Painter::param1 param1)
    {
          add_painter_impl(key, new Painter(param0, param1));
    }     

     void delete_all_painters()
     {
          map_painters_.clear();
     }

     void delete_painter(const key_type& key)
     {
          map_painters_.erase(find_painter_iterator(key));       
     }

     std::vector<key_type> get_keys() const
     {
          std::vector<key_type> keys;
          keys.reserve(map_keys_.size());
          for (PainterMap::const_iterator it = map_painters_.begin(); it != map_painters_.end(); ++it)
               keys.push_back(it->first);
          return keys;
     }

     template <class Painter>
    Painter& get_painter(const key_type& key) const
    {
          PainterPtr pPainter = find_painter_iterator(key)->second;
          Painter* p = dynamic_cast<Painter*> (pPainter.get());
          if (p == NULL)
               throw invalid_painter_cast(*this);

        return *p;                 
    }

     void draw(HDC hDC, int cx, int cy)
     {         
          if (row_count() == 0 || col_count() == 0)
               return;
          
          // calculate scaled margin and default width and height of a cell
          const unsigned HORZ_MARGIN_COUNT = bOuterMargin_ ? col_count() + 1 : col_count() - 1;
          const unsigned VERT_MARGIN_COUNT = bOuterMargin_ ? row_count() + 1 : row_count() - 1;
          const unsigned HORZ_MARGIN = horz_margin_;
          const unsigned VERT_MARGIN = vert_margin_;
          const int DEF_WIDTH         = (cx - HORZ_MARGIN * HORZ_MARGIN_COUNT) / col_count();
          const int DEF_HEIGHT        = (cy - VERT_MARGIN * VERT_MARGIN_COUNT) / row_count();
          if (DEF_WIDTH <= 0 || DEF_HEIGHT <= 0)
               return;        

          for (unsigned row = 0; row < row_count(); ++row) {               
               for (unsigned col = 0; col < col_count(); ++col) {                    
                    cell_type cell = (*this) [col][row];                                       

                    // empty field?
                    key_type key = cell;                    
                    if (key == default_cell_data())
                         continue;                                                        

                    // if a cell is in a range only the upper left cell will be drawn!
                    bg_wnd::cell_range range = cell.range();
                    if (col != range.top_left().col() || row != range.top_left().row())
                         continue;

                    // calculate position and size of the cell
                    factor left   = cell.log_left();
                    factor top    = cell.log_top();                                       
                    factor width  = cell.log_width();
                    factor height = cell.log_height();

                    POINT ptTopLeft = { (long) (DEF_WIDTH * left), (long) (DEF_HEIGHT * top) };
                    SIZE size      = { (long) (DEF_WIDTH * width), (long) (DEF_HEIGHT * height) };
                    
                    // add margin
                    ptTopLeft.x += bOuterMargin_ ? (col + 1) * HORZ_MARGIN : col * HORZ_MARGIN;
                    ptTopLeft.y += bOuterMargin_ ? (row + 1) * VERT_MARGIN : row * VERT_MARGIN;
                    size.cx        += (range.horz_count() - 1) * HORZ_MARGIN;
                    size.cy        += (range.vert_count() - 1) * VERT_MARGIN;
                    
                    try {
                         bg_wnd::memory_dc memDC;
                         memDC.create_dc(hDC, size.cx, size.cy);
                         BitBlt(memDC, 0, 0, size.cx, size.cy, hDC, ptTopLeft.x, ptTopLeft.y, SRCCOPY);

                         get_painter<painter_base> (key).draw(memDC, size.cx, size.cy);
                         memDC.bitblt(hDC, ptTopLeft.x, ptTopLeft.y, size.cx, size.cy);
                    }
                    catch (bg_wnd::general_exception_of_type<self>&) {                              
                         _ASSERTE(false);              // shouldn't throw...something is wrong                     
                         continue;
                    }                             
               }              
          }
     }

private:
     // adds a painter
     void add_painter_impl(const key_type& key, painter_base* pPainter)
     {
          _ASSERTE(pPainter);                     // pPainter must be a valid pointer to an object

          // check if key already exists
          if (key == default_cell_data() || map_painters_.find(key) != map_painters_.end()) {
               delete pPainter;
               throw key_already_used(*this);
          }
          else {
               try {
                    map_painters_.insert( PainterMap::value_type(key, PainterPtr(pPainter)) );
               }
               catch (...) {
                    delete pPainter;
                    throw;
               }
          }
     }

     typename PainterMap::iterator find_painter_iterator(const key_type& key)
     {
          PainterMap::iterator it = map_painters_.find(key);
          if (it == map_painters_.end())
               throw key_invalid(*this);
          return it;
     }

     typename PainterMap::const_iterator find_painter_iterator(const key_type& key) const
     {
          PainterMap::const_iterator it = map_painters_.find(key);
          if (it == map_painters_.end())
               throw key_invalid(*this);
          return it;
     }
     
     PainterMap map_painters_;
     unsigned horz_margin_;        
     unsigned vert_margin_;        
     bool  bOuterMargin_;
};

} }  // namespace win32::gui

---