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