]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/toplevel.cpp
Disable wxUSE_ENH_METAFILE for wxGTK builds.
[wxWidgets.git] / src / msw / toplevel.cpp
index 8219f12a43b782c8a12b20f92be3ab0e47abdb78..1a77562f51d378f73def7c6aaed056392e5dd95d 100644 (file)
     #define ICON_SMALL 0
 #endif
 
     #define ICON_SMALL 0
 #endif
 
+// FIXME-VC6: Only VC6 doesn't have this in its standard headers so this
+//            could be removed once support for it is dropped.
+#ifndef WM_UNINITMENUPOPUP
+    #define WM_UNINITMENUPOPUP 0x0125
+#endif
+
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+
+#if wxUSE_MENUS || wxUSE_MENUS_NATIVE
+    extern wxMenu *wxCurrentPopupMenu;
+#endif // wxUSE_MENUS || wxUSE_MENUS_NATIVE
+
+
 // ----------------------------------------------------------------------------
 // stubs for missing functions under MicroWindows
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // stubs for missing functions under MicroWindows
 // ----------------------------------------------------------------------------
@@ -144,6 +159,7 @@ void wxTopLevelWindowMSW::Init()
 #endif
 
     m_menuSystem = NULL;
 #endif
 
     m_menuSystem = NULL;
+    m_menuDepth = 0;
 }
 
 WXDWORD wxTopLevelWindowMSW::MSWGetStyle(long style, WXDWORD *exflags) const
 }
 
 WXDWORD wxTopLevelWindowMSW::MSWGetStyle(long style, WXDWORD *exflags) const
@@ -361,13 +377,6 @@ WXLRESULT wxTopLevelWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WX
 #endif // __SMARTPHONE__ || __POCKETPC__
 
         case WM_SYSCOMMAND:
 #endif // __SMARTPHONE__ || __POCKETPC__
 
         case WM_SYSCOMMAND:
-        // Keep the #ifdef block inside the case to fix a potential MSVC
-        // warning regarding switch statement containing no case or
-        // default labels (or a default only).
-#ifndef __WXUNIVERSAL__
-            // 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:
                 //
@@ -378,16 +387,81 @@ 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__
 #endif // #ifndef __WXUNIVERSAL__
+            }
             break;
             break;
+
+#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
+#if wxUSE_MENUS
+        case WM_INITMENUPOPUP:
+            processed = HandleMenuPopup(wxEVT_MENU_OPEN, (WXHMENU)wParam);
+            break;
+
+        case WM_MENUSELECT:
+            {
+                WXWORD item, flags;
+                WXHMENU hmenu;
+                UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu);
+
+                processed = HandleMenuSelect(item, flags, hmenu);
+            }
+            break;
+
+        case WM_EXITMENULOOP:
+            // Under Windows 98 and 2000 and later we're going to get
+            // WM_UNINITMENUPOPUP which will be used to generate this event
+            // with more information (notably the menu that was closed) so we
+            // only need this one under old Windows systems where the newer
+            // event is never sent.
+            if ( wxGetWinVersion() < wxWinVersion_98 )
+                processed = HandleExitMenuLoop(wParam);
+            break;
+
+        case WM_UNINITMENUPOPUP:
+            processed = HandleMenuPopup(wxEVT_MENU_CLOSE, (WXHMENU)wParam);
+            break;
+#endif // wxUSE_MENUS
+#endif // !__WXMICROWIN__
     }
 
     if ( !processed )
     }
 
     if ( !processed )
@@ -447,7 +521,7 @@ bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
 
     if ( !title.empty() )
     {
 
     if ( !title.empty() )
     {
-        ::SetWindowText(GetHwnd(), title.wx_str());
+        ::SetWindowText(GetHwnd(), title.t_str());
     }
 
     SubclassWin(m_hWnd);
     }
 
     SubclassWin(m_hWnd);
@@ -497,7 +571,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,
@@ -683,9 +757,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
@@ -727,6 +813,11 @@ bool wxTopLevelWindowMSW::Show(bool show)
     return true;
 }
 
     return true;
 }
 
+void wxTopLevelWindowMSW::Raise()
+{
+    ::SetForegroundWindow(GetHwnd());
+}
+
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowMSW maximize/minimize
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowMSW maximize/minimize
 // ----------------------------------------------------------------------------
@@ -792,9 +883,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;
     }
 }
 
     }
 }
 
@@ -1100,18 +1191,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;
@@ -1315,18 +1395,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
@@ -1344,47 +1412,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."),
@@ -1395,6 +1476,117 @@ void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
     }
 }
 
     }
 }
 
+#if wxUSE_MENUS
+
+bool
+wxTopLevelWindowMSW::HandleMenuSelect(WXWORD nItem, WXWORD flags, WXHMENU hMenu)
+{
+    // Ignore the special messages generated when the menu is closed (this is
+    // the only case when the flags are set to -1), in particular don't clear
+    // the help string in the status bar when this happens as it had just been
+    // restored by the base class code.
+    if ( !hMenu && flags == 0xffff )
+        return false;
+
+    // Unfortunately we also need to ignore another message which is sent after
+    // closing the currently active submenu of the menu bar by pressing Escape:
+    // in this case we get WM_UNINITMENUPOPUP, from which we generate
+    // wxEVT_MENU_CLOSE, and _then_ we get WM_MENUSELECT for the top level menu
+    // from which we overwrite the help string just restored by OnMenuClose()
+    // handler in wxFrameBase. To prevent this from happening we discard these
+    // messages but only in the case it's really the top level menu as we still
+    // need to clear the help string when a submenu is selected in a menu.
+    if ( flags == (MF_POPUP | MF_HILITE) && !m_menuDepth )
+        return false;
+
+    // sign extend to int from unsigned short we get from Windows
+    int item = (signed short)nItem;
+
+    // WM_MENUSELECT is generated for both normal items and menus, including
+    // the top level menus of the menu bar, which can't be represented using
+    // any valid identifier in wxMenuEvent so use an otherwise unused value for
+    // them
+    if ( flags & (MF_POPUP | MF_SEPARATOR) )
+        item = wxID_NONE;
+
+    wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, item);
+    event.SetEventObject(this);
+
+    if ( HandleWindowEvent(event) )
+        return true;
+
+    // by default, i.e. if the event wasn't handled above, clear the status bar
+    // text when an item which can't have any associated help string in wx API
+    // is selected
+    if ( item == wxID_NONE )
+        DoGiveHelp(wxEmptyString, true);
+
+    return false;
+}
+
+bool
+wxTopLevelWindowMSW::DoSendMenuOpenCloseEvent(wxEventType evtType, wxMenu* menu, bool popup)
+{
+    // Update the menu depth when dealing with the top level menus.
+    if ( !popup )
+    {
+        if ( evtType == wxEVT_MENU_OPEN )
+        {
+            m_menuDepth++;
+        }
+        else if ( evtType == wxEVT_MENU_CLOSE )
+        {
+            wxASSERT_MSG( m_menuDepth > 0, wxS("No open menus?") );
+
+            m_menuDepth--;
+        }
+        else
+        {
+            wxFAIL_MSG( wxS("Unexpected menu event type") );
+        }
+    }
+
+    wxMenuEvent event(evtType, popup ? wxID_ANY : 0, menu);
+    event.SetEventObject(menu);
+
+    return HandleWindowEvent(event);
+}
+
+bool wxTopLevelWindowMSW::HandleExitMenuLoop(WXWORD isPopup)
+{
+    return DoSendMenuOpenCloseEvent(wxEVT_MENU_CLOSE,
+                                    isPopup ? wxCurrentPopupMenu : NULL,
+                                    isPopup != 0);
+}
+
+bool wxTopLevelWindowMSW::HandleMenuPopup(wxEventType evtType, WXHMENU hMenu)
+{
+    bool isPopup = false;
+    wxMenu* menu = NULL;
+    if ( wxCurrentPopupMenu && wxCurrentPopupMenu->GetHMenu() == hMenu )
+    {
+        menu = wxCurrentPopupMenu;
+        isPopup = true;
+    }
+    else
+    {
+        menu = MSWFindMenuFromHMENU(hMenu);
+    }
+
+
+    return DoSendMenuOpenCloseEvent(evtType, menu, isPopup);
+}
+
+wxMenu* wxTopLevelWindowMSW::MSWFindMenuFromHMENU(WXHMENU WXUNUSED(hMenu))
+{
+    // We don't have any menus at this level.
+    return NULL;
+}
+
+#endif // wxUSE_MENUS
+
+
+
 // the DialogProc for all wxWidgets dialogs
 LONG APIENTRY _EXPORT
 wxDlgProc(HWND hDlg,
 // the DialogProc for all wxWidgets dialogs
 LONG APIENTRY _EXPORT
 wxDlgProc(HWND hDlg,