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