]> git.saurik.com Git - wxWidgets.git/blame - include/wx/msw/private.h
use MSWCreateControl() instead of the old mess; implemented Get(Class)DefaultAttributes()
[wxWidgets.git] / include / wx / msw / private.h
CommitLineData
2bda0e17
KB
1/////////////////////////////////////////////////////////////////////////////
2// Name: private.h
a23fd0e1
VZ
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".
2bda0e17
KB
6// Author: Julian Smart
7// Modified by:
8// Created: 01/02/97
9// RCS-ID: $Id$
bbcdf8bc 10// Copyright: (c) Julian Smart
c085e333 11// Licence: wxWindows licence
2bda0e17
KB
12/////////////////////////////////////////////////////////////////////////////
13
bbcdf8bc
JS
14#ifndef _WX_PRIVATE_H_
15#define _WX_PRIVATE_H_
2bda0e17 16
9ed0d735 17#include "wx/msw/wrapwin.h"
2bda0e17 18
368c9c6d
JS
19#if defined (__WXWINCE__)
20 #include <wingdi.h> // RGB, COLORREF
42d11c8e 21 #define ERRFALSE(x)
368c9c6d 22 #include <winuser.h> // Global Namespaces ::GetKeyState, ::GetWindowRect
42d11c8e 23 #include "wx/msw/winundef.h"
368c9c6d
JS
24#endif
25
26
04ef50df 27#ifdef __WXMICROWIN__
b225f659
VZ
28 // Extra prototypes and symbols not defined by MicroWindows
29 #include "wx/msw/microwin.h"
04ef50df
JS
30#endif
31
3d5231db
VS
32// Include fixes for MSLU:
33#include "wx/msw/mslu.h"
34
3a922bb4
RL
35#include "wx/log.h"
36
a23fd0e1 37class WXDLLEXPORT wxFont;
d427503c 38class WXDLLEXPORT wxWindow;
2bda0e17 39
42e69d6b
VZ
40// ---------------------------------------------------------------------------
41// private constants
42// ---------------------------------------------------------------------------
43
44// Conversion
45static const double METRIC_CONVERSION_CONSTANT = 0.0393700787;
46
47// Scaling factors for various unit conversions
48static const double mm2inches = (METRIC_CONVERSION_CONSTANT);
49static const double inches2mm = (1/METRIC_CONVERSION_CONSTANT);
50
51static const double mm2twips = (METRIC_CONVERSION_CONSTANT*1440);
52static const double twips2mm = (1/(METRIC_CONVERSION_CONSTANT*1440));
53
54static const double mm2pt = (METRIC_CONVERSION_CONSTANT*72);
55static const double pt2mm = (1/(METRIC_CONVERSION_CONSTANT*72));
56
a23fd0e1
VZ
57// ---------------------------------------------------------------------------
58// standard icons from the resources
59// ---------------------------------------------------------------------------
2bda0e17 60
b568d04f
VZ
61#if wxUSE_GUI
62
2bda0e17
KB
63WXDLLEXPORT_DATA(extern HICON) wxSTD_FRAME_ICON;
64WXDLLEXPORT_DATA(extern HICON) wxSTD_MDIPARENTFRAME_ICON;
65WXDLLEXPORT_DATA(extern HICON) wxSTD_MDICHILDFRAME_ICON;
66WXDLLEXPORT_DATA(extern HICON) wxDEFAULT_FRAME_ICON;
67WXDLLEXPORT_DATA(extern HICON) wxDEFAULT_MDIPARENTFRAME_ICON;
68WXDLLEXPORT_DATA(extern HICON) wxDEFAULT_MDICHILDFRAME_ICON;
69WXDLLEXPORT_DATA(extern HFONT) wxSTATUS_LINE_FONT;
70
b568d04f
VZ
71#endif // wxUSE_GUI
72
a23fd0e1 73// ---------------------------------------------------------------------------
11c7d5b6 74// define things missing from some compilers' headers
a23fd0e1 75// ---------------------------------------------------------------------------
c455ab93 76
7f0586ef 77#if defined(__WXWINCE__) || (defined(__GNUWIN32__) && !wxUSE_NORLANDER_HEADERS)
01dba85a 78#ifndef ZeroMemory
11c7d5b6 79 inline void ZeroMemory(void *buf, size_t len) { memset(buf, 0, len); }
01dba85a 80#endif
11c7d5b6
VZ
81#endif // old mingw32
82
83// this defines a CASTWNDPROC macro which casts a pointer to the type of a
84// window proc
7f0586ef 85#if defined(STRICT) || defined(__GNUC__)
ebb0781f 86 typedef WNDPROC WndProcCast;
c3b177ae 87#else
ebb0781f
VZ
88 typedef FARPROC WndProcCast;
89#endif
90
552a0ebd 91
ebb0781f 92#define CASTWNDPROC (WndProcCast)
2bda0e17 93
dd54f5d3 94
50165591 95
a23fd0e1
VZ
96// ---------------------------------------------------------------------------
97// some stuff for old Windows versions (FIXME: what does it do here??)
98// ---------------------------------------------------------------------------
99
c085e333 100#if !defined(APIENTRY) // NT defines APIENTRY, 3.x not
a23fd0e1 101 #define APIENTRY FAR PASCAL
2bda0e17 102#endif
c085e333 103
2bda0e17 104#ifdef __WIN32__
a23fd0e1 105 #define _EXPORT
2bda0e17 106#else
a23fd0e1
VZ
107 #define _EXPORT _export
108#endif
109
110#ifndef __WIN32__
111 typedef signed short int SHORT;
2bda0e17 112#endif
c085e333
VZ
113
114#if !defined(__WIN32__) // 3.x uses FARPROC for dialogs
27a9bd48 115#ifndef STRICT
a23fd0e1 116 #define DLGPROC FARPROC
2bda0e17 117#endif
27a9bd48 118#endif
2bda0e17 119
47d67540 120#if wxUSE_PENWIN
cc2b7472
VZ
121 WXDLLEXPORT void wxRegisterPenWin();
122 WXDLLEXPORT void wxCleanUpPenWin();
123 WXDLLEXPORT void wxEnablePenAppHooks (bool hook);
124#endif // wxUSE_PENWIN
2bda0e17 125
47d67540 126#if wxUSE_ITSY_BITSY
a23fd0e1
VZ
127 #define IBS_HORZCAPTION 0x4000L
128 #define IBS_VERTCAPTION 0x8000L
2bda0e17 129
a23fd0e1
VZ
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
2bda0e17 135
1f112209 136#if wxUSE_CTL3D
a23fd0e1
VZ
137 #include "wx/msw/ctl3d/ctl3d.h"
138#endif // wxUSE_CTL3D
2bda0e17
KB
139
140/*
141 * Decide what window classes we're going to use
142 * for this combination of CTl3D/FAFA settings
143 */
c085e333 144
223d09f6 145#define STATIC_CLASS wxT("STATIC")
2bda0e17 146#define STATIC_FLAGS (SS_LEFT|WS_CHILD|WS_VISIBLE)
223d09f6 147#define CHECK_CLASS wxT("BUTTON")
2bda0e17
KB
148#define CHECK_FLAGS (BS_AUTOCHECKBOX|WS_TABSTOP|WS_CHILD)
149#define CHECK_IS_FAFA FALSE
223d09f6 150#define RADIO_CLASS wxT("BUTTON")
2bda0e17
KB
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
223d09f6 155#define GROUP_CLASS wxT("BUTTON")
2bda0e17
KB
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
a23fd0e1
VZ
163// ---------------------------------------------------------------------------
164// misc macros
165// ---------------------------------------------------------------------------
166
2bda0e17 167#define MEANING_CHARACTER '0'
5d368213 168#define DEFAULT_ITEM_WIDTH 100
2bda0e17 169#define DEFAULT_ITEM_HEIGHT 80
1c4a764c
VZ
170
171// Scale font to get edit control height
f6bcfd97
BP
172//#define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) (3*(cy)/2)
173#define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) (cy+8)
2bda0e17
KB
174
175// Generic subclass proc, for panel item moving/sizing and intercept
176// EDIT control VK_RETURN messages
177extern LONG APIENTRY _EXPORT
178 wxSubclassedGenericControlProc(WXHWND hWnd, WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
179
11c7d5b6
VZ
180// ---------------------------------------------------------------------------
181// useful macros and functions
182// ---------------------------------------------------------------------------
183
184// a wrapper macro for ZeroMemory()
04ef50df 185#if defined(__WIN32__) && !defined(__WXMICROWIN__)
11c7d5b6 186#define wxZeroMemory(obj) ::ZeroMemory(&obj, sizeof(obj))
0e528b99
JS
187#else
188#define wxZeroMemory(obj) memset((void*) & obj, 0, sizeof(obj))
189#endif
11c7d5b6 190
f6bcfd97
BP
191#if wxUSE_GUI
192
01dba85a 193#include <wx/gdicmn.h>
ed39ff57 194#include <wx/colour.h>
01dba85a 195
11c7d5b6
VZ
196// make conversion from wxColour and COLORREF a bit less painful
197inline COLORREF wxColourToRGB(const wxColour& c)
4ab861e5
VZ
198{
199 return RGB(c.Red(), c.Green(), c.Blue());
200}
201
202inline COLORREF wxColourToPalRGB(const wxColour& c)
11c7d5b6 203{
19193a2c 204 return PALETTERGB(c.Red(), c.Green(), c.Blue());
11c7d5b6
VZ
205}
206
d23c8ba2
VZ
207inline wxColour wxRGBToColour(COLORREF rgb)
208{
209 return wxColour(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb));
210}
211
11c7d5b6
VZ
212inline void wxRGBToColour(wxColour& c, COLORREF rgb)
213{
214 c.Set(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb));
215}
216
90c1530a
VZ
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!
225enum 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
234struct WXDLLEXPORT wxCOLORMAP
235{
236 COLORREF from, to;
237};
238
239// this function is implemented in src/msw/window.cpp
240extern wxCOLORMAP *wxGetStdColourMap();
241
ed791986
VZ
242// copy Windows RECT to our wxRect
243inline 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
d9317fd4
VZ
251// translations between HIMETRIC units (which OLE likes) and pixels (which are
252// liked by all the others) - implemented in msw/utilsexc.cpp
253extern void HIMETRICToPixel(LONG *x, LONG *y);
254extern void PixelToHIMETRIC(LONG *x, LONG *y);
255
4b7f2165
VZ
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
258extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w = 0, int h = 0);
259
211b54b1
VZ
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.
264extern HICON wxBitmapToHICON(const wxBitmap& bmp);
265
266// Same requirments as above apply and the bitmap must also have the correct
267// size.
268extern
269HCURSOR wxBitmapToHCURSOR(const wxBitmap& bmp, int hotSpotX, int hotSpotY);
270
8614c467
VZ
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
a95e38c0 280// get the current state of SHIFT/CTRL keys
1f80a703 281inline bool wxIsShiftDown()
a95e38c0 282{
1fdf858b
JS
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;
a95e38c0
VZ
287}
288
1f80a703 289inline bool wxIsCtrlDown()
a95e38c0 290{
1fdf858b
JS
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;
a95e38c0
VZ
295}
296
82c9f85c
VZ
297// wrapper around GetWindowRect() and GetClientRect() APIs doing error checking
298// for Win32
299inline RECT wxGetWindowRect(HWND hwnd)
300{
301 RECT rect;
3a5bcc4d 302
82c9f85c
VZ
303 if ( !::GetWindowRect(hwnd, &rect) )
304 {
305 wxLogLastError(_T("GetWindowRect"));
306 }
82c9f85c
VZ
307
308 return rect;
309}
310
311inline RECT wxGetClientRect(HWND hwnd)
312{
313 RECT rect;
3a5bcc4d 314
82c9f85c
VZ
315 if ( !::GetClientRect(hwnd, &rect) )
316 {
317 wxLogLastError(_T("GetClientRect"));
318 }
82c9f85c
VZ
319
320 return rect;
321}
322
6d167489
VZ
323// ---------------------------------------------------------------------------
324// small helper classes
325// ---------------------------------------------------------------------------
326
bffa02ff
VZ
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...)
330template <class T>
331struct WinStruct : public T
332{
333 WinStruct()
334 {
5eae641d
VZ
335 ::ZeroMemory(this, sizeof(T));
336 cbSize = sizeof(T);
bffa02ff
VZ
337 }
338};
339
340
6d167489
VZ
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
343class ScreenHDC
344{
345public:
091225b4
VZ
346 ScreenHDC() { m_hdc = ::GetDC(NULL); }
347 ~ScreenHDC() { ::ReleaseDC(NULL, m_hdc); }
348
349 operator HDC() const { return m_hdc; }
350
351private:
352 HDC m_hdc;
22f3361e
VZ
353
354 DECLARE_NO_COPY_CLASS(ScreenHDC)
091225b4
VZ
355};
356
697b08a8
VZ
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
091225b4
VZ
359class MemoryHDC
360{
361public:
9cf743aa 362 MemoryHDC(HDC hdc = 0) { m_hdc = ::CreateCompatibleDC(hdc); }
697b08a8 363 ~MemoryHDC() { ::DeleteDC(m_hdc); }
091225b4
VZ
364
365 operator HDC() const { return m_hdc; }
6d167489
VZ
366
367private:
368 HDC m_hdc;
22f3361e
VZ
369
370 DECLARE_NO_COPY_CLASS(MemoryHDC)
6d167489
VZ
371};
372
091225b4
VZ
373// a class which selects a GDI object into a DC in its ctor and deselects in
374// dtor
375class SelectInHDC
376{
377public:
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
386private:
387 HDC m_hdc;
388 HGDIOBJ m_hgdiobj;
22f3361e 389
51a2a728
VZ
390 DECLARE_NO_COPY_CLASS(SelectInHDC)
391};
392
7f0586ef 393#ifndef __WXWINCE__
51a2a728
VZ
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
06d09389 397class GlobalPtr
51a2a728
VZ
398{
399public:
06d09389 400 GlobalPtr(HGLOBAL hGlobal) : m_hGlobal(hGlobal)
51a2a728
VZ
401 {
402 m_ptr = ::GlobalLock(hGlobal);
403 if ( !m_ptr )
404 {
405 wxLogLastError(_T("GlobalLock"));
406 }
407 }
408
06d09389 409 ~GlobalPtr()
51a2a728
VZ
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
426private:
427 HGLOBAL m_hGlobal;
428 void *m_ptr;
429
06d09389 430 DECLARE_NO_COPY_CLASS(GlobalPtr)
091225b4 431};
7f0586ef 432#endif
091225b4 433
a23fd0e1 434// ---------------------------------------------------------------------------
42e69d6b 435// macros to make casting between WXFOO and FOO a bit easier: the GetFoo()
c50f1fb9
VZ
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)
a23fd0e1
VZ
439// ---------------------------------------------------------------------------
440
441#define GetHwnd() ((HWND)GetHWND())
c50f1fb9
VZ
442#define GetHwndOf(win) ((HWND)((win)->GetHWND()))
443// old name
444#define GetWinHwnd GetHwndOf
a23fd0e1
VZ
445
446#define GetHdc() ((HDC)GetHDC())
c50f1fb9 447#define GetHdcOf(dc) ((HDC)(dc).GetHDC())
a23fd0e1 448
11c7d5b6
VZ
449#define GetHbitmap() ((HBITMAP)GetHBITMAP())
450#define GetHbitmapOf(bmp) ((HBITMAP)(bmp).GetHBITMAP())
451
42e69d6b 452#define GetHicon() ((HICON)GetHICON())
c50f1fb9 453#define GetHiconOf(icon) ((HICON)(icon).GetHICON())
42e69d6b 454
a23fd0e1 455#define GetHaccel() ((HACCEL)GetHACCEL())
c50f1fb9
VZ
456#define GetHaccelOf(table) ((HACCEL)((table).GetHACCEL()))
457
ee50eab8
VZ
458#define GetHbrush() ((HPEN)GetResourceHandle())
459#define GetHbrushOf(brush) ((HPEN)(brush).GetResourceHandle())
460
c50f1fb9
VZ
461#define GetHmenu() ((HMENU)GetHMenu())
462#define GetHmenuOf(menu) ((HMENU)menu->GetHMenu())
a23fd0e1 463
bfbd6dc1
VZ
464#define GetHcursor() ((HCURSOR)GetHCURSOR())
465#define GetHcursorOf(cursor) ((HCURSOR)(cursor).GetHCURSOR())
466
f6bcfd97
BP
467#define GetHfont() ((HFONT)GetHFONT())
468#define GetHfontOf(font) ((HFONT)(font).GetHFONT())
469
1816a070 470#define GetHpalette() ((HPALETTE)GetHPALETTE())
b95edd47 471#define GetHpaletteOf(pal) ((HPALETTE)(pal).GetHPALETTE())
1816a070 472
75776373
VZ
473#define GetHpen() ((HPEN)GetResourceHandle())
474#define GetHpenOf(pen) ((HPEN)(pen).GetResourceHandle())
475
1e6feb95
VZ
476#define GetHrgn() ((HRGN)GetHRGN())
477#define GetHrgnOf(rgn) ((HRGN)(rgn).GetHRGN())
478
f6bcfd97
BP
479#endif // wxUSE_GUI
480
a23fd0e1
VZ
481// ---------------------------------------------------------------------------
482// global data
483// ---------------------------------------------------------------------------
2bda0e17 484
bddd7a8d 485WXDLLIMPEXP_DATA_BASE(extern HINSTANCE) wxhInstance;
2bda0e17 486
a23fd0e1
VZ
487// ---------------------------------------------------------------------------
488// global functions
489// ---------------------------------------------------------------------------
490
18600546
GRG
491extern "C"
492{
bb24c68f 493 WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
18600546
GRG
494}
495
bb24c68f 496WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
a23fd0e1 497
b568d04f
VZ
498#if wxUSE_GUI
499
bfbd6dc1
VZ
500// cursor stuff
501extern HCURSOR wxGetCurrentBusyCursor(); // from msw/utils.cpp
502extern const wxCursor *wxGetGlobalCursor(); // from msw/cursor.cpp
503
f68586e5 504WXDLLEXPORT void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font);
11c7d5b6
VZ
505WXDLLEXPORT void wxFillLogFont(LOGFONT *logFont, const wxFont *font);
506WXDLLEXPORT wxFont wxCreateFontFromLogFont(const LOGFONT *logFont);
f6bcfd97 507WXDLLEXPORT wxFontEncoding wxGetFontEncFromCharSet(int charset);
a23fd0e1
VZ
508
509WXDLLEXPORT void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos);
510WXDLLEXPORT void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos);
511
512// Find maximum size of window/rectangle
513WXDLLEXPORT extern void wxFindMaxSize(WXHWND hwnd, RECT *rect);
514
1c4a764c 515// Safely get the window text (i.e. without using fixed size buffer)
184b5d99 516WXDLLEXPORT extern wxString wxGetWindowText(WXHWND hWnd);
1c4a764c 517
cc2b7472
VZ
518// get the window class name
519WXDLLEXPORT extern wxString wxGetWindowClass(WXHWND hWnd);
520
42e69d6b
VZ
521// get the window id (should be unsigned, hence this is not wxWindowID which
522// is, for mainly historical reasons, signed)
523WXDLLEXPORT extern WXWORD wxGetWindowId(WXHWND hWnd);
cc2b7472 524
ae304744
VZ
525// check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
526// different
527WXDLLEXPORT extern bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc);
eb5e4d9a 528
c085e333 529// Does this window style specify any border?
184b5d99 530inline bool wxStyleHasBorder(long style)
c085e333 531{
82c9f85c
VZ
532 return (style & (wxSIMPLE_BORDER | wxRAISED_BORDER |
533 wxSUNKEN_BORDER | wxDOUBLE_BORDER)) != 0;
c085e333
VZ
534}
535
ae304744
VZ
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
542WXDLLEXPORT 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.
8614c467 547//
ae304744
VZ
548// returns the wxWindow corresponding to the given HWND or NULL.
549WXDLLEXPORT extern wxWindow *wxGetWindowFromHWND(WXHWND hwnd);
8614c467 550
6bad4c32 551// Get the size of an icon
ae304744 552WXDLLEXPORT extern wxSize wxGetHiconSize(HICON hicon);
6bad4c32 553
086b3a5b
JS
554// Lines are drawn differently for WinCE and regular WIN32
555WXDLLEXPORT void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2);
556
5e967044
JS
557// LocalAlloc should be used on WinCE
558#ifdef __WXWINCE__
559#include <winbase.h>
560
42d11c8e 561#if _WIN32_WCE <= 211
5e967044
JS
562#define GlobalAlloc LocalAlloc
563#define GlobalFree LocalFree
564#define GlobalLock(mem) mem
565#define GlobalUnlock(mem)
086b3a5b 566#define GlobalSize LocalSize
5e967044 567#define GPTR LPTR
086b3a5b
JS
568#define GHND LPTR
569#define GMEM_MOVEABLE 0
570#define GMEM_SHARE 0
42d11c8e 571#endif
5e967044
JS
572
573#if 0
574
575HLOCAL
576WINAPI
577LocalAlloc (
578 UINT fuFlags,
579 UINT cbBytes
580 );
581
582HLOCAL
583WINAPI
584LocalFree (
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__
5171ea0e
VZ
608
609// ----------------------------------------------------------------------------
610// 32/64 bit helpers
611// ----------------------------------------------------------------------------
612
613#ifdef __WIN64__
614
615inline void *wxGetWindowProc(HWND hwnd)
616{
617 return (void *)::GetWindowLongPtr(hwnd, GWLP_WNDPROC);
618}
619
620inline void *wxGetWindowUserData(HWND hwnd)
621{
622 return (void *)::GetWindowLongPtr(hwnd, GWLP_USERDATA);
623}
624
625inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
626{
627 return (WNDPROC)::SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)func);
628}
629
630inline void *wxSetWindowUserData(HWND hwnd, void *data)
631{
632 return (void *)::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)data);
633}
634
635#else // __WIN32__
636
637inline void *wxGetWindowProc(HWND hwnd)
638{
639 return (void *)::GetWindowLong(hwnd, GWL_WNDPROC);
640}
641
642inline void *wxGetWindowUserData(HWND hwnd)
643{
644 return (void *)::GetWindowLong(hwnd, GWL_USERDATA);
645}
646
647inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
648{
649 return (WNDPROC)::SetWindowLong(hwnd, GWL_WNDPROC, (LONG)func);
650}
651
652inline void *wxSetWindowUserData(HWND hwnd, void *data)
653{
654 return (void *)::SetWindowLong(hwnd, GWL_USERDATA, (LONG)data);
655}
656
657#endif // __WIN64__/__WIN32__
658
b568d04f
VZ
659#endif // wxUSE_GUI
660
2bda0e17 661#endif
bbcdf8bc 662 // _WX_PRIVATE_H_