SWIGged updates for wxMSW
[wxWidgets.git] / src / msw / window.cpp
index a2dca1ea29a4fcef338a514b22a3b9ddff843503..23d1786d2b769085ca4e6a300a86da0c3fcb9fba 100644 (file)
@@ -37,6 +37,7 @@
     #include "wx/menu.h"
     #include "wx/dc.h"
     #include "wx/dcclient.h"
+    #include "wx/dcmemory.h"
     #include "wx/utils.h"
     #include "wx/app.h"
     #include "wx/layout.h"
 // global variables
 // ---------------------------------------------------------------------------
 
-// the last Windows message we got (MT-UNSAFE)
+// the last Windows message we got (FIXME-MT)
 extern MSG s_currentMsg;
 
 #if wxUSE_MENUS_NATIVE
@@ -131,6 +132,10 @@ wxMenu *wxCurrentPopupMenu = NULL;
 
 extern const wxChar *wxCanvasClassName;
 
+// true if we had already created the std colour map, used by
+// wxGetStdColourMap() and wxWindow::OnSysColourChanged()           (FIXME-MT)
+static bool gs_hasStdCmap = FALSE;
+
 // ---------------------------------------------------------------------------
 // private functions
 // ---------------------------------------------------------------------------
@@ -298,9 +303,6 @@ void wxWindowMSW::Init()
 
     m_hWnd = 0;
 
-    // pass WM_GETDLGCODE to DefWindowProc()
-    m_lDlgCode = 0;
-
     m_xThumbSize = 0;
     m_yThumbSize = 0;
     m_backgroundTransparent = FALSE;
@@ -320,8 +322,6 @@ wxWindowMSW::~wxWindowMSW()
 {
     m_isBeingDeleted = TRUE;
 
-    MSWDetachWindowMenu();
-
 #ifndef __WXUNIVERSAL__
     // VS: make sure there's no wxFrame with last focus set to us:
     for ( wxWindow *win = GetParent(); win; win = win->GetParent() )
@@ -386,53 +386,27 @@ bool wxWindowMSW::Create(wxWindow *parent,
 
     parent->AddChild(this);
 
-    // all windows are created visible
-    DWORD msflags = WS_CHILD | WS_VISIBLE;
+    // note that all windows are created visible by default
+    WXDWORD exstyle;
+    DWORD msflags = WS_VISIBLE | MSWGetCreateWindowFlags(&exstyle);
 
 #ifdef __WXUNIVERSAL__
-    // no 3d effects, we draw them ourselves
-    WXDWORD exStyle = 0;
-#else // !wxUniversal
-    if ( style & wxCLIP_CHILDREN )
-        msflags |= WS_CLIPCHILDREN;
-    if ( style & wxCLIP_SIBLINGS )
-        msflags |= WS_CLIPSIBLINGS;
-
-    bool want3D;
-    WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D);
-
-    // Even with extended styles, need to combine with WS_BORDER
-    // for them to look right.
-    if ( want3D ||
-        (m_windowStyle & (wxBORDER |
-                          wxSIMPLE_BORDER |
-                          wxRAISED_BORDER |
-                          wxSUNKEN_BORDER |
-                          wxDOUBLE_BORDER)) )
-    {
-        msflags |= WS_BORDER;
-    }
-
-    // calculate the value to return from WM_GETDLGCODE handler
-    if ( GetWindowStyleFlag() & wxWANTS_CHARS )
-    {
-        // want everything: i.e. all keys and WM_CHAR message
-        m_lDlgCode = DLGC_WANTARROWS | DLGC_WANTCHARS |
-                     DLGC_WANTTAB | DLGC_WANTMESSAGE;
-    }
-#endif // wxUniversal/!wxUniversal
+    // no borders, we draw them ourselves
+    exstyle = 0;
+    msflags &= ~WS_BORDER;
+#endif // wxUniversal
 
     if ( style & wxPOPUP_WINDOW )
     {
         // a popup window floats on top of everything
-        exStyle |= WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
+        exstyle |= WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
 
         // it is also created hidden as other top level windows
         msflags &= ~WS_VISIBLE;
         m_isShown = FALSE;
     }
 
-    return MSWCreate(wxCanvasClassName, NULL, pos, size, msflags, exStyle);
+    return MSWCreate(wxCanvasClassName, NULL, pos, size, msflags, exstyle);
 }
 
 // ---------------------------------------------------------------------------
@@ -450,23 +424,18 @@ void wxWindowMSW::SetFocus()
 
     if ( !::SetFocus(hWnd) )
     {
+#if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
         // was there really an error?
-#ifndef __WXMICROWIN__
         DWORD dwRes = ::GetLastError();
-#else
-
-        DWORD dwRes = 0;
-#endif
         if ( dwRes )
         {
-            wxLogApiError(_T("SetFocus"), dwRes);
+            HWND hwndFocus = ::GetFocus();
+            if ( hwndFocus != hWnd )
+            {
+                wxLogApiError(_T("SetFocus"), dwRes);
+            }
         }
-
-        // VZ: just why does this happen sometimes?? any idea?
-#if 0
-        HWND hwndFocus = ::GetFocus();
-        wxASSERT_MSG( hwndFocus == hWnd, _T("SetFocus() didn't work?") );
-#endif // 0
+#endif // Debug
     }
 }
 
@@ -548,7 +517,7 @@ wxString wxWindowMSW::GetTitle() const
     return wxGetWindowText(GetHWND());
 }
 
-void wxWindowMSW::CaptureMouse()
+void wxWindowMSW::DoCaptureMouse()
 {
     HWND hWnd = GetHwnd();
     if ( hWnd )
@@ -557,7 +526,7 @@ void wxWindowMSW::CaptureMouse()
     }
 }
 
-void wxWindowMSW::ReleaseMouse()
+void wxWindowMSW::DoReleaseMouse()
 {
     if ( !::ReleaseCapture() )
     {
@@ -904,15 +873,21 @@ void wxWindowMSW::SetScrollbar(int orient, int pos, int thumbVisible,
 void wxWindowMSW::ScrollWindow(int dx, int dy, const wxRect *prect)
 {
     RECT rect;
+    RECT *pr;
     if ( prect )
     {
         rect.left = prect->x;
         rect.top = prect->y;
         rect.right = prect->x + prect->width;
         rect.bottom = prect->y + prect->height;
+        pr = ▭
+    }
+    else
+    {
+        pr = NULL;
     }
 
-    ::ScrollWindow(GetHwnd(), dx, dy, prect ? &rect : NULL, NULL);
+    ::ScrollWindow(GetHwnd(), dx, dy, pr, pr);
 }
 
 static bool ScrollVertically(HWND hwnd, int kind, int count)
@@ -969,7 +944,7 @@ void wxWindowMSW::SubclassWin(WXHWND hWnd)
     wxAssociateWinWithHandle(hwnd, this);
 
     m_oldWndProc = (WXFARPROC)::GetWindowLong((HWND)hWnd, GWL_WNDPROC);
-    
+
     // we don't need to subclass the window of our own class (in the Windows
     // sense of the word)
     if ( !wxCheckWindowWndProc(hWnd, (WXFARPROC)wxWndProc) )
@@ -1024,17 +999,134 @@ bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc)
     //     FIXME: Doesn't handle wnd procs set by SetWindowLong, only these set
     //            with RegisterClass!!
 
-    static wxChar buffer[512];
-    WNDCLASS cls;
+    if ( wxUsingUnicowsDll() )
+    {
+        static wxChar buffer[512];
+        WNDCLASS cls;
 
-    ::GetClassName((HWND)hWnd, buffer, 512);
-    ::GetClassInfo(wxGetInstance(), buffer, &cls);
-    return wndProc == (WXFARPROC)cls.lpfnWndProc;
-#else
-    return wndProc == (WXFARPROC)::GetWindowLong((HWND)hWnd, GWL_WNDPROC);
+        ::GetClassName((HWND)hWnd, buffer, 512);
+        ::GetClassInfo(wxGetInstance(), buffer, &cls);
+        return wndProc == (WXFARPROC)cls.lpfnWndProc;
+    }
+    else
 #endif
+    {
+        return wndProc == (WXFARPROC)::GetWindowLong((HWND)hWnd, GWL_WNDPROC);
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Style handling
+// ----------------------------------------------------------------------------
+
+void wxWindowMSW::SetWindowStyleFlag(long flags)
+{
+    long flagsOld = GetWindowStyleFlag();
+    if ( flags == flagsOld )
+        return;
+
+    // update the internal variable
+    wxWindowBase::SetWindowStyleFlag(flags);
+
+    // now update the Windows style as well if needed - and if the window had
+    // been already created
+    if ( !GetHwnd() )
+        return;
+
+    WXDWORD exstyle, exstyleOld;
+    long style = MSWGetStyle(flags, &exstyle),
+         styleOld = MSWGetStyle(flagsOld, &exstyleOld);
+
+    if ( style != styleOld )
+    {
+        // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
+        // this function so instead of simply setting the style to the new
+        // value we clear the bits which were set in styleOld but are set in
+        // the new one and set the ones which were not set before
+        long styleReal = ::GetWindowLong(GetHwnd(), GWL_STYLE);
+        styleReal &= ~styleOld;
+        styleReal |= style;
+
+        ::SetWindowLong(GetHwnd(), GWL_STYLE, styleReal);
+    }
+
+    // and the extended style
+    if ( exstyle != exstyleOld )
+    {
+        long exstyleReal = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
+        exstyleReal &= ~exstyleOld;
+        exstyleReal |= exstyle;
+
+        ::SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyleReal);
+
+        // we must call SetWindowPos() to flash the cached extended style and
+        // also to make the change to wxSTAY_ON_TOP style take effect: just
+        // setting the style simply doesn't work
+        if ( !::SetWindowPos(GetHwnd(),
+                             exstyleReal & WS_EX_TOPMOST ? HWND_TOPMOST
+                                                         : HWND_NOTOPMOST,
+                             0, 0, 0, 0,
+                             SWP_NOMOVE | SWP_NOSIZE) )
+        {
+            wxLogLastError(_T("SetWindowPos"));
+        }
+    }
 }
 
+WXDWORD wxWindowMSW::MSWGetStyle(long flags, WXDWORD *exstyle) const
+{
+    // translate the style
+    WXDWORD style = WS_CHILD;
+
+    if ( flags & wxCLIP_CHILDREN )
+        style |= WS_CLIPCHILDREN;
+
+    if ( flags & wxCLIP_SIBLINGS )
+        style |= WS_CLIPSIBLINGS;
+
+    wxBorder border = (wxBorder)(flags & wxBORDER_MASK);
+    if ( border != wxBORDER_NONE && border != wxBORDER_DEFAULT )
+        style |= WS_BORDER;
+
+    // now deal with ext style if the caller wants it
+    if ( exstyle )
+    {
+        *exstyle = 0;
+
+        if ( flags & wxTRANSPARENT_WINDOW )
+            *exstyle |= WS_EX_TRANSPARENT;
+
+        switch ( flags & wxBORDER_MASK )
+        {
+            default:
+                wxFAIL_MSG( _T("unknown border style") );
+                // fall through
+
+            case wxBORDER_NONE:
+            case wxBORDER_SIMPLE:
+            case wxBORDER_DEFAULT:
+                break;
+
+            case wxBORDER_STATIC:
+                *exstyle |= WS_EX_STATICEDGE;
+                break;
+
+            case wxBORDER_RAISED:
+                *exstyle |= WS_EX_WINDOWEDGE;
+                break;
+
+            case wxBORDER_SUNKEN:
+                *exstyle |= WS_EX_CLIENTEDGE;
+                break;
+
+            case wxBORDER_DOUBLE:
+                *exstyle |= WS_EX_DLGMODALFRAME;
+                break;
+        }
+    }
+
+    return style;
+}
 
 // Make a Windows extended style from the given wxWindows window style
 WXDWORD wxWindowMSW::MakeExtendedStyle(long style, bool eliminateBorders)
@@ -1182,6 +1274,8 @@ void wxWindowMSW::OnIdle(wxIdleEvent& WXUNUSED(event))
     // Check if we need to send a LEAVE event
     if ( m_mouseInWindow )
     {
+        // note that we should generate the leave event whether the window has
+        // or doesn't have mouse capture
         if ( !IsMouseInWindow() )
         {
             // Generate a LEAVE event
@@ -1446,6 +1540,12 @@ void wxWindowMSW::DoClientToScreen(int *x, int *y) const
 
 void wxWindowMSW::DoMoveWindow(int x, int y, int width, int height)
 {
+    // TODO: is this consistent with other platforms?
+    // Still, negative width or height shouldn't be allowed
+    if (width < 0)
+        width = 0;
+    if (height < 0)
+        height = 0;
     if ( !::MoveWindow(GetHwnd(), x, y, width, height, TRUE) )
     {
         wxLogLastError(wxT("MoveWindow"));
@@ -1527,22 +1627,25 @@ void wxWindowMSW::DoSetClientSize(int width, int height)
     // will not be correct as the difference between the total and client size
     // changes - so we keep changing it until we get it right
     //
-    // normally this loop shouldn't take more than 2 iterations (usually 1 but
-    // if scrollbars [dis]appear as the result of the first call, then 2) but
-    // just to be on the safe side we check for it instead of making it an
+    // normally this loop shouldn't take more than 3 iterations (usually 1 but
+    // if scrollbars [dis]appear as the result of the first call, then 2 and it
+    // may become 3 if the window had 0 size originally and so we didn't
+    // calculate the scrollbar correction correctly during the first iteration)
+    // but just to be on the safe side we check for it instead of making it an
     // "infinite" loop (i.e. leaving break inside as the only way to get out)
-    for ( int i = 0; i < 3; i++ )
+    for ( int i = 0; i < 4; i++ )
     {
         RECT rectClient;
         ::GetClientRect(GetHwnd(), &rectClient);
 
         // if the size is already ok, stop here (rectClient.left = top = 0)
-        if ( rectClient.right == width && rectClient.bottom == height )
+        if ( (rectClient.right == width || width == -1) &&
+             (rectClient.bottom == height || height == -1) )
         {
             break;
         }
 
-        if ( i == 2 )
+        if ( i == 3 )
         {
             // how did it happen? maybe OnSize() handler does something really
             // strange in this class?
@@ -1949,11 +2052,12 @@ bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
     return m_acceleratorTable.Translate(this, pMsg);
 #else
+    (void) pMsg;
     return FALSE;
 #endif // wxUSE_ACCEL
 }
 
-bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* pMsg)
+bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* WXUNUSED(pMsg))
 {
     // preprocess all messages by default
     return TRUE;
@@ -2356,9 +2460,11 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
 #endif // defined(WM_DRAWITEM)
 
         case WM_GETDLGCODE:
-            if ( m_lDlgCode )
+            if ( GetWindowStyleFlag() & wxWANTS_CHARS )
             {
-                rc.result = m_lDlgCode;
+                // want everything: i.e. all keys and WM_CHAR message
+                rc.result = DLGC_WANTARROWS | DLGC_WANTCHARS |
+                            DLGC_WANTTAB | DLGC_WANTMESSAGE;
                 processed = TRUE;
             }
             //else: get the dlg code from the DefWindowProc()
@@ -2492,11 +2598,15 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
             break;
 #endif // !__WXMICROWIN__
 
-            // the return value for this message is ignored
         case WM_SYSCOLORCHANGE:
+            // the return value for this message is ignored
             processed = HandleSysColorChange();
             break;
 
+        case WM_DISPLAYCHANGE:
+            processed = HandleDisplayChange();
+            break;
+
         case WM_PALETTECHANGED:
             processed = HandlePaletteChanged((WXHWND) (HWND) wParam);
             break;
@@ -2602,21 +2712,6 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
             }
             break;
 #endif // __WIN32__
-
-            // unfortunately this doesn't really work as then window which
-            // doesn't accept focus doesn't get any mouse events neither which
-            // means it can't get any input at all
-#if 0 //def __WXUNIVERSAL__
-        case WM_NCHITTEST:
-            // we shouldn't allow the windows which don't want to get focus to
-            // get it
-            if ( !AcceptsFocus() )
-            {
-                rc.result = HTTRANSPARENT;
-                processed = TRUE;
-            }
-            break;
-#endif // __WXUNIVERSAL__
     }
 
     if ( !processed )
@@ -2679,38 +2774,6 @@ void wxWindowMSW::MSWDestroyWindow()
 {
 }
 
-void wxWindowMSW::MSWDetachWindowMenu()
-{
-#ifndef __WXUNIVERSAL__
-    if ( m_hMenu )
-    {
-        wxChar buf[1024];
-        HMENU hMenu = (HMENU)m_hMenu;
-
-        int N = ::GetMenuItemCount(hMenu);
-        for ( int i = 0; i < N; i++ )
-        {
-            if ( !::GetMenuString(hMenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) )
-            {
-                wxLogLastError(wxT("GetMenuString"));
-
-                continue;
-            }
-
-            if ( wxStrcmp(buf, _("&Window")) == 0 )
-            {
-                if ( !::RemoveMenu(hMenu, i, MF_BYPOSITION) )
-                {
-                    wxLogLastError(wxT("RemoveMenu"));
-                }
-
-                break;
-            }
-        }
-    }
-#endif // __WXUNIVERSAL__
-}
-
 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
                                            const wxSize& size,
                                            int& x, int& y,
@@ -2859,7 +2922,7 @@ bool wxWindowMSW::MSWCreate(const wxChar *wclass,
 
     SubclassWin(m_hWnd);
 
-    SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+    SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 
     return TRUE;
 }
@@ -3317,6 +3380,14 @@ bool wxWindowMSW::HandleSysColorChange()
     return FALSE;
 }
 
+bool wxWindowMSW::HandleDisplayChange()
+{
+    wxDisplayChangedEvent event;
+    event.SetEventObject(this);
+
+    return GetEventHandler()->ProcessEvent(event);
+}
+
 bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush,
                               WXHDC pDC,
                               WXHWND pWnd,
@@ -3363,6 +3434,40 @@ WXHBRUSH wxWindowMSW::OnCtlColor(WXHDC WXUNUSED(hDC),
 
 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange)
 {
+#if wxUSE_PALETTE
+    // same as below except we don't respond to our own messages
+    if ( hWndPalChange != GetHWND() )
+    {
+        // check to see if we our our parents have a custom palette
+        wxWindow *win = this;
+        while ( win && !win->HasCustomPalette() )
+        {
+            win = win->GetParent();
+        }
+
+        if ( win && win->HasCustomPalette() )
+        {
+            // realize the palette to see whether redrawing is needed
+            HDC hdc = ::GetDC((HWND) hWndPalChange);
+            win->m_palette.SetHPALETTE((WXHPALETTE)
+                    ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
+
+            int result = ::RealizePalette(hdc);
+
+            // restore the palette (before releasing the DC)
+            win->m_palette.SetHPALETTE((WXHPALETTE)
+                    ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
+            ::RealizePalette(hdc);
+            ::ReleaseDC((HWND) hWndPalChange, hdc);
+
+            // now check for the need to redraw
+            if (result > 0)
+                InvalidateRect((HWND) hWndPalChange, NULL, TRUE);
+        }
+
+    }
+#endif // wxUSE_PALETTE
+
     wxPaletteChangedEvent event(GetId());
     event.SetEventObject(this);
     event.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
@@ -3372,6 +3477,29 @@ bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange)
 
 bool wxWindowMSW::HandleQueryNewPalette()
 {
+
+#if wxUSE_PALETTE
+    // check to see if we our our parents have a custom palette
+    wxWindow *win = this;
+    while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
+    if (win->HasCustomPalette()) {
+        /* realize the palette to see whether redrawing is needed */
+        HDC hdc = GetDC((HWND) GetHWND());
+        win->m_palette.SetHPALETTE( (WXHPALETTE)
+             ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), FALSE) );
+
+        int result = ::RealizePalette(hdc);
+        /* restore the palette (before releasing the DC) */
+        win->m_palette.SetHPALETTE( (WXHPALETTE)
+             ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), TRUE) );
+        ::RealizePalette(hdc);
+        ::ReleaseDC((HWND) GetHWND(), hdc);
+        /* now check for the need to redraw */
+        if (result > 0)
+            ::InvalidateRect((HWND) GetHWND(), NULL, TRUE);
+        }
+#endif // wxUSE_PALETTE
+
     wxQueryNewPaletteEvent event(GetId());
     event.SetEventObject(this);
 
@@ -3379,8 +3507,16 @@ bool wxWindowMSW::HandleQueryNewPalette()
 }
 
 // Responds to colour changes: passes event on to children.
-void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& event)
+void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
 {
+    // the top level window also reset the standard colour map as it might have
+    // changed (there is no need to do it for the non top level windows as we
+    // only have to do it once)
+    if ( IsTopLevel() )
+    {
+        // FIXME-MT
+        gs_hasStdCmap = FALSE;
+    }
     wxWindowList::Node *node = GetChildren().GetFirst();
     while ( node )
     {
@@ -3413,6 +3549,72 @@ void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& event)
     }
 }
 
+extern wxCOLORMAP *wxGetStdColourMap()
+{
+    static COLORREF s_stdColours[wxSTD_COL_MAX];
+    static wxCOLORMAP s_cmap[wxSTD_COL_MAX];
+
+    if ( !gs_hasStdCmap )
+    {
+        static bool s_coloursInit = FALSE;
+
+        if ( !s_coloursInit )
+        {
+            // When a bitmap is loaded, the RGB values can change (apparently
+            // because Windows adjusts them to care for the old programs always
+            // using 0xc0c0c0 while the transparent colour for the new Windows
+            // versions is different). But we do this adjustment ourselves so
+            // we want to avoid Windows' "help" and for this we need to have a
+            // reference bitmap which can tell us what the RGB values change
+            // to.
+            wxBitmap stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
+            if ( stdColourBitmap.Ok() )
+            {
+                // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
+                wxASSERT_MSG( stdColourBitmap.GetWidth() == wxSTD_COL_MAX,
+                              _T("forgot to update wxBITMAP_STD_COLOURS!") );
+
+                wxMemoryDC memDC;
+                memDC.SelectObject(stdColourBitmap);
+
+                wxColour colour;
+                for ( size_t i = 0; i < WXSIZEOF(s_stdColours); i++ )
+                {
+                    memDC.GetPixel(i, 0, &colour);
+                    s_stdColours[i] = wxColourToRGB(colour);
+                }
+            }
+            else // wxBITMAP_STD_COLOURS couldn't be loaded
+            {
+                s_stdColours[0] = RGB(000,000,000);     // black
+                s_stdColours[1] = RGB(128,128,128);     // dark grey
+                s_stdColours[2] = RGB(192,192,192);     // light grey
+                s_stdColours[3] = RGB(255,255,255);     // white
+                //s_stdColours[4] = RGB(000,000,255);     // blue
+                //s_stdColours[5] = RGB(255,000,255);     // magenta
+            }
+
+            s_coloursInit = TRUE;
+        }
+
+        gs_hasStdCmap = TRUE;
+
+        // create the colour map
+#define INIT_CMAP_ENTRY(col) \
+            s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
+            s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
+
+        INIT_CMAP_ENTRY(BTNTEXT);
+        INIT_CMAP_ENTRY(BTNSHADOW);
+        INIT_CMAP_ENTRY(BTNFACE);
+        INIT_CMAP_ENTRY(BTNHIGHLIGHT);
+
+#undef INIT_CMAP_ENTRY
+    }
+
+    return s_cmap;
+}
+
 // ---------------------------------------------------------------------------
 // painting
 // ---------------------------------------------------------------------------
@@ -3552,27 +3754,32 @@ bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo)
 
     bool rc = FALSE;
 
-    if ( m_minWidth != -1 )
+    int minWidth = GetMinWidth(),
+        minHeight = GetMinHeight(),
+        maxWidth = GetMaxWidth(),
+        maxHeight = GetMaxHeight();
+
+    if ( minWidth != -1 )
     {
-        info->ptMinTrackSize.x = m_minWidth;
+        info->ptMinTrackSize.x = minWidth;
         rc = TRUE;
     }
 
-    if ( m_minHeight != -1 )
+    if ( minHeight != -1 )
     {
-        info->ptMinTrackSize.y = m_minHeight;
+        info->ptMinTrackSize.y = minHeight;
         rc = TRUE;
     }
 
-    if ( m_maxWidth != -1 )
+    if ( maxWidth != -1 )
     {
-        info->ptMaxTrackSize.x = m_maxWidth;
+        info->ptMaxTrackSize.x = maxWidth;
         rc = TRUE;
     }
 
-    if ( m_maxHeight != -1 )
+    if ( maxHeight != -1 )
     {
-        info->ptMaxTrackSize.y = m_maxHeight;
+        info->ptMaxTrackSize.y = maxHeight;
         rc = TRUE;
     }
 
@@ -4951,6 +5158,7 @@ wxPoint wxGetMousePosition()
 {
     POINT pt;
     GetCursorPos( & pt );
+    
     return wxPoint(pt.x, pt.y);
 }