| 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 |
| 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 | #ifdef __WXMICROWIN__ |
| 20 | // Extra prototypes and symbols not defined by MicroWindows |
| 21 | #include "wx/msw/microwin.h" |
| 22 | #endif |
| 23 | |
| 24 | #include "wx/log.h" |
| 25 | |
| 26 | #if wxUSE_GUI |
| 27 | #include "wx/window.h" |
| 28 | #endif // wxUSE_GUI |
| 29 | |
| 30 | class WXDLLIMPEXP_FWD_CORE wxFont; |
| 31 | class WXDLLIMPEXP_FWD_CORE wxWindow; |
| 32 | class WXDLLIMPEXP_FWD_CORE wxWindowBase; |
| 33 | |
| 34 | // --------------------------------------------------------------------------- |
| 35 | // private constants |
| 36 | // --------------------------------------------------------------------------- |
| 37 | |
| 38 | // 260 was taken from windef.h |
| 39 | #ifndef MAX_PATH |
| 40 | #define MAX_PATH 260 |
| 41 | #endif |
| 42 | |
| 43 | // --------------------------------------------------------------------------- |
| 44 | // standard icons from the resources |
| 45 | // --------------------------------------------------------------------------- |
| 46 | |
| 47 | #if wxUSE_GUI |
| 48 | |
| 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; |
| 56 | |
| 57 | #endif // wxUSE_GUI |
| 58 | |
| 59 | // --------------------------------------------------------------------------- |
| 60 | // global data |
| 61 | // --------------------------------------------------------------------------- |
| 62 | |
| 63 | extern WXDLLIMPEXP_DATA_BASE(HINSTANCE) wxhInstance; |
| 64 | |
| 65 | // --------------------------------------------------------------------------- |
| 66 | // define things missing from some compilers' headers |
| 67 | // --------------------------------------------------------------------------- |
| 68 | |
| 69 | #if defined(__WXWINCE__) || (defined(__GNUWIN32__) && !wxUSE_NORLANDER_HEADERS) |
| 70 | #ifndef ZeroMemory |
| 71 | inline void ZeroMemory(void *buf, size_t len) { memset(buf, 0, len); } |
| 72 | #endif |
| 73 | #endif // old mingw32 |
| 74 | |
| 75 | // this defines a CASTWNDPROC macro which casts a pointer to the type of a |
| 76 | // window proc |
| 77 | #if defined(STRICT) || defined(__GNUC__) |
| 78 | typedef WNDPROC WndProcCast; |
| 79 | #else |
| 80 | typedef FARPROC WndProcCast; |
| 81 | #endif |
| 82 | |
| 83 | |
| 84 | #define CASTWNDPROC (WndProcCast) |
| 85 | |
| 86 | |
| 87 | |
| 88 | // --------------------------------------------------------------------------- |
| 89 | // some stuff for old Windows versions (FIXME: what does it do here??) |
| 90 | // --------------------------------------------------------------------------- |
| 91 | |
| 92 | #if !defined(APIENTRY) // NT defines APIENTRY, 3.x not |
| 93 | #define APIENTRY FAR PASCAL |
| 94 | #endif |
| 95 | |
| 96 | #ifdef __WIN32__ |
| 97 | #define _EXPORT |
| 98 | #else |
| 99 | #define _EXPORT _export |
| 100 | #endif |
| 101 | |
| 102 | #ifndef __WIN32__ |
| 103 | typedef signed short int SHORT; |
| 104 | #endif |
| 105 | |
| 106 | #if !defined(__WIN32__) // 3.x uses FARPROC for dialogs |
| 107 | #ifndef STRICT |
| 108 | #define DLGPROC FARPROC |
| 109 | #endif |
| 110 | #endif |
| 111 | |
| 112 | /* |
| 113 | * Decide what window classes we're going to use |
| 114 | * for this combination of CTl3D/FAFA settings |
| 115 | */ |
| 116 | |
| 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 |
| 126 | #define PURE_WINDOWS |
| 127 | #define GROUP_CLASS wxT("BUTTON") |
| 128 | #define GROUP_FLAGS (BS_GROUPBOX|WS_CHILD|WS_VISIBLE) |
| 129 | |
| 130 | /* |
| 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) |
| 133 | */ |
| 134 | |
| 135 | // --------------------------------------------------------------------------- |
| 136 | // misc macros |
| 137 | // --------------------------------------------------------------------------- |
| 138 | |
| 139 | #define MEANING_CHARACTER '0' |
| 140 | #define DEFAULT_ITEM_WIDTH 100 |
| 141 | #define DEFAULT_ITEM_HEIGHT 80 |
| 142 | |
| 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) |
| 146 | |
| 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); |
| 151 | |
| 152 | // --------------------------------------------------------------------------- |
| 153 | // useful macros and functions |
| 154 | // --------------------------------------------------------------------------- |
| 155 | |
| 156 | // a wrapper macro for ZeroMemory() |
| 157 | #if defined(__WIN32__) && !defined(__WXMICROWIN__) |
| 158 | #define wxZeroMemory(obj) ::ZeroMemory(&obj, sizeof(obj)) |
| 159 | #else |
| 160 | #define wxZeroMemory(obj) memset((void*) & obj, 0, sizeof(obj)) |
| 161 | #endif |
| 162 | |
| 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 |
| 182 | #endif |
| 183 | |
| 184 | // close the handle in the class dtor |
| 185 | class AutoHANDLE |
| 186 | { |
| 187 | public: |
| 188 | wxEXPLICIT AutoHANDLE(HANDLE handle) : m_handle(handle) { } |
| 189 | |
| 190 | bool IsOk() const { return m_handle != INVALID_HANDLE_VALUE; } |
| 191 | operator HANDLE() const { return m_handle; } |
| 192 | |
| 193 | ~AutoHANDLE() { if ( IsOk() ) ::CloseHandle(m_handle); } |
| 194 | |
| 195 | protected: |
| 196 | HANDLE m_handle; |
| 197 | }; |
| 198 | |
| 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...) |
| 202 | template <class T> |
| 203 | struct WinStruct : public T |
| 204 | { |
| 205 | WinStruct() |
| 206 | { |
| 207 | ::ZeroMemory(this, sizeof(T)); |
| 208 | |
| 209 | // explicit qualification is required here for this to be valid C++ |
| 210 | this->cbSize = sizeof(T); |
| 211 | } |
| 212 | }; |
| 213 | |
| 214 | |
| 215 | #if wxUSE_GUI |
| 216 | |
| 217 | #include "wx/gdicmn.h" |
| 218 | #include "wx/colour.h" |
| 219 | |
| 220 | // make conversion from wxColour and COLORREF a bit less painful |
| 221 | inline COLORREF wxColourToRGB(const wxColour& c) |
| 222 | { |
| 223 | return RGB(c.Red(), c.Green(), c.Blue()); |
| 224 | } |
| 225 | |
| 226 | inline COLORREF wxColourToPalRGB(const wxColour& c) |
| 227 | { |
| 228 | return PALETTERGB(c.Red(), c.Green(), c.Blue()); |
| 229 | } |
| 230 | |
| 231 | inline wxColour wxRGBToColour(COLORREF rgb) |
| 232 | { |
| 233 | return wxColour(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb)); |
| 234 | } |
| 235 | |
| 236 | inline void wxRGBToColour(wxColour& c, COLORREF rgb) |
| 237 | { |
| 238 | c.Set(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb)); |
| 239 | } |
| 240 | |
| 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 |
| 243 | // |
| 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 |
| 246 | // |
| 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! |
| 249 | enum wxSTD_COLOUR |
| 250 | { |
| 251 | wxSTD_COL_BTNTEXT, |
| 252 | wxSTD_COL_BTNSHADOW, |
| 253 | wxSTD_COL_BTNFACE, |
| 254 | wxSTD_COL_BTNHIGHLIGHT, |
| 255 | wxSTD_COL_MAX |
| 256 | }; |
| 257 | |
| 258 | struct WXDLLIMPEXP_CORE wxCOLORMAP |
| 259 | { |
| 260 | COLORREF from, to; |
| 261 | }; |
| 262 | |
| 263 | // this function is implemented in src/msw/window.cpp |
| 264 | extern wxCOLORMAP *wxGetStdColourMap(); |
| 265 | |
| 266 | // create a wxRect from Windows RECT |
| 267 | inline wxRect wxRectFromRECT(const RECT& rc) |
| 268 | { |
| 269 | return wxRect(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top); |
| 270 | } |
| 271 | |
| 272 | // copy Windows RECT to our wxRect |
| 273 | inline void wxCopyRECTToRect(const RECT& rc, wxRect& rect) |
| 274 | { |
| 275 | rect = wxRectFromRECT(rc); |
| 276 | } |
| 277 | |
| 278 | // and vice versa |
| 279 | inline void wxCopyRectToRECT(const wxRect& rect, RECT& rc) |
| 280 | { |
| 281 | // note that we don't use wxRect::GetRight() as it is one of compared to |
| 282 | // wxRectFromRECT() above |
| 283 | rc.top = rect.y; |
| 284 | rc.left = rect.x; |
| 285 | rc.right = rect.x + rect.width; |
| 286 | rc.bottom = rect.y + rect.height; |
| 287 | } |
| 288 | |
| 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 PixelToHIMETRIC(LONG *x, LONG *y); |
| 293 | |
| 294 | // Windows convention of the mask is opposed to the wxWidgets one, so we need |
| 295 | // to invert the mask each time we pass one/get one to/from Windows |
| 296 | extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w = 0, int h = 0); |
| 297 | |
| 298 | // Creates an icon or cursor depending from a bitmap |
| 299 | // |
| 300 | // The bitmap must be valid and it should have a mask. If it doesn't, a default |
| 301 | // mask is created using light grey as the transparent colour. |
| 302 | extern HICON wxBitmapToHICON(const wxBitmap& bmp); |
| 303 | |
| 304 | // Same requirments as above apply and the bitmap must also have the correct |
| 305 | // size. |
| 306 | extern |
| 307 | HCURSOR wxBitmapToHCURSOR(const wxBitmap& bmp, int hotSpotX, int hotSpotY); |
| 308 | |
| 309 | // get (x, y) from DWORD - notice that HI/LOWORD can *not* be used because they |
| 310 | // will fail on system with multiple monitors where the coords may be negative |
| 311 | // |
| 312 | // these macros are standard now (Win98) but some older headers don't have them |
| 313 | #ifndef GET_X_LPARAM |
| 314 | #define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp)) |
| 315 | #define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp)) |
| 316 | #endif // GET_X_LPARAM |
| 317 | |
| 318 | // get the current state of SHIFT/CTRL/ALT keys |
| 319 | inline bool wxIsModifierDown(int vk) |
| 320 | { |
| 321 | // GetKeyState() returns different negative values on WinME and WinNT, |
| 322 | // so simply test for negative value. |
| 323 | return ::GetKeyState(vk) < 0; |
| 324 | } |
| 325 | |
| 326 | inline bool wxIsShiftDown() |
| 327 | { |
| 328 | return wxIsModifierDown(VK_SHIFT); |
| 329 | } |
| 330 | |
| 331 | inline bool wxIsCtrlDown() |
| 332 | { |
| 333 | return wxIsModifierDown(VK_CONTROL); |
| 334 | } |
| 335 | |
| 336 | inline bool wxIsAltDown() |
| 337 | { |
| 338 | return wxIsModifierDown(VK_MENU); |
| 339 | } |
| 340 | |
| 341 | inline bool wxIsAnyModifierDown() |
| 342 | { |
| 343 | return wxIsShiftDown() || wxIsCtrlDown() || wxIsAltDown(); |
| 344 | } |
| 345 | |
| 346 | // wrapper around GetWindowRect() and GetClientRect() APIs doing error checking |
| 347 | // for Win32 |
| 348 | inline RECT wxGetWindowRect(HWND hwnd) |
| 349 | { |
| 350 | RECT rect; |
| 351 | |
| 352 | if ( !::GetWindowRect(hwnd, &rect) ) |
| 353 | wxLogLastError(_T("GetWindowRect")); |
| 354 | |
| 355 | return rect; |
| 356 | } |
| 357 | |
| 358 | inline RECT wxGetClientRect(HWND hwnd) |
| 359 | { |
| 360 | RECT rect; |
| 361 | |
| 362 | if ( !::GetClientRect(hwnd, &rect) ) |
| 363 | wxLogLastError(_T("GetClientRect")); |
| 364 | |
| 365 | return rect; |
| 366 | } |
| 367 | |
| 368 | // --------------------------------------------------------------------------- |
| 369 | // small helper classes |
| 370 | // --------------------------------------------------------------------------- |
| 371 | |
| 372 | // create an instance of this class and use it as the HDC for screen, will |
| 373 | // automatically release the DC going out of scope |
| 374 | class ScreenHDC |
| 375 | { |
| 376 | public: |
| 377 | ScreenHDC() { m_hdc = ::GetDC(NULL); } |
| 378 | ~ScreenHDC() { ::ReleaseDC(NULL, m_hdc); } |
| 379 | |
| 380 | operator HDC() const { return m_hdc; } |
| 381 | |
| 382 | private: |
| 383 | HDC m_hdc; |
| 384 | |
| 385 | DECLARE_NO_COPY_CLASS(ScreenHDC) |
| 386 | }; |
| 387 | |
| 388 | // the same as ScreenHDC but for window DCs |
| 389 | class WindowHDC |
| 390 | { |
| 391 | public: |
| 392 | WindowHDC(HWND hwnd) { m_hdc = ::GetDC(m_hwnd = hwnd); } |
| 393 | ~WindowHDC() { ::ReleaseDC(m_hwnd, m_hdc); } |
| 394 | |
| 395 | operator HDC() const { return m_hdc; } |
| 396 | |
| 397 | private: |
| 398 | HWND m_hwnd; |
| 399 | HDC m_hdc; |
| 400 | |
| 401 | DECLARE_NO_COPY_CLASS(WindowHDC) |
| 402 | }; |
| 403 | |
| 404 | // the same as ScreenHDC but for memory DCs: creates the HDC compatible with |
| 405 | // the given one (screen by default) in ctor and destroys it in dtor |
| 406 | class MemoryHDC |
| 407 | { |
| 408 | public: |
| 409 | MemoryHDC(HDC hdc = 0) { m_hdc = ::CreateCompatibleDC(hdc); } |
| 410 | ~MemoryHDC() { ::DeleteDC(m_hdc); } |
| 411 | |
| 412 | operator HDC() const { return m_hdc; } |
| 413 | |
| 414 | private: |
| 415 | HDC m_hdc; |
| 416 | |
| 417 | DECLARE_NO_COPY_CLASS(MemoryHDC) |
| 418 | }; |
| 419 | |
| 420 | // a class which selects a GDI object into a DC in its ctor and deselects in |
| 421 | // dtor |
| 422 | class SelectInHDC |
| 423 | { |
| 424 | private: |
| 425 | void DoInit(HGDIOBJ hgdiobj) { m_hgdiobj = ::SelectObject(m_hdc, hgdiobj); } |
| 426 | |
| 427 | public: |
| 428 | SelectInHDC() : m_hdc(NULL) { } |
| 429 | SelectInHDC(HDC hdc, HGDIOBJ hgdiobj) : m_hdc(hdc) { DoInit(hgdiobj); } |
| 430 | |
| 431 | void Init(HDC hdc, HGDIOBJ hgdiobj) |
| 432 | { |
| 433 | wxASSERT_MSG( !m_hdc, _T("initializing twice?") ); |
| 434 | |
| 435 | m_hdc = hdc; |
| 436 | |
| 437 | DoInit(hgdiobj); |
| 438 | } |
| 439 | |
| 440 | ~SelectInHDC() { if ( m_hdc ) ::SelectObject(m_hdc, m_hgdiobj); } |
| 441 | |
| 442 | // return true if the object was successfully selected |
| 443 | operator bool() const { return m_hgdiobj != 0; } |
| 444 | |
| 445 | private: |
| 446 | HDC m_hdc; |
| 447 | HGDIOBJ m_hgdiobj; |
| 448 | |
| 449 | DECLARE_NO_COPY_CLASS(SelectInHDC) |
| 450 | }; |
| 451 | |
| 452 | // a class which cleans up any GDI object |
| 453 | class AutoGDIObject |
| 454 | { |
| 455 | protected: |
| 456 | AutoGDIObject() { m_gdiobj = NULL; } |
| 457 | AutoGDIObject(HGDIOBJ gdiobj) : m_gdiobj(gdiobj) { } |
| 458 | ~AutoGDIObject() { if ( m_gdiobj ) ::DeleteObject(m_gdiobj); } |
| 459 | |
| 460 | void InitGdiobj(HGDIOBJ gdiobj) |
| 461 | { |
| 462 | wxASSERT_MSG( !m_gdiobj, _T("initializing twice?") ); |
| 463 | |
| 464 | m_gdiobj = gdiobj; |
| 465 | } |
| 466 | |
| 467 | HGDIOBJ GetObject() const { return m_gdiobj; } |
| 468 | |
| 469 | private: |
| 470 | HGDIOBJ m_gdiobj; |
| 471 | }; |
| 472 | |
| 473 | // TODO: all this asks for using a AutoHandler<T, CreateFunc> template... |
| 474 | |
| 475 | // a class for temporary brushes |
| 476 | class AutoHBRUSH : private AutoGDIObject |
| 477 | { |
| 478 | public: |
| 479 | AutoHBRUSH(COLORREF col) |
| 480 | : AutoGDIObject(::CreateSolidBrush(col)) { } |
| 481 | |
| 482 | operator HBRUSH() const { return (HBRUSH)GetObject(); } |
| 483 | }; |
| 484 | |
| 485 | // a class for temporary fonts |
| 486 | class AutoHFONT : private AutoGDIObject |
| 487 | { |
| 488 | private: |
| 489 | public: |
| 490 | AutoHFONT() |
| 491 | : AutoGDIObject() { } |
| 492 | |
| 493 | AutoHFONT(const LOGFONT& lf) |
| 494 | : AutoGDIObject(::CreateFontIndirect(&lf)) { } |
| 495 | |
| 496 | void Init(const LOGFONT& lf) { InitGdiobj(::CreateFontIndirect(&lf)); } |
| 497 | |
| 498 | operator HFONT() const { return (HFONT)GetObject(); } |
| 499 | }; |
| 500 | |
| 501 | // a class for temporary pens |
| 502 | class AutoHPEN : private AutoGDIObject |
| 503 | { |
| 504 | public: |
| 505 | AutoHPEN(COLORREF col) |
| 506 | : AutoGDIObject(::CreatePen(PS_SOLID, 0, col)) { } |
| 507 | |
| 508 | operator HPEN() const { return (HPEN)GetObject(); } |
| 509 | }; |
| 510 | |
| 511 | // classes for temporary bitmaps |
| 512 | class AutoHBITMAP : private AutoGDIObject |
| 513 | { |
| 514 | public: |
| 515 | AutoHBITMAP(HBITMAP hbmp) : AutoGDIObject(hbmp) { } |
| 516 | |
| 517 | operator HBITMAP() const { return (HBITMAP)GetObject(); } |
| 518 | }; |
| 519 | |
| 520 | class CompatibleBitmap : public AutoHBITMAP |
| 521 | { |
| 522 | public: |
| 523 | CompatibleBitmap(HDC hdc, int w, int h) |
| 524 | : AutoHBITMAP(::CreateCompatibleBitmap(hdc, w, h)) |
| 525 | { |
| 526 | } |
| 527 | }; |
| 528 | |
| 529 | class MonoBitmap : public AutoHBITMAP |
| 530 | { |
| 531 | public: |
| 532 | MonoBitmap(int w, int h) |
| 533 | : AutoHBITMAP(::CreateBitmap(w, h, 1, 1, 0)) |
| 534 | { |
| 535 | } |
| 536 | }; |
| 537 | |
| 538 | // class automatically destroys the region object |
| 539 | class AutoHRGN : private AutoGDIObject |
| 540 | { |
| 541 | public: |
| 542 | AutoHRGN(HRGN hrgn) : AutoGDIObject(hrgn) { } |
| 543 | |
| 544 | operator HRGN() const { return (HRGN)GetObject(); } |
| 545 | }; |
| 546 | |
| 547 | // class sets the specified clipping region during its life time |
| 548 | class HDCClipper |
| 549 | { |
| 550 | public: |
| 551 | HDCClipper(HDC hdc, HRGN hrgn) |
| 552 | : m_hdc(hdc) |
| 553 | { |
| 554 | if ( !::SelectClipRgn(hdc, hrgn) ) |
| 555 | wxLogLastError(_T("SelectClipRgn")); |
| 556 | } |
| 557 | |
| 558 | ~HDCClipper() |
| 559 | { |
| 560 | ::SelectClipRgn(m_hdc, NULL); |
| 561 | } |
| 562 | |
| 563 | private: |
| 564 | HDC m_hdc; |
| 565 | |
| 566 | DECLARE_NO_COPY_CLASS(HDCClipper) |
| 567 | }; |
| 568 | |
| 569 | // set the given map mode for the life time of this object |
| 570 | // |
| 571 | // NB: SetMapMode() is not supported by CE so we also define a helper macro |
| 572 | // to avoid using it there |
| 573 | #ifdef __WXWINCE__ |
| 574 | #define wxCHANGE_HDC_MAP_MODE(hdc, mm) |
| 575 | #else // !__WXWINCE__ |
| 576 | class HDCMapModeChanger |
| 577 | { |
| 578 | public: |
| 579 | HDCMapModeChanger(HDC hdc, int mm) |
| 580 | : m_hdc(hdc) |
| 581 | { |
| 582 | m_modeOld = ::SetMapMode(hdc, mm); |
| 583 | if ( !m_modeOld ) |
| 584 | wxLogLastError(_T("SelectClipRgn")); |
| 585 | } |
| 586 | |
| 587 | ~HDCMapModeChanger() |
| 588 | { |
| 589 | if ( m_modeOld ) |
| 590 | ::SetMapMode(m_hdc, m_modeOld); |
| 591 | } |
| 592 | |
| 593 | private: |
| 594 | HDC m_hdc; |
| 595 | int m_modeOld; |
| 596 | |
| 597 | DECLARE_NO_COPY_CLASS(HDCMapModeChanger) |
| 598 | }; |
| 599 | |
| 600 | #define wxCHANGE_HDC_MAP_MODE(hdc, mm) \ |
| 601 | HDCMapModeChanger wxMAKE_UNIQUE_NAME(wxHDCMapModeChanger)(hdc, mm) |
| 602 | #endif // __WXWINCE__/!__WXWINCE__ |
| 603 | |
| 604 | // smart pointer using GlobalAlloc/GlobalFree() |
| 605 | class GlobalPtr |
| 606 | { |
| 607 | public: |
| 608 | // allocates a block of given size |
| 609 | GlobalPtr(size_t size, unsigned flags = GMEM_MOVEABLE) |
| 610 | { |
| 611 | m_hGlobal = ::GlobalAlloc(flags, size); |
| 612 | if ( !m_hGlobal ) |
| 613 | wxLogLastError(_T("GlobalAlloc")); |
| 614 | } |
| 615 | |
| 616 | ~GlobalPtr() |
| 617 | { |
| 618 | if ( m_hGlobal && ::GlobalFree(m_hGlobal) ) |
| 619 | wxLogLastError(_T("GlobalFree")); |
| 620 | } |
| 621 | |
| 622 | // implicit conversion |
| 623 | operator HGLOBAL() const { return m_hGlobal; } |
| 624 | |
| 625 | private: |
| 626 | HGLOBAL m_hGlobal; |
| 627 | |
| 628 | DECLARE_NO_COPY_CLASS(GlobalPtr) |
| 629 | }; |
| 630 | |
| 631 | // when working with global pointers (which is unfortunately still necessary |
| 632 | // sometimes, e.g. for clipboard) it is important to unlock them exactly as |
| 633 | // many times as we lock them which just asks for using a "smart lock" class |
| 634 | class GlobalPtrLock |
| 635 | { |
| 636 | public: |
| 637 | // default ctor, use Init() later -- should only be used if the HGLOBAL can |
| 638 | // be NULL (in which case Init() shouldn't be called) |
| 639 | GlobalPtrLock() |
| 640 | { |
| 641 | m_hGlobal = NULL; |
| 642 | m_ptr = NULL; |
| 643 | } |
| 644 | |
| 645 | // initialize the object, may be only called if we were created using the |
| 646 | // default ctor; HGLOBAL must not be NULL |
| 647 | void Init(HGLOBAL hGlobal) |
| 648 | { |
| 649 | m_hGlobal = hGlobal; |
| 650 | |
| 651 | // NB: GlobalLock() is a macro, not a function, hence don't use the |
| 652 | // global scope operator with it (and neither with GlobalUnlock()) |
| 653 | m_ptr = GlobalLock(hGlobal); |
| 654 | if ( !m_ptr ) |
| 655 | wxLogLastError(_T("GlobalLock")); |
| 656 | } |
| 657 | |
| 658 | // initialize the object, HGLOBAL must not be NULL |
| 659 | GlobalPtrLock(HGLOBAL hGlobal) |
| 660 | { |
| 661 | Init(hGlobal); |
| 662 | } |
| 663 | |
| 664 | ~GlobalPtrLock() |
| 665 | { |
| 666 | if ( m_hGlobal && !GlobalUnlock(m_hGlobal) ) |
| 667 | { |
| 668 | #ifdef __WXDEBUG__ |
| 669 | // this might happen simply because the block became unlocked |
| 670 | DWORD dwLastError = ::GetLastError(); |
| 671 | if ( dwLastError != NO_ERROR ) |
| 672 | { |
| 673 | wxLogApiError(_T("GlobalUnlock"), dwLastError); |
| 674 | } |
| 675 | #endif // __WXDEBUG__ |
| 676 | } |
| 677 | } |
| 678 | |
| 679 | void *Get() const { return m_ptr; } |
| 680 | operator void *() const { return m_ptr; } |
| 681 | |
| 682 | private: |
| 683 | HGLOBAL m_hGlobal; |
| 684 | void *m_ptr; |
| 685 | |
| 686 | DECLARE_NO_COPY_CLASS(GlobalPtrLock) |
| 687 | }; |
| 688 | |
| 689 | // register the class when it is first needed and unregister it in dtor |
| 690 | class ClassRegistrar |
| 691 | { |
| 692 | public: |
| 693 | // ctor doesn't register the class, call Initialize() for this |
| 694 | ClassRegistrar() { m_registered = -1; } |
| 695 | |
| 696 | // return true if the class is already registered |
| 697 | bool IsInitialized() const { return m_registered != -1; } |
| 698 | |
| 699 | // return true if the class had been already registered |
| 700 | bool IsRegistered() const { return m_registered == 1; } |
| 701 | |
| 702 | // try to register the class if not done yet, return true on success |
| 703 | bool Register(const WNDCLASS& wc) |
| 704 | { |
| 705 | // we should only be called if we hadn't been initialized yet |
| 706 | wxASSERT_MSG( m_registered == -1, |
| 707 | _T("calling ClassRegistrar::Register() twice?") ); |
| 708 | |
| 709 | m_registered = ::RegisterClass(&wc) ? 1 : 0; |
| 710 | if ( !IsRegistered() ) |
| 711 | { |
| 712 | wxLogLastError(_T("RegisterClassEx()")); |
| 713 | } |
| 714 | else |
| 715 | { |
| 716 | m_clsname = wc.lpszClassName; |
| 717 | } |
| 718 | |
| 719 | return m_registered == 1; |
| 720 | } |
| 721 | |
| 722 | // get the name of the registered class (returns empty string if not |
| 723 | // registered) |
| 724 | const wxString& GetName() const { return m_clsname; } |
| 725 | |
| 726 | // unregister the class if it had been registered |
| 727 | ~ClassRegistrar() |
| 728 | { |
| 729 | if ( IsRegistered() ) |
| 730 | { |
| 731 | if ( !::UnregisterClass(m_clsname.wx_str(), wxhInstance) ) |
| 732 | { |
| 733 | wxLogLastError(_T("UnregisterClass")); |
| 734 | } |
| 735 | } |
| 736 | } |
| 737 | |
| 738 | private: |
| 739 | // initial value is -1 which means that we hadn't tried registering the |
| 740 | // class yet, it becomes true or false (1 or 0) when Initialize() is called |
| 741 | int m_registered; |
| 742 | |
| 743 | // the name of the class, only non empty if it had been registered |
| 744 | wxString m_clsname; |
| 745 | }; |
| 746 | |
| 747 | // --------------------------------------------------------------------------- |
| 748 | // macros to make casting between WXFOO and FOO a bit easier: the GetFoo() |
| 749 | // returns Foo cast to the Windows type for oruselves, while GetFooOf() takes |
| 750 | // an argument which should be a pointer or reference to the object of the |
| 751 | // corresponding class (this depends on the macro) |
| 752 | // --------------------------------------------------------------------------- |
| 753 | |
| 754 | #define GetHwnd() ((HWND)GetHWND()) |
| 755 | #define GetHwndOf(win) ((HWND)((win)->GetHWND())) |
| 756 | // old name |
| 757 | #define GetWinHwnd GetHwndOf |
| 758 | |
| 759 | #define GetHdc() ((HDC)GetHDC()) |
| 760 | #define GetHdcOf(dc) ((HDC)(dc).GetHDC()) |
| 761 | |
| 762 | #define GetHbitmap() ((HBITMAP)GetHBITMAP()) |
| 763 | #define GetHbitmapOf(bmp) ((HBITMAP)(bmp).GetHBITMAP()) |
| 764 | |
| 765 | #define GetHicon() ((HICON)GetHICON()) |
| 766 | #define GetHiconOf(icon) ((HICON)(icon).GetHICON()) |
| 767 | |
| 768 | #define GetHaccel() ((HACCEL)GetHACCEL()) |
| 769 | #define GetHaccelOf(table) ((HACCEL)((table).GetHACCEL())) |
| 770 | |
| 771 | #define GetHbrush() ((HBRUSH)GetResourceHandle()) |
| 772 | #define GetHbrushOf(brush) ((HBRUSH)(brush).GetResourceHandle()) |
| 773 | |
| 774 | #define GetHmenu() ((HMENU)GetHMenu()) |
| 775 | #define GetHmenuOf(menu) ((HMENU)menu->GetHMenu()) |
| 776 | |
| 777 | #define GetHcursor() ((HCURSOR)GetHCURSOR()) |
| 778 | #define GetHcursorOf(cursor) ((HCURSOR)(cursor).GetHCURSOR()) |
| 779 | |
| 780 | #define GetHfont() ((HFONT)GetHFONT()) |
| 781 | #define GetHfontOf(font) ((HFONT)(font).GetHFONT()) |
| 782 | |
| 783 | #define GetHimagelist() ((HIMAGELIST)GetHIMAGELIST()) |
| 784 | #define GetHimagelistOf(imgl) ((HIMAGELIST)imgl->GetHIMAGELIST()) |
| 785 | |
| 786 | #define GetHpalette() ((HPALETTE)GetHPALETTE()) |
| 787 | #define GetHpaletteOf(pal) ((HPALETTE)(pal).GetHPALETTE()) |
| 788 | |
| 789 | #define GetHpen() ((HPEN)GetResourceHandle()) |
| 790 | #define GetHpenOf(pen) ((HPEN)(pen).GetResourceHandle()) |
| 791 | |
| 792 | #define GetHrgn() ((HRGN)GetHRGN()) |
| 793 | #define GetHrgnOf(rgn) ((HRGN)(rgn).GetHRGN()) |
| 794 | |
| 795 | #endif // wxUSE_GUI |
| 796 | |
| 797 | // --------------------------------------------------------------------------- |
| 798 | // global functions |
| 799 | // --------------------------------------------------------------------------- |
| 800 | |
| 801 | extern "C" |
| 802 | { |
| 803 | WXDLLIMPEXP_BASE HINSTANCE wxGetInstance(); |
| 804 | } |
| 805 | |
| 806 | WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst); |
| 807 | |
| 808 | // return the full path of the given module |
| 809 | inline wxString wxGetFullModuleName(HMODULE hmod) |
| 810 | { |
| 811 | wxString fullname; |
| 812 | if ( !::GetModuleFileName |
| 813 | ( |
| 814 | hmod, |
| 815 | wxStringBuffer(fullname, MAX_PATH), |
| 816 | MAX_PATH |
| 817 | ) ) |
| 818 | { |
| 819 | wxLogLastError(_T("GetModuleFileName")); |
| 820 | } |
| 821 | |
| 822 | return fullname; |
| 823 | } |
| 824 | |
| 825 | // return the full path of the program file |
| 826 | inline wxString wxGetFullModuleName() |
| 827 | { |
| 828 | return wxGetFullModuleName((HMODULE)wxGetInstance()); |
| 829 | } |
| 830 | |
| 831 | // return the run-time version of the OS in a format similar to |
| 832 | // WINVER/_WIN32_WINNT compile-time macros: |
| 833 | // |
| 834 | // 0x0300 Windows NT 3.51 |
| 835 | // 0x0400 Windows 95, NT4 |
| 836 | // 0x0410 Windows 98 |
| 837 | // 0x0500 Windows ME, 2000 |
| 838 | // 0x0501 Windows XP |
| 839 | // 0x0502 Windows 2003 |
| 840 | // 0x0600 Longhorn |
| 841 | // |
| 842 | // for the other Windows versions 0 is currently returned |
| 843 | enum wxWinVersion |
| 844 | { |
| 845 | wxWinVersion_Unknown = 0, |
| 846 | |
| 847 | wxWinVersion_3 = 0x0300, |
| 848 | wxWinVersion_NT3 = wxWinVersion_3, |
| 849 | |
| 850 | wxWinVersion_4 = 0x0400, |
| 851 | wxWinVersion_95 = wxWinVersion_4, |
| 852 | wxWinVersion_NT4 = wxWinVersion_4, |
| 853 | wxWinVersion_98 = 0x0410, |
| 854 | |
| 855 | wxWinVersion_5 = 0x0500, |
| 856 | wxWinVersion_ME = wxWinVersion_5, |
| 857 | wxWinVersion_NT5 = wxWinVersion_5, |
| 858 | wxWinVersion_2000 = wxWinVersion_5, |
| 859 | wxWinVersion_XP = 0x0501, |
| 860 | wxWinVersion_2003 = 0x0502, |
| 861 | |
| 862 | wxWinVersion_6 = 0x0600, |
| 863 | wxWinVersion_Vista = wxWinVersion_6, |
| 864 | wxWinVersion_NT6 = wxWinVersion_6 |
| 865 | }; |
| 866 | |
| 867 | WXDLLIMPEXP_BASE wxWinVersion wxGetWinVersion(); |
| 868 | |
| 869 | #if wxUSE_GUI |
| 870 | |
| 871 | // cursor stuff |
| 872 | extern HCURSOR wxGetCurrentBusyCursor(); // from msw/utils.cpp |
| 873 | extern const wxCursor *wxGetGlobalCursor(); // from msw/cursor.cpp |
| 874 | |
| 875 | WXDLLIMPEXP_CORE void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font); |
| 876 | WXDLLIMPEXP_CORE void wxFillLogFont(LOGFONT *logFont, const wxFont *font); |
| 877 | WXDLLIMPEXP_CORE wxFont wxCreateFontFromLogFont(const LOGFONT *logFont); |
| 878 | WXDLLIMPEXP_CORE wxFontEncoding wxGetFontEncFromCharSet(int charset); |
| 879 | |
| 880 | WXDLLIMPEXP_CORE void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos); |
| 881 | WXDLLIMPEXP_CORE void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos); |
| 882 | |
| 883 | // Find maximum size of window/rectangle |
| 884 | extern WXDLLIMPEXP_CORE void wxFindMaxSize(WXHWND hwnd, RECT *rect); |
| 885 | |
| 886 | // Safely get the window text (i.e. without using fixed size buffer) |
| 887 | extern WXDLLIMPEXP_CORE wxString wxGetWindowText(WXHWND hWnd); |
| 888 | |
| 889 | // get the window class name |
| 890 | extern WXDLLIMPEXP_CORE wxString wxGetWindowClass(WXHWND hWnd); |
| 891 | |
| 892 | // get the window id (should be unsigned, hence this is not wxWindowID which |
| 893 | // is, for mainly historical reasons, signed) |
| 894 | extern WXDLLIMPEXP_CORE int wxGetWindowId(WXHWND hWnd); |
| 895 | |
| 896 | // check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are |
| 897 | // different |
| 898 | extern WXDLLIMPEXP_CORE bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc); |
| 899 | |
| 900 | // Does this window style specify any border? |
| 901 | inline bool wxStyleHasBorder(long style) |
| 902 | { |
| 903 | return (style & (wxSIMPLE_BORDER | wxRAISED_BORDER | |
| 904 | wxSUNKEN_BORDER | wxDOUBLE_BORDER)) != 0; |
| 905 | } |
| 906 | |
| 907 | inline long wxGetWindowExStyle(const wxWindowMSW *win) |
| 908 | { |
| 909 | return ::GetWindowLong(GetHwndOf(win), GWL_EXSTYLE); |
| 910 | } |
| 911 | |
| 912 | inline bool wxHasWindowExStyle(const wxWindowMSW *win, long style) |
| 913 | { |
| 914 | return (wxGetWindowExStyle(win) & style) != 0; |
| 915 | } |
| 916 | |
| 917 | inline long wxSetWindowExStyle(const wxWindowMSW *win, long style) |
| 918 | { |
| 919 | return ::SetWindowLong(GetHwndOf(win), GWL_EXSTYLE, style); |
| 920 | } |
| 921 | |
| 922 | // ---------------------------------------------------------------------------- |
| 923 | // functions mapping HWND to wxWindow |
| 924 | // ---------------------------------------------------------------------------- |
| 925 | |
| 926 | // this function simply checks whether the given hwnd corresponds to a wxWindow |
| 927 | // and returns either that window if it does or NULL otherwise |
| 928 | extern WXDLLIMPEXP_CORE wxWindow* wxFindWinFromHandle(HWND hwnd); |
| 929 | |
| 930 | // without STRICT WXHWND is the same as HWND anyhow |
| 931 | inline wxWindow* wxFindWinFromHandle(WXHWND hWnd) |
| 932 | { |
| 933 | return wxFindWinFromHandle(wx_static_cast(HWND, hWnd)); |
| 934 | } |
| 935 | |
| 936 | // find the window for HWND which is part of some wxWindow, i.e. unlike |
| 937 | // wxFindWinFromHandle() above it will also work for "sub controls" of a |
| 938 | // wxWindow. |
| 939 | // |
| 940 | // returns the wxWindow corresponding to the given HWND or NULL. |
| 941 | extern WXDLLIMPEXP_CORE wxWindow *wxGetWindowFromHWND(WXHWND hwnd); |
| 942 | |
| 943 | // Get the size of an icon |
| 944 | extern WXDLLIMPEXP_CORE wxSize wxGetHiconSize(HICON hicon); |
| 945 | |
| 946 | // Lines are drawn differently for WinCE and regular WIN32 |
| 947 | WXDLLIMPEXP_CORE void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2); |
| 948 | |
| 949 | // fill the client rect of the given window on the provided dc using this brush |
| 950 | inline void wxFillRect(HWND hwnd, HDC hdc, HBRUSH hbr) |
| 951 | { |
| 952 | RECT rc; |
| 953 | ::GetClientRect(hwnd, &rc); |
| 954 | ::FillRect(hdc, &rc, hbr); |
| 955 | } |
| 956 | |
| 957 | // ---------------------------------------------------------------------------- |
| 958 | // 32/64 bit helpers |
| 959 | // ---------------------------------------------------------------------------- |
| 960 | |
| 961 | #ifdef __WIN64__ |
| 962 | |
| 963 | inline void *wxGetWindowProc(HWND hwnd) |
| 964 | { |
| 965 | return (void *)::GetWindowLongPtr(hwnd, GWLP_WNDPROC); |
| 966 | } |
| 967 | |
| 968 | inline void *wxGetWindowUserData(HWND hwnd) |
| 969 | { |
| 970 | return (void *)::GetWindowLongPtr(hwnd, GWLP_USERDATA); |
| 971 | } |
| 972 | |
| 973 | inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func) |
| 974 | { |
| 975 | return (WNDPROC)::SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)func); |
| 976 | } |
| 977 | |
| 978 | inline void *wxSetWindowUserData(HWND hwnd, void *data) |
| 979 | { |
| 980 | return (void *)::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)data); |
| 981 | } |
| 982 | |
| 983 | #else // __WIN32__ |
| 984 | |
| 985 | // note that the casts to LONG_PTR here are required even on 32-bit machines |
| 986 | // for the 64-bit warning mode of later versions of MSVC (C4311/4312) |
| 987 | inline WNDPROC wxGetWindowProc(HWND hwnd) |
| 988 | { |
| 989 | return (WNDPROC)(LONG_PTR)::GetWindowLong(hwnd, GWL_WNDPROC); |
| 990 | } |
| 991 | |
| 992 | inline void *wxGetWindowUserData(HWND hwnd) |
| 993 | { |
| 994 | return (void *)(LONG_PTR)::GetWindowLong(hwnd, GWL_USERDATA); |
| 995 | } |
| 996 | |
| 997 | inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func) |
| 998 | { |
| 999 | return (WNDPROC)(LONG_PTR)::SetWindowLong(hwnd, GWL_WNDPROC, (LONG_PTR)func); |
| 1000 | } |
| 1001 | |
| 1002 | inline void *wxSetWindowUserData(HWND hwnd, void *data) |
| 1003 | { |
| 1004 | return (void *)(LONG_PTR)::SetWindowLong(hwnd, GWL_USERDATA, (LONG_PTR)data); |
| 1005 | } |
| 1006 | |
| 1007 | #endif // __WIN64__/__WIN32__ |
| 1008 | |
| 1009 | #endif // wxUSE_GUI |
| 1010 | |
| 1011 | #endif // _WX_PRIVATE_H_ |