background_wnd.cpp

// background_wnd.cpp

// 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/detail/include.hpp>
#include <background_wnd/background_wnd.hpp>

#include <win32gui/window.hpp>                    // win32gui
#include <win32gui/event_handler.hpp>


namespace win32 { namespace gui {


// ============================================================================================================= //
// background_wnd-class

// ========================================================================================================== //
// Public interface

// c'tor
background_wnd::background_wnd() : cr_bkgnd_(RGB(255, 255, 255)), bRedraw_on_changes_(true), next_index_(0)
{}

void background_wnd::bk_color(COLORREF cr)
{
     if (cr != cr_bkgnd_) {
          cr_bkgnd_ = cr;
          if (bRedraw_on_changes_)           // redraw
               redraw_painters();
     }         
}

COLORREF background_wnd::bk_color() const
{
     return cr_bkgnd_;
}

unsigned background_wnd::add_painter(const painter_base& painter)
{    
     return add_raw_painter(painter.clone());     
}

void background_wnd::delete_painter(unsigned idx)
{
     coll_painters_.erase( find_painter_info_iterator(idx) );    
     if (bRedraw_on_changes_)                // redraw
          redraw_painters();
}

void background_wnd::delete_all_painters()
{
     coll_painters_.clear();
     if (bRedraw_on_changes_)                // redraw
          redraw_painters();
}

painter_base& background_wnd::get_painter(unsigned idx) const
{
     return find_painter_info(idx).get_painter();
}


std::vector<unsigned> background_wnd::get_indices() const
{
     std::vector<unsigned> indices;
     indices.reserve(coll_painters_.size());
     for (iterator it = coll_painters_.begin(); it != coll_painters_.end(); ++it)
          indices.push_back( (*it)->idx_ );
     return indices;        
}

void background_wnd::drawing_rect(unsigned idx, const rectangle& rc)
{      
     find_painter_info(idx).rc_drawing_ = rc;     
     if (bRedraw_on_changes_)                // redraw
          redraw_painters();
}

rectangle background_wnd::drawing_rect(unsigned idx) const
{     
     return find_painter_info(idx).rc_drawing_;    
}

bool background_wnd::is_painter_visible(unsigned idx) const
{
     return find_painter_info(idx).bVisible_;         
}

void background_wnd::show_painter(unsigned idx, bool bVisible)
{        
     painter_info& info = find_painter_info(idx);
    if ( info.bVisible_ != bVisible) {
        info.bVisible_ = bVisible;
        if (bRedraw_on_changes_)                  // redraw
               redraw_painters();
    }
}    

void background_wnd::redraw_on_changes(bool bRedraw)
{
     bRedraw_on_changes_ = bRedraw;
}

bool background_wnd::redraw_on_changes() const
{
     return bRedraw_on_changes_;
}

void background_wnd::redraw_painters()
{
     if (mem_dc_) {
          // fill background            
          HBRUSH hbr = CreateSolidBrush(cr_bkgnd_);
          FillRect(mem_dc_, &window_rect(rel_to_self), hbr);        
          DeleteObject((HGDIOBJ) hbr);    

          // redraw DC and invalidate window
          redraw_mem_dc();
          redraw();
     }
}

void background_wnd::transparency(unsigned idx, unsigned transparency)
{
     painter_info& info = find_painter_info(idx);

     transparency = min<unsigned> (255, transparency);
     if (info.transparency_ != transparency) {
          info.transparency_ = transparency;
          if (bRedraw_on_changes_)           // redraw
               redraw_painters();
     }
}

unsigned background_wnd::transparency(unsigned idx) const
{
     return find_painter_info(idx).transparency_;
}

// Z-Order functions
// note: painters at the end of the sequence are on top of the Z-Order

void background_wnd::zorder_to_front(unsigned idx)
{  
     iterator it = find_painter_info_iterator(idx);
     if (it != coll_painters_.end() - 1) {        
        PainterInfoPtr p = *it;                   // lovely boost::shared_ptr's copy c'tor doesn't throw :-)
        coll_painters_.erase(it);
        coll_painters_.push_back(p);  

          if (bRedraw_on_changes_)           // redraw
               redraw_painters();
    }     
}

void background_wnd::zorder_to_back(unsigned idx)
{    
     iterator it = find_painter_info_iterator(idx);
    if (it != coll_painters_.begin()) {
        PainterColl tmp;
        tmp.reserve(coll_painters_.size());
        tmp.push_back(*it);            
        std::copy( coll_painters_.begin(), it, std::back_inserter(tmp) );
          std::copy( it + 1, coll_painters_.end(), std::back_inserter(tmp) );
        coll_painters_.swap(tmp);            

          if (bRedraw_on_changes_)           // redraw
               redraw_painters();
    }
}    

void background_wnd::zorder_forward(unsigned idx)
{    
     iterator it = find_painter_info_iterator(idx);
     if (it != coll_painters_.end() - 1) {
          std::swap(*it, *(it + 1));
          
          if (bRedraw_on_changes_)           // redraw
               redraw_painters();
     }
}

void background_wnd::zorder_backward(unsigned idx)
{  
     iterator it = find_painter_info_iterator(idx);
     if (it != coll_painters_.begin()) {
          std::swap(*it, *(it - 1));
          
          if (bRedraw_on_changes_)           // redraw
               redraw_painters();
     }
}


// ========================================================================================================== //
// Protected interface

bg_wnd::memory_dc& background_wnd::get_mem_dc()
{
    return mem_dc_;
}

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


// ========================================================================================================== //
// Implementation

// Adds a painter and returns the index of this new painter
unsigned background_wnd::add_raw_painter(painter_base* pPainter)
{    
     try {          
          coll_painters_.push_back( PainterInfoPtr(new painter_info(next_index_, pPainter)) );
          ++next_index_;
     }
     catch (...) {
          delete pPainter;
          throw;
     }

     if (bRedraw_on_changes_)                // redraw
          redraw_painters();
     return next_index_ - 1;
}

// finds a painter_info by index
background_wnd::iterator background_wnd::find_painter_info_iterator(unsigned idx) const
{
     for (iterator it = coll_painters_.begin(); it != coll_painters_.end(); ++it) {
        if ((*it)->idx_ == idx)
            return it;
    }
     throw index_invalid(*this);             // no painter with this index -> throw    
}

// finds a painter_info by index
background_wnd::painter_info& background_wnd::find_painter_info(unsigned idx) const
{
     iterator it = find_painter_info_iterator(idx);
     return *( (*it).get() ); 
}

// creates the memory dc
void background_wnd::create_mem_dc(HDC hDC)
{
     if (mem_dc_ == NULL) {                  
        rectangle rc = window_rect(rel_to_self);
          COLORREF crOld = SetBkColor(hDC, cr_bkgnd_); // set background color so the memdc is filled with it ;-)
          mem_dc_.create_dc(hDC, rc.width(), rc.height());            
          SetBkColor(hDC, crOld);

        // draw memory dc
        redraw_mem_dc();
    }
}

// returns the actual rectangle in which a painter is drawn. if the drawing rect has a width or height of 0
// or less the painter will be drawn in full client-rectangle size
rectangle background_wnd::get_actual_drawing_rect(PainterInfoPtr pInfo) const
{    
     // FIX_3
     // If drawing rect width/height is less than 0 now the width or the height are
     // separately scaled to client width/height

     // if drawing-rect is null take client-rect
     rectangle rc_painter = pInfo->rc_drawing_;
     rectangle rc_window = window_rect(rel_to_self);
     if (rc_painter.width() <= 0)
          rc_painter.right = rc_window.width();
     if (rc_painter.height() <= 0)
          rc_painter.bottom = rc_window.height();
     
     return rc_painter;
}

// determines if rc is totally overlapped by the rectangles stored in rects. it would be possible to use 
// regions instead of this function but they're very slow
bool background_wnd::is_overlapped(const rectangle& rc, const std::vector<rectangle>& rects)
{         
     typedef std::vector<rectangle> RectangleCont;
     RectangleCont intersecting;
     unsigned area_rect = rc.height() * rc.width();
     unsigned area_total = 0;      

     // walk through all rectangles and accumulate the area intersecting rc
     for (RectangleCont::const_iterator it_added = rects.begin(); it_added != rects.end(); ++it_added) {                          
          rectangle  rc_intersect;
          if ( IntersectRect(&rc_intersect, &rc, &(*it_added)) ) {

               // because more than one added rectangles can overlap themselves we have to take care of that...
               for (RectangleCont::const_iterator it_intersected = intersecting.begin(); it_intersected != intersecting.end(); ++it_intersected) {                                                 
                    rectangle rc_temp;
                    if ( IntersectRect(&rc_temp, &rc_intersect, &(*it_intersected)) ) {

                         // if the intersection isn't big enough for SubtractRect() to succeed subtract the area of the
                         // intersection from area_total!
                         const int width = rc_temp.width();
                         const int height = rc_temp.height();
                         if (width < rc_intersect.width() && height < rc_intersect.height())
                              area_total -= width * height;                          
                         else
                              SubtractRect( &rc_intersect, &rc_intersect, &(*it_intersected) );
                    }
               }

               const int width = rc_intersect.width();
               const int height = rc_intersect.height();
               if (width && height) {
                    intersecting.push_back(rc_intersect);
                    area_total += rc_intersect.width() * rc_intersect.height();
                    
                    // early return?
                    if (area_total >= area_rect)
                         return true;
               }
          }              
     }
     return area_total >= area_rect;
}

// determines if a painter is partially visible. necessary for avoiding unnecessary redrawing
bool background_wnd::is_partially_visible(const_iterator it_info, const rectangle& rc_painter) const
{         
     // if painter invisible return immediately
     if ( (*it_info)->bVisible_ == false || (*it_info)->transparency_ == 0)
          return false;
     
     // test if this painter is overlapped by another painter which is 
     //        - higher in the z-order (for-loop)
     //        - has a bigger drawing_rect than this painter
     //        - visible (bVisible_ set to true)
     //        - opaque (transparency_ set to 255 and painter_base::is_opaque() returns true)
     //
     // note: it is possible that some painters TOGETHER overlap this painter...is_overlapped() checks this   
     std::vector<rectangle> rects_accumulated;         
     for (const_iterator it = it_info + 1; it != coll_painters_.end(); ++it) {
                         
          if ( (*it_info)->bVisible_ == true && (*it)->transparency_ == 255 && (*it)->get_painter().is_opaque(rc_painter.width(), rc_painter.height()) ) {
               rectangle rc = get_actual_drawing_rect(*it);
               ++rc.right; ++rc.bottom;           // increase by 1 because bottom right is excluded by contains_point()...
               if ( rc.contains_point(rc_painter.top_left()) && rc.contains_point(rc_painter.bottom_right()) )
                    return false;                 
               else {
                    --rc.right; --rc.bottom;      // reset rc
                    rects_accumulated.push_back(rc);                       
               }
          }
     }
     
     // no painter overlapped overlapped the passed painter by itself...so call is_overlapped() for the accumulated
     // painter drawing-rects
     return is_overlapped(rc_painter, rects_accumulated) == false;
}

// redraws the memory dc
void background_wnd::redraw_mem_dc()
{                   
    // Draw painters        
     for (iterator it = coll_painters_.begin(); it != coll_painters_.end(); ++it) {                                                         
          rectangle rc_painter = get_actual_drawing_rect(*it);
                    
          // only draw the painter if it is partially visible...
          if (is_partially_visible(it, rc_painter))         
               redraw_one_painter(*it, rc_painter);
     }
}

// Draws a painter on the memory DC  
void background_wnd::redraw_one_painter(PainterInfoPtr pInfo, const rectangle& rc_painter)
{        
     const int x = rc_painter.left;          const int y = rc_painter.top;
     const int cx = rc_painter.width(); const int cy = rc_painter.height();

     // FIX_2
     // because we now have a separate DC for the painter, it can't paint outside
     // its drawing-rect (before this fix the painter drawed directly on the memory
     // DC...). so the clipping works now correct! this change also affects the interface 
     // of painter_base: the draw()-function now doesn't need the x- and y-parameters - they're 
     // always 0!
     bg_wnd::memory_dc hPainterDC;
     hPainterDC.create_dc(get_mem_dc(), cx, cy);

     // FIX_1
     // if a painter was transparent and not all of the area of the drawing rect is drawn 
     // (-> transparent) it would be filled with the background-color of hTransparentDC.
     // because it is transparent you would see a colored glow...          
     get_mem_dc().bitblt(hPainterDC, 0, 0, cx, cy, x, y);

     // FIX_2
     // draw painter to painter DC      
     pInfo->get_painter().draw( hPainterDC, cx, cy );                 

     // painter is opaque so bitblt from the painter DC to the memory DC
     if (pInfo->transparency_ == 255) {                                    
          hPainterDC.bitblt(get_mem_dc(), x, y, cx, cy);
     }
     // painter is transparent so call AlphaBlend()
     else {
          BLENDFUNCTION bf;
          bf.BlendOp = AC_SRC_OVER;
          bf.BlendFlags = NULL;
          bf.SourceConstantAlpha = pInfo->transparency_;
          bf.AlphaFormat = 0;                     // ignore the alpha channel
          AlphaBlend(get_mem_dc(), x, y, cx, cy, hPainterDC, 0, 0, cx, cy, bf);           
     }
}
      

// ============================================================================================================= //
// Handler for background_wnd

struct background_wnd_handler : event_handler<background_wnd_handler, background_wnd>
{
    handle_event on_erase_bkgnd(w_param<HDC> hDC, result res)
    {        
        // first make sure the memory DC is created
        window()->create_mem_dc(hDC);
          rectangle rc = window()->window_rect(rel_to_self);            
          window()->mem_dc_.bitblt(hDC, 0, 0, rc.width(), rc.height());
        
        res = true;        
        return event<WM_ERASEBKGND> ().HANDLED_BY(&me::on_erase_bkgnd);
    }

    handle_event on_size(l_param_lo cx, l_param_hi cy)
    {
          if (cx > 0 && cy > 0 && window()->mem_dc_) {
               SIZE size = window()->mem_dc_.size();
                   
               // If
               // (1) the window's size increases
               // (2) the window's size is FACTOR times smaller than the memory DC's
               // -> delete the memory DC, so it will be recreated in on_erase_bkgnd()
               const int FACTOR = 2;
               if (size.cx < cx || size.cy < cy || cx * FACTOR < size.cx || cy * FACTOR < size.cy)
                    window()->mem_dc_.delete_dc();               
          }
        return event<WM_SIZE> ().HANDLED_BY(&me::on_size);
    }
};


} }  // namespace win32::gui

---