background_wnd/background_wnd.hpp

// background_wnd.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.

// version history in version.txt


#pragma once
#include <background_wnd/painter_holder.hpp>
#include <background_wnd/detail/memory_dc.hpp>
#include <win32gui/window.hpp>                    // win32gui


namespace win32 { namespace gui {


struct background_wnd_handler;            // forward-declarations


// ============================================================================================================= //
// background_wnd

class background_wnd : public wnd_extend<window_base, background_wnd>
{
private:
    struct painter_info;

     typedef boost::shared_ptr<painter_info> PainterInfoPtr;
     typedef std::vector<PainterInfoPtr> PainterColl;
     typedef PainterColl::iterator      iterator;
     typedef PainterColl::const_iterator const_iterator;

public:
     // exceptions
     typedef bg_wnd::general_exception<background_wnd, 0> index_invalid;
     typedef bg_wnd::general_exception<background_wnd, 1> invalid_painter_cast;


     // c'tor
     background_wnd();

     // add and remove painters
     unsigned add_painter(const painter_base& painter);
     void delete_painter(unsigned idx);
     void delete_all_painters();

     // direct access to painters
     painter_base& get_painter(unsigned idx) const;
     std::vector<unsigned> get_indices() const;

     // drawing rectangle
     void drawing_rect(unsigned idx, const rectangle& rc);
     rectangle drawing_rect(unsigned idx) const;

     // visibility state and transparency
     bool is_painter_visible(unsigned idx) const;
     void show_painter(unsigned idx, bool bVisible);
     void transparency(unsigned idx, unsigned transparency);
     unsigned transparency(unsigned idx) const;
     void redraw_on_changes(bool bRedraw);
     bool redraw_on_changes() const;
     void redraw_painters();

     // z-order
     void zorder_to_front(unsigned idx);
     void zorder_to_back(unsigned idx);
     void zorder_forward(unsigned idx);
     void zorder_backward(unsigned idx);

     // background-color of window
     void bk_color(COLORREF cr);
     COLORREF bk_color() const;

public:
     // template-memberfunctions

     template <class Painter> unsigned add_painter()
     {
          return add_raw_painter(new Painter());
     }

     template <class Painter> unsigned add_painter(typename Painter::param0 param)
     {
          return add_raw_painter(new Painter(param));
     }

     template <class Painter> unsigned add_painter(typename Painter::param0 param0, typename Painter::param1 param1)
     {
          return add_raw_painter(new Painter(param0, param1));
     }

     template <class Painter> Painter& get_painter(unsigned idx) const
     {
          try {
               return find_painter_info(idx).get_painter<Painter> ();
          }
          catch (painter_holder::invalid_painter_cast&) {
               throw invalid_painter_cast(*this);           // throw our own exception ;-)
          }
     }

protected:
     // interface for derived classes
     bg_wnd::memory_dc& get_mem_dc();
     const bg_wnd::memory_dc& get_mem_dc() const;

private:
     // painter access
     unsigned add_raw_painter(painter_base* pPainter);
     iterator find_painter_info_iterator(unsigned idx) const;
     painter_info& find_painter_info(unsigned idx) const;

     // memory dc and painting functions
     void create_mem_dc(HDC hDC);
    void redraw_mem_dc();
    void redraw_one_painter(PainterInfoPtr pInfo, const rectangle& rc_painter);
     rectangle get_actual_drawing_rect(PainterInfoPtr pInfo) const;
     static bool is_overlapped(const rectangle& rc, const std::vector<rectangle>& rects);
     bool is_partially_visible(const_iterator it_painter, const rectangle& rc_painter) const;


     // struct with additional information about a painter
     struct painter_info : painter_holder
    {
        painter_info(unsigned idx, painter_base* pPainter)
            : idx_(idx), painter_holder(pPainter), bVisible_(true), transparency_(255)
        {}

          unsigned       idx_;
        rectangle        rc_drawing_;
        bool             bVisible_;
          unsigned       transparency_;
    };

    friend struct background_wnd_handler;

    mutable PainterColl coll_painters_;
     bg_wnd::memory_dc mem_dc_;
     COLORREF  cr_bkgnd_;
     bool   bRedraw_on_changes_;
     unsigned  next_index_;
};


// ========================================================================================================== //
// background_wnd_by_key

// thx to John Torjo for his suggestions about a separation of background_wnd and a keyed background_wnd

template <class Key>
class background_wnd_by_key : private wnd_extend<background_wnd, background_wnd_by_key>,
                                     public  wnd_extend<window_base, background_wnd_by_key>
{
     typedef std::map<Key, unsigned>    KeyMap;
     typedef background_wnd_by_key<Key> self;
     typedef background_wnd Base;

     KeyMap map_keys_;
public:
     typedef Key key_type;

     // 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;


     // add and remove painters
     void add_painter(const key_type& key, painter_base& painter)
     {
          check_key_invalid(key);
          unsigned idx = Base::add_painter(painter);
          insert_key(key, idx);
     }

     template <class Painter> void add_painter(const key_type& key)
     {
          check_key_invalid(key);
          unsigned idx = Base::add_painter<Painter> ();
          insert_key(key, idx);
     }

     template <class Painter> void add_painter(const key_type& key, typename Painter::param0 param)
     {
          check_key_invalid(key);
          unsigned idx = Base::add_painter<Painter> (param);
          insert_key(key, idx);
     }

     template <class Painter> void add_painter(const key_type& key, typename Painter::param0 param0, typename Painter::param1 param1)
     {
          check_key_invalid(key);
          unsigned idx = Base::add_painter<Painter> (param0, param1);
          insert_key(key, idx);
     }

     void delete_painter(const key_type& key)
     {
          Base::delete_painter(key_index(key));
          map_keys_.erase(key);
     }

     void delete_all_painters()
     {
          Base::delete_all_painters();
          map_keys_.clear();
     }

     // direct access to painters
     painter_base& get_painter(const key_type& key) const
     {
          return Base::get_painter(key_index(key));
     }

     template <class Painter> Painter& get_painter(const key_type& key) const
     {
          try {
               return Base::get_painter<Painter> (key_index(key));
          }
          catch (Base::invalid_painter_cast&) {
               throw invalid_painter_cast(*this);           // throw our own exception ;-)
          }
     }

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

     // drawing rectangle
     void drawing_rect(const key_type& key, const rectangle& rc)
     {
          Base::drawing_rect(key_index(key), rc);
     }

     rectangle drawing_rect(const key_type& key) const
     {
          return Base::drawing_rect(key_index(key));
     }

     // visibility state and transparency
     bool is_painter_visible(const key_type& key) const
     {
          return Base::is_painter_visible(key_index(key));
     }

     void show_painter(const key_type& key, bool bVisible)
     {
          Base::show_painter(key_index(key), bVisible);
     }

     void transparency(const key_type& key, unsigned transparency)
     {
          Base::transparency(key_index(key), transparency);
     }

     unsigned transparency(const key_type& key) const
     {
          return Base::transparency(key_index(key));
     }

     void redraw_on_changes(bool bRedraw)
     {
          Base::redraw_on_changes(bRedraw);
     }

     bool redraw_on_changes() const
     {
          return Base::redraw_on_changes();
     }

     // z-order
     void zorder_to_front(const key_type& key)
     {
          Base::zorder_to_front(key_index(key));
     }

     void zorder_to_back(const key_type& key)
     {
          Base::zorder_to_back(key_index(key));
     }

     void zorder_forward(const key_type& key)
     {
          Base::zorder_forward(key_index(key));
     }

     void zorder_backward(const key_type& key)
     {
          Base::zorder_backward(key_index(key));
     }

     // background-color of window
     void bk_color(COLORREF cr)
     {
          Base::bk_color(cr);
     }

     COLORREF bk_color() const
     {
          return Base::bk_color();
     }

protected:
     bg_wnd::memory_dc& get_mem_dc()
     {
          return Base::get_mem_dc();
     }

     const bg_wnd::memory_dc& get_mem_dc() const
     {
          return Base::get_mem_dc();
     }


private:
     void insert_key(const key_type& key, unsigned idx)
     {
          try {
               map_keys_.insert( KeyMap::value_type(key, idx) );
          }
          catch (...) {
               Base::delete_painter(idx);
               throw;
          }
     }

     void check_key_invalid(const key_type& key) const
     {
          if (map_keys_.find(key) != map_keys_.end())
               throw key_already_used(*this);
     }

     unsigned key_index(const key_type& key) const
     {
          KeyMap::const_iterator it = map_keys_.find(key);
          if (it == map_keys_.end())
               throw key_invalid(*this);
          return it->second;
     }
};


} }  // namespace win32::gui