2978 lines
95 KiB
C
2978 lines
95 KiB
C
|
// Win32++ Version 7.2
|
|||
|
|
// Released: 5th AUgust 2011
|
|||
|
|
//
|
|||
|
|
// David Nash
|
|||
|
|
// email: dnash@bigpond.net.au
|
|||
|
|
// url: https://sourceforge.net/projects/win32-framework
|
|||
|
|
//
|
|||
|
|
//
|
|||
|
|
// Copyright (c) 2005-2011 David Nash
|
|||
|
|
//
|
|||
|
|
// Permission is hereby granted, free of charge, to
|
|||
|
|
// any person obtaining a copy of this software and
|
|||
|
|
// associated documentation files (the "Software"),
|
|||
|
|
// to deal in the Software without restriction, including
|
|||
|
|
// without limitation the rights to use, copy, modify,
|
|||
|
|
// merge, publish, distribute, sublicense, and/or sell
|
|||
|
|
// copies of the Software, and to permit persons to whom
|
|||
|
|
// the Software is furnished to do so, subject to the
|
|||
|
|
// following conditions:
|
|||
|
|
//
|
|||
|
|
// The above copyright notice and this permission notice
|
|||
|
|
// shall be included in all copies or substantial portions
|
|||
|
|
// of the Software.
|
|||
|
|
//
|
|||
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
|||
|
|
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
|||
|
|
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
|||
|
|
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
|||
|
|
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
|||
|
|
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|||
|
|
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|||
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
|||
|
|
// OR OTHER DEALINGS IN THE SOFTWARE.
|
|||
|
|
//
|
|||
|
|
////////////////////////////////////////////////////////
|
|||
|
|
|
|||
|
|
|
|||
|
|
///////////////////////////////////////////////////////
|
|||
|
|
// wincore.h
|
|||
|
|
// Declaration of the following classes:
|
|||
|
|
// CWinApp, CWnd, CWinException, CCriticalSection,
|
|||
|
|
// CPoint, CRect, and CSize
|
|||
|
|
//
|
|||
|
|
// This file contains the declarations for the core set of classes required to
|
|||
|
|
// create simple windows using Win32++.
|
|||
|
|
//
|
|||
|
|
// 1) CCriticalSection: This class is used internally to manage thread access
|
|||
|
|
// to shared resources. You can also use this class to lock and
|
|||
|
|
// release your own critical sections.
|
|||
|
|
//
|
|||
|
|
// 2) CWinException: This class is used internally by Win32++ to handle
|
|||
|
|
// exceptions. You can also use it to throw and catch exceptions.
|
|||
|
|
//
|
|||
|
|
// 3) WinApp: This class is used start Win32++ and run the message loop. You
|
|||
|
|
// should inherit from this class to start Win32++ in your own
|
|||
|
|
// application.
|
|||
|
|
//
|
|||
|
|
// 4) CWnd: This class is used to represent a window. It provides a means
|
|||
|
|
// of creating the window, and handling its messages. Inherit
|
|||
|
|
// from this class to define and control windows.
|
|||
|
|
//
|
|||
|
|
//
|
|||
|
|
// Note: This header file (or another Win32++ header file which includes it)
|
|||
|
|
// should be included before all other header files. It sets some
|
|||
|
|
// important macros which need to be set before including Windows.h
|
|||
|
|
// Including this file first also allows it to disable some pointless
|
|||
|
|
// warning messages (see below).
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
#ifndef _WIN32XX_WINCORE_H_
|
|||
|
|
#define _WIN32XX_WINCORE_H_
|
|||
|
|
|
|||
|
|
|
|||
|
|
// Remove pointless warning messages
|
|||
|
|
#ifdef _MSC_VER
|
|||
|
|
#pragma warning (disable : 4996) // function or variable may be unsafe (deprecated)
|
|||
|
|
#ifndef _CRT_SECURE_NO_WARNINGS
|
|||
|
|
#define _CRT_SECURE_NO_WARNINGS // eliminate deprecation warnings for VS2005/VS2010
|
|||
|
|
#endif
|
|||
|
|
#if _MSC_VER < 1500
|
|||
|
|
#pragma warning (disable : 4511) // copy operator could not be generated
|
|||
|
|
#pragma warning (disable : 4512) // assignment operator could not be generated
|
|||
|
|
#pragma warning (disable : 4702) // unreachable code (bugs in Microsoft's STL)
|
|||
|
|
#pragma warning (disable : 4786) // identifier was truncated
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#ifdef __BORLANDC__
|
|||
|
|
#pragma option -w-8019 // code has no effect
|
|||
|
|
#pragma option -w-8026 // functions with exception specifiations are not expanded inline
|
|||
|
|
#pragma option -w-8027 // function not expanded inline
|
|||
|
|
#define STRICT 1
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#ifdef __GNUC__
|
|||
|
|
#pragma GCC diagnostic ignored "-Wmissing-braces"
|
|||
|
|
#pragma GCC diagnostic ignored "-Wunused-value"
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#ifdef _WIN32_WCE
|
|||
|
|
#include "wcestddef.h"
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#define _WINSOCKAPI_ // Prevent winsock.h #include's.
|
|||
|
|
|
|||
|
|
#include <assert.h>
|
|||
|
|
#include <vector>
|
|||
|
|
#include <algorithm>
|
|||
|
|
#include <string>
|
|||
|
|
#include <map>
|
|||
|
|
#include <windows.h>
|
|||
|
|
#include <commctrl.h>
|
|||
|
|
#include <stdio.h>
|
|||
|
|
#include <tchar.h>
|
|||
|
|
#include <shlwapi.h>
|
|||
|
|
#include "shared_ptr.h"
|
|||
|
|
//#include "winutils.h" // included later in this file
|
|||
|
|
//#include "cstring.h" // included later in this file
|
|||
|
|
//#include "gdi.h" // included later in this file
|
|||
|
|
//#include "menu.h" // included later in this file
|
|||
|
|
|
|||
|
|
// For compilers lacking Win64 support
|
|||
|
|
#ifndef GetWindowLongPtr
|
|||
|
|
#define GetWindowLongPtr GetWindowLong
|
|||
|
|
#define SetWindowLongPtr SetWindowLong
|
|||
|
|
#define GWLP_WNDPROC GWL_WNDPROC
|
|||
|
|
#define GWLP_HINSTANCE GWL_HINSTANCE
|
|||
|
|
#define GWLP_ID GWL_ID
|
|||
|
|
#define GWLP_USERDATA GWL_USERDATA
|
|||
|
|
#define DWLP_DLGPROC DWL_DLGPROC
|
|||
|
|
#define DWLP_MSGRESULT DWL_MSGRESULT
|
|||
|
|
#define DWLP_USER DWL_USER
|
|||
|
|
#define DWORD_PTR DWORD
|
|||
|
|
#define LONG_PTR LONG
|
|||
|
|
#define ULONG_PTR LONG
|
|||
|
|
#endif
|
|||
|
|
#ifndef GetClassLongPtr
|
|||
|
|
#define GetClassLongPtr GetClassLong
|
|||
|
|
#define SetClassLongPtr SetClassLong
|
|||
|
|
#define GCLP_HBRBACKGROUND GCL_HBRBACKGROUND
|
|||
|
|
#define GCLP_HCURSOR GCL_HCURSOR
|
|||
|
|
#define GCLP_HICON GCL_HICON
|
|||
|
|
#define GCLP_HICONSM GCL_HICONSM
|
|||
|
|
#define GCLP_HMODULE GCL_HMODULE
|
|||
|
|
#define GCLP_MENUNAME GCL_MENUNAME
|
|||
|
|
#define GCLP_WNDPROC GCL_WNDPROC
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
|
|||
|
|
// Messages defined by Win32++
|
|||
|
|
#define UWM_POPUPMENU (WM_APP + 1) // Message - creates the menubar popup menu
|
|||
|
|
#define UWM_DOCK_START (WM_APP + 2) // Notification - about to start undocking
|
|||
|
|
#define UWM_DOCK_MOVE (WM_APP + 3) // Notification - undocked docker is being moved
|
|||
|
|
#define UWM_DOCK_END (WM_APP + 4) // Notification - docker has been docked
|
|||
|
|
#define UWM_BAR_START (WM_APP + 5) // Notification - docker bar selected for move
|
|||
|
|
#define UWM_BAR_MOVE (WM_APP + 6) // Notification - docker bar moved
|
|||
|
|
#define UWM_BAR_END (WM_APP + 7) // Notification - end of docker bar move
|
|||
|
|
#define UWM_UNDOCKED (WM_APP + 8) // Notification - sent by docker when undocked
|
|||
|
|
#define UWM_FRAMELOSTFOCUS (WM_APP + 9) // Notification - sent by frame to view window when focus lost
|
|||
|
|
#define UWM_FRAMEGOTFOCUS (WM_APP + 10) // Notification - sent by frame to view window when focus acquired
|
|||
|
|
#define UWM_DOCK_DESTROYED (WM_APP + 11) // Message - posted when docker is destroyed
|
|||
|
|
#define UWM_TAB_CHANGED (WM_APP + 12) // Notification - tab layout changed
|
|||
|
|
#define UWM_TOOLBAR_RESIZE (WM_APP + 13) // Message - sent by toolbar to parent. Used by the rebar
|
|||
|
|
#define UWM_UPDATE_COMMAND (WM_APP + 14) // Message - sent before a menu is displayed. Used by OnUpdate
|
|||
|
|
#define UWM_DOCK_ACTIVATED (WM_APP + 15) // Message - sent to dock ancestor when a docker is activated or deactivated.
|
|||
|
|
#define UWM_GETMENUTHEME (WM_APP + 16) // Message - returns a pointer to MenuTheme
|
|||
|
|
#define UWM_GETREBARTHEME (WM_APP + 17) // Message - returns a pointer to CToolBar
|
|||
|
|
#define UWM_GETTOOLBARTHEME (WM_APP + 18) // Message - returns a pointer to ToolBarTheme
|
|||
|
|
#define UWM_CLEANUPTEMPS (WM_APP + 19) // Message - posted to cleanup temporary CDCs
|
|||
|
|
|
|||
|
|
|
|||
|
|
// Automatically include the Win32xx namespace
|
|||
|
|
// define NO_USING_NAMESPACE to skip this step
|
|||
|
|
namespace Win32xx {}
|
|||
|
|
#ifndef NO_USING_NAMESPACE
|
|||
|
|
using namespace Win32xx;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
// Required for WinCE
|
|||
|
|
#ifndef TLS_OUT_OF_INDEXES
|
|||
|
|
#define TLS_OUT_OF_INDEXES ((DWORD_PTR) -1)
|
|||
|
|
#endif
|
|||
|
|
#ifndef WM_PARENTNOTIFY
|
|||
|
|
#define WM_PARENTNOTIFY 0x0210
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
|
|||
|
|
namespace Win32xx
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
////////////////////////////////////////////////
|
|||
|
|
// Forward declarations.
|
|||
|
|
// These classes are defined later or elsewhere
|
|||
|
|
class CDC;
|
|||
|
|
class CGDIObject;
|
|||
|
|
class CMenu;
|
|||
|
|
class CWinApp;
|
|||
|
|
class CWnd;
|
|||
|
|
class CBitmap;
|
|||
|
|
class CBrush;
|
|||
|
|
class CFont;
|
|||
|
|
class CPalette;
|
|||
|
|
class CPen;
|
|||
|
|
class CRgn;
|
|||
|
|
|
|||
|
|
// tString is a TCHAR std::string
|
|||
|
|
typedef std::basic_string<TCHAR> tString;
|
|||
|
|
|
|||
|
|
// tStringStream is a TCHAR std::stringstream
|
|||
|
|
typedef std::basic_stringstream<TCHAR> tStringStream;
|
|||
|
|
|
|||
|
|
// Some useful smart pointers
|
|||
|
|
typedef Shared_Ptr<CDC> DCPtr;
|
|||
|
|
typedef Shared_Ptr<CGDIObject> GDIPtr;
|
|||
|
|
typedef Shared_Ptr<CMenu> MenuPtr;
|
|||
|
|
typedef Shared_Ptr<CWnd> WndPtr;
|
|||
|
|
typedef Shared_Ptr<CBitmap> BitmapPtr;
|
|||
|
|
typedef Shared_Ptr<CBrush> BrushPtr;
|
|||
|
|
typedef Shared_Ptr<CFont> FontPtr;
|
|||
|
|
typedef Shared_Ptr<CPalette> PalettePtr;
|
|||
|
|
typedef Shared_Ptr<CPen> PenPtr;
|
|||
|
|
typedef Shared_Ptr<CRgn> RgnPtr;
|
|||
|
|
|
|||
|
|
enum Constants // Defines the maximum size for TCHAR strings
|
|||
|
|
{
|
|||
|
|
MAX_MENU_STRING = 80,
|
|||
|
|
MAX_STRING_SIZE = 255,
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
struct CompareHDC // The comparison function object used by CWinApp::m_mapHDC
|
|||
|
|
{
|
|||
|
|
bool operator()(HDC const a, const HDC b) const
|
|||
|
|
{return ((DWORD_PTR)a < (DWORD_PTR)b);}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
struct CompareGDI // The comparison function object used by CWinApp::m_mapGDI
|
|||
|
|
{
|
|||
|
|
bool operator()(HGDIOBJ const a, const HGDIOBJ b) const
|
|||
|
|
{return ((DWORD_PTR)a < (DWORD_PTR)b);}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
struct CompareHMENU // The comparison function object used by CWinApp::m_mapHMENU
|
|||
|
|
{
|
|||
|
|
bool operator()(HMENU const a, const HMENU b) const
|
|||
|
|
{return ((DWORD_PTR)a < (DWORD_PTR)b);}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
struct CompareHWND // The comparison function object used by CWinApp::m_mapHWND
|
|||
|
|
{
|
|||
|
|
bool operator()(HWND const a, const HWND b) const
|
|||
|
|
{return ((DWORD_PTR)a < (DWORD_PTR)b);}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
struct TLSData // Used for Thread Local Storage (TLS)
|
|||
|
|
{
|
|||
|
|
CWnd* pCWnd; // pointer to CWnd object for Window creation
|
|||
|
|
CWnd* pMenuBar; // pointer to CMenuBar object used for the WH_MSGFILTER hook
|
|||
|
|
HHOOK hHook; // WH_MSGFILTER hook for CMenuBar and Modeless Dialogs
|
|||
|
|
|
|||
|
|
std::vector<DCPtr> vTmpDCs; // A vector of temporary CDC pointers
|
|||
|
|
std::vector<GDIPtr> vTmpGDIs; // A vector of temporary CGDIObject pointers
|
|||
|
|
std::vector<WndPtr> vTmpWnds; // A vector of temporary CWnd pointers
|
|||
|
|
TLSData() : pCWnd(0), pMenuBar(0), hHook(0) {}
|
|||
|
|
|
|||
|
|
#ifndef _WIN32_WCE
|
|||
|
|
std::vector<MenuPtr> vTmpMenus; // A vector of temporary CMenu pointers
|
|||
|
|
#endif
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
/////////////////////////////////////////
|
|||
|
|
// Declarations for the CCriticalSection class
|
|||
|
|
// This class is used for thread synchronisation
|
|||
|
|
class CCriticalSection
|
|||
|
|
{
|
|||
|
|
public:
|
|||
|
|
CCriticalSection() { ::InitializeCriticalSection(&m_cs); }
|
|||
|
|
~CCriticalSection() { ::DeleteCriticalSection(&m_cs); }
|
|||
|
|
|
|||
|
|
void Lock() { ::EnterCriticalSection(&m_cs); }
|
|||
|
|
void Release() { ::LeaveCriticalSection(&m_cs); }
|
|||
|
|
|
|||
|
|
private:
|
|||
|
|
CCriticalSection ( const CCriticalSection& );
|
|||
|
|
CCriticalSection& operator = ( const CCriticalSection& );
|
|||
|
|
|
|||
|
|
CRITICAL_SECTION m_cs;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
////////////////////////////////////////
|
|||
|
|
// Declaration of the CWinException class
|
|||
|
|
//
|
|||
|
|
// Note: Each function guarantees not to throw an exception
|
|||
|
|
|
|||
|
|
class CWinException : public std::exception
|
|||
|
|
{
|
|||
|
|
public:
|
|||
|
|
CWinException(LPCTSTR pszText) throw ();
|
|||
|
|
~CWinException() throw() {}
|
|||
|
|
DWORD GetError() const throw ();
|
|||
|
|
LPCTSTR GetErrorString() const throw ();
|
|||
|
|
const char * what () const throw ();
|
|||
|
|
|
|||
|
|
private:
|
|||
|
|
DWORD m_Error;
|
|||
|
|
LPCTSTR m_pszText;
|
|||
|
|
TCHAR m_szErrorString[MAX_STRING_SIZE];
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
///////////////////////////////////
|
|||
|
|
// Declaration of the CWinApp class
|
|||
|
|
//
|
|||
|
|
class CWinApp
|
|||
|
|
{
|
|||
|
|
// Provide these access to CWinApp's private members:
|
|||
|
|
friend class CDC;
|
|||
|
|
friend class CDialog;
|
|||
|
|
friend class CGDIObject;
|
|||
|
|
friend class CMenu;
|
|||
|
|
friend class CMenuBar;
|
|||
|
|
friend class CPropertyPage;
|
|||
|
|
friend class CPropertySheet;
|
|||
|
|
friend class CTaskDialog;
|
|||
|
|
friend class CWnd;
|
|||
|
|
friend CWinApp* GetApp();
|
|||
|
|
friend CGDIObject* FromHandle(HGDIOBJ hObject);
|
|||
|
|
friend CBitmap* FromHandle(HBITMAP hBitmap);
|
|||
|
|
friend CBrush* FromHandle(HBRUSH hBrush);
|
|||
|
|
friend CFont* FromHandle(HFONT hFont);
|
|||
|
|
friend CPalette* FromHandle(HPALETTE hPalette);
|
|||
|
|
friend CPen* FromHandle(HPEN hPen);
|
|||
|
|
friend CRgn* FromHandle(HRGN hRgn);
|
|||
|
|
friend CDC* FromHandle(HDC hDC);
|
|||
|
|
friend CWnd* FromHandle(HWND hWnd);
|
|||
|
|
#ifndef _WIN32_WCE
|
|||
|
|
friend CMenu* FromHandle(HMENU hMenu);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
typedef Shared_Ptr<TLSData> TLSDataPtr;
|
|||
|
|
|
|||
|
|
public:
|
|||
|
|
CWinApp();
|
|||
|
|
virtual ~CWinApp();
|
|||
|
|
|
|||
|
|
HACCEL GetAccelerators() const { return m_hAccel; }
|
|||
|
|
HINSTANCE GetInstanceHandle() const { return m_hInstance; }
|
|||
|
|
HINSTANCE GetResourceHandle() const { return (m_hResource ? m_hResource : m_hInstance); }
|
|||
|
|
void SetAccelerators(HACCEL hAccel, CWnd* pWndAccel);
|
|||
|
|
void SetResourceHandle(HINSTANCE hResource);
|
|||
|
|
|
|||
|
|
// These are the functions you might wish to override
|
|||
|
|
virtual BOOL InitInstance();
|
|||
|
|
virtual int MessageLoop();
|
|||
|
|
virtual int Run();
|
|||
|
|
|
|||
|
|
protected:
|
|||
|
|
virtual BOOL OnIdle(LONG lCount);
|
|||
|
|
virtual BOOL PreTranslateMessage(MSG Msg);
|
|||
|
|
|
|||
|
|
private:
|
|||
|
|
CWinApp(const CWinApp&); // Disable copy construction
|
|||
|
|
CWinApp& operator = (const CWinApp&); // Disable assignment operator
|
|||
|
|
CDC* GetCDCFromMap(HDC hDC);
|
|||
|
|
CGDIObject* GetCGDIObjectFromMap(HGDIOBJ hObject);
|
|||
|
|
CMenu* GetCMenuFromMap(HMENU hMenu);
|
|||
|
|
CWnd* GetCWndFromMap(HWND hWnd);
|
|||
|
|
|
|||
|
|
void AddTmpDC(CDC* pDC);
|
|||
|
|
void AddTmpGDI(CGDIObject* pObject);
|
|||
|
|
CMenu* AddTmpMenu(HMENU hMenu);
|
|||
|
|
CWnd* AddTmpWnd(HWND hWnd);
|
|||
|
|
void CleanupTemps();
|
|||
|
|
DWORD GetTlsIndex() const {return m_dwTlsIndex;}
|
|||
|
|
void SetCallback();
|
|||
|
|
TLSData* SetTlsIndex();
|
|||
|
|
static CWinApp* SetnGetThis(CWinApp* pThis = 0);
|
|||
|
|
|
|||
|
|
std::map<HDC, CDC*, CompareHDC> m_mapHDC; // maps device context handles to CDC objects
|
|||
|
|
std::map<HGDIOBJ, CGDIObject*, CompareGDI> m_mapGDI; // maps GDI handles to CGDIObjects.
|
|||
|
|
std::map<HMENU, CMenu*, CompareHMENU> m_mapHMENU; // maps menu handles to CMenu objects
|
|||
|
|
std::map<HWND, CWnd*, CompareHWND> m_mapHWND; // maps window handles to CWnd objects
|
|||
|
|
std::vector<TLSDataPtr> m_vTLSData; // vector of TLSData smart pointers, one for each thread
|
|||
|
|
CCriticalSection m_csMapLock; // thread synchronisation for m_mapHWND
|
|||
|
|
CCriticalSection m_csTLSLock; // thread synchronisation for m_vTLSData
|
|||
|
|
CCriticalSection m_csAppStart; // thread synchronisation for application startup
|
|||
|
|
HINSTANCE m_hInstance; // handle to the applications instance
|
|||
|
|
HINSTANCE m_hResource; // handle to the applications resources
|
|||
|
|
DWORD m_dwTlsIndex; // Thread Local Storage index
|
|||
|
|
WNDPROC m_Callback; // callback address of CWnd::StaticWndowProc
|
|||
|
|
HACCEL m_hAccel; // handle to the accelerator table
|
|||
|
|
CWnd* m_pWndAccel; // handle to the window for accelerator keys
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#include "winutils.h"
|
|||
|
|
#include "cstring.h"
|
|||
|
|
|
|||
|
|
|
|||
|
|
namespace Win32xx
|
|||
|
|
{
|
|||
|
|
////////////////////////////////
|
|||
|
|
// Declaration of the CWnd class
|
|||
|
|
//
|
|||
|
|
class CWnd
|
|||
|
|
{
|
|||
|
|
friend class CMDIChild;
|
|||
|
|
friend class CDialog;
|
|||
|
|
friend class CPropertyPage;
|
|||
|
|
friend class CTaskDialog;
|
|||
|
|
friend class CWinApp;
|
|||
|
|
|
|||
|
|
public:
|
|||
|
|
CWnd(); // Constructor
|
|||
|
|
virtual ~CWnd(); // Destructor
|
|||
|
|
|
|||
|
|
// These virtual functions can be overridden
|
|||
|
|
virtual BOOL Attach(HWND hWnd);
|
|||
|
|
virtual BOOL AttachDlgItem(UINT nID, CWnd* pParent);
|
|||
|
|
virtual void CenterWindow() const;
|
|||
|
|
virtual HWND Create(CWnd* pParent = NULL);
|
|||
|
|
virtual HWND CreateEx(DWORD dwExStyle, LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, CWnd* pParent, CMenu* pMenu, LPVOID lpParam = NULL);
|
|||
|
|
virtual HWND CreateEx(DWORD dwExStyle, LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rc, CWnd* pParent, CMenu* pMenu, LPVOID lpParam = NULL);
|
|||
|
|
virtual void Destroy();
|
|||
|
|
virtual HWND Detach();
|
|||
|
|
virtual HICON SetIconLarge(int nIcon);
|
|||
|
|
virtual HICON SetIconSmall(int nIcon);
|
|||
|
|
|
|||
|
|
// Attributes
|
|||
|
|
HWND GetHwnd() const { return m_hWnd; }
|
|||
|
|
WNDPROC GetPrevWindowProc() const { return m_PrevWindowProc; }
|
|||
|
|
|
|||
|
|
// Wrappers for Win32 API functions
|
|||
|
|
// These functions aren't virtual, and shouldn't be overridden
|
|||
|
|
CDC* BeginPaint(PAINTSTRUCT& ps) const;
|
|||
|
|
BOOL BringWindowToTop() const;
|
|||
|
|
LRESULT CallWindowProc(WNDPROC lpPrevWndFunc, UINT Msg, WPARAM wParam, LPARAM lParam) const;
|
|||
|
|
BOOL CheckDlgButton(int nIDButton, UINT uCheck) const;
|
|||
|
|
BOOL CheckRadioButton(int nIDFirstButton, int nIDLastButton, int nIDCheckButton) const;
|
|||
|
|
CWnd* ChildWindowFromPoint(POINT pt) const;
|
|||
|
|
BOOL ClientToScreen(POINT& pt) const;
|
|||
|
|
BOOL ClientToScreen(RECT& rc) const;
|
|||
|
|
LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam) const;
|
|||
|
|
HDWP DeferWindowPos(HDWP hWinPosInfo, HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT uFlags) const;
|
|||
|
|
HDWP DeferWindowPos(HDWP hWinPosInfo, HWND hWndInsertAfter, const RECT& rc, UINT uFlags) const;
|
|||
|
|
BOOL DrawMenuBar() const;
|
|||
|
|
BOOL EnableWindow(BOOL bEnable = TRUE) const;
|
|||
|
|
BOOL EndPaint(PAINTSTRUCT& ps) const;
|
|||
|
|
CWnd* GetActiveWindow() const;
|
|||
|
|
CWnd* GetAncestor(UINT gaFlag = 3 /*= GA_ROOTOWNER*/) const;
|
|||
|
|
CWnd* GetCapture() const;
|
|||
|
|
ULONG_PTR GetClassLongPtr(int nIndex) const;
|
|||
|
|
CString GetClassName() const;
|
|||
|
|
CRect GetClientRect() const;
|
|||
|
|
CDC* GetDC() const;
|
|||
|
|
CDC* GetDCEx(HRGN hrgnClip, DWORD flags) const;
|
|||
|
|
CWnd* GetDesktopWindow() const;
|
|||
|
|
CWnd* GetDlgItem(int nIDDlgItem) const;
|
|||
|
|
UINT GetDlgItemInt(int nIDDlgItem, BOOL* lpTranslated, BOOL bSigned) const;
|
|||
|
|
CString GetDlgItemText(int nIDDlgItem) const;
|
|||
|
|
CWnd* GetFocus() const;
|
|||
|
|
CFont* GetFont() const;
|
|||
|
|
HICON GetIcon(BOOL bBigIcon) const;
|
|||
|
|
CWnd* GetNextDlgGroupItem(CWnd* pCtl, BOOL bPrevious) const;
|
|||
|
|
CWnd* GetNextDlgTabItem(CWnd* pCtl, BOOL bPrevious) const;
|
|||
|
|
CWnd* GetParent() const;
|
|||
|
|
BOOL GetScrollInfo(int fnBar, SCROLLINFO& si) const;
|
|||
|
|
CRect GetUpdateRect(BOOL bErase) const;
|
|||
|
|
int GetUpdateRgn(CRgn* pRgn, BOOL bErase) const;
|
|||
|
|
CWnd* GetWindow(UINT uCmd) const;
|
|||
|
|
CDC* GetWindowDC() const;
|
|||
|
|
LONG_PTR GetWindowLongPtr(int nIndex) const;
|
|||
|
|
CRect GetWindowRect() const;
|
|||
|
|
CString GetWindowText() const;
|
|||
|
|
int GetWindowTextLength() const;
|
|||
|
|
void Invalidate(BOOL bErase = TRUE) const;
|
|||
|
|
BOOL InvalidateRect(LPCRECT lpRect, BOOL bErase = TRUE) const;
|
|||
|
|
BOOL InvalidateRgn(CRgn* pRgn, BOOL bErase = TRUE) const;
|
|||
|
|
BOOL IsChild(CWnd* pChild) const;
|
|||
|
|
BOOL IsDialogMessage(LPMSG lpMsg) const;
|
|||
|
|
UINT IsDlgButtonChecked(int nIDButton) const;
|
|||
|
|
BOOL IsWindow() const;
|
|||
|
|
BOOL IsWindowEnabled() const;
|
|||
|
|
BOOL IsWindowVisible() const;
|
|||
|
|
BOOL KillTimer(UINT_PTR uIDEvent) const;
|
|||
|
|
int MessageBox(LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) const;
|
|||
|
|
void MapWindowPoints(CWnd* pWndTo, POINT& pt) const;
|
|||
|
|
void MapWindowPoints(CWnd* pWndTo, RECT& rc) const;
|
|||
|
|
void MapWindowPoints(CWnd* pWndTo, LPPOINT ptArray, UINT nCount) const;
|
|||
|
|
BOOL MoveWindow(int x, int y, int nWidth, int nHeight, BOOL bRepaint = TRUE) const;
|
|||
|
|
BOOL MoveWindow(const RECT& rc, BOOL bRepaint = TRUE) const;
|
|||
|
|
BOOL PostMessage(UINT uMsg, WPARAM wParam = 0L, LPARAM lParam = 0L) const;
|
|||
|
|
BOOL PostMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) const;
|
|||
|
|
BOOL RedrawWindow(LPCRECT lpRectUpdate = NULL, CRgn* pRgn = NULL, UINT flags = RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ALLCHILDREN) const;
|
|||
|
|
int ReleaseDC(CDC* pDC) const;
|
|||
|
|
BOOL ScreenToClient(POINT& Point) const;
|
|||
|
|
BOOL ScreenToClient(RECT& rc) const;
|
|||
|
|
LRESULT SendDlgItemMessage(int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam) const;
|
|||
|
|
LRESULT SendMessage(UINT uMsg, WPARAM wParam = 0L, LPARAM lParam = 0L) const;
|
|||
|
|
LRESULT SendMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) const;
|
|||
|
|
BOOL SendNotifyMessage(UINT Msg, WPARAM wParam, LPARAM lParam) const;
|
|||
|
|
CWnd* SetActiveWindow() const;
|
|||
|
|
CWnd* SetCapture() const;
|
|||
|
|
ULONG_PTR SetClassLongPtr(int nIndex, LONG_PTR dwNewLong) const;
|
|||
|
|
BOOL SetDlgItemInt(int nIDDlgItem, UINT uValue, BOOL bSigned) const;
|
|||
|
|
BOOL SetDlgItemText(int nIDDlgItem, LPCTSTR lpString) const;
|
|||
|
|
CWnd* SetFocus() const;
|
|||
|
|
void SetFont(CFont* pFont, BOOL bRedraw = TRUE) const;
|
|||
|
|
BOOL SetForegroundWindow() const;
|
|||
|
|
HICON SetIcon(HICON hIcon, BOOL bBigIcon) const;
|
|||
|
|
CWnd* SetParent(CWnd* pWndParent) const;
|
|||
|
|
BOOL SetRedraw(BOOL bRedraw = TRUE) const;
|
|||
|
|
int SetScrollInfo(int fnBar, const SCROLLINFO& si, BOOL fRedraw) const;
|
|||
|
|
UINT_PTR SetTimer(UINT_PTR nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc) const;
|
|||
|
|
LONG_PTR SetWindowLongPtr(int nIndex, LONG_PTR dwNewLong) const;
|
|||
|
|
BOOL SetWindowPos(HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT uFlags) const;
|
|||
|
|
BOOL SetWindowPos(HWND hWndInsertAfter, const RECT& rc, UINT uFlags) const;
|
|||
|
|
int SetWindowRgn(CRgn* pRgn, BOOL bRedraw = TRUE) const;
|
|||
|
|
BOOL SetWindowText(LPCTSTR lpString) const;
|
|||
|
|
HRESULT SetWindowTheme(LPCWSTR pszSubAppName, LPCWSTR pszSubIdList) const;
|
|||
|
|
BOOL ShowWindow(int nCmdShow = SW_SHOWNORMAL) const;
|
|||
|
|
BOOL UpdateWindow() const;
|
|||
|
|
BOOL ValidateRect(LPCRECT prc) const;
|
|||
|
|
BOOL ValidateRgn(CRgn* pRgn) const;
|
|||
|
|
static CWnd* WindowFromPoint(POINT pt);
|
|||
|
|
|
|||
|
|
#ifndef _WIN32_WCE
|
|||
|
|
BOOL CloseWindow() const;
|
|||
|
|
int DlgDirList(LPTSTR lpPathSpec, int nIDListBox, int nIDStaticPath, UINT uFileType) const;
|
|||
|
|
int DlgDirListComboBox(LPTSTR lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT uFiletype) const;
|
|||
|
|
BOOL DlgDirSelectEx(LPTSTR lpString, int nCount, int nIDListBox) const;
|
|||
|
|
BOOL DlgDirSelectComboBoxEx(LPTSTR lpString, int nCount, int nIDComboBox) const;
|
|||
|
|
BOOL DrawAnimatedRects(int idAni, RECT& rcFrom, RECT& rcTo) const;
|
|||
|
|
BOOL DrawCaption(CDC* pDC, RECT& rc, UINT uFlags) const;
|
|||
|
|
BOOL EnableScrollBar(UINT uSBflags, UINT uArrows) const;
|
|||
|
|
CWnd* GetLastActivePopup() const;
|
|||
|
|
CMenu* GetMenu() const;
|
|||
|
|
int GetScrollPos(int nBar) const;
|
|||
|
|
BOOL GetScrollRange(int nBar, int& MinPos, int& MaxPos) const;
|
|||
|
|
CMenu* GetSystemMenu(BOOL bRevert) const;
|
|||
|
|
CWnd* GetTopWindow() const;
|
|||
|
|
BOOL GetWindowPlacement(WINDOWPLACEMENT& pWndpl) const;
|
|||
|
|
BOOL HiliteMenuItem(CMenu* pMenu, UINT uItemHilite, UINT uHilite) const;
|
|||
|
|
BOOL IsIconic() const;
|
|||
|
|
BOOL IsZoomed() const;
|
|||
|
|
BOOL LockWindowUpdate() const;
|
|||
|
|
BOOL OpenIcon() const;
|
|||
|
|
void Print(CDC* pDC, DWORD dwFlags) const;
|
|||
|
|
BOOL SetMenu(CMenu* pMenu) const;
|
|||
|
|
BOOL ScrollWindow(int XAmount, int YAmount, LPCRECT lprcScroll, LPCRECT lprcClip) const;
|
|||
|
|
int ScrollWindowEx(int dx, int dy, LPCRECT lprcScroll, LPCRECT lprcClip, CRgn* prgnUpdate, LPRECT lprcUpdate, UINT flags) const;
|
|||
|
|
int SetScrollPos(int nBar, int nPos, BOOL bRedraw) const;
|
|||
|
|
BOOL SetScrollRange(int nBar, int nMinPos, int nMaxPos, BOOL bRedraw) const;
|
|||
|
|
BOOL SetWindowPlacement(const WINDOWPLACEMENT& wndpl) const;
|
|||
|
|
BOOL ShowOwnedPopups(BOOL fShow) const;
|
|||
|
|
BOOL ShowScrollBar(int nBar, BOOL bShow) const;
|
|||
|
|
BOOL ShowWindowAsync(int nCmdShow) const;
|
|||
|
|
BOOL UnLockWindowUpdate() const;
|
|||
|
|
CWnd* WindowFromDC(CDC* pDC) const;
|
|||
|
|
|
|||
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
|||
|
|
void DragAcceptFiles(BOOL fAccept) const;
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
static LRESULT CALLBACK StaticWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|||
|
|
operator HWND() const { return m_hWnd; }
|
|||
|
|
|
|||
|
|
protected:
|
|||
|
|
// Override these functions as required
|
|||
|
|
virtual LRESULT FinalWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|||
|
|
virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam);
|
|||
|
|
virtual void OnCreate();
|
|||
|
|
virtual void OnDraw(CDC* pDC);
|
|||
|
|
virtual BOOL OnEraseBkgnd(CDC* pDC);
|
|||
|
|
virtual void OnInitialUpdate();
|
|||
|
|
virtual void OnMenuUpdate(UINT nID);
|
|||
|
|
virtual LRESULT OnMessageReflect(UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|||
|
|
virtual LRESULT OnNotify(WPARAM wParam, LPARAM lParam);
|
|||
|
|
virtual LRESULT OnNotifyReflect(WPARAM wParam, LPARAM lParam);
|
|||
|
|
virtual void PreCreate(CREATESTRUCT& cs);
|
|||
|
|
virtual void PreRegisterClass(WNDCLASS& wc);
|
|||
|
|
virtual BOOL PreTranslateMessage(MSG* pMsg);
|
|||
|
|
virtual LRESULT WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|||
|
|
virtual LRESULT WndProcDefault(UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|||
|
|
|
|||
|
|
HWND m_hWnd; // handle to this object's window
|
|||
|
|
|
|||
|
|
private:
|
|||
|
|
CWnd(const CWnd&); // Disable copy construction
|
|||
|
|
CWnd& operator = (const CWnd&); // Disable assignment operator
|
|||
|
|
void AddToMap();
|
|||
|
|
void Cleanup();
|
|||
|
|
LRESULT MessageReflect(HWND hwndParent, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|||
|
|
BOOL RegisterClass(WNDCLASS& wc);
|
|||
|
|
BOOL RemoveFromMap();
|
|||
|
|
void Subclass(HWND hWnd);
|
|||
|
|
|
|||
|
|
Shared_Ptr<WNDCLASS> m_pwc; // defines initialisation parameters for PreRegisterClass
|
|||
|
|
Shared_Ptr<CREATESTRUCT> m_pcs; // defines initialisation parameters for PreCreate and Create
|
|||
|
|
WNDPROC m_PrevWindowProc; // pre-subclassed Window Procedure
|
|||
|
|
BOOL m_IsTmpWnd; // True if this CWnd is a TmpWnd
|
|||
|
|
|
|||
|
|
}; // class CWnd
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|||
|
|
|
|||
|
|
#include "gdi.h"
|
|||
|
|
#include "menu.h"
|
|||
|
|
|
|||
|
|
namespace Win32xx
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
//////////////////////////////////////////
|
|||
|
|
// Definitions for the CWinException class
|
|||
|
|
//
|
|||
|
|
inline CWinException::CWinException(LPCTSTR pszText) throw () : m_Error(::GetLastError()), m_pszText(pszText)
|
|||
|
|
{
|
|||
|
|
memset(m_szErrorString, 0, MAX_STRING_SIZE * sizeof(TCHAR));
|
|||
|
|
|
|||
|
|
if (m_Error != 0)
|
|||
|
|
{
|
|||
|
|
DWORD dwFlags = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;
|
|||
|
|
::FormatMessage(dwFlags, NULL, m_Error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), m_szErrorString, MAX_STRING_SIZE-1, NULL);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline DWORD CWinException::GetError() const throw ()
|
|||
|
|
{
|
|||
|
|
return m_Error;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LPCTSTR CWinException::GetErrorString() const throw ()
|
|||
|
|
{
|
|||
|
|
return m_szErrorString;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline const char * CWinException::what() const throw ()
|
|||
|
|
{
|
|||
|
|
// Sends the last error string to the debugger (typically displayed in the IDE's output window).
|
|||
|
|
::OutputDebugString(m_szErrorString);
|
|||
|
|
return "CWinException thrown";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
////////////////////////////////////
|
|||
|
|
// Definitions for the CWinApp class
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
// To begin Win32++, inherit your application class from this one.
|
|||
|
|
// You must run only one instance of the class inherited from this.
|
|||
|
|
inline CWinApp::CWinApp() : m_Callback(NULL), m_hAccel(0), m_pWndAccel(0)
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
m_csAppStart.Lock();
|
|||
|
|
assert( 0 == SetnGetThis() ); // Test if this is the first instance of CWinApp
|
|||
|
|
|
|||
|
|
m_dwTlsIndex = ::TlsAlloc();
|
|||
|
|
if (m_dwTlsIndex == TLS_OUT_OF_INDEXES)
|
|||
|
|
{
|
|||
|
|
// We only get here in the unlikely event that all TLS indexes are already allocated by this app
|
|||
|
|
// At least 64 TLS indexes per process are allowed. Win32++ requires only one TLS index.
|
|||
|
|
m_csAppStart.Release();
|
|||
|
|
throw CWinException(_T("CWinApp::CWinApp Failed to allocate TLS Index"));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
SetnGetThis(this);
|
|||
|
|
m_csAppStart.Release();
|
|||
|
|
|
|||
|
|
// Set the instance handle
|
|||
|
|
#ifdef _WIN32_WCE
|
|||
|
|
m_hInstance = (HINSTANCE)GetModuleHandle(0);
|
|||
|
|
#else
|
|||
|
|
MEMORY_BASIC_INFORMATION mbi = {0};
|
|||
|
|
VirtualQuery( (LPCVOID)SetnGetThis, &mbi, sizeof(mbi) );
|
|||
|
|
assert(mbi.AllocationBase);
|
|||
|
|
m_hInstance = (HINSTANCE)mbi.AllocationBase;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
m_hResource = m_hInstance;
|
|||
|
|
SetCallback();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
catch (const CWinException &e)
|
|||
|
|
{
|
|||
|
|
e.what();
|
|||
|
|
throw;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWinApp::~CWinApp()
|
|||
|
|
{
|
|||
|
|
std::vector<TLSDataPtr>::iterator iter;
|
|||
|
|
for (iter = m_vTLSData.begin(); iter < m_vTLSData.end(); ++iter)
|
|||
|
|
{
|
|||
|
|
(*iter)->vTmpDCs.clear();
|
|||
|
|
#ifndef _WIN32_WCE
|
|||
|
|
(*iter)->vTmpMenus.clear();
|
|||
|
|
#endif
|
|||
|
|
(*iter)->vTmpWnds.clear();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Check that all CWnd windows are destroyed
|
|||
|
|
std::map<HWND, CWnd*, CompareHWND>::iterator m;
|
|||
|
|
for (m = m_mapHWND.begin(); m != m_mapHWND.end(); ++m)
|
|||
|
|
{
|
|||
|
|
HWND hWnd = (*m).first;
|
|||
|
|
if (::IsWindow(hWnd))
|
|||
|
|
::DestroyWindow(hWnd);
|
|||
|
|
}
|
|||
|
|
m_mapHWND.clear();
|
|||
|
|
m_mapGDI.clear();
|
|||
|
|
m_mapHDC.clear();
|
|||
|
|
m_mapHMENU.clear();
|
|||
|
|
|
|||
|
|
// Do remaining tidy up
|
|||
|
|
if (m_dwTlsIndex != TLS_OUT_OF_INDEXES)
|
|||
|
|
{
|
|||
|
|
::TlsSetValue(GetTlsIndex(), NULL);
|
|||
|
|
::TlsFree(m_dwTlsIndex);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
SetnGetThis((CWinApp*)-1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWinApp::AddTmpDC(CDC* pDC)
|
|||
|
|
{
|
|||
|
|
// The TmpMenus are created by GetSybMenu.
|
|||
|
|
// They are removed by CleanupTemps
|
|||
|
|
assert(pDC);
|
|||
|
|
|
|||
|
|
// Ensure this thread has the TLS index set
|
|||
|
|
TLSData* pTLSData = GetApp()->SetTlsIndex();
|
|||
|
|
pTLSData->vTmpDCs.push_back(pDC); // save pDC as a smart pointer
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWinApp::AddTmpGDI(CGDIObject* pObject)
|
|||
|
|
{
|
|||
|
|
// The temporary CGDIObjects are removed by CleanupTemps
|
|||
|
|
assert(pObject);
|
|||
|
|
|
|||
|
|
// Ensure this thread has the TLS index set
|
|||
|
|
TLSData* pTLSData = GetApp()->SetTlsIndex();
|
|||
|
|
pTLSData->vTmpGDIs.push_back(pObject); // save pObject as a smart pointer
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#ifndef _WIN32_WCE
|
|||
|
|
inline CMenu* CWinApp::AddTmpMenu(HMENU hMenu)
|
|||
|
|
{
|
|||
|
|
// The TmpMenus are created by GetSybMenu.
|
|||
|
|
// They are removed by CleanupTemps
|
|||
|
|
assert(::IsMenu(hMenu));
|
|||
|
|
assert(!GetCMenuFromMap(hMenu));
|
|||
|
|
|
|||
|
|
CMenu* pMenu = new CMenu;
|
|||
|
|
pMenu->m_hMenu = hMenu;
|
|||
|
|
m_csMapLock.Lock();
|
|||
|
|
m_mapHMENU.insert(std::make_pair(hMenu, pMenu));
|
|||
|
|
m_csMapLock.Release();
|
|||
|
|
pMenu->m_IsTmpMenu = TRUE;
|
|||
|
|
|
|||
|
|
// Ensure this thread has the TLS index set
|
|||
|
|
TLSData* pTLSData = GetApp()->SetTlsIndex();
|
|||
|
|
pTLSData->vTmpMenus.push_back(pMenu); // save pMenu as a smart pointer
|
|||
|
|
return pMenu;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
inline CWnd* CWinApp::AddTmpWnd(HWND hWnd)
|
|||
|
|
{
|
|||
|
|
// TmpWnds are created if required to support functions like CWnd::GetParent.
|
|||
|
|
// They are removed by CleanupTemps
|
|||
|
|
assert(::IsWindow(hWnd));
|
|||
|
|
assert(!GetCWndFromMap(hWnd));
|
|||
|
|
|
|||
|
|
CWnd* pWnd = new CWnd;
|
|||
|
|
pWnd->m_hWnd = hWnd;
|
|||
|
|
pWnd->AddToMap();
|
|||
|
|
pWnd->m_IsTmpWnd = TRUE;
|
|||
|
|
|
|||
|
|
// Ensure this thread has the TLS index set
|
|||
|
|
TLSData* pTLSData = GetApp()->SetTlsIndex();
|
|||
|
|
pTLSData->vTmpWnds.push_back(pWnd); // save pWnd as a smart pointer
|
|||
|
|
return pWnd;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWinApp::CleanupTemps()
|
|||
|
|
// Removes all Temporary CWnds and CMenus belonging to this thread
|
|||
|
|
{
|
|||
|
|
// Retrieve the pointer to the TLS Data
|
|||
|
|
TLSData* pTLSData = (TLSData*)TlsGetValue(GetApp()->GetTlsIndex());
|
|||
|
|
assert(pTLSData);
|
|||
|
|
|
|||
|
|
pTLSData->vTmpDCs.clear();
|
|||
|
|
pTLSData->vTmpGDIs.clear();
|
|||
|
|
pTLSData->vTmpWnds.clear();
|
|||
|
|
|
|||
|
|
|
|||
|
|
#ifndef _WIN32_WCE
|
|||
|
|
pTLSData->vTmpMenus.clear();
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CDC* CWinApp::GetCDCFromMap(HDC hDC)
|
|||
|
|
{
|
|||
|
|
// Allocate an iterator for our HWND map
|
|||
|
|
std::map<HDC, CDC*, CompareHDC>::iterator m;
|
|||
|
|
|
|||
|
|
// Find the CDC pointer mapped to this HDC
|
|||
|
|
CDC* pDC = 0;
|
|||
|
|
m_csMapLock.Lock();
|
|||
|
|
m = m_mapHDC.find(hDC);
|
|||
|
|
|
|||
|
|
if (m != m_mapHDC.end())
|
|||
|
|
pDC = m->second;
|
|||
|
|
|
|||
|
|
m_csMapLock.Release();
|
|||
|
|
return pDC;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CGDIObject* CWinApp::GetCGDIObjectFromMap(HGDIOBJ hObject)
|
|||
|
|
{
|
|||
|
|
// Allocate an iterator for our HWND map
|
|||
|
|
std::map<HGDIOBJ, CGDIObject*, CompareGDI>::iterator m;
|
|||
|
|
|
|||
|
|
// Find the CGDIObject pointer mapped to this HGDIOBJ
|
|||
|
|
CGDIObject* pObject = 0;
|
|||
|
|
m_csMapLock.Lock();
|
|||
|
|
m = m_mapGDI.find(hObject);
|
|||
|
|
|
|||
|
|
if (m != m_mapGDI.end())
|
|||
|
|
pObject = m->second;
|
|||
|
|
|
|||
|
|
m_csMapLock.Release();
|
|||
|
|
return pObject;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CMenu* CWinApp::GetCMenuFromMap(HMENU hMenu)
|
|||
|
|
{
|
|||
|
|
std::map<HMENU, CMenu*, CompareHMENU>::iterator m;
|
|||
|
|
|
|||
|
|
// Find the CMenu pointer mapped to this HMENU
|
|||
|
|
CMenu* pMenu = 0;
|
|||
|
|
m_csMapLock.Lock();
|
|||
|
|
m = m_mapHMENU.find(hMenu);
|
|||
|
|
|
|||
|
|
if (m != m_mapHMENU.end())
|
|||
|
|
pMenu = m->second;
|
|||
|
|
|
|||
|
|
m_csMapLock.Release();
|
|||
|
|
return pMenu;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWinApp::GetCWndFromMap(HWND hWnd)
|
|||
|
|
{
|
|||
|
|
// Allocate an iterator for our HWND map
|
|||
|
|
std::map<HWND, CWnd*, CompareHWND>::iterator m;
|
|||
|
|
|
|||
|
|
// Find the CWnd pointer mapped to this HWND
|
|||
|
|
CWnd* pWnd = 0;
|
|||
|
|
m_csMapLock.Lock();
|
|||
|
|
m = m_mapHWND.find(hWnd);
|
|||
|
|
|
|||
|
|
if (m != m_mapHWND.end())
|
|||
|
|
pWnd = m->second;
|
|||
|
|
|
|||
|
|
m_csMapLock.Release();
|
|||
|
|
return pWnd;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWinApp::InitInstance()
|
|||
|
|
{
|
|||
|
|
// InitInstance contains the initialization code for your application
|
|||
|
|
// You should override this function with the code to run when the application starts.
|
|||
|
|
|
|||
|
|
// return TRUE to indicate success. FALSE will end the application
|
|||
|
|
return TRUE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWinApp::MessageLoop()
|
|||
|
|
{
|
|||
|
|
// This gets any messages queued for the application, and dispatches them.
|
|||
|
|
MSG Msg = {0};
|
|||
|
|
int status = 1;
|
|||
|
|
LONG lCount = 0;
|
|||
|
|
|
|||
|
|
while (status != 0)
|
|||
|
|
{
|
|||
|
|
// While idle, perform idle processing until OnIdle returns FALSE
|
|||
|
|
while (!::PeekMessage(&Msg, 0, 0, 0, PM_NOREMOVE) && OnIdle(lCount) == TRUE)
|
|||
|
|
{
|
|||
|
|
++lCount;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
lCount = 0;
|
|||
|
|
|
|||
|
|
// Now wait until we get a message
|
|||
|
|
if ((status = ::GetMessage(&Msg, NULL, 0, 0)) == -1)
|
|||
|
|
return -1;
|
|||
|
|
|
|||
|
|
if (!PreTranslateMessage(Msg))
|
|||
|
|
{
|
|||
|
|
::TranslateMessage(&Msg);
|
|||
|
|
::DispatchMessage(&Msg);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return LOWORD(Msg.wParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWinApp::OnIdle(LONG lCount)
|
|||
|
|
{
|
|||
|
|
if (lCount == 0)
|
|||
|
|
CleanupTemps();
|
|||
|
|
|
|||
|
|
return FALSE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWinApp::PreTranslateMessage(MSG Msg)
|
|||
|
|
{
|
|||
|
|
// This functions is called by the MessageLoop. It processes the
|
|||
|
|
// keyboard accelerator keys and calls CWnd::PreTranslateMessage for
|
|||
|
|
// keyboard and mouse events.
|
|||
|
|
|
|||
|
|
BOOL Processed = FALSE;
|
|||
|
|
|
|||
|
|
// only pre-translate mouse and keyboard input events
|
|||
|
|
if ((Msg.message >= WM_KEYFIRST && Msg.message <= WM_KEYLAST) ||
|
|||
|
|
(Msg.message >= WM_MOUSEFIRST && Msg.message <= WM_MOUSELAST))
|
|||
|
|
{
|
|||
|
|
// Process keyboard accelerators
|
|||
|
|
if (m_pWndAccel && ::TranslateAccelerator(*m_pWndAccel, m_hAccel, &Msg))
|
|||
|
|
Processed = TRUE;
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
// Search the chain of parents for pretranslated messages.
|
|||
|
|
for (HWND hWnd = Msg.hwnd; hWnd != NULL; hWnd = ::GetParent(hWnd))
|
|||
|
|
{
|
|||
|
|
CWnd* pWnd = GetCWndFromMap(hWnd);
|
|||
|
|
if (pWnd)
|
|||
|
|
{
|
|||
|
|
Processed = pWnd->PreTranslateMessage(&Msg);
|
|||
|
|
if(Processed)
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return Processed;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWinApp::Run()
|
|||
|
|
{
|
|||
|
|
// InitInstance runs the App's initialization code
|
|||
|
|
if (InitInstance())
|
|||
|
|
{
|
|||
|
|
// Dispatch the window messages
|
|||
|
|
return MessageLoop();
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
TRACE(_T("InitInstance failed! Terminating program\n"));
|
|||
|
|
::PostQuitMessage(-1);
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWinApp::SetAccelerators(HACCEL hAccel, CWnd* pWndAccel)
|
|||
|
|
// nID is the resource ID of the accelerator table
|
|||
|
|
// pWndAccel is the window pointer for translated messages
|
|||
|
|
{
|
|||
|
|
assert (hAccel);
|
|||
|
|
assert (pWndAccel);
|
|||
|
|
|
|||
|
|
m_pWndAccel = pWndAccel;
|
|||
|
|
m_hAccel = hAccel;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWinApp::SetCallback()
|
|||
|
|
{
|
|||
|
|
// Registers a temporary window class so we can get the callback
|
|||
|
|
// address of CWnd::StaticWindowProc.
|
|||
|
|
// This technique works for all Window versions, including WinCE.
|
|||
|
|
|
|||
|
|
WNDCLASS wcDefault = {0};
|
|||
|
|
|
|||
|
|
LPCTSTR szClassName = _T("Win32++ Temporary Window Class");
|
|||
|
|
wcDefault.hInstance = GetInstanceHandle();
|
|||
|
|
wcDefault.lpfnWndProc = CWnd::StaticWindowProc;
|
|||
|
|
wcDefault.lpszClassName = szClassName;
|
|||
|
|
|
|||
|
|
::RegisterClass(&wcDefault);
|
|||
|
|
|
|||
|
|
// Retrieve the class information
|
|||
|
|
ZeroMemory(&wcDefault, sizeof(wcDefault));
|
|||
|
|
::GetClassInfo(GetInstanceHandle(), szClassName, &wcDefault);
|
|||
|
|
|
|||
|
|
// Save the callback address of CWnd::StaticWindowProc
|
|||
|
|
assert(wcDefault.lpfnWndProc); // Assert fails when running UNICODE build on ANSI OS.
|
|||
|
|
m_Callback = wcDefault.lpfnWndProc;
|
|||
|
|
::UnregisterClass(szClassName, GetInstanceHandle());
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWinApp* CWinApp::SetnGetThis(CWinApp* pThis /*= 0*/)
|
|||
|
|
{
|
|||
|
|
// This function stores the 'this' pointer in a static variable.
|
|||
|
|
// Once stored, it can be used later to return the 'this' pointer.
|
|||
|
|
// CWinApp's Destructor calls this function with a value of -1.
|
|||
|
|
|
|||
|
|
static CWinApp* pWinApp = 0;
|
|||
|
|
|
|||
|
|
if ((CWinApp*)-1 == pThis)
|
|||
|
|
pWinApp = 0;
|
|||
|
|
else if (0 == pWinApp)
|
|||
|
|
pWinApp = pThis;
|
|||
|
|
|
|||
|
|
return pWinApp;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWinApp::SetResourceHandle(HINSTANCE hResource)
|
|||
|
|
{
|
|||
|
|
// This function can be used to load a resource dll.
|
|||
|
|
// A resource dll can be used to define resources in different languages.
|
|||
|
|
// To use this function, place code like this in InitInstance
|
|||
|
|
//
|
|||
|
|
// HINSTANCE hResource = LoadLibrary(_T("MyResourceDLL.dll"));
|
|||
|
|
// SetResourceHandle(hResource);
|
|||
|
|
|
|||
|
|
m_hResource = hResource;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline TLSData* CWinApp::SetTlsIndex()
|
|||
|
|
{
|
|||
|
|
TLSData* pTLSData = (TLSData*)::TlsGetValue(GetTlsIndex());
|
|||
|
|
if (NULL == pTLSData)
|
|||
|
|
{
|
|||
|
|
pTLSData = new TLSData;
|
|||
|
|
|
|||
|
|
m_csTLSLock.Lock();
|
|||
|
|
m_vTLSData.push_back(pTLSData); // store as a Shared_Ptr
|
|||
|
|
m_csTLSLock.Release();
|
|||
|
|
|
|||
|
|
::TlsSetValue(GetTlsIndex(), pTLSData);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return pTLSData;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
////////////////////////////////////////
|
|||
|
|
// Definitions for the CWnd class
|
|||
|
|
//
|
|||
|
|
inline CWnd::CWnd() : m_hWnd(NULL), m_PrevWindowProc(NULL), m_IsTmpWnd(FALSE)
|
|||
|
|
{
|
|||
|
|
// Note: m_hWnd is set in CWnd::CreateEx(...)
|
|||
|
|
m_pcs = new CREATESTRUCT; // store the CREATESTRICT in a smart pointer
|
|||
|
|
m_pwc = new WNDCLASS; // store the WNDCLASS in a smart pointer
|
|||
|
|
::ZeroMemory(m_pcs.get(), sizeof(CREATESTRUCT));
|
|||
|
|
::ZeroMemory(m_pwc.get(), sizeof(WNDCLASS));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd::~CWnd()
|
|||
|
|
{
|
|||
|
|
// Destroys the window for this object and cleans up resources.
|
|||
|
|
Destroy();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::AddToMap()
|
|||
|
|
// Store the window handle and CWnd pointer in the HWND map
|
|||
|
|
{
|
|||
|
|
assert( GetApp() );
|
|||
|
|
GetApp()->m_csMapLock.Lock();
|
|||
|
|
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
assert(!GetApp()->GetCWndFromMap(m_hWnd));
|
|||
|
|
|
|||
|
|
GetApp()->m_mapHWND.insert(std::make_pair(m_hWnd, this));
|
|||
|
|
GetApp()->m_csMapLock.Release();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::Attach(HWND hWnd)
|
|||
|
|
// Subclass an existing window and attach it to a CWnd
|
|||
|
|
{
|
|||
|
|
assert( GetApp() );
|
|||
|
|
assert(::IsWindow(hWnd));
|
|||
|
|
|
|||
|
|
// Ensure this thread has the TLS index set
|
|||
|
|
// Note: Perform the attach from the same thread as the window's message loop
|
|||
|
|
GetApp()->SetTlsIndex();
|
|||
|
|
|
|||
|
|
if (m_PrevWindowProc)
|
|||
|
|
Detach();
|
|||
|
|
|
|||
|
|
Subclass(hWnd);
|
|||
|
|
|
|||
|
|
// Store the CWnd pointer in the HWND map
|
|||
|
|
AddToMap();
|
|||
|
|
OnCreate();
|
|||
|
|
OnInitialUpdate();
|
|||
|
|
|
|||
|
|
return TRUE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::AttachDlgItem(UINT nID, CWnd* pParent)
|
|||
|
|
// Converts a dialog item to a CWnd object
|
|||
|
|
{
|
|||
|
|
assert(pParent->IsWindow());
|
|||
|
|
|
|||
|
|
HWND hWnd = ::GetDlgItem(pParent->GetHwnd(), nID);
|
|||
|
|
return Attach(hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::CenterWindow() const
|
|||
|
|
// Centers this window over it's parent
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
// required for multi-monitor support with Dev-C++ and VC6
|
|||
|
|
#ifndef _WIN32_WCE
|
|||
|
|
#ifndef MONITOR_DEFAULTTONEAREST
|
|||
|
|
#define MONITOR_DEFAULTTONEAREST 0x00000002
|
|||
|
|
#endif
|
|||
|
|
#ifndef HMONITOR
|
|||
|
|
DECLARE_HANDLE(HMONITOR);
|
|||
|
|
#endif
|
|||
|
|
#ifndef MONITORINFO
|
|||
|
|
typedef struct tagMONITORINFO
|
|||
|
|
{
|
|||
|
|
DWORD cbSize;
|
|||
|
|
RECT rcMonitor;
|
|||
|
|
RECT rcWork;
|
|||
|
|
DWORD dwFlags;
|
|||
|
|
} MONITORINFO, *LPMONITORINFO;
|
|||
|
|
#endif // MONITOR_DEFAULTTONEAREST
|
|||
|
|
#endif // _WIN32_WCE
|
|||
|
|
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
|
|||
|
|
CRect rc = GetWindowRect();
|
|||
|
|
CRect rcParent;
|
|||
|
|
CRect rcDesktop;
|
|||
|
|
|
|||
|
|
// Get screen dimensions excluding task bar
|
|||
|
|
::SystemParametersInfo(SPI_GETWORKAREA, 0, &rcDesktop, 0);
|
|||
|
|
|
|||
|
|
// Get the parent window dimensions (parent could be the desktop)
|
|||
|
|
if (GetParent() != NULL) rcParent = GetParent()->GetWindowRect();
|
|||
|
|
else rcParent = rcDesktop;
|
|||
|
|
|
|||
|
|
#ifndef _WIN32_WCE
|
|||
|
|
// Import the GetMonitorInfo and MonitorFromWindow functions
|
|||
|
|
HMODULE hUser32 = LoadLibrary(_T("USER32.DLL"));
|
|||
|
|
typedef BOOL (WINAPI* LPGMI)(HMONITOR hMonitor, LPMONITORINFO lpmi);
|
|||
|
|
typedef HMONITOR (WINAPI* LPMFW)(HWND hwnd, DWORD dwFlags);
|
|||
|
|
LPMFW pfnMonitorFromWindow = (LPMFW)::GetProcAddress(hUser32, "MonitorFromWindow");
|
|||
|
|
#ifdef _UNICODE
|
|||
|
|
LPGMI pfnGetMonitorInfo = (LPGMI)::GetProcAddress(hUser32, "GetMonitorInfoW");
|
|||
|
|
#else
|
|||
|
|
LPGMI pfnGetMonitorInfo = (LPGMI)::GetProcAddress(hUser32, "GetMonitorInfoA");
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
// Take multi-monitor systems into account
|
|||
|
|
if (pfnGetMonitorInfo && pfnMonitorFromWindow)
|
|||
|
|
{
|
|||
|
|
HMONITOR hActiveMonitor = pfnMonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST);
|
|||
|
|
MONITORINFO mi = { sizeof(mi), 0};
|
|||
|
|
|
|||
|
|
if(pfnGetMonitorInfo(hActiveMonitor, &mi))
|
|||
|
|
{
|
|||
|
|
rcDesktop = mi.rcWork;
|
|||
|
|
if (GetParent() == NULL) rcParent = mi.rcWork;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
FreeLibrary(hUser32);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
// Calculate point to center the dialog over the portion of parent window on this monitor
|
|||
|
|
rcParent.IntersectRect(rcParent, rcDesktop);
|
|||
|
|
int x = rcParent.left + (rcParent.Width() - rc.Width())/2;
|
|||
|
|
int y = rcParent.top + (rcParent.Height() - rc.Height())/2;
|
|||
|
|
|
|||
|
|
// Keep the dialog wholly on the monitor display
|
|||
|
|
x = (x < rcDesktop.left)? rcDesktop.left : x;
|
|||
|
|
x = (x > rcDesktop.right - rc.Width())? rcDesktop.right - rc.Width() : x;
|
|||
|
|
y = (y < rcDesktop.top) ? rcDesktop.top: y;
|
|||
|
|
y = (y > rcDesktop.bottom - rc.Height())? rcDesktop.bottom - rc.Height() : y;
|
|||
|
|
|
|||
|
|
SetWindowPos(HWND_TOP, x, y, 0, 0, SWP_NOSIZE);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::Cleanup()
|
|||
|
|
// Returns the CWnd to its default state
|
|||
|
|
{
|
|||
|
|
if ( GetApp() ) RemoveFromMap();
|
|||
|
|
m_hWnd = NULL;
|
|||
|
|
m_PrevWindowProc = NULL;
|
|||
|
|
m_IsTmpWnd = FALSE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline HWND CWnd::Create(CWnd* pParent /* = NULL */)
|
|||
|
|
// Creates the window. This is the default method of window creation.
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
// Test if Win32++ has been started
|
|||
|
|
assert( GetApp() );
|
|||
|
|
|
|||
|
|
// Set the WNDCLASS parameters
|
|||
|
|
PreRegisterClass(*m_pwc);
|
|||
|
|
if (m_pwc->lpszClassName)
|
|||
|
|
{
|
|||
|
|
RegisterClass(*m_pwc);
|
|||
|
|
m_pcs->lpszClass = m_pwc->lpszClassName;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Set the CREATESTRUCT parameters
|
|||
|
|
PreCreate(*m_pcs);
|
|||
|
|
|
|||
|
|
// Set the Window Class Name
|
|||
|
|
if (!m_pcs->lpszClass)
|
|||
|
|
m_pcs->lpszClass = _T("Win32++ Window");
|
|||
|
|
|
|||
|
|
// Set Parent
|
|||
|
|
HWND hWndParent = pParent? pParent->GetHwnd() : 0;
|
|||
|
|
if (!hWndParent && m_pcs->hwndParent)
|
|||
|
|
hWndParent = m_pcs->hwndParent;
|
|||
|
|
|
|||
|
|
// Set the window style
|
|||
|
|
DWORD dwStyle;
|
|||
|
|
DWORD dwOverlappedStyle = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
|
|||
|
|
if (m_pcs->style)
|
|||
|
|
dwStyle = m_pcs->style;
|
|||
|
|
else
|
|||
|
|
dwStyle = WS_VISIBLE | ((hWndParent)? WS_CHILD : dwOverlappedStyle);
|
|||
|
|
|
|||
|
|
// Set window size and position
|
|||
|
|
int x = (m_pcs->cx || m_pcs->cy)? m_pcs->x : CW_USEDEFAULT;
|
|||
|
|
int cx = (m_pcs->cx || m_pcs->cy)? m_pcs->cx : CW_USEDEFAULT;
|
|||
|
|
int y = (m_pcs->cx || m_pcs->cy)? m_pcs->y : CW_USEDEFAULT;
|
|||
|
|
int cy = (m_pcs->cx || m_pcs->cy)? m_pcs->cy : CW_USEDEFAULT;
|
|||
|
|
|
|||
|
|
// Create the window
|
|||
|
|
#ifndef _WIN32_WCE
|
|||
|
|
CreateEx(m_pcs->dwExStyle, m_pcs->lpszClass, m_pcs->lpszName, dwStyle, x, y,
|
|||
|
|
cx, cy, pParent, FromHandle(m_pcs->hMenu), m_pcs->lpCreateParams);
|
|||
|
|
#else
|
|||
|
|
CreateEx(m_pcs->dwExStyle, m_pcs->lpszClass, m_pcs->lpszName, dwStyle, x, y,
|
|||
|
|
cx, cy, pParent, 0, m_pcs->lpCreateParams);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
return m_hWnd;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline HWND CWnd::CreateEx(DWORD dwExStyle, LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rc, CWnd* pParent, CMenu* pMenu, LPVOID lpParam /*= NULL*/)
|
|||
|
|
// Creates the window by specifying all the window creation parameters
|
|||
|
|
{
|
|||
|
|
int x = rc.left;
|
|||
|
|
int y = rc.top;
|
|||
|
|
int cx = rc.right - rc.left;
|
|||
|
|
int cy = rc.bottom - rc.top;
|
|||
|
|
return CreateEx(dwExStyle, lpszClassName, lpszWindowName, dwStyle, x, y, cx, cy, pParent, pMenu, lpParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline HWND CWnd::CreateEx(DWORD dwExStyle, LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, CWnd* pParent, CMenu* pMenu, LPVOID lpParam /*= NULL*/)
|
|||
|
|
// Creates the window by specifying all the window creation parameters
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
assert( GetApp() ); // Test if Win32++ has been started
|
|||
|
|
assert(!::IsWindow(m_hWnd)); // Only one window per CWnd instance allowed
|
|||
|
|
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
// Prepare the CWnd if it has been reused
|
|||
|
|
Destroy();
|
|||
|
|
|
|||
|
|
// Ensure a window class is registered
|
|||
|
|
std::vector<TCHAR> vTChar( MAX_STRING_SIZE+1, _T('\0') );
|
|||
|
|
TCHAR* ClassName = &vTChar[0];
|
|||
|
|
if (0 == lpszClassName || 0 == lstrlen(lpszClassName) )
|
|||
|
|
lstrcpyn (ClassName, _T("Win32++ Window"), MAX_STRING_SIZE);
|
|||
|
|
else
|
|||
|
|
// Create our own local copy of szClassName.
|
|||
|
|
lstrcpyn(ClassName, lpszClassName, MAX_STRING_SIZE);
|
|||
|
|
|
|||
|
|
WNDCLASS wc = {0};
|
|||
|
|
wc.lpszClassName = ClassName;
|
|||
|
|
wc.hbrBackground = (HBRUSH)::GetStockObject(WHITE_BRUSH);
|
|||
|
|
wc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
|
|||
|
|
|
|||
|
|
// Register the window class (if not already registered)
|
|||
|
|
if (!RegisterClass(wc))
|
|||
|
|
throw CWinException(_T("Failed to register window class"));
|
|||
|
|
|
|||
|
|
HWND hWndParent = pParent? pParent->GetHwnd() : 0;
|
|||
|
|
|
|||
|
|
// Ensure this thread has the TLS index set
|
|||
|
|
TLSData* pTLSData = GetApp()->SetTlsIndex();
|
|||
|
|
|
|||
|
|
// Store the CWnd pointer in thread local storage
|
|||
|
|
pTLSData->pCWnd = this;
|
|||
|
|
|
|||
|
|
// Create window
|
|||
|
|
#ifdef _WIN32_WCE
|
|||
|
|
m_hWnd = ::CreateWindowEx(dwExStyle, ClassName, lpszWindowName, dwStyle, x, y, nWidth, nHeight,
|
|||
|
|
hWndParent, 0, GetApp()->GetInstanceHandle(), lpParam);
|
|||
|
|
#else
|
|||
|
|
HMENU hMenu = pMenu? pMenu->GetHandle() : NULL;
|
|||
|
|
m_hWnd = ::CreateWindowEx(dwExStyle, ClassName, lpszWindowName, dwStyle, x, y, nWidth, nHeight,
|
|||
|
|
hWndParent, hMenu, GetApp()->GetInstanceHandle(), lpParam);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
// Now handle window creation failure
|
|||
|
|
if (!m_hWnd)
|
|||
|
|
throw CWinException(_T("Failed to Create Window"));
|
|||
|
|
|
|||
|
|
// Automatically subclass predefined window class types
|
|||
|
|
::GetClassInfo(GetApp()->GetInstanceHandle(), lpszClassName, &wc);
|
|||
|
|
if (wc.lpfnWndProc != GetApp()->m_Callback)
|
|||
|
|
{
|
|||
|
|
Subclass(m_hWnd);
|
|||
|
|
|
|||
|
|
// Send a message to force the HWND to be added to the map
|
|||
|
|
SendMessage(WM_NULL, 0L, 0L);
|
|||
|
|
|
|||
|
|
OnCreate(); // We missed the WM_CREATE message, so call OnCreate now
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Clear the CWnd pointer from TLS
|
|||
|
|
pTLSData->pCWnd = NULL;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
catch (const CWinException &e)
|
|||
|
|
{
|
|||
|
|
TRACE(_T("\n*** Failed to create window ***\n"));
|
|||
|
|
e.what(); // Display the last error message.
|
|||
|
|
|
|||
|
|
// eat the exception (don't rethrow)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Window creation is complete. Now call OnInitialUpdate
|
|||
|
|
OnInitialUpdate();
|
|||
|
|
|
|||
|
|
return m_hWnd;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::Destroy()
|
|||
|
|
// Destroys the window and returns the CWnd back to its default state, ready for reuse.
|
|||
|
|
{
|
|||
|
|
if (m_IsTmpWnd)
|
|||
|
|
m_hWnd = NULL;
|
|||
|
|
|
|||
|
|
if (IsWindow())
|
|||
|
|
::DestroyWindow(m_hWnd);
|
|||
|
|
|
|||
|
|
// Return the CWnd to its default state
|
|||
|
|
Cleanup();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline HWND CWnd::Detach()
|
|||
|
|
// Reverse an Attach
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
assert(0 != m_PrevWindowProc); // Only a subclassed window can be detached
|
|||
|
|
|
|||
|
|
SetWindowLongPtr(GWLP_WNDPROC, (LONG_PTR)m_PrevWindowProc);
|
|||
|
|
HWND hWnd = m_hWnd;
|
|||
|
|
Cleanup();
|
|||
|
|
|
|||
|
|
return hWnd;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::FinalWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|||
|
|
// Pass messages on to the appropriate default window procedure
|
|||
|
|
// CMDIChild and CMDIFrame override this function
|
|||
|
|
{
|
|||
|
|
return ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetAncestor(UINT gaFlags /*= GA_ROOTOWNER*/) const
|
|||
|
|
// The GetAncestor function retrieves a pointer to the ancestor (root parent)
|
|||
|
|
// of the window. Supports Win95.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
HWND hWnd;
|
|||
|
|
|
|||
|
|
#if (WINVER < 0x0500) // Win2000 and above
|
|||
|
|
UNREFERENCED_PARAMETER(gaFlags);
|
|||
|
|
hWnd = m_hWnd;
|
|||
|
|
HWND hWndParent = ::GetParent(hWnd);
|
|||
|
|
while (::IsChild(hWndParent, hWnd))
|
|||
|
|
{
|
|||
|
|
hWnd = hWndParent;
|
|||
|
|
hWndParent = ::GetParent(hWnd);
|
|||
|
|
}
|
|||
|
|
#else
|
|||
|
|
hWnd = ::GetAncestor(m_hWnd, gaFlags);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
return FromHandle(hWnd);
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CString CWnd::GetClassName() const
|
|||
|
|
// Retrieves the name of the class to which the specified window belongs.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
|
|||
|
|
CString str;
|
|||
|
|
LPTSTR szStr = str.GetBuffer(MAX_STRING_SIZE+1);
|
|||
|
|
::GetClassName(m_hWnd, szStr, MAX_STRING_SIZE+1);
|
|||
|
|
str.ReleaseBuffer();
|
|||
|
|
return str;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CString CWnd::GetDlgItemText(int nIDDlgItem) const
|
|||
|
|
// Retrieves the title or text associated with a control in a dialog box.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
|
|||
|
|
int nLength = ::GetWindowTextLength(::GetDlgItem(m_hWnd, nIDDlgItem));
|
|||
|
|
CString str;
|
|||
|
|
LPTSTR szStr = str.GetBuffer(nLength+1);
|
|||
|
|
::GetDlgItemText(m_hWnd, nIDDlgItem, szStr, nLength+1);
|
|||
|
|
str.ReleaseBuffer();
|
|||
|
|
return str;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CString CWnd::GetWindowText() const
|
|||
|
|
// Retrieves the text of the window's title bar.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
|
|||
|
|
int nLength = ::GetWindowTextLength(m_hWnd);
|
|||
|
|
CString str;
|
|||
|
|
LPTSTR szStr = str.GetBuffer(nLength+1);
|
|||
|
|
::GetWindowText(m_hWnd, szStr, nLength+1);
|
|||
|
|
str.ReleaseBuffer();
|
|||
|
|
return str;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::OnCommand(WPARAM wParam, LPARAM lParam)
|
|||
|
|
{
|
|||
|
|
UNREFERENCED_PARAMETER(wParam);
|
|||
|
|
UNREFERENCED_PARAMETER(lParam);
|
|||
|
|
|
|||
|
|
// Override this to handle WM_COMMAND messages, for example
|
|||
|
|
|
|||
|
|
// switch (LOWORD(wParam))
|
|||
|
|
// {
|
|||
|
|
// case IDM_FILE_NEW:
|
|||
|
|
// OnFileNew();
|
|||
|
|
// TRUE; // return TRUE for handled commands
|
|||
|
|
// }
|
|||
|
|
|
|||
|
|
// return FALSE for unhandled commands
|
|||
|
|
return FALSE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::OnCreate()
|
|||
|
|
{
|
|||
|
|
// This function is called when a WM_CREATE message is recieved
|
|||
|
|
// Override it in your derived class to automatically perform tasks
|
|||
|
|
// during window creation.
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::OnDraw(CDC* pDC)
|
|||
|
|
// Called when part of the client area of the window needs to be drawn
|
|||
|
|
{
|
|||
|
|
UNREFERENCED_PARAMETER(pDC);
|
|||
|
|
|
|||
|
|
// Override this function in your derived class to perform drawing tasks.
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::OnEraseBkgnd(CDC* pDC)
|
|||
|
|
// Called when the background of the window's client area needs to be erased.
|
|||
|
|
{
|
|||
|
|
UNREFERENCED_PARAMETER(pDC);
|
|||
|
|
|
|||
|
|
// Override this function in your derived class to perform drawing tasks.
|
|||
|
|
|
|||
|
|
// Return Value: Return FALSE to also permit default erasure of the background
|
|||
|
|
// Return TRUE to prevent default erasure of the background
|
|||
|
|
|
|||
|
|
return FALSE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
inline void CWnd::OnInitialUpdate()
|
|||
|
|
{
|
|||
|
|
// This function is called automatically once the window is created
|
|||
|
|
// Override it in your derived class to automatically perform tasks
|
|||
|
|
// after window creation.
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::MessageReflect(HWND hWndParent, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|||
|
|
{
|
|||
|
|
// A function used to call OnMessageReflect. You shouldn't need to call or
|
|||
|
|
// override this function.
|
|||
|
|
|
|||
|
|
HWND hWnd = NULL;
|
|||
|
|
switch (uMsg)
|
|||
|
|
{
|
|||
|
|
case WM_COMMAND:
|
|||
|
|
case WM_CTLCOLORBTN:
|
|||
|
|
case WM_CTLCOLOREDIT:
|
|||
|
|
case WM_CTLCOLORDLG:
|
|||
|
|
case WM_CTLCOLORLISTBOX:
|
|||
|
|
case WM_CTLCOLORSCROLLBAR:
|
|||
|
|
case WM_CTLCOLORSTATIC:
|
|||
|
|
case WM_CHARTOITEM:
|
|||
|
|
case WM_VKEYTOITEM:
|
|||
|
|
case WM_HSCROLL:
|
|||
|
|
case WM_VSCROLL:
|
|||
|
|
hWnd = (HWND)lParam;
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case WM_DRAWITEM:
|
|||
|
|
case WM_MEASUREITEM:
|
|||
|
|
case WM_DELETEITEM:
|
|||
|
|
case WM_COMPAREITEM:
|
|||
|
|
hWnd = ::GetDlgItem(hWndParent, (int)wParam);
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case WM_PARENTNOTIFY:
|
|||
|
|
switch(LOWORD(wParam))
|
|||
|
|
{
|
|||
|
|
case WM_CREATE:
|
|||
|
|
case WM_DESTROY:
|
|||
|
|
hWnd = (HWND)lParam;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
CWnd* Wnd = GetApp()->GetCWndFromMap(hWnd);
|
|||
|
|
|
|||
|
|
if (Wnd != NULL)
|
|||
|
|
return Wnd->OnMessageReflect(uMsg, wParam, lParam);
|
|||
|
|
|
|||
|
|
return 0L;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::OnMessageReflect(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|||
|
|
{
|
|||
|
|
UNREFERENCED_PARAMETER(uMsg);
|
|||
|
|
UNREFERENCED_PARAMETER(wParam);
|
|||
|
|
UNREFERENCED_PARAMETER(lParam);
|
|||
|
|
// This function processes those special messages (see above) sent
|
|||
|
|
// by some older controls, and reflects them back to the originating CWnd object.
|
|||
|
|
// Override this function in your derrived class to handle these special messages.
|
|||
|
|
|
|||
|
|
// Your overriding function should look like this ...
|
|||
|
|
|
|||
|
|
// switch (uMsg)
|
|||
|
|
// {
|
|||
|
|
// Handle your reflected messages here
|
|||
|
|
// }
|
|||
|
|
|
|||
|
|
// return 0L for unhandled messages
|
|||
|
|
return 0L;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::OnNotify(WPARAM wParam, LPARAM lParam)
|
|||
|
|
{
|
|||
|
|
UNREFERENCED_PARAMETER(wParam);
|
|||
|
|
UNREFERENCED_PARAMETER(lParam);
|
|||
|
|
|
|||
|
|
// You can use either OnNotifyReflect or OnNotify to handle notifications
|
|||
|
|
// Override OnNotifyReflect to handle notifications in the CWnd class that
|
|||
|
|
// generated the notification. OR
|
|||
|
|
// Override OnNotify to handle notifications in the PARENT of the CWnd class
|
|||
|
|
// that generated the notification.
|
|||
|
|
|
|||
|
|
// Your overriding function should look like this ...
|
|||
|
|
|
|||
|
|
// switch (((LPNMHDR)lParam)->code)
|
|||
|
|
// {
|
|||
|
|
// Handle your notifications from the CHILD window here
|
|||
|
|
// Return the value recommended by the Windows API documentation.
|
|||
|
|
// For many notifications, the return value doesn't matter, but for some it does.
|
|||
|
|
// }
|
|||
|
|
|
|||
|
|
// return 0L for unhandled notifications
|
|||
|
|
return 0L;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::OnNotifyReflect(WPARAM wParam, LPARAM lParam)
|
|||
|
|
{
|
|||
|
|
UNREFERENCED_PARAMETER(wParam);
|
|||
|
|
UNREFERENCED_PARAMETER(lParam);
|
|||
|
|
|
|||
|
|
// Override OnNotifyReflect to handle notifications in the CWnd class that
|
|||
|
|
// generated the notification.
|
|||
|
|
|
|||
|
|
// Your overriding function should look like this ...
|
|||
|
|
|
|||
|
|
// switch (((LPNMHDR)lParam)->code)
|
|||
|
|
// {
|
|||
|
|
// Handle your notifications from this window here
|
|||
|
|
// Return the value recommended by the Windows API documentation.
|
|||
|
|
// }
|
|||
|
|
|
|||
|
|
// return 0L for unhandled notifications
|
|||
|
|
return 0L;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::OnMenuUpdate(UINT nID)
|
|||
|
|
// Called when menu items are about to be displayed
|
|||
|
|
{
|
|||
|
|
UNREFERENCED_PARAMETER(nID);
|
|||
|
|
|
|||
|
|
// Override this function to modify the behaviour of menu items,
|
|||
|
|
// such as adding or removing checkmarks
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::PreCreate(CREATESTRUCT& cs)
|
|||
|
|
// Called by CWnd::Create to set some window parameters
|
|||
|
|
{
|
|||
|
|
// Test if Win32++ has been started
|
|||
|
|
assert(GetApp()); // Test if Win32++ has been started
|
|||
|
|
|
|||
|
|
m_pcs->cx = cs.cx;
|
|||
|
|
m_pcs->cy = cs.cy;
|
|||
|
|
m_pcs->dwExStyle = cs.dwExStyle;
|
|||
|
|
m_pcs->hInstance = GetApp()->GetInstanceHandle();
|
|||
|
|
m_pcs->hMenu = cs.hMenu;
|
|||
|
|
m_pcs->hwndParent = cs.hwndParent;
|
|||
|
|
m_pcs->lpCreateParams = cs.lpCreateParams;
|
|||
|
|
m_pcs->lpszClass = cs.lpszClass;
|
|||
|
|
m_pcs->lpszName = cs.lpszName;
|
|||
|
|
m_pcs->style = cs.style;
|
|||
|
|
m_pcs->x = cs.x;
|
|||
|
|
m_pcs->y = cs.y;
|
|||
|
|
|
|||
|
|
// Overide this function in your derived class to set the
|
|||
|
|
// CREATESTRUCT values prior to window creation.
|
|||
|
|
// The cs.lpszClass parameter should NOT be specified if the
|
|||
|
|
// PreRegisterClass function is used to create a window class.
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::PreRegisterClass(WNDCLASS& wc)
|
|||
|
|
// Called by CWnd::Create to set some window parameters
|
|||
|
|
// Useful for setting the background brush and cursor
|
|||
|
|
{
|
|||
|
|
// Test if Win32++ has been started
|
|||
|
|
assert( GetApp() );
|
|||
|
|
|
|||
|
|
m_pwc->style = wc.style;
|
|||
|
|
m_pwc->lpfnWndProc = CWnd::StaticWindowProc;
|
|||
|
|
m_pwc->cbClsExtra = wc.cbClsExtra;
|
|||
|
|
m_pwc->cbWndExtra = wc.cbWndExtra;
|
|||
|
|
m_pwc->hInstance = GetApp()->GetInstanceHandle();
|
|||
|
|
m_pwc->hIcon = wc.hIcon;
|
|||
|
|
m_pwc->hCursor = wc.hCursor;
|
|||
|
|
m_pwc->hbrBackground = wc.hbrBackground;
|
|||
|
|
m_pwc->lpszMenuName = wc.lpszMenuName;
|
|||
|
|
m_pwc->lpszClassName = wc.lpszClassName;
|
|||
|
|
|
|||
|
|
// Overide this function in your derived class to set the
|
|||
|
|
// WNDCLASS values prior to window creation.
|
|||
|
|
|
|||
|
|
// ADDITIONAL NOTES:
|
|||
|
|
// 1) The lpszClassName must be set for this function to take effect.
|
|||
|
|
// 2) The lpfnWndProc is always CWnd::StaticWindowProc.
|
|||
|
|
// 3) No other defaults are set, so the following settings might prove useful
|
|||
|
|
// wc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
|
|||
|
|
// wc.hbrBackground = (HBRUSH)::GetStockObject(WHITE_BRUSH);
|
|||
|
|
// wc.hIcon = ::LoadIcon(NULL, IDI_APPLICATION);
|
|||
|
|
// 4) The styles that can be set here are WNDCLASS styles. These are a different
|
|||
|
|
// set of styles to those set by CREATESTRUCT (used in PreCreate).
|
|||
|
|
// 5) RegisterClassEx is not used because its not supported on WinCE.
|
|||
|
|
// To set a small icon for the window, use SetIconSmall.
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::PreTranslateMessage(MSG* pMsg)
|
|||
|
|
{
|
|||
|
|
UNREFERENCED_PARAMETER(pMsg);
|
|||
|
|
|
|||
|
|
// Override this function if your class requires input messages to be
|
|||
|
|
// translated before normal processing. Function which translate messages
|
|||
|
|
// include TranslateAccelerator, TranslateMDISysAccel and IsDialogMessage.
|
|||
|
|
// Return TRUE if the message is translated.
|
|||
|
|
|
|||
|
|
return FALSE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::RegisterClass(WNDCLASS& wc)
|
|||
|
|
// A private function used by the PreRegisterClass function to register a
|
|||
|
|
// window class prior to window creation
|
|||
|
|
{
|
|||
|
|
assert( GetApp() );
|
|||
|
|
assert( (0 != lstrlen(wc.lpszClassName) && ( lstrlen(wc.lpszClassName) <= MAX_STRING_SIZE) ) );
|
|||
|
|
|
|||
|
|
// Check to see if this classname is already registered
|
|||
|
|
WNDCLASS wcTest = {0};
|
|||
|
|
BOOL Done = FALSE;
|
|||
|
|
|
|||
|
|
if (::GetClassInfo(GetApp()->GetInstanceHandle(), wc.lpszClassName, &wcTest))
|
|||
|
|
{
|
|||
|
|
wc = wcTest;
|
|||
|
|
Done = TRUE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!Done)
|
|||
|
|
{
|
|||
|
|
// Set defaults
|
|||
|
|
wc.hInstance = GetApp()->GetInstanceHandle();
|
|||
|
|
wc.lpfnWndProc = CWnd::StaticWindowProc;
|
|||
|
|
|
|||
|
|
// Register the WNDCLASS structure
|
|||
|
|
if ( !::RegisterClass(&wc) )
|
|||
|
|
throw CWinException(_T("Failed to register window class"));
|
|||
|
|
|
|||
|
|
Done = TRUE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return Done;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::RemoveFromMap()
|
|||
|
|
{
|
|||
|
|
BOOL Success = FALSE;
|
|||
|
|
|
|||
|
|
if (GetApp())
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
// Allocate an iterator for our HWND map
|
|||
|
|
std::map<HWND, CWnd*, CompareHWND>::iterator m;
|
|||
|
|
|
|||
|
|
CWinApp* pApp = GetApp();
|
|||
|
|
if (pApp)
|
|||
|
|
{
|
|||
|
|
// Erase the CWnd pointer entry from the map
|
|||
|
|
pApp->m_csMapLock.Lock();
|
|||
|
|
for (m = pApp->m_mapHWND.begin(); m != pApp->m_mapHWND.end(); ++m)
|
|||
|
|
{
|
|||
|
|
if (this == m->second)
|
|||
|
|
{
|
|||
|
|
pApp->m_mapHWND.erase(m);
|
|||
|
|
Success = TRUE;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
pApp->m_csMapLock.Release();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return Success;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline HICON CWnd::SetIconLarge(int nIcon)
|
|||
|
|
// Sets the large icon associated with the window
|
|||
|
|
{
|
|||
|
|
assert( GetApp() );
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
|
|||
|
|
HICON hIconLarge = (HICON) (::LoadImage (GetApp()->GetResourceHandle(), MAKEINTRESOURCE (nIcon), IMAGE_ICON,
|
|||
|
|
::GetSystemMetrics (SM_CXICON), ::GetSystemMetrics (SM_CYICON), 0));
|
|||
|
|
|
|||
|
|
if (hIconLarge)
|
|||
|
|
SendMessage (WM_SETICON, WPARAM (ICON_BIG), LPARAM (hIconLarge));
|
|||
|
|
else
|
|||
|
|
TRACE(_T("**WARNING** SetIconLarge Failed\n"));
|
|||
|
|
|
|||
|
|
return hIconLarge;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline HICON CWnd::SetIconSmall(int nIcon)
|
|||
|
|
// Sets the small icon associated with the window
|
|||
|
|
{
|
|||
|
|
assert( GetApp() );
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
|
|||
|
|
HICON hIconSmall = (HICON) (::LoadImage (GetApp()->GetResourceHandle(), MAKEINTRESOURCE (nIcon), IMAGE_ICON,
|
|||
|
|
::GetSystemMetrics (SM_CXSMICON), ::GetSystemMetrics (SM_CYSMICON), 0));
|
|||
|
|
|
|||
|
|
if (hIconSmall)
|
|||
|
|
SendMessage (WM_SETICON, WPARAM (ICON_SMALL), LPARAM (hIconSmall));
|
|||
|
|
else
|
|||
|
|
TRACE(_T("**WARNING** SetIconSmall Failed\n"));
|
|||
|
|
|
|||
|
|
return hIconSmall;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CALLBACK CWnd::StaticWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|||
|
|
// All CWnd windows direct their messages here. This function redirects the message
|
|||
|
|
// to the CWnd's WndProc function.
|
|||
|
|
{
|
|||
|
|
assert( GetApp() );
|
|||
|
|
|
|||
|
|
CWnd* w = GetApp()->GetCWndFromMap(hWnd);
|
|||
|
|
if (0 == w)
|
|||
|
|
{
|
|||
|
|
// The CWnd pointer wasn't found in the map, so add it now
|
|||
|
|
|
|||
|
|
// Retrieve the pointer to the TLS Data
|
|||
|
|
TLSData* pTLSData = (TLSData*)TlsGetValue(GetApp()->GetTlsIndex());
|
|||
|
|
assert(pTLSData);
|
|||
|
|
|
|||
|
|
// Retrieve pointer to CWnd object from Thread Local Storage TLS
|
|||
|
|
w = pTLSData->pCWnd;
|
|||
|
|
assert(w); // pTLSData->pCWnd is assigned in CreateEx
|
|||
|
|
pTLSData->pCWnd = NULL;
|
|||
|
|
|
|||
|
|
// Store the CWnd pointer in the HWND map
|
|||
|
|
w->m_hWnd = hWnd;
|
|||
|
|
w->AddToMap();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return w->WndProc(uMsg, wParam, lParam);
|
|||
|
|
|
|||
|
|
} // LRESULT CALLBACK StaticWindowProc(...)
|
|||
|
|
|
|||
|
|
inline void CWnd::Subclass(HWND hWnd)
|
|||
|
|
// A private function used by CreateEx, Attach and AttachDlgItem
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(hWnd));
|
|||
|
|
|
|||
|
|
m_PrevWindowProc = (WNDPROC)::SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)CWnd::StaticWindowProc);
|
|||
|
|
m_hWnd = hWnd;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|||
|
|
{
|
|||
|
|
// Override this function in your class derrived from CWnd to handle
|
|||
|
|
// window messages. A typical function might look like this:
|
|||
|
|
|
|||
|
|
// switch (uMsg)
|
|||
|
|
// {
|
|||
|
|
// case MESSAGE1: // Some Windows API message
|
|||
|
|
// OnMessage1(); // A user defined function
|
|||
|
|
// break; // Also do default processing
|
|||
|
|
// case MESSAGE2:
|
|||
|
|
// OnMessage2();
|
|||
|
|
// return x; // Don't do default processing, but instead return
|
|||
|
|
// // a value recommended by the Windows API documentation
|
|||
|
|
// }
|
|||
|
|
|
|||
|
|
// Always pass unhandled messages on to WndProcDefault
|
|||
|
|
return WndProcDefault(uMsg, wParam, lParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::WndProcDefault(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|||
|
|
// All WndProc functions should pass unhandled window messages to this function
|
|||
|
|
{
|
|||
|
|
LRESULT lr = 0L;
|
|||
|
|
|
|||
|
|
switch (uMsg)
|
|||
|
|
{
|
|||
|
|
case UWM_CLEANUPTEMPS:
|
|||
|
|
{
|
|||
|
|
TLSData* pTLSData = (TLSData*)TlsGetValue(GetApp()->GetTlsIndex());
|
|||
|
|
pTLSData->vTmpWnds.clear();
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
case WM_COMMAND:
|
|||
|
|
{
|
|||
|
|
// Refelect this message if it's from a control
|
|||
|
|
CWnd* pWnd = GetApp()->GetCWndFromMap((HWND)lParam);
|
|||
|
|
if (pWnd != NULL)
|
|||
|
|
lr = pWnd->OnCommand(wParam, lParam);
|
|||
|
|
|
|||
|
|
// Handle user commands
|
|||
|
|
if (!lr)
|
|||
|
|
lr = OnCommand(wParam, lParam);
|
|||
|
|
|
|||
|
|
if (lr) return 0L;
|
|||
|
|
}
|
|||
|
|
break; // Note: Some MDI commands require default processing
|
|||
|
|
case WM_CREATE:
|
|||
|
|
OnCreate();
|
|||
|
|
break;
|
|||
|
|
// An example of how to end the application when the window closes
|
|||
|
|
// If needed, put this in the class you inherit from CWnd
|
|||
|
|
// case WM_DESTROY:
|
|||
|
|
// ::PostQuitMessage(0);
|
|||
|
|
// return 0L;
|
|||
|
|
case WM_NOTIFY:
|
|||
|
|
{
|
|||
|
|
// Do Notification reflection if it came from a CWnd object
|
|||
|
|
HWND hwndFrom = ((LPNMHDR)lParam)->hwndFrom;
|
|||
|
|
CWnd* pWndFrom = GetApp()->GetCWndFromMap(hwndFrom);
|
|||
|
|
|
|||
|
|
if (lstrcmp(GetClassName(), _T("ReBarWindow32")) != 0) // Skip notification reflection for rebars to avoid double handling
|
|||
|
|
{
|
|||
|
|
if (pWndFrom != NULL)
|
|||
|
|
lr = pWndFrom->OnNotifyReflect(wParam, lParam);
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
// Some controls (eg ListView) have child windows.
|
|||
|
|
// Reflect those notifications too.
|
|||
|
|
CWnd* pWndFromParent = GetApp()->GetCWndFromMap(::GetParent(hwndFrom));
|
|||
|
|
if (pWndFromParent != NULL)
|
|||
|
|
lr = pWndFromParent->OnNotifyReflect(wParam, lParam);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Handle user notifications
|
|||
|
|
if (!lr) lr = OnNotify(wParam, lParam);
|
|||
|
|
if (lr) return lr;
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case WM_PAINT:
|
|||
|
|
{
|
|||
|
|
// Subclassed controls expect to do their own painting.
|
|||
|
|
// CustomDraw or OwnerDraw are normally used to modify the drawing of controls.
|
|||
|
|
if (m_PrevWindowProc) break;
|
|||
|
|
|
|||
|
|
if (::GetUpdateRect(m_hWnd, NULL, FALSE))
|
|||
|
|
{
|
|||
|
|
CPaintDC dc(this);
|
|||
|
|
OnDraw(&dc);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
// RedrawWindow can require repainting without an update rect
|
|||
|
|
{
|
|||
|
|
CClientDC dc(this);
|
|||
|
|
OnDraw(&dc);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return 0L;
|
|||
|
|
|
|||
|
|
case WM_ERASEBKGND:
|
|||
|
|
{
|
|||
|
|
CDC dc((HDC)wParam);
|
|||
|
|
BOOL bResult = OnEraseBkgnd(&dc);
|
|||
|
|
dc.Detach();
|
|||
|
|
if (bResult) return TRUE;
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
// A set of messages to be reflected back to the control that generated them
|
|||
|
|
case WM_CTLCOLORBTN:
|
|||
|
|
case WM_CTLCOLOREDIT:
|
|||
|
|
case WM_CTLCOLORDLG:
|
|||
|
|
case WM_CTLCOLORLISTBOX:
|
|||
|
|
case WM_CTLCOLORSCROLLBAR:
|
|||
|
|
case WM_CTLCOLORSTATIC:
|
|||
|
|
case WM_DRAWITEM:
|
|||
|
|
case WM_MEASUREITEM:
|
|||
|
|
case WM_DELETEITEM:
|
|||
|
|
case WM_COMPAREITEM:
|
|||
|
|
case WM_CHARTOITEM:
|
|||
|
|
case WM_VKEYTOITEM:
|
|||
|
|
case WM_HSCROLL:
|
|||
|
|
case WM_VSCROLL:
|
|||
|
|
case WM_PARENTNOTIFY:
|
|||
|
|
{
|
|||
|
|
// if (m_PrevWindowProc) break; // Suppress for subclassed windows
|
|||
|
|
|
|||
|
|
LRESULT lr = MessageReflect(m_hWnd, uMsg, wParam, lParam);
|
|||
|
|
if (lr) return lr; // Message processed so return
|
|||
|
|
}
|
|||
|
|
break; // Do default processing when message not already processed
|
|||
|
|
|
|||
|
|
case UWM_UPDATE_COMMAND:
|
|||
|
|
OnMenuUpdate((UINT)wParam); // Perform menu updates
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
} // switch (uMsg)
|
|||
|
|
|
|||
|
|
// Now hand all messages to the default procedure
|
|||
|
|
if (m_PrevWindowProc)
|
|||
|
|
return ::CallWindowProc(m_PrevWindowProc, m_hWnd, uMsg, wParam, lParam);
|
|||
|
|
else
|
|||
|
|
return FinalWindowProc(uMsg, wParam, lParam);
|
|||
|
|
|
|||
|
|
} // LRESULT CWnd::WindowProc(...)
|
|||
|
|
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Wrappers for Win32 API functions
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
inline CDC* CWnd::BeginPaint(PAINTSTRUCT& ps) const
|
|||
|
|
// The BeginPaint function prepares the specified window for painting and fills a PAINTSTRUCT structure with
|
|||
|
|
// information about the painting.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle(::BeginPaint(m_hWnd, &ps));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::BringWindowToTop() const
|
|||
|
|
// The BringWindowToTop function brings the specified window to the top
|
|||
|
|
// of the Z order. If the window is a top-level window, it is activated.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::BringWindowToTop(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::CallWindowProc(WNDPROC lpPrevWndFunc, UINT Msg, WPARAM wParam, LPARAM lParam) const
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::CallWindowProc(lpPrevWndFunc, m_hWnd, Msg, wParam, lParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::CheckDlgButton(int nIDButton, UINT uCheck) const
|
|||
|
|
// The CheckDlgButton function changes the check state of a button control.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::CheckDlgButton(m_hWnd, nIDButton, uCheck);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::CheckRadioButton(int nIDFirstButton, int nIDLastButton, int nIDCheckButton) const
|
|||
|
|
// The CheckRadioButton function adds a check mark to (checks) a specified radio button in a group
|
|||
|
|
// and removes a check mark from (clears) all other radio buttons in the group.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::CheckRadioButton(m_hWnd, nIDFirstButton, nIDLastButton, nIDCheckButton);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::ChildWindowFromPoint(POINT pt) const
|
|||
|
|
// determines which, if any, of the child windows belonging to a parent window contains
|
|||
|
|
// the specified point. The search is restricted to immediate child windows.
|
|||
|
|
// Grandchildren, and deeper descendant windows are not searched.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle(::ChildWindowFromPoint(m_hWnd, pt));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::ClientToScreen(POINT& pt) const
|
|||
|
|
// The ClientToScreen function converts the client-area coordinates of a specified point to screen coordinates.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::ClientToScreen(m_hWnd, &pt);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::ClientToScreen(RECT& rc) const
|
|||
|
|
// The ClientToScreen function converts the client-area coordinates of a specified RECT to screen coordinates.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return (BOOL)::MapWindowPoints(m_hWnd, NULL, (LPPOINT)&rc, 2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline HDWP CWnd::DeferWindowPos(HDWP hWinPosInfo, HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT uFlags) const
|
|||
|
|
// The DeferWindowPos function updates the specified multiple-window <20> position structure for the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::DeferWindowPos(hWinPosInfo, m_hWnd, hWndInsertAfter, x, y, cx, cy, uFlags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline HDWP CWnd::DeferWindowPos(HDWP hWinPosInfo, HWND hWndInsertAfter, const RECT& rc, UINT uFlags) const
|
|||
|
|
// The DeferWindowPos function updates the specified multiple-window <20> position structure for the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::DeferWindowPos(hWinPosInfo, m_hWnd, hWndInsertAfter, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, uFlags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam) const
|
|||
|
|
// This function provides default processing for any window messages that an application does not process.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::DrawMenuBar() const
|
|||
|
|
// The DrawMenuBar function redraws the menu bar of the specified window. If the menu bar changes after
|
|||
|
|
// the system has created the window, this function must be called to draw the changed menu bar.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::DrawMenuBar(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::EnableWindow(BOOL bEnable /*= TRUE*/) const
|
|||
|
|
// The EnableWindow function enables or disables mouse and
|
|||
|
|
// keyboard input to the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::EnableWindow(m_hWnd, bEnable);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::EndPaint(PAINTSTRUCT& ps) const
|
|||
|
|
// The EndPaint function marks the end of painting in the specified window. This function is required for
|
|||
|
|
// each call to the BeginPaint function, but only after painting is complete.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::EndPaint(m_hWnd, &ps);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetActiveWindow() const
|
|||
|
|
// The GetActiveWindow function retrieves a pointer to the active window attached to the calling
|
|||
|
|
// thread's message queue.
|
|||
|
|
{
|
|||
|
|
return FromHandle( ::GetActiveWindow() );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetCapture() const
|
|||
|
|
// The GetCapture function retrieves a pointer to the window (if any) that has captured the mouse.
|
|||
|
|
{
|
|||
|
|
return FromHandle( ::GetCapture() );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline ULONG_PTR CWnd::GetClassLongPtr(int nIndex) const
|
|||
|
|
// The GetClassLongPtr function retrieves the specified value from the
|
|||
|
|
// WNDCLASSEX structure associated with the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::GetClassLongPtr(m_hWnd, nIndex);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CRect CWnd::GetClientRect() const
|
|||
|
|
// The GetClientRect function retrieves the coordinates of a window's client area.
|
|||
|
|
// The client coordinates specify the upper-left and lower-right corners of the
|
|||
|
|
// client area. Because client coordinates are relative to the upper-left corner
|
|||
|
|
// of a window's client area, the coordinates of the upper-left corner are (0,0).
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
CRect rc;
|
|||
|
|
::GetClientRect(m_hWnd, &rc);
|
|||
|
|
return rc;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CDC* CWnd::GetDC() const
|
|||
|
|
// The GetDC function retrieves a handle to a display device context (DC) for the
|
|||
|
|
// client area of the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return CDC::AddTempHDC(::GetDC(m_hWnd), m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CDC* CWnd::GetDCEx(HRGN hrgnClip, DWORD flags) const
|
|||
|
|
// The GetDCEx function retrieves a handle to a display device context (DC) for the
|
|||
|
|
// client area or entire area of a window
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return CDC::AddTempHDC(::GetDCEx(m_hWnd, hrgnClip, flags), m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetDesktopWindow() const
|
|||
|
|
// The GetDesktopWindow function retrieves a pointer to the desktop window.
|
|||
|
|
{
|
|||
|
|
return FromHandle( ::GetDesktopWindow() );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetDlgItem(int nIDDlgItem) const
|
|||
|
|
// The GetDlgItem function retrieves a handle to a control in the dialog box.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle( ::GetDlgItem(m_hWnd, nIDDlgItem) );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline UINT CWnd::GetDlgItemInt(int nIDDlgItem, BOOL* lpTranslated, BOOL bSigned) const
|
|||
|
|
// The GetDlgItemInt function translates the text of a specified control in a dialog box into an integer value.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::GetDlgItemInt(m_hWnd, nIDDlgItem, lpTranslated, bSigned);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetFocus() const
|
|||
|
|
// The GetFocus function retrieves a pointer to the window that has the keyboard focus, if the window
|
|||
|
|
// is attached to the calling thread's message queue.
|
|||
|
|
{
|
|||
|
|
return FromHandle( ::GetFocus() );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CFont* CWnd::GetFont() const
|
|||
|
|
// Retrieves the font with which the window is currently drawing its text.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle((HFONT)SendMessage(WM_GETFONT, 0, 0));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline HICON CWnd::GetIcon(BOOL bBigIcon) const
|
|||
|
|
// Retrieves a handle to the large or small icon associated with a window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return (HICON)SendMessage(WM_GETICON, (WPARAM)bBigIcon, 0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetNextDlgGroupItem(CWnd* pCtl, BOOL bPrevious) const
|
|||
|
|
// The GetNextDlgGroupItem function retrieves a pointer to the first control in a group of controls that
|
|||
|
|
// precedes (or follows) the specified control in a dialog box.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
assert(pCtl);
|
|||
|
|
return FromHandle(::GetNextDlgGroupItem(m_hWnd, pCtl->GetHwnd(), bPrevious));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetNextDlgTabItem(CWnd* pCtl, BOOL bPrevious) const
|
|||
|
|
// The GetNextDlgTabItem function retrieves a pointer to the first control that has the WS_TABSTOP style
|
|||
|
|
// that precedes (or follows) the specified control.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
assert(pCtl);
|
|||
|
|
return FromHandle(::GetNextDlgTabItem(m_hWnd, pCtl->GetHwnd(), bPrevious));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetParent() const
|
|||
|
|
// The GetParent function retrieves a pointer to the specified window's parent or owner.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle( ::GetParent(m_hWnd) );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LONG_PTR CWnd::GetWindowLongPtr(int nIndex) const
|
|||
|
|
// The GetWindowLongPtr function retrieves information about the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::GetWindowLongPtr(m_hWnd, nIndex);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::GetScrollInfo(int fnBar, SCROLLINFO& si) const
|
|||
|
|
// The GetScrollInfo function retrieves the parameters of a scroll bar, including
|
|||
|
|
// the minimum and maximum scrolling positions, the page size, and the position
|
|||
|
|
// of the scroll box (thumb).
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::GetScrollInfo(m_hWnd, fnBar, &si);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CRect CWnd::GetUpdateRect(BOOL bErase) const
|
|||
|
|
// The GetUpdateRect function retrieves the coordinates of the smallest rectangle that completely
|
|||
|
|
// encloses the update region of the specified window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
CRect rc;
|
|||
|
|
::GetUpdateRect(m_hWnd, &rc, bErase);
|
|||
|
|
return rc;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWnd::GetUpdateRgn(CRgn* pRgn, BOOL bErase) const
|
|||
|
|
// The GetUpdateRgn function retrieves the update region of a window by copying it into the specified region.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
assert(pRgn);
|
|||
|
|
HRGN hRgn = (HRGN)pRgn->GetHandle();
|
|||
|
|
return ::GetUpdateRgn(m_hWnd, hRgn, bErase);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetWindow(UINT uCmd) const
|
|||
|
|
// The GetWindow function retrieves a pointer to a window that has the specified
|
|||
|
|
// relationship (Z-Order or owner) to the specified window.
|
|||
|
|
// Possible uCmd values: GW_CHILD, GW_ENABLEDPOPUP, GW_HWNDFIRST, GW_HWNDLAST,
|
|||
|
|
// GW_HWNDNEXT, GW_HWNDPREV, GW_OWNER
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle( ::GetWindow(m_hWnd, uCmd) );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CDC* CWnd::GetWindowDC() const
|
|||
|
|
// The GetWindowDC function retrieves the device context (DC) for the entire
|
|||
|
|
// window, including title bar, menus, and scroll bars.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return CDC::AddTempHDC(::GetWindowDC(m_hWnd), m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CRect CWnd::GetWindowRect() const
|
|||
|
|
// retrieves the dimensions of the bounding rectangle of the window.
|
|||
|
|
// The dimensions are given in screen coordinates that are relative to the
|
|||
|
|
// upper-left corner of the screen.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
CRect rc;
|
|||
|
|
::GetWindowRect(m_hWnd, &rc);
|
|||
|
|
return rc;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWnd::GetWindowTextLength() const
|
|||
|
|
// The GetWindowTextLength function retrieves the length, in characters, of the specified window's
|
|||
|
|
// title bar text (if the window has a title bar).
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::GetWindowTextLength(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::Invalidate(BOOL bErase /*= TRUE*/) const
|
|||
|
|
// The Invalidate function adds the entire client area the window's update region.
|
|||
|
|
// The update region represents the portion of the window's client area that must be redrawn.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
::InvalidateRect(m_hWnd, NULL, bErase);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::InvalidateRect(LPCRECT lpRect, BOOL bErase /*= TRUE*/) const
|
|||
|
|
// The InvalidateRect function adds a rectangle to the window's update region.
|
|||
|
|
// The update region represents the portion of the window's client area that must be redrawn.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::InvalidateRect(m_hWnd, lpRect, bErase);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::InvalidateRgn(CRgn* pRgn, BOOL bErase /*= TRUE*/) const
|
|||
|
|
// The InvalidateRgn function invalidates the client area within the specified region
|
|||
|
|
// by adding it to the current update region of a window. The invalidated region,
|
|||
|
|
// along with all other areas in the update region, is marked for painting when the
|
|||
|
|
// next WM_PAINT message occurs.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
HRGN hRgn = pRgn? (HRGN)pRgn->GetHandle() : NULL;
|
|||
|
|
return ::InvalidateRgn(m_hWnd, hRgn, bErase);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::IsChild(CWnd* pChild) const
|
|||
|
|
// The IsChild function tests whether a window is a child window or descendant window
|
|||
|
|
// of a parent window's CWnd.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::IsChild(m_hWnd, pChild->GetHwnd());
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::IsDialogMessage(LPMSG lpMsg) const
|
|||
|
|
// The IsDialogMessage function determines whether a message is intended for the specified dialog box and,
|
|||
|
|
// if it is, processes the message.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::IsDialogMessage(m_hWnd, lpMsg);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline UINT CWnd::IsDlgButtonChecked(int nIDButton) const
|
|||
|
|
// The IsDlgButtonChecked function determines whether a button control has a check mark next to it
|
|||
|
|
// or whether a three-state button control is grayed, checked, or neither.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::IsDlgButtonChecked(m_hWnd, nIDButton);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::IsWindowEnabled() const
|
|||
|
|
// The IsWindowEnabled function determines whether the window is enabled
|
|||
|
|
// for mouse and keyboard input.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::IsWindowEnabled(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::IsWindowVisible() const
|
|||
|
|
// The IsWindowVisible function retrieves the visibility state of the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::IsWindowVisible(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::IsWindow() const
|
|||
|
|
// The IsWindow function determines whether the window exists.
|
|||
|
|
{
|
|||
|
|
return ::IsWindow(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::MapWindowPoints(CWnd* pWndTo, POINT& pt) const
|
|||
|
|
// The MapWindowPoints function converts (maps) a set of points from a coordinate space relative to one
|
|||
|
|
// window to a coordinate space relative to another window.
|
|||
|
|
{
|
|||
|
|
assert (m_hWnd);
|
|||
|
|
if(pWndTo)
|
|||
|
|
{
|
|||
|
|
assert (pWndTo->GetHwnd());
|
|||
|
|
::MapWindowPoints(m_hWnd, pWndTo->GetHwnd(), &pt, 1);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
::MapWindowPoints(m_hWnd, NULL, &pt, 1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::MapWindowPoints(CWnd* pWndTo, RECT& rc) const
|
|||
|
|
// The MapWindowPoints function converts (maps) a set of points from a coordinate space relative to one
|
|||
|
|
// window to a coordinate space relative to another window.
|
|||
|
|
{
|
|||
|
|
assert (m_hWnd);
|
|||
|
|
if(pWndTo)
|
|||
|
|
{
|
|||
|
|
assert (pWndTo->GetHwnd());
|
|||
|
|
::MapWindowPoints(m_hWnd, pWndTo->GetHwnd(), (LPPOINT)&rc, 2);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
::MapWindowPoints(m_hWnd, NULL, (LPPOINT)&rc, 2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::MapWindowPoints(CWnd* pWndTo, LPPOINT ptArray, UINT nCount) const
|
|||
|
|
// The MapWindowPoints function converts (maps) a set of points from a coordinate space relative to one
|
|||
|
|
// window to a coordinate space relative to another window.
|
|||
|
|
{
|
|||
|
|
assert (m_hWnd);
|
|||
|
|
if (pWndTo)
|
|||
|
|
{
|
|||
|
|
assert (pWndTo->GetHwnd());
|
|||
|
|
::MapWindowPoints(m_hWnd, pWndTo->GetHwnd(), (LPPOINT)ptArray, nCount);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
::MapWindowPoints(m_hWnd, NULL, (LPPOINT)ptArray, nCount);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWnd::MessageBox(LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) const
|
|||
|
|
// The MessageBox function creates, displays, and operates a message box.
|
|||
|
|
// Possible combinations of uType values include: MB_OK, MB_HELP, MB_OKCANCEL, MB_RETRYCANCEL,
|
|||
|
|
// MB_YESNO, MB_YESNOCANCEL, MB_ICONEXCLAMATION, MB_ICONWARNING, MB_ICONERROR (+ many others).
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::MessageBox(m_hWnd, lpText, lpCaption, uType);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::MoveWindow(int x, int y, int nWidth, int nHeight, BOOL bRepaint /* = TRUE*/) const
|
|||
|
|
// The MoveWindow function changes the position and dimensions of the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::MoveWindow(m_hWnd, x, y, nWidth, nHeight, bRepaint = TRUE);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::MoveWindow(const RECT& rc, BOOL bRepaint /* = TRUE*/) const
|
|||
|
|
// The MoveWindow function changes the position and dimensions of the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::MoveWindow(m_hWnd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, bRepaint);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::PostMessage(UINT uMsg, WPARAM wParam /*= 0L*/, LPARAM lParam /*= 0L*/) const
|
|||
|
|
// The PostMessage function places (posts) a message in the message queue
|
|||
|
|
// associated with the thread that created the window and returns without
|
|||
|
|
// waiting for the thread to process the message.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::PostMessage(m_hWnd, uMsg, wParam, lParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::PostMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) const
|
|||
|
|
// Required by by some macros
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::PostMessage(hWnd, uMsg, wParam, lParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::RedrawWindow(LPCRECT lpRectUpdate, CRgn* pRgn, UINT flags) const
|
|||
|
|
// The RedrawWindow function updates the specified rectangle or region in a window's client area.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
HRGN hRgn = pRgn? (HRGN)pRgn->GetHandle() : NULL;
|
|||
|
|
return ::RedrawWindow(m_hWnd, lpRectUpdate, hRgn, flags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWnd::ReleaseDC(CDC* pDC) const
|
|||
|
|
// The ReleaseDC function releases a device context (DC), freeing it for use
|
|||
|
|
// by other applications.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
assert(pDC);
|
|||
|
|
return ::ReleaseDC(m_hWnd, pDC->GetHDC());
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::ScreenToClient(POINT& Point) const
|
|||
|
|
// The ScreenToClient function converts the screen coordinates of a specified point on the screen to client-area coordinates.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::ScreenToClient(m_hWnd, &Point);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::ScreenToClient(RECT& rc) const
|
|||
|
|
// The ScreenToClient function converts the screen coordinates of a specified RECT on the screen to client-area coordinates.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return (BOOL)::MapWindowPoints(NULL, m_hWnd, (LPPOINT)&rc, 2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::SendDlgItemMessage(int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam) const
|
|||
|
|
// The SendDlgItemMessage function sends a message to the specified control in a dialog box.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SendDlgItemMessage(m_hWnd, nIDDlgItem, Msg, wParam, lParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::SendMessage(UINT uMsg, WPARAM wParam /*= 0L*/, LPARAM lParam /*= 0L*/) const
|
|||
|
|
// The SendMessage function sends the specified message to a window or windows.
|
|||
|
|
// It calls the window procedure for the window and does not return until the
|
|||
|
|
// window procedure has processed the message.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SendMessage(m_hWnd, uMsg, wParam, lParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LRESULT CWnd::SendMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) const
|
|||
|
|
// Required by by some macros
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SendMessage(hWnd, uMsg, wParam, lParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::SendNotifyMessage(UINT Msg, WPARAM wParam, LPARAM lParam) const
|
|||
|
|
// The SendNotifyMessage function sends the specified message to a window or windows. If the window was created by the
|
|||
|
|
// calling thread, SendNotifyMessage calls the window procedure for the window and does not return until the window procedure
|
|||
|
|
// has processed the message. If the window was created by a different thread, SendNotifyMessage passes the message to the
|
|||
|
|
// window procedure and returns immediately; it does not wait for the window procedure to finish processing the message.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SendNotifyMessage(m_hWnd, Msg, wParam, lParam);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::SetActiveWindow() const
|
|||
|
|
// The SetActiveWindow function activates the window, but
|
|||
|
|
// not if the application is in the background.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle( ::SetActiveWindow(m_hWnd) );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::SetCapture() const
|
|||
|
|
// The SetCapture function sets the mouse capture to the window.
|
|||
|
|
// SetCapture captures mouse input either when the mouse is over the capturing
|
|||
|
|
// window, or when the mouse button was pressed while the mouse was over the
|
|||
|
|
// capturing window and the button is still down.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle( ::SetCapture(m_hWnd) );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline ULONG_PTR CWnd::SetClassLongPtr(int nIndex, LONG_PTR dwNewLong) const
|
|||
|
|
// The SetClassLongPtr function replaces the specified value at the specified offset in the
|
|||
|
|
// extra class memory or the WNDCLASSEX structure for the class to which the window belongs.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetClassLongPtr(m_hWnd, nIndex, dwNewLong);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::SetFocus() const
|
|||
|
|
// The SetFocus function sets the keyboard focus to the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle( ::SetFocus(m_hWnd) );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::SetFont(CFont* pFont, BOOL bRedraw /* = TRUE*/) const
|
|||
|
|
// Specifies the font that the window will use when drawing text.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
assert(pFont);
|
|||
|
|
SendMessage(WM_SETFONT, (WPARAM)pFont->GetHandle(), (LPARAM)bRedraw);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline HICON CWnd::SetIcon(HICON hIcon, BOOL bBigIcon) const
|
|||
|
|
// Associates a new large or small icon with a window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return (HICON)SendMessage(WM_SETICON, (WPARAM)bBigIcon, (LPARAM)hIcon);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::SetForegroundWindow() const
|
|||
|
|
// The SetForegroundWindow function puts the thread that created the window into the
|
|||
|
|
// foreground and activates the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetForegroundWindow(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::SetParent(CWnd* pWndParent) const
|
|||
|
|
// The SetParent function changes the parent window of the child window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
if (pWndParent)
|
|||
|
|
{
|
|||
|
|
HWND hParent = pWndParent->GetHwnd();
|
|||
|
|
return FromHandle(::SetParent(m_hWnd, hParent));
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
return FromHandle(::SetParent(m_hWnd, 0));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::SetRedraw(BOOL bRedraw /*= TRUE*/) const
|
|||
|
|
// This function allows changes in that window to be redrawn or prevents changes
|
|||
|
|
// in that window from being redrawn.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return (BOOL)::SendMessage(m_hWnd, WM_SETREDRAW, (WPARAM)bRedraw, 0L);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline LONG_PTR CWnd::SetWindowLongPtr(int nIndex, LONG_PTR dwNewLong) const
|
|||
|
|
// The SetWindowLongPtr function changes an attribute of the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetWindowLongPtr(m_hWnd, nIndex, dwNewLong);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::SetWindowPos(HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT uFlags) const
|
|||
|
|
// The SetWindowPos function changes the size, position, and Z order of a child, pop-up,
|
|||
|
|
// or top-level window. The hWndInsertAfter can be a HWND or one of:
|
|||
|
|
// HWND_BOTTOM, HWND_NOTOPMOST, HWND_TOP, HWND_TOPMOST
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetWindowPos(m_hWnd, hWndInsertAfter, x, y, cx, cy, uFlags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::SetWindowPos(HWND hWndInsertAfter, const RECT& rc, UINT uFlags) const
|
|||
|
|
// The SetWindowPos function changes the size, position, and Z order of a child, pop-up,
|
|||
|
|
// or top-level window. The hWndInsertAfter can be a HWND or one of:
|
|||
|
|
// HWND_BOTTOM, HWND_NOTOPMOST, HWND_TOP, HWND_TOPMOST
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetWindowPos(m_hWnd, hWndInsertAfter, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, uFlags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWnd::SetWindowRgn(CRgn* pRgn, BOOL bRedraw /*= TRUE*/) const
|
|||
|
|
// The SetWindowRgn function sets the window region of the window.
|
|||
|
|
// The window region determines the area within the window where the system permits drawing.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
HRGN hRgn = pRgn? (HRGN)pRgn->GetHandle() : NULL;
|
|||
|
|
int iResult = ::SetWindowRgn(m_hWnd, hRgn, bRedraw);
|
|||
|
|
if (iResult && pRgn)
|
|||
|
|
pRgn->Detach(); // The system owns the region now
|
|||
|
|
return iResult;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::SetDlgItemInt(int nIDDlgItem, UINT uValue, BOOL bSigned) const
|
|||
|
|
// The SetDlgItemInt function sets the text of a control in a dialog box to the string representation of a specified integer value.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetDlgItemInt(m_hWnd, nIDDlgItem, uValue, bSigned);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::SetDlgItemText(int nIDDlgItem, LPCTSTR lpString) const
|
|||
|
|
// The SetDlgItemText function sets the title or text of a control in a dialog box.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetDlgItemText(m_hWnd, nIDDlgItem, lpString);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline UINT_PTR CWnd::SetTimer(UINT_PTR nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc) const
|
|||
|
|
// Creates a timer with the specified time-out value.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetTimer(m_hWnd, nIDEvent, uElapse, lpTimerFunc);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::SetWindowText(LPCTSTR lpString) const
|
|||
|
|
// The SetWindowText function changes the text of the window's title bar (if it has one).
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetWindowText(m_hWnd, lpString);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline HRESULT CWnd::SetWindowTheme(LPCWSTR pszSubAppName, LPCWSTR pszSubIdList) const
|
|||
|
|
// Set the XP Theme for a window.
|
|||
|
|
// Exampes:
|
|||
|
|
// SetWindowTheme(NULL, NULL); // Reverts the window's XP theme back to default
|
|||
|
|
// SetWindowTheme(L" ", L" "); // Disables XP theme for the window
|
|||
|
|
{
|
|||
|
|
HRESULT hr = E_NOTIMPL;
|
|||
|
|
|
|||
|
|
#ifndef _WIN32_WCE
|
|||
|
|
|
|||
|
|
HMODULE hMod = ::LoadLibrary(_T("uxtheme.dll"));
|
|||
|
|
if(hMod)
|
|||
|
|
{
|
|||
|
|
typedef HRESULT (__stdcall *PFNSETWINDOWTHEME)(HWND hWnd, LPCWSTR pszSubAppName, LPCWSTR pszSubIdList);
|
|||
|
|
PFNSETWINDOWTHEME pfn = (PFNSETWINDOWTHEME)GetProcAddress(hMod, "SetWindowTheme");
|
|||
|
|
|
|||
|
|
hr = (*pfn)(m_hWnd, pszSubAppName, pszSubIdList);
|
|||
|
|
|
|||
|
|
::FreeLibrary(hMod);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
return hr;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::ShowWindow(int nCmdShow /*= SW_SHOWNORMAL*/) const
|
|||
|
|
// The ShowWindow function sets the window's show state.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::ShowWindow(m_hWnd, nCmdShow);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::UpdateWindow() const
|
|||
|
|
// The UpdateWindow function updates the client area of the window by sending a
|
|||
|
|
// WM_PAINT message to the window if the window's update region is not empty.
|
|||
|
|
// If the update region is empty, no message is sent.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::UpdateWindow(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::ValidateRect(LPCRECT prc) const
|
|||
|
|
// The ValidateRect function validates the client area within a rectangle by
|
|||
|
|
// removing the rectangle from the update region of the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::ValidateRect(m_hWnd, prc);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::ValidateRgn(CRgn* pRgn) const
|
|||
|
|
// The ValidateRgn function validates the client area within a region by
|
|||
|
|
// removing the region from the current update region of the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
HRGN hRgn = pRgn? (HRGN)pRgn->GetHandle() : NULL;
|
|||
|
|
return ::ValidateRgn(m_hWnd, hRgn);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::WindowFromPoint(POINT pt)
|
|||
|
|
// Retrieves the window that contains the specified point (in screen coodinates).
|
|||
|
|
{
|
|||
|
|
return FromHandle(::WindowFromPoint(pt));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// These functions aren't supported on WinCE
|
|||
|
|
//
|
|||
|
|
#ifndef _WIN32_WCE
|
|||
|
|
inline BOOL CWnd::CloseWindow() const
|
|||
|
|
// The CloseWindow function minimizes (but does not destroy) the window.
|
|||
|
|
// To destroy a window, an application can use the Destroy function.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::CloseWindow(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWnd::DlgDirList(LPTSTR lpPathSpec, int nIDListBox, int nIDStaticPath, UINT uFileType) const
|
|||
|
|
// The DlgDirList function replaces the contents of a list box with the names of the subdirectories and files
|
|||
|
|
// in a specified directory. You can filter the list of names by specifying a set of file attributes.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::DlgDirList(m_hWnd, lpPathSpec, nIDListBox, nIDStaticPath, uFileType);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWnd::DlgDirListComboBox(LPTSTR lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT uFiletype) const
|
|||
|
|
// The DlgDirListComboBox function replaces the contents of a combo box with the names of the subdirectories
|
|||
|
|
// and files in a specified directory. You can filter the list of names by specifying a set of file attributes.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::DlgDirListComboBox(m_hWnd, lpPathSpec, nIDComboBox, nIDStaticPath, uFiletype);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::DlgDirSelectEx(LPTSTR lpString, int nCount, int nIDListBox) const
|
|||
|
|
// The DlgDirSelectEx function retrieves the current selection from a single-selection list box. It assumes that the list box
|
|||
|
|
// has been filled by the DlgDirList function and that the selection is a drive letter, filename, or directory name.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::DlgDirSelectEx(m_hWnd, lpString, nCount, nIDListBox);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::DlgDirSelectComboBoxEx(LPTSTR lpString, int nCount, int nIDComboBox) const
|
|||
|
|
// The DlgDirSelectComboBoxEx function retrieves the current selection from a combo box filled by using the
|
|||
|
|
// DlgDirListComboBox function. The selection is interpreted as a drive letter, a file, or a directory name.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::DlgDirSelectComboBoxEx(m_hWnd, lpString, nCount, nIDComboBox);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
|||
|
|
inline void CWnd::DragAcceptFiles(BOOL fAccept) const
|
|||
|
|
// Registers whether a window accepts dropped files.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
::DragAcceptFiles(m_hWnd, fAccept);
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::DrawAnimatedRects(int idAni, RECT& rcFrom, RECT& rcTo) const
|
|||
|
|
// The DrawAnimatedRects function draws a wire-frame rectangle and animates it to indicate the opening of
|
|||
|
|
// an icon or the minimizing or maximizing of a window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::DrawAnimatedRects(m_hWnd, idAni, &rcFrom, &rcTo);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::DrawCaption(CDC* pDC, RECT& rc, UINT uFlags) const
|
|||
|
|
// The DrawCaption function draws a window caption.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
assert(pDC);
|
|||
|
|
return ::DrawCaption(m_hWnd, pDC->GetHDC(), &rc, uFlags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::EnableScrollBar(UINT uSBflags, UINT uArrows) const
|
|||
|
|
// The EnableScrollBar function enables or disables one or both scroll bar arrows.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::EnableScrollBar(m_hWnd, uSBflags, uArrows);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetLastActivePopup() const
|
|||
|
|
// The GetLastActivePopup function determines which pop-up window owned by the specified window was most recently active.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle( ::GetLastActivePopup(m_hWnd) );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CMenu* CWnd::GetMenu() const
|
|||
|
|
// The GetMenu function retrieves a handle to the menu assigned to the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle(::GetMenu(m_hWnd));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWnd::GetScrollPos(int nBar) const
|
|||
|
|
// The GetScrollPos function retrieves the current position of the scroll box
|
|||
|
|
// (thumb) in the specified scroll bar.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::GetScrollPos(m_hWnd, nBar);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::GetScrollRange(int nBar, int& MinPos, int& MaxPos) const
|
|||
|
|
// The GetScrollRange function retrieves the current minimum and maximum scroll box
|
|||
|
|
// (thumb) positions for the specified scroll bar.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::GetScrollRange(m_hWnd, nBar, &MinPos, &MaxPos );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CMenu* CWnd::GetSystemMenu(BOOL bRevert) const
|
|||
|
|
// The GetSystemMenu function allows the application to access the window menu (also known as the system menu
|
|||
|
|
// or the control menu) for copying and modifying.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle(::GetSystemMenu(m_hWnd, bRevert));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::GetTopWindow() const
|
|||
|
|
// The GetTopWindow function examines the Z order of the child windows associated with the parent window and
|
|||
|
|
// retrieves a handle to the child window at the top of the Z order.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return FromHandle( ::GetTopWindow(m_hWnd) );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::GetWindowPlacement(WINDOWPLACEMENT& wndpl) const
|
|||
|
|
// The GetWindowPlacement function retrieves the show state and the restored,
|
|||
|
|
// minimized, and maximized positions of the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::GetWindowPlacement(m_hWnd, &wndpl);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::HiliteMenuItem(CMenu* pMenu, UINT uItemHilite, UINT uHilite) const
|
|||
|
|
// The HiliteMenuItem function highlights or removes the highlighting from an item in a menu bar.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
assert(pMenu);
|
|||
|
|
return ::HiliteMenuItem(m_hWnd, pMenu->GetHandle(), uItemHilite, uHilite);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::IsIconic() const
|
|||
|
|
// The IsIconic function determines whether the window is minimized (iconic).
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::IsIconic(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::IsZoomed() const
|
|||
|
|
// The IsZoomed function determines whether the window is maximized.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::IsZoomed(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::KillTimer(UINT_PTR uIDEvent) const
|
|||
|
|
// Destroys the specified timer.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::KillTimer(m_hWnd, uIDEvent);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::LockWindowUpdate() const
|
|||
|
|
// Disables drawing in the window. Only one window can be locked at a time.
|
|||
|
|
// Use UnLockWindowUpdate to re-enable drawing in the window
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::LockWindowUpdate(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::OpenIcon() const
|
|||
|
|
// The OpenIcon function restores a minimized (iconic) window to its previous size and position.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::OpenIcon(m_hWnd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline void CWnd::Print(CDC* pDC, DWORD dwFlags) const
|
|||
|
|
// Requests that the window draw itself in the specified device context, most commonly in a printer device context.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
assert(pDC);
|
|||
|
|
SendMessage(m_hWnd, WM_PRINT, (WPARAM)pDC, (LPARAM)dwFlags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::ScrollWindow(int XAmount, int YAmount, LPCRECT lprcScroll, LPCRECT lprcClip) const
|
|||
|
|
// The ScrollWindow function scrolls the contents of the specified window's client area.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::ScrollWindow(m_hWnd, XAmount, YAmount, lprcScroll, lprcClip);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWnd::ScrollWindowEx(int dx, int dy, LPCRECT lprcScroll, LPCRECT lprcClip, CRgn* prgnUpdate, LPRECT lprcUpdate, UINT flags) const
|
|||
|
|
// The ScrollWindow function scrolls the contents of the window's client area.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
HRGN hrgnUpdate = prgnUpdate? (HRGN)prgnUpdate->GetHandle() : NULL;
|
|||
|
|
return ::ScrollWindowEx(m_hWnd, dx, dy, lprcScroll, lprcClip, hrgnUpdate, lprcUpdate, flags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::SetMenu(CMenu* pMenu) const
|
|||
|
|
// The SetMenu function assigns a menu to the specified window.
|
|||
|
|
// A hMenu of NULL removes the menu.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetMenu(m_hWnd, pMenu? pMenu->GetHandle() : NULL);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWnd::SetScrollInfo(int fnBar, const SCROLLINFO& si, BOOL fRedraw) const
|
|||
|
|
// The SetScrollInfo function sets the parameters of a scroll bar, including
|
|||
|
|
// the minimum and maximum scrolling positions, the page size, and the
|
|||
|
|
// position of the scroll box (thumb).
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetScrollInfo(m_hWnd, fnBar, &si, fRedraw);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline int CWnd::SetScrollPos(int nBar, int nPos, BOOL bRedraw) const
|
|||
|
|
// The SetScrollPos function sets the position of the scroll box (thumb) in
|
|||
|
|
// the specified scroll bar.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetScrollPos(m_hWnd, nBar, nPos, bRedraw);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::SetScrollRange(int nBar, int nMinPos, int nMaxPos, BOOL bRedraw) const
|
|||
|
|
// The SetScrollRange function sets the minimum and maximum scroll box positions for the scroll bar.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetScrollRange(m_hWnd, nBar, nMinPos, nMaxPos, bRedraw);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::SetWindowPlacement(const WINDOWPLACEMENT& wndpl) const
|
|||
|
|
// The SetWindowPlacement function sets the show state and the restored, minimized,
|
|||
|
|
// and maximized positions of the window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::SetWindowPlacement(m_hWnd, &wndpl);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::ShowOwnedPopups(BOOL fShow) const
|
|||
|
|
// The ShowOwnedPopups function shows or hides all pop-up windows owned by the specified window.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::ShowOwnedPopups(m_hWnd, fShow);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::ShowScrollBar(int nBar, BOOL bShow) const
|
|||
|
|
// The ShowScrollBar function shows or hides the specified scroll bar.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::ShowScrollBar(m_hWnd, nBar, bShow);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::ShowWindowAsync(int nCmdShow) const
|
|||
|
|
// The ShowWindowAsync function sets the show state of a window created by a different thread.
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::ShowWindowAsync(m_hWnd, nCmdShow);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline BOOL CWnd::UnLockWindowUpdate() const
|
|||
|
|
// Enables drawing in the window. Only one window can be locked at a time.
|
|||
|
|
// Use LockWindowUpdate to disable drawing in the window
|
|||
|
|
{
|
|||
|
|
assert(::IsWindow(m_hWnd));
|
|||
|
|
return ::LockWindowUpdate(0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
inline CWnd* CWnd::WindowFromDC(CDC* pDC) const
|
|||
|
|
// The WindowFromDC function returns a handle to the window associated with the specified display device context (DC).
|
|||
|
|
{
|
|||
|
|
assert(pDC);
|
|||
|
|
return FromHandle( ::WindowFromDC(pDC->GetHDC()) );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
}; // namespace Win32xx
|
|||
|
|
|
|||
|
|
|
|||
|
|
#endif // _WIN32XX_WINCORE_H_
|
|||
|
|
|