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