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"
27 #include "wx/window.h"
30 class WXDLLIMPEXP_FWD_CORE wxFont
;
31 class WXDLLIMPEXP_FWD_CORE wxWindow
;
32 class WXDLLIMPEXP_FWD_CORE wxWindowBase
;
34 // ---------------------------------------------------------------------------
36 // ---------------------------------------------------------------------------
38 // 260 was taken from windef.h
43 // ---------------------------------------------------------------------------
44 // standard icons from the resources
45 // ---------------------------------------------------------------------------
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
;
59 // ---------------------------------------------------------------------------
61 // ---------------------------------------------------------------------------
63 extern WXDLLIMPEXP_DATA_BASE(HINSTANCE
) wxhInstance
;
65 // ---------------------------------------------------------------------------
66 // define things missing from some compilers' headers
67 // ---------------------------------------------------------------------------
69 #if defined(__WXWINCE__) || (defined(__GNUWIN32__) && !wxUSE_NORLANDER_HEADERS)
71 inline void ZeroMemory(void *buf
, size_t len
) { memset(buf
, 0, len
); }
75 // this defines a CASTWNDPROC macro which casts a pointer to the type of a
77 #if defined(STRICT) || defined(__GNUC__)
78 typedef WNDPROC WndProcCast
;
80 typedef FARPROC WndProcCast
;
84 #define CASTWNDPROC (WndProcCast)
88 // ---------------------------------------------------------------------------
89 // some stuff for old Windows versions (FIXME: what does it do here??)
90 // ---------------------------------------------------------------------------
92 #if !defined(APIENTRY) // NT defines APIENTRY, 3.x not
93 #define APIENTRY FAR PASCAL
99 #define _EXPORT _export
103 typedef signed short int SHORT
;
106 #if !defined(__WIN32__) // 3.x uses FARPROC for dialogs
108 #define DLGPROC FARPROC
113 * Decide what window classes we're going to use
114 * for this combination of CTl3D/FAFA settings
117 #define STATIC_CLASS wxT("STATIC")
118 #define STATIC_FLAGS (SS_LEFT|WS_CHILD|WS_VISIBLE)
119 #define CHECK_CLASS wxT("BUTTON")
120 #define CHECK_FLAGS (BS_AUTOCHECKBOX|WS_TABSTOP|WS_CHILD)
121 #define CHECK_IS_FAFA FALSE
122 #define RADIO_CLASS wxT("BUTTON")
123 #define RADIO_FLAGS (BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE)
124 #define RADIO_SIZE 20
125 #define RADIO_IS_FAFA FALSE
127 #define GROUP_CLASS wxT("BUTTON")
128 #define GROUP_FLAGS (BS_GROUPBOX|WS_CHILD|WS_VISIBLE)
131 #define BITCHECK_FLAGS (FB_BITMAP|FC_BUTTONDRAW|FC_DEFAULT|WS_VISIBLE)
132 #define BITRADIO_FLAGS (FC_BUTTONDRAW|FB_BITMAP|FC_RADIO|WS_CHILD|WS_VISIBLE)
135 // ---------------------------------------------------------------------------
137 // ---------------------------------------------------------------------------
139 #define MEANING_CHARACTER '0'
140 #define DEFAULT_ITEM_WIDTH 100
141 #define DEFAULT_ITEM_HEIGHT 80
143 // Scale font to get edit control height
144 //#define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) (3*(cy)/2)
145 #define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) (cy+8)
147 // Generic subclass proc, for panel item moving/sizing and intercept
148 // EDIT control VK_RETURN messages
149 extern LONG APIENTRY _EXPORT
150 wxSubclassedGenericControlProc(WXHWND hWnd
, WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
);
152 // ---------------------------------------------------------------------------
153 // useful macros and functions
154 // ---------------------------------------------------------------------------
156 // a wrapper macro for ZeroMemory()
157 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
158 #define wxZeroMemory(obj) ::ZeroMemory(&obj, sizeof(obj))
160 #define wxZeroMemory(obj) memset((void*) & obj, 0, sizeof(obj))
163 // This one is a macro so that it can be tested with #ifdef, it will be
164 // undefined if it cannot be implemented for a given compiler.
165 // Vc++, bcc, dmc, ow, mingw, codewarrior (and rsxnt) have _get_osfhandle.
166 // Cygwin has get_osfhandle. Others are currently unknown, e.g. Salford,
167 // Intel, Visual Age.
168 #if defined(__WXWINCE__)
169 #define wxGetOSFHandle(fd) ((HANDLE)fd)
170 #define wxOpenOSFHandle(h, flags) ((int)wxPtrToUInt(h))
171 #elif defined(__CYGWIN__)
172 #define wxGetOSFHandle(fd) ((HANDLE)get_osfhandle(fd))
173 #elif defined(__VISUALC__) \
174 || defined(__BORLANDC__) \
175 || defined(__DMC__) \
176 || defined(__WATCOMC__) \
177 || defined(__MINGW32__) \
178 || (defined(__MWERKS__) && defined(__MSL__))
179 #define wxGetOSFHandle(fd) ((HANDLE)_get_osfhandle(fd))
180 #define wxOpenOSFHandle(h, flags) (_open_osfhandle(wxPtrToUInt(h), flags))
181 #define wx_fdopen _fdopen
184 // close the handle in the class dtor
188 wxEXPLICIT
AutoHANDLE(HANDLE handle
) : m_handle(handle
) { }
190 bool IsOk() const { return m_handle
!= INVALID_HANDLE_VALUE
; }
191 operator HANDLE() const { return m_handle
; }
193 ~AutoHANDLE() { if ( IsOk() ) ::CloseHandle(m_handle
); }
199 // a template to make initializing Windows styructs less painful: it zeroes all
200 // the struct fields and also sets cbSize member to the correct value (and so
201 // can be only used with structures which have this member...)
203 struct WinStruct
: public T
207 ::ZeroMemory(this, sizeof(T
));
209 // explicit qualification is required here for this to be valid C++
210 this->cbSize
= sizeof(T
);
217 #include "wx/gdicmn.h"
218 #include "wx/colour.h"
220 // make conversion from wxColour and COLORREF a bit less painful
221 inline COLORREF
wxColourToRGB(const wxColour
& c
)
223 return RGB(c
.Red(), c
.Green(), c
.Blue());
226 inline COLORREF
wxColourToPalRGB(const wxColour
& c
)
228 return PALETTERGB(c
.Red(), c
.Green(), c
.Blue());
231 inline wxColour
wxRGBToColour(COLORREF rgb
)
233 return wxColour(GetRValue(rgb
), GetGValue(rgb
), GetBValue(rgb
));
236 inline void wxRGBToColour(wxColour
& c
, COLORREF rgb
)
238 c
.Set(GetRValue(rgb
), GetGValue(rgb
), GetBValue(rgb
));
241 // get the standard colour map for some standard colours - see comment in this
242 // function to understand why is it needed and when should it be used
244 // it returns a wxCOLORMAP (can't use COLORMAP itself here as comctl32.dll
245 // might be not included/available) array of size wxSTD_COLOUR_MAX
247 // NB: if you change these colours, update wxBITMAP_STD_COLOURS in the
248 // resources as well: it must have the same number of pixels!
254 wxSTD_COL_BTNHIGHLIGHT
,
258 struct WXDLLIMPEXP_CORE wxCOLORMAP
263 // this function is implemented in src/msw/window.cpp
264 extern wxCOLORMAP
*wxGetStdColourMap();
266 // create a wxRect from Windows RECT
267 inline wxRect
wxRectFromRECT(const RECT
& rc
)
269 return wxRect(rc
.left
, rc
.top
, rc
.right
- rc
.left
, rc
.bottom
- rc
.top
);
272 // copy Windows RECT to our wxRect
273 inline void wxCopyRECTToRect(const RECT
& rc
, wxRect
& rect
)
275 rect
= wxRectFromRECT(rc
);
279 inline void wxCopyRectToRECT(const wxRect
& rect
, RECT
& rc
)
281 // note that we don't use wxRect::GetRight() as it is one of compared to
282 // wxRectFromRECT() above
285 rc
.right
= rect
.x
+ rect
.width
;
286 rc
.bottom
= rect
.y
+ rect
.height
;
289 // translations between HIMETRIC units (which OLE likes) and pixels (which are
290 // liked by all the others) - implemented in msw/utilsexc.cpp
291 extern void HIMETRICToPixel(LONG
*x
, LONG
*y
);
292 extern void HIMETRICToPixel(LONG
*x
, LONG
*y
, HDC hdcRef
);
293 extern void PixelToHIMETRIC(LONG
*x
, LONG
*y
);
294 extern void PixelToHIMETRIC(LONG
*x
, LONG
*y
, HDC hdcRef
);
296 // Windows convention of the mask is opposed to the wxWidgets one, so we need
297 // to invert the mask each time we pass one/get one to/from Windows
298 extern HBITMAP
wxInvertMask(HBITMAP hbmpMask
, int w
= 0, int h
= 0);
300 // Creates an icon or cursor depending from a bitmap
302 // The bitmap must be valid and it should have a mask. If it doesn't, a default
303 // mask is created using light grey as the transparent colour.
304 extern HICON
wxBitmapToHICON(const wxBitmap
& bmp
);
306 // Same requirments as above apply and the bitmap must also have the correct
309 HCURSOR
wxBitmapToHCURSOR(const wxBitmap
& bmp
, int hotSpotX
, int hotSpotY
);
312 #if wxUSE_OWNER_DRAWN
314 // Draw the bitmap in specified state (this is used by owner drawn controls)
323 BOOL
wxDrawStateBitmap(HDC hDC
, HBITMAP hBitmap
, int x
, int y
, UINT uState
);
325 #endif // wxUSE_OWNER_DRAWN
327 // get (x, y) from DWORD - notice that HI/LOWORD can *not* be used because they
328 // will fail on system with multiple monitors where the coords may be negative
330 // these macros are standard now (Win98) but some older headers don't have them
332 #define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
333 #define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))
334 #endif // GET_X_LPARAM
336 // get the current state of SHIFT/CTRL/ALT keys
337 inline bool wxIsModifierDown(int vk
)
339 // GetKeyState() returns different negative values on WinME and WinNT,
340 // so simply test for negative value.
341 return ::GetKeyState(vk
) < 0;
344 inline bool wxIsShiftDown()
346 return wxIsModifierDown(VK_SHIFT
);
349 inline bool wxIsCtrlDown()
351 return wxIsModifierDown(VK_CONTROL
);
354 inline bool wxIsAltDown()
356 return wxIsModifierDown(VK_MENU
);
359 inline bool wxIsAnyModifierDown()
361 return wxIsShiftDown() || wxIsCtrlDown() || wxIsAltDown();
364 // wrapper around GetWindowRect() and GetClientRect() APIs doing error checking
366 inline RECT
wxGetWindowRect(HWND hwnd
)
370 if ( !::GetWindowRect(hwnd
, &rect
) )
372 wxLogLastError(wxT("GetWindowRect"));
378 inline RECT
wxGetClientRect(HWND hwnd
)
382 if ( !::GetClientRect(hwnd
, &rect
) )
384 wxLogLastError(wxT("GetClientRect"));
390 // ---------------------------------------------------------------------------
391 // small helper classes
392 // ---------------------------------------------------------------------------
394 // create an instance of this class and use it as the HDC for screen, will
395 // automatically release the DC going out of scope
399 ScreenHDC() { m_hdc
= ::GetDC(NULL
); }
400 ~ScreenHDC() { ::ReleaseDC(NULL
, m_hdc
); }
402 operator HDC() const { return m_hdc
; }
407 wxDECLARE_NO_COPY_CLASS(ScreenHDC
);
410 // the same as ScreenHDC but for window DCs
414 WindowHDC(HWND hwnd
) { m_hdc
= ::GetDC(m_hwnd
= hwnd
); }
415 ~WindowHDC() { ::ReleaseDC(m_hwnd
, m_hdc
); }
417 operator HDC() const { return m_hdc
; }
423 wxDECLARE_NO_COPY_CLASS(WindowHDC
);
426 // the same as ScreenHDC but for memory DCs: creates the HDC compatible with
427 // the given one (screen by default) in ctor and destroys it in dtor
431 MemoryHDC(HDC hdc
= 0) { m_hdc
= ::CreateCompatibleDC(hdc
); }
432 ~MemoryHDC() { ::DeleteDC(m_hdc
); }
434 operator HDC() const { return m_hdc
; }
439 wxDECLARE_NO_COPY_CLASS(MemoryHDC
);
442 // a class which selects a GDI object into a DC in its ctor and deselects in
447 void DoInit(HGDIOBJ hgdiobj
) { m_hgdiobj
= ::SelectObject(m_hdc
, hgdiobj
); }
450 SelectInHDC() : m_hdc(NULL
) { }
451 SelectInHDC(HDC hdc
, HGDIOBJ hgdiobj
) : m_hdc(hdc
) { DoInit(hgdiobj
); }
453 void Init(HDC hdc
, HGDIOBJ hgdiobj
)
455 wxASSERT_MSG( !m_hdc
, wxT("initializing twice?") );
462 ~SelectInHDC() { if ( m_hdc
) ::SelectObject(m_hdc
, m_hgdiobj
); }
464 // return true if the object was successfully selected
465 operator bool() const { return m_hgdiobj
!= 0; }
471 wxDECLARE_NO_COPY_CLASS(SelectInHDC
);
474 // a class which cleans up any GDI object
478 AutoGDIObject() { m_gdiobj
= NULL
; }
479 AutoGDIObject(HGDIOBJ gdiobj
) : m_gdiobj(gdiobj
) { }
480 ~AutoGDIObject() { if ( m_gdiobj
) ::DeleteObject(m_gdiobj
); }
482 void InitGdiobj(HGDIOBJ gdiobj
)
484 wxASSERT_MSG( !m_gdiobj
, wxT("initializing twice?") );
489 HGDIOBJ
GetObject() const { return m_gdiobj
; }
495 // TODO: all this asks for using a AutoHandler<T, CreateFunc> template...
497 // a class for temporary brushes
498 class AutoHBRUSH
: private AutoGDIObject
501 AutoHBRUSH(COLORREF col
)
502 : AutoGDIObject(::CreateSolidBrush(col
)) { }
504 operator HBRUSH() const { return (HBRUSH
)GetObject(); }
507 // a class for temporary fonts
508 class AutoHFONT
: private AutoGDIObject
513 : AutoGDIObject() { }
515 AutoHFONT(const LOGFONT
& lf
)
516 : AutoGDIObject(::CreateFontIndirect(&lf
)) { }
518 void Init(const LOGFONT
& lf
) { InitGdiobj(::CreateFontIndirect(&lf
)); }
520 operator HFONT() const { return (HFONT
)GetObject(); }
523 // a class for temporary pens
524 class AutoHPEN
: private AutoGDIObject
527 AutoHPEN(COLORREF col
)
528 : AutoGDIObject(::CreatePen(PS_SOLID
, 0, col
)) { }
530 operator HPEN() const { return (HPEN
)GetObject(); }
533 // classes for temporary bitmaps
534 class AutoHBITMAP
: private AutoGDIObject
537 AutoHBITMAP(HBITMAP hbmp
) : AutoGDIObject(hbmp
) { }
539 operator HBITMAP() const { return (HBITMAP
)GetObject(); }
542 class CompatibleBitmap
: public AutoHBITMAP
545 CompatibleBitmap(HDC hdc
, int w
, int h
)
546 : AutoHBITMAP(::CreateCompatibleBitmap(hdc
, w
, h
))
551 class MonoBitmap
: public AutoHBITMAP
554 MonoBitmap(int w
, int h
)
555 : AutoHBITMAP(::CreateBitmap(w
, h
, 1, 1, 0))
560 // class automatically destroys the region object
561 class AutoHRGN
: private AutoGDIObject
564 AutoHRGN(HRGN hrgn
) : AutoGDIObject(hrgn
) { }
566 operator HRGN() const { return (HRGN
)GetObject(); }
569 // class sets the specified clipping region during its life time
573 HDCClipper(HDC hdc
, HRGN hrgn
)
576 if ( !::SelectClipRgn(hdc
, hrgn
) )
578 wxLogLastError(wxT("SelectClipRgn"));
584 ::SelectClipRgn(m_hdc
, NULL
);
590 wxDECLARE_NO_COPY_CLASS(HDCClipper
);
593 // set the given map mode for the life time of this object
595 // NB: SetMapMode() is not supported by CE so we also define a helper macro
596 // to avoid using it there
598 #define wxCHANGE_HDC_MAP_MODE(hdc, mm)
599 #else // !__WXWINCE__
600 class HDCMapModeChanger
603 HDCMapModeChanger(HDC hdc
, int mm
)
606 m_modeOld
= ::SetMapMode(hdc
, mm
);
609 wxLogLastError(wxT("SelectClipRgn"));
616 ::SetMapMode(m_hdc
, m_modeOld
);
623 wxDECLARE_NO_COPY_CLASS(HDCMapModeChanger
);
626 #define wxCHANGE_HDC_MAP_MODE(hdc, mm) \
627 HDCMapModeChanger wxMAKE_UNIQUE_NAME(wxHDCMapModeChanger)(hdc, mm)
628 #endif // __WXWINCE__/!__WXWINCE__
630 // smart pointer using GlobalAlloc/GlobalFree()
634 // default ctor, call Init() later
640 // allocates a block of given size
641 void Init(size_t size
, unsigned flags
= GMEM_MOVEABLE
)
643 m_hGlobal
= ::GlobalAlloc(flags
, size
);
646 wxLogLastError(wxT("GlobalAlloc"));
650 GlobalPtr(size_t size
, unsigned flags
= GMEM_MOVEABLE
)
657 if ( m_hGlobal
&& ::GlobalFree(m_hGlobal
) )
659 wxLogLastError(wxT("GlobalFree"));
663 // implicit conversion
664 operator HGLOBAL() const { return m_hGlobal
; }
669 wxDECLARE_NO_COPY_CLASS(GlobalPtr
);
672 // when working with global pointers (which is unfortunately still necessary
673 // sometimes, e.g. for clipboard) it is important to unlock them exactly as
674 // many times as we lock them which just asks for using a "smart lock" class
678 // default ctor, use Init() later -- should only be used if the HGLOBAL can
679 // be NULL (in which case Init() shouldn't be called)
686 // initialize the object, may be only called if we were created using the
687 // default ctor; HGLOBAL must not be NULL
688 void Init(HGLOBAL hGlobal
)
692 // NB: GlobalLock() is a macro, not a function, hence don't use the
693 // global scope operator with it (and neither with GlobalUnlock())
694 m_ptr
= GlobalLock(hGlobal
);
697 wxLogLastError(wxT("GlobalLock"));
701 // initialize the object, HGLOBAL must not be NULL
702 GlobalPtrLock(HGLOBAL hGlobal
)
709 if ( m_hGlobal
&& !GlobalUnlock(m_hGlobal
) )
711 // this might happen simply because the block became unlocked
712 DWORD dwLastError
= ::GetLastError();
713 if ( dwLastError
!= NO_ERROR
)
715 wxLogApiError(wxT("GlobalUnlock"), dwLastError
);
720 void *Get() const { return m_ptr
; }
721 operator void *() const { return m_ptr
; }
727 wxDECLARE_NO_COPY_CLASS(GlobalPtrLock
);
730 // smart pointer like class using OpenPrinter and ClosePrinter
737 m_hPrinter
= (HANDLE
)NULL
;
740 WinPrinter( const wxString
& printerName
)
750 BOOL
Open( const wxString
& printerName
, LPPRINTER_DEFAULTS pDefault
=(LPPRINTER_DEFAULTS
)NULL
)
753 return OpenPrinter( (LPTSTR
)printerName
.wx_str(), &m_hPrinter
, pDefault
);
761 result
= ClosePrinter( m_hPrinter
);
762 m_hPrinter
= (HANDLE
)NULL
;
767 operator HANDLE() { return m_hPrinter
; }
768 operator bool() { return m_hPrinter
!= (HANDLE
)NULL
; }
773 wxDECLARE_NO_COPY_CLASS(WinPrinter
);
776 // register the class when it is first needed and unregister it in dtor
780 // ctor doesn't register the class, call Initialize() for this
781 ClassRegistrar() { m_registered
= -1; }
783 // return true if the class is already registered
784 bool IsInitialized() const { return m_registered
!= -1; }
786 // return true if the class had been already registered
787 bool IsRegistered() const { return m_registered
== 1; }
789 // try to register the class if not done yet, return true on success
790 bool Register(const WNDCLASS
& wc
)
792 // we should only be called if we hadn't been initialized yet
793 wxASSERT_MSG( m_registered
== -1,
794 wxT("calling ClassRegistrar::Register() twice?") );
796 m_registered
= ::RegisterClass(&wc
) ? 1 : 0;
797 if ( !IsRegistered() )
799 wxLogLastError(wxT("RegisterClassEx()"));
803 m_clsname
= wc
.lpszClassName
;
806 return m_registered
== 1;
809 // get the name of the registered class (returns empty string if not
811 const wxString
& GetName() const { return m_clsname
; }
813 // unregister the class if it had been registered
816 if ( IsRegistered() )
818 if ( !::UnregisterClass(m_clsname
.wx_str(), wxhInstance
) )
820 wxLogLastError(wxT("UnregisterClass"));
826 // initial value is -1 which means that we hadn't tried registering the
827 // class yet, it becomes true or false (1 or 0) when Initialize() is called
830 // the name of the class, only non empty if it had been registered
834 // ---------------------------------------------------------------------------
835 // macros to make casting between WXFOO and FOO a bit easier: the GetFoo()
836 // returns Foo cast to the Windows type for oruselves, while GetFooOf() takes
837 // an argument which should be a pointer or reference to the object of the
838 // corresponding class (this depends on the macro)
839 // ---------------------------------------------------------------------------
841 #define GetHwnd() ((HWND)GetHWND())
842 #define GetHwndOf(win) ((HWND)((win)->GetHWND()))
844 #define GetWinHwnd GetHwndOf
846 #define GetHdc() ((HDC)GetHDC())
847 #define GetHdcOf(dc) ((HDC)(dc).GetHDC())
849 #define GetHbitmap() ((HBITMAP)GetHBITMAP())
850 #define GetHbitmapOf(bmp) ((HBITMAP)(bmp).GetHBITMAP())
852 #define GetHicon() ((HICON)GetHICON())
853 #define GetHiconOf(icon) ((HICON)(icon).GetHICON())
855 #define GetHaccel() ((HACCEL)GetHACCEL())
856 #define GetHaccelOf(table) ((HACCEL)((table).GetHACCEL()))
858 #define GetHbrush() ((HBRUSH)GetResourceHandle())
859 #define GetHbrushOf(brush) ((HBRUSH)(brush).GetResourceHandle())
861 #define GetHmenu() ((HMENU)GetHMenu())
862 #define GetHmenuOf(menu) ((HMENU)(menu)->GetHMenu())
864 #define GetHcursor() ((HCURSOR)GetHCURSOR())
865 #define GetHcursorOf(cursor) ((HCURSOR)(cursor).GetHCURSOR())
867 #define GetHfont() ((HFONT)GetHFONT())
868 #define GetHfontOf(font) ((HFONT)(font).GetHFONT())
870 #define GetHimagelist() ((HIMAGELIST)GetHIMAGELIST())
871 #define GetHimagelistOf(imgl) ((HIMAGELIST)(imgl)->GetHIMAGELIST())
873 #define GetHpalette() ((HPALETTE)GetHPALETTE())
874 #define GetHpaletteOf(pal) ((HPALETTE)(pal).GetHPALETTE())
876 #define GetHpen() ((HPEN)GetResourceHandle())
877 #define GetHpenOf(pen) ((HPEN)(pen).GetResourceHandle())
879 #define GetHrgn() ((HRGN)GetHRGN())
880 #define GetHrgnOf(rgn) ((HRGN)(rgn).GetHRGN())
884 // ---------------------------------------------------------------------------
886 // ---------------------------------------------------------------------------
890 WXDLLIMPEXP_BASE HINSTANCE
wxGetInstance();
893 WXDLLIMPEXP_BASE
void wxSetInstance(HINSTANCE hInst
);
895 // return the full path of the given module
896 inline wxString
wxGetFullModuleName(HMODULE hmod
)
899 if ( !::GetModuleFileName
902 wxStringBuffer(fullname
, MAX_PATH
),
906 wxLogLastError(wxT("GetModuleFileName"));
912 // return the full path of the program file
913 inline wxString
wxGetFullModuleName()
915 return wxGetFullModuleName((HMODULE
)wxGetInstance());
918 // return the run-time version of the OS in a format similar to
919 // WINVER/_WIN32_WINNT compile-time macros:
921 // 0x0300 Windows NT 3.51
922 // 0x0400 Windows 95, NT4
924 // 0x0500 Windows ME, 2000
926 // 0x0502 Windows 2003
929 // for the other Windows versions 0 is currently returned
932 wxWinVersion_Unknown
= 0,
934 wxWinVersion_3
= 0x0300,
935 wxWinVersion_NT3
= wxWinVersion_3
,
937 wxWinVersion_4
= 0x0400,
938 wxWinVersion_95
= wxWinVersion_4
,
939 wxWinVersion_NT4
= wxWinVersion_4
,
940 wxWinVersion_98
= 0x0410,
942 wxWinVersion_5
= 0x0500,
943 wxWinVersion_ME
= wxWinVersion_5
,
944 wxWinVersion_NT5
= wxWinVersion_5
,
945 wxWinVersion_2000
= wxWinVersion_5
,
946 wxWinVersion_XP
= 0x0501,
947 wxWinVersion_2003
= 0x0502,
949 wxWinVersion_6
= 0x0600,
950 wxWinVersion_Vista
= wxWinVersion_6
,
951 wxWinVersion_NT6
= wxWinVersion_6
954 WXDLLIMPEXP_BASE wxWinVersion
wxGetWinVersion();
959 extern HCURSOR
wxGetCurrentBusyCursor(); // from msw/utils.cpp
960 extern const wxCursor
*wxGetGlobalCursor(); // from msw/cursor.cpp
962 WXDLLIMPEXP_CORE
void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
);
963 WXDLLIMPEXP_CORE
void wxFillLogFont(LOGFONT
*logFont
, const wxFont
*font
);
964 WXDLLIMPEXP_CORE wxFont
wxCreateFontFromLogFont(const LOGFONT
*logFont
);
965 WXDLLIMPEXP_CORE wxFontEncoding
wxGetFontEncFromCharSet(int charset
);
967 WXDLLIMPEXP_CORE
void wxSliderEvent(WXHWND control
, WXWORD wParam
, WXWORD pos
);
968 WXDLLIMPEXP_CORE
void wxScrollBarEvent(WXHWND hbar
, WXWORD wParam
, WXWORD pos
);
970 // Find maximum size of window/rectangle
971 extern WXDLLIMPEXP_CORE
void wxFindMaxSize(WXHWND hwnd
, RECT
*rect
);
973 // Safely get the window text (i.e. without using fixed size buffer)
974 extern WXDLLIMPEXP_CORE wxString
wxGetWindowText(WXHWND hWnd
);
976 // get the window class name
977 extern WXDLLIMPEXP_CORE wxString
wxGetWindowClass(WXHWND hWnd
);
979 // get the window id (should be unsigned, hence this is not wxWindowID which
980 // is, for mainly historical reasons, signed)
981 extern WXDLLIMPEXP_CORE
int wxGetWindowId(WXHWND hWnd
);
983 // check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
985 extern WXDLLIMPEXP_CORE
bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
);
987 // Does this window style specify any border?
988 inline bool wxStyleHasBorder(long style
)
990 return (style
& (wxSIMPLE_BORDER
| wxRAISED_BORDER
|
991 wxSUNKEN_BORDER
| wxDOUBLE_BORDER
)) != 0;
994 inline long wxGetWindowExStyle(const wxWindowMSW
*win
)
996 return ::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
);
999 inline bool wxHasWindowExStyle(const wxWindowMSW
*win
, long style
)
1001 return (wxGetWindowExStyle(win
) & style
) != 0;
1004 inline long wxSetWindowExStyle(const wxWindowMSW
*win
, long style
)
1006 return ::SetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
, style
);
1009 // ----------------------------------------------------------------------------
1010 // functions mapping HWND to wxWindow
1011 // ----------------------------------------------------------------------------
1013 // this function simply checks whether the given hwnd corresponds to a wxWindow
1014 // and returns either that window if it does or NULL otherwise
1015 extern WXDLLIMPEXP_CORE wxWindow
* wxFindWinFromHandle(HWND hwnd
);
1017 // without STRICT WXHWND is the same as HWND anyhow
1018 inline wxWindow
* wxFindWinFromHandle(WXHWND hWnd
)
1020 return wxFindWinFromHandle(static_cast<HWND
>(hWnd
));
1023 // find the window for HWND which is part of some wxWindow, i.e. unlike
1024 // wxFindWinFromHandle() above it will also work for "sub controls" of a
1027 // returns the wxWindow corresponding to the given HWND or NULL.
1028 extern WXDLLIMPEXP_CORE wxWindow
*wxGetWindowFromHWND(WXHWND hwnd
);
1030 // Get the size of an icon
1031 extern WXDLLIMPEXP_CORE wxSize
wxGetHiconSize(HICON hicon
);
1033 // Lines are drawn differently for WinCE and regular WIN32
1034 WXDLLIMPEXP_CORE
void wxDrawLine(HDC hdc
, int x1
, int y1
, int x2
, int y2
);
1036 // fill the client rect of the given window on the provided dc using this brush
1037 inline void wxFillRect(HWND hwnd
, HDC hdc
, HBRUSH hbr
)
1040 ::GetClientRect(hwnd
, &rc
);
1041 ::FillRect(hdc
, &rc
, hbr
);
1044 // ----------------------------------------------------------------------------
1045 // 32/64 bit helpers
1046 // ----------------------------------------------------------------------------
1050 inline void *wxGetWindowProc(HWND hwnd
)
1052 return (void *)::GetWindowLongPtr(hwnd
, GWLP_WNDPROC
);
1055 inline void *wxGetWindowUserData(HWND hwnd
)
1057 return (void *)::GetWindowLongPtr(hwnd
, GWLP_USERDATA
);
1060 inline WNDPROC
wxSetWindowProc(HWND hwnd
, WNDPROC func
)
1062 return (WNDPROC
)::SetWindowLongPtr(hwnd
, GWLP_WNDPROC
, (LONG_PTR
)func
);
1065 inline void *wxSetWindowUserData(HWND hwnd
, void *data
)
1067 return (void *)::SetWindowLongPtr(hwnd
, GWLP_USERDATA
, (LONG_PTR
)data
);
1072 // note that the casts to LONG_PTR here are required even on 32-bit machines
1073 // for the 64-bit warning mode of later versions of MSVC (C4311/4312)
1074 inline WNDPROC
wxGetWindowProc(HWND hwnd
)
1076 return (WNDPROC
)(LONG_PTR
)::GetWindowLong(hwnd
, GWL_WNDPROC
);
1079 inline void *wxGetWindowUserData(HWND hwnd
)
1081 return (void *)(LONG_PTR
)::GetWindowLong(hwnd
, GWL_USERDATA
);
1084 inline WNDPROC
wxSetWindowProc(HWND hwnd
, WNDPROC func
)
1086 return (WNDPROC
)(LONG_PTR
)::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG_PTR
)func
);
1089 inline void *wxSetWindowUserData(HWND hwnd
, void *data
)
1091 return (void *)(LONG_PTR
)::SetWindowLong(hwnd
, GWL_USERDATA
, (LONG_PTR
)data
);
1094 #endif // __WIN64__/__WIN32__
1098 #endif // _WX_PRIVATE_H_