include/wx/msw/private.h

   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$
  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
  26 class WXDLLIMPEXP_FWD_CORE wxFont;
  27 class WXDLLIMPEXP_FWD_CORE wxWindow;
  28 class 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
  45 extern WXDLLEXPORT_DATA(HICON) wxSTD_FRAME_ICON;
  46 extern WXDLLEXPORT_DATA(HICON) wxSTD_MDIPARENTFRAME_ICON;
  47 extern WXDLLEXPORT_DATA(HICON) wxSTD_MDICHILDFRAME_ICON;
  48 extern WXDLLEXPORT_DATA(HICON) wxDEFAULT_FRAME_ICON;
  49 extern WXDLLEXPORT_DATA(HICON) wxDEFAULT_MDIPARENTFRAME_ICON;
  50 extern WXDLLEXPORT_DATA(HICON) wxDEFAULT_MDICHILDFRAME_ICON;
  51 extern WXDLLEXPORT_DATA(HFONT) wxSTATUS_LINE_FONT;
  52
  53 #endif // wxUSE_GUI
  54
  55 // ---------------------------------------------------------------------------
  56 // global data
  57 // ---------------------------------------------------------------------------
  58
  59 extern 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
 145 extern 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
 181 class AutoHANDLE
 182 {
 183 public:
 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
 191 protected:
 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...)
 198 template <class T>
 199 struct 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
 217 inline COLORREF wxColourToRGB(const wxColour& c)
 218 {
 219     return RGB(c.Red(), c.Green(), c.Blue());
 220 }
 221
 222 inline COLORREF wxColourToPalRGB(const wxColour& c)
 223 {
 224     return PALETTERGB(c.Red(), c.Green(), c.Blue());
 225 }
 226
 227 inline wxColour wxRGBToColour(COLORREF rgb)
 228 {
 229     return wxColour(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb));
 230 }
 231
 232 inline 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!
 245 enum 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
 254 struct WXDLLEXPORT wxCOLORMAP
 255 {
 256     COLORREF from, to;
 257 };
 258
 259 // this function is implemented in src/msw/window.cpp
 260 extern wxCOLORMAP *wxGetStdColourMap();
 261
 262 // create a wxRect from Windows RECT
 263 inline 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
 269 inline void wxCopyRECTToRect(const RECT& rc, wxRect& rect)
 270 {
 271     rect = wxRectFromRECT(rc);
 272 }
 273
 274 // and vice versa
 275 inline 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
 287 extern void HIMETRICToPixel(LONG *x, LONG *y);
 288 extern 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
 292 extern 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.
 298 extern HICON wxBitmapToHICON(const wxBitmap& bmp);
 299
 300 // Same requirments as above apply and the bitmap must also have the correct
 301 // size.
 302 extern
 303 HCURSOR 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/ALT keys
 315 inline bool wxIsModifierDown(int vk)
 316 {
 317     // GetKeyState() returns different negative values on WinME and WinNT,
 318     // so simply test for negative value.
 319     return ::GetKeyState(vk) < 0;
 320 }
 321
 322 inline bool wxIsShiftDown()
 323 {
 324     return wxIsModifierDown(VK_SHIFT);
 325 }
 326
 327 inline bool wxIsCtrlDown()
 328 {
 329     return wxIsModifierDown(VK_CONTROL);
 330 }
 331
 332 inline bool wxIsAltDown()
 333 {
 334     return wxIsModifierDown(VK_MENU);
 335 }
 336
 337 inline bool wxIsAnyModifierDown()
 338 {
 339     return wxIsShiftDown() || wxIsCtrlDown() || wxIsAltDown();
 340 }
 341
 342 // wrapper around GetWindowRect() and GetClientRect() APIs doing error checking
 343 // for Win32
 344 inline RECT wxGetWindowRect(HWND hwnd)
 345 {
 346     RECT rect;
 347
 348     if ( !::GetWindowRect(hwnd, &rect) )
 349         wxLogLastError(_T("GetWindowRect"));
 350
 351     return rect;
 352 }
 353
 354 inline RECT wxGetClientRect(HWND hwnd)
 355 {
 356     RECT rect;
 357
 358     if ( !::GetClientRect(hwnd, &rect) )
 359         wxLogLastError(_T("GetClientRect"));
 360
 361     return rect;
 362 }
 363
 364 // ---------------------------------------------------------------------------
 365 // small helper classes
 366 // ---------------------------------------------------------------------------
 367
 368 // create an instance of this class and use it as the HDC for screen, will
 369 // automatically release the DC going out of scope
 370 class ScreenHDC
 371 {
 372 public:
 373     ScreenHDC() { m_hdc = ::GetDC(NULL);    }
 374    ~ScreenHDC() { ::ReleaseDC(NULL, m_hdc); }
 375
 376     operator HDC() const { return m_hdc; }
 377
 378 private:
 379     HDC m_hdc;
 380
 381     DECLARE_NO_COPY_CLASS(ScreenHDC)
 382 };
 383
 384 // the same as ScreenHDC but for window DCs
 385 class WindowHDC
 386 {
 387 public:
 388     WindowHDC(HWND hwnd) { m_hdc = ::GetDC(m_hwnd = hwnd); }
 389    ~WindowHDC() { ::ReleaseDC(m_hwnd, m_hdc); }
 390
 391     operator HDC() const { return m_hdc; }
 392
 393 private:
 394    HWND m_hwnd;
 395    HDC m_hdc;
 396
 397    DECLARE_NO_COPY_CLASS(WindowHDC)
 398 };
 399
 400 // the same as ScreenHDC but for memory DCs: creates the HDC compatible with
 401 // the given one (screen by default) in ctor and destroys it in dtor
 402 class MemoryHDC
 403 {
 404 public:
 405     MemoryHDC(HDC hdc = 0) { m_hdc = ::CreateCompatibleDC(hdc); }
 406    ~MemoryHDC() { ::DeleteDC(m_hdc); }
 407
 408     operator HDC() const { return m_hdc; }
 409
 410 private:
 411     HDC m_hdc;
 412
 413     DECLARE_NO_COPY_CLASS(MemoryHDC)
 414 };
 415
 416 // a class which selects a GDI object into a DC in its ctor and deselects in
 417 // dtor
 418 class SelectInHDC
 419 {
 420 private:
 421     void DoInit(HGDIOBJ hgdiobj) { m_hgdiobj = ::SelectObject(m_hdc, hgdiobj); }
 422
 423 public:
 424     SelectInHDC() : m_hdc(NULL) { }
 425     SelectInHDC(HDC hdc, HGDIOBJ hgdiobj) : m_hdc(hdc) { DoInit(hgdiobj); }
 426
 427     void Init(HDC hdc, HGDIOBJ hgdiobj)
 428     {
 429         wxASSERT_MSG( !m_hdc, _T("initializing twice?") );
 430
 431         m_hdc = hdc;
 432
 433         DoInit(hgdiobj);
 434     }
 435
 436     ~SelectInHDC() { if ( m_hdc ) ::SelectObject(m_hdc, m_hgdiobj); }
 437
 438     // return true if the object was successfully selected
 439     operator bool() const { return m_hgdiobj != 0; }
 440
 441 private:
 442     HDC m_hdc;
 443     HGDIOBJ m_hgdiobj;
 444
 445     DECLARE_NO_COPY_CLASS(SelectInHDC)
 446 };
 447
 448 // a class which cleans up any GDI object
 449 class AutoGDIObject
 450 {
 451 protected:
 452     AutoGDIObject() { m_gdiobj = NULL; }
 453     AutoGDIObject(HGDIOBJ gdiobj) : m_gdiobj(gdiobj) { }
 454     ~AutoGDIObject() { if ( m_gdiobj ) ::DeleteObject(m_gdiobj); }
 455
 456     void InitGdiobj(HGDIOBJ gdiobj)
 457     {
 458         wxASSERT_MSG( !m_gdiobj, _T("initializing twice?") );
 459
 460         m_gdiobj = gdiobj;
 461     }
 462
 463     HGDIOBJ GetObject() const { return m_gdiobj; }
 464
 465 private:
 466     HGDIOBJ m_gdiobj;
 467 };
 468
 469 // TODO: all this asks for using a AutoHandler<T, CreateFunc> template...
 470
 471 // a class for temporary brushes
 472 class AutoHBRUSH : private AutoGDIObject
 473 {
 474 public:
 475     AutoHBRUSH(COLORREF col)
 476         : AutoGDIObject(::CreateSolidBrush(col)) { }
 477
 478     operator HBRUSH() const { return (HBRUSH)GetObject(); }
 479 };
 480
 481 // a class for temporary fonts
 482 class AutoHFONT : private AutoGDIObject
 483 {
 484 private:
 485 public:
 486     AutoHFONT()
 487         : AutoGDIObject() { }
 488
 489     AutoHFONT(const LOGFONT& lf)
 490         : AutoGDIObject(::CreateFontIndirect(&lf)) { }
 491
 492     void Init(const LOGFONT& lf) { InitGdiobj(::CreateFontIndirect(&lf)); }
 493
 494     operator HFONT() const { return (HFONT)GetObject(); }
 495 };
 496
 497 // a class for temporary pens
 498 class AutoHPEN : private AutoGDIObject
 499 {
 500 public:
 501     AutoHPEN(COLORREF col)
 502         : AutoGDIObject(::CreatePen(PS_SOLID, 0, col)) { }
 503
 504     operator HPEN() const { return (HPEN)GetObject(); }
 505 };
 506
 507 // classes for temporary bitmaps
 508 class AutoHBITMAP : private AutoGDIObject
 509 {
 510 public:
 511     AutoHBITMAP(HBITMAP hbmp) : AutoGDIObject(hbmp) { }
 512
 513     operator HBITMAP() const { return (HBITMAP)GetObject(); }
 514 };
 515
 516 class CompatibleBitmap : public AutoHBITMAP
 517 {
 518 public:
 519     CompatibleBitmap(HDC hdc, int w, int h)
 520         : AutoHBITMAP(::CreateCompatibleBitmap(hdc, w, h))
 521     {
 522     }
 523 };
 524
 525 class MonoBitmap : public AutoHBITMAP
 526 {
 527 public:
 528     MonoBitmap(int w, int h)
 529         : AutoHBITMAP(::CreateBitmap(w, h, 1, 1, 0))
 530     {
 531     }
 532 };
 533
 534 // class automatically destroys the region object
 535 class AutoHRGN : private AutoGDIObject
 536 {
 537 public:
 538     AutoHRGN(HRGN hrgn) : AutoGDIObject(hrgn) { }
 539
 540     operator HRGN() const { return (HRGN)GetObject(); }
 541 };
 542
 543 // class sets the specified clipping region during its life time
 544 class HDCClipper
 545 {
 546 public:
 547     HDCClipper(HDC hdc, HRGN hrgn)
 548         : m_hdc(hdc)
 549     {
 550         if ( !::SelectClipRgn(hdc, hrgn) )
 551             wxLogLastError(_T("SelectClipRgn"));
 552     }
 553
 554     ~HDCClipper()
 555     {
 556         ::SelectClipRgn(m_hdc, NULL);
 557     }
 558
 559 private:
 560     HDC m_hdc;
 561
 562     DECLARE_NO_COPY_CLASS(HDCClipper)
 563 };
 564
 565 // set the given map mode for the life time of this object
 566 //
 567 // NB: SetMapMode() is not supported by CE so we also define a helper macro
 568 //     to avoid using it there
 569 #ifdef __WXWINCE__
 570     #define wxCHANGE_HDC_MAP_MODE(hdc, mm)
 571 #else // !__WXWINCE__
 572     class HDCMapModeChanger
 573     {
 574     public:
 575         HDCMapModeChanger(HDC hdc, int mm)
 576             : m_hdc(hdc)
 577         {
 578             m_modeOld = ::SetMapMode(hdc, mm);
 579             if ( !m_modeOld )
 580                 wxLogLastError(_T("SelectClipRgn"));
 581         }
 582
 583         ~HDCMapModeChanger()
 584         {
 585             if ( m_modeOld )
 586                 ::SetMapMode(m_hdc, m_modeOld);
 587         }
 588
 589     private:
 590         HDC m_hdc;
 591         int m_modeOld;
 592
 593         DECLARE_NO_COPY_CLASS(HDCMapModeChanger)
 594     };
 595
 596     #define wxCHANGE_HDC_MAP_MODE(hdc, mm) \
 597         HDCMapModeChanger wxMAKE_UNIQUE_NAME(wxHDCMapModeChanger)(hdc, mm)
 598 #endif // __WXWINCE__/!__WXWINCE__
 599
 600 // smart buffeer using GlobalAlloc/GlobalFree()
 601 class GlobalPtr
 602 {
 603 public:
 604     // allocates a block of given size
 605     GlobalPtr(size_t size, unsigned flags = GMEM_MOVEABLE)
 606     {
 607         m_hGlobal = ::GlobalAlloc(flags, size);
 608         if ( !m_hGlobal )
 609             wxLogLastError(_T("GlobalAlloc"));
 610     }
 611
 612     ~GlobalPtr()
 613     {
 614         if ( m_hGlobal && ::GlobalFree(m_hGlobal) )
 615             wxLogLastError(_T("GlobalFree"));
 616     }
 617
 618     // implicit conversion
 619     operator HGLOBAL() const { return m_hGlobal; }
 620
 621 private:
 622     HGLOBAL m_hGlobal;
 623
 624     DECLARE_NO_COPY_CLASS(GlobalPtr)
 625 };
 626
 627 // when working with global pointers (which is unfortunately still necessary
 628 // sometimes, e.g. for clipboard) it is important to unlock them exactly as
 629 // many times as we lock them which just asks for using a "smart lock" class
 630 class GlobalPtrLock
 631 {
 632 public:
 633     GlobalPtrLock(HGLOBAL hGlobal) : m_hGlobal(hGlobal)
 634     {
 635         m_ptr = GlobalLock(hGlobal);
 636         if ( !m_ptr )
 637             wxLogLastError(_T("GlobalLock"));
 638     }
 639
 640     ~GlobalPtrLock()
 641     {
 642         if ( !GlobalUnlock(m_hGlobal) )
 643         {
 644 #ifdef __WXDEBUG__
 645             // this might happen simply because the block became unlocked
 646             DWORD dwLastError = ::GetLastError();
 647             if ( dwLastError != NO_ERROR )
 648             {
 649                 wxLogApiError(_T("GlobalUnlock"), dwLastError);
 650             }
 651 #endif // __WXDEBUG__
 652         }
 653     }
 654
 655     operator void *() const { return m_ptr; }
 656
 657 private:
 658     HGLOBAL m_hGlobal;
 659     void *m_ptr;
 660
 661     DECLARE_NO_COPY_CLASS(GlobalPtrLock)
 662 };
 663
 664 // register the class when it is first needed and unregister it in dtor
 665 class ClassRegistrar
 666 {
 667 public:
 668     // ctor doesn't register the class, call Initialize() for this
 669     ClassRegistrar() { m_registered = -1; }
 670
 671     // return true if the class is already registered
 672     bool IsInitialized() const { return m_registered != -1; }
 673
 674     // return true if the class had been already registered
 675     bool IsRegistered() const { return m_registered == 1; }
 676
 677     // try to register the class if not done yet, return true on success
 678     bool Register(const WNDCLASS& wc)
 679     {
 680         // we should only be called if we hadn't been initialized yet
 681         wxASSERT_MSG( m_registered == -1,
 682                         _T("calling ClassRegistrar::Register() twice?") );
 683
 684         m_registered = ::RegisterClass(&wc) ? 1 : 0;
 685         if ( !IsRegistered() )
 686         {
 687             wxLogLastError(_T("RegisterClassEx()"));
 688         }
 689         else
 690         {
 691             m_clsname = wc.lpszClassName;
 692         }
 693
 694         return m_registered == 1;
 695     }
 696
 697     // get the name of the registered class (returns empty string if not
 698     // registered)
 699     const wxString& GetName() const { return m_clsname; }
 700
 701     // unregister the class if it had been registered
 702     ~ClassRegistrar()
 703     {
 704         if ( IsRegistered() )
 705         {
 706             if ( !::UnregisterClass(m_clsname.wx_str(), wxhInstance) )
 707             {
 708                 wxLogLastError(_T("UnregisterClass"));
 709             }
 710         }
 711     }
 712
 713 private:
 714     // initial value is -1 which means that we hadn't tried registering the
 715     // class yet, it becomes true or false (1 or 0) when Initialize() is called
 716     int m_registered;
 717
 718     // the name of the class, only non empty if it had been registered
 719     wxString m_clsname;
 720 };
 721
 722 // ---------------------------------------------------------------------------
 723 // macros to make casting between WXFOO and FOO a bit easier: the GetFoo()
 724 // returns Foo cast to the Windows type for oruselves, while GetFooOf() takes
 725 // an argument which should be a pointer or reference to the object of the
 726 // corresponding class (this depends on the macro)
 727 // ---------------------------------------------------------------------------
 728
 729 #define GetHwnd()               ((HWND)GetHWND())
 730 #define GetHwndOf(win)          ((HWND)((win)->GetHWND()))
 731 // old name
 732 #define GetWinHwnd              GetHwndOf
 733
 734 #define GetHdc()                ((HDC)GetHDC())
 735 #define GetHdcOf(dc)            ((HDC)(dc).GetHDC())
 736
 737 #define GetHbitmap()            ((HBITMAP)GetHBITMAP())
 738 #define GetHbitmapOf(bmp)       ((HBITMAP)(bmp).GetHBITMAP())
 739
 740 #define GetHicon()              ((HICON)GetHICON())
 741 #define GetHiconOf(icon)        ((HICON)(icon).GetHICON())
 742
 743 #define GetHaccel()             ((HACCEL)GetHACCEL())
 744 #define GetHaccelOf(table)      ((HACCEL)((table).GetHACCEL()))
 745
 746 #define GetHbrush()             ((HBRUSH)GetResourceHandle())
 747 #define GetHbrushOf(brush)      ((HBRUSH)(brush).GetResourceHandle())
 748
 749 #define GetHmenu()              ((HMENU)GetHMenu())
 750 #define GetHmenuOf(menu)        ((HMENU)menu->GetHMenu())
 751
 752 #define GetHcursor()            ((HCURSOR)GetHCURSOR())
 753 #define GetHcursorOf(cursor)    ((HCURSOR)(cursor).GetHCURSOR())
 754
 755 #define GetHfont()              ((HFONT)GetHFONT())
 756 #define GetHfontOf(font)        ((HFONT)(font).GetHFONT())
 757
 758 #define GetHimagelist()         ((HIMAGELIST)GetHIMAGELIST())
 759 #define GetHimagelistOf(imgl)   ((HIMAGELIST)imgl->GetHIMAGELIST())
 760
 761 #define GetHpalette()           ((HPALETTE)GetHPALETTE())
 762 #define GetHpaletteOf(pal)      ((HPALETTE)(pal).GetHPALETTE())
 763
 764 #define GetHpen()               ((HPEN)GetResourceHandle())
 765 #define GetHpenOf(pen)          ((HPEN)(pen).GetResourceHandle())
 766
 767 #define GetHrgn()               ((HRGN)GetHRGN())
 768 #define GetHrgnOf(rgn)          ((HRGN)(rgn).GetHRGN())
 769
 770 #endif // wxUSE_GUI
 771
 772 // ---------------------------------------------------------------------------
 773 // global functions
 774 // ---------------------------------------------------------------------------
 775
 776 extern "C"
 777 {
 778     WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
 779 }
 780
 781 WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
 782
 783 // return the full path of the given module
 784 inline wxString wxGetFullModuleName(HMODULE hmod)
 785 {
 786     wxString fullname;
 787     if ( !::GetModuleFileName
 788             (
 789                 hmod,
 790                 wxStringBuffer(fullname, MAX_PATH),
 791                 MAX_PATH
 792             ) )
 793     {
 794         wxLogLastError(_T("GetModuleFileName"));
 795     }
 796
 797     return fullname;
 798 }
 799
 800 // return the full path of the program file
 801 inline wxString wxGetFullModuleName()
 802 {
 803     return wxGetFullModuleName((HMODULE)wxGetInstance());
 804 }
 805
 806 // return the run-time version of the OS in a format similar to
 807 // WINVER/_WIN32_WINNT compile-time macros:
 808 //
 809 //      0x0300      Windows NT 3.51
 810 //      0x0400      Windows 95, NT4
 811 //      0x0410      Windows 98
 812 //      0x0500      Windows ME, 2000
 813 //      0x0501      Windows XP
 814 //      0x0502      Windows 2003
 815 //      0x0600      Longhorn
 816 //
 817 // for the other Windows versions 0 is currently returned
 818 enum wxWinVersion
 819 {
 820     wxWinVersion_Unknown = 0,
 821
 822     wxWinVersion_3 = 0x0300,
 823     wxWinVersion_NT3 = wxWinVersion_3,
 824
 825     wxWinVersion_4 = 0x0400,
 826     wxWinVersion_95 = wxWinVersion_4,
 827     wxWinVersion_NT4 = wxWinVersion_4,
 828     wxWinVersion_98 = 0x0410,
 829
 830     wxWinVersion_5 = 0x0500,
 831     wxWinVersion_ME = wxWinVersion_5,
 832     wxWinVersion_NT5 = wxWinVersion_5,
 833     wxWinVersion_2000 = wxWinVersion_5,
 834     wxWinVersion_XP = 0x0501,
 835     wxWinVersion_2003 = 0x0502,
 836
 837     wxWinVersion_6 = 0x0600,
 838     wxWinVersion_Vista = wxWinVersion_6,
 839     wxWinVersion_NT6 = wxWinVersion_6
 840 };
 841
 842 WXDLLIMPEXP_BASE wxWinVersion wxGetWinVersion();
 843
 844 #if wxUSE_GUI
 845
 846 // cursor stuff
 847 extern HCURSOR wxGetCurrentBusyCursor();    // from msw/utils.cpp
 848 extern const wxCursor *wxGetGlobalCursor(); // from msw/cursor.cpp
 849
 850 WXDLLEXPORT void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font);
 851 WXDLLEXPORT void wxFillLogFont(LOGFONT *logFont, const wxFont *font);
 852 WXDLLEXPORT wxFont wxCreateFontFromLogFont(const LOGFONT *logFont);
 853 WXDLLEXPORT wxFontEncoding wxGetFontEncFromCharSet(int charset);
 854
 855 WXDLLEXPORT void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos);
 856 WXDLLEXPORT void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos);
 857
 858 // Find maximum size of window/rectangle
 859 extern WXDLLEXPORT void wxFindMaxSize(WXHWND hwnd, RECT *rect);
 860
 861 // Safely get the window text (i.e. without using fixed size buffer)
 862 extern WXDLLEXPORT wxString wxGetWindowText(WXHWND hWnd);
 863
 864 // get the window class name
 865 extern WXDLLEXPORT wxString wxGetWindowClass(WXHWND hWnd);
 866
 867 // get the window id (should be unsigned, hence this is not wxWindowID which
 868 // is, for mainly historical reasons, signed)
 869 extern WXDLLEXPORT WXWORD wxGetWindowId(WXHWND hWnd);
 870
 871 // check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
 872 // different
 873 extern WXDLLEXPORT bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc);
 874
 875 // Does this window style specify any border?
 876 inline bool wxStyleHasBorder(long style)
 877 {
 878     return (style & (wxSIMPLE_BORDER | wxRAISED_BORDER |
 879                      wxSUNKEN_BORDER | wxDOUBLE_BORDER)) != 0;
 880 }
 881
 882 // ----------------------------------------------------------------------------
 883 // functions mapping HWND to wxWindow
 884 // ----------------------------------------------------------------------------
 885
 886 // this function simply checks whether the given hWnd corresponds to a wxWindow
 887 // and returns either that window if it does or NULL otherwise
 888 extern WXDLLEXPORT wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 889
 890 // find the window for HWND which is part of some wxWindow, i.e. unlike
 891 // wxFindWinFromHandle() above it will also work for "sub controls" of a
 892 // wxWindow.
 893 //
 894 // returns the wxWindow corresponding to the given HWND or NULL.
 895 extern WXDLLEXPORT wxWindow *wxGetWindowFromHWND(WXHWND hwnd);
 896
 897 // Get the size of an icon
 898 extern WXDLLEXPORT wxSize wxGetHiconSize(HICON hicon);
 899
 900 // Lines are drawn differently for WinCE and regular WIN32
 901 WXDLLEXPORT void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2);
 902
 903 // fill the client rect of the given window on the provided dc using this brush
 904 inline void wxFillRect(HWND hwnd, HDC hdc, HBRUSH hbr)
 905 {
 906     RECT rc;
 907     ::GetClientRect(hwnd, &rc);
 908     ::FillRect(hdc, &rc, hbr);
 909 }
 910
 911 // ----------------------------------------------------------------------------
 912 // 32/64 bit helpers
 913 // ----------------------------------------------------------------------------
 914
 915 #ifdef __WIN64__
 916
 917 inline void *wxGetWindowProc(HWND hwnd)
 918 {
 919     return (void *)::GetWindowLongPtr(hwnd, GWLP_WNDPROC);
 920 }
 921
 922 inline void *wxGetWindowUserData(HWND hwnd)
 923 {
 924     return (void *)::GetWindowLongPtr(hwnd, GWLP_USERDATA);
 925 }
 926
 927 inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
 928 {
 929     return (WNDPROC)::SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)func);
 930 }
 931
 932 inline void *wxSetWindowUserData(HWND hwnd, void *data)
 933 {
 934     return (void *)::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)data);
 935 }
 936
 937 #else // __WIN32__
 938
 939 // note that the casts to LONG_PTR here are required even on 32-bit machines
 940 // for the 64-bit warning mode of later versions of MSVC (C4311/4312)
 941 inline WNDPROC wxGetWindowProc(HWND hwnd)
 942 {
 943     return (WNDPROC)(LONG_PTR)::GetWindowLong(hwnd, GWL_WNDPROC);
 944 }
 945
 946 inline void *wxGetWindowUserData(HWND hwnd)
 947 {
 948     return (void *)(LONG_PTR)::GetWindowLong(hwnd, GWL_USERDATA);
 949 }
 950
 951 inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
 952 {
 953     return (WNDPROC)(LONG_PTR)::SetWindowLong(hwnd, GWL_WNDPROC, (LONG_PTR)func);
 954 }
 955
 956 inline void *wxSetWindowUserData(HWND hwnd, void *data)
 957 {
 958     return (void *)(LONG_PTR)::SetWindowLong(hwnd, GWL_USERDATA, (LONG_PTR)data);
 959 }
 960
 961 #endif // __WIN64__/__WIN32__
 962
 963 #endif // wxUSE_GUI
 964
 965 #endif // _WX_PRIVATE_H_