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
6 // Author: Julian Smart
10 // Copyright: (c) Julian Smart
11 // Licence: wxWindows licence
12 /////////////////////////////////////////////////////////////////////////////
14 #ifndef _WX_PRIVATE_H_
15 #define _WX_PRIVATE_H_
17 #include "wx/msw/wrapwin.h"
20 // Extra prototypes and symbols not defined by MicroWindows
21 #include "wx/msw/microwin.h"
26 class WXDLLEXPORT wxFont
;
27 class WXDLLEXPORT wxWindow
;
28 class WXDLLEXPORT wxWindowBase
;
30 // ---------------------------------------------------------------------------
32 // ---------------------------------------------------------------------------
34 // 260 was taken from windef.h
39 // ---------------------------------------------------------------------------
40 // standard icons from the resources
41 // ---------------------------------------------------------------------------
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
;
55 // ---------------------------------------------------------------------------
57 // ---------------------------------------------------------------------------
59 extern WXDLLIMPEXP_DATA_BASE(HINSTANCE
) wxhInstance
;
61 // ---------------------------------------------------------------------------
62 // define things missing from some compilers' headers
63 // ---------------------------------------------------------------------------
65 #if defined(__WXWINCE__) || (defined(__GNUWIN32__) && !wxUSE_NORLANDER_HEADERS)
67 inline void ZeroMemory(void *buf
, size_t len
) { memset(buf
, 0, len
); }
71 // this defines a CASTWNDPROC macro which casts a pointer to the type of a
73 #if defined(STRICT) || defined(__GNUC__)
74 typedef WNDPROC WndProcCast
;
76 typedef FARPROC WndProcCast
;
80 #define CASTWNDPROC (WndProcCast)
84 // ---------------------------------------------------------------------------
85 // some stuff for old Windows versions (FIXME: what does it do here??)
86 // ---------------------------------------------------------------------------
88 #if !defined(APIENTRY) // NT defines APIENTRY, 3.x not
89 #define APIENTRY FAR PASCAL
95 #define _EXPORT _export
99 typedef signed short int SHORT
;
102 #if !defined(__WIN32__) // 3.x uses FARPROC for dialogs
104 #define DLGPROC FARPROC
109 * Decide what window classes we're going to use
110 * for this combination of CTl3D/FAFA settings
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
123 #define GROUP_CLASS wxT("BUTTON")
124 #define GROUP_FLAGS (BS_GROUPBOX|WS_CHILD|WS_VISIBLE)
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)
131 // ---------------------------------------------------------------------------
133 // ---------------------------------------------------------------------------
135 #define MEANING_CHARACTER '0'
136 #define DEFAULT_ITEM_WIDTH 100
137 #define DEFAULT_ITEM_HEIGHT 80
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)
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
);
148 // ---------------------------------------------------------------------------
149 // useful macros and functions
150 // ---------------------------------------------------------------------------
152 // a wrapper macro for ZeroMemory()
153 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
154 #define wxZeroMemory(obj) ::ZeroMemory(&obj, sizeof(obj))
156 #define wxZeroMemory(obj) memset((void*) & obj, 0, sizeof(obj))
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
180 // close the handle in the class dtor
184 wxEXPLICIT
AutoHANDLE(HANDLE handle
) : m_handle(handle
) { }
186 bool IsOk() const { return m_handle
!= INVALID_HANDLE_VALUE
; }
187 operator HANDLE() const { return m_handle
; }
189 ~AutoHANDLE() { if ( IsOk() ) ::CloseHandle(m_handle
); }
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...)
199 struct WinStruct
: public T
203 ::ZeroMemory(this, sizeof(T
));
205 // explicit qualification is required here for this to be valid C++
206 this->cbSize
= sizeof(T
);
213 #include "wx/gdicmn.h"
214 #include "wx/colour.h"
216 // make conversion from wxColour and COLORREF a bit less painful
217 inline COLORREF
wxColourToRGB(const wxColour
& c
)
219 return RGB(c
.Red(), c
.Green(), c
.Blue());
222 inline COLORREF
wxColourToPalRGB(const wxColour
& c
)
224 return PALETTERGB(c
.Red(), c
.Green(), c
.Blue());
227 inline wxColour
wxRGBToColour(COLORREF rgb
)
229 return wxColour(GetRValue(rgb
), GetGValue(rgb
), GetBValue(rgb
));
232 inline void wxRGBToColour(wxColour
& c
, COLORREF rgb
)
234 c
.Set(GetRValue(rgb
), GetGValue(rgb
), GetBValue(rgb
));
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
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
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!
250 wxSTD_COL_BTNHIGHLIGHT
,
254 struct WXDLLEXPORT wxCOLORMAP
259 // this function is implemented in src/msw/window.cpp
260 extern wxCOLORMAP
*wxGetStdColourMap();
262 // create a wxRect from Windows RECT
263 inline wxRect
wxRectFromRECT(const RECT
& rc
)
265 return wxRect(rc
.left
, rc
.top
, rc
.right
- rc
.left
, rc
.bottom
- rc
.top
);
268 // copy Windows RECT to our wxRect
269 inline void wxCopyRECTToRect(const RECT
& rc
, wxRect
& rect
)
271 rect
= wxRectFromRECT(rc
);
275 inline void wxCopyRectToRECT(const wxRect
& rect
, RECT
& rc
)
277 // note that we don't use wxRect::GetRight() as it is one of compared to
278 // wxRectFromRECT() above
281 rc
.right
= rect
.x
+ rect
.width
;
282 rc
.bottom
= rect
.y
+ rect
.height
;
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
);
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);
294 // Creates an icon or cursor depending from a bitmap
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
);
300 // Same requirments as above apply and the bitmap must also have the correct
303 HCURSOR
wxBitmapToHCURSOR(const wxBitmap
& bmp
, int hotSpotX
, int hotSpotY
);
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
308 // these macros are standard now (Win98) but some older headers don't have them
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
314 // get the current state of SHIFT/CTRL keys
315 inline bool wxIsShiftDown()
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;
323 inline bool wxIsCtrlDown()
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;
331 // wrapper around GetWindowRect() and GetClientRect() APIs doing error checking
333 inline RECT
wxGetWindowRect(HWND hwnd
)
337 if ( !::GetWindowRect(hwnd
, &rect
) )
338 wxLogLastError(_T("GetWindowRect"));
343 inline RECT
wxGetClientRect(HWND hwnd
)
347 if ( !::GetClientRect(hwnd
, &rect
) )
348 wxLogLastError(_T("GetClientRect"));
353 // ---------------------------------------------------------------------------
354 // small helper classes
355 // ---------------------------------------------------------------------------
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
362 ScreenHDC() { m_hdc
= ::GetDC(NULL
); }
363 ~ScreenHDC() { ::ReleaseDC(NULL
, m_hdc
); }
365 operator HDC() const { return m_hdc
; }
370 DECLARE_NO_COPY_CLASS(ScreenHDC
)
373 // the same as ScreenHDC but for window DCs
377 WindowHDC(HWND hwnd
) { m_hdc
= ::GetDC(m_hwnd
= hwnd
); }
378 ~WindowHDC() { ::ReleaseDC(m_hwnd
, m_hdc
); }
380 operator HDC() const { return m_hdc
; }
386 DECLARE_NO_COPY_CLASS(WindowHDC
)
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
394 MemoryHDC(HDC hdc
= 0) { m_hdc
= ::CreateCompatibleDC(hdc
); }
395 ~MemoryHDC() { ::DeleteDC(m_hdc
); }
397 operator HDC() const { return m_hdc
; }
402 DECLARE_NO_COPY_CLASS(MemoryHDC
)
405 // a class which selects a GDI object into a DC in its ctor and deselects in
410 void DoInit(HGDIOBJ hgdiobj
) { m_hgdiobj
= ::SelectObject(m_hdc
, hgdiobj
); }
413 SelectInHDC() : m_hdc(NULL
) { }
414 SelectInHDC(HDC hdc
, HGDIOBJ hgdiobj
) : m_hdc(hdc
) { DoInit(hgdiobj
); }
416 void Init(HDC hdc
, HGDIOBJ hgdiobj
)
418 wxASSERT_MSG( !m_hdc
, _T("initializing twice?") );
425 ~SelectInHDC() { if ( m_hdc
) ::SelectObject(m_hdc
, m_hgdiobj
); }
427 // return true if the object was successfully selected
428 operator bool() const { return m_hgdiobj
!= 0; }
434 DECLARE_NO_COPY_CLASS(SelectInHDC
)
437 // a class which cleans up any GDI object
441 AutoGDIObject() { m_gdiobj
= NULL
; }
442 AutoGDIObject(HGDIOBJ gdiobj
) : m_gdiobj(gdiobj
) { }
443 ~AutoGDIObject() { if ( m_gdiobj
) ::DeleteObject(m_gdiobj
); }
445 void InitGdiobj(HGDIOBJ gdiobj
)
447 wxASSERT_MSG( !m_gdiobj
, _T("initializing twice?") );
452 HGDIOBJ
GetObject() const { return m_gdiobj
; }
458 // TODO: all this asks for using a AutoHandler<T, CreateFunc> template...
460 // a class for temporary brushes
461 class AutoHBRUSH
: private AutoGDIObject
464 AutoHBRUSH(COLORREF col
)
465 : AutoGDIObject(::CreateSolidBrush(col
)) { }
467 operator HBRUSH() const { return (HBRUSH
)GetObject(); }
470 // a class for temporary fonts
471 class AutoHFONT
: private AutoGDIObject
476 : AutoGDIObject() { }
478 AutoHFONT(const LOGFONT
& lf
)
479 : AutoGDIObject(::CreateFontIndirect(&lf
)) { }
481 void Init(const LOGFONT
& lf
) { InitGdiobj(::CreateFontIndirect(&lf
)); }
483 operator HFONT() const { return (HFONT
)GetObject(); }
486 // a class for temporary pens
487 class AutoHPEN
: private AutoGDIObject
490 AutoHPEN(COLORREF col
)
491 : AutoGDIObject(::CreatePen(PS_SOLID
, 0, col
)) { }
493 operator HPEN() const { return (HPEN
)GetObject(); }
496 // classes for temporary bitmaps
497 class AutoHBITMAP
: private AutoGDIObject
500 AutoHBITMAP(HBITMAP hbmp
) : AutoGDIObject(hbmp
) { }
502 operator HBITMAP() const { return (HBITMAP
)GetObject(); }
505 class CompatibleBitmap
: public AutoHBITMAP
508 CompatibleBitmap(HDC hdc
, int w
, int h
)
509 : AutoHBITMAP(::CreateCompatibleBitmap(hdc
, w
, h
))
514 class MonoBitmap
: public AutoHBITMAP
517 MonoBitmap(int w
, int h
)
518 : AutoHBITMAP(::CreateBitmap(w
, h
, 1, 1, 0))
523 // class automatically destroys the region object
524 class AutoHRGN
: private AutoGDIObject
527 AutoHRGN(HRGN hrgn
) : AutoGDIObject(hrgn
) { }
529 operator HRGN() const { return (HRGN
)GetObject(); }
532 // class sets the specified clipping region during its life time
536 HDCClipper(HDC hdc
, HRGN hrgn
)
539 if ( !::SelectClipRgn(hdc
, hrgn
) )
540 wxLogLastError(_T("SelectClipRgn"));
545 ::SelectClipRgn(m_hdc
, NULL
);
551 DECLARE_NO_COPY_CLASS(HDCClipper
)
554 // set the given map mode for the life time of this object
556 // NB: SetMapMode() is not supported by CE so we also define a helper macro
557 // to avoid using it there
559 #define wxCHANGE_HDC_MAP_MODE(hdc, mm)
560 #else // !__WXWINCE__
561 class HDCMapModeChanger
564 HDCMapModeChanger(HDC hdc
, int mm
)
567 m_modeOld
= ::SetMapMode(hdc
, mm
);
569 wxLogLastError(_T("SelectClipRgn"));
575 ::SetMapMode(m_hdc
, m_modeOld
);
582 DECLARE_NO_COPY_CLASS(HDCMapModeChanger
)
585 #define wxCHANGE_HDC_MAP_MODE(hdc, mm) \
586 HDCMapModeChanger wxMAKE_UNIQUE_NAME(wxHDCMapModeChanger)(hdc, mm)
587 #endif // __WXWINCE__/!__WXWINCE__
589 // smart buffeer using GlobalAlloc/GlobalFree()
593 // allocates a block of given size
594 GlobalPtr(size_t size
, unsigned flags
= GMEM_MOVEABLE
)
596 m_hGlobal
= ::GlobalAlloc(flags
, size
);
598 wxLogLastError(_T("GlobalAlloc"));
603 if ( m_hGlobal
&& ::GlobalFree(m_hGlobal
) )
604 wxLogLastError(_T("GlobalFree"));
607 // implicit conversion
608 operator HGLOBAL() const { return m_hGlobal
; }
613 DECLARE_NO_COPY_CLASS(GlobalPtr
)
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
622 GlobalPtrLock(HGLOBAL hGlobal
) : m_hGlobal(hGlobal
)
624 m_ptr
= GlobalLock(hGlobal
);
626 wxLogLastError(_T("GlobalLock"));
631 if ( !GlobalUnlock(m_hGlobal
) )
634 // this might happen simply because the block became unlocked
635 DWORD dwLastError
= ::GetLastError();
636 if ( dwLastError
!= NO_ERROR
)
638 wxLogApiError(_T("GlobalUnlock"), dwLastError
);
640 #endif // __WXDEBUG__
644 operator void *() const { return m_ptr
; }
650 DECLARE_NO_COPY_CLASS(GlobalPtrLock
)
653 // register the class when it is first needed and unregister it in dtor
657 // ctor doesn't register the class, call Initialize() for this
658 ClassRegistrar() { m_registered
= -1; }
660 // return true if the class is already registered
661 bool IsInitialized() const { return m_registered
!= -1; }
663 // return true if the class had been already registered
664 bool IsRegistered() const { return m_registered
== 1; }
666 // try to register the class if not done yet, return true on success
667 bool Register(const WNDCLASS
& wc
)
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?") );
673 m_registered
= ::RegisterClass(&wc
) ? 1 : 0;
674 if ( !IsRegistered() )
676 wxLogLastError(_T("RegisterClassEx()"));
680 m_clsname
= wc
.lpszClassName
;
683 return m_registered
== 1;
686 // get the name of the registered class (returns empty string if not
688 const wxString
& GetName() const { return m_clsname
; }
690 // unregister the class if it had been registered
693 if ( IsRegistered() )
695 if ( !::UnregisterClass(m_clsname
, wxhInstance
) )
697 wxLogLastError(_T("UnregisterClass"));
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
707 // the name of the class, only non empty if it had been registered
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 // ---------------------------------------------------------------------------
718 #define GetHwnd() ((HWND)GetHWND())
719 #define GetHwndOf(win) ((HWND)((win)->GetHWND()))
721 #define GetWinHwnd GetHwndOf
723 #define GetHdc() ((HDC)GetHDC())
724 #define GetHdcOf(dc) ((HDC)(dc).GetHDC())
726 #define GetHbitmap() ((HBITMAP)GetHBITMAP())
727 #define GetHbitmapOf(bmp) ((HBITMAP)(bmp).GetHBITMAP())
729 #define GetHicon() ((HICON)GetHICON())
730 #define GetHiconOf(icon) ((HICON)(icon).GetHICON())
732 #define GetHaccel() ((HACCEL)GetHACCEL())
733 #define GetHaccelOf(table) ((HACCEL)((table).GetHACCEL()))
735 #define GetHbrush() ((HBRUSH)GetResourceHandle())
736 #define GetHbrushOf(brush) ((HBRUSH)(brush).GetResourceHandle())
738 #define GetHmenu() ((HMENU)GetHMenu())
739 #define GetHmenuOf(menu) ((HMENU)menu->GetHMenu())
741 #define GetHcursor() ((HCURSOR)GetHCURSOR())
742 #define GetHcursorOf(cursor) ((HCURSOR)(cursor).GetHCURSOR())
744 #define GetHfont() ((HFONT)GetHFONT())
745 #define GetHfontOf(font) ((HFONT)(font).GetHFONT())
747 #define GetHimagelist() ((HIMAGELIST)GetHIMAGELIST())
748 #define GetHimagelistOf(imgl) ((HIMAGELIST)imgl->GetHIMAGELIST())
750 #define GetHpalette() ((HPALETTE)GetHPALETTE())
751 #define GetHpaletteOf(pal) ((HPALETTE)(pal).GetHPALETTE())
753 #define GetHpen() ((HPEN)GetResourceHandle())
754 #define GetHpenOf(pen) ((HPEN)(pen).GetResourceHandle())
756 #define GetHrgn() ((HRGN)GetHRGN())
757 #define GetHrgnOf(rgn) ((HRGN)(rgn).GetHRGN())
761 // ---------------------------------------------------------------------------
763 // ---------------------------------------------------------------------------
767 WXDLLIMPEXP_BASE HINSTANCE
wxGetInstance();
770 WXDLLIMPEXP_BASE
void wxSetInstance(HINSTANCE hInst
);
772 // return the full path of the given module
773 inline wxString
wxGetFullModuleName(HMODULE hmod
)
776 if ( !::GetModuleFileName
779 wxStringBuffer(fullname
, MAX_PATH
),
783 wxLogLastError(_T("GetModuleFileName"));
789 // return the full path of the program file
790 inline wxString
wxGetFullModuleName()
792 return wxGetFullModuleName((HMODULE
)wxGetInstance());
795 // return the run-time version of the OS in a format similar to
796 // WINVER/_WIN32_WINNT compile-time macros:
798 // 0x0300 Windows NT 3.51
799 // 0x0400 Windows 95, NT4
801 // 0x0500 Windows ME, 2000
803 // 0x0502 Windows 2003
806 // for the other Windows versions 0 is currently returned
809 wxWinVersion_Unknown
= 0,
811 wxWinVersion_3
= 0x0300,
812 wxWinVersion_NT3
= wxWinVersion_3
,
814 wxWinVersion_4
= 0x0400,
815 wxWinVersion_95
= wxWinVersion_4
,
816 wxWinVersion_NT4
= wxWinVersion_4
,
817 wxWinVersion_98
= 0x0410,
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,
826 wxWinVersion_6
= 0x0600,
827 wxWinVersion_Vista
= wxWinVersion_6
828 wxWinVersion_NT6
= wxWinVersion_6
831 WXDLLIMPEXP_BASE wxWinVersion
wxGetWinVersion();
836 extern HCURSOR
wxGetCurrentBusyCursor(); // from msw/utils.cpp
837 extern const wxCursor
*wxGetGlobalCursor(); // from msw/cursor.cpp
839 WXDLLEXPORT
void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
);
840 WXDLLEXPORT
void wxFillLogFont(LOGFONT
*logFont
, const wxFont
*font
);
841 WXDLLEXPORT wxFont
wxCreateFontFromLogFont(const LOGFONT
*logFont
);
842 WXDLLEXPORT wxFontEncoding
wxGetFontEncFromCharSet(int charset
);
844 WXDLLEXPORT
void wxSliderEvent(WXHWND control
, WXWORD wParam
, WXWORD pos
);
845 WXDLLEXPORT
void wxScrollBarEvent(WXHWND hbar
, WXWORD wParam
, WXWORD pos
);
847 // Find maximum size of window/rectangle
848 extern WXDLLEXPORT
void wxFindMaxSize(WXHWND hwnd
, RECT
*rect
);
850 // Safely get the window text (i.e. without using fixed size buffer)
851 extern WXDLLEXPORT wxString
wxGetWindowText(WXHWND hWnd
);
853 // get the window class name
854 extern WXDLLEXPORT wxString
wxGetWindowClass(WXHWND hWnd
);
856 // get the window id (should be unsigned, hence this is not wxWindowID which
857 // is, for mainly historical reasons, signed)
858 extern WXDLLEXPORT WXWORD
wxGetWindowId(WXHWND hWnd
);
860 // check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
862 extern WXDLLEXPORT
bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
);
864 // Does this window style specify any border?
865 inline bool wxStyleHasBorder(long style
)
867 return (style
& (wxSIMPLE_BORDER
| wxRAISED_BORDER
|
868 wxSUNKEN_BORDER
| wxDOUBLE_BORDER
)) != 0;
871 // ----------------------------------------------------------------------------
872 // functions mapping HWND to wxWindow
873 // ----------------------------------------------------------------------------
875 // this function simply checks whether the given hWnd corresponds to a wxWindow
876 // and returns either that window if it does or NULL otherwise
877 extern WXDLLEXPORT wxWindow
* wxFindWinFromHandle(WXHWND hWnd
);
879 // find the window for HWND which is part of some wxWindow, i.e. unlike
880 // wxFindWinFromHandle() above it will also work for "sub controls" of a
883 // returns the wxWindow corresponding to the given HWND or NULL.
884 extern WXDLLEXPORT wxWindow
*wxGetWindowFromHWND(WXHWND hwnd
);
886 // Get the size of an icon
887 extern WXDLLEXPORT wxSize
wxGetHiconSize(HICON hicon
);
889 // Lines are drawn differently for WinCE and regular WIN32
890 WXDLLEXPORT
void wxDrawLine(HDC hdc
, int x1
, int y1
, int x2
, int y2
);
892 // fill the client rect of the given window on the provided dc using this brush
893 inline void wxFillRect(HWND hwnd
, HDC hdc
, HBRUSH hbr
)
896 ::GetClientRect(hwnd
, &rc
);
897 ::FillRect(hdc
, &rc
, hbr
);
900 // ----------------------------------------------------------------------------
902 // ----------------------------------------------------------------------------
906 inline void *wxGetWindowProc(HWND hwnd
)
908 return (void *)::GetWindowLongPtr(hwnd
, GWLP_WNDPROC
);
911 inline void *wxGetWindowUserData(HWND hwnd
)
913 return (void *)::GetWindowLongPtr(hwnd
, GWLP_USERDATA
);
916 inline WNDPROC
wxSetWindowProc(HWND hwnd
, WNDPROC func
)
918 return (WNDPROC
)::SetWindowLongPtr(hwnd
, GWLP_WNDPROC
, (LONG_PTR
)func
);
921 inline void *wxSetWindowUserData(HWND hwnd
, void *data
)
923 return (void *)::SetWindowLongPtr(hwnd
, GWLP_USERDATA
, (LONG_PTR
)data
);
928 // note that the casts to LONG_PTR here are required even on 32-bit machines
929 // for the 64-bit warning mode of later versions of MSVC (C4311/4312)
930 inline WNDPROC
wxGetWindowProc(HWND hwnd
)
932 return (WNDPROC
)(LONG_PTR
)::GetWindowLong(hwnd
, GWL_WNDPROC
);
935 inline void *wxGetWindowUserData(HWND hwnd
)
937 return (void *)(LONG_PTR
)::GetWindowLong(hwnd
, GWL_USERDATA
);
940 inline WNDPROC
wxSetWindowProc(HWND hwnd
, WNDPROC func
)
942 return (WNDPROC
)(LONG_PTR
)::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG_PTR
)func
);
945 inline void *wxSetWindowUserData(HWND hwnd
, void *data
)
947 return (void *)(LONG_PTR
)::SetWindowLong(hwnd
, GWL_USERDATA
, (LONG_PTR
)data
);
950 #endif // __WIN64__/__WIN32__
954 #endif // _WX_PRIVATE_H_