]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/docview.cpp
Improve horizontal scrolling in wxRibbonControl.
[wxWidgets.git] / src / common / docview.cpp
index 335265e02c972d9fddc9d4a94ce9bd09bf594f0b..fc1c256337baa61a4766a83b34d5bf24dc56f954 100644 (file)
@@ -60,6 +60,7 @@
 #include "wx/vector.h"
 #include "wx/scopedarray.h"
 #include "wx/scopedptr.h"
+#include "wx/scopeguard.h"
 #include "wx/except.h"
 
 #if wxUSE_STD_IOSTREAM
@@ -75,8 +76,6 @@
     #include "wx/wfstream.h"
 #endif
 
-typedef wxVector<wxDocTemplate *> wxDocTemplates;
-
 // ----------------------------------------------------------------------------
 // wxWidgets macros
 // ----------------------------------------------------------------------------
@@ -122,8 +121,12 @@ wxString FindExtension(const wxString& path)
 wxDocument::wxDocument(wxDocument *parent)
 {
     m_documentModified = false;
-    m_documentParent = parent;
     m_documentTemplate = NULL;
+
+    m_documentParent = parent;
+    if ( parent )
+        parent->m_childDocuments.push_back(this);
+
     m_commandProcessor = NULL;
     m_savedYet = false;
 }
@@ -135,13 +138,14 @@ bool wxDocument::DeleteContents()
 
 wxDocument::~wxDocument()
 {
-    DeleteContents();
-
     delete m_commandProcessor;
 
     if (GetDocumentManager())
         GetDocumentManager()->RemoveDocument(this);
 
+    if ( m_documentParent )
+        m_documentParent->m_childDocuments.remove(this);
+
     // Not safe to do here, since it'll invoke virtual view functions
     // expecting to see valid derived objects: and by the time we get here,
     // we've called destructors higher up.
@@ -153,6 +157,40 @@ bool wxDocument::Close()
     if ( !OnSaveModified() )
         return false;
 
+    // When the parent document closes, its children must be closed as well as
+    // they can't exist without the parent.
+
+    // As usual, first check if all children can be closed.
+    DocsList::const_iterator it = m_childDocuments.begin();
+    for ( DocsList::const_iterator end = m_childDocuments.end(); it != end; ++it )
+    {
+        if ( !(*it)->OnSaveModified() )
+        {
+            // Leave the parent document opened if a child can't close.
+            return false;
+        }
+    }
+
+    // Now that they all did, do close them: as m_childDocuments is modified as
+    // we iterate over it, don't use the usual for-style iteration here.
+    while ( !m_childDocuments.empty() )
+    {
+        wxDocument * const childDoc = m_childDocuments.front();
+
+        // This will call OnSaveModified() once again but it shouldn't do
+        // anything as the document was just saved or marked as not needing to
+        // be saved by the call to OnSaveModified() that returned true above.
+        if ( !childDoc->Close() )
+        {
+            wxFAIL_MSG( "Closing the child document unexpectedly failed "
+                        "after its OnSaveModified() returned true" );
+        }
+
+        // Delete the child document by deleting all its views.
+        childDoc->DeleteAllViews();
+    }
+
+
     return OnCloseDocument();
 }
 
@@ -233,6 +271,12 @@ void wxDocument::Modify(bool mod)
 
 wxDocManager *wxDocument::GetDocumentManager() const
 {
+    // For child documents we use the same document manager as the parent, even
+    // though we don't have our own template (as children are not opened/saved
+    // directly).
+    if ( m_documentParent )
+        return m_documentParent->GetDocumentManager();
+
     return m_documentTemplate ? m_documentTemplate->GetDocumentManager() : NULL;
 }
 
@@ -352,6 +396,9 @@ bool wxDocument::OnSaveDocument(const wxString& file)
     if ( !DoSaveDocument(file) )
         return false;
 
+    if ( m_commandProcessor )
+        m_commandProcessor->MarkAsSaved();
+
     Modify(false);
     SetFilename(file);
     SetDocumentSaved(true);
@@ -427,7 +474,7 @@ bool wxDocument::Revert()
 #if WXWIN_COMPATIBILITY_2_8
 bool wxDocument::GetPrintableName(wxString& buf) const
 {
-    // this function can not only be overridden by the user code but also
+    // this function cannot only be overridden by the user code but also
     // called by it so we need to ensure that we return the same thing as
     // GetUserReadableName() but we can't call it because this would result in
     // an infinite recursion, hence we use the helper DoGetUserReadableName()
@@ -811,17 +858,19 @@ wxDocument *wxDocTemplate::CreateDocument(const wxString& path, long flags)
 bool
 wxDocTemplate::InitDocument(wxDocument* doc, const wxString& path, long flags)
 {
+    wxScopeGuard g = wxMakeObjGuard(*doc, &wxDocument::DeleteAllViews);
+
     doc->SetFilename(path);
     doc->SetDocumentTemplate(this);
     GetDocumentManager()->AddDocument(doc);
     doc->SetCommandProcessor(doc->OnCreateCommandProcessor());
 
-    if (doc->OnCreate(path, flags))
-        return true;
+    if ( !doc->OnCreate(path, flags) )
+        return false;
 
-    if (GetDocumentManager()->GetDocuments().Member(doc))
-        doc->DeleteAllViews();
-    return false;
+    g.Dismiss(); // no need to call DeleteAllViews() anymore
+
+    return true;
 }
 
 wxView *wxDocTemplate::CreateView(wxDocument *doc, long flags)
@@ -886,23 +935,31 @@ BEGIN_EVENT_TABLE(wxDocManager, wxEvtHandler)
     EVT_MENU(wxID_UNDO, wxDocManager::OnUndo)
     EVT_MENU(wxID_REDO, wxDocManager::OnRedo)
 
+    // We don't know in advance how many items can there be in the MRU files
+    // list so set up OnMRUFile() as a handler for all menu events and do the
+    // check for the id of the menu item clicked inside it.
+    EVT_MENU(wxID_ANY, wxDocManager::OnMRUFile)
+
     EVT_UPDATE_UI(wxID_OPEN, wxDocManager::OnUpdateFileOpen)
     EVT_UPDATE_UI(wxID_CLOSE, wxDocManager::OnUpdateDisableIfNoDoc)
     EVT_UPDATE_UI(wxID_CLOSE_ALL, wxDocManager::OnUpdateDisableIfNoDoc)
     EVT_UPDATE_UI(wxID_REVERT, wxDocManager::OnUpdateFileRevert)
     EVT_UPDATE_UI(wxID_NEW, wxDocManager::OnUpdateFileNew)
     EVT_UPDATE_UI(wxID_SAVE, wxDocManager::OnUpdateFileSave)
-    EVT_UPDATE_UI(wxID_SAVEAS, wxDocManager::OnUpdateDisableIfNoDoc)
+    EVT_UPDATE_UI(wxID_SAVEAS, wxDocManager::OnUpdateFileSaveAs)
     EVT_UPDATE_UI(wxID_UNDO, wxDocManager::OnUpdateUndo)
     EVT_UPDATE_UI(wxID_REDO, wxDocManager::OnUpdateRedo)
 
 #if wxUSE_PRINTING_ARCHITECTURE
     EVT_MENU(wxID_PRINT, wxDocManager::OnPrint)
     EVT_MENU(wxID_PREVIEW, wxDocManager::OnPreview)
+    EVT_MENU(wxID_PRINT_SETUP, wxDocManager::OnPageSetup)
 
     EVT_UPDATE_UI(wxID_PRINT, wxDocManager::OnUpdateDisableIfNoDoc)
     EVT_UPDATE_UI(wxID_PREVIEW, wxDocManager::OnUpdateDisableIfNoDoc)
-#endif
+    // NB: we keep "Print setup" menu item always enabled as it can be used
+    //     even without an active document
+#endif // wxUSE_PRINTING_ARCHITECTURE
 END_EVENT_TABLE()
 
 wxDocManager* wxDocManager::sm_docManager = NULL;
@@ -1030,14 +1087,8 @@ wxFileHistory *wxDocManager::OnCreateFileHistory()
 void wxDocManager::OnFileClose(wxCommandEvent& WXUNUSED(event))
 {
     wxDocument *doc = GetCurrentDocument();
-    if (!doc)
-        return;
-    if (doc->Close())
-    {
-        doc->DeleteAllViews();
-        if (m_docs.Member(doc))
-            delete doc;
-    }
+    if (doc)
+        CloseDocument(doc);
 }
 
 void wxDocManager::OnFileCloseAll(wxCommandEvent& WXUNUSED(event))
@@ -1082,48 +1133,107 @@ void wxDocManager::OnFileSaveAs(wxCommandEvent& WXUNUSED(event))
     doc->SaveAs();
 }
 
-void wxDocManager::OnPrint(wxCommandEvent& WXUNUSED(event))
+void wxDocManager::OnMRUFile(wxCommandEvent& event)
+{
+    // Check if the id is in the range assigned to MRU list entries.
+    const int id = event.GetId();
+    if ( id >= wxID_FILE1 &&
+            id < wxID_FILE1 + static_cast<int>(m_fileHistory->GetCount()) )
+    {
+        DoOpenMRUFile(id - wxID_FILE1);
+    }
+    else
+    {
+        event.Skip();
+    }
+}
+
+void wxDocManager::DoOpenMRUFile(unsigned n)
 {
+    wxString filename(GetHistoryFile(n));
+    if ( filename.empty() )
+        return;
+
+    wxString errMsg; // must contain exactly one "%s" if non-empty
+    if ( wxFile::Exists(filename) )
+    {
+        // Try to open it but don't give an error if it failed: this could be
+        // normal, e.g. because the user cancelled opening it, and we don't
+        // have any useful information to put in the error message anyhow, so
+        // we assume that in case of an error the appropriate message had been
+        // already logged.
+        (void)CreateDocument(filename, wxDOC_SILENT);
+    }
+    else // file doesn't exist
+    {
+        OnMRUFileNotExist(n, filename);
+    }
+}
+
+void wxDocManager::OnMRUFileNotExist(unsigned n, const wxString& filename)
+{
+    // remove the file which we can't open from the MRU list
+    RemoveFileFromHistory(n);
+
+    // and tell the user about it
+    wxLogError(_("The file '%s' doesn't exist and couldn't be opened.\n"
+                 "It has been removed from the most recently used files list."),
+               filename);
+}
+
 #if wxUSE_PRINTING_ARCHITECTURE
-    wxView *view = GetActiveView();
+
+void wxDocManager::OnPrint(wxCommandEvent& WXUNUSED(event))
+{
+    wxView *view = GetAnyUsableView();
     if (!view)
         return;
 
     wxPrintout *printout = view->OnCreatePrintout();
     if (printout)
     {
-        wxPrinter printer;
+        wxPrintDialogData printDialogData(m_pageSetupDialogData.GetPrintData());
+        wxPrinter printer(&printDialogData);
         printer.Print(view->GetFrame(), printout, true);
 
         delete printout;
     }
-#endif // wxUSE_PRINTING_ARCHITECTURE
 }
 
-#if wxUSE_PRINTING_ARCHITECTURE
+void wxDocManager::OnPageSetup(wxCommandEvent& WXUNUSED(event))
+{
+    wxPageSetupDialog dlg(wxTheApp->GetTopWindow(), &m_pageSetupDialogData);
+    if ( dlg.ShowModal() == wxID_OK )
+    {
+        m_pageSetupDialogData = dlg.GetPageSetupData();
+    }
+}
+
 wxPreviewFrame* wxDocManager::CreatePreviewFrame(wxPrintPreviewBase* preview,
                                                  wxWindow *parent,
                                                  const wxString& title)
 {
     return new wxPreviewFrame(preview, parent, title);
 }
-#endif // wxUSE_PRINTING_ARCHITECTURE
 
 void wxDocManager::OnPreview(wxCommandEvent& WXUNUSED(event))
 {
-#if wxUSE_PRINTING_ARCHITECTURE
     wxBusyCursor busy;
-    wxView *view = GetActiveView();
+    wxView *view = GetAnyUsableView();
     if (!view)
         return;
 
     wxPrintout *printout = view->OnCreatePrintout();
     if (printout)
     {
+        wxPrintDialogData printDialogData(m_pageSetupDialogData.GetPrintData());
+
         // Pass two printout objects: for preview, and possible printing.
         wxPrintPreviewBase *
-            preview = new wxPrintPreview(printout, view->OnCreatePrintout());
-        if ( !preview->Ok() )
+            preview = new wxPrintPreview(printout,
+                                         view->OnCreatePrintout(),
+                                         &printDialogData);
+        if ( !preview->IsOk() )
         {
             delete preview;
             wxLogError(_("Print preview creation failed."));
@@ -1139,8 +1249,8 @@ void wxDocManager::OnPreview(wxCommandEvent& WXUNUSED(event))
         frame->Initialize();
         frame->Show(true);
     }
-#endif // wxUSE_PRINTING_ARCHITECTURE
 }
+#endif // wxUSE_PRINTING_ARCHITECTURE
 
 void wxDocManager::OnUndo(wxCommandEvent& event)
 {
@@ -1196,7 +1306,13 @@ void wxDocManager::OnUpdateFileNew(wxUpdateUIEvent& event)
 void wxDocManager::OnUpdateFileSave(wxUpdateUIEvent& event)
 {
     wxDocument * const doc = GetCurrentDocument();
-    event.Enable( doc && !doc->AlreadySaved() );
+    event.Enable( doc && !doc->IsChildDocument() && !doc->AlreadySaved() );
+}
+
+void wxDocManager::OnUpdateFileSaveAs(wxUpdateUIEvent& event)
+{
+    wxDocument * const doc = GetCurrentDocument();
+    event.Enable( doc && !doc->IsChildDocument() );
 }
 
 void wxDocManager::OnUpdateUndo(wxUpdateUIEvent& event)
@@ -1204,10 +1320,14 @@ void wxDocManager::OnUpdateUndo(wxUpdateUIEvent& event)
     wxCommandProcessor * const cmdproc = GetCurrentCommandProcessor();
     if ( !cmdproc )
     {
-        event.Enable(false);
+        // If we don't have any document at all, the menu item should really be
+        // disabled.
+        if ( !GetCurrentDocument() )
+            event.Enable(false);
+        else // But if we do have it, it might handle wxID_UNDO on its own
+            event.Skip();
         return;
     }
-
     event.Enable(cmdproc->CanUndo());
     cmdproc->SetMenuStrings();
 }
@@ -1217,15 +1337,18 @@ void wxDocManager::OnUpdateRedo(wxUpdateUIEvent& event)
     wxCommandProcessor * const cmdproc = GetCurrentCommandProcessor();
     if ( !cmdproc )
     {
-        event.Enable(false);
+        // Use same logic as in OnUpdateUndo() above.
+        if ( !GetCurrentDocument() )
+            event.Enable(false);
+        else
+            event.Skip();
         return;
     }
-
     event.Enable(cmdproc->CanRedo());
     cmdproc->SetMenuStrings();
 }
 
-wxView *wxDocManager::GetActiveView() const
+wxView *wxDocManager::GetAnyUsableView() const
 {
     wxView *view = GetCurrentView();
 
@@ -1251,7 +1374,7 @@ wxView *wxDocManager::GetActiveView() const
 
 bool wxDocManager::TryBefore(wxEvent& event)
 {
-    wxView * const view = GetActiveView();
+    wxView * const view = GetAnyUsableView();
     return view && view->ProcessEventLocally(event);
 }
 
@@ -1259,11 +1382,11 @@ namespace
 {
 
 // helper function: return only the visible templates
-wxDocTemplates GetVisibleTemplates(const wxList& allTemplates)
+wxDocTemplateVector GetVisibleTemplates(const wxList& allTemplates)
 {
     // select only the visible templates
     const size_t totalNumTemplates = allTemplates.GetCount();
-    wxDocTemplates templates;
+    wxDocTemplateVector templates;
     if ( totalNumTemplates )
     {
         templates.reserve(totalNumTemplates);
@@ -1284,12 +1407,36 @@ wxDocTemplates GetVisibleTemplates(const wxList& allTemplates)
 
 } // anonymous namespace
 
+void wxDocument::Activate()
+{
+    wxView * const view = GetFirstView();
+    if ( !view )
+        return;
+
+    view->Activate(true);
+    if ( wxWindow *win = view->GetFrame() )
+        win->Raise();
+}
+
+wxDocument* wxDocManager::FindDocumentByPath(const wxString& path) const
+{
+    const wxFileName fileName(path);
+    for ( wxList::const_iterator i = m_docs.begin(); i != m_docs.end(); ++i )
+    {
+        wxDocument * const doc = wxStaticCast(*i, wxDocument);
+
+        if ( fileName == wxFileName(doc->GetFilename()) )
+            return doc;
+    }
+    return NULL;
+}
+
 wxDocument *wxDocManager::CreateDocument(const wxString& pathOrig, long flags)
 {
     // this ought to be const but SelectDocumentType/Path() are not
     // const-correct and can't be changed as, being virtual, this risks
     // breaking user code overriding them
-    wxDocTemplates templates(GetVisibleTemplates(m_templates));
+    wxDocTemplateVector templates(GetVisibleTemplates(m_templates));
     const size_t numTemplates = templates.size();
     if ( !numTemplates )
     {
@@ -1330,26 +1477,15 @@ wxDocument *wxDocManager::CreateDocument(const wxString& pathOrig, long flags)
     // check whether the document with this path is already opened
     if ( !path.empty() )
     {
-        const wxFileName fn(path);
-        for ( wxList::const_iterator i = m_docs.begin(); i != m_docs.end(); ++i )
+        wxDocument * const doc = FindDocumentByPath(path);
+        if (doc)
         {
-            wxDocument * const doc = (wxDocument*)*i;
-
-            if ( fn == doc->GetFilename() )
-            {
-                // file already open, just activate it and return
-                if ( doc->GetFirstView() )
-                {
-                    ActivateView(doc->GetFirstView());
-                    if ( doc->GetDocumentWindow() )
-                        doc->GetDocumentWindow()->SetFocus();
-                    return doc;
-                }
-            }
+            // file already open, just activate it and return
+            doc->Activate();
+            return doc;
         }
     }
 
-
     // no, we need to create a new document
 
 
@@ -1391,12 +1527,17 @@ wxDocument *wxDocManager::CreateDocument(const wxString& pathOrig, long flags)
     if ( !(flags & wxDOC_NEW) && temp->FileMatchesTemplate(path) )
         AddFileToHistory(path);
 
+    // at least under Mac (where views are top level windows) it seems to be
+    // necessary to manually activate the new document to bring it to the
+    // forefront -- and it shouldn't hurt doing this under the other platforms
+    docNew->Activate();
+
     return docNew;
 }
 
 wxView *wxDocManager::CreateView(wxDocument *doc, long flags)
 {
-    wxDocTemplates templates(GetVisibleTemplates(m_templates));
+    wxDocTemplateVector templates(GetVisibleTemplates(m_templates));
     const size_t numTemplates = templates.size();
 
     if ( numTemplates == 0 )
@@ -1429,7 +1570,7 @@ bool wxDocManager::FlushDoc(wxDocument *WXUNUSED(doc))
 
 wxDocument *wxDocManager::GetCurrentDocument() const
 {
-    wxView * const view = GetActiveView();
+    wxView * const view = GetAnyUsableView();
     return view ? view->GetDocument() : NULL;
 }
 
@@ -1825,6 +1966,20 @@ void wxDocManager::DisassociateTemplate(wxDocTemplate *temp)
     m_templates.DeleteObject(temp);
 }
 
+wxDocTemplate* wxDocManager::FindTemplate(const wxClassInfo* classinfo)
+{
+   for ( wxList::compatibility_iterator node = m_templates.GetFirst();
+         node;
+         node = node->GetNext() )
+   {
+      wxDocTemplate* t = wxStaticCast(node->GetData(), wxDocTemplate);
+      if ( t->GetDocClassInfo() == classinfo )
+         return t;
+   }
+
+   return NULL;
+}
+
 // Add and remove a document from the manager's list
 void wxDocManager::AddDocument(wxDocument *doc)
 {
@@ -1859,6 +2014,26 @@ void wxDocManager::ActivateView(wxView *view, bool activate)
 // wxDocChildFrameAnyBase
 // ----------------------------------------------------------------------------
 
+bool wxDocChildFrameAnyBase::TryProcessEvent(wxEvent& event)
+{
+    if ( !m_childView )
+    {
+        // We must be being destroyed, don't forward events anywhere as
+        // m_childDocument could be invalid by now.
+        return false;
+    }
+
+    // Forward the event to the document manager which will, in turn, forward
+    // it to its active view which must be our m_childView.
+    //
+    // Notice that we do things in this roundabout way to guarantee the correct
+    // event handlers call order: first the document, then the new and then the
+    // document manager itself. And if we forwarded the event directly to the
+    // view, then the document manager would do it once again when we forwarded
+    // it to it.
+    return m_childDocument->GetDocumentManager()->ProcessEventLocally(event);
+}
+
 bool wxDocChildFrameAnyBase::CloseView(wxCloseEvent& event)
 {
     if ( m_childView )
@@ -1879,8 +2054,7 @@ bool wxDocChildFrameAnyBase::CloseView(wxCloseEvent& event)
         // deleted directly not by us as indicated by its doc child frame
         // pointer still being set
         m_childView->SetDocChildFrame(NULL);
-        delete m_childView;
-        m_childView = NULL;
+        wxDELETE(m_childView);
     }
 
     m_childDocument = NULL;
@@ -1889,109 +2063,70 @@ bool wxDocChildFrameAnyBase::CloseView(wxCloseEvent& event)
 }
 
 // ----------------------------------------------------------------------------
-// Default parent frame
+// wxDocParentFrameAnyBase
 // ----------------------------------------------------------------------------
 
-BEGIN_EVENT_TABLE(wxDocParentFrame, wxFrame)
-    EVT_MENU(wxID_EXIT, wxDocParentFrame::OnExit)
-    EVT_MENU_RANGE(wxID_FILE1, wxID_FILE9, wxDocParentFrame::OnMRUFile)
-    EVT_CLOSE(wxDocParentFrame::OnCloseWindow)
-END_EVENT_TABLE()
-
-wxDocParentFrame::wxDocParentFrame()
+bool wxDocParentFrameAnyBase::TryProcessEvent(wxEvent& event)
 {
-    m_docManager = NULL;
-}
-
-wxDocParentFrame::wxDocParentFrame(wxDocManager *manager,
-                                   wxFrame *frame,
-                                   wxWindowID id,
-                                   const wxString& title,
-                                   const wxPoint& pos,
-                                   const wxSize& size,
-                                   long style,
-                                   const wxString& name)
-                : wxFrame(frame, id, title, pos, size, style, name)
-{
-    m_docManager = manager;
-}
-
-bool wxDocParentFrame::Create(wxDocManager *manager,
-                              wxFrame *frame,
-                              wxWindowID id,
-                              const wxString& title,
-                              const wxPoint& pos,
-                              const wxSize& size,
-                              long style,
-                              const wxString& name)
-{
-    m_docManager = manager;
-    return base_type::Create(frame, id, title, pos, size, style, name);
-}
-
-void wxDocParentFrame::OnExit(wxCommandEvent& WXUNUSED(event))
-{
-    Close();
-}
-
-void wxDocParentFrame::OnMRUFile(wxCommandEvent& event)
-{
-    int n = event.GetId() - wxID_FILE1;  // the index in MRU list
-    wxString filename(m_docManager->GetHistoryFile(n));
-    if ( filename.empty() )
-        return;
-
-    wxString errMsg; // must contain exactly one "%s" if non-empty
-    if ( wxFile::Exists(filename) )
-    {
-        // try to open it
-        if ( m_docManager->CreateDocument(filename, wxDOC_SILENT) )
-            return;
+    if ( !m_docManager )
+        return false;
 
-        errMsg = _("The file '%s' couldn't be opened.");
-    }
-    else // file doesn't exist
+    // If we have an active view, its associated child frame may have
+    // already forwarded the event to wxDocManager, check for this:
+    if ( wxView* const view = m_docManager->GetAnyUsableView() )
     {
-        errMsg = _("The file '%s' doesn't exist and couldn't be opened.");
+        wxWindow* win = view->GetFrame();
+        if ( win && win != m_frame )
+        {
+            // Notice that we intentionally don't use wxGetTopLevelParent()
+            // here because we want to check both for the case of a child
+            // "frame" (e.g. MDI child frame or notebook page) inside this TLW
+            // and a separate child TLW frame (as used in the SDI mode) here.
+            for ( win = win->GetParent(); win; win = win->GetParent() )
+            {
+                if ( win == m_frame )
+                    return false;
+            }
+        }
+        //else: This view is directly associated with the parent frame (which
+        //      can happen in the so called "single" mode in which only one
+        //      document can be opened and so is managed by the parent frame
+        //      itself), there can be no child frame in play so we must forward
+        //      the event to wxDocManager ourselves.
     }
 
+    // But forward the event to wxDocManager ourselves if there are no views at
+    // all or if we are the frame's view ourselves.
+    return m_docManager->ProcessEventLocally(event);
+}
 
-    wxASSERT_MSG( !errMsg.empty(), "should have an error message" );
-
-    // remove the file which we can't open from the MRU list
-    m_docManager->RemoveFileFromHistory(n);
+// ----------------------------------------------------------------------------
+// Printing support
+// ----------------------------------------------------------------------------
 
-    // and tell the user about it
-    wxLogError(errMsg + '\n' +
-               _("It has been removed from the most recently used files list."),
-               filename);
-}
+#if wxUSE_PRINTING_ARCHITECTURE
 
-// Extend event processing to search the view's event table
-bool wxDocParentFrame::TryBefore(wxEvent& event)
+namespace
 {
-    if ( m_docManager && m_docManager->ProcessEventLocally(event) )
-        return true;
 
-    return wxFrame::TryBefore(event);
-}
-
-// Define the behaviour for the frame closing
-// - must delete all frames except for the main one.
-void wxDocParentFrame::OnCloseWindow(wxCloseEvent& event)
+wxString GetAppropriateTitle(const wxView *view, const wxString& titleGiven)
 {
-    if (m_docManager->Clear(!event.CanVeto()))
+    wxString title(titleGiven);
+    if ( title.empty() )
     {
-        Destroy();
+        if ( view && view->GetDocument() )
+            title = view->GetDocument()->GetUserReadableName();
+        else
+            title = _("Printout");
     }
-    else
-        event.Veto();
+
+    return title;
 }
 
-#if wxUSE_PRINTING_ARCHITECTURE
+} // anonymous namespace
 
 wxDocPrintout::wxDocPrintout(wxView *view, const wxString& title)
-             : wxPrintout(title)
+             : wxPrintout(GetAppropriateTitle(view, title))
 {
     m_printoutView = view;
 }