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