AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@5737 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin 2000-01-30 01:31:09 +00:00
parent 55c56a6d80
commit b6c588e1a6
3 changed files with 484 additions and 429 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
include/wx/msw/dialog.h
View File

@ -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);
bool IsShown() const;
void Iconize(bool iconize);
// For now, same as Show(TRUE) but returns return code
virtual int ShowModal();
// 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;
void Fit();
// implementation only from now on
// -------------------------------
virtual bool IsTopLevel() const { return TRUE; }
void SetTitle(const wxString& title);
wxString GetTitle() const ;
void OnSize(wxSizeEvent& event);
// event handlers
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);
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
#endif // wxUSE_CTL3D
protected:
bool m_modalShowing;
WXHWND m_hwndOldFocus; // the window which had focus before we were shown
// override more base class virtuals
virtual void DoSetClientSize(int width, int height);
virtual void DoGetPosition(int *x, int *y) const;
private:
#if wxUSE_TOOLTIPS
WXHWND m_hwndToolTip;
#endif // tooltips
// show modal dialog and enter modal loop
void DoShowModal();
private:
DECLARE_EVENT_TABLE()

11
src/msw/app.cpp
View File

@ -916,12 +916,10 @@ int wxApp::MainLoop()
wxMutexGuiLeaveOrEnter();
#endif // wxUSE_THREADS
while ( !::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) &&
ProcessIdle() )
{
}
while ( !Pending() && 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()

336
src/msw/dialog.cpp
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dialog.cpp
// Name: src/msw/dialog.cpp
// Purpose: wxDialog class
// Author: Julian Smart
// Modified by:
@ -9,6 +9,14 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "dialog.h"
#endif
@ -37,31 +45,60 @@
#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
// for modal dialogs
wxWindowList wxModalDialogs;
wxWindowList wxModelessWindows; // Frames and modeless dialogs
#define wxDIALOG_DEFAULT_WIDTH 500
#define wxDIALOG_DEFAULT_HEIGHT 500
// ----------------------------------------------------------------------------
// 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 (y < 0) y = wxDIALOG_DEFAULT_Y;
if (x < 0)
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,15 +187,18 @@ bool wxDialog::Create(wxWindow *parent, wxWindowID id,
void wxDialog::SetModal(bool flag)
{
if ( flag )
{
m_windowStyle |= wxDIALOG_MODAL;
else
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
// window which had it previosuly if we do this
// VZ: this is bogus and breaks focus handling - it won't be returned to
// the window which had it previosuly if we do this
#if 0
if (m_modalShowing)
{
@ -185,11 +222,11 @@ 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.
@ -199,11 +236,15 @@ wxDialog::~wxDialog()
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)
{
// No: if you call the default procedure, it makes
// the following painting code not work.
// wxWindow::OnPaint(event);
}
void wxDialog::Fit()
{
wxWindow::Fit();
}
// ----------------------------------------------------------------------------
// Windows dialog boxes can't be iconized
// ----------------------------------------------------------------------------
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
{
return m_isShown;
}
// ----------------------------------------------------------------------------
// showing the dialogs
// ----------------------------------------------------------------------------
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) ;
#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
bool modal = IsModal();
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);
return wxString(wxBuffer);
}
wxCHECK_RET( !IsModalShowing(), _T("DoShowModal() called twice") );
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) ;
parent->GetSize(&display_width,&display_height) ;
winFocus = parent;
}
else
if ( !winFocus )
{
wxDisplaySize(&display_width, &display_height);
x_offset = 0 ;
y_offset = 0 ;
winFocus = wxTheApp->GetTopWindow();
}
GetSize(&width, &height);
GetPosition(&x, &y);
if (direction & wxHORIZONTAL)
x = (int)((display_width - width)/2);
if (direction & wxVERTICAL)
y = (int)((display_height - height)/2);
SetSize(x+x_offset, y+y_offset, width, height);
// disable the parent window first
HWND hwndParent = parent ? GetHwndOf(parent) : (HWND)NULL;
if ( hwndParent )
{
::EnableWindow(hwndParent, FALSE);
}
// enter the modal loop
while ( IsModalShowing() )
{
#if wxUSE_THREADS
wxMutexGuiLeaveOrEnter();
#endif // wxUSE_THREADS
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,36 +614,24 @@ 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,
WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
{
#if wxUSE_CTL3D
HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
return (WXHBRUSH) hbrush;
#else
return 0;
#endif
}
// ----------------------------------------------------------------------------
// wxWin event handlers
// ----------------------------------------------------------------------------
// Standard buttons
void wxDialog::OnOK(wxCommandEvent& event)
{
if ( Validate() && TransferDataFromWindow() )
{
if ( IsModal() )
EndModal(wxID_OK);
else
{
SetReturnCode(wxID_OK);
this->Show(FALSE);
}
}
}
@ -572,36 +639,31 @@ void wxDialog::OnApply(wxCommandEvent& event)
{
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,
// which may close the dialog.
// We'll send a Cancel message by default, 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().
// We wouldn't want to destroy the dialog by default, since the dialog may have been
// created on the stack.
// However, this does mean that calling dialog->Close() won't delete the dialog
// unless the handler for wxID_CANCEL does so. So use Destroy() if you want to be
// sure to destroy the dialog.
// The default OnCancel (above) simply ends a modal dialog, and hides a modeless dialog.
// via Close(). We wouldn't want to destroy the dialog by default, since
// the dialog may have been created on the stack. However, this does mean
// that calling dialog->Close() won't delete the dialog unless the handler
// for wxID_CANCEL does so. So use Destroy() if you want to be sure to
// destroy the 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))
wxPendingDelete.Append(this);
return TRUE;
}
wxCHECK_MSG( !wxPendingDelete.Member(this), FALSE,
_T("wxDialog destroyed twice") );
void wxDialog::OnSize(wxSizeEvent& WXUNUSED(event))
{
// if we're using constraints - do use them
#if wxUSE_CONSTRAINTS
if ( GetAutoLayout() )
{
Layout();
}
#endif
wxPendingDelete.Append(this);
return TRUE;
}
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