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