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