Fix pulsing of bitmaps in focused buttons under Windows 7.

[wxWidgets.git] / src / msw / toplevel.cpp

diff --git a/src/msw/toplevel.cpp b/src/msw/toplevel.cpp
index 856e761b392eb2fcb350d49624d8ff50265b3d39..0d1a0735cdde9113e08dff1284c3b12b08a22715 100644 (file)
--- a/src/msw/toplevel.cpp
+++ b/src/msw/toplevel.cpp
@@ -33,6 +33,7 @@
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/frame.h"
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/frame.h"

+    #include "wx/menu.h"

     #include "wx/containr.h"        // wxSetFocusToChild()
     #include "wx/module.h"
 #endif //WX_PRECOMP
     #include "wx/containr.h"        // wxSetFocusToChild()
     #include "wx/module.h"
 #endif //WX_PRECOMP


@@ -360,9 +361,6 @@ WXLRESULT wxTopLevelWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WX
 #endif // __SMARTPHONE__ || __POCKETPC__
 
         case WM_SYSCOMMAND:
 #endif // __SMARTPHONE__ || __POCKETPC__
 
         case WM_SYSCOMMAND:

-            // We may need to generate events for the items added to the system
-            // menu if it had been created (and presumably modified).
-            if ( m_menuSystem )

             {
                 // From MSDN:
                 //
             {
                 // From MSDN:
                 //


@@ -373,13 +371,47 @@ WXLRESULT wxTopLevelWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WX
                 //      using the bitwise AND operator.
                 unsigned id = wParam & 0xfff0;
 
                 //      using the bitwise AND operator.
                 unsigned id = wParam & 0xfff0;
 

-                // SC_SIZE is the first of the system-defined commands and we
-                // leave those to DefWindowProc().
-                if ( id < SC_SIZE )
+                // Preserve the focus when minimizing/restoring the window: we
+                // need to do it manually as DefWindowProc() doesn't appear to
+                // do this for us for some reason (perhaps because we don't use
+                // WM_NEXTDLGCTL for setting focus?). Moreover, our code in
+                // OnActivate() doesn't work in this case as we receive the
+                // deactivation event too late when the window is being
+                // minimized and the focus is already NULL by then. Similarly,
+                // we receive the activation event too early and restoring
+                // focus in it fails because the window is still minimized. So
+                // we need to do it here.
+                if ( id == SC_MINIMIZE )
+                {
+                    // For minimization, it's simple enough: just save the
+                    // focus as usual. The important thing is that we're not
+                    // minimized yet, so this works correctly.
+                    DoSaveLastFocus();
+                }
+                else if ( id == SC_RESTORE )
+                {
+                    // For restoring, it's trickier as DefWindowProc() sets
+                    // focus to the window itself. So run it first and restore
+                    // our saved focus only afterwards.
+                    processed = true;
+                    rc = wxTopLevelWindowBase::MSWWindowProc(message,
+                                                             wParam, lParam);
+
+                    DoRestoreLastFocus();
+                }
+
+#ifndef __WXUNIVERSAL__
+                // We need to generate events for the custom items added to the
+                // system menu if it had been created (and presumably modified).
+                // As SC_SIZE is the first of the system-defined commands, we
+                // only do this for the custom commands before it and leave
+                // SC_SIZE and everything after it to DefWindowProc().
+                if ( m_menuSystem && id < SC_SIZE )

                 {
                     if ( m_menuSystem->MSWCommand(0 /* unused anyhow */, id) )
                         processed = true;
                 }
                 {
                     if ( m_menuSystem->MSWCommand(0 /* unused anyhow */, id) )
                         processed = true;
                 }

+#endif // #ifndef __WXUNIVERSAL__

             }
             break;
     }
             }
             break;
     }


@@ -439,32 +471,33 @@ bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
     }
 #endif // !__WXWINCE__
 
     }
 #endif // !__WXWINCE__
 

+    if ( !title.empty() )
+    {
+        ::SetWindowText(GetHwnd(), title.t_str());
+    }
+
+    SubclassWin(m_hWnd);
+
+#if !defined(__WXWINCE__) || defined(__WINCE_STANDARDSDK__)

     // move the dialog to its initial position without forcing repainting
     int x, y, w, h;
     (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
 
     if ( x == (int)CW_USEDEFAULT )
     {
     // move the dialog to its initial position without forcing repainting
     int x, y, w, h;
     (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
 
     if ( x == (int)CW_USEDEFAULT )
     {

-        // centre it on the screen - what else can we do?
-        wxSize sizeDpy = wxGetDisplaySize();
-
-        x = (sizeDpy.x - w) / 2;
-        y = (sizeDpy.y - h) / 2;
-    }
-
-#if !defined(__WXWINCE__) || defined(__WINCE_STANDARDSDK__)
-    if ( !::MoveWindow(GetHwnd(), x, y, w, h, FALSE) )
-    {
-        wxLogLastError(wxT("MoveWindow"));
+        // Let the system position the window, just set its size.
+        ::SetWindowPos(GetHwnd(), 0,
+                       0, 0, w, h,
+                       SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);

     }
     }

-#endif
-
-    if ( !title.empty() )
+    else // Move the window to the desired location and set its size too.

     {
     {

-        ::SetWindowText(GetHwnd(), title.wx_str());
+        if ( !::MoveWindow(GetHwnd(), x, y, w, h, FALSE) )
+        {
+            wxLogLastError(wxT("MoveWindow"));
+        }

     }
     }

-
-    SubclassWin(m_hWnd);
+#endif // !__WXWINCE__

 
 #ifdef __SMARTPHONE__
     // Work around title non-display glitch
 
 #ifdef __SMARTPHONE__
     // Work around title non-display glitch


@@ -490,7 +523,7 @@ bool wxTopLevelWindowMSW::CreateFrame(const wxString& title,
 #endif
 
     return MSWCreate(MSWGetRegisteredClassName(),
 #endif
 
     return MSWCreate(MSWGetRegisteredClassName(),

-                     title.wx_str(), pos, sz, flags, exflags);
+                     title.t_str(), pos, sz, flags, exflags);

 }
 
 bool wxTopLevelWindowMSW::Create(wxWindow *parent,
 }
 
 bool wxTopLevelWindowMSW::Create(wxWindow *parent,


@@ -636,7 +669,13 @@ void wxTopLevelWindowMSW::DoShowWindow(int nShowCmd)
 {
     ::ShowWindow(GetHwnd(), nShowCmd);
 
 {
     ::ShowWindow(GetHwnd(), nShowCmd);
 

-    m_iconized = nShowCmd == SW_MINIMIZE;
+    // Hiding the window doesn't change its iconized state.
+    if ( nShowCmd != SW_HIDE )
+    {
+        // Otherwise restoring, maximizing or showing the window normally also
+        // makes it not iconized and only minimizing it does make it iconized.
+        m_iconized = nShowCmd == SW_MINIMIZE;
+    }

 }
 
 void wxTopLevelWindowMSW::ShowWithoutActivating()
 }
 
 void wxTopLevelWindowMSW::ShowWithoutActivating()


@@ -670,9 +709,21 @@ bool wxTopLevelWindowMSW::Show(bool show)
         }
         else if ( m_iconized )
         {
         }
         else if ( m_iconized )
         {

-            // iconize and show
+            // We were iconized while we were hidden, so now we need to show
+            // the window in iconized state.

             nShowCmd = SW_MINIMIZE;
         }
             nShowCmd = SW_MINIMIZE;
         }

+        else if ( ::IsIconic(GetHwnd()) )
+        {
+            // We were restored while we were hidden, so now we need to show
+            // the window in its normal state.
+            //
+            // As below, don't activate some kinds of windows.
+            if ( HasFlag(wxFRAME_TOOL_WINDOW) || !IsEnabled() )
+                nShowCmd = SW_SHOWNOACTIVATE;
+            else
+                nShowCmd = SW_RESTORE;
+        }

         else // just show
         {
             // we shouldn't use SW_SHOW which also activates the window for
         else // just show
         {
             // we shouldn't use SW_SHOW which also activates the window for


@@ -714,6 +765,11 @@ bool wxTopLevelWindowMSW::Show(bool show)
     return true;
 }
 
     return true;
 }
 

+void wxTopLevelWindowMSW::Raise()
+{
+    ::SetForegroundWindow(GetHwnd());
+}
+

 // ----------------------------------------------------------------------------
 // wxTopLevelWindowMSW maximize/minimize
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowMSW maximize/minimize
 // ----------------------------------------------------------------------------


@@ -779,9 +835,9 @@ void wxTopLevelWindowMSW::Iconize(bool iconize)
     }
     else // hidden
     {
     }
     else // hidden
     {

-        // iconizing the window shouldn't show it so just remember that we need
-        // to become iconized when shown later
-        m_iconized = true;
+        // iconizing the window shouldn't show it so just update the internal
+        // state (otherwise it's done by DoShowWindow() itself)
+        m_iconized = iconize;

     }
 }
 
     }
 }
 


@@ -1087,18 +1143,7 @@ bool wxTopLevelWindowMSW::DoSelectAndSetIcon(const wxIconBundle& icons,
 {
     const wxSize size(::GetSystemMetrics(smX), ::GetSystemMetrics(smY));
 
 {
     const wxSize size(::GetSystemMetrics(smX), ::GetSystemMetrics(smY));
 

-    // Try the exact size first.
-    wxIcon icon = icons.GetIconOfExactSize(size);
-
-    if ( !icon.IsOk() )
-    {
-        // If we didn't find any, set at least some icon: it will look scaled
-        // and ugly but in practice it's impossible to prevent this because not
-        // everyone can provide the icons in all sizes used by all versions of
-        // Windows in all DPIs (this would include creating them in at least
-        // 14, 16, 22, 32, 48, 64 and 128 pixel sizes).
-        icon = icons.GetIcon(size);
-    }
+    wxIcon icon = icons.GetIcon(size, wxIconBundle::FALLBACK_NEAREST_LARGER);

 
     if ( !icon.IsOk() )
         return false;
 
     if ( !icon.IsOk() )
         return false;


@@ -1157,54 +1202,6 @@ bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
     return true;
 }
 
     return true;
 }
 

-#ifndef __WXWINCE__
-
-bool wxTopLevelWindowMSW::SetShape(const wxRegion& region)
-{
-    wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
-                 wxT("Shaped windows must be created with the wxFRAME_SHAPED style."));
-
-    // The empty region signifies that the shape should be removed from the
-    // window.
-    if ( region.IsEmpty() )
-    {
-        if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0)
-        {
-            wxLogLastError(wxT("SetWindowRgn"));
-            return false;
-        }
-        return true;
-    }
-
-    // Windows takes ownership of the region, so
-    // we'll have to make a copy of the region to give to it.
-    DWORD noBytes = ::GetRegionData(GetHrgnOf(region), 0, NULL);
-    RGNDATA *rgnData = (RGNDATA*) new char[noBytes];
-    ::GetRegionData(GetHrgnOf(region), noBytes, rgnData);
-    HRGN hrgn = ::ExtCreateRegion(NULL, noBytes, rgnData);
-    delete[] (char*) rgnData;
-
-    // SetWindowRgn expects the region to be in coordinants
-    // relative to the window, not the client area.  Figure
-    // out the offset, if any.
-    RECT rect;
-    DWORD dwStyle =   ::GetWindowLong(GetHwnd(), GWL_STYLE);
-    DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
-    ::GetClientRect(GetHwnd(), &rect);
-    ::AdjustWindowRectEx(&rect, dwStyle, ::GetMenu(GetHwnd()) != NULL, dwExStyle);
-    ::OffsetRgn(hrgn, -rect.left, -rect.top);
-
-    // Now call the shape API with the new region.
-    if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0)
-    {
-        wxLogLastError(wxT("SetWindowRgn"));
-        return false;
-    }
-    return true;
-}
-
-#endif // !__WXWINCE__
-

 void wxTopLevelWindowMSW::RequestUserAttention(int flags)
 {
     // check if we can use FlashWindowEx(): unfortunately a simple test for
 void wxTopLevelWindowMSW::RequestUserAttention(int flags)
 {
     // check if we can use FlashWindowEx(): unfortunately a simple test for


@@ -1256,6 +1253,7 @@ void wxTopLevelWindowMSW::RequestUserAttention(int flags)
 
 wxMenu *wxTopLevelWindowMSW::MSWGetSystemMenu() const
 {
 
 wxMenu *wxTopLevelWindowMSW::MSWGetSystemMenu() const
 {

+#ifndef __WXUNIVERSAL__

     if ( !m_menuSystem )
     {
         HMENU hmenu = ::GetSystemMenu(GetHwnd(), FALSE);
     if ( !m_menuSystem )
     {
         HMENU hmenu = ::GetSystemMenu(GetHwnd(), FALSE);


@@ -1281,6 +1279,7 @@ wxMenu *wxTopLevelWindowMSW::MSWGetSystemMenu() const
         // correct but doesn't seem to have any serious drawbacks.
         m_menuSystem->SetInvokingWindow(self);
     }
         // correct but doesn't seem to have any serious drawbacks.
         m_menuSystem->SetInvokingWindow(self);
     }

+#endif // #ifndef __WXUNIVERSAL__

 
     return m_menuSystem;
 }
 
     return m_menuSystem;
 }


@@ -1348,18 +1347,6 @@ bool wxTopLevelWindowMSW::CanSetTransparent()
     return (os_type == wxOS_WINDOWS_NT && ver_major >= 5);
 }
 
     return (os_type == wxOS_WINDOWS_NT && ver_major >= 5);
 }
 

-void wxTopLevelWindowMSW::DoEnable(bool enable)
-{
-    wxTopLevelWindowBase::DoEnable(enable);
-
-    // Enabling or disabling a window may change its appearance. Unfortunately,
-    // in at least some situation, toplevel windows don't repaint themselves,
-    // so we have to issue explicit refresh to avoid rendering artifacts.
-    //
-    // TODO: find out just what exactly is wrong here
-    Refresh();
-}
-

 void wxTopLevelWindowMSW::DoFreeze()
 {
     // do nothing: freezing toplevel window causes paint and mouse events
 void wxTopLevelWindowMSW::DoFreeze()
 {
     // do nothing: freezing toplevel window causes paint and mouse events


@@ -1377,47 +1364,60 @@ void wxTopLevelWindowMSW::DoThaw()
 // wxTopLevelWindow event handling
 // ----------------------------------------------------------------------------
 
 // wxTopLevelWindow event handling
 // ----------------------------------------------------------------------------
 

-// Default activation behaviour - set the focus for the first child
-// subwindow found.
+void wxTopLevelWindowMSW::DoSaveLastFocus()
+{
+    if ( m_iconized )
+        return;
+
+    // remember the last focused child if it is our child
+    m_winLastFocused = FindFocus();
+
+    if ( m_winLastFocused )
+    {
+        // and don't remember it if it's a child from some other frame
+        if ( wxGetTopLevelParent(m_winLastFocused) != this )
+        {
+            m_winLastFocused = NULL;
+        }
+    }
+}
+
+void wxTopLevelWindowMSW::DoRestoreLastFocus()
+{
+    wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent()
+                                        : NULL;
+    if ( !parent )
+    {
+        parent = this;
+    }
+
+    wxSetFocusToChild(parent, &m_winLastFocused);
+}
+

 void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
 {
     if ( event.GetActive() )
     {
 void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
 {
     if ( event.GetActive() )
     {

+        // We get WM_ACTIVATE before being restored from iconized state, so we
+        // can be still iconized here. In this case, avoid restoring the focus
+        // as it doesn't work anyhow and we will do when we're really restored.
+        if ( m_iconized )
+        {
+            event.Skip();
+            return;
+        }
+

         // restore focus to the child which was last focused unless we already
         // have it
         wxLogTrace(wxT("focus"), wxT("wxTLW %p activated."), m_hWnd);
 
         wxWindow *winFocus = FindFocus();
         if ( !winFocus || wxGetTopLevelParent(winFocus) != this )
         // restore focus to the child which was last focused unless we already
         // have it
         wxLogTrace(wxT("focus"), wxT("wxTLW %p activated."), m_hWnd);
 
         wxWindow *winFocus = FindFocus();
         if ( !winFocus || wxGetTopLevelParent(winFocus) != this )

-        {
-            wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent()
-                                                : NULL;
-            if ( !parent )
-            {
-                parent = this;
-            }
-
-            wxSetFocusToChild(parent, &m_winLastFocused);
-        }
+            DoRestoreLastFocus();

     }
     else // deactivating
     {
     }
     else // deactivating
     {

-        // remember the last focused child if it is our child
-        m_winLastFocused = FindFocus();
-
-        if ( m_winLastFocused )
-        {
-            // let it know that it doesn't have focus any more
-            // But this will already be done via WM_KILLFOCUS, so we'll get two kill
-            // focus events if we call it explicitly.
-            // m_winLastFocused->HandleKillFocus((WXHWND)NULL);
-
-            // and don't remember it if it's a child from some other frame
-            if ( wxGetTopLevelParent(m_winLastFocused) != this )
-            {
-                m_winLastFocused = NULL;
-            }
-        }
+        DoSaveLastFocus();

 
         wxLogTrace(wxT("focus"),
                    wxT("wxTLW %p deactivated, last focused: %p."),
 
         wxLogTrace(wxT("focus"),
                    wxT("wxTLW %p deactivated, last focused: %p."),