wxDialog change (Show() completely rewritten, modal dialogs handling changed)

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@5737 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/msw/dialog.h

@@ -60,43 +60,38 @@ public:
 
     ~wxDialog();
 
+    // override some base class virtuals
     virtual bool Destroy();
+    virtual bool Show(bool show);
+    virtual void Iconize(bool iconize);
+    virtual bool IsIconized() const;
 
-    virtual void DoSetClientSize(int width, int height);
+    virtual bool IsTopLevel() const { return TRUE; }
 
-    virtual void GetPosition(int *x, int *y) const;
+    void SetModal(bool flag);
+    virtual bool IsModal() const;
 
-    bool Show(bool show);
+    // For now, same as Show(TRUE) but returns return code
-    bool IsShown() const;
+    virtual int ShowModal();
-    void Iconize(bool iconize);
+
+    // may be called to terminate the dialog with the given return code
+    virtual void EndModal(int retCode);
+
+    // returns TRUE if we're in a modal loop
+    bool IsModalShowing() const;
 
 #if WXWIN_COMPATIBILITY
     bool Iconized() const { return IsIconized(); };
 #endif
 
-    virtual bool IsIconized() const;
+    // implementation only from now on
-    void Fit();
+    // -------------------------------
 
-    virtual bool IsTopLevel() const { return TRUE; }
+    // event handlers
-    
-    void SetTitle(const wxString& title);
-    wxString GetTitle() const ;
-
-    void OnSize(wxSizeEvent& event);
     bool OnClose();
     void OnCharHook(wxKeyEvent& event);
-    void OnPaint(wxPaintEvent& event);
     void OnCloseWindow(wxCloseEvent& event);
 
-    void SetModal(bool flag);
-
-    virtual void Centre(int direction = wxBOTH);
-    virtual bool IsModal() const;
-
-    // For now, same as Show(TRUE) but returns return code
-    virtual int ShowModal();
-    virtual void EndModal(int retCode);
-
     // Standard buttons
     void OnOK(wxCommandEvent& event);
     void OnApply(wxCommandEvent& event);
@@ -105,30 +100,21 @@ public:
     // Responds to colour changes
     void OnSysColourChanged(wxSysColourChangedEvent& event);
 
-    // implementation
+    // Windows callbacks
-    // --------------
-
     long MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
 
+#if wxUSE_CTL3D
     virtual WXHBRUSH OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
                                 WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
-
+#endif // wxUSE_CTL3D
-    bool IsModalShowing() const { return m_modalShowing; }
-
-  // tooltip management
-#if wxUSE_TOOLTIPS
-    WXHWND GetToolTipCtrl() const { return m_hwndToolTip; }
-    void SetToolTipCtrl(WXHWND hwndTT) { m_hwndToolTip = hwndTT; }
-#endif // tooltips
 
 protected:
-    bool   m_modalShowing;
+    // override more base class virtuals
-    WXHWND m_hwndOldFocus;  // the window which had focus before we were shown
+    virtual void DoSetClientSize(int width, int height);
+    virtual void DoGetPosition(int *x, int *y) const;
 
-private:
+    // show modal dialog and enter modal loop
-#if wxUSE_TOOLTIPS
+    void DoShowModal();
-    WXHWND                m_hwndToolTip;
-#endif // tooltips
 
 private:
     DECLARE_EVENT_TABLE()

src/msw/app.cpp

@@ -916,12 +916,10 @@ int wxApp::MainLoop()
         wxMutexGuiLeaveOrEnter();
 #endif // wxUSE_THREADS
 
-        while ( !::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) &&
+        while ( !Pending() && ProcessIdle() )
-                ProcessIdle() )
+            ;
-        {
-        }
-
 
+        // a message came or no more idle processing to do
         DoMessage();
     }
 
@@ -940,12 +938,13 @@ bool wxApp::ProcessIdle()
 
 void wxApp::ExitMainLoop()
 {
+    // VZ: why not ::PostQuitMessage()?
     m_keepGoing = FALSE;
 }
 
 bool wxApp::Pending()
 {
-    return (::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) != 0);
+    return ::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) != 0;
 }
 
 void wxApp::Dispatch()

src/msw/dialog.cpp

@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        dialog.cpp
+// Name:        src/msw/dialog.cpp
 // Purpose:     wxDialog class
 // Author:      Julian Smart
 // Modified by:
@@ -9,59 +9,96 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __GNUG__
-#pragma implementation "dialog.h"
+    #pragma implementation "dialog.h"
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #ifndef WX_PRECOMP
-#include "wx/dialog.h"
+    #include "wx/dialog.h"
-#include "wx/utils.h"
+    #include "wx/utils.h"
-#include "wx/frame.h"
+    #include "wx/frame.h"
-#include "wx/app.h"
+    #include "wx/app.h"
-#include "wx/settings.h"
+    #include "wx/settings.h"
-#include "wx/intl.h"
+    #include "wx/intl.h"
-#include "wx/log.h"
+    #include "wx/log.h"
 #endif
 
 #include "wx/msw/private.h"
 #include "wx/log.h"
 
 #if wxUSE_COMMON_DIALOGS
-#include <commdlg.h>
+    #include <commdlg.h>
 #endif
 
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+// default dialog pos and size
+
 #define wxDIALOG_DEFAULT_X 300
 #define wxDIALOG_DEFAULT_Y 300
 
-// Lists to keep track of windows, so we can disable/enable them
+#define wxDIALOG_DEFAULT_WIDTH 500
-// for modal dialogs
+#define wxDIALOG_DEFAULT_HEIGHT 500
-wxWindowList wxModalDialogs;
+
-wxWindowList wxModelessWindows;  // Frames and modeless dialogs
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+
+// all objects to be deleted during next idle processing - from window.cpp
 extern wxList WXDLLEXPORT wxPendingDelete;
 
+// all frames and modeless dialogs - not static, used in frame.cpp, mdi.cpp &c
+wxWindowList wxModelessWindows;
+
+// all modal dialogs currently shown
+static wxWindowList wxModalDialogs;
+
+// ----------------------------------------------------------------------------
+// wxWin macros
+// ----------------------------------------------------------------------------
+
 IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxPanel)
 
 BEGIN_EVENT_TABLE(wxDialog, wxPanel)
-    EVT_SIZE(wxDialog::OnSize)
     EVT_BUTTON(wxID_OK, wxDialog::OnOK)
     EVT_BUTTON(wxID_APPLY, wxDialog::OnApply)
     EVT_BUTTON(wxID_CANCEL, wxDialog::OnCancel)
+
     EVT_CHAR_HOOK(wxDialog::OnCharHook)
+
     EVT_SYS_COLOUR_CHANGED(wxDialog::OnSysColourChanged)
+
     EVT_CLOSE(wxDialog::OnCloseWindow)
 END_EVENT_TABLE()
 
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxDialog construction
+// ----------------------------------------------------------------------------
+
 wxDialog::wxDialog()
 {
     m_isShown = FALSE;
-  m_modalShowing = FALSE;
 
     SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
 }
@@ -73,10 +110,6 @@ bool wxDialog::Create(wxWindow *parent, wxWindowID id,
                       long style,
                       const wxString& name)
 {
-#if wxUSE_TOOLTIPS
-    m_hwndToolTip = 0;
-#endif
-
     SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
     SetName(name);
 
@@ -97,18 +130,19 @@ bool wxDialog::Create(wxWindow *parent, wxWindowID id,
     int width = size.x;
     int height = size.y;
 
-    if (x < 0) x = wxDIALOG_DEFAULT_X;
+    if (x < 0)
-    if (y < 0) y = wxDIALOG_DEFAULT_Y;
+        x = wxDIALOG_DEFAULT_X;
+    if (y < 0)
+        y = wxDIALOG_DEFAULT_Y;
 
     m_windowStyle = style;
 
     m_isShown = FALSE;
-    m_modalShowing = FALSE;
 
     if (width < 0)
-        width = 500;
+        width = wxDIALOG_DEFAULT_WIDTH;
     if (height < 0)
-        height = 500;
+        height = wxDIALOG_DEFAULT_HEIGHT;
 
     // All dialogs should really have this style
     m_windowStyle |= wxTAB_TRAVERSAL;
@@ -153,14 +187,17 @@ bool wxDialog::Create(wxWindow *parent, wxWindowID id,
 void wxDialog::SetModal(bool flag)
 {
     if ( flag )
-    m_windowStyle |= wxDIALOG_MODAL ;
+    {
-  else
+        m_windowStyle |= wxDIALOG_MODAL;
-    if ( m_windowStyle & wxDIALOG_MODAL )
-        m_windowStyle -= wxDIALOG_MODAL ;
 
         wxModelessWindows.DeleteObject(this);
-  if (!flag)
+    }
+    else
+    {
+        m_windowStyle &= ~wxDIALOG_MODAL;
+
         wxModelessWindows.Append(this);
+    }
 }
 
 wxDialog::~wxDialog()
@@ -171,8 +208,8 @@ wxDialog::~wxDialog()
 
     Show(FALSE);
 
-  // VZ: this is bogus and breaks focus handling - it won't be returned to the
+    // VZ: this is bogus and breaks focus handling - it won't be returned to
-  //     window which had it previosuly if we do this
+    //     the window which had it previosuly if we do this
 #if 0
     if (m_modalShowing)
     {
@@ -185,25 +222,29 @@ wxDialog::~wxDialog()
         if (GetParent() && GetParent()->GetHWND())
             ::BringWindowToTop((HWND) GetParent()->GetHWND());
     }
-#endif // 0
 
     m_modalShowing = FALSE;
+#endif // 0
 
-  if ( (GetWindowStyleFlag() & wxDIALOG_MODAL) != wxDIALOG_MODAL )
+    if ( !IsModal() )
         wxModelessWindows.DeleteObject(this);
 
     // If this is the last top-level window, exit.
-  if (wxTheApp && (wxTopLevelWindows.Number() == 0))
+    if ( wxTheApp && (wxTopLevelWindows.Number() == 0) )
     {
         wxTheApp->SetTopWindow(NULL);
 
-    if (wxTheApp->GetExitOnFrameDelete())
+        if ( wxTheApp->GetExitOnFrameDelete() )
         {
-       PostQuitMessage(0);
+            ::PostQuitMessage(0);
         }
     }
 }
 
+// ----------------------------------------------------------------------------
+// kbd handling
+// ----------------------------------------------------------------------------
+
 // By default, pressing escape cancels the dialog
 void wxDialog::OnCharHook(wxKeyEvent& event)
 {
@@ -227,21 +268,12 @@ void wxDialog::OnCharHook(wxKeyEvent& event)
   event.Skip();
 }
 
-void wxDialog::OnPaint(wxPaintEvent& event)
+// ----------------------------------------------------------------------------
-{
+// Windows dialog boxes can't be iconized
-  // No: if you call the default procedure, it makes
+// ----------------------------------------------------------------------------
-  // the following painting code not work.
-//  wxWindow::OnPaint(event);
-}
-
-void wxDialog::Fit()
-{
-  wxWindow::Fit();
-}
 
 void wxDialog::Iconize(bool WXUNUSED(iconize))
 {
-  // Windows dialog boxes can't be iconized
 }
 
 bool wxDialog::IsIconized() const
@@ -249,6 +281,10 @@ bool wxDialog::IsIconized() const
     return FALSE;
 }
 
+// ----------------------------------------------------------------------------
+// size/position handling
+// ----------------------------------------------------------------------------
+
 void wxDialog::DoSetClientSize(int width, int height)
 {
     HWND hWnd = (HWND) GetHWND();
@@ -271,26 +307,30 @@ void wxDialog::DoSetClientSize(int width, int height)
     GetEventHandler()->ProcessEvent(event);
 }
 
-void wxDialog::GetPosition(int *x, int *y) const
+void wxDialog::DoGetPosition(int *x, int *y) const
 {
-  HWND hWnd = (HWND) GetHWND();
     RECT rect;
-  GetWindowRect(hWnd, &rect);
+    GetWindowRect(GetHwnd(), &rect);
 
+    if ( x )
         *x = rect.left;
+    if ( y )
         *y = rect.top;
 }
 
-bool wxDialog::IsShown() const
+// ----------------------------------------------------------------------------
-{
+// showing the dialogs
-  return m_isShown;
+// ----------------------------------------------------------------------------
-}
 
 bool wxDialog::IsModal() const
 {
-    return wxModalDialogs.Find((wxDialog *)this) != 0; // const_cast
+    return (GetWindowStyleFlag() & wxDIALOG_MODAL) != 0;
 }
 
+// VZ: this is the old version unchanged (reindented only), it will be removed
+//     as soon as we're sure the new one works correctly
+#if 0
+
 bool wxDialog::Show(bool show)
 {
     m_isShown = show;
@@ -298,22 +338,7 @@ bool wxDialog::Show(bool show)
     if (show)
         InitDialog();
 
-  bool modal =  ((GetWindowStyleFlag() & wxDIALOG_MODAL) == wxDIALOG_MODAL) ;
+    bool modal = IsModal();
-
-#if WXGARBAGE_COLLECTION_ON /* MATTHEW: GC */
-  if (!modal) {
-    if (show) {
-      if (!wxModelessWindows.Find(this))
-        wxModelessWindows.Append(this);
-    } else
-      wxModelessWindows.DeleteObject(this);
-  }
-  if (show) {
-    if (!wxTopLevelWindows.Find(this))
-      wxTopLevelWindows.Append(this);
-  } else
-    wxTopLevelWindows.DeleteObject(this);
-#endif
 
     if (modal)
     {
@@ -484,49 +509,103 @@ bool wxDialog::Show(bool show)
                 ShowWindow((HWND) GetHWND(), SW_HIDE);
         }
     }
+
     return TRUE;
 }
 
-void wxDialog::SetTitle(const wxString& title)
+#else // 1
+
+bool wxDialog::IsModalShowing() const
 {
-  SetWindowText((HWND) GetHWND(), title.c_str());
+    return wxModalDialogs.Find((wxDialog *)this) != NULL; // const_cast
 }
 
-wxString wxDialog::GetTitle() const
+void wxDialog::DoShowModal()
 {
-  GetWindowText((HWND) GetHWND(), wxBuffer, 1000);
+    wxCHECK_RET( !IsModalShowing(), _T("DoShowModal() called twice") );
-  return wxString(wxBuffer);
+
-}
+    wxModalDialogs.Append(this);
 
-void wxDialog::Centre(int direction)
-{
-  int x_offset,y_offset ;
-  int display_width, display_height;
-  int  width, height, x, y;
     wxWindow *parent = GetParent();
-  if ((direction & wxCENTER_FRAME) && parent)
+
+    // remember where the focus was
+    wxWindow *winFocus = FindFocus();
+    if ( !winFocus )
     {
-      parent->GetPosition(&x_offset,&y_offset) ;
+        winFocus = parent;
-      parent->GetSize(&display_width,&display_height) ;
     }
-  else
+    if ( !winFocus )
     {
-    wxDisplaySize(&display_width, &display_height);
+        winFocus = wxTheApp->GetTopWindow();
-    x_offset = 0 ;
-    y_offset = 0 ;
     }
 
-  GetSize(&width, &height);
+    // disable the parent window first
-  GetPosition(&x, &y);
+    HWND hwndParent = parent ? GetHwndOf(parent) : (HWND)NULL;
+    if ( hwndParent )
+    {
+        ::EnableWindow(hwndParent, FALSE);
+    }
 
-  if (direction & wxHORIZONTAL)
+    // enter the modal loop
-    x = (int)((display_width - width)/2);
+    while ( IsModalShowing() )
-  if (direction & wxVERTICAL)
+    {
-    y = (int)((display_height - height)/2);
+#if wxUSE_THREADS
+        wxMutexGuiLeaveOrEnter();
+#endif // wxUSE_THREADS
 
-  SetSize(x+x_offset, y+y_offset, width, height);
+        while ( !wxTheApp->Pending() && wxTheApp->ProcessIdle() )
+            ;
+
+        // a message came or no more idle processing to do
+        wxTheApp->DoMessage();
+    }
+
+    // reenable the parent window if any
+    if ( hwndParent )
+    {
+        ::EnableWindow(hwndParent, TRUE);
+    }
+
+    // and restore focus
+    if ( winFocus )
+    {
+        winFocus->SetFocus();
+    }
 }
 
+bool wxDialog::Show(bool show)
+{
+    if ( !wxDialogBase::Show(show) )
+    {
+        // nothing to do
+        return FALSE;
+    }
+
+    if ( show )
+    {
+        // usually will result in TransferDataToWindow() being called
+        InitDialog();
+    }
+
+    if ( IsModal() )
+    {
+        if ( show )
+        {
+            DoShowModal();
+        }
+        else // end of modal dialog
+        {
+            // this will cause IsModalShowing() return FALSE and our local
+            // message loop will terminate
+            wxModalDialogs.DeleteObject(this);
+        }
+    }
+
+    return TRUE;
+}
+
+#endif // 0/1
+
 // Replacement for Show(TRUE) for modal dialogs - returns return code
 int wxDialog::ShowModal()
 {
@@ -535,73 +614,56 @@ int wxDialog::ShowModal()
     return GetReturnCode();
 }
 
+// NB: this function (surprizingly) may be called for both modal and modeless
+//     dialogs and should work for both of them
 void wxDialog::EndModal(int retCode)
 {
     SetReturnCode(retCode);
     Show(FALSE);
 }
 
-// Define for each class of dialog and control
+// ----------------------------------------------------------------------------
-WXHBRUSH wxDialog::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
+// wxWin event handlers
-      WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
+// ----------------------------------------------------------------------------
-{
-#if wxUSE_CTL3D
-  HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
-  return (WXHBRUSH) hbrush;
-#else
-  return 0;
-#endif
-}
 
 // Standard buttons
 void wxDialog::OnOK(wxCommandEvent& event)
 {
   if ( Validate() && TransferDataFromWindow() )
   {
-        if ( IsModal() )
       EndModal(wxID_OK);
-        else
-        {
-            SetReturnCode(wxID_OK);
-            this->Show(FALSE);
-        }
   }
 }
 
 void wxDialog::OnApply(wxCommandEvent& event)
 {
-  if (Validate())
+    if ( Validate() )
         TransferDataFromWindow();
+
     // TODO probably need to disable the Apply button until things change again
 }
 
 void wxDialog::OnCancel(wxCommandEvent& event)
 {
-    if ( IsModal() )
     EndModal(wxID_CANCEL);
-    else
-    {
-        SetReturnCode(wxID_CANCEL);
-        this->Show(FALSE);
-    }
 }
 
 void wxDialog::OnCloseWindow(wxCloseEvent& event)
 {
-    // We'll send a Cancel message by default,
+    // We'll send a Cancel message by default, which may close the dialog.
-    // which may close the dialog.
     // Check for looping if the Cancel event handler calls Close().
 
     // Note that if a cancel button and handler aren't present in the dialog,
     // nothing will happen when you close the dialog via the window manager, or
-    // via Close().
+    // via Close(). We wouldn't want to destroy the dialog by default, since
-    // We wouldn't want to destroy the dialog by default, since the dialog may have been
+    // the dialog may have been created on the stack. However, this does mean
-    // created on the stack.
+    // that calling dialog->Close() won't delete the dialog unless the handler
-    // However, this does mean that calling dialog->Close() won't delete the dialog
+    // for wxID_CANCEL does so. So use Destroy() if you want to be sure to
-    // unless the handler for wxID_CANCEL does so. So use Destroy() if you want to be
+    // destroy the dialog. The default OnCancel (above) simply ends a modal
-    // sure to destroy the dialog.
+    // dialog, and hides a modeless dialog.
-    // The default OnCancel (above) simply ends a modal dialog, and hides a modeless dialog.
 
+    // VZ: this is horrible and MT-unsafe. Can't we reuse some of these global
+    //     lists here? don't dare to change it now, but should be done later!
     static wxList closing;
 
     if ( closing.Member(this) )
@@ -619,20 +681,12 @@ void wxDialog::OnCloseWindow(wxCloseEvent& event)
 // Destroy the window (delayed, if a managed window)
 bool wxDialog::Destroy()
 {
-  if (!wxPendingDelete.Member(this))
+    wxCHECK_MSG( !wxPendingDelete.Member(this), FALSE,
-    wxPendingDelete.Append(this);
+                 _T("wxDialog destroyed twice") );
-  return TRUE;
-}
 
-void wxDialog::OnSize(wxSizeEvent& WXUNUSED(event))
+    wxPendingDelete.Append(this);
-{
+
-  // if we're using constraints - do use them
+    return TRUE;
-  #if wxUSE_CONSTRAINTS
-    if ( GetAutoLayout() )
-    {
-      Layout();
-    }
-  #endif
 }
 
 void wxDialog::OnSysColourChanged(wxSysColourChangedEvent& event)
@@ -668,3 +722,19 @@ long wxDialog::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 
     return rc;
 }
+
+#if wxUSE_CTL3D
+
+// Define for each class of dialog and control
+WXHBRUSH wxDialog::OnCtlColor(WXHDC WXUNUSED(pDC),
+                              WXHWND WXUNUSED(pWnd),
+                              WXUINT WXUNUSED(nCtlColor),
+                              WXUINT message,
+                              WXWPARAM wParam,
+                              WXLPARAM lParam)
+{
+    return (WXHBRUSH)Ctl3dCtlColorEx(message, wParam, lParam);
+}
+
+#endif // wxUSE_CTL3D
+