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 WXDLLEXPORT wxFont;
  27 class WXDLLEXPORT wxWindow;
  28 class WXDLLEXPORT 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 public:
 410     SelectInHDC(HDC hdc, HGDIOBJ hgdiobj) : m_hdc(hdc)
 411         { m_hgdiobj = ::SelectObject(hdc, hgdiobj); }
 412
 413    ~SelectInHDC() { ::SelectObject(m_hdc, m_hgdiobj); }
 414
 415    // return true if the object was successfully selected
 416    operator bool() const { return m_hgdiobj != 0; }
 417
 418 private:
 419    HDC m_hdc;
 420    HGDIOBJ m_hgdiobj;
 421
 422    DECLARE_NO_COPY_CLASS(SelectInHDC)
 423 };
 424
 425 // a class which cleans up any GDI object
 426 class AutoGDIObject
 427 {
 428 protected:
 429     AutoGDIObject(HGDIOBJ gdiobj) : m_gdiobj(gdiobj) { }
 430     ~AutoGDIObject() { if ( m_gdiobj ) ::DeleteObject(m_gdiobj); }
 431
 432     HGDIOBJ GetObject() const { return m_gdiobj; }
 433
 434 private:
 435     HGDIOBJ m_gdiobj;
 436 };
 437
 438 // TODO: all this asks for using a AutoHandler<T, CreateFunc> template...
 439
 440 // a class for temporary pens
 441 class AutoHBRUSH : private AutoGDIObject
 442 {
 443 public:
 444     AutoHBRUSH(COLORREF col)
 445         : AutoGDIObject(::CreateSolidBrush(col)) { }
 446
 447     operator HBRUSH() const { return (HBRUSH)GetObject(); }
 448 };
 449
 450 // a class for temporary pens
 451 class AutoHPEN : private AutoGDIObject
 452 {
 453 public:
 454     AutoHPEN(COLORREF col)
 455         : AutoGDIObject(::CreatePen(PS_SOLID, 0, col)) { }
 456
 457     operator HPEN() const { return (HPEN)GetObject(); }
 458 };
 459
 460 // classes for temporary bitmaps
 461 class AutoHBITMAP : private AutoGDIObject
 462 {
 463 public:
 464     AutoHBITMAP(HBITMAP hbmp) : AutoGDIObject(hbmp) { }
 465
 466     operator HBITMAP() const { return (HBITMAP)GetObject(); }
 467 };
 468
 469 class CompatibleBitmap : public AutoHBITMAP
 470 {
 471 public:
 472     CompatibleBitmap(HDC hdc, int w, int h)
 473         : AutoHBITMAP(::CreateCompatibleBitmap(hdc, w, h))
 474     {
 475     }
 476 };
 477
 478 class MonoBitmap : public AutoHBITMAP
 479 {
 480 public:
 481     MonoBitmap(int w, int h)
 482         : AutoHBITMAP(::CreateBitmap(w, h, 1, 1, 0))
 483     {
 484     }
 485 };
 486
 487 // class automatically destroys the region object
 488 class AutoHRGN : private AutoGDIObject
 489 {
 490 public:
 491     AutoHRGN(HRGN hrgn) : AutoGDIObject(hrgn) { }
 492
 493     operator HRGN() const { return (HRGN)GetObject(); }
 494 };
 495
 496 // class sets the specified clipping region during its life time
 497 class HDCClipper
 498 {
 499 public:
 500     HDCClipper(HDC hdc, HRGN hrgn)
 501         : m_hdc(hdc)
 502     {
 503         if ( !::SelectClipRgn(hdc, hrgn) )
 504             wxLogLastError(_T("SelectClipRgn"));
 505     }
 506
 507     ~HDCClipper()
 508     {
 509         ::SelectClipRgn(m_hdc, NULL);
 510     }
 511
 512 private:
 513     HDC m_hdc;
 514
 515     DECLARE_NO_COPY_CLASS(HDCClipper)
 516 };
 517
 518 // set the given map mode for the life time of this object
 519 //
 520 // NB: SetMapMode() is not supported by CE so we also define a helper macro
 521 //     to avoid using it there
 522 #ifdef __WXWINCE__
 523     #define wxCHANGE_HDC_MAP_MODE(hdc, mm)
 524 #else // !__WXWINCE__
 525     class HDCMapModeChanger
 526     {
 527     public:
 528         HDCMapModeChanger(HDC hdc, int mm)
 529             : m_hdc(hdc)
 530         {
 531             m_modeOld = ::SetMapMode(hdc, mm);
 532             if ( !m_modeOld )
 533                 wxLogLastError(_T("SelectClipRgn"));
 534         }
 535
 536         ~HDCMapModeChanger()
 537         {
 538             if ( m_modeOld )
 539                 ::SetMapMode(m_hdc, m_modeOld);
 540         }
 541
 542     private:
 543         HDC m_hdc;
 544         int m_modeOld;
 545
 546         DECLARE_NO_COPY_CLASS(HDCMapModeChanger)
 547     };
 548
 549     #define wxCHANGE_HDC_MAP_MODE(hdc, mm) \
 550         HDCMapModeChanger wxMAKE_UNIQUE_NAME(wxHDCMapModeChanger)(hdc, mm)
 551 #endif // __WXWINCE__/!__WXWINCE__
 552
 553 // smart buffeer using GlobalAlloc/GlobalFree()
 554 class GlobalPtr
 555 {
 556 public:
 557     // allocates a block of given size
 558     GlobalPtr(size_t size, unsigned flags = GMEM_MOVEABLE)
 559     {
 560         m_hGlobal = ::GlobalAlloc(flags, size);
 561         if ( !m_hGlobal )
 562             wxLogLastError(_T("GlobalAlloc"));
 563     }
 564
 565     ~GlobalPtr()
 566     {
 567         if ( m_hGlobal && ::GlobalFree(m_hGlobal) )
 568             wxLogLastError(_T("GlobalFree"));
 569     }
 570
 571     // implicit conversion
 572     operator HGLOBAL() const { return m_hGlobal; }
 573
 574 private:
 575     HGLOBAL m_hGlobal;
 576
 577     DECLARE_NO_COPY_CLASS(GlobalPtr)
 578 };
 579
 580 // when working with global pointers (which is unfortunately still necessary
 581 // sometimes, e.g. for clipboard) it is important to unlock them exactly as
 582 // many times as we lock them which just asks for using a "smart lock" class
 583 class GlobalPtrLock
 584 {
 585 public:
 586     GlobalPtrLock(HGLOBAL hGlobal) : m_hGlobal(hGlobal)
 587     {
 588         m_ptr = GlobalLock(hGlobal);
 589         if ( !m_ptr )
 590             wxLogLastError(_T("GlobalLock"));
 591     }
 592
 593     ~GlobalPtrLock()
 594     {
 595         if ( !GlobalUnlock(m_hGlobal) )
 596         {
 597 #ifdef __WXDEBUG__
 598             // this might happen simply because the block became unlocked
 599             DWORD dwLastError = ::GetLastError();
 600             if ( dwLastError != NO_ERROR )
 601             {
 602                 wxLogApiError(_T("GlobalUnlock"), dwLastError);
 603             }
 604 #endif // __WXDEBUG__
 605         }
 606     }
 607
 608     operator void *() const { return m_ptr; }
 609
 610 private:
 611     HGLOBAL m_hGlobal;
 612     void *m_ptr;
 613
 614     DECLARE_NO_COPY_CLASS(GlobalPtrLock)
 615 };
 616
 617 // register the class when it is first needed and unregister it in dtor
 618 class ClassRegistrar
 619 {
 620 public:
 621     // ctor doesn't register the class, call Initialize() for this
 622     ClassRegistrar() { m_registered = -1; }
 623
 624     // return true if the class is already registered
 625     bool IsInitialized() const { return m_registered != -1; }
 626
 627     // return true if the class had been already registered
 628     bool IsRegistered() const { return m_registered == 1; }
 629
 630     // try to register the class if not done yet, return true on success
 631     bool Register(const WNDCLASS& wc)
 632     {
 633         // we should only be called if we hadn't been initialized yet
 634         wxASSERT_MSG( m_registered == -1,
 635                         _T("calling ClassRegistrar::Register() twice?") );
 636
 637         m_registered = ::RegisterClass(&wc) ? 1 : 0;
 638         if ( !IsRegistered() )
 639         {
 640             wxLogLastError(_T("RegisterClassEx()"));
 641         }
 642         else
 643         {
 644             m_clsname = wc.lpszClassName;
 645         }
 646
 647         return m_registered == 1;
 648     }
 649
 650     // get the name of the registered class (returns empty string if not
 651     // registered)
 652     const wxString& GetName() const { return m_clsname; }
 653
 654     // unregister the class if it had been registered
 655     ~ClassRegistrar()
 656     {
 657         if ( IsRegistered() )
 658         {
 659             if ( !::UnregisterClass(m_clsname, wxhInstance) )
 660             {
 661                 wxLogLastError(_T("UnregisterClass"));
 662             }
 663         }
 664     }
 665
 666 private:
 667     // initial value is -1 which means that we hadn't tried registering the
 668     // class yet, it becomes true or false (1 or 0) when Initialize() is called
 669     int m_registered;
 670
 671     // the name of the class, only non empty if it had been registered
 672     wxString m_clsname;
 673 };
 674
 675 // ---------------------------------------------------------------------------
 676 // macros to make casting between WXFOO and FOO a bit easier: the GetFoo()
 677 // returns Foo cast to the Windows type for oruselves, while GetFooOf() takes
 678 // an argument which should be a pointer or reference to the object of the
 679 // corresponding class (this depends on the macro)
 680 // ---------------------------------------------------------------------------
 681
 682 #define GetHwnd()               ((HWND)GetHWND())
 683 #define GetHwndOf(win)          ((HWND)((win)->GetHWND()))
 684 // old name
 685 #define GetWinHwnd              GetHwndOf
 686
 687 #define GetHdc()                ((HDC)GetHDC())
 688 #define GetHdcOf(dc)            ((HDC)(dc).GetHDC())
 689
 690 #define GetHbitmap()            ((HBITMAP)GetHBITMAP())
 691 #define GetHbitmapOf(bmp)       ((HBITMAP)(bmp).GetHBITMAP())
 692
 693 #define GetHicon()              ((HICON)GetHICON())
 694 #define GetHiconOf(icon)        ((HICON)(icon).GetHICON())
 695
 696 #define GetHaccel()             ((HACCEL)GetHACCEL())
 697 #define GetHaccelOf(table)      ((HACCEL)((table).GetHACCEL()))
 698
 699 #define GetHbrush()             ((HBRUSH)GetResourceHandle())
 700 #define GetHbrushOf(brush)      ((HBRUSH)(brush).GetResourceHandle())
 701
 702 #define GetHmenu()              ((HMENU)GetHMenu())
 703 #define GetHmenuOf(menu)        ((HMENU)menu->GetHMenu())
 704
 705 #define GetHcursor()            ((HCURSOR)GetHCURSOR())
 706 #define GetHcursorOf(cursor)    ((HCURSOR)(cursor).GetHCURSOR())
 707
 708 #define GetHfont()              ((HFONT)GetHFONT())
 709 #define GetHfontOf(font)        ((HFONT)(font).GetHFONT())
 710
 711 #define GetHimagelist()         ((HIMAGELIST)GetHIMAGELIST())
 712 #define GetHimagelistOf(imgl)   ((HIMAGELIST)imgl->GetHIMAGELIST())
 713
 714 #define GetHpalette()           ((HPALETTE)GetHPALETTE())
 715 #define GetHpaletteOf(pal)      ((HPALETTE)(pal).GetHPALETTE())
 716
 717 #define GetHpen()               ((HPEN)GetResourceHandle())
 718 #define GetHpenOf(pen)          ((HPEN)(pen).GetResourceHandle())
 719
 720 #define GetHrgn()               ((HRGN)GetHRGN())
 721 #define GetHrgnOf(rgn)          ((HRGN)(rgn).GetHRGN())
 722
 723 #endif // wxUSE_GUI
 724
 725 // ---------------------------------------------------------------------------
 726 // global functions
 727 // ---------------------------------------------------------------------------
 728
 729 extern "C"
 730 {
 731     WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
 732 }
 733
 734 WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
 735
 736 // return the full path of the given module
 737 inline wxString wxGetFullModuleName(HMODULE hmod)
 738 {
 739     wxString fullname;
 740     if ( !::GetModuleFileName
 741             (
 742                 hmod,
 743                 wxStringBuffer(fullname, MAX_PATH),
 744                 MAX_PATH
 745             ) )
 746     {
 747         wxLogLastError(_T("GetModuleFileName"));
 748     }
 749
 750     return fullname;
 751 }
 752
 753 // return the full path of the program file
 754 inline wxString wxGetFullModuleName()
 755 {
 756     return wxGetFullModuleName((HMODULE)wxGetInstance());
 757 }
 758
 759 // return the run-time version of the OS in a format similar to
 760 // WINVER/_WIN32_WINNT compile-time macros:
 761 //
 762 //      0x0300      Windows NT 3.51
 763 //      0x0400      Windows 95, NT4
 764 //      0x0410      Windows 98
 765 //      0x0500      Windows ME, 2000
 766 //      0x0501      Windows XP
 767 //      0x0502      Windows 2003
 768 //      0x0600      Longhorn
 769 //
 770 // for the other Windows versions 0 is currently returned
 771 enum wxWinVersion
 772 {
 773     wxWinVersion_Unknown = 0,
 774
 775     wxWinVersion_3 = 0x0300,
 776     wxWinVersion_NT3 = wxWinVersion_3,
 777
 778     wxWinVersion_4 = 0x0400,
 779     wxWinVersion_95 = wxWinVersion_4,
 780     wxWinVersion_NT4 = wxWinVersion_4,
 781     wxWinVersion_98 = 0x0410,
 782
 783     wxWinVersion_5 = 0x0500,
 784     wxWinVersion_ME = wxWinVersion_5,
 785     wxWinVersion_NT5 = wxWinVersion_5,
 786     wxWinVersion_2000 = wxWinVersion_5,
 787     wxWinVersion_XP = 0x0501,
 788     wxWinVersion_2003 = 0x0502,
 789
 790     wxWinVersion_6 = 0x0600,
 791     wxWinVersion_NT6 = 0x0600
 792 };
 793
 794 WXDLLIMPEXP_BASE wxWinVersion wxGetWinVersion();
 795
 796 #if wxUSE_GUI
 797
 798 // cursor stuff
 799 extern HCURSOR wxGetCurrentBusyCursor();    // from msw/utils.cpp
 800 extern const wxCursor *wxGetGlobalCursor(); // from msw/cursor.cpp
 801
 802 WXDLLEXPORT void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font);
 803 WXDLLEXPORT void wxFillLogFont(LOGFONT *logFont, const wxFont *font);
 804 WXDLLEXPORT wxFont wxCreateFontFromLogFont(const LOGFONT *logFont);
 805 WXDLLEXPORT wxFontEncoding wxGetFontEncFromCharSet(int charset);
 806
 807 WXDLLEXPORT void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos);
 808 WXDLLEXPORT void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos);
 809
 810 // Find maximum size of window/rectangle
 811 extern WXDLLEXPORT void wxFindMaxSize(WXHWND hwnd, RECT *rect);
 812
 813 // Safely get the window text (i.e. without using fixed size buffer)
 814 extern WXDLLEXPORT wxString wxGetWindowText(WXHWND hWnd);
 815
 816 // get the window class name
 817 extern WXDLLEXPORT wxString wxGetWindowClass(WXHWND hWnd);
 818
 819 // get the window id (should be unsigned, hence this is not wxWindowID which
 820 // is, for mainly historical reasons, signed)
 821 extern WXDLLEXPORT WXWORD wxGetWindowId(WXHWND hWnd);
 822
 823 // check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
 824 // different
 825 extern WXDLLEXPORT bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc);
 826
 827 // Does this window style specify any border?
 828 inline bool wxStyleHasBorder(long style)
 829 {
 830     return (style & (wxSIMPLE_BORDER | wxRAISED_BORDER |
 831                      wxSUNKEN_BORDER | wxDOUBLE_BORDER)) != 0;
 832 }
 833
 834 // ----------------------------------------------------------------------------
 835 // functions mapping HWND to wxWindow
 836 // ----------------------------------------------------------------------------
 837
 838 // this function simply checks whether the given hWnd corresponds to a wxWindow
 839 // and returns either that window if it does or NULL otherwise
 840 extern WXDLLEXPORT wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 841
 842 // find the window for HWND which is part of some wxWindow, i.e. unlike
 843 // wxFindWinFromHandle() above it will also work for "sub controls" of a
 844 // wxWindow.
 845 //
 846 // returns the wxWindow corresponding to the given HWND or NULL.
 847 extern WXDLLEXPORT wxWindow *wxGetWindowFromHWND(WXHWND hwnd);
 848
 849 // Get the size of an icon
 850 extern WXDLLEXPORT wxSize wxGetHiconSize(HICON hicon);
 851
 852 // Lines are drawn differently for WinCE and regular WIN32
 853 WXDLLEXPORT void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2);
 854
 855 // fill the client rect of the given window on the provided dc using this brush
 856 inline void wxFillRect(HWND hwnd, HDC hdc, HBRUSH hbr)
 857 {
 858     RECT rc;
 859     ::GetClientRect(hwnd, &rc);
 860     ::FillRect(hdc, &rc, hbr);
 861 }
 862
 863 // ----------------------------------------------------------------------------
 864 // 32/64 bit helpers
 865 // ----------------------------------------------------------------------------
 866
 867 #ifdef __WIN64__
 868
 869 inline void *wxGetWindowProc(HWND hwnd)
 870 {
 871     return (void *)::GetWindowLongPtr(hwnd, GWLP_WNDPROC);
 872 }
 873
 874 inline void *wxGetWindowUserData(HWND hwnd)
 875 {
 876     return (void *)::GetWindowLongPtr(hwnd, GWLP_USERDATA);
 877 }
 878
 879 inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
 880 {
 881     return (WNDPROC)::SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)func);
 882 }
 883
 884 inline void *wxSetWindowUserData(HWND hwnd, void *data)
 885 {
 886     return (void *)::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)data);
 887 }
 888
 889 #else // __WIN32__
 890
 891 // note that the casts to LONG_PTR here are required even on 32-bit machines
 892 // for the 64-bit warning mode of later versions of MSVC (C4311/4312)
 893 inline WNDPROC wxGetWindowProc(HWND hwnd)
 894 {
 895     return (WNDPROC)(LONG_PTR)::GetWindowLong(hwnd, GWL_WNDPROC);
 896 }
 897
 898 inline void *wxGetWindowUserData(HWND hwnd)
 899 {
 900     return (void *)(LONG_PTR)::GetWindowLong(hwnd, GWL_USERDATA);
 901 }
 902
 903 inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
 904 {
 905     return (WNDPROC)(LONG_PTR)::SetWindowLong(hwnd, GWL_WNDPROC, (LONG_PTR)func);
 906 }
 907
 908 inline void *wxSetWindowUserData(HWND hwnd, void *data)
 909 {
 910     return (void *)(LONG_PTR)::SetWindowLong(hwnd, GWL_USERDATA, (LONG_PTR)data);
 911 }
 912
 913 #endif // __WIN64__/__WIN32__
 914
 915 #endif // wxUSE_GUI
 916
 917 #endif // _WX_PRIVATE_H_