]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/msw/private.h
Don't define __STRICT_ANSI__, we should build both with and without it.
[wxWidgets.git] / include / wx / msw / private.h
index dd0bd996a37836fcae9a5fd3f6eff4811a049b44..0f966b841b8afb7fb2dfe64376df332ca7360f79 100644 (file)
@@ -6,7 +6,6 @@
 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97
-// RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
     #include "wx/msw/microwin.h"
 #endif
 
-// Include fixes for MSLU:
-#include "wx/msw/mslu.h"
-
 #include "wx/log.h"
 
-class WXDLLEXPORT wxFont;
-class WXDLLEXPORT wxWindow;
-class WXDLLEXPORT wxWindowBase;
+#if wxUSE_GUI
+    #include "wx/window.h"
+#endif // wxUSE_GUI
+
+class WXDLLIMPEXP_FWD_CORE wxFont;
+class WXDLLIMPEXP_FWD_CORE wxWindow;
+class WXDLLIMPEXP_FWD_CORE wxWindowBase;
 
 // ---------------------------------------------------------------------------
 // private constants
@@ -45,13 +45,13 @@ class WXDLLEXPORT wxWindowBase;
 
 #if wxUSE_GUI
 
-extern WXDLLEXPORT_DATA(HICON) wxSTD_FRAME_ICON;
-extern WXDLLEXPORT_DATA(HICON) wxSTD_MDIPARENTFRAME_ICON;
-extern WXDLLEXPORT_DATA(HICON) wxSTD_MDICHILDFRAME_ICON;
-extern WXDLLEXPORT_DATA(HICON) wxDEFAULT_FRAME_ICON;
-extern WXDLLEXPORT_DATA(HICON) wxDEFAULT_MDIPARENTFRAME_ICON;
-extern WXDLLEXPORT_DATA(HICON) wxDEFAULT_MDICHILDFRAME_ICON;
-extern WXDLLEXPORT_DATA(HFONT) wxSTATUS_LINE_FONT;
+extern WXDLLIMPEXP_DATA_CORE(HICON) wxSTD_FRAME_ICON;
+extern WXDLLIMPEXP_DATA_CORE(HICON) wxSTD_MDIPARENTFRAME_ICON;
+extern WXDLLIMPEXP_DATA_CORE(HICON) wxSTD_MDICHILDFRAME_ICON;
+extern WXDLLIMPEXP_DATA_CORE(HICON) wxDEFAULT_FRAME_ICON;
+extern WXDLLIMPEXP_DATA_CORE(HICON) wxDEFAULT_MDIPARENTFRAME_ICON;
+extern WXDLLIMPEXP_DATA_CORE(HICON) wxDEFAULT_MDICHILDFRAME_ICON;
+extern WXDLLIMPEXP_DATA_CORE(HFONT) wxSTATUS_LINE_FONT;
 
 #endif // wxUSE_GUI
 
@@ -61,6 +61,13 @@ extern WXDLLEXPORT_DATA(HFONT) wxSTATUS_LINE_FONT;
 
 extern WXDLLIMPEXP_DATA_BASE(HINSTANCE) wxhInstance;
 
+extern "C"
+{
+    WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
+}
+
+WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
+
 // ---------------------------------------------------------------------------
 // define things missing from some compilers' headers
 // ---------------------------------------------------------------------------
@@ -161,20 +168,22 @@ extern LONG APIENTRY _EXPORT
 
 // This one is a macro so that it can be tested with #ifdef, it will be
 // undefined if it cannot be implemented for a given compiler.
-// Vc++, bcc, dmc, ow, mingw, codewarrior (and rsxnt) have _get_osfhandle.
-// Cygwin has get_osfhandle. Others are currently unknown, e.g. Salford,
-// Intel, Visual Age.
+// Vc++, bcc, dmc, ow, mingw akk have _get_osfhandle() and Cygwin has
+// get_osfhandle. Others are currently unknown, e.g. Salford, Intel, Visual
+// Age.
 #if defined(__WXWINCE__)
     #define wxGetOSFHandle(fd) ((HANDLE)fd)
+    #define wxOpenOSFHandle(h, flags) ((int)wxPtrToUInt(h))
 #elif defined(__CYGWIN__)
     #define wxGetOSFHandle(fd) ((HANDLE)get_osfhandle(fd))
 #elif defined(__VISUALC__) \
    || defined(__BORLANDC__) \
    || defined(__DMC__) \
    || defined(__WATCOMC__) \
-   || defined(__MINGW32__) \
-   || (defined(__MWERKS__) && defined(__MSL__))
+   || defined(__MINGW32__)
     #define wxGetOSFHandle(fd) ((HANDLE)_get_osfhandle(fd))
+    #define wxOpenOSFHandle(h, flags) (_open_osfhandle(wxPtrToUInt(h), flags))
+    #define wx_fdopen _fdopen
 #endif
 
 // close the handle in the class dtor
@@ -208,6 +217,21 @@ struct WinStruct : public T
 };
 
 
+// Macros for converting wxString to the type expected by API functions.
+//
+// Normally it is enough to just use wxString::t_str() which is implicitly
+// convertible to LPCTSTR, but in some cases an explicit conversion is required.
+//
+// In such cases wxMSW_CONV_LPCTSTR() should be used. But if an API function
+// takes a non-const pointer, wxMSW_CONV_LPTSTR() which casts away the
+// constness (but doesn't make it possible to really modify the returned
+// pointer, of course) should be used. And if a string is passed as LPARAM, use
+// wxMSW_CONV_LPARAM() which does the required ugly reinterpret_cast<> too.
+#define wxMSW_CONV_LPCTSTR(s) static_cast<const wxChar *>((s).t_str())
+#define wxMSW_CONV_LPTSTR(s) const_cast<wxChar *>(wxMSW_CONV_LPCTSTR(s))
+#define wxMSW_CONV_LPARAM(s) reinterpret_cast<LPARAM>(wxMSW_CONV_LPCTSTR(s))
+
+
 #if wxUSE_GUI
 
 #include "wx/gdicmn.h"
@@ -251,7 +275,7 @@ enum wxSTD_COLOUR
     wxSTD_COL_MAX
 };
 
-struct WXDLLEXPORT wxCOLORMAP
+struct WXDLLIMPEXP_CORE wxCOLORMAP
 {
     COLORREF from, to;
 };
@@ -285,7 +309,9 @@ inline void wxCopyRectToRECT(const wxRect& rect, RECT& rc)
 // translations between HIMETRIC units (which OLE likes) and pixels (which are
 // liked by all the others) - implemented in msw/utilsexc.cpp
 extern void HIMETRICToPixel(LONG *x, LONG *y);
+extern void HIMETRICToPixel(LONG *x, LONG *y, HDC hdcRef);
 extern void PixelToHIMETRIC(LONG *x, LONG *y);
+extern void PixelToHIMETRIC(LONG *x, LONG *y, HDC hdcRef);
 
 // Windows convention of the mask is opposed to the wxWidgets one, so we need
 // to invert the mask each time we pass one/get one to/from Windows
@@ -302,6 +328,22 @@ extern HICON wxBitmapToHICON(const wxBitmap& bmp);
 extern
 HCURSOR wxBitmapToHCURSOR(const wxBitmap& bmp, int hotSpotX, int hotSpotY);
 
+
+#if wxUSE_OWNER_DRAWN
+
+// Draw the bitmap in specified state (this is used by owner drawn controls)
+enum wxDSBStates
+{
+    wxDSB_NORMAL = 0,
+    wxDSB_SELECTED,
+    wxDSB_DISABLED
+};
+
+extern
+BOOL wxDrawStateBitmap(HDC hDC, HBITMAP hBitmap, int x, int y, UINT uState);
+
+#endif // wxUSE_OWNER_DRAWN
+
 // get (x, y) from DWORD - notice that HI/LOWORD can *not* be used because they
 // will fail on system with multiple monitors where the coords may be negative
 //
@@ -311,21 +353,32 @@ HCURSOR wxBitmapToHCURSOR(const wxBitmap& bmp, int hotSpotX, int hotSpotY);
     #define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))
 #endif // GET_X_LPARAM
 
-// get the current state of SHIFT/CTRL keys
-inline bool wxIsShiftDown()
+// get the current state of SHIFT/CTRL/ALT keys
+inline bool wxIsModifierDown(int vk)
 {
-//    return (::GetKeyState(VK_SHIFT) & 0x100) != 0;
-    // Returns different negative values on WinME and WinNT,
+    // GetKeyState() returns different negative values on WinME and WinNT,
     // so simply test for negative value.
-    return ::GetKeyState(VK_SHIFT) < 0;
+    return ::GetKeyState(vk) < 0;
+}
+
+inline bool wxIsShiftDown()
+{
+    return wxIsModifierDown(VK_SHIFT);
 }
 
 inline bool wxIsCtrlDown()
 {
-//    return (::GetKeyState(VK_CONTROL) & 0x100) != 0;
-    // Returns different negative values on WinME and WinNT,
-    // so simply test for negative value.
-    return ::GetKeyState(VK_CONTROL) < 0;
+    return wxIsModifierDown(VK_CONTROL);
+}
+
+inline bool wxIsAltDown()
+{
+    return wxIsModifierDown(VK_MENU);
+}
+
+inline bool wxIsAnyModifierDown()
+{
+    return wxIsShiftDown() || wxIsCtrlDown() || wxIsAltDown();
 }
 
 // wrapper around GetWindowRect() and GetClientRect() APIs doing error checking
@@ -335,7 +388,9 @@ inline RECT wxGetWindowRect(HWND hwnd)
     RECT rect;
 
     if ( !::GetWindowRect(hwnd, &rect) )
-        wxLogLastError(_T("GetWindowRect"));
+    {
+        wxLogLastError(wxT("GetWindowRect"));
+    }
 
     return rect;
 }
@@ -345,7 +400,9 @@ inline RECT wxGetClientRect(HWND hwnd)
     RECT rect;
 
     if ( !::GetClientRect(hwnd, &rect) )
-        wxLogLastError(_T("GetClientRect"));
+    {
+        wxLogLastError(wxT("GetClientRect"));
+    }
 
     return rect;
 }
@@ -367,15 +424,16 @@ public:
 private:
     HDC m_hdc;
 
-    DECLARE_NO_COPY_CLASS(ScreenHDC)
+    wxDECLARE_NO_COPY_CLASS(ScreenHDC);
 };
 
 // the same as ScreenHDC but for window DCs
 class WindowHDC
 {
 public:
+    WindowHDC() : m_hwnd(NULL), m_hdc(NULL) { }
     WindowHDC(HWND hwnd) { m_hdc = ::GetDC(m_hwnd = hwnd); }
-   ~WindowHDC() { ::ReleaseDC(m_hwnd, m_hdc); }
+   ~WindowHDC() { if ( m_hwnd && m_hdc ) { ::ReleaseDC(m_hwnd, m_hdc); } }
 
     operator HDC() const { return m_hdc; }
 
@@ -383,7 +441,7 @@ private:
    HWND m_hwnd;
    HDC m_hdc;
 
-   DECLARE_NO_COPY_CLASS(WindowHDC)
+   wxDECLARE_NO_COPY_CLASS(WindowHDC);
 };
 
 // the same as ScreenHDC but for memory DCs: creates the HDC compatible with
@@ -399,36 +457,56 @@ public:
 private:
     HDC m_hdc;
 
-    DECLARE_NO_COPY_CLASS(MemoryHDC)
+    wxDECLARE_NO_COPY_CLASS(MemoryHDC);
 };
 
 // a class which selects a GDI object into a DC in its ctor and deselects in
 // dtor
 class SelectInHDC
 {
+private:
+    void DoInit(HGDIOBJ hgdiobj) { m_hgdiobj = ::SelectObject(m_hdc, hgdiobj); }
+
 public:
-    SelectInHDC(HDC hdc, HGDIOBJ hgdiobj) : m_hdc(hdc)
-        { m_hgdiobj = ::SelectObject(hdc, hgdiobj); }
+    SelectInHDC() : m_hdc(NULL), m_hgdiobj(NULL) { }
+    SelectInHDC(HDC hdc, HGDIOBJ hgdiobj) : m_hdc(hdc) { DoInit(hgdiobj); }
 
-   ~SelectInHDC() { ::SelectObject(m_hdc, m_hgdiobj); }
+    void Init(HDC hdc, HGDIOBJ hgdiobj)
+    {
+        wxASSERT_MSG( !m_hdc, wxT("initializing twice?") );
+
+        m_hdc = hdc;
+
+        DoInit(hgdiobj);
+    }
 
-   // return true if the object was successfully selected
-   operator bool() const { return m_hgdiobj != 0; }
+    ~SelectInHDC() { if ( m_hdc ) ::SelectObject(m_hdc, m_hgdiobj); }
+
+    // return true if the object was successfully selected
+    operator bool() const { return m_hgdiobj != 0; }
 
 private:
-   HDC m_hdc;
-   HGDIOBJ m_hgdiobj;
+    HDC m_hdc;
+    HGDIOBJ m_hgdiobj;
 
-   DECLARE_NO_COPY_CLASS(SelectInHDC)
+    wxDECLARE_NO_COPY_CLASS(SelectInHDC);
 };
 
 // a class which cleans up any GDI object
 class AutoGDIObject
 {
 protected:
+    AutoGDIObject() { m_gdiobj = NULL; }
     AutoGDIObject(HGDIOBJ gdiobj) : m_gdiobj(gdiobj) { }
     ~AutoGDIObject() { if ( m_gdiobj ) ::DeleteObject(m_gdiobj); }
 
+    void InitGdiobj(HGDIOBJ gdiobj)
+    {
+        wxASSERT_MSG( !m_gdiobj, wxT("initializing twice?") );
+
+        m_gdiobj = gdiobj;
+    }
+
     HGDIOBJ GetObject() const { return m_gdiobj; }
 
 private:
@@ -437,7 +515,7 @@ private:
 
 // TODO: all this asks for using a AutoHandler<T, CreateFunc> template...
 
-// a class for temporary pens
+// a class for temporary brushes
 class AutoHBRUSH : private AutoGDIObject
 {
 public:
@@ -447,6 +525,22 @@ public:
     operator HBRUSH() const { return (HBRUSH)GetObject(); }
 };
 
+// a class for temporary fonts
+class AutoHFONT : private AutoGDIObject
+{
+private:
+public:
+    AutoHFONT()
+        : AutoGDIObject() { }
+
+    AutoHFONT(const LOGFONT& lf)
+        : AutoGDIObject(::CreateFontIndirect(&lf)) { }
+
+    void Init(const LOGFONT& lf) { InitGdiobj(::CreateFontIndirect(&lf)); }
+
+    operator HFONT() const { return (HFONT)GetObject(); }
+};
+
 // a class for temporary pens
 class AutoHPEN : private AutoGDIObject
 {
@@ -461,8 +555,13 @@ public:
 class AutoHBITMAP : private AutoGDIObject
 {
 public:
+    AutoHBITMAP()
+        : AutoGDIObject() { }
+
     AutoHBITMAP(HBITMAP hbmp) : AutoGDIObject(hbmp) { }
 
+    void Init(HBITMAP hbmp) { InitGdiobj(hbmp); }
+
     operator HBITMAP() const { return (HBITMAP)GetObject(); }
 };
 
@@ -501,7 +600,9 @@ public:
         : m_hdc(hdc)
     {
         if ( !::SelectClipRgn(hdc, hrgn) )
-            wxLogLastError(_T("SelectClipRgn"));
+        {
+            wxLogLastError(wxT("SelectClipRgn"));
+        }
     }
 
     ~HDCClipper()
@@ -512,7 +613,7 @@ public:
 private:
     HDC m_hdc;
 
-    DECLARE_NO_COPY_CLASS(HDCClipper)
+    wxDECLARE_NO_COPY_CLASS(HDCClipper);
 };
 
 // set the given map mode for the life time of this object
@@ -530,7 +631,9 @@ private:
         {
             m_modeOld = ::SetMapMode(hdc, mm);
             if ( !m_modeOld )
-                wxLogLastError(_T("SelectClipRgn"));
+            {
+                wxLogLastError(wxT("SelectClipRgn"));
+            }
         }
 
         ~HDCMapModeChanger()
@@ -543,29 +646,44 @@ private:
         HDC m_hdc;
         int m_modeOld;
 
-        DECLARE_NO_COPY_CLASS(HDCMapModeChanger)
+        wxDECLARE_NO_COPY_CLASS(HDCMapModeChanger);
     };
 
     #define wxCHANGE_HDC_MAP_MODE(hdc, mm) \
         HDCMapModeChanger wxMAKE_UNIQUE_NAME(wxHDCMapModeChanger)(hdc, mm)
 #endif // __WXWINCE__/!__WXWINCE__
 
-// smart buffeer using GlobalAlloc/GlobalFree()
+// smart pointer using GlobalAlloc/GlobalFree()
 class GlobalPtr
 {
 public:
+    // default ctor, call Init() later
+    GlobalPtr()
+    {
+        m_hGlobal = NULL;
+    }
+
     // allocates a block of given size
-    GlobalPtr(size_t size, unsigned flags = GMEM_MOVEABLE)
+    void Init(size_t size, unsigned flags = GMEM_MOVEABLE)
     {
         m_hGlobal = ::GlobalAlloc(flags, size);
         if ( !m_hGlobal )
-            wxLogLastError(_T("GlobalAlloc"));
+        {
+            wxLogLastError(wxT("GlobalAlloc"));
+        }
+    }
+
+    GlobalPtr(size_t size, unsigned flags = GMEM_MOVEABLE)
+    {
+        Init(size, flags);
     }
 
     ~GlobalPtr()
     {
         if ( m_hGlobal && ::GlobalFree(m_hGlobal) )
-            wxLogLastError(_T("GlobalFree"));
+        {
+            wxLogLastError(wxT("GlobalFree"));
+        }
     }
 
     // implicit conversion
@@ -574,7 +692,7 @@ public:
 private:
     HGLOBAL m_hGlobal;
 
-    DECLARE_NO_COPY_CLASS(GlobalPtr)
+    wxDECLARE_NO_COPY_CLASS(GlobalPtr);
 };
 
 // when working with global pointers (which is unfortunately still necessary
@@ -583,35 +701,56 @@ private:
 class GlobalPtrLock
 {
 public:
-    GlobalPtrLock(HGLOBAL hGlobal) : m_hGlobal(hGlobal)
+    // default ctor, use Init() later -- should only be used if the HGLOBAL can
+    // be NULL (in which case Init() shouldn't be called)
+    GlobalPtrLock()
+    {
+        m_hGlobal = NULL;
+        m_ptr = NULL;
+    }
+
+    // initialize the object, may be only called if we were created using the
+    // default ctor; HGLOBAL must not be NULL
+    void Init(HGLOBAL hGlobal)
     {
+        m_hGlobal = hGlobal;
+
+        // NB: GlobalLock() is a macro, not a function, hence don't use the
+        //     global scope operator with it (and neither with GlobalUnlock())
         m_ptr = GlobalLock(hGlobal);
         if ( !m_ptr )
-            wxLogLastError(_T("GlobalLock"));
+        {
+            wxLogLastError(wxT("GlobalLock"));
+        }
+    }
+
+    // initialize the object, HGLOBAL must not be NULL
+    GlobalPtrLock(HGLOBAL hGlobal)
+    {
+        Init(hGlobal);
     }
 
     ~GlobalPtrLock()
     {
-        if ( !GlobalUnlock(m_hGlobal) )
+        if ( m_hGlobal && !GlobalUnlock(m_hGlobal) )
         {
-#ifdef __WXDEBUG__
             // this might happen simply because the block became unlocked
             DWORD dwLastError = ::GetLastError();
             if ( dwLastError != NO_ERROR )
             {
-                wxLogApiError(_T("GlobalUnlock"), dwLastError);
+                wxLogApiError(wxT("GlobalUnlock"), dwLastError);
             }
-#endif // __WXDEBUG__
         }
     }
 
+    void *Get() const { return m_ptr; }
     operator void *() const { return m_ptr; }
 
 private:
     HGLOBAL m_hGlobal;
     void *m_ptr;
 
-    DECLARE_NO_COPY_CLASS(GlobalPtrLock)
+    wxDECLARE_NO_COPY_CLASS(GlobalPtrLock);
 };
 
 // register the class when it is first needed and unregister it in dtor
@@ -632,12 +771,12 @@ public:
     {
         // we should only be called if we hadn't been initialized yet
         wxASSERT_MSG( m_registered == -1,
-                        _T("calling ClassRegistrar::Register() twice?") );
+                        wxT("calling ClassRegistrar::Register() twice?") );
 
         m_registered = ::RegisterClass(&wc) ? 1 : 0;
         if ( !IsRegistered() )
         {
-            wxLogLastError(_T("RegisterClassEx()"));
+            wxLogLastError(wxT("RegisterClassEx()"));
         }
         else
         {
@@ -656,9 +795,9 @@ public:
     {
         if ( IsRegistered() )
         {
-            if ( !::UnregisterClass(m_clsname, wxhInstance) )
+            if ( !::UnregisterClass(m_clsname.t_str(), wxGetInstance()) )
             {
-                wxLogLastError(_T("UnregisterClass"));
+                wxLogLastError(wxT("UnregisterClass"));
             }
         }
     }
@@ -700,7 +839,7 @@ private:
 #define GetHbrushOf(brush)      ((HBRUSH)(brush).GetResourceHandle())
 
 #define GetHmenu()              ((HMENU)GetHMenu())
-#define GetHmenuOf(menu)        ((HMENU)menu->GetHMenu())
+#define GetHmenuOf(menu)        ((HMENU)(menu)->GetHMenu())
 
 #define GetHcursor()            ((HCURSOR)GetHCURSOR())
 #define GetHcursorOf(cursor)    ((HCURSOR)(cursor).GetHCURSOR())
@@ -709,7 +848,7 @@ private:
 #define GetHfontOf(font)        ((HFONT)(font).GetHFONT())
 
 #define GetHimagelist()         ((HIMAGELIST)GetHIMAGELIST())
-#define GetHimagelistOf(imgl)   ((HIMAGELIST)imgl->GetHIMAGELIST())
+#define GetHimagelistOf(imgl)   ((HIMAGELIST)(imgl)->GetHIMAGELIST())
 
 #define GetHpalette()           ((HPALETTE)GetHPALETTE())
 #define GetHpaletteOf(pal)      ((HPALETTE)(pal).GetHPALETTE())
@@ -726,13 +865,6 @@ private:
 // global functions
 // ---------------------------------------------------------------------------
 
-extern "C"
-{
-    WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
-}
-
-WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
-
 // return the full path of the given module
 inline wxString wxGetFullModuleName(HMODULE hmod)
 {
@@ -744,7 +876,7 @@ inline wxString wxGetFullModuleName(HMODULE hmod)
                 MAX_PATH
             ) )
     {
-        wxLogLastError(_T("GetModuleFileName"));
+        wxLogLastError(wxT("GetModuleFileName"));
     }
 
     return fullname;
@@ -763,9 +895,10 @@ inline wxString wxGetFullModuleName()
 //      0x0400      Windows 95, NT4
 //      0x0410      Windows 98
 //      0x0500      Windows ME, 2000
-//      0x0501      Windows XP
-//      0x0502      Windows 2003
-//      0x0600      Longhorn
+//      0x0501      Windows XP, 2003
+//      0x0502      Windows XP SP2, 2003 SP1
+//      0x0600      Windows Vista, 2008
+//      0x0601      Windows 7
 //
 // for the other Windows versions 0 is currently returned
 enum wxWinVersion
@@ -785,44 +918,52 @@ enum wxWinVersion
     wxWinVersion_NT5 = wxWinVersion_5,
     wxWinVersion_2000 = wxWinVersion_5,
     wxWinVersion_XP = 0x0501,
-    wxWinVersion_2003 = 0x0502,
+    wxWinVersion_2003 = 0x0501,
+    wxWinVersion_XP_SP2 = 0x0502,
+    wxWinVersion_2003_SP1 = 0x0502,
 
     wxWinVersion_6 = 0x0600,
-    wxWinVersion_NT6 = 0x0600
+    wxWinVersion_Vista = wxWinVersion_6,
+    wxWinVersion_NT6 = wxWinVersion_6,
+
+    wxWinVersion_7 = 0x601
 };
 
 WXDLLIMPEXP_BASE wxWinVersion wxGetWinVersion();
 
-#if wxUSE_GUI
+#if wxUSE_GUI && defined(__WXMSW__)
 
 // cursor stuff
 extern HCURSOR wxGetCurrentBusyCursor();    // from msw/utils.cpp
 extern const wxCursor *wxGetGlobalCursor(); // from msw/cursor.cpp
 
-WXDLLEXPORT void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font);
-WXDLLEXPORT void wxFillLogFont(LOGFONT *logFont, const wxFont *font);
-WXDLLEXPORT wxFont wxCreateFontFromLogFont(const LOGFONT *logFont);
-WXDLLEXPORT wxFontEncoding wxGetFontEncFromCharSet(int charset);
+// GetCursorPos can fail without populating the POINT. This falls back to GetMessagePos.
+WXDLLIMPEXP_CORE void wxGetCursorPosMSW(POINT* pt);
 
-WXDLLEXPORT void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos);
-WXDLLEXPORT void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos);
+WXDLLIMPEXP_CORE void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font);
+WXDLLIMPEXP_CORE void wxFillLogFont(LOGFONT *logFont, const wxFont *font);
+WXDLLIMPEXP_CORE wxFont wxCreateFontFromLogFont(const LOGFONT *logFont);
+WXDLLIMPEXP_CORE wxFontEncoding wxGetFontEncFromCharSet(int charset);
+
+WXDLLIMPEXP_CORE void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos);
+WXDLLIMPEXP_CORE void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos);
 
 // Find maximum size of window/rectangle
-extern WXDLLEXPORT void wxFindMaxSize(WXHWND hwnd, RECT *rect);
+extern WXDLLIMPEXP_CORE void wxFindMaxSize(WXHWND hwnd, RECT *rect);
 
 // Safely get the window text (i.e. without using fixed size buffer)
-extern WXDLLEXPORT wxString wxGetWindowText(WXHWND hWnd);
+extern WXDLLIMPEXP_CORE wxString wxGetWindowText(WXHWND hWnd);
 
 // get the window class name
-extern WXDLLEXPORT wxString wxGetWindowClass(WXHWND hWnd);
+extern WXDLLIMPEXP_CORE wxString wxGetWindowClass(WXHWND hWnd);
 
 // get the window id (should be unsigned, hence this is not wxWindowID which
 // is, for mainly historical reasons, signed)
-extern WXDLLEXPORT WXWORD wxGetWindowId(WXHWND hWnd);
+extern WXDLLIMPEXP_CORE int wxGetWindowId(WXHWND hWnd);
 
 // check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
 // different
-extern WXDLLEXPORT bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc);
+extern WXDLLIMPEXP_CORE bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc);
 
 // Does this window style specify any border?
 inline bool wxStyleHasBorder(long style)
@@ -831,26 +972,41 @@ inline bool wxStyleHasBorder(long style)
                      wxSUNKEN_BORDER | wxDOUBLE_BORDER)) != 0;
 }
 
+inline long wxGetWindowExStyle(const wxWindowMSW *win)
+{
+    return ::GetWindowLong(GetHwndOf(win), GWL_EXSTYLE);
+}
+
+inline bool wxHasWindowExStyle(const wxWindowMSW *win, long style)
+{
+    return (wxGetWindowExStyle(win) & style) != 0;
+}
+
+inline long wxSetWindowExStyle(const wxWindowMSW *win, long style)
+{
+    return ::SetWindowLong(GetHwndOf(win), GWL_EXSTYLE, style);
+}
+
 // ----------------------------------------------------------------------------
 // functions mapping HWND to wxWindow
 // ----------------------------------------------------------------------------
 
-// this function simply checks whether the given hWnd corresponds to a wxWindow
+// this function simply checks whether the given hwnd corresponds to a wxWindow
 // and returns either that window if it does or NULL otherwise
-extern WXDLLEXPORT wxWindow* wxFindWinFromHandle(WXHWND hWnd);
+extern WXDLLIMPEXP_CORE wxWindow* wxFindWinFromHandle(HWND hwnd);
 
 // find the window for HWND which is part of some wxWindow, i.e. unlike
 // wxFindWinFromHandle() above it will also work for "sub controls" of a
 // wxWindow.
 //
 // returns the wxWindow corresponding to the given HWND or NULL.
-extern WXDLLEXPORT wxWindow *wxGetWindowFromHWND(WXHWND hwnd);
+extern WXDLLIMPEXP_CORE wxWindow *wxGetWindowFromHWND(WXHWND hwnd);
 
 // Get the size of an icon
-extern WXDLLEXPORT wxSize wxGetHiconSize(HICON hicon);
+extern WXDLLIMPEXP_CORE wxSize wxGetHiconSize(HICON hicon);
 
 // Lines are drawn differently for WinCE and regular WIN32
-WXDLLEXPORT void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2);
+WXDLLIMPEXP_CORE void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2);
 
 // fill the client rect of the given window on the provided dc using this brush
 inline void wxFillRect(HWND hwnd, HDC hdc, HBRUSH hbr)
@@ -912,6 +1068,6 @@ inline void *wxSetWindowUserData(HWND hwnd, void *data)
 
 #endif // __WIN64__/__WIN32__
 
-#endif // wxUSE_GUI
+#endif // wxUSE_GUI && __WXMSW__
 
 #endif // _WX_PRIVATE_H_