1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/docview.cpp
3 // Purpose: Document/view classes
4 // Author: Julian Smart
5 // Modified by: Vadim Zeitlin
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #if wxUSE_DOC_VIEW_ARCHITECTURE
29 #include "wx/docview.h"
33 #include "wx/string.h"
37 #include "wx/dialog.h"
39 #include "wx/filedlg.h"
42 #include "wx/msgdlg.h"
44 #include "wx/choicdlg.h"
47 #if wxUSE_PRINTING_ARCHITECTURE
48 #include "wx/prntbase.h"
49 #include "wx/printdlg.h"
52 #include "wx/confbase.h"
53 #include "wx/filename.h"
56 #include "wx/cmdproc.h"
57 #include "wx/tokenzr.h"
58 #include "wx/filename.h"
59 #include "wx/stdpaths.h"
60 #include "wx/vector.h"
61 #include "wx/scopedarray.h"
62 #include "wx/scopedptr.h"
63 #include "wx/except.h"
65 #if wxUSE_STD_IOSTREAM
66 #include "wx/ioswrap.h"
67 #include "wx/beforestd.h"
73 #include "wx/afterstd.h"
75 #include "wx/wfstream.h"
78 typedef wxVector
<wxDocTemplate
*> wxDocTemplates
;
80 // ----------------------------------------------------------------------------
82 // ----------------------------------------------------------------------------
84 IMPLEMENT_ABSTRACT_CLASS(wxDocument
, wxEvtHandler
)
85 IMPLEMENT_ABSTRACT_CLASS(wxView
, wxEvtHandler
)
86 IMPLEMENT_ABSTRACT_CLASS(wxDocTemplate
, wxObject
)
87 IMPLEMENT_DYNAMIC_CLASS(wxDocManager
, wxEvtHandler
)
88 IMPLEMENT_CLASS(wxDocChildFrame
, wxFrame
)
89 IMPLEMENT_CLASS(wxDocParentFrame
, wxFrame
)
91 #if wxUSE_PRINTING_ARCHITECTURE
92 IMPLEMENT_DYNAMIC_CLASS(wxDocPrintout
, wxPrintout
)
95 // ============================================================================
97 // ============================================================================
99 // ----------------------------------------------------------------------------
101 // ----------------------------------------------------------------------------
106 wxString
FindExtension(const wxString
& path
)
109 wxFileName::SplitPath(path
, NULL
, NULL
, &ext
);
111 // VZ: extensions are considered not case sensitive - is this really a good
113 return ext
.MakeLower();
116 } // anonymous namespace
118 // ----------------------------------------------------------------------------
119 // Definition of wxDocument
120 // ----------------------------------------------------------------------------
122 wxDocument::wxDocument(wxDocument
*parent
)
124 m_documentModified
= false;
125 m_documentParent
= parent
;
126 m_documentTemplate
= NULL
;
127 m_commandProcessor
= NULL
;
131 bool wxDocument::DeleteContents()
136 wxDocument::~wxDocument()
138 delete m_commandProcessor
;
140 if (GetDocumentManager())
141 GetDocumentManager()->RemoveDocument(this);
143 // Not safe to do here, since it'll invoke virtual view functions
144 // expecting to see valid derived objects: and by the time we get here,
145 // we've called destructors higher up.
149 bool wxDocument::Close()
151 if ( !OnSaveModified() )
154 return OnCloseDocument();
157 bool wxDocument::OnCloseDocument()
159 // Tell all views that we're about to close
166 // Note that this implicitly deletes the document when the last view is
168 bool wxDocument::DeleteAllViews()
170 wxDocManager
* manager
= GetDocumentManager();
172 // first check if all views agree to be closed
173 const wxList::iterator end
= m_documentViews
.end();
174 for ( wxList::iterator i
= m_documentViews
.begin(); i
!= end
; ++i
)
176 wxView
*view
= (wxView
*)*i
;
177 if ( !view
->Close() )
181 // all views agreed to close, now do close them
182 if ( m_documentViews
.empty() )
184 // normally the document would be implicitly deleted when the last view
185 // is, but if don't have any views, do it here instead
186 if ( manager
&& manager
->GetDocuments().Member(this) )
191 // as we delete elements we iterate over, don't use the usual "from
192 // begin to end" loop
195 wxView
*view
= (wxView
*)*m_documentViews
.begin();
197 bool isLastOne
= m_documentViews
.size() == 1;
199 // this always deletes the node implicitly and if this is the last
200 // view also deletes this object itself (also implicitly, great),
201 // so we can't test for m_documentViews.empty() after calling this!
212 wxView
*wxDocument::GetFirstView() const
214 if ( m_documentViews
.empty() )
217 return static_cast<wxView
*>(m_documentViews
.GetFirst()->GetData());
220 void wxDocument::Modify(bool mod
)
222 if (mod
!= m_documentModified
)
224 m_documentModified
= mod
;
226 // Allow views to append asterix to the title
227 wxView
* view
= GetFirstView();
228 if (view
) view
->OnChangeFilename();
232 wxDocManager
*wxDocument::GetDocumentManager() const
234 return m_documentTemplate
? m_documentTemplate
->GetDocumentManager() : NULL
;
237 bool wxDocument::OnNewDocument()
239 // notice that there is no need to neither reset nor even check the
240 // modified flag here as the document itself is a new object (this is only
241 // called from CreateDocument()) and so it shouldn't be saved anyhow even
242 // if it is modified -- this could happen if the user code creates
243 // documents pre-filled with some user-entered (and which hence must not be
246 SetDocumentSaved(false);
248 const wxString name
= GetDocumentManager()->MakeNewDocumentName();
250 SetFilename(name
, true);
255 bool wxDocument::Save()
257 if ( AlreadySaved() )
260 if ( m_documentFile
.empty() || !m_savedYet
)
263 return OnSaveDocument(m_documentFile
);
266 bool wxDocument::SaveAs()
268 wxDocTemplate
*docTemplate
= GetDocumentTemplate();
272 #ifdef wxHAS_MULTIPLE_FILEDLG_FILTERS
273 wxString filter
= docTemplate
->GetDescription() + wxT(" (") +
274 docTemplate
->GetFileFilter() + wxT(")|") +
275 docTemplate
->GetFileFilter();
277 // Now see if there are some other template with identical view and document
278 // classes, whose filters may also be used.
279 if (docTemplate
->GetViewClassInfo() && docTemplate
->GetDocClassInfo())
281 wxList::compatibility_iterator
282 node
= docTemplate
->GetDocumentManager()->GetTemplates().GetFirst();
285 wxDocTemplate
*t
= (wxDocTemplate
*) node
->GetData();
287 if (t
->IsVisible() && t
!= docTemplate
&&
288 t
->GetViewClassInfo() == docTemplate
->GetViewClassInfo() &&
289 t
->GetDocClassInfo() == docTemplate
->GetDocClassInfo())
291 // add a '|' to separate this filter from the previous one
292 if ( !filter
.empty() )
295 filter
<< t
->GetDescription()
296 << wxT(" (") << t
->GetFileFilter() << wxT(") |")
297 << t
->GetFileFilter();
300 node
= node
->GetNext();
304 wxString filter
= docTemplate
->GetFileFilter() ;
307 wxString defaultDir
= docTemplate
->GetDirectory();
308 if ( defaultDir
.empty() )
310 defaultDir
= wxPathOnly(GetFilename());
311 if ( defaultDir
.empty() )
312 defaultDir
= GetDocumentManager()->GetLastDirectory();
315 wxString fileName
= wxFileSelector(_("Save As"),
317 wxFileNameFromPath(GetFilename()),
318 docTemplate
->GetDefaultExtension(),
320 wxFD_SAVE
| wxFD_OVERWRITE_PROMPT
,
321 GetDocumentWindow());
323 if (fileName
.empty())
324 return false; // cancelled by user
326 // Files that were not saved correctly are not added to the FileHistory.
327 if (!OnSaveDocument(fileName
))
330 SetTitle(wxFileNameFromPath(fileName
));
331 SetFilename(fileName
, true); // will call OnChangeFileName automatically
333 // A file that doesn't use the default extension of its document template
334 // cannot be opened via the FileHistory, so we do not add it.
335 if (docTemplate
->FileMatchesTemplate(fileName
))
337 GetDocumentManager()->AddFileToHistory(fileName
);
339 //else: the user will probably not be able to open the file again, so we
340 // could warn about the wrong file-extension here
345 bool wxDocument::OnSaveDocument(const wxString
& file
)
350 if ( !DoSaveDocument(file
) )
355 SetDocumentSaved(true);
356 #if defined( __WXOSX_MAC__ ) && wxOSX_USE_CARBON
357 wxFileName
fn(file
) ;
358 fn
.MacSetDefaultTypeAndCreator() ;
363 bool wxDocument::OnOpenDocument(const wxString
& file
)
365 // notice that there is no need to check the modified flag here for the
366 // reasons explained in OnNewDocument()
368 if ( !DoOpenDocument(file
) )
371 SetFilename(file
, true);
373 // stretching the logic a little this does make sense because the document
374 // had been saved into the file we just loaded it from, it just could have
375 // happened during a previous program execution, it's just that the name of
376 // this method is a bit unfortunate, it should probably have been called
377 // HasAssociatedFileName()
378 SetDocumentSaved(true);
385 #if wxUSE_STD_IOSTREAM
386 wxSTD istream
& wxDocument::LoadObject(wxSTD istream
& stream
)
388 wxInputStream
& wxDocument::LoadObject(wxInputStream
& stream
)
394 #if wxUSE_STD_IOSTREAM
395 wxSTD ostream
& wxDocument::SaveObject(wxSTD ostream
& stream
)
397 wxOutputStream
& wxDocument::SaveObject(wxOutputStream
& stream
)
403 bool wxDocument::Revert()
407 _("Discard changes and reload the last saved version?"),
408 wxTheApp
->GetAppDisplayName(),
409 wxYES_NO
| wxCANCEL
| wxICON_QUESTION
,
414 if ( !DoOpenDocument(GetFilename()) )
424 // Get title, or filename if no title, else unnamed
425 #if WXWIN_COMPATIBILITY_2_8
426 bool wxDocument::GetPrintableName(wxString
& buf
) const
428 // this function can not only be overridden by the user code but also
429 // called by it so we need to ensure that we return the same thing as
430 // GetUserReadableName() but we can't call it because this would result in
431 // an infinite recursion, hence we use the helper DoGetUserReadableName()
432 buf
= DoGetUserReadableName();
436 #endif // WXWIN_COMPATIBILITY_2_8
438 wxString
wxDocument::GetUserReadableName() const
440 #if WXWIN_COMPATIBILITY_2_8
441 // we need to call the old virtual function to ensure that the overridden
442 // version of it is still called
444 if ( GetPrintableName(name
) )
446 #endif // WXWIN_COMPATIBILITY_2_8
448 return DoGetUserReadableName();
451 wxString
wxDocument::DoGetUserReadableName() const
453 if ( !m_documentTitle
.empty() )
454 return m_documentTitle
;
456 if ( !m_documentFile
.empty() )
457 return wxFileNameFromPath(m_documentFile
);
462 wxWindow
*wxDocument::GetDocumentWindow() const
464 wxView
* const view
= GetFirstView();
466 return view
? view
->GetFrame() : wxTheApp
->GetTopWindow();
469 wxCommandProcessor
*wxDocument::OnCreateCommandProcessor()
471 return new wxCommandProcessor
;
474 // true if safe to close
475 bool wxDocument::OnSaveModified()
479 switch ( wxMessageBox
483 _("Do you want to save changes to %s?"),
484 GetUserReadableName()
486 wxTheApp
->GetAppDisplayName(),
487 wxYES_NO
| wxCANCEL
| wxICON_QUESTION
| wxCENTRE
505 bool wxDocument::Draw(wxDC
& WXUNUSED(context
))
510 bool wxDocument::AddView(wxView
*view
)
512 if ( !m_documentViews
.Member(view
) )
514 m_documentViews
.Append(view
);
520 bool wxDocument::RemoveView(wxView
*view
)
522 (void)m_documentViews
.DeleteObject(view
);
527 bool wxDocument::OnCreate(const wxString
& WXUNUSED(path
), long flags
)
529 return GetDocumentTemplate()->CreateView(this, flags
) != NULL
;
532 // Called after a view is added or removed.
533 // The default implementation deletes the document if
534 // there are no more views.
535 void wxDocument::OnChangedViewList()
537 if ( m_documentViews
.empty() && OnSaveModified() )
541 void wxDocument::UpdateAllViews(wxView
*sender
, wxObject
*hint
)
543 wxList::compatibility_iterator node
= m_documentViews
.GetFirst();
546 wxView
*view
= (wxView
*)node
->GetData();
548 view
->OnUpdate(sender
, hint
);
549 node
= node
->GetNext();
553 void wxDocument::NotifyClosing()
555 wxList::compatibility_iterator node
= m_documentViews
.GetFirst();
558 wxView
*view
= (wxView
*)node
->GetData();
559 view
->OnClosingDocument();
560 node
= node
->GetNext();
564 void wxDocument::SetFilename(const wxString
& filename
, bool notifyViews
)
566 m_documentFile
= filename
;
567 OnChangeFilename(notifyViews
);
570 void wxDocument::OnChangeFilename(bool notifyViews
)
574 // Notify the views that the filename has changed
575 wxList::compatibility_iterator node
= m_documentViews
.GetFirst();
578 wxView
*view
= (wxView
*)node
->GetData();
579 view
->OnChangeFilename();
580 node
= node
->GetNext();
585 bool wxDocument::DoSaveDocument(const wxString
& file
)
587 #if wxUSE_STD_IOSTREAM
588 wxSTD ofstream
store(file
.mb_str(), wxSTD
ios::binary
);
591 wxFileOutputStream
store(file
);
592 if ( store
.GetLastError() != wxSTREAM_NO_ERROR
)
595 wxLogError(_("File \"%s\" could not be opened for writing."), file
);
599 if (!SaveObject(store
))
601 wxLogError(_("Failed to save document to the file \"%s\"."), file
);
608 bool wxDocument::DoOpenDocument(const wxString
& file
)
610 #if wxUSE_STD_IOSTREAM
611 wxSTD ifstream
store(file
.mb_str(), wxSTD
ios::binary
);
614 wxFileInputStream
store(file
);
615 if (store
.GetLastError() != wxSTREAM_NO_ERROR
|| !store
.IsOk())
618 wxLogError(_("File \"%s\" could not be opened for reading."), file
);
622 #if wxUSE_STD_IOSTREAM
626 int res
= LoadObject(store
).GetLastError();
627 if ( res
!= wxSTREAM_NO_ERROR
&& res
!= wxSTREAM_EOF
)
630 wxLogError(_("Failed to read document from the file \"%s\"."), file
);
638 // ----------------------------------------------------------------------------
640 // ----------------------------------------------------------------------------
644 m_viewDocument
= NULL
;
648 m_docChildFrame
= NULL
;
653 if (m_viewDocument
&& GetDocumentManager())
654 GetDocumentManager()->ActivateView(this, false);
656 // reset our frame view first, before removing it from the document as
657 // SetView(NULL) is a simple call while RemoveView() may result in user
658 // code being executed and this user code can, for example, show a message
659 // box which would result in an activation event for m_docChildFrame and so
660 // could reactivate the view being destroyed -- unless we reset it first
661 if ( m_docChildFrame
&& m_docChildFrame
->GetView() == this )
663 // prevent it from doing anything with us
664 m_docChildFrame
->SetView(NULL
);
666 // it doesn't make sense to leave the frame alive if its associated
667 // view doesn't exist any more so unconditionally close it as well
669 // notice that we only get here if m_docChildFrame is non-NULL in the
670 // first place and it will be always NULL if we're deleted because our
671 // frame was closed, so this only catches the case of directly deleting
672 // the view, as it happens if its creation fails in wxDocTemplate::
673 // CreateView() for example
674 m_docChildFrame
->GetWindow()->Destroy();
677 if ( m_viewDocument
)
678 m_viewDocument
->RemoveView(this);
681 void wxView::SetDocChildFrame(wxDocChildFrameAnyBase
*docChildFrame
)
683 SetFrame(docChildFrame
? docChildFrame
->GetWindow() : NULL
);
684 m_docChildFrame
= docChildFrame
;
687 bool wxView::TryBefore(wxEvent
& event
)
689 wxDocument
* const doc
= GetDocument();
690 return doc
&& doc
->ProcessEventLocally(event
);
693 void wxView::OnActivateView(bool WXUNUSED(activate
),
694 wxView
*WXUNUSED(activeView
),
695 wxView
*WXUNUSED(deactiveView
))
699 void wxView::OnPrint(wxDC
*dc
, wxObject
*WXUNUSED(info
))
704 void wxView::OnUpdate(wxView
*WXUNUSED(sender
), wxObject
*WXUNUSED(hint
))
708 void wxView::OnChangeFilename()
710 // GetFrame can return wxWindow rather than wxTopLevelWindow due to
711 // generic MDI implementation so use SetLabel rather than SetTitle.
712 // It should cause SetTitle() for top level windows.
713 wxWindow
*win
= GetFrame();
716 wxDocument
*doc
= GetDocument();
719 wxString label
= doc
->GetUserReadableName();
720 if (doc
->IsModified())
724 win
->SetLabel(label
);
727 void wxView::SetDocument(wxDocument
*doc
)
729 m_viewDocument
= doc
;
734 bool wxView::Close(bool deleteWindow
)
736 return OnClose(deleteWindow
);
739 void wxView::Activate(bool activate
)
741 if (GetDocument() && GetDocumentManager())
743 OnActivateView(activate
, this, GetDocumentManager()->GetCurrentView());
744 GetDocumentManager()->ActivateView(this, activate
);
748 bool wxView::OnClose(bool WXUNUSED(deleteWindow
))
750 return GetDocument() ? GetDocument()->Close() : true;
753 #if wxUSE_PRINTING_ARCHITECTURE
754 wxPrintout
*wxView::OnCreatePrintout()
756 return new wxDocPrintout(this);
758 #endif // wxUSE_PRINTING_ARCHITECTURE
760 // ----------------------------------------------------------------------------
762 // ----------------------------------------------------------------------------
764 wxDocTemplate::wxDocTemplate(wxDocManager
*manager
,
765 const wxString
& descr
,
766 const wxString
& filter
,
769 const wxString
& docTypeName
,
770 const wxString
& viewTypeName
,
771 wxClassInfo
*docClassInfo
,
772 wxClassInfo
*viewClassInfo
,
775 m_documentManager
= manager
;
776 m_description
= descr
;
779 m_fileFilter
= filter
;
781 m_docTypeName
= docTypeName
;
782 m_viewTypeName
= viewTypeName
;
783 m_documentManager
->AssociateTemplate(this);
785 m_docClassInfo
= docClassInfo
;
786 m_viewClassInfo
= viewClassInfo
;
789 wxDocTemplate::~wxDocTemplate()
791 m_documentManager
->DisassociateTemplate(this);
794 // Tries to dynamically construct an object of the right class.
795 wxDocument
*wxDocTemplate::CreateDocument(const wxString
& path
, long flags
)
797 // InitDocument() is supposed to delete the document object if its
798 // initialization fails so don't use wxScopedPtr<> here: this is fragile
799 // but unavoidable because the default implementation uses CreateView()
800 // which may -- or not -- create a wxView and if it does create it and its
801 // initialization fails then the view destructor will delete the document
802 // (via RemoveView()) and as we can't distinguish between the two cases we
803 // just have to assume that it always deletes it in case of failure
804 wxDocument
* const doc
= DoCreateDocument();
806 return doc
&& InitDocument(doc
, path
, flags
) ? doc
: NULL
;
810 wxDocTemplate::InitDocument(wxDocument
* doc
, const wxString
& path
, long flags
)
812 doc
->SetFilename(path
);
813 doc
->SetDocumentTemplate(this);
814 GetDocumentManager()->AddDocument(doc
);
815 doc
->SetCommandProcessor(doc
->OnCreateCommandProcessor());
817 if (doc
->OnCreate(path
, flags
))
820 if (GetDocumentManager()->GetDocuments().Member(doc
))
821 doc
->DeleteAllViews();
825 wxView
*wxDocTemplate::CreateView(wxDocument
*doc
, long flags
)
827 wxScopedPtr
<wxView
> view(DoCreateView());
831 view
->SetDocument(doc
);
832 if ( !view
->OnCreate(doc
, flags
) )
835 return view
.release();
838 // The default (very primitive) format detection: check is the extension is
839 // that of the template
840 bool wxDocTemplate::FileMatchesTemplate(const wxString
& path
)
842 wxStringTokenizer
parser (GetFileFilter(), wxT(";"));
843 wxString anything
= wxT ("*");
844 while (parser
.HasMoreTokens())
846 wxString filter
= parser
.GetNextToken();
847 wxString filterExt
= FindExtension (filter
);
848 if ( filter
.IsSameAs (anything
) ||
849 filterExt
.IsSameAs (anything
) ||
850 filterExt
.IsSameAs (FindExtension (path
)) )
853 return GetDefaultExtension().IsSameAs(FindExtension(path
));
856 wxDocument
*wxDocTemplate::DoCreateDocument()
861 return static_cast<wxDocument
*>(m_docClassInfo
->CreateObject());
864 wxView
*wxDocTemplate::DoCreateView()
866 if (!m_viewClassInfo
)
869 return static_cast<wxView
*>(m_viewClassInfo
->CreateObject());
872 // ----------------------------------------------------------------------------
874 // ----------------------------------------------------------------------------
876 BEGIN_EVENT_TABLE(wxDocManager
, wxEvtHandler
)
877 EVT_MENU(wxID_OPEN
, wxDocManager::OnFileOpen
)
878 EVT_MENU(wxID_CLOSE
, wxDocManager::OnFileClose
)
879 EVT_MENU(wxID_CLOSE_ALL
, wxDocManager::OnFileCloseAll
)
880 EVT_MENU(wxID_REVERT
, wxDocManager::OnFileRevert
)
881 EVT_MENU(wxID_NEW
, wxDocManager::OnFileNew
)
882 EVT_MENU(wxID_SAVE
, wxDocManager::OnFileSave
)
883 EVT_MENU(wxID_SAVEAS
, wxDocManager::OnFileSaveAs
)
884 EVT_MENU(wxID_UNDO
, wxDocManager::OnUndo
)
885 EVT_MENU(wxID_REDO
, wxDocManager::OnRedo
)
887 // We don't know in advance how many items can there be in the MRU files
888 // list so set up OnMRUFile() as a handler for all menu events and do the
889 // check for the id of the menu item clicked inside it.
890 EVT_MENU(wxID_ANY
, wxDocManager::OnMRUFile
)
892 EVT_UPDATE_UI(wxID_OPEN
, wxDocManager::OnUpdateFileOpen
)
893 EVT_UPDATE_UI(wxID_CLOSE
, wxDocManager::OnUpdateDisableIfNoDoc
)
894 EVT_UPDATE_UI(wxID_CLOSE_ALL
, wxDocManager::OnUpdateDisableIfNoDoc
)
895 EVT_UPDATE_UI(wxID_REVERT
, wxDocManager::OnUpdateFileRevert
)
896 EVT_UPDATE_UI(wxID_NEW
, wxDocManager::OnUpdateFileNew
)
897 EVT_UPDATE_UI(wxID_SAVE
, wxDocManager::OnUpdateFileSave
)
898 EVT_UPDATE_UI(wxID_SAVEAS
, wxDocManager::OnUpdateDisableIfNoDoc
)
899 EVT_UPDATE_UI(wxID_UNDO
, wxDocManager::OnUpdateUndo
)
900 EVT_UPDATE_UI(wxID_REDO
, wxDocManager::OnUpdateRedo
)
902 #if wxUSE_PRINTING_ARCHITECTURE
903 EVT_MENU(wxID_PRINT
, wxDocManager::OnPrint
)
904 EVT_MENU(wxID_PREVIEW
, wxDocManager::OnPreview
)
905 EVT_MENU(wxID_PRINT_SETUP
, wxDocManager::OnPageSetup
)
907 EVT_UPDATE_UI(wxID_PRINT
, wxDocManager::OnUpdateDisableIfNoDoc
)
908 EVT_UPDATE_UI(wxID_PREVIEW
, wxDocManager::OnUpdateDisableIfNoDoc
)
909 // NB: we keep "Print setup" menu item always enabled as it can be used
910 // even without an active document
911 #endif // wxUSE_PRINTING_ARCHITECTURE
914 wxDocManager
* wxDocManager::sm_docManager
= NULL
;
916 wxDocManager::wxDocManager(long WXUNUSED(flags
), bool initialize
)
918 sm_docManager
= this;
920 m_defaultDocumentNameCounter
= 1;
921 m_currentView
= NULL
;
922 m_maxDocsOpen
= INT_MAX
;
923 m_fileHistory
= NULL
;
928 wxDocManager::~wxDocManager()
931 delete m_fileHistory
;
932 sm_docManager
= NULL
;
935 // closes the specified document
936 bool wxDocManager::CloseDocument(wxDocument
* doc
, bool force
)
938 if ( !doc
->Close() && !force
)
941 // Implicitly deletes the document when
942 // the last view is deleted
943 doc
->DeleteAllViews();
945 // Check we're really deleted
946 if (m_docs
.Member(doc
))
952 bool wxDocManager::CloseDocuments(bool force
)
954 wxList::compatibility_iterator node
= m_docs
.GetFirst();
957 wxDocument
*doc
= (wxDocument
*)node
->GetData();
958 wxList::compatibility_iterator next
= node
->GetNext();
960 if (!CloseDocument(doc
, force
))
963 // This assumes that documents are not connected in
964 // any way, i.e. deleting one document does NOT
971 bool wxDocManager::Clear(bool force
)
973 if (!CloseDocuments(force
))
976 m_currentView
= NULL
;
978 wxList::compatibility_iterator node
= m_templates
.GetFirst();
981 wxDocTemplate
*templ
= (wxDocTemplate
*) node
->GetData();
982 wxList::compatibility_iterator next
= node
->GetNext();
989 bool wxDocManager::Initialize()
991 m_fileHistory
= OnCreateFileHistory();
995 wxString
wxDocManager::GetLastDirectory() const
997 // if we haven't determined the last used directory yet, do it now
998 if ( m_lastDirectory
.empty() )
1000 // we're going to modify m_lastDirectory in this const method, so do it
1001 // via non-const self pointer instead of const this one
1002 wxDocManager
* const self
= const_cast<wxDocManager
*>(this);
1004 // first try to reuse the directory of the most recently opened file:
1005 // this ensures that if the user opens a file, closes the program and
1006 // runs it again the "Open file" dialog will open in the directory of
1007 // the last file he used
1008 if ( m_fileHistory
&& m_fileHistory
->GetCount() )
1010 const wxString lastOpened
= m_fileHistory
->GetHistoryFile(0);
1011 const wxFileName
fn(lastOpened
);
1012 if ( fn
.DirExists() )
1014 self
->m_lastDirectory
= fn
.GetPath();
1016 //else: should we try the next one?
1018 //else: no history yet
1020 // if we don't have any files in the history (yet?), use the
1021 // system-dependent default location for the document files
1022 if ( m_lastDirectory
.empty() )
1024 self
->m_lastDirectory
= wxStandardPaths::Get().GetAppDocumentsDir();
1028 return m_lastDirectory
;
1031 wxFileHistory
*wxDocManager::OnCreateFileHistory()
1033 return new wxFileHistory
;
1036 void wxDocManager::OnFileClose(wxCommandEvent
& WXUNUSED(event
))
1038 wxDocument
*doc
= GetCurrentDocument();
1043 void wxDocManager::OnFileCloseAll(wxCommandEvent
& WXUNUSED(event
))
1045 CloseDocuments(false);
1048 void wxDocManager::OnFileNew(wxCommandEvent
& WXUNUSED(event
))
1050 CreateNewDocument();
1053 void wxDocManager::OnFileOpen(wxCommandEvent
& WXUNUSED(event
))
1055 if ( !CreateDocument("") )
1057 OnOpenFileFailure();
1061 void wxDocManager::OnFileRevert(wxCommandEvent
& WXUNUSED(event
))
1063 wxDocument
*doc
= GetCurrentDocument();
1069 void wxDocManager::OnFileSave(wxCommandEvent
& WXUNUSED(event
))
1071 wxDocument
*doc
= GetCurrentDocument();
1077 void wxDocManager::OnFileSaveAs(wxCommandEvent
& WXUNUSED(event
))
1079 wxDocument
*doc
= GetCurrentDocument();
1085 void wxDocManager::OnMRUFile(wxCommandEvent
& event
)
1087 // Check if the id is in the range assigned to MRU list entries.
1088 const int id
= event
.GetId();
1089 if ( id
>= wxID_FILE1
&&
1090 id
< wxID_FILE1
+ m_fileHistory
->GetBaseId() )
1092 DoOpenMRUFile(id
- wxID_FILE1
);
1100 void wxDocManager::DoOpenMRUFile(unsigned n
)
1102 wxString
filename(GetHistoryFile(n
));
1103 if ( filename
.empty() )
1106 wxString errMsg
; // must contain exactly one "%s" if non-empty
1107 if ( wxFile::Exists(filename
) )
1110 if ( CreateDocument(filename
, wxDOC_SILENT
) )
1113 errMsg
= _("The file '%s' couldn't be opened.");
1115 else // file doesn't exist
1117 errMsg
= _("The file '%s' doesn't exist and couldn't be opened.");
1121 wxASSERT_MSG( !errMsg
.empty(), "should have an error message" );
1123 // remove the file which we can't open from the MRU list
1124 RemoveFileFromHistory(n
);
1126 // and tell the user about it
1127 wxLogError(errMsg
+ '\n' +
1128 _("It has been removed from the most recently used files list."),
1132 #if wxUSE_PRINTING_ARCHITECTURE
1134 void wxDocManager::OnPrint(wxCommandEvent
& WXUNUSED(event
))
1136 wxView
*view
= GetActiveView();
1140 wxPrintout
*printout
= view
->OnCreatePrintout();
1143 wxPrintDialogData
printDialogData(m_pageSetupDialogData
.GetPrintData());
1144 wxPrinter
printer(&printDialogData
);
1145 printer
.Print(view
->GetFrame(), printout
, true);
1151 void wxDocManager::OnPageSetup(wxCommandEvent
& WXUNUSED(event
))
1153 wxPageSetupDialog
dlg(wxTheApp
->GetTopWindow(), &m_pageSetupDialogData
);
1154 if ( dlg
.ShowModal() == wxID_OK
)
1156 m_pageSetupDialogData
= dlg
.GetPageSetupData();
1160 wxPreviewFrame
* wxDocManager::CreatePreviewFrame(wxPrintPreviewBase
* preview
,
1162 const wxString
& title
)
1164 return new wxPreviewFrame(preview
, parent
, title
);
1167 void wxDocManager::OnPreview(wxCommandEvent
& WXUNUSED(event
))
1170 wxView
*view
= GetActiveView();
1174 wxPrintout
*printout
= view
->OnCreatePrintout();
1177 wxPrintDialogData
printDialogData(m_pageSetupDialogData
.GetPrintData());
1179 // Pass two printout objects: for preview, and possible printing.
1180 wxPrintPreviewBase
*
1181 preview
= new wxPrintPreview(printout
,
1182 view
->OnCreatePrintout(),
1184 if ( !preview
->Ok() )
1187 wxLogError(_("Print preview creation failed."));
1191 wxPreviewFrame
* frame
= CreatePreviewFrame(preview
,
1192 wxTheApp
->GetTopWindow(),
1193 _("Print Preview"));
1194 wxCHECK_RET( frame
, "should create a print preview frame" );
1196 frame
->Centre(wxBOTH
);
1197 frame
->Initialize();
1201 #endif // wxUSE_PRINTING_ARCHITECTURE
1203 void wxDocManager::OnUndo(wxCommandEvent
& event
)
1205 wxCommandProcessor
* const cmdproc
= GetCurrentCommandProcessor();
1215 void wxDocManager::OnRedo(wxCommandEvent
& event
)
1217 wxCommandProcessor
* const cmdproc
= GetCurrentCommandProcessor();
1227 // Handlers for UI update commands
1229 void wxDocManager::OnUpdateFileOpen(wxUpdateUIEvent
& event
)
1231 // CreateDocument() (which is called from OnFileOpen) may succeed
1232 // only when there is at least a template:
1233 event
.Enable( GetTemplates().GetCount()>0 );
1236 void wxDocManager::OnUpdateDisableIfNoDoc(wxUpdateUIEvent
& event
)
1238 event
.Enable( GetCurrentDocument() != NULL
);
1241 void wxDocManager::OnUpdateFileRevert(wxUpdateUIEvent
& event
)
1243 wxDocument
* doc
= GetCurrentDocument();
1244 event
.Enable(doc
&& doc
->IsModified() && doc
->GetDocumentSaved());
1247 void wxDocManager::OnUpdateFileNew(wxUpdateUIEvent
& event
)
1249 // CreateDocument() (which is called from OnFileNew) may succeed
1250 // only when there is at least a template:
1251 event
.Enable( GetTemplates().GetCount()>0 );
1254 void wxDocManager::OnUpdateFileSave(wxUpdateUIEvent
& event
)
1256 wxDocument
* const doc
= GetCurrentDocument();
1257 event
.Enable( doc
&& !doc
->AlreadySaved() );
1260 void wxDocManager::OnUpdateUndo(wxUpdateUIEvent
& event
)
1262 wxCommandProcessor
* const cmdproc
= GetCurrentCommandProcessor();
1265 event
.Enable(false);
1269 event
.Enable(cmdproc
->CanUndo());
1270 cmdproc
->SetMenuStrings();
1273 void wxDocManager::OnUpdateRedo(wxUpdateUIEvent
& event
)
1275 wxCommandProcessor
* const cmdproc
= GetCurrentCommandProcessor();
1278 event
.Enable(false);
1282 event
.Enable(cmdproc
->CanRedo());
1283 cmdproc
->SetMenuStrings();
1286 wxView
*wxDocManager::GetActiveView() const
1288 wxView
*view
= GetCurrentView();
1290 if ( !view
&& !m_docs
.empty() )
1292 // if we have exactly one document, consider its view to be the current
1295 // VZ: I'm not exactly sure why is this needed but this is how this
1296 // code used to behave before the bug #9518 was fixed and it seems
1297 // safer to preserve the old logic
1298 wxList::compatibility_iterator node
= m_docs
.GetFirst();
1299 if ( !node
->GetNext() )
1301 wxDocument
*doc
= static_cast<wxDocument
*>(node
->GetData());
1302 view
= doc
->GetFirstView();
1304 //else: we have more than one document
1310 bool wxDocManager::TryBefore(wxEvent
& event
)
1312 wxView
* const view
= GetActiveView();
1313 return view
&& view
->ProcessEventLocally(event
);
1319 // helper function: return only the visible templates
1320 wxDocTemplates
GetVisibleTemplates(const wxList
& allTemplates
)
1322 // select only the visible templates
1323 const size_t totalNumTemplates
= allTemplates
.GetCount();
1324 wxDocTemplates templates
;
1325 if ( totalNumTemplates
)
1327 templates
.reserve(totalNumTemplates
);
1329 for ( wxList::const_iterator i
= allTemplates
.begin(),
1330 end
= allTemplates
.end();
1334 wxDocTemplate
* const temp
= (wxDocTemplate
*)*i
;
1335 if ( temp
->IsVisible() )
1336 templates
.push_back(temp
);
1343 } // anonymous namespace
1345 void wxDocManager::ActivateDocument(wxDocument
*doc
)
1347 wxView
* const view
= doc
->GetFirstView();
1351 view
->Activate(true);
1352 if ( wxWindow
*win
= view
->GetFrame() )
1356 wxDocument
*wxDocManager::CreateDocument(const wxString
& pathOrig
, long flags
)
1358 // this ought to be const but SelectDocumentType/Path() are not
1359 // const-correct and can't be changed as, being virtual, this risks
1360 // breaking user code overriding them
1361 wxDocTemplates
templates(GetVisibleTemplates(m_templates
));
1362 const size_t numTemplates
= templates
.size();
1363 if ( !numTemplates
)
1365 // no templates can be used, can't create document
1370 // normally user should select the template to use but wxDOC_SILENT flag we
1371 // choose one ourselves
1372 wxString path
= pathOrig
; // may be modified below
1373 wxDocTemplate
*temp
;
1374 if ( flags
& wxDOC_SILENT
)
1376 wxASSERT_MSG( !path
.empty(),
1377 "using empty path with wxDOC_SILENT doesn't make sense" );
1379 temp
= FindTemplateForPath(path
);
1382 wxLogWarning(_("The format of file '%s' couldn't be determined."),
1386 else // not silent, ask the user
1388 // for the new file we need just the template, for an existing one we
1389 // need the template and the path, unless it's already specified
1390 if ( (flags
& wxDOC_NEW
) || !path
.empty() )
1391 temp
= SelectDocumentType(&templates
[0], numTemplates
);
1393 temp
= SelectDocumentPath(&templates
[0], numTemplates
, path
, flags
);
1399 // check whether the document with this path is already opened
1400 if ( !path
.empty() )
1402 const wxFileName
fn(path
);
1403 for ( wxList::const_iterator i
= m_docs
.begin(); i
!= m_docs
.end(); ++i
)
1405 wxDocument
* const doc
= (wxDocument
*)*i
;
1407 if ( fn
== doc
->GetFilename() )
1409 // file already open, just activate it and return
1410 ActivateDocument(doc
);
1416 // no, we need to create a new document
1419 // if we've reached the max number of docs, close the first one.
1420 if ( (int)GetDocuments().GetCount() >= m_maxDocsOpen
)
1422 if ( !CloseDocument((wxDocument
*)GetDocuments().GetFirst()->GetData()) )
1424 // can't open the new document if closing the old one failed
1430 // do create and initialize the new document finally
1431 wxDocument
* const docNew
= temp
->CreateDocument(path
, flags
);
1435 docNew
->SetDocumentName(temp
->GetDocumentName());
1436 docNew
->SetDocumentTemplate(temp
);
1440 // call the appropriate function depending on whether we're creating a
1441 // new file or opening an existing one
1442 if ( !(flags
& wxDOC_NEW
? docNew
->OnNewDocument()
1443 : docNew
->OnOpenDocument(path
)) )
1445 docNew
->DeleteAllViews();
1449 wxCATCH_ALL( docNew
->DeleteAllViews(); throw; )
1451 // add the successfully opened file to MRU, but only if we're going to be
1452 // able to reopen it successfully later which requires the template for
1453 // this document to be retrievable from the file extension
1454 if ( !(flags
& wxDOC_NEW
) && temp
->FileMatchesTemplate(path
) )
1455 AddFileToHistory(path
);
1457 // at least under Mac (where views are top level windows) it seems to be
1458 // necessary to manually activate the new document to bring it to the
1459 // forefront -- and it shouldn't hurt doing this under the other platforms
1460 ActivateDocument(docNew
);
1465 wxView
*wxDocManager::CreateView(wxDocument
*doc
, long flags
)
1467 wxDocTemplates
templates(GetVisibleTemplates(m_templates
));
1468 const size_t numTemplates
= templates
.size();
1470 if ( numTemplates
== 0 )
1473 wxDocTemplate
* const
1474 temp
= numTemplates
== 1 ? templates
[0]
1475 : SelectViewType(&templates
[0], numTemplates
);
1480 wxView
*view
= temp
->CreateView(doc
, flags
);
1482 view
->SetViewName(temp
->GetViewName());
1486 // Not yet implemented
1488 wxDocManager::DeleteTemplate(wxDocTemplate
*WXUNUSED(temp
), long WXUNUSED(flags
))
1492 // Not yet implemented
1493 bool wxDocManager::FlushDoc(wxDocument
*WXUNUSED(doc
))
1498 wxDocument
*wxDocManager::GetCurrentDocument() const
1500 wxView
* const view
= GetActiveView();
1501 return view
? view
->GetDocument() : NULL
;
1504 wxCommandProcessor
*wxDocManager::GetCurrentCommandProcessor() const
1506 wxDocument
* const doc
= GetCurrentDocument();
1507 return doc
? doc
->GetCommandProcessor() : NULL
;
1510 // Make a default name for a new document
1511 #if WXWIN_COMPATIBILITY_2_8
1512 bool wxDocManager::MakeDefaultName(wxString
& WXUNUSED(name
))
1514 // we consider that this function can only be overridden by the user code,
1515 // not called by it as it only makes sense to call it internally, so we
1516 // don't bother to return anything from here
1519 #endif // WXWIN_COMPATIBILITY_2_8
1521 wxString
wxDocManager::MakeNewDocumentName()
1525 #if WXWIN_COMPATIBILITY_2_8
1526 if ( !MakeDefaultName(name
) )
1527 #endif // WXWIN_COMPATIBILITY_2_8
1529 name
.Printf(_("unnamed%d"), m_defaultDocumentNameCounter
);
1530 m_defaultDocumentNameCounter
++;
1536 // Make a frame title (override this to do something different)
1537 // If docName is empty, a document is not currently active.
1538 wxString
wxDocManager::MakeFrameTitle(wxDocument
* doc
)
1540 wxString appName
= wxTheApp
->GetAppDisplayName();
1546 wxString docName
= doc
->GetUserReadableName();
1547 title
= docName
+ wxString(_(" - ")) + appName
;
1553 // Not yet implemented
1554 wxDocTemplate
*wxDocManager::MatchTemplate(const wxString
& WXUNUSED(path
))
1559 // File history management
1560 void wxDocManager::AddFileToHistory(const wxString
& file
)
1563 m_fileHistory
->AddFileToHistory(file
);
1566 void wxDocManager::RemoveFileFromHistory(size_t i
)
1569 m_fileHistory
->RemoveFileFromHistory(i
);
1572 wxString
wxDocManager::GetHistoryFile(size_t i
) const
1577 histFile
= m_fileHistory
->GetHistoryFile(i
);
1582 void wxDocManager::FileHistoryUseMenu(wxMenu
*menu
)
1585 m_fileHistory
->UseMenu(menu
);
1588 void wxDocManager::FileHistoryRemoveMenu(wxMenu
*menu
)
1591 m_fileHistory
->RemoveMenu(menu
);
1595 void wxDocManager::FileHistoryLoad(const wxConfigBase
& config
)
1598 m_fileHistory
->Load(config
);
1601 void wxDocManager::FileHistorySave(wxConfigBase
& config
)
1604 m_fileHistory
->Save(config
);
1608 void wxDocManager::FileHistoryAddFilesToMenu(wxMenu
* menu
)
1611 m_fileHistory
->AddFilesToMenu(menu
);
1614 void wxDocManager::FileHistoryAddFilesToMenu()
1617 m_fileHistory
->AddFilesToMenu();
1620 size_t wxDocManager::GetHistoryFilesCount() const
1622 return m_fileHistory
? m_fileHistory
->GetCount() : 0;
1626 // Find out the document template via matching in the document file format
1627 // against that of the template
1628 wxDocTemplate
*wxDocManager::FindTemplateForPath(const wxString
& path
)
1630 wxDocTemplate
*theTemplate
= NULL
;
1632 // Find the template which this extension corresponds to
1633 for (size_t i
= 0; i
< m_templates
.GetCount(); i
++)
1635 wxDocTemplate
*temp
= (wxDocTemplate
*)m_templates
.Item(i
)->GetData();
1636 if ( temp
->FileMatchesTemplate(path
) )
1645 // Prompts user to open a file, using file specs in templates.
1646 // Must extend the file selector dialog or implement own; OR
1647 // match the extension to the template extension.
1649 wxDocTemplate
*wxDocManager::SelectDocumentPath(wxDocTemplate
**templates
,
1652 long WXUNUSED(flags
),
1653 bool WXUNUSED(save
))
1655 #ifdef wxHAS_MULTIPLE_FILEDLG_FILTERS
1658 for (int i
= 0; i
< noTemplates
; i
++)
1660 if (templates
[i
]->IsVisible())
1662 // add a '|' to separate this filter from the previous one
1663 if ( !descrBuf
.empty() )
1664 descrBuf
<< wxT('|');
1666 descrBuf
<< templates
[i
]->GetDescription()
1667 << wxT(" (") << templates
[i
]->GetFileFilter() << wxT(") |")
1668 << templates
[i
]->GetFileFilter();
1672 wxString descrBuf
= wxT("*.*");
1673 wxUnusedVar(noTemplates
);
1676 int FilterIndex
= -1;
1678 wxString pathTmp
= wxFileSelectorEx(_("Open File"),
1683 wxFD_OPEN
| wxFD_FILE_MUST_EXIST
);
1685 wxDocTemplate
*theTemplate
= NULL
;
1686 if (!pathTmp
.empty())
1688 if (!wxFileExists(pathTmp
))
1691 if (!wxTheApp
->GetAppDisplayName().empty())
1692 msgTitle
= wxTheApp
->GetAppDisplayName();
1694 msgTitle
= wxString(_("File error"));
1696 wxMessageBox(_("Sorry, could not open this file."),
1698 wxOK
| wxICON_EXCLAMATION
| wxCENTRE
);
1700 path
= wxEmptyString
;
1704 SetLastDirectory(wxPathOnly(pathTmp
));
1708 // first choose the template using the extension, if this fails (i.e.
1709 // wxFileSelectorEx() didn't fill it), then use the path
1710 if ( FilterIndex
!= -1 )
1711 theTemplate
= templates
[FilterIndex
];
1713 theTemplate
= FindTemplateForPath(path
);
1716 // Since we do not add files with non-default extensions to the
1717 // file history this can only happen if the application changes the
1718 // allowed templates in runtime.
1719 wxMessageBox(_("Sorry, the format for this file is unknown."),
1721 wxOK
| wxICON_EXCLAMATION
| wxCENTRE
);
1732 wxDocTemplate
*wxDocManager::SelectDocumentType(wxDocTemplate
**templates
,
1733 int noTemplates
, bool sort
)
1735 wxArrayString strings
;
1736 wxScopedArray
<wxDocTemplate
*> data(new wxDocTemplate
*[noTemplates
]);
1740 for (i
= 0; i
< noTemplates
; i
++)
1742 if (templates
[i
]->IsVisible())
1746 for (j
= 0; j
< n
; j
++)
1748 //filter out NOT unique documents + view combinations
1749 if ( templates
[i
]->m_docTypeName
== data
[j
]->m_docTypeName
&&
1750 templates
[i
]->m_viewTypeName
== data
[j
]->m_viewTypeName
1757 strings
.Add(templates
[i
]->m_description
);
1759 data
[n
] = templates
[i
];
1767 strings
.Sort(); // ascending sort
1768 // Yes, this will be slow, but template lists
1769 // are typically short.
1771 n
= strings
.Count();
1772 for (i
= 0; i
< n
; i
++)
1774 for (j
= 0; j
< noTemplates
; j
++)
1776 if (strings
[i
] == templates
[j
]->m_description
)
1777 data
[i
] = templates
[j
];
1782 wxDocTemplate
*theTemplate
;
1787 // no visible templates, hence nothing to choose from
1792 // don't propose the user to choose if he has no choice
1793 theTemplate
= data
[0];
1797 // propose the user to choose one of several
1798 theTemplate
= (wxDocTemplate
*)wxGetSingleChoiceData
1800 _("Select a document template"),
1810 wxDocTemplate
*wxDocManager::SelectViewType(wxDocTemplate
**templates
,
1811 int noTemplates
, bool sort
)
1813 wxArrayString strings
;
1814 wxScopedArray
<wxDocTemplate
*> data(new wxDocTemplate
*[noTemplates
]);
1818 for (i
= 0; i
< noTemplates
; i
++)
1820 wxDocTemplate
*templ
= templates
[i
];
1821 if ( templ
->IsVisible() && !templ
->GetViewName().empty() )
1825 for (j
= 0; j
< n
; j
++)
1827 //filter out NOT unique views
1828 if ( templates
[i
]->m_viewTypeName
== data
[j
]->m_viewTypeName
)
1834 strings
.Add(templ
->m_viewTypeName
);
1843 strings
.Sort(); // ascending sort
1844 // Yes, this will be slow, but template lists
1845 // are typically short.
1847 n
= strings
.Count();
1848 for (i
= 0; i
< n
; i
++)
1850 for (j
= 0; j
< noTemplates
; j
++)
1852 if (strings
[i
] == templates
[j
]->m_viewTypeName
)
1853 data
[i
] = templates
[j
];
1858 wxDocTemplate
*theTemplate
;
1860 // the same logic as above
1868 theTemplate
= data
[0];
1872 theTemplate
= (wxDocTemplate
*)wxGetSingleChoiceData
1874 _("Select a document view"),
1885 void wxDocManager::AssociateTemplate(wxDocTemplate
*temp
)
1887 if (!m_templates
.Member(temp
))
1888 m_templates
.Append(temp
);
1891 void wxDocManager::DisassociateTemplate(wxDocTemplate
*temp
)
1893 m_templates
.DeleteObject(temp
);
1896 // Add and remove a document from the manager's list
1897 void wxDocManager::AddDocument(wxDocument
*doc
)
1899 if (!m_docs
.Member(doc
))
1903 void wxDocManager::RemoveDocument(wxDocument
*doc
)
1905 m_docs
.DeleteObject(doc
);
1908 // Views or windows should inform the document manager
1909 // when a view is going in or out of focus
1910 void wxDocManager::ActivateView(wxView
*view
, bool activate
)
1914 m_currentView
= view
;
1918 if ( m_currentView
== view
)
1920 // don't keep stale pointer
1921 m_currentView
= NULL
;
1926 // ----------------------------------------------------------------------------
1927 // wxDocChildFrameAnyBase
1928 // ----------------------------------------------------------------------------
1930 bool wxDocChildFrameAnyBase::CloseView(wxCloseEvent
& event
)
1934 // notice that we must call wxView::Close() and OnClose() called from
1935 // it in any case, even if we know that we are going to close anyhow
1936 if ( !m_childView
->Close(false) && event
.CanVeto() )
1942 m_childView
->Activate(false);
1944 // it is important to reset m_childView frame pointer to NULL before
1945 // deleting it because while normally it is the frame which deletes the
1946 // view when it's closed, the view also closes the frame if it is
1947 // deleted directly not by us as indicated by its doc child frame
1948 // pointer still being set
1949 m_childView
->SetDocChildFrame(NULL
);
1950 wxDELETE(m_childView
);
1953 m_childDocument
= NULL
;
1958 // ----------------------------------------------------------------------------
1959 // wxDocParentFrameAnyBase
1960 // ----------------------------------------------------------------------------
1962 #if wxUSE_PRINTING_ARCHITECTURE
1964 wxDocPrintout::wxDocPrintout(wxView
*view
, const wxString
& title
)
1967 m_printoutView
= view
;
1970 bool wxDocPrintout::OnPrintPage(int WXUNUSED(page
))
1974 // Get the logical pixels per inch of screen and printer
1975 int ppiScreenX
, ppiScreenY
;
1976 GetPPIScreen(&ppiScreenX
, &ppiScreenY
);
1977 wxUnusedVar(ppiScreenY
);
1978 int ppiPrinterX
, ppiPrinterY
;
1979 GetPPIPrinter(&ppiPrinterX
, &ppiPrinterY
);
1980 wxUnusedVar(ppiPrinterY
);
1982 // This scales the DC so that the printout roughly represents the
1983 // the screen scaling. The text point size _should_ be the right size
1984 // but in fact is too small for some reason. This is a detail that will
1985 // need to be addressed at some point but can be fudged for the
1987 float scale
= (float)((float)ppiPrinterX
/(float)ppiScreenX
);
1989 // Now we have to check in case our real page size is reduced
1990 // (e.g. because we're drawing to a print preview memory DC)
1991 int pageWidth
, pageHeight
;
1993 dc
->GetSize(&w
, &h
);
1994 GetPageSizePixels(&pageWidth
, &pageHeight
);
1995 wxUnusedVar(pageHeight
);
1997 // If printer pageWidth == current DC width, then this doesn't
1998 // change. But w might be the preview bitmap width, so scale down.
1999 float overallScale
= scale
* (float)(w
/(float)pageWidth
);
2000 dc
->SetUserScale(overallScale
, overallScale
);
2004 m_printoutView
->OnDraw(dc
);
2009 bool wxDocPrintout::HasPage(int pageNum
)
2011 return (pageNum
== 1);
2014 bool wxDocPrintout::OnBeginDocument(int startPage
, int endPage
)
2016 if (!wxPrintout::OnBeginDocument(startPage
, endPage
))
2022 void wxDocPrintout::GetPageInfo(int *minPage
, int *maxPage
,
2023 int *selPageFrom
, int *selPageTo
)
2031 #endif // wxUSE_PRINTING_ARCHITECTURE
2033 // ----------------------------------------------------------------------------
2034 // Permits compatibility with existing file formats and functions that
2035 // manipulate files directly
2036 // ----------------------------------------------------------------------------
2038 #if wxUSE_STD_IOSTREAM
2040 bool wxTransferFileToStream(const wxString
& filename
, wxSTD ostream
& stream
)
2043 wxFFile
file(filename
, wxT("rb"));
2045 wxFile
file(filename
, wxFile::read
);
2047 if ( !file
.IsOpened() )
2055 nRead
= file
.Read(buf
, WXSIZEOF(buf
));
2059 stream
.write(buf
, nRead
);
2063 while ( !file
.Eof() );
2068 bool wxTransferStreamToFile(wxSTD istream
& stream
, const wxString
& filename
)
2071 wxFFile
file(filename
, wxT("wb"));
2073 wxFile
file(filename
, wxFile::write
);
2075 if ( !file
.IsOpened() )
2081 stream
.read(buf
, WXSIZEOF(buf
));
2082 if ( !stream
.bad() ) // fail may be set on EOF, don't use operator!()
2084 if ( !file
.Write(buf
, stream
.gcount()) )
2088 while ( !stream
.eof() );
2093 #else // !wxUSE_STD_IOSTREAM
2095 bool wxTransferFileToStream(const wxString
& filename
, wxOutputStream
& stream
)
2098 wxFFile
file(filename
, wxT("rb"));
2100 wxFile
file(filename
, wxFile::read
);
2102 if ( !file
.IsOpened() )
2110 nRead
= file
.Read(buf
, WXSIZEOF(buf
));
2114 stream
.Write(buf
, nRead
);
2118 while ( !file
.Eof() );
2123 bool wxTransferStreamToFile(wxInputStream
& stream
, const wxString
& filename
)
2126 wxFFile
file(filename
, wxT("wb"));
2128 wxFile
file(filename
, wxFile::write
);
2130 if ( !file
.IsOpened() )
2136 stream
.Read(buf
, WXSIZEOF(buf
));
2138 const size_t nRead
= stream
.LastRead();
2147 if ( !file
.Write(buf
, nRead
) )
2154 #endif // wxUSE_STD_IOSTREAM/!wxUSE_STD_IOSTREAM
2156 #endif // wxUSE_DOC_VIEW_ARCHITECTURE