cWndHandle.h

Go to the documentation of this file.

//
 
#ifndef _INC_cWndHandle_H
#define _INC_cWndHandle_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "../WinAPI/WinTypes.h"
#include "../WinAPI/cClipboard.h"
#include "../WinAPI/cWinResource.h"
#include "../Geometry/cRectI.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cOSProcess.h"
#include "GrayCore/include/cArrayString.h"
#include "GrayCore/include/cAppState.h"
 
namespace GrayLib
{
        typedef UINT DLGID_t;   
 
        class GRAYLIB_LINK cWndHandle : public CObject  // similar to Std MFC class CWnd
        {
 
                typedef CObject SUPER_t;
 
        protected:
                HWND m_hWnd;    
 
        public:
                cWndHandle(HWND hWnd = WINHANDLE_NULL) noexcept
                        : m_hWnd(hWnd)
                {
                }
                cWndHandle(cWndHandle* pWnd) noexcept
                        : m_hWnd(pWnd->GetSafeHwnd())
                {
                }
#ifdef _WIN32
                cWndHandle(cWndHandle* pWndParent, DLGID_t id)
                        : m_hWnd(pWndParent->GetDlgItem(id))
                {
                        ASSERT(pWndParent != nullptr);
                }
#endif
#ifdef _MFC_VER
                cWndHandle(CWnd* pWnd)
                        : m_hWnd(pWnd->GetSafeHwnd())
                {
                }
#endif
                virtual ~cWndHandle()
                {
                }
 
                bool isValidHwnd() const noexcept
                {
#ifdef _WIN32
                        return ::IsWindow(m_hWnd);              // How expensive is this?
#else
                        return(m_hWnd != WINHANDLE_NULL);
#endif
                }
                virtual bool isValidCheck() const noexcept // override
                {
#ifndef _MFC_VER
                        if (!SUPER_t::isValidCheck())
                                return false;
#endif
                        if (!IS_TYPE_OF(cWndHandle, this))      // structure definitions are valid.
                                return false;
                        if (m_hWnd == WINHANDLE_NULL)
                                return true;
                        return isValidHwnd();
                }
 
                operator HWND() const noexcept      // cast as a HWND
                {
                        DEBUG_CHECK(isValidCheck());
                        return m_hWnd;
                }
                HWND get_Hwnd() const noexcept
                {
                        DEBUG_CHECK(isValidCheck());
                        return m_hWnd;
                }
                HWND GetSafeHwnd() const noexcept
                {
                        if (!cMem::IsValidApp(this))
                                return WINHANDLE_NULL;
                        return m_hWnd;
                }
                bool AttachHwnd(HWND hWnd)
                {
                        m_hWnd = hWnd;
                        return isValidHwnd();
                }
                void DetachHwnd()
                {
                        m_hWnd = WINHANDLE_NULL;
                }
 
#ifdef _WIN32
 
                bool CreateWindowX(DWORD dwExStyle, const GChar_t* pszClassName, const GChar_t* pszText,
                        DWORD dwStyle, int x, int y, int iSizeX, int iSizeY,
                        HWND hWndParent, HMENU hMenuOrChildId = WINHANDLE_NULL)
                {
                        return AttachHwnd(_GTN(::CreateWindowEx)(dwExStyle, pszClassName, pszText,
                                dwStyle, x, y, iSizeX, iSizeY,
                                hWndParent, hMenuOrChildId, cAppState::get_HModule(), this));
                }
 
                // Standard message handlers.
                virtual BOOL OnCreate(HWND hwnd, _GTN(CREATESTRUCT)* lpCreateStruct = nullptr)
                {
                        UNREFERENCED_PARAMETER(lpCreateStruct);
                        ASSERT_VALID(this);
                        if (!this->AttachHwnd(hwnd))
                                return false;
                        this->put_WindowLongPtr(GWLP_USERDATA, (LONG_PTR)this); // GWL_USERDATA
                        return true;
                }
                virtual void OnDestroy()
                {
                        // Called internally. WM_DESTROY.
                        // DON't call WM_DESTROY via HANDLE_MSG(m_hWnd, WM_DESTROY, OnDestroy)
                        DetachHwnd();
                }
 
                // Basic window functions.
                BOOL IsWindow(void) const
                {
                        if (!cMem::IsValidApp(this))
                                return false;
                        ASSERT_VALID(this);
                        if (!isValidHwnd())
                                return false;
                        return ::IsWindow(m_hWnd);      // Ask OS if this is truly valid HWND.
                }
                HWND GetParent() const
                {
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return ::GetParent(m_hWnd);
                }
                BOOL IsChild(HWND hWndChild) const
                {
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return ::IsChild(m_hWnd, hWndChild);
                }
 
                LRESULT SendMessageX(WINMSG_t uMsg, WPARAM wParam = 0, LPARAM lParam = 0) const
                {
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return _GTN(::SendMessage)(m_hWnd, uMsg, wParam, lParam);
                }
                BOOL PostMessageX(WINMSG_t uMsg, WPARAM wParam = 0, LPARAM lParam = 0) const
                {
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return _GTN(::PostMessage)(m_hWnd, uMsg, wParam, lParam);
                }
 
                // Create/Destroy
                void DestroyWindow(void)
                {
                        if (!isValidHwnd())
                                return;
                        ::DestroyWindow(m_hWnd);
                        DetachHwnd();
                }
                void CloseWindow()
                {
#ifdef UNDER_CE
                        ::DestroyWindow(m_hWnd);
#else
                        ::CloseWindow(m_hWnd);
#endif
                }
 
                // Area and location
                bool GetClientRect(RECT& rcClient) const
                {
                        ASSERT(isValidHwnd());
                        return ::GetClientRect(m_hWnd, &rcClient);
                }
                bool GetWindowRect(RECT& rcWnd) const
                {
 
                        ASSERT(isValidHwnd());
                        return ::GetWindowRect(m_hWnd, &rcWnd);
                }
                cRectI get_ClientRect() const
                {
                        cRectI rect;
                        GetClientRect(rect);
                        return rect;
                }
                cRectI get_WindowRect() const
                {
 
                        cRectI rect;
                        GetWindowRect(rect);
                        return rect;
                }
 
                BOOL GetWindowPlacement(::WINDOWPLACEMENT* lpwndpl) const
                {
                        // Like MFC. cWindowPlacement.
                        return ::GetWindowPlacement(m_hWnd, lpwndpl);
                }
 
                BOOL SetWindowPlacement(const ::WINDOWPLACEMENT* lpwndpl)
                {
                        // Like MFC.
                        return ::SetWindowPlacement(m_hWnd, lpwndpl);
                }
 
                BOOL MoveWindow(int X, int Y, int nWidth, int nHeight, bool bRepaint = true)
                {
                        ASSERT(isValidHwnd());
                        return(::MoveWindow(m_hWnd, X, Y, nWidth, nHeight, bRepaint));
                }
                BOOL SetWindowPos(HWND hWndAfter, int x, int y, int cx, int cy, UINT nFlags)
                {
                        ASSERT(isValidHwnd());
                        return(::SetWindowPos(m_hWnd, hWndAfter, x, y, cx, cy, nFlags));
                }
 
                THREADID_t get_WindowThread() const
                {
                        return ::GetWindowThreadProcessId(m_hWnd, nullptr);
                }
 
                BOOL SetForegroundWindow()
                {
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return(::SetForegroundWindow(m_hWnd));
                }
                HWND SetActiveWindow()
                {
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return(::SetActiveWindow(m_hWnd));
                }
                HWND SetFocus()
                {
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return(::SetFocus(m_hWnd));
                }
                void ClientToScreen(POINT* pPoint) const
                {
                        ASSERT_VALID(this);
                        ::ClientToScreen(m_hWnd, (POINT*)pPoint);
                }
                void ClientToScreen(RECT* pRect) const
                {
                        ClientToScreen((POINT*)&(pRect->left));
                        ClientToScreen((POINT*)&(pRect->right));
                }
                void ScreenToClient(POINT* pPoint) const
                {
                        ASSERT_VALID(this);
                        ::ScreenToClient(m_hWnd, (POINT*)pPoint);
                }
                void ScreenToClient(RECT* pRect) const
                {
                        ScreenToClient((POINT*)&(pRect->left));
                        ScreenToClient((POINT*)&(pRect->right));
                }
                bool IsWindowVisible(void) const
                {
                        return ::IsWindowVisible(m_hWnd);
                }
                bool IsZoomed(void) const
                {
#ifdef UNDER_CE
                        return IsWindowVisible();
#else
                        return ::IsZoomed(m_hWnd);
#endif
                }
                bool IsIconic(void) const
                {
#ifdef UNDER_CE
                        return false;
#else
                        return ::IsIconic(m_hWnd);
#endif
                }
                bool ShowWindow(SHOWWINDOW_t nCmdShow)
                {
                        ASSERT(isValidHwnd());
                        return ::ShowWindow(m_hWnd, nCmdShow);
                }
                bool ShowWindow(bool bCmdShow)
                {
                        return ShowWindow(bCmdShow ? SW_SHOWNORMAL : SW_HIDE);
                }
 
                bool IsWindowEnabled() const
                {
                        if (!isValidHwnd())
                                return false;
                        return ::IsWindowEnabled(m_hWnd);
                }
                bool EnableWindow(bool bState = true)
                {
                        ASSERT(isValidHwnd());
                        return ::EnableWindow(m_hWnd, bState);
                }
 
                // Drawing.
                void SetRedraw(bool bRedraw)
                {
                        SendMessageX(WM_SETREDRAW, bRedraw);
                }
                HDC GetDC(void) const
                {
                        ASSERT_VALID(this);
                        return(::GetDC(m_hWnd));
                }
                void ReleaseDC(HDC hDC) const
                {
                        ASSERT_VALID(this);
                        ::ReleaseDC(m_hWnd, hDC);
                }
                void ValidateRect(RECT* pRect = nullptr) const
                {
                        ASSERT_VALID(this);
                        if (!isValidHwnd())
                                return;
                        ::ValidateRect(m_hWnd, pRect);
                }
                void InvalidateRect(RECT* pRect = nullptr, bool bErase = false) const
                {
                        ASSERT_VALID(this);
                        if (!isValidHwnd())
                                return;
                        ::InvalidateRect(m_hWnd, pRect, bErase);
                }
                void InvalidateRect(int sx, int sy, int iWidth, int iHeight) const
                {
                        cRectI rect(sx, sy, sx + iWidth, sy + iHeight);
                        InvalidateRect(rect);
                }
                bool UpdateWindow()
                {
                        return(::UpdateWindow(m_hWnd));
                }
                bool RedrawWindow(const RECT* pRectUpdate = nullptr, HRGN hRgn = WINHANDLE_NULL, UINT flags = RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE)
                {
                        return(::RedrawWindow(m_hWnd, pRectUpdate, hRgn, flags));
                }
 
                // Standard windows props.
                StrLen_t GetWindowTextLengthX() const
                {
                        // name used in #define
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return(_GTN(::GetWindowTextLength)(m_hWnd));
                }
                StrLen_t GetWindowTextX(GChar_t* lpszText, StrLen_t iLen) const
                {
                        // name used in #define
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return(_GTN(::GetWindowText)(m_hWnd, lpszText, iLen));
                }
                cString GetWindowTextX() const;
                BOOL SetWindowTextX(const GChar_t* lpszText)
                {
                        // name used in #define
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return(_GTN(::SetWindowText)(m_hWnd, lpszText));
                }
 
#ifndef UNDER_CE
                HMENU GetMenu(void) const
                {
                        ASSERT_VALID(this);
                        return(::GetMenu(m_hWnd));
                }
                HMENU GetSystemMenu(bool bReset = false) const
                {
                        ASSERT_VALID(this);
                        return(::GetSystemMenu(m_hWnd, bReset));
                }
#endif
 
                HFONT GetFont() const
                {
                        return((HFONT)(UINT_PTR)SendMessageX(WM_GETFONT));
                }
                void SetFont(HFONT hFont, bool bRedraw = false)
                {
                        SendMessageX(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(bRedraw, 0));
                }
 
                HICON GetIcon(int fType = ICON_SMALL) const
                {
                        return((HICON)(UINT_PTR)SendMessageX(WM_GETICON, (WPARAM)fType));
                }
                HICON SetIcon(HICON hIcon, int fType = ICON_SMALL)
                {
                        return((HICON)(UINT_PTR)SendMessageX(WM_SETICON, (WPARAM)fType, (LPARAM)hIcon));
                }
 
                UINT_PTR SetTimer(DLGID_t uTimerID, TIMESYSD_t uWaitmSec)
                {
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return(::SetTimer(m_hWnd, uTimerID, uWaitmSec, nullptr));
                }
                BOOL KillTimer(DLGID_t uTimerID)
                {
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return(::KillTimer(m_hWnd, uTimerID));
                }
                int ShowMessageBox(const GChar_t* pszText, const GChar_t* pszTitle, UINT fuStyle = MB_OK) const
                {
                        return(_GTN(::MessageBox)(m_hWnd, pszText, pszTitle, fuStyle));
                }
                LONG SetLongValue(int nIndex, LONG dwNewLong)
                {
                        // X is used in #define
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return(_GTN(::SetWindowLong)(m_hWnd, nIndex, dwNewLong));
                }
                LONG GetLongValue(int nIndex) const
                {
                        // X is used in #define
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return(_GTN(::GetWindowLong)(m_hWnd, nIndex));
                }
 
                static inline LONG_PTR SetLongPtr(HWND hWnd, int nIndex, LONG_PTR dwNewLong)
                {
                        // X is used in #define
#ifndef GWLP_USERDATA
#define GWLP_USERDATA   GWL_USERDATA
#define GWLP_WNDPROC    GWL_WNDPROC
#endif
#if defined(USE_64BIT) && ! defined(UNDER_CE)
                        return(_GTN(::SetWindowLongPtr)(hWnd, nIndex, dwNewLong));
#else
                        return(_GTN(::SetWindowLong)(hWnd, nIndex, (LONG)dwNewLong));
#endif
                }
 
                static inline LONG_PTR GetLongPtr(HWND hWnd, int nIndex)
                {
                        // X is used in #define
#if defined(USE_64BIT) && ! defined(UNDER_CE)
                        return(_GTN(::GetWindowLongPtr)(hWnd, nIndex));
#else
                        return(_GTN(::GetWindowLong)(hWnd, nIndex));
#endif
                }
 
                LONG_PTR put_WindowLongPtr(int nIndex, LONG_PTR dwNewLong)
                {
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return SetLongPtr(m_hWnd, nIndex, dwNewLong);
                }
 
                LONG_PTR get_WindowLongPtr(int nIndex)
                {
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return GetLongPtr(m_hWnd, nIndex);
                }
                LONG_PTR GetClassLongPtrX(int nIndex) const
                {
                        // X is used in #define
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
#if defined(USE_64BIT)
                        return(_GTN(::GetClassLongPtr)(m_hWnd, nIndex));
#else
                        return(_GTN(::GetClassLong)(m_hWnd, nIndex));
#endif
                }
 
                DWORD GetStyle() const
                {
                        return((DWORD)GetLongValue(GWL_STYLE));
                }
                DWORD SetStyle(DWORD dwStyle)
                {
                        return((DWORD)SetLongValue(GWL_STYLE, dwStyle));
                }
                DWORD GetExStyle() const
                {
                        return((DWORD)GetLongValue(GWL_EXSTYLE));
                }
 
                // Child Windows
                virtual DLGID_t GetDlgCtrlID() const
                {
 
                        ASSERT_VALID(this);
                        ASSERT(isValidHwnd());
                        return ::GetDlgCtrlID(m_hWnd);
                }
 
                cWndHandle GetDlgItem(DLGID_t id) const
                {
                        ASSERT(isValidHwnd());
                        return ::GetDlgItem(m_hWnd, id);
                }
                LRESULT SendDlgItemMessageX(DLGID_t nIDDlgItem, WINMSG_t Msg, WPARAM wParam = 0, LPARAM lParam = 0) const
                {
                        ASSERT(isValidHwnd());
                        return(_GTN(::SendDlgItemMessage)(m_hWnd, nIDDlgItem, Msg, wParam, lParam));
                }
                UINT GetDlgItemTextX(DLGID_t nIDDlgItem, GChar_t* lpString, StrLen_t nMaxCount) const
                {
                        ASSERT(isValidHwnd());
                        return(_GTN(::GetDlgItemText)(m_hWnd, nIDDlgItem, lpString, nMaxCount));
                }
                cString GetDlgItemTextX(DLGID_t nIDDlgItem) const;
 
                BOOL SetDlgItemTextX(DLGID_t nIDDlgItem, const GChar_t* lpszText) const
                {
                        ASSERT_VALID(this);
                        return(_GTN(::SetDlgItemText)(m_hWnd, nIDDlgItem, lpszText));
                }
 
                void SetDlgItemInt(DLGID_t nIDDlgItem, int iVal) const;
                int GetDlgItemInt(DLGID_t nIDDlgItem) const;
 
                UINT IsDlgButtonChecked(DLGID_t nIDDlgItem) const
                {
                        ASSERT_VALID(this);
                        return(::IsDlgButtonChecked(m_hWnd, nIDDlgItem));
                }
                bool CheckDlgButton(DLGID_t nIDButton, UINT uCheck)
                {
                        ASSERT_VALID(this);
                        return(::CheckDlgButton(m_hWnd, nIDButton, uCheck));
                }
                bool CheckRadioButton(DLGID_t nIDFirstButton, DLGID_t nIDLastButton, DLGID_t nIDCheckButton)
                {
                        ASSERT_VALID(this);
                        return(::CheckRadioButton(m_hWnd, nIDFirstButton, nIDLastButton, nIDCheckButton));
                }
 
                HWND SetCapture()
                {
                        return(::SetCapture(m_hWnd));
                }
 
                // Special methods.
                // Cursor selection stuff.
                static HWND GRAYCALL FindWindowAtPoint(HWND hWndParent, const POINT& ptScreen);
 
                void CenterWindow(HWND hWndOrder = HWND_NOTOPMOST);
                void EnableWindowItem(DLGID_t id, bool bState);
                void EnableWindowRange(DLGID_t idChildStart, DLGID_t idChildEnd, bool bState);
                void ShowWindowItem(DLGID_t id, bool bState);
                void ShowWindowRange(DLGID_t idChildStart, DLGID_t idChildEnd, bool bState);
                ITERATE_t FillComboBox(DLGID_t idChild, const cArrayStringA& aValues);
 
                cString GetClipboardText(int iSizeMax = StrT::k_LEN_MAX - 1)
                {
                        return cClipboard::GetClipboardText(get_Hwnd(), iSizeMax);
                }
                bool SetClipboardText(cString sText)
                {
                        return cClipboard::SetClipboardText(get_Hwnd(), sText);
                }
#endif  // _WIN32
        };
 
 
#ifndef _MFC_VER
        typedef cWndHandle CWnd;
#define HANDLE_DLGMSG   HANDLE_MSG
#endif
 
}
 
#endif