cWndGDI.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cWndGDI_H
#define _INC_cWndGDI_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
 
#ifdef _WIN32
#include "../Geometry/cRectI.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cObject.h"
#include "GrayCore/include/cHandlePtr.h"
#include "GrayCore/include/cOSHandle.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cAppState.h"
 
namespace Gray
{
        template <> inline void cHandlePtr<HMENU>::CloseHandle(HMENU h) // static
        {
                ::DestroyMenu(h);
        }
        template <> inline void cHandlePtr<HICON>::CloseHandle(HICON h) // static
        {
                ::DestroyIcon(h);
        }
}
 
namespace GrayLib
{
        class cWndDC;
 
        class GRAYLIB_LINK cWndGDI : public CObject
        {
 
        public:
                HGDIOBJ m_hObject;      // cHandlePtr<HGDIOBJ>
 
        protected:
                void DeleteObjectLast() noexcept
                {
                        if (m_hObject != WINHANDLE_NULL)
                        {
                                ::DeleteObject(m_hObject);
                        }
                }
 
        public:
                cWndGDI(HGDIOBJ hGDIObj = WINHANDLE_NULL) noexcept
                        : m_hObject(hGDIObj)
                {
                }
#ifndef STRICT
                cWndGDI(HBITMAP h) noexcept
                        : m_hObject((HGDIOBJ)h)
                {
                }
#endif
                ~cWndGDI() noexcept
                {
                        DeleteObjectLast();
                }
 
                void Attach(HGDIOBJ hObject) noexcept
                {
                        if (hObject != m_hObject)
                        {
                                DeleteObjectLast();
                                m_hObject = hObject;
                        }
                }
                void Detach() noexcept 
                {
                        m_hObject = WINHANDLE_NULL;
                }
                HGDIOBJ DetachRet() noexcept
                {
                        HGDIOBJ hObject = m_hObject;
                        m_hObject = WINHANDLE_NULL;
                        return hObject;
                }
 
                void DeleteObject() noexcept
                {
                        if (m_hObject != WINHANDLE_NULL)
                        {
                                ::DeleteObject(m_hObject);
                                m_hObject = WINHANDLE_NULL;
                        }
                }
 
                DWORD GetObjectType() const noexcept
                {
                        return ::GetObjectType(m_hObject);
                }
                int GetObjectX(size_t iSizeMax, void* pData) const noexcept
                {
                        return _GTN(::GetObject)(m_hObject, (int)iSizeMax, pData);
                }
                bool GetBitmap(BITMAP* pBitmap) const noexcept
                {
                        return GetObjectX(sizeof(BITMAP), (char*)pBitmap) == sizeof(BITMAP) ;
                }
 
                HGDIOBJ get_Handle() const noexcept
                {
                        return m_hObject;
                }
                operator HGDIOBJ() const noexcept
                {
                        return m_hObject;
                }
                bool isValidHandle() const noexcept
                {
                        return m_hObject != WINHANDLE_NULL ;
                }
 
                HBRUSH get_HBrush() const noexcept
                {
                        return (HBRUSH)m_hObject;
                }
                HPEN get_HPen() const noexcept
                {
                        return (HPEN)m_hObject;
                }
                HRGN get_HRgn() const noexcept
                {
                        return (HRGN)m_hObject;
                }
                HBITMAP get_HBitmap() const noexcept
                {
                        return (HBITMAP)m_hObject;
                }
                HFONT get_HFont() const noexcept
                {
                        return (HFONT)m_hObject;
                }
 
                HBRUSH CreateSolidBrush(COLORREF color) noexcept
                {
                        Attach((HGDIOBJ) ::CreateSolidBrush(color));
                        return get_HBrush();
                }
                HPEN CreatePen(int iStyle, int cWidth, COLORREF color) noexcept
                {
                        Attach((HGDIOBJ) ::CreatePen(iStyle, cWidth, color));
                        return get_HPen();
                }
 
#if 0
                // use cWndBitmap
                HBITMAP CreateCompatibleBitmap(HDC hDC, int cx, int cy)
                {
                        Attach((HGDIOBJ) ::CreateCompatibleBitmap(hDC, cx, cy));
                        return get_HBitmap();
                }
#endif
        };
 
        template <class _TYPE_HANDLE = HGDIOBJ>
        class cWndGDIT : public cWndGDI
        {
 
                typedef cWndGDI SUPER_t;
 
        public:
                cWndGDIT(_TYPE_HANDLE h = WINHANDLE_NULL) noexcept
                : cWndGDI((HGDIOBJ)h)
                {
                }
                _TYPE_HANDLE get_Handle() const
                {
                        return (_TYPE_HANDLE)m_hObject;
                }
                operator _TYPE_HANDLE() const
                {
                        return (_TYPE_HANDLE)m_hObject;
                }
        };
 
        class GRAYLIB_LINK cWndBrush : public cWndGDIT<HBRUSH>
        {
 
                typedef cWndGDIT<HBRUSH> SUPER_t;
 
        public:
                cWndBrush(HBRUSH h = WINHANDLE_NULL) noexcept
                        : cWndGDIT<HBRUSH>(h)
                {
                }
                cWndBrush(COLORREF color)
                        : cWndGDIT<HBRUSH>(::CreateSolidBrush(color))
                {
                }
        };
 
        class GRAYLIB_LINK cWndPen : public cWndGDIT<HPEN>
        {
 
                typedef cWndGDIT<HPEN> SUPER_t;
 
        public:
                cWndPen(HPEN h = WINHANDLE_NULL) noexcept
                        : cWndGDIT<HPEN>(h)
                {
                }
                cWndPen(int iStyle, int cWidth, COLORREF color)
                        : cWndGDIT<HPEN>(::CreatePen(iStyle, cWidth, color))
                {
                }
        };
 
        class GRAYLIB_LINK cWndFont : public cWndGDIT<HFONT>
        {
 
                typedef cWndGDIT<HFONT> SUPER_t;
 
        public:
                cWndFont(HFONT h = WINHANDLE_NULL) noexcept
                : cWndGDIT<HFONT>(h)
                {
                }
                int GetLogFont(_GTN(LOGFONT)& lf) const noexcept
                {
                        return GetObjectX(sizeof(_GTN(LOGFONT)), &lf);
                }
                HFONT CreateFontIndirectX(const _GTN(LOGFONT)* pLogFont) noexcept
                {
                        Attach((HGDIOBJ)_GTN(::CreateFontIndirect)(pLogFont));
                        return get_HFont();
                }
        };
 
        class GRAYLIB_LINK cWndRgn : public cWndGDIT<HRGN>
        {
                typedef cWndGDIT<HRGN> SUPER_t;
        public:
                cWndRgn(HRGN h = WINHANDLE_NULL) noexcept
                : cWndGDIT<HRGN>(h)
                {
                }
                cWndRgn(int nLeft, int nTop, int nRight, int nBottom)
                : cWndGDIT<HRGN>(::CreateRectRgn(nLeft, nTop, nRight, nBottom))
                {
                }
                cWndRgn(const RECT& new_rect)
                : cWndGDIT<HRGN>(::CreateRectRgnIndirect(&new_rect))
                {
                }
                void ClearRgn()
                {
                        DeleteObject();
                }
                HRGN CreateRectRgn(int nLeft, int nTop, int nRight, int nBottom)
                {
                        Attach((HGDIOBJ) ::CreateRectRgn(nLeft, nTop, nRight, nBottom));
                        return get_HRgn();
                }
                HRGN CreateRectRgn(const RECT& new_rect)
                {
                        Attach((HGDIOBJ) ::CreateRectRgnIndirect(&new_rect));
                        return get_HRgn();
                }
                bool SetRectRgn(int nLeft, int nTop, int nRight, int nBottom)
                {
                        return ::SetRectRgn(get_HRgn(), nLeft, nTop, nRight, nBottom);
                }
                int CombineRgn(HRGN hRgn1, HRGN hRgn2, int iMode)
                {
                        return ::CombineRgn(get_HRgn(), hRgn1, hRgn2, iMode);
                }
                bool IsEqualRgn(HRGN hRgn) const
                {
                        return ::EqualRgn(get_HRgn(), hRgn);
                }
                int GetRgnBox(RECT* pRectRet) const
                {
                        return ::GetRgnBox(get_HRgn(), pRectRet);
                }
                int OffsetRgn(int x, int y)
                {
                        return ::OffsetRgn(get_HRgn(), x, y);
                }
                bool PtInRegion(int x, int y) const
                {
                        return ::PtInRegion(get_HRgn(), x, y);
                }
                bool RectInRegion(const RECT* pRect) const
                {
                        return ::RectInRegion(get_HRgn(), pRect);
                }
 
                int AddRect(const RECT& new_rect);
                int SubtractRect(const RECT& new_rect);
 
                void Combine(const cWndRgn &rgn);
                void Intersect(const cWndRgn &rgn);
                void Subtract(const cWndRgn &rgn);
 
                int GetRects(cArrayStruct<RECT>& rects) const;
                bool SetRects(const RECT* pRects, int nCount);
        };
 
        class GRAYLIB_LINK cWndGDISelect
        {
        private:
                HDC m_hDC;
                HGDIOBJ m_hGDIObjPrv;   // Keep previous copy to restore when this is destroyed.
        public:
                cWndGDISelect(HDC hDC, HGDIOBJ hGDIObj) 
                : m_hDC(hDC)
                {
                        ASSERT(hGDIObj != WINHANDLE_NULL);
                        m_hGDIObjPrv = ::SelectObject(hDC, hGDIObj);
                }
                ~cWndGDISelect()
                {
                        ::SelectObject(m_hDC, m_hGDIObjPrv);
                }
        };
 
        class GRAYLIB_LINK cWndGDICur : public cWndGDI, public cWndGDISelect
        {
        public:
                cWndGDICur(HDC hDC, HGDIOBJ hObj)
                : cWndGDI(hObj)
                , cWndGDISelect(hDC, hObj)
                {
                }
        };
 
        class GRAYLIB_LINK cWndIconInfo : public ::ICONINFO
        {
        public:
                cWndGDIT<HBITMAP> m_hbmMask;            
                cWndGDIT<HBITMAP> m_hbmColor;           
 
        public:
                bool InitIconInfo(HICON hIcon)
                {
                        if (!::GetIconInfo(hIcon, static_cast<::ICONINFO*>(this)))
                                return false;
                        m_hbmMask.Attach(this->hbmMask);                // Alpha mask for the bitmap.
                        m_hbmColor.Attach(this->hbmColor);              // color mask. (if color)
                        return true;
                }
                bool InitCursorInfo(HCURSOR hCursor)
                {
                        return InitIconInfo((HCURSOR)hCursor);
                }
        };
 
        typedef cWndGDIT<HCURSOR> cWndCursor;
        typedef cWndGDIT<HICON> cWndIcon;
 
#ifndef _MFC_VER
        typedef cWinSize CSize;         // Alias for MFC
        typedef cWndGDI CGdiObject;
        typedef cWndFont CFont;
        typedef cWndRgn CRgn;
        typedef cWndPen CPen;
        typedef cWndBrush CBrush;
#endif
};
#endif // _WIN32
#endif // _INC_cWndGDI_H