sprint/gtl/Brush.h

Go to the documentation of this file.

/******************************************************************************
 *  GTL: GUI Template Library 
 *    A Cross Platform C++ Wrapper for Win32 users
 *  Copyright (C) 2007-2011 Paolo Medici (www.pmx.it)
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *******************************************************************************/

#ifndef _SPRINT_GTL_BRUSH_H
#define _SPRINT_GTL_BRUSH_H

namespace sprint {
        namespace gtl {

template <bool t_bManaged>
class CBrushT
{
public:
// Data members
        HBRUSH m_hBrush;

// Constructor/destructor/operators
        CBrushT(HBRUSH hBrush = NULL) : m_hBrush(hBrush)
        { }

// costruttore con un COLORREF crea un pennello solido
        CBrushT(COLORREF col) : m_hBrush(::CreateSolidBrush(col))
        {
        }
                
        ~CBrushT()
        {
                if(t_bManaged && m_hBrush != NULL)
                        DeleteObject();
        }

        CBrushT<t_bManaged>& operator =(HBRUSH hBrush)
        {
                Attach(hBrush);
                return *this;
        }

        void Attach(HBRUSH hBrush)
        {
                if(t_bManaged && m_hBrush != NULL && m_hBrush != hBrush)
                        ::DeleteObject(m_hBrush);
                m_hBrush = hBrush;
        }

        HBRUSH Detach()
        {
                HBRUSH hBrush = m_hBrush;
                m_hBrush = NULL;
                return hBrush;
        }

        operator HBRUSH() const { return m_hBrush; }

        bool IsNull() const { return (m_hBrush == NULL); }

// Create methods
        HBRUSH CreateSolidBrush(COLORREF crColor)
        {
                m_hBrush = ::CreateSolidBrush(crColor);
                return m_hBrush;
        }

// Crea un Brush
        HBRUSH CreatePatternBrush(HBITMAP hBitmap)
        {
                m_hBrush = ::CreatePatternBrush(hBitmap);
                return m_hBrush;
        }

// Crea un Brush
        HBRUSH CreateSysColorBrush(int nIndex)
        {
                m_hBrush = ::GetSysColorBrush(nIndex);
                return m_hBrush;
        }

        BOOL DeleteObject()
        {
                BOOL bRet = ::DeleteObject(m_hBrush);
                if(bRet)
                        m_hBrush = NULL;
                return bRet;
        }

        int GetLogBrush(LOGBRUSH* pLogBrush) const
        {
                return ::GetObject(m_hBrush, sizeof(LOGBRUSH), pLogBrush);
        }

        bool GetLogBrush(LOGBRUSH& LogBrush) const
        {
                return (::GetObject(m_hBrush, sizeof(LOGBRUSH), &LogBrush) == sizeof(LOGBRUSH));
        }
};

typedef CBrushT<false>   CBrushHandle;
typedef CBrushT<true>    CBrush;

inline CBrushHandle BlackBrush() { return (HBRUSH)::GetStockObject(BLACK_BRUSH); }
inline CBrushHandle WhiteBrush() { return (HBRUSH)::GetStockObject(WHITE_BRUSH); }

        }
} 

#endif