ColorBlob.cpp

Go to the documentation of this file.

#include "stdafx.h"
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
//
//
//                                                  WTL Control Library
//                                                           by
//                                            Bright Ideas Software®
//                               Copyright © 2018 by Bright Ideas Software.
//
//
//
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------


namespace BIS_WTL_CONTROLS
{
    //----------------------------------------------------------------------------------------------
    CColorBlob::CColorBlob() noexcept
    {
        m_hMemDC = NULL;
        m_hOldMap = NULL;
        m_hbrBackBrush = NULL;

        m_bDirtyColor = true;
        m_bUpdateContent = true;

        m_clrBackColor = CLR_RED;
        m_EdgeStyle = CEdgeStyle::esLine;
    }
    //----------------------------------------------------------------------------------------------
    CColorBlob::~CColorBlob()
    {
        ATLASSERT( m_hWnd == NULL);

        DestroyGDIStuff();

        if (m_hbrBackBrush != NULL)
        {
            ::DeleteObject (m_hbrBackBrush);
            m_hbrBackBrush = NULL;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void CColorBlob::SubclassStatic(HWND hWnd)
    {

        CWindowImpl<CColorBlob, CStatic>::SubclassWindow(hWnd);
        UpdateBackBrush();

    }                                                                                                                            
    //----------------------------------------------------------------------------------------------
    void CColorBlob::UnSubclassStatic()
    {

        DestroyGDIStuff();

        if (m_hbrBackBrush != NULL)
        {
            ::DeleteObject (m_hbrBackBrush);
            m_hbrBackBrush = NULL;
        }

        UnsubclassWindow();
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    COLORREF CColorBlob::GetBackColor() const
    {
        return(m_clrBackColor);
    }
    //----------------------------------------------------------------------------------------------
    void CColorBlob::SetBackColor(COLORREF value)
    {
        m_bDirtyColor = true;
        m_clrBackColor = value;
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    CEdgeStyle CColorBlob::GetEdgeStyle() const
    {
        return(m_EdgeStyle);
    }
    //----------------------------------------------------------------------------------------------
    void CColorBlob::SetEdgeStyle(CEdgeStyle style)
    {
        if (m_EdgeStyle != style)
        {
            m_EdgeStyle = style;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void CColorBlob::UpdateContent()
    {
        m_bUpdateContent = true;
        Invalidate();
        UpdateWindow(); 
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    //
    //                                                      Private Methods
    //
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void CColorBlob::UpdateBackBrush()
    {
        m_bDirtyColor = false;

        if (m_hbrBackBrush != NULL)
        {
            ::DeleteObject (m_hbrBackBrush);
            m_hbrBackBrush = NULL;
        }

        m_hbrBackBrush = ::CreateSolidBrush (m_clrBackColor);

        m_bUpdateContent = true;
    }
    //----------------------------------------------------------------------------------------------
    void CColorBlob::PrepareGDIStuff()
    {
        DestroyGDIStuff();

        CRect r;
        GetClientRect(&r);

        if (::IsWindow(m_hWnd))
        {
            if ((r.Width() > 0)&&(r.Height() > 0))
            {
                m_hCanvas.Create(r.Width(), r.Height(), 24, 0);

                if (! m_hCanvas.IsNull())
                {

                    HDC dc = ::GetDC(m_hWnd);
                    m_hMemDC = ::CreateCompatibleDC(dc);

                    if (m_hMemDC != NULL)
                        m_hOldMap = (HBITMAP)::SelectObject(m_hMemDC, (HBITMAP)m_hCanvas);
                    else
                        m_hCanvas.Destroy();;

                    ::ReleaseDC(m_hWnd, dc);
                    m_bUpdateContent = true;
                }
            }
        }
    }
    //----------------------------------------------------------------------------------------------
    void CColorBlob::DestroyGDIStuff()
    {

        if (m_hMemDC != NULL)
        {
            if (m_hCanvas != NULL)
            {
                ::SelectObject(m_hMemDC, m_hOldMap);
                m_hOldMap = NULL;

                m_hCanvas.Destroy();
            }
            ::DeleteDC(m_hMemDC);
            m_hMemDC = NULL; 
        }

    }
    //----------------------------------------------------------------------------------------------
    void CColorBlob::DrawEdge(CRect r)
    {

        switch (m_EdgeStyle)
        {
            case CEdgeStyle::esNone:
            break;
        case CEdgeStyle::esLine:
            OutlineRect(m_hMemDC, r);
            break;
        case CEdgeStyle::esBump:
            ::DrawEdge(m_hMemDC, r, EDGE_BUMP,BF_RECT  );
            break;
        case CEdgeStyle::esEtched:
            ::DrawEdge(m_hMemDC, r, EDGE_ETCHED,BF_RECT );
            break;
        case CEdgeStyle::esRaised:
            ::DrawEdge(m_hMemDC, r, EDGE_RAISED,BF_RECT );
            break;
        case CEdgeStyle::esSunken:
            ::DrawEdge(m_hMemDC, r, EDGE_SUNKEN,BF_RECT);
            break;
        case CEdgeStyle::esThinRaised:
            ::DrawEdge(m_hMemDC, r, BDR_RAISEDOUTER,BF_RECT );
            break;
        case CEdgeStyle::esThinSunken:
            ::DrawEdge(m_hMemDC, r, BDR_SUNKENOUTER,BF_RECT);
            break;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    //
    //                                                  Message Handlers
    //
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    BOOL CColorBlob::OnEraseBkgnd(CDCHandle dc)
    {
        return(TRUE);
    }
    //----------------------------------------------------------------------------------------------
    LRESULT CColorBlob::OnPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
    {
        CRect rect;

        HDC dc = NULL;
        bool do_end_paint = false;
        PAINTSTRUCT ps;

        if (wParam != NULL)
            dc = (HDC)wParam;
        else
        {
            RECT update_rect{ 0 };
            if (GetUpdateRect(&update_rect) != 0)
            {
                dc = BeginPaint(&ps);
                do_end_paint = true;
            }
        }

        if (dc == NULL)
            return(0);

        if (m_bDirtyColor == true)
            UpdateBackBrush();

        GetClientRect(&rect);


        if  ((m_hMemDC == NULL)||(m_hCanvas.IsNull()))
            PrepareGDIStuff();

        if ((m_hMemDC != NULL)&&( ! m_hCanvas.IsNull()))
        {

            if ((rect.Width() != m_hCanvas.GetWidth())||(rect.Height() != m_hCanvas.GetHeight()))
                PrepareGDIStuff();

            if (m_bUpdateContent)
            {
                m_bUpdateContent = false;

                ::FillRect(m_hMemDC, rect, m_hbrBackBrush);
                ::SetBkColor(m_hMemDC, m_clrBackColor);

                DrawEdge(rect);
            }

            ::BitBlt (dc, 0, 0,rect.Width (), rect.Height (), m_hMemDC, 0, 0, SRCCOPY);

        }

        if (do_end_paint == true)
            EndPaint(&ps);

        bHandled = TRUE;

        return(0);
    }
    //----------------------------------------------------------------------------------------------
};