#include "wx/vector.h"
#include "wx/scopedarray.h"
#include "wx/scopedptr.h"
+#include "wx/scopeguard.h"
#include "wx/except.h"
#if wxUSE_STD_IOSTREAM
#include "wx/wfstream.h"
#endif
-typedef wxVector<wxDocTemplate *> wxDocTemplates;
-
// ----------------------------------------------------------------------------
// wxWidgets macros
// ----------------------------------------------------------------------------
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)
void wxDocManager::OnPrint(wxCommandEvent& WXUNUSED(event))
{
- wxView *view = GetActiveView();
+ wxView *view = GetAnyUsableView();
if (!view)
return;
void wxDocManager::OnPreview(wxCommandEvent& WXUNUSED(event))
{
wxBusyCursor busy;
- wxView *view = GetActiveView();
+ wxView *view = GetAnyUsableView();
if (!view)
return;
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();
}
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();
bool wxDocManager::TryBefore(wxEvent& event)
{
- wxView * const view = GetActiveView();
+ wxView * const view = GetAnyUsableView();
return view && view->ProcessEventLocally(event);
}
{
// 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);
} // anonymous namespace
-void wxDocManager::ActivateDocument(wxDocument *doc)
+void wxDocument::Activate()
{
- wxView * const view = doc->GetFirstView();
+ wxView * const view = GetFirstView();
if ( !view )
return;
view->Activate(true);
if ( wxWindow *win = view->GetFrame() )
- win->SetFocus();
+ 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 )
{
// 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
- ActivateDocument(doc);
- return doc;
- }
+ // file already open, just activate it and return
+ doc->Activate();
+ return doc;
}
}
-
// no, we need to create a new document
// 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
- ActivateDocument(docNew);
+ 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 )
wxDocument *wxDocManager::GetCurrentDocument() const
{
- wxView * const view = GetActiveView();
+ wxView * const view = GetAnyUsableView();
return view ? view->GetDocument() : NULL;
}
// 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 )
// wxDocParentFrameAnyBase
// ----------------------------------------------------------------------------
+bool wxDocParentFrameAnyBase::TryProcessEvent(wxEvent& event)
+{
+ if ( !m_docManager )
+ return false;
+
+ // 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() )
+ {
+ 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);
+}
+
+// ----------------------------------------------------------------------------
+// Printing support
+// ----------------------------------------------------------------------------
+
#if wxUSE_PRINTING_ARCHITECTURE
namespace
projects / wxWidgets.git / blobdiff