compilation fix for windows compilers: _wrename is declared in io.h

[wxWidgets.git] / include / wx / msw / private.h

diff --git a/include/wx/msw/private.h b/include/wx/msw/private.h
index 8337606c2257cf509d657edc12fcab292cbff5db..22049abda79f65510d7c0c68bf64f55736134b87 100644 (file)
--- a/include/wx/msw/private.h
+++ b/include/wx/msw/private.h
@@ -1,7 +1,7 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        private.h
+// Name:        wx/msw/private.h

 // Purpose:     Private declarations: as this header is only included by
 // Purpose:     Private declarations: as this header is only included by

-//              wxWindows itself, it may contain identifiers which don't start
+//              wxWidgets itself, it may contain identifiers which don't start

 //              with "wx".
 // Author:      Julian Smart
 // Modified by:
 //              with "wx".
 // Author:      Julian Smart
 // Modified by:


@@ -16,43 +16,25 @@
 
 #include "wx/msw/wrapwin.h"
 
 
 #include "wx/msw/wrapwin.h"
 

-#if defined (__WXWINCE__)
-    #include <wingdi.h>     // RGB, COLORREF
-    #define ERRFALSE(x)
-    #include <winuser.h>    // Global Namespaces ::GetKeyState, ::GetWindowRect
-    #include "wx/msw/winundef.h"
-#endif
-
-

 #ifdef __WXMICROWIN__
     // Extra prototypes and symbols not defined by MicroWindows
     #include "wx/msw/microwin.h"
 #endif
 
 #ifdef __WXMICROWIN__
     // Extra prototypes and symbols not defined by MicroWindows
     #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;
 #include "wx/log.h"
 
 class WXDLLEXPORT wxFont;
 class WXDLLEXPORT wxWindow;

+class WXDLLEXPORT wxWindowBase;

 
 // ---------------------------------------------------------------------------
 // private constants
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // private constants
 // ---------------------------------------------------------------------------
 

-// Conversion
-static const double METRIC_CONVERSION_CONSTANT = 0.0393700787;
-
-// Scaling factors for various unit conversions
-static const double mm2inches = (METRIC_CONVERSION_CONSTANT);
-static const double inches2mm = (1/METRIC_CONVERSION_CONSTANT);
-
-static const double mm2twips = (METRIC_CONVERSION_CONSTANT*1440);
-static const double twips2mm = (1/(METRIC_CONVERSION_CONSTANT*1440));
-
-static const double mm2pt = (METRIC_CONVERSION_CONSTANT*72);
-static const double pt2mm = (1/(METRIC_CONVERSION_CONSTANT*72));
+// 260 was taken from windef.h
+#ifndef MAX_PATH
+    #define MAX_PATH  260
+#endif

 
 // ---------------------------------------------------------------------------
 // standard icons from the resources
 
 // ---------------------------------------------------------------------------
 // standard icons from the resources


@@ -60,16 +42,22 @@ static const double pt2mm = (1/(METRIC_CONVERSION_CONSTANT*72));
 
 #if wxUSE_GUI
 
 
 #if wxUSE_GUI
 

-WXDLLEXPORT_DATA(extern HICON) wxSTD_FRAME_ICON;
-WXDLLEXPORT_DATA(extern HICON) wxSTD_MDIPARENTFRAME_ICON;
-WXDLLEXPORT_DATA(extern HICON) wxSTD_MDICHILDFRAME_ICON;
-WXDLLEXPORT_DATA(extern HICON) wxDEFAULT_FRAME_ICON;
-WXDLLEXPORT_DATA(extern HICON) wxDEFAULT_MDIPARENTFRAME_ICON;
-WXDLLEXPORT_DATA(extern HICON) wxDEFAULT_MDICHILDFRAME_ICON;
-WXDLLEXPORT_DATA(extern HFONT) wxSTATUS_LINE_FONT;
+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;

 
 #endif // wxUSE_GUI
 
 
 #endif // wxUSE_GUI
 

+// ---------------------------------------------------------------------------
+// global data
+// ---------------------------------------------------------------------------
+
+extern WXDLLIMPEXP_DATA_BASE(HINSTANCE) wxhInstance;
+

 // ---------------------------------------------------------------------------
 // define things missing from some compilers' headers
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // define things missing from some compilers' headers
 // ---------------------------------------------------------------------------


@@ -117,26 +105,6 @@ WXDLLEXPORT_DATA(extern HFONT) wxSTATUS_LINE_FONT;
 #endif
 #endif
 
 #endif
 #endif
 

-#if wxUSE_PENWIN
-    WXDLLEXPORT void wxRegisterPenWin();
-    WXDLLEXPORT void wxCleanUpPenWin();
-    WXDLLEXPORT void wxEnablePenAppHooks (bool hook);
-#endif // wxUSE_PENWIN
-
-#if wxUSE_ITSY_BITSY
-    #define IBS_HORZCAPTION    0x4000L
-    #define IBS_VERTCAPTION    0x8000L
-
-    UINT    WINAPI ibGetCaptionSize( HWND hWnd  ) ;
-    UINT    WINAPI ibSetCaptionSize( HWND hWnd, UINT nSize ) ;
-    LRESULT WINAPI ibDefWindowProc( HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam ) ;
-    VOID    WINAPI ibAdjustWindowRect( HWND hWnd, LPRECT lprc ) ;
-#endif // wxUSE_ITSY_BITSY
-
-#if wxUSE_CTL3D
-    #include "wx/msw/ctl3d/ctl3d.h"
-#endif // wxUSE_CTL3D
-

 /*
  * Decide what window classes we're going to use
  * for this combination of CTl3D/FAFA settings
 /*
  * Decide what window classes we're going to use
  * for this combination of CTl3D/FAFA settings


@@ -146,11 +114,11 @@ WXDLLEXPORT_DATA(extern HFONT) wxSTATUS_LINE_FONT;
 #define STATIC_FLAGS     (SS_LEFT|WS_CHILD|WS_VISIBLE)
 #define CHECK_CLASS      wxT("BUTTON")
 #define CHECK_FLAGS      (BS_AUTOCHECKBOX|WS_TABSTOP|WS_CHILD)
 #define STATIC_FLAGS     (SS_LEFT|WS_CHILD|WS_VISIBLE)
 #define CHECK_CLASS      wxT("BUTTON")
 #define CHECK_FLAGS      (BS_AUTOCHECKBOX|WS_TABSTOP|WS_CHILD)

-#define CHECK_IS_FAFA   FALSE
+#define CHECK_IS_FAFA    FALSE

 #define RADIO_CLASS      wxT("BUTTON")
 #define RADIO_FLAGS      (BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE)
 #define RADIO_SIZE       20
 #define RADIO_CLASS      wxT("BUTTON")
 #define RADIO_FLAGS      (BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE)
 #define RADIO_SIZE       20

-#define RADIO_IS_FAFA   FALSE
+#define RADIO_IS_FAFA    FALSE

 #define PURE_WINDOWS
 #define GROUP_CLASS      wxT("BUTTON")
 #define GROUP_FLAGS      (BS_GROUPBOX|WS_CHILD|WS_VISIBLE)
 #define PURE_WINDOWS
 #define GROUP_CLASS      wxT("BUTTON")
 #define GROUP_FLAGS      (BS_GROUPBOX|WS_CHILD|WS_VISIBLE)


@@ -188,10 +156,62 @@ extern LONG APIENTRY _EXPORT
 #define wxZeroMemory(obj)   memset((void*) & obj, 0, sizeof(obj))
 #endif
 
 #define wxZeroMemory(obj)   memset((void*) & obj, 0, sizeof(obj))
 #endif
 

+// 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.
+#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__))
+    #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
+class AutoHANDLE
+{
+public:
+    wxEXPLICIT AutoHANDLE(HANDLE handle) : m_handle(handle) { }
+
+    bool IsOk() const { return m_handle != INVALID_HANDLE_VALUE; }
+    operator HANDLE() const { return m_handle; }
+
+    ~AutoHANDLE() { if ( IsOk() ) ::CloseHandle(m_handle); }
+
+protected:
+    HANDLE m_handle;
+};
+
+// a template to make initializing Windows styructs less painful: it zeroes all
+// the struct fields and also sets cbSize member to the correct value (and so
+// can be only used with structures which have this member...)
+template <class T>
+struct WinStruct : public T
+{
+    WinStruct()
+    {
+        ::ZeroMemory(this, sizeof(T));
+
+        // explicit qualification is required here for this to be valid C++
+        this->cbSize = sizeof(T);
+    }
+};
+
+

 #if wxUSE_GUI
 
 #if wxUSE_GUI
 

-#include <wx/gdicmn.h>
-#include <wx/colour.h>
+#include "wx/gdicmn.h"
+#include "wx/colour.h"

 
 // make conversion from wxColour and COLORREF a bit less painful
 inline COLORREF wxColourToRGB(const wxColour& c)
 
 // make conversion from wxColour and COLORREF a bit less painful
 inline COLORREF wxColourToRGB(const wxColour& c)


@@ -228,7 +248,7 @@ enum wxSTD_COLOUR
     wxSTD_COL_BTNSHADOW,
     wxSTD_COL_BTNFACE,
     wxSTD_COL_BTNHIGHLIGHT,
     wxSTD_COL_BTNSHADOW,
     wxSTD_COL_BTNFACE,
     wxSTD_COL_BTNHIGHLIGHT,

-    wxSTD_COL_MAX,
+    wxSTD_COL_MAX

 };
 
 struct WXDLLEXPORT wxCOLORMAP
 };
 
 struct WXDLLEXPORT wxCOLORMAP


@@ -239,13 +259,27 @@ struct WXDLLEXPORT wxCOLORMAP
 // this function is implemented in src/msw/window.cpp
 extern wxCOLORMAP *wxGetStdColourMap();
 
 // this function is implemented in src/msw/window.cpp
 extern wxCOLORMAP *wxGetStdColourMap();
 

+// create a wxRect from Windows RECT
+inline wxRect wxRectFromRECT(const RECT& rc)
+{
+    return wxRect(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
+}
+

 // copy Windows RECT to our wxRect
 // copy Windows RECT to our wxRect

-inline void wxCopyRECTToRect(const RECT& r, wxRect& rect)
+inline void wxCopyRECTToRect(const RECT& rc, wxRect& rect)
+{
+    rect = wxRectFromRECT(rc);
+}
+
+// and vice versa
+inline void wxCopyRectToRECT(const wxRect& rect, RECT& rc)

 {
 {

-    rect.y = r.top;
-    rect.x = r.left;
-    rect.width = r.right - r.left;
-    rect.height = r.bottom - r.top;
+    // note that we don't use wxRect::GetRight() as it is one of compared to
+    // wxRectFromRECT() above
+    rc.top = rect.y;
+    rc.left = rect.x;
+    rc.right = rect.x + rect.width;
+    rc.bottom = rect.y + rect.height;

 }
 
 // translations between HIMETRIC units (which OLE likes) and pixels (which are
 }
 
 // translations between HIMETRIC units (which OLE likes) and pixels (which are


@@ -253,7 +287,7 @@ inline void wxCopyRECTToRect(const RECT& r, wxRect& rect)
 extern void HIMETRICToPixel(LONG *x, LONG *y);
 extern void PixelToHIMETRIC(LONG *x, LONG *y);
 
 extern void HIMETRICToPixel(LONG *x, LONG *y);
 extern void PixelToHIMETRIC(LONG *x, LONG *y);
 

-// Windows convention of the mask is opposed to the wxWindows one, so we need
+// 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
 extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w = 0, int h = 0);
 
 // to invert the mask each time we pass one/get one to/from Windows
 extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w = 0, int h = 0);
 


@@ -299,14 +333,9 @@ inline bool wxIsCtrlDown()
 inline RECT wxGetWindowRect(HWND hwnd)
 {
     RECT rect;
 inline RECT wxGetWindowRect(HWND hwnd)
 {
     RECT rect;

-#ifdef __WIN16__
-    ::GetWindowRect(hwnd, &rect);
-#else // Win32
+

     if ( !::GetWindowRect(hwnd, &rect) )
     if ( !::GetWindowRect(hwnd, &rect) )

-    {

         wxLogLastError(_T("GetWindowRect"));
         wxLogLastError(_T("GetWindowRect"));

-    }
-#endif // Win16/32

 
     return rect;
 }
 
     return rect;
 }


@@ -314,14 +343,9 @@ inline RECT wxGetWindowRect(HWND hwnd)
 inline RECT wxGetClientRect(HWND hwnd)
 {
     RECT rect;
 inline RECT wxGetClientRect(HWND hwnd)
 {
     RECT rect;

-#ifdef __WIN16__
-    ::GetClientRect(hwnd, &rect);
-#else // Win32
+

     if ( !::GetClientRect(hwnd, &rect) )
     if ( !::GetClientRect(hwnd, &rect) )

-    {

         wxLogLastError(_T("GetClientRect"));
         wxLogLastError(_T("GetClientRect"));

-    }
-#endif // Win16/32

 
     return rect;
 }
 
     return rect;
 }


@@ -330,20 +354,6 @@ inline RECT wxGetClientRect(HWND hwnd)
 // small helper classes
 // ---------------------------------------------------------------------------
 
 // small helper classes
 // ---------------------------------------------------------------------------
 

-// a template to make initializing Windows styructs less painful: it zeroes all
-// the struct fields and also sets cbSize member to the correct value (and so
-// can be only used with structures which have this member...)
-template <class T>
-struct WinStruct : public T
-{
-    WinStruct()
-    {
-        ::ZeroMemory(this, sizeof(T));
-        cbSize = sizeof(T);
-    }
-};
-
-

 // create an instance of this class and use it as the HDC for screen, will
 // automatically release the DC going out of scope
 class ScreenHDC
 // create an instance of this class and use it as the HDC for screen, will
 // automatically release the DC going out of scope
 class ScreenHDC


@@ -360,6 +370,22 @@ private:
     DECLARE_NO_COPY_CLASS(ScreenHDC)
 };
 
     DECLARE_NO_COPY_CLASS(ScreenHDC)
 };
 

+// the same as ScreenHDC but for window DCs
+class WindowHDC
+{
+public:
+    WindowHDC(HWND hwnd) { m_hdc = ::GetDC(m_hwnd = hwnd); }
+   ~WindowHDC() { ::ReleaseDC(m_hwnd, m_hdc); }
+
+    operator HDC() const { return m_hdc; }
+
+private:
+   HWND m_hwnd;
+   HDC m_hdc;
+
+   DECLARE_NO_COPY_CLASS(WindowHDC)
+};
+

 // the same as ScreenHDC but for memory DCs: creates the HDC compatible with
 // the given one (screen by default) in ctor and destroys it in dtor
 class MemoryHDC
 // the same as ScreenHDC but for memory DCs: creates the HDC compatible with
 // the given one (screen by default) in ctor and destroys it in dtor
 class MemoryHDC


@@ -380,41 +406,229 @@ private:
 // dtor
 class SelectInHDC
 {
 // dtor
 class SelectInHDC
 {

+private:
+    void DoInit(HGDIOBJ hgdiobj) { m_hgdiobj = ::SelectObject(m_hdc, hgdiobj); }
+

 public:
 public:

-    SelectInHDC(HDC hdc, HGDIOBJ hgdiobj) : m_hdc(hdc)
-        { m_hgdiobj = ::SelectObject(hdc, hgdiobj); }
+    SelectInHDC() : m_hdc(NULL) { }
+    SelectInHDC(HDC hdc, HGDIOBJ hgdiobj) : m_hdc(hdc) { DoInit(hgdiobj); }
+
+    void Init(HDC hdc, HGDIOBJ hgdiobj)
+    {
+        wxASSERT_MSG( !m_hdc, _T("initializing twice?") );
+
+        m_hdc = hdc;

 
 

-   ~SelectInHDC() { ::SelectObject(m_hdc, m_hgdiobj); }
+        DoInit(hgdiobj);
+    }
+
+    ~SelectInHDC() { if ( m_hdc ) ::SelectObject(m_hdc, m_hgdiobj); }

 
 

-   // return true if the object was successfully selected
-   operator bool() const { return m_hgdiobj != 0; }
+    // return true if the object was successfully selected
+    operator bool() const { return m_hgdiobj != 0; }

 
 private:
 
 private:

-   HDC m_hdc;
-   HGDIOBJ m_hgdiobj;
+    HDC m_hdc;
+    HGDIOBJ m_hgdiobj;
+
+    DECLARE_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, _T("initializing twice?") );
+
+        m_gdiobj = gdiobj;
+    }
+
+    HGDIOBJ GetObject() const { return m_gdiobj; }
+
+private:
+    HGDIOBJ m_gdiobj;
+};
+
+// TODO: all this asks for using a AutoHandler<T, CreateFunc> template...
+
+// a class for temporary brushes
+class AutoHBRUSH : private AutoGDIObject
+{
+public:
+    AutoHBRUSH(COLORREF col)
+        : AutoGDIObject(::CreateSolidBrush(col)) { }
+
+    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
+{
+public:
+    AutoHPEN(COLORREF col)
+        : AutoGDIObject(::CreatePen(PS_SOLID, 0, col)) { }
+
+    operator HPEN() const { return (HPEN)GetObject(); }
+};
+
+// classes for temporary bitmaps
+class AutoHBITMAP : private AutoGDIObject
+{
+public:
+    AutoHBITMAP(HBITMAP hbmp) : AutoGDIObject(hbmp) { }
+
+    operator HBITMAP() const { return (HBITMAP)GetObject(); }
+};
+
+class CompatibleBitmap : public AutoHBITMAP
+{
+public:
+    CompatibleBitmap(HDC hdc, int w, int h)
+        : AutoHBITMAP(::CreateCompatibleBitmap(hdc, w, h))
+    {
+    }
+};
+
+class MonoBitmap : public AutoHBITMAP
+{
+public:
+    MonoBitmap(int w, int h)
+        : AutoHBITMAP(::CreateBitmap(w, h, 1, 1, 0))
+    {
+    }
+};
+
+// class automatically destroys the region object
+class AutoHRGN : private AutoGDIObject
+{
+public:
+    AutoHRGN(HRGN hrgn) : AutoGDIObject(hrgn) { }

 
 

-   DECLARE_NO_COPY_CLASS(SelectInHDC)
+    operator HRGN() const { return (HRGN)GetObject(); }
+};
+
+// class sets the specified clipping region during its life time
+class HDCClipper
+{
+public:
+    HDCClipper(HDC hdc, HRGN hrgn)
+        : m_hdc(hdc)
+    {
+        if ( !::SelectClipRgn(hdc, hrgn) )
+            wxLogLastError(_T("SelectClipRgn"));
+    }
+
+    ~HDCClipper()
+    {
+        ::SelectClipRgn(m_hdc, NULL);
+    }
+
+private:
+    HDC m_hdc;
+
+    DECLARE_NO_COPY_CLASS(HDCClipper)
+};
+
+// set the given map mode for the life time of this object
+//
+// NB: SetMapMode() is not supported by CE so we also define a helper macro
+//     to avoid using it there
+#ifdef __WXWINCE__
+    #define wxCHANGE_HDC_MAP_MODE(hdc, mm)
+#else // !__WXWINCE__
+    class HDCMapModeChanger
+    {
+    public:
+        HDCMapModeChanger(HDC hdc, int mm)
+            : m_hdc(hdc)
+        {
+            m_modeOld = ::SetMapMode(hdc, mm);
+            if ( !m_modeOld )
+                wxLogLastError(_T("SelectClipRgn"));
+        }
+
+        ~HDCMapModeChanger()
+        {
+            if ( m_modeOld )
+                ::SetMapMode(m_hdc, m_modeOld);
+        }
+
+    private:
+        HDC m_hdc;
+        int m_modeOld;
+
+        DECLARE_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()
+class GlobalPtr
+{
+public:
+    // allocates a block of given size
+    GlobalPtr(size_t size, unsigned flags = GMEM_MOVEABLE)
+    {
+        m_hGlobal = ::GlobalAlloc(flags, size);
+        if ( !m_hGlobal )
+            wxLogLastError(_T("GlobalAlloc"));
+    }
+
+    ~GlobalPtr()
+    {
+        if ( m_hGlobal && ::GlobalFree(m_hGlobal) )
+            wxLogLastError(_T("GlobalFree"));
+    }
+
+    // implicit conversion
+    operator HGLOBAL() const { return m_hGlobal; }
+
+private:
+    HGLOBAL m_hGlobal;
+
+    DECLARE_NO_COPY_CLASS(GlobalPtr)

 };
 
 };
 

-#ifndef __WXWINCE__

 // when working with global pointers (which is unfortunately still necessary
 // sometimes, e.g. for clipboard) it is important to unlock them exactly as
 // many times as we lock them which just asks for using a "smart lock" class
 // when working with global pointers (which is unfortunately still necessary
 // sometimes, e.g. for clipboard) it is important to unlock them exactly as
 // many times as we lock them which just asks for using a "smart lock" class

-class GlobalPtr
+class GlobalPtrLock

 {
 public:
 {
 public:

-    GlobalPtr(HGLOBAL hGlobal) : m_hGlobal(hGlobal)
+    GlobalPtrLock(HGLOBAL hGlobal) : m_hGlobal(hGlobal)

     {
     {

-        m_ptr = ::GlobalLock(hGlobal);
+        m_ptr = GlobalLock(hGlobal);

         if ( !m_ptr )
         if ( !m_ptr )

-        {

             wxLogLastError(_T("GlobalLock"));
             wxLogLastError(_T("GlobalLock"));

-        }

     }
 
     }
 

-    ~GlobalPtr()
+    ~GlobalPtrLock()

     {
     {

-        if ( !::GlobalUnlock(m_hGlobal) )
+        if ( !GlobalUnlock(m_hGlobal) )

         {
 #ifdef __WXDEBUG__
             // this might happen simply because the block became unlocked
         {
 #ifdef __WXDEBUG__
             // this might happen simply because the block became unlocked


@@ -433,9 +647,66 @@ private:
     HGLOBAL m_hGlobal;
     void *m_ptr;
 
     HGLOBAL m_hGlobal;
     void *m_ptr;
 

-    DECLARE_NO_COPY_CLASS(GlobalPtr)
+    DECLARE_NO_COPY_CLASS(GlobalPtrLock)
+};
+
+// register the class when it is first needed and unregister it in dtor
+class ClassRegistrar
+{
+public:
+    // ctor doesn't register the class, call Initialize() for this
+    ClassRegistrar() { m_registered = -1; }
+
+    // return true if the class is already registered
+    bool IsInitialized() const { return m_registered != -1; }
+
+    // return true if the class had been already registered
+    bool IsRegistered() const { return m_registered == 1; }
+
+    // try to register the class if not done yet, return true on success
+    bool Register(const WNDCLASS& wc)
+    {
+        // we should only be called if we hadn't been initialized yet
+        wxASSERT_MSG( m_registered == -1,
+                        _T("calling ClassRegistrar::Register() twice?") );
+
+        m_registered = ::RegisterClass(&wc) ? 1 : 0;
+        if ( !IsRegistered() )
+        {
+            wxLogLastError(_T("RegisterClassEx()"));
+        }
+        else
+        {
+            m_clsname = wc.lpszClassName;
+        }
+
+        return m_registered == 1;
+    }
+
+    // get the name of the registered class (returns empty string if not
+    // registered)
+    const wxString& GetName() const { return m_clsname; }
+
+    // unregister the class if it had been registered
+    ~ClassRegistrar()
+    {
+        if ( IsRegistered() )
+        {
+            if ( !::UnregisterClass(m_clsname.wx_str(), wxhInstance) )
+            {
+                wxLogLastError(_T("UnregisterClass"));
+            }
+        }
+    }
+
+private:
+    // initial value is -1 which means that we hadn't tried registering the
+    // class yet, it becomes true or false (1 or 0) when Initialize() is called
+    int m_registered;
+
+    // the name of the class, only non empty if it had been registered
+    wxString m_clsname;

 };
 };

-#endif

 
 // ---------------------------------------------------------------------------
 // macros to make casting between WXFOO and FOO a bit easier: the GetFoo()
 
 // ---------------------------------------------------------------------------
 // macros to make casting between WXFOO and FOO a bit easier: the GetFoo()


@@ -461,8 +732,8 @@ private:
 #define GetHaccel()             ((HACCEL)GetHACCEL())
 #define GetHaccelOf(table)      ((HACCEL)((table).GetHACCEL()))
 
 #define GetHaccel()             ((HACCEL)GetHACCEL())
 #define GetHaccelOf(table)      ((HACCEL)((table).GetHACCEL()))
 

-#define GetHbrush()             ((HPEN)GetResourceHandle())
-#define GetHbrushOf(brush)      ((HPEN)(brush).GetResourceHandle())
+#define GetHbrush()             ((HBRUSH)GetResourceHandle())
+#define GetHbrushOf(brush)      ((HBRUSH)(brush).GetResourceHandle())

 
 #define GetHmenu()              ((HMENU)GetHMenu())
 #define GetHmenuOf(menu)        ((HMENU)menu->GetHMenu())
 
 #define GetHmenu()              ((HMENU)GetHMenu())
 #define GetHmenuOf(menu)        ((HMENU)menu->GetHMenu())


@@ -473,6 +744,9 @@ private:
 #define GetHfont()              ((HFONT)GetHFONT())
 #define GetHfontOf(font)        ((HFONT)(font).GetHFONT())
 
 #define GetHfont()              ((HFONT)GetHFONT())
 #define GetHfontOf(font)        ((HFONT)(font).GetHFONT())
 

+#define GetHimagelist()         ((HIMAGELIST)GetHIMAGELIST())
+#define GetHimagelistOf(imgl)   ((HIMAGELIST)imgl->GetHIMAGELIST())
+

 #define GetHpalette()           ((HPALETTE)GetHPALETTE())
 #define GetHpaletteOf(pal)      ((HPALETTE)(pal).GetHPALETTE())
 
 #define GetHpalette()           ((HPALETTE)GetHPALETTE())
 #define GetHpaletteOf(pal)      ((HPALETTE)(pal).GetHPALETTE())
 


@@ -484,12 +758,6 @@ private:
 
 #endif // wxUSE_GUI
 
 
 #endif // wxUSE_GUI
 

-// ---------------------------------------------------------------------------
-// global data
-// ---------------------------------------------------------------------------
-
-WXDLLIMPEXP_DATA_BASE(extern HINSTANCE) wxhInstance;
-

 // ---------------------------------------------------------------------------
 // global functions
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // global functions
 // ---------------------------------------------------------------------------


@@ -501,13 +769,74 @@ extern "C"
 
 WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
 
 
 WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
 

+// return the full path of the given module
+inline wxString wxGetFullModuleName(HMODULE hmod)
+{
+    wxString fullname;
+    if ( !::GetModuleFileName
+            (
+                hmod,
+                wxStringBuffer(fullname, MAX_PATH),
+                MAX_PATH
+            ) )
+    {
+        wxLogLastError(_T("GetModuleFileName"));
+    }
+
+    return fullname;
+}
+
+// return the full path of the program file
+inline wxString wxGetFullModuleName()
+{
+    return wxGetFullModuleName((HMODULE)wxGetInstance());
+}
+
+// return the run-time version of the OS in a format similar to
+// WINVER/_WIN32_WINNT compile-time macros:
+//
+//      0x0300      Windows NT 3.51
+//      0x0400      Windows 95, NT4
+//      0x0410      Windows 98
+//      0x0500      Windows ME, 2000
+//      0x0501      Windows XP
+//      0x0502      Windows 2003
+//      0x0600      Longhorn
+//
+// for the other Windows versions 0 is currently returned
+enum wxWinVersion
+{
+    wxWinVersion_Unknown = 0,
+
+    wxWinVersion_3 = 0x0300,
+    wxWinVersion_NT3 = wxWinVersion_3,
+
+    wxWinVersion_4 = 0x0400,
+    wxWinVersion_95 = wxWinVersion_4,
+    wxWinVersion_NT4 = wxWinVersion_4,
+    wxWinVersion_98 = 0x0410,
+
+    wxWinVersion_5 = 0x0500,
+    wxWinVersion_ME = wxWinVersion_5,
+    wxWinVersion_NT5 = wxWinVersion_5,
+    wxWinVersion_2000 = wxWinVersion_5,
+    wxWinVersion_XP = 0x0501,
+    wxWinVersion_2003 = 0x0502,
+
+    wxWinVersion_6 = 0x0600,
+    wxWinVersion_Vista = wxWinVersion_6,
+    wxWinVersion_NT6 = wxWinVersion_6
+};
+
+WXDLLIMPEXP_BASE wxWinVersion wxGetWinVersion();
+

 #if wxUSE_GUI
 
 // cursor stuff
 extern HCURSOR wxGetCurrentBusyCursor();    // from msw/utils.cpp
 extern const wxCursor *wxGetGlobalCursor(); // from msw/cursor.cpp
 
 #if wxUSE_GUI
 
 // 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 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);
 WXDLLEXPORT void wxFillLogFont(LOGFONT *logFont, const wxFont *font);
 WXDLLEXPORT wxFont wxCreateFontFromLogFont(const LOGFONT *logFont);
 WXDLLEXPORT wxFontEncoding wxGetFontEncFromCharSet(int charset);


@@ -516,21 +845,21 @@ WXDLLEXPORT void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos);
 WXDLLEXPORT void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos);
 
 // Find maximum size of window/rectangle
 WXDLLEXPORT void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos);
 
 // Find maximum size of window/rectangle

-WXDLLEXPORT extern void wxFindMaxSize(WXHWND hwnd, RECT *rect);
+extern WXDLLEXPORT void wxFindMaxSize(WXHWND hwnd, RECT *rect);

 
 // Safely get the window text (i.e. without using fixed size buffer)
 
 // Safely get the window text (i.e. without using fixed size buffer)

-WXDLLEXPORT extern wxString wxGetWindowText(WXHWND hWnd);
+extern WXDLLEXPORT wxString wxGetWindowText(WXHWND hWnd);

 
 // get the window class name
 
 // get the window class name

-WXDLLEXPORT extern wxString wxGetWindowClass(WXHWND hWnd);
+extern WXDLLEXPORT wxString wxGetWindowClass(WXHWND hWnd);

 
 // get the window id (should be unsigned, hence this is not wxWindowID which
 // is, for mainly historical reasons, signed)
 
 // get the window id (should be unsigned, hence this is not wxWindowID which
 // is, for mainly historical reasons, signed)

-WXDLLEXPORT extern WXWORD wxGetWindowId(WXHWND hWnd);
+extern WXDLLEXPORT WXWORD wxGetWindowId(WXHWND hWnd);

 
 // check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
 // different
 
 // check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
 // different

-WXDLLEXPORT extern bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc);
+extern WXDLLEXPORT bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc);

 
 // Does this window style specify any border?
 inline bool wxStyleHasBorder(long style)
 
 // Does this window style specify any border?
 inline bool wxStyleHasBorder(long style)


@@ -545,72 +874,28 @@ inline bool wxStyleHasBorder(long style)
 
 // this function simply checks whether the given hWnd corresponds to a wxWindow
 // and returns either that window if it does or NULL otherwise
 
 // this function simply checks whether the given hWnd corresponds to a wxWindow
 // and returns either that window if it does or NULL otherwise

-WXDLLEXPORT extern wxWindow* wxFindWinFromHandle(WXHWND hWnd);
+extern WXDLLEXPORT wxWindow* wxFindWinFromHandle(WXHWND 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.
 
 // 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.

-WXDLLEXPORT extern wxWindow *wxGetWindowFromHWND(WXHWND hwnd);
+extern WXDLLEXPORT wxWindow *wxGetWindowFromHWND(WXHWND hwnd);

 
 // Get the size of an icon
 
 // Get the size of an icon

-WXDLLEXPORT extern wxSize wxGetHiconSize(HICON hicon);
+extern WXDLLEXPORT 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);
 
 
 // Lines are drawn differently for WinCE and regular WIN32
 WXDLLEXPORT void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2);
 

-// LocalAlloc should be used on WinCE
-#ifdef __WXWINCE__
-#include <winbase.h>
-
-#if _WIN32_WCE <= 211
-#define GlobalAlloc LocalAlloc
-#define GlobalFree LocalFree
-#define GlobalLock(mem) mem
-#define GlobalUnlock(mem)
-#define GlobalSize LocalSize
-#define GPTR LPTR
-#define GHND LPTR
-#define GMEM_MOVEABLE 0
-#define GMEM_SHARE 0
-#endif
-
-#if 0
-
-HLOCAL
-WINAPI
-LocalAlloc (
-    UINT fuFlags,
-    UINT cbBytes
-    );
-
-HLOCAL
-WINAPI
-LocalFree (
-    HLOCAL hMem
-    );
-
-#ifndef LMEM_FIXED
-#define LMEM_FIXED          0x0000
-#define LMEM_MOVEABLE       0x0002
-#define LMEM_NOCOMPACT      0x0010       /**** Used for Moveable Memory  ***/
-#define LMEM_NODISCARD      0x0020       /**** Ignored *****/
-#define LMEM_ZEROINIT       0x0040
-#define LMEM_MODIFY         0x0080       /*** Used only in LocalReAlloc() **/
-#define LMEM_DISCARDABLE    0x0F00       /**** Ignored ****/
-#define LMEM_VALID_FLAGS    0x0F72
-#define LMEM_INVALID_HANDLE 0x8000
-
-#define LHND                (LMEM_MOVEABLE | LMEM_ZEROINIT)
-#define LPTR                (LMEM_FIXED | LMEM_ZEROINIT)
-#endif
-
-#endif
-    // 0
-
-#endif
-    // __WXWINCE__
+// fill the client rect of the given window on the provided dc using this brush
+inline void wxFillRect(HWND hwnd, HDC hdc, HBRUSH hbr)
+{
+    RECT rc;
+    ::GetClientRect(hwnd, &rc);
+    ::FillRect(hdc, &rc, hbr);
+}

 
 // ----------------------------------------------------------------------------
 // 32/64 bit helpers
 
 // ----------------------------------------------------------------------------
 // 32/64 bit helpers


@@ -640,29 +925,30 @@ inline void *wxSetWindowUserData(HWND hwnd, void *data)
 
 #else // __WIN32__
 
 
 #else // __WIN32__
 

-inline void *wxGetWindowProc(HWND hwnd)
+// note that the casts to LONG_PTR here are required even on 32-bit machines
+// for the 64-bit warning mode of later versions of MSVC (C4311/4312)
+inline WNDPROC wxGetWindowProc(HWND hwnd)

 {
 {

-    return (void *)::GetWindowLong(hwnd, GWL_WNDPROC);
+    return (WNDPROC)(LONG_PTR)::GetWindowLong(hwnd, GWL_WNDPROC);

 }
 
 inline void *wxGetWindowUserData(HWND hwnd)
 {
 }
 
 inline void *wxGetWindowUserData(HWND hwnd)
 {

-    return (void *)::GetWindowLong(hwnd, GWL_USERDATA);
+    return (void *)(LONG_PTR)::GetWindowLong(hwnd, GWL_USERDATA);

 }
 
 inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
 {
 }
 
 inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
 {

-    return (WNDPROC)::SetWindowLong(hwnd, GWL_WNDPROC, (LONG)func);
+    return (WNDPROC)(LONG_PTR)::SetWindowLong(hwnd, GWL_WNDPROC, (LONG_PTR)func);

 }
 
 inline void *wxSetWindowUserData(HWND hwnd, void *data)
 {
 }
 
 inline void *wxSetWindowUserData(HWND hwnd, void *data)
 {

-    return (void *)::SetWindowLong(hwnd, GWL_USERDATA, (LONG)data);
+    return (void *)(LONG_PTR)::SetWindowLong(hwnd, GWL_USERDATA, (LONG_PTR)data);

 }
 
 #endif // __WIN64__/__WIN32__
 
 #endif // wxUSE_GUI
 
 }
 
 #endif // __WIN64__/__WIN32__
 
 #endif // wxUSE_GUI
 

-#endif
-    // _WX_PRIVATE_H_
+#endif // _WX_PRIVATE_H_