1///////////////////////////////////////////////////////////////////////////// 2// Name: wx/msw/private.h 3// Purpose: Private declarations: as this header is only included by 4// wxWidgets itself, it may contain identifiers which don't start 5// with "wx". 6// Author: Julian Smart 7// Modified by: 8// Created: 01/02/97 9// RCS-ID: $Id: private.h 62189 2009-09-28 16:02:08Z JS $ 10// Copyright: (c) Julian Smart 11// Licence: wxWindows licence 12///////////////////////////////////////////////////////////////////////////// 13 14#ifndef _WX_PRIVATE_H_ 15#define _WX_PRIVATE_H_ 16 17#include "wx/msw/wrapwin.h" 18 19#ifdef __WXMICROWIN__ 20 // Extra prototypes and symbols not defined by MicroWindows 21 #include "wx/msw/microwin.h" 22#endif 23 24#include "wx/log.h" 25 26class WXDLLIMPEXP_FWD_CORE wxFont; 27class WXDLLIMPEXP_FWD_CORE wxWindow; 28class WXDLLIMPEXP_FWD_CORE wxWindowBase; 29 30// --------------------------------------------------------------------------- 31// private constants 32// --------------------------------------------------------------------------- 33 34// 260 was taken from windef.h 35#ifndef MAX_PATH 36 #define MAX_PATH 260 37#endif 38 39// --------------------------------------------------------------------------- 40// standard icons from the resources 41// --------------------------------------------------------------------------- 42 43#if wxUSE_GUI 44 45extern WXDLLEXPORT_DATA(HICON) wxSTD_FRAME_ICON; 46extern WXDLLEXPORT_DATA(HICON) wxSTD_MDIPARENTFRAME_ICON; 47extern WXDLLEXPORT_DATA(HICON) wxSTD_MDICHILDFRAME_ICON; 48extern WXDLLEXPORT_DATA(HICON) wxDEFAULT_FRAME_ICON; 49extern WXDLLEXPORT_DATA(HICON) wxDEFAULT_MDIPARENTFRAME_ICON; 50extern WXDLLEXPORT_DATA(HICON) wxDEFAULT_MDICHILDFRAME_ICON; 51extern WXDLLEXPORT_DATA(HFONT) wxSTATUS_LINE_FONT; 52 53#endif // wxUSE_GUI 54 55// --------------------------------------------------------------------------- 56// global data 57// --------------------------------------------------------------------------- 58 59extern WXDLLIMPEXP_DATA_BASE(HINSTANCE) wxhInstance; 60 61// --------------------------------------------------------------------------- 62// define things missing from some compilers' headers 63// --------------------------------------------------------------------------- 64 65#if defined(__WXWINCE__) || (defined(__GNUWIN32__) && !wxUSE_NORLANDER_HEADERS) 66#ifndef ZeroMemory 67 inline void ZeroMemory(void *buf, size_t len) { memset(buf, 0, len); } 68#endif 69#endif // old mingw32 70 71// this defines a CASTWNDPROC macro which casts a pointer to the type of a 72// window proc 73#if defined(STRICT) || defined(__GNUC__) 74 typedef WNDPROC WndProcCast; 75#else 76 typedef FARPROC WndProcCast; 77#endif 78 79 80#define CASTWNDPROC (WndProcCast) 81 82 83 84// --------------------------------------------------------------------------- 85// some stuff for old Windows versions (FIXME: what does it do here??) 86// --------------------------------------------------------------------------- 87 88#if !defined(APIENTRY) // NT defines APIENTRY, 3.x not 89 #define APIENTRY FAR PASCAL 90#endif 91 92#ifdef __WIN32__ 93 #define _EXPORT 94#else 95 #define _EXPORT _export 96#endif 97 98#ifndef __WIN32__ 99 typedef signed short int SHORT; 100#endif 101 102#if !defined(__WIN32__) // 3.x uses FARPROC for dialogs 103#ifndef STRICT 104 #define DLGPROC FARPROC 105#endif 106#endif 107 108/* 109 * Decide what window classes we're going to use 110 * for this combination of CTl3D/FAFA settings 111 */ 112 113#define STATIC_CLASS wxT("STATIC") 114#define STATIC_FLAGS (SS_LEFT|WS_CHILD|WS_VISIBLE) 115#define CHECK_CLASS wxT("BUTTON") 116#define CHECK_FLAGS (BS_AUTOCHECKBOX|WS_TABSTOP|WS_CHILD) 117#define CHECK_IS_FAFA FALSE 118#define RADIO_CLASS wxT("BUTTON") 119#define RADIO_FLAGS (BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE) 120#define RADIO_SIZE 20 121#define RADIO_IS_FAFA FALSE 122#define PURE_WINDOWS 123#define GROUP_CLASS wxT("BUTTON") 124#define GROUP_FLAGS (BS_GROUPBOX|WS_CHILD|WS_VISIBLE) 125 126/* 127#define BITCHECK_FLAGS (FB_BITMAP|FC_BUTTONDRAW|FC_DEFAULT|WS_VISIBLE) 128#define BITRADIO_FLAGS (FC_BUTTONDRAW|FB_BITMAP|FC_RADIO|WS_CHILD|WS_VISIBLE) 129*/ 130 131// --------------------------------------------------------------------------- 132// misc macros 133// --------------------------------------------------------------------------- 134 135#define MEANING_CHARACTER '0' 136#define DEFAULT_ITEM_WIDTH 100 137#define DEFAULT_ITEM_HEIGHT 80 138 139// Scale font to get edit control height 140//#define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) (3*(cy)/2) 141#define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) (cy+8) 142 143// Generic subclass proc, for panel item moving/sizing and intercept 144// EDIT control VK_RETURN messages 145extern LONG APIENTRY _EXPORT 146 wxSubclassedGenericControlProc(WXHWND hWnd, WXUINT message, WXWPARAM wParam, WXLPARAM lParam); 147 148// --------------------------------------------------------------------------- 149// useful macros and functions 150// --------------------------------------------------------------------------- 151 152// a wrapper macro for ZeroMemory() 153#if defined(__WIN32__) && !defined(__WXMICROWIN__) 154#define wxZeroMemory(obj) ::ZeroMemory(&obj, sizeof(obj)) 155#else 156#define wxZeroMemory(obj) memset((void*) & obj, 0, sizeof(obj)) 157#endif 158 159// This one is a macro so that it can be tested with #ifdef, it will be 160// undefined if it cannot be implemented for a given compiler. 161// Vc++, bcc, dmc, ow, mingw, codewarrior (and rsxnt) have _get_osfhandle. 162// Cygwin has get_osfhandle. Others are currently unknown, e.g. Salford, 163// Intel, Visual Age. 164#if defined(__WXWINCE__) 165 #define wxGetOSFHandle(fd) ((HANDLE)fd) 166 #define wxOpenOSFHandle(h, flags) ((int)wxPtrToUInt(h)) 167#elif defined(__CYGWIN__) 168 #define wxGetOSFHandle(fd) ((HANDLE)get_osfhandle(fd)) 169#elif defined(__VISUALC__) \ 170 || defined(__BORLANDC__) \ 171 || defined(__DMC__) \ 172 || defined(__WATCOMC__) \ 173 || defined(__MINGW32__) \ 174 || (defined(__MWERKS__) && defined(__MSL__)) 175 #define wxGetOSFHandle(fd) ((HANDLE)_get_osfhandle(fd)) 176 #define wxOpenOSFHandle(h, flags) (_open_osfhandle(wxPtrToUInt(h), flags)) 177 #define wx_fdopen _fdopen 178#endif 179 180// close the handle in the class dtor 181class AutoHANDLE 182{ 183public: 184 wxEXPLICIT AutoHANDLE(HANDLE handle) : m_handle(handle) { } 185 186 bool IsOk() const { return m_handle != INVALID_HANDLE_VALUE; } 187 operator HANDLE() const { return m_handle; } 188 189 ~AutoHANDLE() { if ( IsOk() ) ::CloseHandle(m_handle); } 190 191protected: 192 HANDLE m_handle; 193}; 194 195// a template to make initializing Windows styructs less painful: it zeroes all 196// the struct fields and also sets cbSize member to the correct value (and so 197// can be only used with structures which have this member...) 198template <class T> 199struct WinStruct : public T 200{ 201 WinStruct() 202 { 203 ::ZeroMemory(this, sizeof(T)); 204 205 // explicit qualification is required here for this to be valid C++ 206 this->cbSize = sizeof(T); 207 } 208}; 209 210 211#if wxUSE_GUI 212 213#include "wx/gdicmn.h" 214#include "wx/colour.h" 215 216// make conversion from wxColour and COLORREF a bit less painful 217inline COLORREF wxColourToRGB(const wxColour& c) 218{ 219 return RGB(c.Red(), c.Green(), c.Blue()); 220} 221 222inline COLORREF wxColourToPalRGB(const wxColour& c) 223{ 224 return PALETTERGB(c.Red(), c.Green(), c.Blue()); 225} 226 227inline wxColour wxRGBToColour(COLORREF rgb) 228{ 229 return wxColour(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb)); 230} 231 232inline void wxRGBToColour(wxColour& c, COLORREF rgb) 233{ 234 c.Set(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb)); 235} 236 237// get the standard colour map for some standard colours - see comment in this 238// function to understand why is it needed and when should it be used 239// 240// it returns a wxCOLORMAP (can't use COLORMAP itself here as comctl32.dll 241// might be not included/available) array of size wxSTD_COLOUR_MAX 242// 243// NB: if you change these colours, update wxBITMAP_STD_COLOURS in the 244// resources as well: it must have the same number of pixels! 245enum wxSTD_COLOUR 246{ 247 wxSTD_COL_BTNTEXT, 248 wxSTD_COL_BTNSHADOW, 249 wxSTD_COL_BTNFACE, 250 wxSTD_COL_BTNHIGHLIGHT, 251 wxSTD_COL_MAX 252}; 253 254struct WXDLLEXPORT wxCOLORMAP 255{ 256 COLORREF from, to; 257}; 258 259// this function is implemented in src/msw/window.cpp 260extern wxCOLORMAP *wxGetStdColourMap(); 261 262// create a wxRect from Windows RECT 263inline wxRect wxRectFromRECT(const RECT& rc) 264{ 265 return wxRect(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top); 266} 267 268// copy Windows RECT to our wxRect 269inline void wxCopyRECTToRect(const RECT& rc, wxRect& rect) 270{ 271 rect = wxRectFromRECT(rc); 272} 273 274// and vice versa 275inline void wxCopyRectToRECT(const wxRect& rect, RECT& rc) 276{ 277 // note that we don't use wxRect::GetRight() as it is one of compared to 278 // wxRectFromRECT() above 279 rc.top = rect.y; 280 rc.left = rect.x; 281 rc.right = rect.x + rect.width; 282 rc.bottom = rect.y + rect.height; 283} 284 285// translations between HIMETRIC units (which OLE likes) and pixels (which are 286// liked by all the others) - implemented in msw/utilsexc.cpp 287extern void HIMETRICToPixel(LONG *x, LONG *y); 288extern void PixelToHIMETRIC(LONG *x, LONG *y); 289 290// Windows convention of the mask is opposed to the wxWidgets one, so we need 291// to invert the mask each time we pass one/get one to/from Windows 292extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w = 0, int h = 0); 293 294// Creates an icon or cursor depending from a bitmap 295// 296// The bitmap must be valid and it should have a mask. If it doesn't, a default 297// mask is created using light grey as the transparent colour. 298extern HICON wxBitmapToHICON(const wxBitmap& bmp); 299 300// Same requirments as above apply and the bitmap must also have the correct 301// size. 302extern 303HCURSOR wxBitmapToHCURSOR(const wxBitmap& bmp, int hotSpotX, int hotSpotY); 304 305// get (x, y) from DWORD - notice that HI/LOWORD can *not* be used because they 306// will fail on system with multiple monitors where the coords may be negative 307// 308// these macros are standard now (Win98) but some older headers don't have them 309#ifndef GET_X_LPARAM 310 #define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp)) 311 #define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp)) 312#endif // GET_X_LPARAM 313 314// get the current state of SHIFT/CTRL keys 315inline bool wxIsShiftDown() 316{ 317// return (::GetKeyState(VK_SHIFT) & 0x100) != 0; 318 // Returns different negative values on WinME and WinNT, 319 // so simply test for negative value. 320 return ::GetKeyState(VK_SHIFT) < 0; 321} 322 323inline bool wxIsCtrlDown() 324{ 325// return (::GetKeyState(VK_CONTROL) & 0x100) != 0; 326 // Returns different negative values on WinME and WinNT, 327 // so simply test for negative value. 328 return ::GetKeyState(VK_CONTROL) < 0; 329} 330 331// wrapper around GetWindowRect() and GetClientRect() APIs doing error checking 332// for Win32 333inline RECT wxGetWindowRect(HWND hwnd) 334{ 335 RECT rect; 336 337 if ( !::GetWindowRect(hwnd, &rect) ) 338 wxLogLastError(_T("GetWindowRect")); 339 340 return rect; 341} 342 343inline RECT wxGetClientRect(HWND hwnd) 344{ 345 RECT rect; 346 347 if ( !::GetClientRect(hwnd, &rect) ) 348 wxLogLastError(_T("GetClientRect")); 349 350 return rect; 351} 352 353// --------------------------------------------------------------------------- 354// small helper classes 355// --------------------------------------------------------------------------- 356 357// create an instance of this class and use it as the HDC for screen, will 358// automatically release the DC going out of scope 359class ScreenHDC 360{ 361public: 362 ScreenHDC() { m_hdc = ::GetDC(NULL); } 363 ~ScreenHDC() { ::ReleaseDC(NULL, m_hdc); } 364 365 operator HDC() const { return m_hdc; } 366 367private: 368 HDC m_hdc; 369 370 DECLARE_NO_COPY_CLASS(ScreenHDC) 371}; 372 373// the same as ScreenHDC but for window DCs 374class WindowHDC 375{ 376public: 377 WindowHDC(HWND hwnd) { m_hdc = ::GetDC(m_hwnd = hwnd); } 378 ~WindowHDC() { ::ReleaseDC(m_hwnd, m_hdc); } 379 380 operator HDC() const { return m_hdc; } 381 382private: 383 HWND m_hwnd; 384 HDC m_hdc; 385 386 DECLARE_NO_COPY_CLASS(WindowHDC) 387}; 388 389// the same as ScreenHDC but for memory DCs: creates the HDC compatible with 390// the given one (screen by default) in ctor and destroys it in dtor 391class MemoryHDC 392{ 393public: 394 MemoryHDC(HDC hdc = 0) { m_hdc = ::CreateCompatibleDC(hdc); } 395 ~MemoryHDC() { ::DeleteDC(m_hdc); } 396 397 operator HDC() const { return m_hdc; } 398 399private: 400 HDC m_hdc; 401 402 DECLARE_NO_COPY_CLASS(MemoryHDC) 403}; 404 405// a class which selects a GDI object into a DC in its ctor and deselects in 406// dtor 407class SelectInHDC 408{ 409private: 410 void DoInit(HGDIOBJ hgdiobj) { m_hgdiobj = ::SelectObject(m_hdc, hgdiobj); } 411 412public: 413 SelectInHDC() : m_hdc(NULL) { } 414 SelectInHDC(HDC hdc, HGDIOBJ hgdiobj) : m_hdc(hdc) { DoInit(hgdiobj); } 415 416 void Init(HDC hdc, HGDIOBJ hgdiobj) 417 { 418 wxASSERT_MSG( !m_hdc, _T("initializing twice?") ); 419 420 m_hdc = hdc; 421 422 DoInit(hgdiobj); 423 } 424 425 ~SelectInHDC() { if ( m_hdc ) ::SelectObject(m_hdc, m_hgdiobj); } 426 427 // return true if the object was successfully selected 428 operator bool() const { return m_hgdiobj != 0; } 429 430private: 431 HDC m_hdc; 432 HGDIOBJ m_hgdiobj; 433 434 DECLARE_NO_COPY_CLASS(SelectInHDC) 435}; 436 437// a class which cleans up any GDI object 438class AutoGDIObject 439{ 440protected: 441 AutoGDIObject() { m_gdiobj = NULL; } 442 AutoGDIObject(HGDIOBJ gdiobj) : m_gdiobj(gdiobj) { } 443 ~AutoGDIObject() { if ( m_gdiobj ) ::DeleteObject(m_gdiobj); } 444 445 void InitGdiobj(HGDIOBJ gdiobj) 446 { 447 wxASSERT_MSG( !m_gdiobj, _T("initializing twice?") ); 448 449 m_gdiobj = gdiobj; 450 } 451 452 HGDIOBJ GetObject() const { return m_gdiobj; } 453 454private: 455 HGDIOBJ m_gdiobj; 456}; 457 458// TODO: all this asks for using a AutoHandler<T, CreateFunc> template... 459 460// a class for temporary brushes 461class AutoHBRUSH : private AutoGDIObject 462{ 463public: 464 AutoHBRUSH(COLORREF col) 465 : AutoGDIObject(::CreateSolidBrush(col)) { } 466 467 operator HBRUSH() const { return (HBRUSH)GetObject(); } 468}; 469 470// a class for temporary fonts 471class AutoHFONT : private AutoGDIObject 472{ 473private: 474public: 475 AutoHFONT() 476 : AutoGDIObject() { } 477 478 AutoHFONT(const LOGFONT& lf) 479 : AutoGDIObject(::CreateFontIndirect(&lf)) { } 480 481 void Init(const LOGFONT& lf) { InitGdiobj(::CreateFontIndirect(&lf)); } 482 483 operator HFONT() const { return (HFONT)GetObject(); } 484}; 485 486// a class for temporary pens 487class AutoHPEN : private AutoGDIObject 488{ 489public: 490 AutoHPEN(COLORREF col) 491 : AutoGDIObject(::CreatePen(PS_SOLID, 0, col)) { } 492 493 operator HPEN() const { return (HPEN)GetObject(); } 494}; 495 496// classes for temporary bitmaps 497class AutoHBITMAP : private AutoGDIObject 498{ 499public: 500 AutoHBITMAP(HBITMAP hbmp) : AutoGDIObject(hbmp) { } 501 502 operator HBITMAP() const { return (HBITMAP)GetObject(); } 503}; 504 505class CompatibleBitmap : public AutoHBITMAP 506{ 507public: 508 CompatibleBitmap(HDC hdc, int w, int h) 509 : AutoHBITMAP(::CreateCompatibleBitmap(hdc, w, h)) 510 { 511 } 512}; 513 514class MonoBitmap : public AutoHBITMAP 515{ 516public: 517 MonoBitmap(int w, int h) 518 : AutoHBITMAP(::CreateBitmap(w, h, 1, 1, 0)) 519 { 520 } 521}; 522 523// class automatically destroys the region object 524class AutoHRGN : private AutoGDIObject 525{ 526public: 527 AutoHRGN(HRGN hrgn) : AutoGDIObject(hrgn) { } 528 529 operator HRGN() const { return (HRGN)GetObject(); } 530}; 531 532// class sets the specified clipping region during its life time 533class HDCClipper 534{ 535public: 536 HDCClipper(HDC hdc, HRGN hrgn) 537 : m_hdc(hdc) 538 { 539 if ( !::SelectClipRgn(hdc, hrgn) ) 540 wxLogLastError(_T("SelectClipRgn")); 541 } 542 543 ~HDCClipper() 544 { 545 ::SelectClipRgn(m_hdc, NULL); 546 } 547 548private: 549 HDC m_hdc; 550 551 DECLARE_NO_COPY_CLASS(HDCClipper) 552}; 553 554// set the given map mode for the life time of this object 555// 556// NB: SetMapMode() is not supported by CE so we also define a helper macro 557// to avoid using it there 558#ifdef __WXWINCE__ 559 #define wxCHANGE_HDC_MAP_MODE(hdc, mm) 560#else // !__WXWINCE__ 561 class HDCMapModeChanger 562 { 563 public: 564 HDCMapModeChanger(HDC hdc, int mm) 565 : m_hdc(hdc) 566 { 567 m_modeOld = ::SetMapMode(hdc, mm); 568 if ( !m_modeOld ) 569 wxLogLastError(_T("SelectClipRgn")); 570 } 571 572 ~HDCMapModeChanger() 573 { 574 if ( m_modeOld ) 575 ::SetMapMode(m_hdc, m_modeOld); 576 } 577 578 private: 579 HDC m_hdc; 580 int m_modeOld; 581 582 DECLARE_NO_COPY_CLASS(HDCMapModeChanger) 583 }; 584 585 #define wxCHANGE_HDC_MAP_MODE(hdc, mm) \ 586 HDCMapModeChanger wxMAKE_UNIQUE_NAME(wxHDCMapModeChanger)(hdc, mm) 587#endif // __WXWINCE__/!__WXWINCE__ 588 589// smart buffeer using GlobalAlloc/GlobalFree() 590class GlobalPtr 591{ 592public: 593 // allocates a block of given size 594 GlobalPtr(size_t size, unsigned flags = GMEM_MOVEABLE) 595 { 596 m_hGlobal = ::GlobalAlloc(flags, size); 597 if ( !m_hGlobal ) 598 wxLogLastError(_T("GlobalAlloc")); 599 } 600 601 ~GlobalPtr() 602 { 603 if ( m_hGlobal && ::GlobalFree(m_hGlobal) ) 604 wxLogLastError(_T("GlobalFree")); 605 } 606 607 // implicit conversion 608 operator HGLOBAL() const { return m_hGlobal; } 609 610private: 611 HGLOBAL m_hGlobal; 612 613 DECLARE_NO_COPY_CLASS(GlobalPtr) 614}; 615 616// when working with global pointers (which is unfortunately still necessary 617// sometimes, e.g. for clipboard) it is important to unlock them exactly as 618// many times as we lock them which just asks for using a "smart lock" class 619class GlobalPtrLock 620{ 621public: 622 GlobalPtrLock(HGLOBAL hGlobal) : m_hGlobal(hGlobal) 623 { 624 m_ptr = GlobalLock(hGlobal); 625 if ( !m_ptr ) 626 wxLogLastError(_T("GlobalLock")); 627 } 628 629 ~GlobalPtrLock() 630 { 631 if ( !GlobalUnlock(m_hGlobal) ) 632 { 633#ifdef __WXDEBUG__ 634 // this might happen simply because the block became unlocked 635 DWORD dwLastError = ::GetLastError(); 636 if ( dwLastError != NO_ERROR ) 637 { 638 wxLogApiError(_T("GlobalUnlock"), dwLastError); 639 } 640#endif // __WXDEBUG__ 641 } 642 } 643 644 operator void *() const { return m_ptr; } 645 646private: 647 HGLOBAL m_hGlobal; 648 void *m_ptr; 649 650 DECLARE_NO_COPY_CLASS(GlobalPtrLock) 651}; 652 653// register the class when it is first needed and unregister it in dtor 654class ClassRegistrar 655{ 656public: 657 // ctor doesn't register the class, call Initialize() for this 658 ClassRegistrar() { m_registered = -1; } 659 660 // return true if the class is already registered 661 bool IsInitialized() const { return m_registered != -1; } 662 663 // return true if the class had been already registered 664 bool IsRegistered() const { return m_registered == 1; } 665 666 // try to register the class if not done yet, return true on success 667 bool Register(const WNDCLASS& wc) 668 { 669 // we should only be called if we hadn't been initialized yet 670 wxASSERT_MSG( m_registered == -1, 671 _T("calling ClassRegistrar::Register() twice?") ); 672 673 m_registered = ::RegisterClass(&wc) ? 1 : 0; 674 if ( !IsRegistered() ) 675 { 676 wxLogLastError(_T("RegisterClassEx()")); 677 } 678 else 679 { 680 m_clsname = wc.lpszClassName; 681 } 682 683 return m_registered == 1; 684 } 685 686 // get the name of the registered class (returns empty string if not 687 // registered) 688 const wxString& GetName() const { return m_clsname; } 689 690 // unregister the class if it had been registered 691 ~ClassRegistrar() 692 { 693 if ( IsRegistered() ) 694 { 695 if ( !::UnregisterClass(m_clsname, wxhInstance) ) 696 { 697 wxLogLastError(_T("UnregisterClass")); 698 } 699 } 700 } 701 702private: 703 // initial value is -1 which means that we hadn't tried registering the 704 // class yet, it becomes true or false (1 or 0) when Initialize() is called 705 int m_registered; 706 707 // the name of the class, only non empty if it had been registered 708 wxString m_clsname; 709}; 710 711// --------------------------------------------------------------------------- 712// macros to make casting between WXFOO and FOO a bit easier: the GetFoo() 713// returns Foo cast to the Windows type for oruselves, while GetFooOf() takes 714// an argument which should be a pointer or reference to the object of the 715// corresponding class (this depends on the macro) 716// --------------------------------------------------------------------------- 717 718#define GetHwnd() ((HWND)GetHWND()) 719#define GetHwndOf(win) ((HWND)((win)->GetHWND())) 720// old name 721#define GetWinHwnd GetHwndOf 722 723#define GetHdc() ((HDC)GetHDC()) 724#define GetHdcOf(dc) ((HDC)(dc).GetHDC()) 725 726#define GetHbitmap() ((HBITMAP)GetHBITMAP()) 727#define GetHbitmapOf(bmp) ((HBITMAP)(bmp).GetHBITMAP()) 728 729#define GetHicon() ((HICON)GetHICON()) 730#define GetHiconOf(icon) ((HICON)(icon).GetHICON()) 731 732#define GetHaccel() ((HACCEL)GetHACCEL()) 733#define GetHaccelOf(table) ((HACCEL)((table).GetHACCEL())) 734 735#define GetHbrush() ((HBRUSH)GetResourceHandle()) 736#define GetHbrushOf(brush) ((HBRUSH)(brush).GetResourceHandle()) 737 738#define GetHmenu() ((HMENU)GetHMenu()) 739#define GetHmenuOf(menu) ((HMENU)menu->GetHMenu()) 740 741#define GetHcursor() ((HCURSOR)GetHCURSOR()) 742#define GetHcursorOf(cursor) ((HCURSOR)(cursor).GetHCURSOR()) 743 744#define GetHfont() ((HFONT)GetHFONT()) 745#define GetHfontOf(font) ((HFONT)(font).GetHFONT()) 746 747#define GetHimagelist() ((HIMAGELIST)GetHIMAGELIST()) 748#define GetHimagelistOf(imgl) ((HIMAGELIST)imgl->GetHIMAGELIST()) 749 750#define GetHpalette() ((HPALETTE)GetHPALETTE()) 751#define GetHpaletteOf(pal) ((HPALETTE)(pal).GetHPALETTE()) 752 753#define GetHpen() ((HPEN)GetResourceHandle()) 754#define GetHpenOf(pen) ((HPEN)(pen).GetResourceHandle()) 755 756#define GetHrgn() ((HRGN)GetHRGN()) 757#define GetHrgnOf(rgn) ((HRGN)(rgn).GetHRGN()) 758 759#endif // wxUSE_GUI 760 761// --------------------------------------------------------------------------- 762// global functions 763// --------------------------------------------------------------------------- 764 765extern "C" 766{ 767 WXDLLIMPEXP_BASE HINSTANCE wxGetInstance(); 768} 769 770WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst); 771 772// return the full path of the given module 773inline wxString wxGetFullModuleName(HMODULE hmod) 774{ 775 wxString fullname; 776 if ( !::GetModuleFileName 777 ( 778 hmod, 779 wxStringBuffer(fullname, MAX_PATH), 780 MAX_PATH 781 ) ) 782 { 783 wxLogLastError(_T("GetModuleFileName")); 784 } 785 786 return fullname; 787} 788 789// return the full path of the program file 790inline wxString wxGetFullModuleName() 791{ 792 return wxGetFullModuleName((HMODULE)wxGetInstance()); 793} 794 795// return the run-time version of the OS in a format similar to 796// WINVER/_WIN32_WINNT compile-time macros: 797// 798// 0x0300 Windows NT 3.51 799// 0x0400 Windows 95, NT4 800// 0x0410 Windows 98 801// 0x0500 Windows ME, 2000 802// 0x0501 Windows XP 803// 0x0502 Windows 2003 804// 0x0600 Longhorn 805// 806// for the other Windows versions 0 is currently returned 807enum wxWinVersion 808{ 809 wxWinVersion_Unknown = 0, 810 811 wxWinVersion_3 = 0x0300, 812 wxWinVersion_NT3 = wxWinVersion_3, 813 814 wxWinVersion_4 = 0x0400, 815 wxWinVersion_95 = wxWinVersion_4, 816 wxWinVersion_NT4 = wxWinVersion_4, 817 wxWinVersion_98 = 0x0410, 818 819 wxWinVersion_5 = 0x0500, 820 wxWinVersion_ME = wxWinVersion_5, 821 wxWinVersion_NT5 = wxWinVersion_5, 822 wxWinVersion_2000 = wxWinVersion_5, 823 wxWinVersion_XP = 0x0501, 824 wxWinVersion_2003 = 0x0502, 825 826 wxWinVersion_6 = 0x0600, 827 wxWinVersion_NT6 = 0x0600 828}; 829 830WXDLLIMPEXP_BASE wxWinVersion wxGetWinVersion(); 831 832#if wxUSE_GUI 833 834// cursor stuff 835extern HCURSOR wxGetCurrentBusyCursor(); // from msw/utils.cpp 836extern const wxCursor *wxGetGlobalCursor(); // from msw/cursor.cpp 837 838WXDLLEXPORT void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font); 839WXDLLEXPORT void wxFillLogFont(LOGFONT *logFont, const wxFont *font); 840WXDLLEXPORT wxFont wxCreateFontFromLogFont(const LOGFONT *logFont); 841WXDLLEXPORT wxFontEncoding wxGetFontEncFromCharSet(int charset); 842 843WXDLLEXPORT void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos); 844WXDLLEXPORT void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos); 845 846// Find maximum size of window/rectangle 847extern WXDLLEXPORT void wxFindMaxSize(WXHWND hwnd, RECT *rect); 848 849// Safely get the window text (i.e. without using fixed size buffer) 850extern WXDLLEXPORT wxString wxGetWindowText(WXHWND hWnd); 851 852// get the window class name 853extern WXDLLEXPORT wxString wxGetWindowClass(WXHWND hWnd); 854 855// get the window id (should be unsigned, hence this is not wxWindowID which 856// is, for mainly historical reasons, signed) 857extern WXDLLEXPORT WXWORD wxGetWindowId(WXHWND hWnd); 858 859// check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are 860// different 861extern WXDLLEXPORT bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc); 862 863// Does this window style specify any border? 864inline bool wxStyleHasBorder(long style) 865{ 866 return (style & (wxSIMPLE_BORDER | wxRAISED_BORDER | 867 wxSUNKEN_BORDER | wxDOUBLE_BORDER)) != 0; 868} 869 870// ---------------------------------------------------------------------------- 871// functions mapping HWND to wxWindow 872// ---------------------------------------------------------------------------- 873 874// this function simply checks whether the given hWnd corresponds to a wxWindow 875// and returns either that window if it does or NULL otherwise 876extern WXDLLEXPORT wxWindow* wxFindWinFromHandle(WXHWND hWnd); 877 878// find the window for HWND which is part of some wxWindow, i.e. unlike 879// wxFindWinFromHandle() above it will also work for "sub controls" of a 880// wxWindow. 881// 882// returns the wxWindow corresponding to the given HWND or NULL. 883extern WXDLLEXPORT wxWindow *wxGetWindowFromHWND(WXHWND hwnd); 884 885// Get the size of an icon 886extern WXDLLEXPORT wxSize wxGetHiconSize(HICON hicon); 887 888// Lines are drawn differently for WinCE and regular WIN32 889WXDLLEXPORT void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2); 890 891// fill the client rect of the given window on the provided dc using this brush 892inline void wxFillRect(HWND hwnd, HDC hdc, HBRUSH hbr) 893{ 894 RECT rc; 895 ::GetClientRect(hwnd, &rc); 896 ::FillRect(hdc, &rc, hbr); 897} 898 899// ---------------------------------------------------------------------------- 900// 32/64 bit helpers 901// ---------------------------------------------------------------------------- 902 903#ifdef __WIN64__ 904 905inline void *wxGetWindowProc(HWND hwnd) 906{ 907 return (void *)::GetWindowLongPtr(hwnd, GWLP_WNDPROC); 908} 909 910inline void *wxGetWindowUserData(HWND hwnd) 911{ 912 return (void *)::GetWindowLongPtr(hwnd, GWLP_USERDATA); 913} 914 915inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func) 916{ 917 return (WNDPROC)::SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)func); 918} 919 920inline void *wxSetWindowUserData(HWND hwnd, void *data) 921{ 922 return (void *)::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)data); 923} 924 925#else // __WIN32__ 926 927// note that the casts to LONG_PTR here are required even on 32-bit machines 928// for the 64-bit warning mode of later versions of MSVC (C4311/4312) 929inline WNDPROC wxGetWindowProc(HWND hwnd) 930{ 931 return (WNDPROC)(LONG_PTR)::GetWindowLong(hwnd, GWL_WNDPROC); 932} 933 934inline void *wxGetWindowUserData(HWND hwnd) 935{ 936 return (void *)(LONG_PTR)::GetWindowLong(hwnd, GWL_USERDATA); 937} 938 939inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func) 940{ 941 return (WNDPROC)(LONG_PTR)::SetWindowLong(hwnd, GWL_WNDPROC, (LONG_PTR)func); 942} 943 944inline void *wxSetWindowUserData(HWND hwnd, void *data) 945{ 946 return (void *)(LONG_PTR)::SetWindowLong(hwnd, GWL_USERDATA, (LONG_PTR)data); 947} 948 949#endif // __WIN64__/__WIN32__ 950 951#endif // wxUSE_GUI 952 953#endif // _WX_PRIVATE_H_ 954