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 keys
 315 inline 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
 323 inline 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
 333 inline RECT wxGetWindowRect(HWND hwnd)
 334 {
 335     RECT rect;
 336
 337     if ( !::GetWindowRect(hwnd, &rect) )
 338         wxLogLastError(_T("GetWindowRect"));
 339
 340     return rect;
 341 }
 342
 343 inline 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
 359 class ScreenHDC
 360 {
 361 public:
 362     ScreenHDC() { m_hdc = ::GetDC(NULL);    }
 363    ~ScreenHDC() { ::ReleaseDC(NULL, m_hdc); }
 364
 365     operator HDC() const { return m_hdc; }
 366
 367 private:
 368     HDC m_hdc;
 369
 370     DECLARE_NO_COPY_CLASS(ScreenHDC)
 371 };
 372
 373 // the same as ScreenHDC but for window DCs
 374 class WindowHDC
 375 {
 376 public:
 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
 382 private:
 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
 391 class MemoryHDC
 392 {
 393 public:
 394     MemoryHDC(HDC hdc = 0) { m_hdc = ::CreateCompatibleDC(hdc); }
 395    ~MemoryHDC() { ::DeleteDC(m_hdc); }
 396
 397     operator HDC() const { return m_hdc; }
 398
 399 private:
 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
 407 class SelectInHDC
 408 {
 409 private:
 410     void DoInit(HGDIOBJ hgdiobj) { m_hgdiobj = ::SelectObject(m_hdc, hgdiobj); }
 411
 412 public:
 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
 430 private:
 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
 438 class AutoGDIObject
 439 {
 440 protected:
 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
 454 private:
 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
 461 class AutoHBRUSH : private AutoGDIObject
 462 {
 463 public:
 464     AutoHBRUSH(COLORREF col)
 465         : AutoGDIObject(::CreateSolidBrush(col)) { }
 466
 467     operator HBRUSH() const { return (HBRUSH)GetObject(); }
 468 };
 469
 470 // a class for temporary fonts
 471 class AutoHFONT : private AutoGDIObject
 472 {
 473 private:
 474 public:
 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
 487 class AutoHPEN : private AutoGDIObject
 488 {
 489 public:
 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
 497 class AutoHBITMAP : private AutoGDIObject
 498 {
 499 public:
 500     AutoHBITMAP(HBITMAP hbmp) : AutoGDIObject(hbmp) { }
 501
 502     operator HBITMAP() const { return (HBITMAP)GetObject(); }
 503 };
 504
 505 class CompatibleBitmap : public AutoHBITMAP
 506 {
 507 public:
 508     CompatibleBitmap(HDC hdc, int w, int h)
 509         : AutoHBITMAP(::CreateCompatibleBitmap(hdc, w, h))
 510     {
 511     }
 512 };
 513
 514 class MonoBitmap : public AutoHBITMAP
 515 {
 516 public:
 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
 524 class AutoHRGN : private AutoGDIObject
 525 {
 526 public:
 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
 533 class HDCClipper
 534 {
 535 public:
 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
 548 private:
 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()
 590 class GlobalPtr
 591 {
 592 public:
 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
 610 private:
 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
 619 class GlobalPtrLock
 620 {
 621 public:
 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
 646 private:
 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
 654 class ClassRegistrar
 655 {
 656 public:
 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.wx_str(), wxhInstance) )
 696             {
 697                 wxLogLastError(_T("UnregisterClass"));
 698             }
 699         }
 700     }
 701
 702 private:
 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
 765 extern "C"
 766 {
 767     WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
 768 }
 769
 770 WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
 771
 772 // return the full path of the given module
 773 inline 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
 790 inline 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
 807 enum 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_Vista = wxWinVersion_6,
 828     wxWinVersion_NT6 = wxWinVersion_6
 829 };
 830
 831 WXDLLIMPEXP_BASE wxWinVersion wxGetWinVersion();
 832
 833 #if wxUSE_GUI
 834
 835 // cursor stuff
 836 extern HCURSOR wxGetCurrentBusyCursor();    // from msw/utils.cpp
 837 extern const wxCursor *wxGetGlobalCursor(); // from msw/cursor.cpp
 838
 839 WXDLLEXPORT void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font);
 840 WXDLLEXPORT void wxFillLogFont(LOGFONT *logFont, const wxFont *font);
 841 WXDLLEXPORT wxFont wxCreateFontFromLogFont(const LOGFONT *logFont);
 842 WXDLLEXPORT wxFontEncoding wxGetFontEncFromCharSet(int charset);
 843
 844 WXDLLEXPORT void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos);
 845 WXDLLEXPORT void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos);
 846
 847 // Find maximum size of window/rectangle
 848 extern WXDLLEXPORT void wxFindMaxSize(WXHWND hwnd, RECT *rect);
 849
 850 // Safely get the window text (i.e. without using fixed size buffer)
 851 extern WXDLLEXPORT wxString wxGetWindowText(WXHWND hWnd);
 852
 853 // get the window class name
 854 extern WXDLLEXPORT wxString wxGetWindowClass(WXHWND hWnd);
 855
 856 // get the window id (should be unsigned, hence this is not wxWindowID which
 857 // is, for mainly historical reasons, signed)
 858 extern WXDLLEXPORT WXWORD wxGetWindowId(WXHWND hWnd);
 859
 860 // check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
 861 // different
 862 extern WXDLLEXPORT bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc);
 863
 864 // Does this window style specify any border?
 865 inline bool wxStyleHasBorder(long style)
 866 {
 867     return (style & (wxSIMPLE_BORDER | wxRAISED_BORDER |
 868                      wxSUNKEN_BORDER | wxDOUBLE_BORDER)) != 0;
 869 }
 870
 871 // ----------------------------------------------------------------------------
 872 // functions mapping HWND to wxWindow
 873 // ----------------------------------------------------------------------------
 874
 875 // this function simply checks whether the given hWnd corresponds to a wxWindow
 876 // and returns either that window if it does or NULL otherwise
 877 extern WXDLLEXPORT wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 878
 879 // find the window for HWND which is part of some wxWindow, i.e. unlike
 880 // wxFindWinFromHandle() above it will also work for "sub controls" of a
 881 // wxWindow.
 882 //
 883 // returns the wxWindow corresponding to the given HWND or NULL.
 884 extern WXDLLEXPORT wxWindow *wxGetWindowFromHWND(WXHWND hwnd);
 885
 886 // Get the size of an icon
 887 extern WXDLLEXPORT wxSize wxGetHiconSize(HICON hicon);
 888
 889 // Lines are drawn differently for WinCE and regular WIN32
 890 WXDLLEXPORT void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2);
 891
 892 // fill the client rect of the given window on the provided dc using this brush
 893 inline void wxFillRect(HWND hwnd, HDC hdc, HBRUSH hbr)
 894 {
 895     RECT rc;
 896     ::GetClientRect(hwnd, &rc);
 897     ::FillRect(hdc, &rc, hbr);
 898 }
 899
 900 // ----------------------------------------------------------------------------
 901 // 32/64 bit helpers
 902 // ----------------------------------------------------------------------------
 903
 904 #ifdef __WIN64__
 905
 906 inline void *wxGetWindowProc(HWND hwnd)
 907 {
 908     return (void *)::GetWindowLongPtr(hwnd, GWLP_WNDPROC);
 909 }
 910
 911 inline void *wxGetWindowUserData(HWND hwnd)
 912 {
 913     return (void *)::GetWindowLongPtr(hwnd, GWLP_USERDATA);
 914 }
 915
 916 inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
 917 {
 918     return (WNDPROC)::SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)func);
 919 }
 920
 921 inline void *wxSetWindowUserData(HWND hwnd, void *data)
 922 {
 923     return (void *)::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)data);
 924 }
 925
 926 #else // __WIN32__
 927
 928 // note that the casts to LONG_PTR here are required even on 32-bit machines
 929 // for the 64-bit warning mode of later versions of MSVC (C4311/4312)
 930 inline WNDPROC wxGetWindowProc(HWND hwnd)
 931 {
 932     return (WNDPROC)(LONG_PTR)::GetWindowLong(hwnd, GWL_WNDPROC);
 933 }
 934
 935 inline void *wxGetWindowUserData(HWND hwnd)
 936 {
 937     return (void *)(LONG_PTR)::GetWindowLong(hwnd, GWL_USERDATA);
 938 }
 939
 940 inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
 941 {
 942     return (WNDPROC)(LONG_PTR)::SetWindowLong(hwnd, GWL_WNDPROC, (LONG_PTR)func);
 943 }
 944
 945 inline void *wxSetWindowUserData(HWND hwnd, void *data)
 946 {
 947     return (void *)(LONG_PTR)::SetWindowLong(hwnd, GWL_USERDATA, (LONG_PTR)data);
 948 }
 949
 950 #endif // __WIN64__/__WIN32__
 951
 952 #endif // wxUSE_GUI
 953
 954 #endif // _WX_PRIVATE_H_