sprint/gtl/Pen.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_PEN_H
#define _SPRINT_PEN_H

namespace sprint {
        namespace gtl {
          
template <bool t_bManaged>
class CPenT
{
public:
// Data members
        HPEN m_hPen;

// Constructor/destructor/operators
        CPenT(HPEN hPen = NULL) : m_hPen(hPen)
        { }

        ~CPenT()
        {
                if(t_bManaged && m_hPen != NULL)
                        DeleteObject();
        }

        CPenT<t_bManaged>& operator =(HPEN hPen)
        {
                Attach(hPen);
                return *this;
        }

        void Attach(HPEN hPen)
        {
                if(t_bManaged && m_hPen != NULL && m_hPen != hPen)
                        ::DeleteObject(m_hPen);
                m_hPen = hPen;
        }

        HPEN Detach()
        {
                HPEN hPen = m_hPen;
                m_hPen = NULL;
                return hPen;
        }

        operator HPEN() const { return m_hPen; }

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

// Create methods
        HPEN CreatePen(int nPenStyle, int nWidth, COLORREF crColor)
        {
                m_hPen = ::CreatePen(nPenStyle, nWidth, crColor);
                return m_hPen;
        }

        HPEN CreateSolidPen(int nWidth, COLORREF crColor)
        {
                return CreatePen(PS_SOLID, nWidth, crColor);
        }

#ifndef _WIN32_WCE
        HPEN CreatePen(int nPenStyle, int nWidth, const LOGBRUSH* pLogBrush, int nStyleCount = 0, const DWORD* lpStyle = NULL)
        {
                m_hPen = ::ExtCreatePen(nPenStyle, nWidth, pLogBrush, nStyleCount, lpStyle);
                return m_hPen;
        }
#endif // !_WIN32_WCE

        HPEN CreatePenIndirect(LPLOGPEN lpLogPen)
        {
                m_hPen = ::CreatePenIndirect(lpLogPen);
                return m_hPen;
        }

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

// Attributes
        int GetLogPen(LOGPEN* pLogPen) const
        {
                return ::GetObject(m_hPen, sizeof(LOGPEN), pLogPen);
        }

        bool GetLogPen(LOGPEN& LogPen) const
        {
                return (::GetObject(m_hPen, sizeof(LOGPEN), &LogPen) == sizeof(LOGPEN));
        }

#ifndef _WIN32_WCE
        int GetExtLogPen(EXTLOGPEN* pLogPen) const
        {
                return ::GetObject(m_hPen, sizeof(EXTLOGPEN), pLogPen);
        }

        bool GetExtLogPen(EXTLOGPEN& ExtLogPen) const
        {
                return (::GetObject(m_hPen, sizeof(EXTLOGPEN), &ExtLogPen) == sizeof(EXTLOGPEN));
        }
#endif // !_WIN32_WCE
};

typedef CPenT<false>   CPenHandle;
typedef CPenT<true>    CPen;

        } // gtl
} // sprint

#endif