]> git.saurik.com Git - wxWidgets.git/blob - include/wx/msw/private.h
added Get(Class)DefaultAttributes()
[wxWidgets.git] / include / wx / msw / private.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: private.h
3 // Purpose: Private declarations: as this header is only included by
4 // wxWindows 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 #if defined (__WXWINCE__)
20 #include <wingdi.h> // RGB, COLORREF
21 #define ERRFALSE(x)
22 #include <winuser.h> // Global Namespaces ::GetKeyState, ::GetWindowRect
23 #include "wx/msw/winundef.h"
24 #endif
25
26
27 #ifdef __WXMICROWIN__
28 // Extra prototypes and symbols not defined by MicroWindows
29 #include "wx/msw/microwin.h"
30 #endif
31
32 // Include fixes for MSLU:
33 #include "wx/msw/mslu.h"
34
35 #include "wx/log.h"
36
37 class WXDLLEXPORT wxFont;
38 class WXDLLEXPORT wxWindow;
39
40 // ---------------------------------------------------------------------------
41 // private constants
42 // ---------------------------------------------------------------------------
43
44 // Conversion
45 static const double METRIC_CONVERSION_CONSTANT = 0.0393700787;
46
47 // Scaling factors for various unit conversions
48 static const double mm2inches = (METRIC_CONVERSION_CONSTANT);
49 static const double inches2mm = (1/METRIC_CONVERSION_CONSTANT);
50
51 static const double mm2twips = (METRIC_CONVERSION_CONSTANT*1440);
52 static const double twips2mm = (1/(METRIC_CONVERSION_CONSTANT*1440));
53
54 static const double mm2pt = (METRIC_CONVERSION_CONSTANT*72);
55 static const double pt2mm = (1/(METRIC_CONVERSION_CONSTANT*72));
56
57 // ---------------------------------------------------------------------------
58 // standard icons from the resources
59 // ---------------------------------------------------------------------------
60
61 #if wxUSE_GUI
62
63 WXDLLEXPORT_DATA(extern HICON) wxSTD_FRAME_ICON;
64 WXDLLEXPORT_DATA(extern HICON) wxSTD_MDIPARENTFRAME_ICON;
65 WXDLLEXPORT_DATA(extern HICON) wxSTD_MDICHILDFRAME_ICON;
66 WXDLLEXPORT_DATA(extern HICON) wxDEFAULT_FRAME_ICON;
67 WXDLLEXPORT_DATA(extern HICON) wxDEFAULT_MDIPARENTFRAME_ICON;
68 WXDLLEXPORT_DATA(extern HICON) wxDEFAULT_MDICHILDFRAME_ICON;
69 WXDLLEXPORT_DATA(extern HFONT) wxSTATUS_LINE_FONT;
70
71 #endif // wxUSE_GUI
72
73 // ---------------------------------------------------------------------------
74 // define things missing from some compilers' headers
75 // ---------------------------------------------------------------------------
76
77 #if defined(__WXWINCE__) || (defined(__GNUWIN32__) && !wxUSE_NORLANDER_HEADERS)
78 #ifndef ZeroMemory
79 inline void ZeroMemory(void *buf, size_t len) { memset(buf, 0, len); }
80 #endif
81 #endif // old mingw32
82
83 // this defines a CASTWNDPROC macro which casts a pointer to the type of a
84 // window proc
85 #if defined(STRICT) || defined(__GNUC__)
86 typedef WNDPROC WndProcCast;
87 #else
88 typedef FARPROC WndProcCast;
89 #endif
90
91
92 #define CASTWNDPROC (WndProcCast)
93
94
95
96 // ---------------------------------------------------------------------------
97 // some stuff for old Windows versions (FIXME: what does it do here??)
98 // ---------------------------------------------------------------------------
99
100 #if !defined(APIENTRY) // NT defines APIENTRY, 3.x not
101 #define APIENTRY FAR PASCAL
102 #endif
103
104 #ifdef __WIN32__
105 #define _EXPORT
106 #else
107 #define _EXPORT _export
108 #endif
109
110 #ifndef __WIN32__
111 typedef signed short int SHORT;
112 #endif
113
114 #if !defined(__WIN32__) // 3.x uses FARPROC for dialogs
115 #ifndef STRICT
116 #define DLGPROC FARPROC
117 #endif
118 #endif
119
120 #if wxUSE_PENWIN
121 WXDLLEXPORT void wxRegisterPenWin();
122 WXDLLEXPORT void wxCleanUpPenWin();
123 WXDLLEXPORT void wxEnablePenAppHooks (bool hook);
124 #endif // wxUSE_PENWIN
125
126 #if wxUSE_ITSY_BITSY
127 #define IBS_HORZCAPTION 0x4000L
128 #define IBS_VERTCAPTION 0x8000L
129
130 UINT WINAPI ibGetCaptionSize( HWND hWnd ) ;
131 UINT WINAPI ibSetCaptionSize( HWND hWnd, UINT nSize ) ;
132 LRESULT WINAPI ibDefWindowProc( HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam ) ;
133 VOID WINAPI ibAdjustWindowRect( HWND hWnd, LPRECT lprc ) ;
134 #endif // wxUSE_ITSY_BITSY
135
136 #if wxUSE_CTL3D
137 #include "wx/msw/ctl3d/ctl3d.h"
138 #endif // wxUSE_CTL3D
139
140 /*
141 * Decide what window classes we're going to use
142 * for this combination of CTl3D/FAFA settings
143 */
144
145 #define STATIC_CLASS wxT("STATIC")
146 #define STATIC_FLAGS (SS_LEFT|WS_CHILD|WS_VISIBLE)
147 #define CHECK_CLASS wxT("BUTTON")
148 #define CHECK_FLAGS (BS_AUTOCHECKBOX|WS_TABSTOP|WS_CHILD)
149 #define CHECK_IS_FAFA FALSE
150 #define RADIO_CLASS wxT("BUTTON")
151 #define RADIO_FLAGS (BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE)
152 #define RADIO_SIZE 20
153 #define RADIO_IS_FAFA FALSE
154 #define PURE_WINDOWS
155 #define GROUP_CLASS wxT("BUTTON")
156 #define GROUP_FLAGS (BS_GROUPBOX|WS_CHILD|WS_VISIBLE)
157
158 /*
159 #define BITCHECK_FLAGS (FB_BITMAP|FC_BUTTONDRAW|FC_DEFAULT|WS_VISIBLE)
160 #define BITRADIO_FLAGS (FC_BUTTONDRAW|FB_BITMAP|FC_RADIO|WS_CHILD|WS_VISIBLE)
161 */
162
163 // ---------------------------------------------------------------------------
164 // misc macros
165 // ---------------------------------------------------------------------------
166
167 #define MEANING_CHARACTER '0'
168 #define DEFAULT_ITEM_WIDTH 100
169 #define DEFAULT_ITEM_HEIGHT 80
170
171 // Scale font to get edit control height
172 //#define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) (3*(cy)/2)
173 #define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) (cy+8)
174
175 // Generic subclass proc, for panel item moving/sizing and intercept
176 // EDIT control VK_RETURN messages
177 extern LONG APIENTRY _EXPORT
178 wxSubclassedGenericControlProc(WXHWND hWnd, WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
179
180 // ---------------------------------------------------------------------------
181 // useful macros and functions
182 // ---------------------------------------------------------------------------
183
184 // a wrapper macro for ZeroMemory()
185 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
186 #define wxZeroMemory(obj) ::ZeroMemory(&obj, sizeof(obj))
187 #else
188 #define wxZeroMemory(obj) memset((void*) & obj, 0, sizeof(obj))
189 #endif
190
191 #if wxUSE_GUI
192
193 #include <wx/gdicmn.h>
194 #include <wx/colour.h>
195
196 // make conversion from wxColour and COLORREF a bit less painful
197 inline COLORREF wxColourToRGB(const wxColour& c)
198 {
199 return RGB(c.Red(), c.Green(), c.Blue());
200 }
201
202 inline COLORREF wxColourToPalRGB(const wxColour& c)
203 {
204 return PALETTERGB(c.Red(), c.Green(), c.Blue());
205 }
206
207 inline wxColour wxRGBToColour(COLORREF rgb)
208 {
209 return wxColour(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb));
210 }
211
212 inline void wxRGBToColour(wxColour& c, COLORREF rgb)
213 {
214 c.Set(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb));
215 }
216
217 // get the standard colour map for some standard colours - see comment in this
218 // function to understand why is it needed and when should it be used
219 //
220 // it returns a wxCOLORMAP (can't use COLORMAP itself here as comctl32.dll
221 // might be not included/available) array of size wxSTD_COLOUR_MAX
222 //
223 // NB: if you change these colours, update wxBITMAP_STD_COLOURS in the
224 // resources as well: it must have the same number of pixels!
225 enum wxSTD_COLOUR
226 {
227 wxSTD_COL_BTNTEXT,
228 wxSTD_COL_BTNSHADOW,
229 wxSTD_COL_BTNFACE,
230 wxSTD_COL_BTNHIGHLIGHT,
231 wxSTD_COL_MAX,
232 };
233
234 struct WXDLLEXPORT wxCOLORMAP
235 {
236 COLORREF from, to;
237 };
238
239 // this function is implemented in src/msw/window.cpp
240 extern wxCOLORMAP *wxGetStdColourMap();
241
242 // copy Windows RECT to our wxRect
243 inline void wxCopyRECTToRect(const RECT& r, wxRect& rect)
244 {
245 rect.y = r.top;
246 rect.x = r.left;
247 rect.width = r.right - r.left;
248 rect.height = r.bottom - r.top;
249 }
250
251 // translations between HIMETRIC units (which OLE likes) and pixels (which are
252 // liked by all the others) - implemented in msw/utilsexc.cpp
253 extern void HIMETRICToPixel(LONG *x, LONG *y);
254 extern void PixelToHIMETRIC(LONG *x, LONG *y);
255
256 // Windows convention of the mask is opposed to the wxWindows one, so we need
257 // to invert the mask each time we pass one/get one to/from Windows
258 extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w = 0, int h = 0);
259
260 // Creates an icon or cursor depending from a bitmap
261 //
262 // The bitmap must be valid and it should have a mask. If it doesn't, a default
263 // mask is created using light grey as the transparent colour.
264 extern HICON wxBitmapToHICON(const wxBitmap& bmp);
265
266 // Same requirments as above apply and the bitmap must also have the correct
267 // size.
268 extern
269 HCURSOR wxBitmapToHCURSOR(const wxBitmap& bmp, int hotSpotX, int hotSpotY);
270
271 // get (x, y) from DWORD - notice that HI/LOWORD can *not* be used because they
272 // will fail on system with multiple monitors where the coords may be negative
273 //
274 // these macros are standard now (Win98) but some older headers don't have them
275 #ifndef GET_X_LPARAM
276 #define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
277 #define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))
278 #endif // GET_X_LPARAM
279
280 // get the current state of SHIFT/CTRL keys
281 inline bool wxIsShiftDown()
282 {
283 // return (::GetKeyState(VK_SHIFT) & 0x100) != 0;
284 // Returns different negative values on WinME and WinNT,
285 // so simply test for negative value.
286 return ::GetKeyState(VK_SHIFT) < 0;
287 }
288
289 inline bool wxIsCtrlDown()
290 {
291 // return (::GetKeyState(VK_CONTROL) & 0x100) != 0;
292 // Returns different negative values on WinME and WinNT,
293 // so simply test for negative value.
294 return ::GetKeyState(VK_CONTROL) < 0;
295 }
296
297 // wrapper around GetWindowRect() and GetClientRect() APIs doing error checking
298 // for Win32
299 inline RECT wxGetWindowRect(HWND hwnd)
300 {
301 RECT rect;
302
303 if ( !::GetWindowRect(hwnd, &rect) )
304 {
305 wxLogLastError(_T("GetWindowRect"));
306 }
307
308 return rect;
309 }
310
311 inline RECT wxGetClientRect(HWND hwnd)
312 {
313 RECT rect;
314
315 if ( !::GetClientRect(hwnd, &rect) )
316 {
317 wxLogLastError(_T("GetClientRect"));
318 }
319
320 return rect;
321 }
322
323 // ---------------------------------------------------------------------------
324 // small helper classes
325 // ---------------------------------------------------------------------------
326
327 // a template to make initializing Windows styructs less painful: it zeroes all
328 // the struct fields and also sets cbSize member to the correct value (and so
329 // can be only used with structures which have this member...)
330 template <class T>
331 struct WinStruct : public T
332 {
333 WinStruct()
334 {
335 ::ZeroMemory(this, sizeof(T));
336 cbSize = sizeof(T);
337 }
338 };
339
340
341 // create an instance of this class and use it as the HDC for screen, will
342 // automatically release the DC going out of scope
343 class ScreenHDC
344 {
345 public:
346 ScreenHDC() { m_hdc = ::GetDC(NULL); }
347 ~ScreenHDC() { ::ReleaseDC(NULL, m_hdc); }
348
349 operator HDC() const { return m_hdc; }
350
351 private:
352 HDC m_hdc;
353
354 DECLARE_NO_COPY_CLASS(ScreenHDC)
355 };
356
357 // the same as ScreenHDC but for memory DCs: creates the HDC compatible with
358 // the given one (screen by default) in ctor and destroys it in dtor
359 class MemoryHDC
360 {
361 public:
362 MemoryHDC(HDC hdc = 0) { m_hdc = ::CreateCompatibleDC(hdc); }
363 ~MemoryHDC() { ::DeleteDC(m_hdc); }
364
365 operator HDC() const { return m_hdc; }
366
367 private:
368 HDC m_hdc;
369
370 DECLARE_NO_COPY_CLASS(MemoryHDC)
371 };
372
373 // a class which selects a GDI object into a DC in its ctor and deselects in
374 // dtor
375 class SelectInHDC
376 {
377 public:
378 SelectInHDC(HDC hdc, HGDIOBJ hgdiobj) : m_hdc(hdc)
379 { m_hgdiobj = ::SelectObject(hdc, hgdiobj); }
380
381 ~SelectInHDC() { ::SelectObject(m_hdc, m_hgdiobj); }
382
383 // return true if the object was successfully selected
384 operator bool() const { return m_hgdiobj != 0; }
385
386 private:
387 HDC m_hdc;
388 HGDIOBJ m_hgdiobj;
389
390 DECLARE_NO_COPY_CLASS(SelectInHDC)
391 };
392
393 #ifndef __WXWINCE__
394 // when working with global pointers (which is unfortunately still necessary
395 // sometimes, e.g. for clipboard) it is important to unlock them exactly as
396 // many times as we lock them which just asks for using a "smart lock" class
397 class GlobalPtr
398 {
399 public:
400 GlobalPtr(HGLOBAL hGlobal) : m_hGlobal(hGlobal)
401 {
402 m_ptr = ::GlobalLock(hGlobal);
403 if ( !m_ptr )
404 {
405 wxLogLastError(_T("GlobalLock"));
406 }
407 }
408
409 ~GlobalPtr()
410 {
411 if ( !::GlobalUnlock(m_hGlobal) )
412 {
413 #ifdef __WXDEBUG__
414 // this might happen simply because the block became unlocked
415 DWORD dwLastError = ::GetLastError();
416 if ( dwLastError != NO_ERROR )
417 {
418 wxLogApiError(_T("GlobalUnlock"), dwLastError);
419 }
420 #endif // __WXDEBUG__
421 }
422 }
423
424 operator void *() const { return m_ptr; }
425
426 private:
427 HGLOBAL m_hGlobal;
428 void *m_ptr;
429
430 DECLARE_NO_COPY_CLASS(GlobalPtr)
431 };
432 #endif
433
434 // ---------------------------------------------------------------------------
435 // macros to make casting between WXFOO and FOO a bit easier: the GetFoo()
436 // returns Foo cast to the Windows type for oruselves, while GetFooOf() takes
437 // an argument which should be a pointer or reference to the object of the
438 // corresponding class (this depends on the macro)
439 // ---------------------------------------------------------------------------
440
441 #define GetHwnd() ((HWND)GetHWND())
442 #define GetHwndOf(win) ((HWND)((win)->GetHWND()))
443 // old name
444 #define GetWinHwnd GetHwndOf
445
446 #define GetHdc() ((HDC)GetHDC())
447 #define GetHdcOf(dc) ((HDC)(dc).GetHDC())
448
449 #define GetHbitmap() ((HBITMAP)GetHBITMAP())
450 #define GetHbitmapOf(bmp) ((HBITMAP)(bmp).GetHBITMAP())
451
452 #define GetHicon() ((HICON)GetHICON())
453 #define GetHiconOf(icon) ((HICON)(icon).GetHICON())
454
455 #define GetHaccel() ((HACCEL)GetHACCEL())
456 #define GetHaccelOf(table) ((HACCEL)((table).GetHACCEL()))
457
458 #define GetHbrush() ((HPEN)GetResourceHandle())
459 #define GetHbrushOf(brush) ((HPEN)(brush).GetResourceHandle())
460
461 #define GetHmenu() ((HMENU)GetHMenu())
462 #define GetHmenuOf(menu) ((HMENU)menu->GetHMenu())
463
464 #define GetHcursor() ((HCURSOR)GetHCURSOR())
465 #define GetHcursorOf(cursor) ((HCURSOR)(cursor).GetHCURSOR())
466
467 #define GetHfont() ((HFONT)GetHFONT())
468 #define GetHfontOf(font) ((HFONT)(font).GetHFONT())
469
470 #define GetHpalette() ((HPALETTE)GetHPALETTE())
471 #define GetHpaletteOf(pal) ((HPALETTE)(pal).GetHPALETTE())
472
473 #define GetHpen() ((HPEN)GetResourceHandle())
474 #define GetHpenOf(pen) ((HPEN)(pen).GetResourceHandle())
475
476 #define GetHrgn() ((HRGN)GetHRGN())
477 #define GetHrgnOf(rgn) ((HRGN)(rgn).GetHRGN())
478
479 #endif // wxUSE_GUI
480
481 // ---------------------------------------------------------------------------
482 // global data
483 // ---------------------------------------------------------------------------
484
485 WXDLLIMPEXP_DATA_BASE(extern HINSTANCE) wxhInstance;
486
487 // ---------------------------------------------------------------------------
488 // global functions
489 // ---------------------------------------------------------------------------
490
491 extern "C"
492 {
493 WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
494 }
495
496 WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
497
498 #if wxUSE_GUI
499
500 // cursor stuff
501 extern HCURSOR wxGetCurrentBusyCursor(); // from msw/utils.cpp
502 extern const wxCursor *wxGetGlobalCursor(); // from msw/cursor.cpp
503
504 WXDLLEXPORT void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font);
505 WXDLLEXPORT void wxFillLogFont(LOGFONT *logFont, const wxFont *font);
506 WXDLLEXPORT wxFont wxCreateFontFromLogFont(const LOGFONT *logFont);
507 WXDLLEXPORT wxFontEncoding wxGetFontEncFromCharSet(int charset);
508
509 WXDLLEXPORT void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos);
510 WXDLLEXPORT void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos);
511
512 // Find maximum size of window/rectangle
513 WXDLLEXPORT extern void wxFindMaxSize(WXHWND hwnd, RECT *rect);
514
515 // Safely get the window text (i.e. without using fixed size buffer)
516 WXDLLEXPORT extern wxString wxGetWindowText(WXHWND hWnd);
517
518 // get the window class name
519 WXDLLEXPORT extern wxString wxGetWindowClass(WXHWND hWnd);
520
521 // get the window id (should be unsigned, hence this is not wxWindowID which
522 // is, for mainly historical reasons, signed)
523 WXDLLEXPORT extern WXWORD wxGetWindowId(WXHWND hWnd);
524
525 // check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
526 // different
527 WXDLLEXPORT extern bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc);
528
529 // Does this window style specify any border?
530 inline bool wxStyleHasBorder(long style)
531 {
532 return (style & (wxSIMPLE_BORDER | wxRAISED_BORDER |
533 wxSUNKEN_BORDER | wxDOUBLE_BORDER)) != 0;
534 }
535
536 // ----------------------------------------------------------------------------
537 // functions mapping HWND to wxWindow
538 // ----------------------------------------------------------------------------
539
540 // this function simply checks whether the given hWnd corresponds to a wxWindow
541 // and returns either that window if it does or NULL otherwise
542 WXDLLEXPORT extern wxWindow* wxFindWinFromHandle(WXHWND hWnd);
543
544 // find the window for HWND which is part of some wxWindow, i.e. unlike
545 // wxFindWinFromHandle() above it will also work for "sub controls" of a
546 // wxWindow.
547 //
548 // returns the wxWindow corresponding to the given HWND or NULL.
549 WXDLLEXPORT extern wxWindow *wxGetWindowFromHWND(WXHWND hwnd);
550
551 // Get the size of an icon
552 WXDLLEXPORT extern wxSize wxGetHiconSize(HICON hicon);
553
554 // Lines are drawn differently for WinCE and regular WIN32
555 WXDLLEXPORT void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2);
556
557 // LocalAlloc should be used on WinCE
558 #ifdef __WXWINCE__
559 #include <winbase.h>
560
561 #if _WIN32_WCE <= 211
562 #define GlobalAlloc LocalAlloc
563 #define GlobalFree LocalFree
564 #define GlobalLock(mem) mem
565 #define GlobalUnlock(mem)
566 #define GlobalSize LocalSize
567 #define GPTR LPTR
568 #define GHND LPTR
569 #define GMEM_MOVEABLE 0
570 #define GMEM_SHARE 0
571 #endif
572
573 #if 0
574
575 HLOCAL
576 WINAPI
577 LocalAlloc (
578 UINT fuFlags,
579 UINT cbBytes
580 );
581
582 HLOCAL
583 WINAPI
584 LocalFree (
585 HLOCAL hMem
586 );
587
588 #ifndef LMEM_FIXED
589 #define LMEM_FIXED 0x0000
590 #define LMEM_MOVEABLE 0x0002
591 #define LMEM_NOCOMPACT 0x0010 /**** Used for Moveable Memory ***/
592 #define LMEM_NODISCARD 0x0020 /**** Ignored *****/
593 #define LMEM_ZEROINIT 0x0040
594 #define LMEM_MODIFY 0x0080 /*** Used only in LocalReAlloc() **/
595 #define LMEM_DISCARDABLE 0x0F00 /**** Ignored ****/
596 #define LMEM_VALID_FLAGS 0x0F72
597 #define LMEM_INVALID_HANDLE 0x8000
598
599 #define LHND (LMEM_MOVEABLE | LMEM_ZEROINIT)
600 #define LPTR (LMEM_FIXED | LMEM_ZEROINIT)
601 #endif
602
603 #endif
604 // 0
605
606 #endif
607 // __WXWINCE__
608
609 // ----------------------------------------------------------------------------
610 // 32/64 bit helpers
611 // ----------------------------------------------------------------------------
612
613 #ifdef __WIN64__
614
615 inline void *wxGetWindowProc(HWND hwnd)
616 {
617 return (void *)::GetWindowLongPtr(hwnd, GWLP_WNDPROC);
618 }
619
620 inline void *wxGetWindowUserData(HWND hwnd)
621 {
622 return (void *)::GetWindowLongPtr(hwnd, GWLP_USERDATA);
623 }
624
625 inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
626 {
627 return (WNDPROC)::SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)func);
628 }
629
630 inline void *wxSetWindowUserData(HWND hwnd, void *data)
631 {
632 return (void *)::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)data);
633 }
634
635 #else // __WIN32__
636
637 inline void *wxGetWindowProc(HWND hwnd)
638 {
639 return (void *)::GetWindowLong(hwnd, GWL_WNDPROC);
640 }
641
642 inline void *wxGetWindowUserData(HWND hwnd)
643 {
644 return (void *)::GetWindowLong(hwnd, GWL_USERDATA);
645 }
646
647 inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
648 {
649 return (WNDPROC)::SetWindowLong(hwnd, GWL_WNDPROC, (LONG)func);
650 }
651
652 inline void *wxSetWindowUserData(HWND hwnd, void *data)
653 {
654 return (void *)::SetWindowLong(hwnd, GWL_USERDATA, (LONG)data);
655 }
656
657 #endif // __WIN64__/__WIN32__
658
659 #endif // wxUSE_GUI
660
661 #endif
662 // _WX_PRIVATE_H_