1 /////////////////////////////////////////////////////////////////////////////
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"
24 // Include fixes for MSLU:
25 #include "wx/msw/mslu.h"
29 class WXDLLEXPORT wxFont
;
30 class WXDLLEXPORT wxWindow
;
31 class WXDLLEXPORT wxWindowBase
;
33 // ---------------------------------------------------------------------------
35 // ---------------------------------------------------------------------------
37 // 260 was taken from windef.h
42 // ---------------------------------------------------------------------------
43 // standard icons from the resources
44 // ---------------------------------------------------------------------------
48 extern WXDLLEXPORT_DATA(HICON
) wxSTD_FRAME_ICON
;
49 extern WXDLLEXPORT_DATA(HICON
) wxSTD_MDIPARENTFRAME_ICON
;
50 extern WXDLLEXPORT_DATA(HICON
) wxSTD_MDICHILDFRAME_ICON
;
51 extern WXDLLEXPORT_DATA(HICON
) wxDEFAULT_FRAME_ICON
;
52 extern WXDLLEXPORT_DATA(HICON
) wxDEFAULT_MDIPARENTFRAME_ICON
;
53 extern WXDLLEXPORT_DATA(HICON
) wxDEFAULT_MDICHILDFRAME_ICON
;
54 extern WXDLLEXPORT_DATA(HFONT
) wxSTATUS_LINE_FONT
;
58 // ---------------------------------------------------------------------------
60 // ---------------------------------------------------------------------------
62 extern WXDLLIMPEXP_DATA_BASE(HINSTANCE
) wxhInstance
;
64 // ---------------------------------------------------------------------------
65 // define things missing from some compilers' headers
66 // ---------------------------------------------------------------------------
68 #if defined(__WXWINCE__) || (defined(__GNUWIN32__) && !wxUSE_NORLANDER_HEADERS)
70 inline void ZeroMemory(void *buf
, size_t len
) { memset(buf
, 0, len
); }
74 // this defines a CASTWNDPROC macro which casts a pointer to the type of a
76 #if defined(STRICT) || defined(__GNUC__)
77 typedef WNDPROC WndProcCast
;
79 typedef FARPROC WndProcCast
;
83 #define CASTWNDPROC (WndProcCast)
87 // ---------------------------------------------------------------------------
88 // some stuff for old Windows versions (FIXME: what does it do here??)
89 // ---------------------------------------------------------------------------
91 #if !defined(APIENTRY) // NT defines APIENTRY, 3.x not
92 #define APIENTRY FAR PASCAL
98 #define _EXPORT _export
102 typedef signed short int SHORT
;
105 #if !defined(__WIN32__) // 3.x uses FARPROC for dialogs
107 #define DLGPROC FARPROC
112 WXDLLEXPORT
void wxRegisterPenWin();
113 WXDLLEXPORT
void wxCleanUpPenWin();
114 WXDLLEXPORT
void wxEnablePenAppHooks (bool hook
);
115 #endif // wxUSE_PENWIN
118 #define IBS_HORZCAPTION 0x4000L
119 #define IBS_VERTCAPTION 0x8000L
121 UINT WINAPI
ibGetCaptionSize( HWND hWnd
) ;
122 UINT WINAPI
ibSetCaptionSize( HWND hWnd
, UINT nSize
) ;
123 LRESULT WINAPI
ibDefWindowProc( HWND hWnd
, UINT uiMsg
, WPARAM wParam
, LPARAM lParam
) ;
124 VOID WINAPI
ibAdjustWindowRect( HWND hWnd
, LPRECT lprc
) ;
125 #endif // wxUSE_ITSY_BITSY
128 * Decide what window classes we're going to use
129 * for this combination of CTl3D/FAFA settings
132 #define STATIC_CLASS wxT("STATIC")
133 #define STATIC_FLAGS (SS_LEFT|WS_CHILD|WS_VISIBLE)
134 #define CHECK_CLASS wxT("BUTTON")
135 #define CHECK_FLAGS (BS_AUTOCHECKBOX|WS_TABSTOP|WS_CHILD)
136 #define CHECK_IS_FAFA FALSE
137 #define RADIO_CLASS wxT("BUTTON")
138 #define RADIO_FLAGS (BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE)
139 #define RADIO_SIZE 20
140 #define RADIO_IS_FAFA FALSE
142 #define GROUP_CLASS wxT("BUTTON")
143 #define GROUP_FLAGS (BS_GROUPBOX|WS_CHILD|WS_VISIBLE)
146 #define BITCHECK_FLAGS (FB_BITMAP|FC_BUTTONDRAW|FC_DEFAULT|WS_VISIBLE)
147 #define BITRADIO_FLAGS (FC_BUTTONDRAW|FB_BITMAP|FC_RADIO|WS_CHILD|WS_VISIBLE)
150 // ---------------------------------------------------------------------------
152 // ---------------------------------------------------------------------------
154 #define MEANING_CHARACTER '0'
155 #define DEFAULT_ITEM_WIDTH 100
156 #define DEFAULT_ITEM_HEIGHT 80
158 // Scale font to get edit control height
159 //#define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) (3*(cy)/2)
160 #define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) (cy+8)
162 // Generic subclass proc, for panel item moving/sizing and intercept
163 // EDIT control VK_RETURN messages
164 extern LONG APIENTRY _EXPORT
165 wxSubclassedGenericControlProc(WXHWND hWnd
, WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
);
167 // ---------------------------------------------------------------------------
168 // useful macros and functions
169 // ---------------------------------------------------------------------------
171 // a wrapper macro for ZeroMemory()
172 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
173 #define wxZeroMemory(obj) ::ZeroMemory(&obj, sizeof(obj))
175 #define wxZeroMemory(obj) memset((void*) & obj, 0, sizeof(obj))
178 // This one is a macro so that it can be tested with #ifdef, it will be
179 // undefined if it cannot be implemented for a given compiler.
180 // Vc++, bcc, dmc, ow, mingw, codewarrior (and rsxnt) have _get_osfhandle.
181 // Cygwin has get_osfhandle. Others are currently unknown, e.g. Salford,
182 // Intel, Visual Age.
183 #if defined(__WXWINCE__)
184 #define wxGetOSFHandle(fd) ((HANDLE)fd)
185 #elif defined(__CYGWIN__)
186 #define wxGetOSFHandle(fd) ((HANDLE)get_osfhandle(fd))
187 #elif defined(__VISUALC__) \
188 || defined(__BORLANDC__) \
189 || defined(__DMC__) \
190 || defined(__WATCOMC__) \
191 || defined(__MINGW32__) \
192 || (defined(__MWERKS__) && defined(__MSL__))
193 #define wxGetOSFHandle(fd) ((HANDLE)_get_osfhandle(fd))
198 #include <wx/gdicmn.h>
199 #include <wx/colour.h>
201 // make conversion from wxColour and COLORREF a bit less painful
202 inline COLORREF
wxColourToRGB(const wxColour
& c
)
204 return RGB(c
.Red(), c
.Green(), c
.Blue());
207 inline COLORREF
wxColourToPalRGB(const wxColour
& c
)
209 return PALETTERGB(c
.Red(), c
.Green(), c
.Blue());
212 inline wxColour
wxRGBToColour(COLORREF rgb
)
214 return wxColour(GetRValue(rgb
), GetGValue(rgb
), GetBValue(rgb
));
217 inline void wxRGBToColour(wxColour
& c
, COLORREF rgb
)
219 c
.Set(GetRValue(rgb
), GetGValue(rgb
), GetBValue(rgb
));
222 // get the standard colour map for some standard colours - see comment in this
223 // function to understand why is it needed and when should it be used
225 // it returns a wxCOLORMAP (can't use COLORMAP itself here as comctl32.dll
226 // might be not included/available) array of size wxSTD_COLOUR_MAX
228 // NB: if you change these colours, update wxBITMAP_STD_COLOURS in the
229 // resources as well: it must have the same number of pixels!
235 wxSTD_COL_BTNHIGHLIGHT
,
239 struct WXDLLEXPORT wxCOLORMAP
244 // this function is implemented in src/msw/window.cpp
245 extern wxCOLORMAP
*wxGetStdColourMap();
247 // create a wxRect from Windows RECT
248 inline wxRect
wxRectFromRECT(const RECT
& rc
)
250 return wxRect(rc
.left
, rc
.top
, rc
.right
- rc
.left
, rc
.bottom
- rc
.top
);
253 // copy Windows RECT to our wxRect
254 inline void wxCopyRECTToRect(const RECT
& rc
, wxRect
& rect
)
256 rect
= wxRectFromRECT(rc
);
260 inline void wxCopyRectToRECT(const wxRect
& rect
, RECT
& rc
)
262 // note that we don't use wxRect::GetRight() as it is one of compared to
263 // wxRectFromRECT() above
266 rc
.right
= rect
.x
+ rect
.width
;
267 rc
.bottom
= rect
.y
+ rect
.height
;
270 // translations between HIMETRIC units (which OLE likes) and pixels (which are
271 // liked by all the others) - implemented in msw/utilsexc.cpp
272 extern void HIMETRICToPixel(LONG
*x
, LONG
*y
);
273 extern void PixelToHIMETRIC(LONG
*x
, LONG
*y
);
275 // Windows convention of the mask is opposed to the wxWidgets one, so we need
276 // to invert the mask each time we pass one/get one to/from Windows
277 extern HBITMAP
wxInvertMask(HBITMAP hbmpMask
, int w
= 0, int h
= 0);
279 // Creates an icon or cursor depending from a bitmap
281 // The bitmap must be valid and it should have a mask. If it doesn't, a default
282 // mask is created using light grey as the transparent colour.
283 extern HICON
wxBitmapToHICON(const wxBitmap
& bmp
);
285 // Same requirments as above apply and the bitmap must also have the correct
288 HCURSOR
wxBitmapToHCURSOR(const wxBitmap
& bmp
, int hotSpotX
, int hotSpotY
);
290 // get (x, y) from DWORD - notice that HI/LOWORD can *not* be used because they
291 // will fail on system with multiple monitors where the coords may be negative
293 // these macros are standard now (Win98) but some older headers don't have them
295 #define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
296 #define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))
297 #endif // GET_X_LPARAM
299 // get the current state of SHIFT/CTRL keys
300 inline bool wxIsShiftDown()
302 // return (::GetKeyState(VK_SHIFT) & 0x100) != 0;
303 // Returns different negative values on WinME and WinNT,
304 // so simply test for negative value.
305 return ::GetKeyState(VK_SHIFT
) < 0;
308 inline bool wxIsCtrlDown()
310 // return (::GetKeyState(VK_CONTROL) & 0x100) != 0;
311 // Returns different negative values on WinME and WinNT,
312 // so simply test for negative value.
313 return ::GetKeyState(VK_CONTROL
) < 0;
316 // wrapper around GetWindowRect() and GetClientRect() APIs doing error checking
318 inline RECT
wxGetWindowRect(HWND hwnd
)
322 if ( !::GetWindowRect(hwnd
, &rect
) )
324 wxLogLastError(_T("GetWindowRect"));
330 inline RECT
wxGetClientRect(HWND hwnd
)
334 if ( !::GetClientRect(hwnd
, &rect
) )
336 wxLogLastError(_T("GetClientRect"));
342 // ---------------------------------------------------------------------------
343 // small helper classes
344 // ---------------------------------------------------------------------------
346 // a template to make initializing Windows styructs less painful: it zeroes all
347 // the struct fields and also sets cbSize member to the correct value (and so
348 // can be only used with structures which have this member...)
350 struct WinStruct
: public T
354 ::ZeroMemory(this, sizeof(T
));
356 // explicit qualification is required here for this to be valid C++
357 this->cbSize
= sizeof(T
);
362 // create an instance of this class and use it as the HDC for screen, will
363 // automatically release the DC going out of scope
367 ScreenHDC() { m_hdc
= ::GetDC(NULL
); }
368 ~ScreenHDC() { ::ReleaseDC(NULL
, m_hdc
); }
370 operator HDC() const { return m_hdc
; }
375 DECLARE_NO_COPY_CLASS(ScreenHDC
)
378 // the same as ScreenHDC but for window DCs
382 WindowHDC(HWND hwnd
) { m_hdc
= ::GetDC(m_hwnd
= hwnd
); }
383 ~WindowHDC() { ::ReleaseDC(m_hwnd
, m_hdc
); }
385 operator HDC() const { return m_hdc
; }
391 DECLARE_NO_COPY_CLASS(WindowHDC
)
394 // the same as ScreenHDC but for memory DCs: creates the HDC compatible with
395 // the given one (screen by default) in ctor and destroys it in dtor
399 MemoryHDC(HDC hdc
= 0) { m_hdc
= ::CreateCompatibleDC(hdc
); }
400 ~MemoryHDC() { ::DeleteDC(m_hdc
); }
402 operator HDC() const { return m_hdc
; }
407 DECLARE_NO_COPY_CLASS(MemoryHDC
)
410 // a class which selects a GDI object into a DC in its ctor and deselects in
415 SelectInHDC(HDC hdc
, HGDIOBJ hgdiobj
) : m_hdc(hdc
)
416 { m_hgdiobj
= ::SelectObject(hdc
, hgdiobj
); }
418 ~SelectInHDC() { ::SelectObject(m_hdc
, m_hgdiobj
); }
420 // return true if the object was successfully selected
421 operator bool() const { return m_hgdiobj
!= 0; }
427 DECLARE_NO_COPY_CLASS(SelectInHDC
)
430 // a class which cleans up any GDI object
434 AutoGDIObject(HGDIOBJ gdiobj
) : m_gdiobj(gdiobj
) { }
435 ~AutoGDIObject() { if ( m_gdiobj
) ::DeleteObject(m_gdiobj
); }
437 HGDIOBJ
GetObject() const { return m_gdiobj
; }
443 // TODO: all this asks for using a AutoHandler<T, CreateFunc> template...
445 // a class for temporary pens
446 class AutoHBRUSH
: private AutoGDIObject
449 AutoHBRUSH(COLORREF col
)
450 : AutoGDIObject(::CreateSolidBrush(col
)) { }
452 operator HBRUSH() const { return (HBRUSH
)GetObject(); }
455 // a class for temporary pens
456 class AutoHPEN
: private AutoGDIObject
459 AutoHPEN(COLORREF col
)
460 : AutoGDIObject(::CreatePen(PS_SOLID
, 0, col
)) { }
462 operator HPEN() const { return (HPEN
)GetObject(); }
465 // classes for temporary bitmaps
466 class AutoHBITMAP
: private AutoGDIObject
469 AutoHBITMAP(HBITMAP hbmp
) : AutoGDIObject(hbmp
) { }
471 operator HBITMAP() const { return (HBITMAP
)GetObject(); }
474 class CompatibleBitmap
: public AutoHBITMAP
477 CompatibleBitmap(HDC hdc
, int w
, int h
)
478 : AutoHBITMAP(::CreateCompatibleBitmap(hdc
, w
, h
))
483 class MonoBitmap
: public AutoHBITMAP
486 MonoBitmap(int w
, int h
)
487 : AutoHBITMAP(::CreateBitmap(w
, h
, 1, 1, 0))
492 // class automatically destroys the region object
493 class AutoHRGN
: private AutoGDIObject
496 AutoHRGN(HRGN hrgn
) : AutoGDIObject(hrgn
) { }
498 operator HRGN() const { return (HRGN
)GetObject(); }
501 // class sets the specified clipping region during its life time
505 HDCClipper(HDC hdc
, HRGN hrgn
)
508 if ( !::SelectClipRgn(hdc
, hrgn
) )
509 wxLogLastError(_T("SelectClipRgn"));
514 ::SelectClipRgn(m_hdc
, NULL
);
520 DECLARE_NO_COPY_CLASS(HDCClipper
)
523 // when working with global pointers (which is unfortunately still necessary
524 // sometimes, e.g. for clipboard) it is important to unlock them exactly as
525 // many times as we lock them which just asks for using a "smart lock" class
529 GlobalPtr(HGLOBAL hGlobal
) : m_hGlobal(hGlobal
)
531 m_ptr
= GlobalLock(hGlobal
);
534 wxLogLastError(_T("GlobalLock"));
540 if ( !GlobalUnlock(m_hGlobal
) )
543 // this might happen simply because the block became unlocked
544 DWORD dwLastError
= ::GetLastError();
545 if ( dwLastError
!= NO_ERROR
)
547 wxLogApiError(_T("GlobalUnlock"), dwLastError
);
549 #endif // __WXDEBUG__
553 operator void *() const { return m_ptr
; }
559 DECLARE_NO_COPY_CLASS(GlobalPtr
)
562 // register the class when it is first needed and unregister it in dtor
566 // ctor doesn't register the class, call Initialize() for this
567 ClassRegistrar() { m_registered
= -1; }
569 // return true if the class is already registered
570 bool IsInitialized() const { return m_registered
!= -1; }
572 // return true if the class had been already registered
573 bool IsRegistered() const { return m_registered
== 1; }
575 // try to register the class if not done yet, return true on success
576 bool Register(const WNDCLASS
& wc
)
578 // we should only be called if we hadn't been initialized yet
579 wxASSERT_MSG( m_registered
== -1,
580 _T("calling ClassRegistrar::Register() twice?") );
582 m_registered
= ::RegisterClass(&wc
) ? 1 : 0;
583 if ( !IsRegistered() )
585 wxLogLastError(_T("RegisterClassEx()"));
589 m_clsname
= wc
.lpszClassName
;
592 return m_registered
== 1;
595 // get the name of the registered class (returns empty string if not
597 const wxString
& GetName() const { return m_clsname
; }
599 // unregister the class if it had been registered
602 if ( IsRegistered() )
604 if ( !::UnregisterClass(m_clsname
, wxhInstance
) )
606 wxLogLastError(_T("UnregisterClass"));
612 // initial value is -1 which means that we hadn't tried registering the
613 // class yet, it becomes true or false (1 or 0) when Initialize() is called
616 // the name of the class, only non empty if it had been registered
620 // ---------------------------------------------------------------------------
621 // macros to make casting between WXFOO and FOO a bit easier: the GetFoo()
622 // returns Foo cast to the Windows type for oruselves, while GetFooOf() takes
623 // an argument which should be a pointer or reference to the object of the
624 // corresponding class (this depends on the macro)
625 // ---------------------------------------------------------------------------
627 #define GetHwnd() ((HWND)GetHWND())
628 #define GetHwndOf(win) ((HWND)((win)->GetHWND()))
630 #define GetWinHwnd GetHwndOf
632 #define GetHdc() ((HDC)GetHDC())
633 #define GetHdcOf(dc) ((HDC)(dc).GetHDC())
635 #define GetHbitmap() ((HBITMAP)GetHBITMAP())
636 #define GetHbitmapOf(bmp) ((HBITMAP)(bmp).GetHBITMAP())
638 #define GetHicon() ((HICON)GetHICON())
639 #define GetHiconOf(icon) ((HICON)(icon).GetHICON())
641 #define GetHaccel() ((HACCEL)GetHACCEL())
642 #define GetHaccelOf(table) ((HACCEL)((table).GetHACCEL()))
644 #define GetHbrush() ((HBRUSH)GetResourceHandle())
645 #define GetHbrushOf(brush) ((HBRUSH)(brush).GetResourceHandle())
647 #define GetHmenu() ((HMENU)GetHMenu())
648 #define GetHmenuOf(menu) ((HMENU)menu->GetHMenu())
650 #define GetHcursor() ((HCURSOR)GetHCURSOR())
651 #define GetHcursorOf(cursor) ((HCURSOR)(cursor).GetHCURSOR())
653 #define GetHfont() ((HFONT)GetHFONT())
654 #define GetHfontOf(font) ((HFONT)(font).GetHFONT())
656 #define GetHimagelist() ((HIMAGELIST)GetHIMAGELIST())
657 #define GetHimagelistOf(imgl) ((HIMAGELIST)imgl->GetHIMAGELIST())
659 #define GetHpalette() ((HPALETTE)GetHPALETTE())
660 #define GetHpaletteOf(pal) ((HPALETTE)(pal).GetHPALETTE())
662 #define GetHpen() ((HPEN)GetResourceHandle())
663 #define GetHpenOf(pen) ((HPEN)(pen).GetResourceHandle())
665 #define GetHrgn() ((HRGN)GetHRGN())
666 #define GetHrgnOf(rgn) ((HRGN)(rgn).GetHRGN())
670 // ---------------------------------------------------------------------------
672 // ---------------------------------------------------------------------------
676 WXDLLIMPEXP_BASE HINSTANCE
wxGetInstance();
679 WXDLLIMPEXP_BASE
void wxSetInstance(HINSTANCE hInst
);
681 // return the full path of the given module
682 inline wxString
wxGetFullModuleName(HMODULE hmod
)
685 if ( !::GetModuleFileName
688 wxStringBuffer(fullname
, MAX_PATH
),
692 wxLogLastError(_T("GetModuleFileName"));
698 // return the full path of the program file
699 inline wxString
wxGetFullModuleName()
701 return wxGetFullModuleName((HMODULE
)wxGetInstance());
704 // return the run-time version of the OS in a format similar to
705 // WINVER/_WIN32_WINNT compile-time macros:
707 // 0x0300 Windows NT 3.51
708 // 0x0400 Windows 95, NT4
710 // 0x0500 Windows ME, 2000
712 // 0x0502 Windows 2003
715 // for the other Windows versions 0 is currently returned
718 wxWinVersion_Unknown
= 0,
720 wxWinVersion_3
= 0x0300,
721 wxWinVersion_NT3
= wxWinVersion_3
,
723 wxWinVersion_4
= 0x0400,
724 wxWinVersion_95
= wxWinVersion_4
,
725 wxWinVersion_NT4
= wxWinVersion_4
,
726 wxWinVersion_98
= 0x0410,
728 wxWinVersion_5
= 0x0500,
729 wxWinVersion_ME
= wxWinVersion_5
,
730 wxWinVersion_NT5
= wxWinVersion_5
,
731 wxWinVersion_2000
= wxWinVersion_5
,
732 wxWinVersion_XP
= 0x0501,
733 wxWinVersion_2003
= 0x0502,
735 wxWinVersion_6
= 0x0600,
736 wxWinVersion_NT6
= 0x0600
739 WXDLLEXPORT wxWinVersion
wxGetWinVersion();
744 extern HCURSOR
wxGetCurrentBusyCursor(); // from msw/utils.cpp
745 extern const wxCursor
*wxGetGlobalCursor(); // from msw/cursor.cpp
747 WXDLLEXPORT
void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
);
748 WXDLLEXPORT
void wxFillLogFont(LOGFONT
*logFont
, const wxFont
*font
);
749 WXDLLEXPORT wxFont
wxCreateFontFromLogFont(const LOGFONT
*logFont
);
750 WXDLLEXPORT wxFontEncoding
wxGetFontEncFromCharSet(int charset
);
752 WXDLLEXPORT
void wxSliderEvent(WXHWND control
, WXWORD wParam
, WXWORD pos
);
753 WXDLLEXPORT
void wxScrollBarEvent(WXHWND hbar
, WXWORD wParam
, WXWORD pos
);
755 // Find maximum size of window/rectangle
756 extern WXDLLEXPORT
void wxFindMaxSize(WXHWND hwnd
, RECT
*rect
);
758 // Safely get the window text (i.e. without using fixed size buffer)
759 extern WXDLLEXPORT wxString
wxGetWindowText(WXHWND hWnd
);
761 // get the window class name
762 extern WXDLLEXPORT wxString
wxGetWindowClass(WXHWND hWnd
);
764 // get the window id (should be unsigned, hence this is not wxWindowID which
765 // is, for mainly historical reasons, signed)
766 extern WXDLLEXPORT WXWORD
wxGetWindowId(WXHWND hWnd
);
768 // check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
770 extern WXDLLEXPORT
bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
);
772 // Does this window style specify any border?
773 inline bool wxStyleHasBorder(long style
)
775 return (style
& (wxSIMPLE_BORDER
| wxRAISED_BORDER
|
776 wxSUNKEN_BORDER
| wxDOUBLE_BORDER
)) != 0;
779 // Deferred window moving
780 bool wxMoveWindowDeferred(HDWP
& hdwp
, wxWindowBase
* win
, HWND hWnd
, int x
, int y
, int width
, int height
);
782 // ----------------------------------------------------------------------------
783 // functions mapping HWND to wxWindow
784 // ----------------------------------------------------------------------------
786 // this function simply checks whether the given hWnd corresponds to a wxWindow
787 // and returns either that window if it does or NULL otherwise
788 extern WXDLLEXPORT wxWindow
* wxFindWinFromHandle(WXHWND hWnd
);
790 // find the window for HWND which is part of some wxWindow, i.e. unlike
791 // wxFindWinFromHandle() above it will also work for "sub controls" of a
794 // returns the wxWindow corresponding to the given HWND or NULL.
795 extern WXDLLEXPORT wxWindow
*wxGetWindowFromHWND(WXHWND hwnd
);
797 // Get the size of an icon
798 extern WXDLLEXPORT wxSize
wxGetHiconSize(HICON hicon
);
800 // Lines are drawn differently for WinCE and regular WIN32
801 WXDLLEXPORT
void wxDrawLine(HDC hdc
, int x1
, int y1
, int x2
, int y2
);
803 // fill the client rect of the given window on the provided dc using this brush
804 inline void wxFillRect(HWND hwnd
, HDC hdc
, HBRUSH hbr
)
807 ::GetClientRect(hwnd
, &rc
);
808 ::FillRect(hdc
, &rc
, hbr
);
811 // ----------------------------------------------------------------------------
813 // ----------------------------------------------------------------------------
817 inline void *wxGetWindowProc(HWND hwnd
)
819 return (void *)::GetWindowLongPtr(hwnd
, GWLP_WNDPROC
);
822 inline void *wxGetWindowUserData(HWND hwnd
)
824 return (void *)::GetWindowLongPtr(hwnd
, GWLP_USERDATA
);
827 inline WNDPROC
wxSetWindowProc(HWND hwnd
, WNDPROC func
)
829 return (WNDPROC
)::SetWindowLongPtr(hwnd
, GWLP_WNDPROC
, (LONG_PTR
)func
);
832 inline void *wxSetWindowUserData(HWND hwnd
, void *data
)
834 return (void *)::SetWindowLongPtr(hwnd
, GWLP_USERDATA
, (LONG_PTR
)data
);
840 // strangely enough, VC++ 7.1 gives warnings about 32 -> 64 bit conversions
841 // in the functions below, even in spite of the explicit casts
842 #pragma warning(disable:4311)
843 #pragma warning(disable:4312)
846 inline void *wxGetWindowProc(HWND hwnd
)
848 return (void *)::GetWindowLong(hwnd
, GWL_WNDPROC
);
851 inline void *wxGetWindowUserData(HWND hwnd
)
853 return (void *)::GetWindowLong(hwnd
, GWL_USERDATA
);
856 inline WNDPROC
wxSetWindowProc(HWND hwnd
, WNDPROC func
)
858 return (WNDPROC
)::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
)func
);
861 inline void *wxSetWindowUserData(HWND hwnd
, void *data
)
863 return (void *)::SetWindowLong(hwnd
, GWL_USERDATA
, (LONG
)data
);
867 #pragma warning(default:4311)
868 #pragma warning(default:4312)
871 #endif // __WIN64__/__WIN32__
875 #endif // _WX_PRIVATE_H_