]> git.saurik.com Git - wxWidgets.git/blob - src/common/docview.cpp
Rewind the input stream after failing to load image from it.
[wxWidgets.git] / src / common / docview.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/docview.cpp
3 // Purpose: Document/view classes
4 // Author: Julian Smart
5 // Modified by: Vadim Zeitlin
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #if wxUSE_DOC_VIEW_ARCHITECTURE
28
29 #include "wx/docview.h"
30
31 #ifndef WX_PRECOMP
32 #include "wx/list.h"
33 #include "wx/string.h"
34 #include "wx/utils.h"
35 #include "wx/app.h"
36 #include "wx/dc.h"
37 #include "wx/dialog.h"
38 #include "wx/menu.h"
39 #include "wx/filedlg.h"
40 #include "wx/intl.h"
41 #include "wx/log.h"
42 #include "wx/msgdlg.h"
43 #include "wx/mdi.h"
44 #include "wx/choicdlg.h"
45 #endif
46
47 #if wxUSE_PRINTING_ARCHITECTURE
48 #include "wx/prntbase.h"
49 #include "wx/printdlg.h"
50 #endif
51
52 #include "wx/confbase.h"
53 #include "wx/filename.h"
54 #include "wx/file.h"
55 #include "wx/ffile.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"
64
65 #if wxUSE_STD_IOSTREAM
66 #include "wx/ioswrap.h"
67 #include "wx/beforestd.h"
68 #if wxUSE_IOSTREAMH
69 #include <fstream.h>
70 #else
71 #include <fstream>
72 #endif
73 #include "wx/afterstd.h"
74 #else
75 #include "wx/wfstream.h"
76 #endif
77
78 typedef wxVector<wxDocTemplate *> wxDocTemplates;
79
80 // ----------------------------------------------------------------------------
81 // wxWidgets macros
82 // ----------------------------------------------------------------------------
83
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)
90
91 #if wxUSE_PRINTING_ARCHITECTURE
92 IMPLEMENT_DYNAMIC_CLASS(wxDocPrintout, wxPrintout)
93 #endif
94
95 // ============================================================================
96 // implementation
97 // ============================================================================
98
99 // ----------------------------------------------------------------------------
100 // private helpers
101 // ----------------------------------------------------------------------------
102
103 namespace
104 {
105
106 wxString FindExtension(const wxString& path)
107 {
108 wxString ext;
109 wxFileName::SplitPath(path, NULL, NULL, &ext);
110
111 // VZ: extensions are considered not case sensitive - is this really a good
112 // idea?
113 return ext.MakeLower();
114 }
115
116 } // anonymous namespace
117
118 // ----------------------------------------------------------------------------
119 // Definition of wxDocument
120 // ----------------------------------------------------------------------------
121
122 wxDocument::wxDocument(wxDocument *parent)
123 {
124 m_documentModified = false;
125 m_documentParent = parent;
126 m_documentTemplate = NULL;
127 m_commandProcessor = NULL;
128 m_savedYet = false;
129 }
130
131 bool wxDocument::DeleteContents()
132 {
133 return true;
134 }
135
136 wxDocument::~wxDocument()
137 {
138 delete m_commandProcessor;
139
140 if (GetDocumentManager())
141 GetDocumentManager()->RemoveDocument(this);
142
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.
146 //DeleteAllViews();
147 }
148
149 bool wxDocument::Close()
150 {
151 if ( !OnSaveModified() )
152 return false;
153
154 return OnCloseDocument();
155 }
156
157 bool wxDocument::OnCloseDocument()
158 {
159 // Tell all views that we're about to close
160 NotifyClosing();
161 DeleteContents();
162 Modify(false);
163 return true;
164 }
165
166 // Note that this implicitly deletes the document when the last view is
167 // deleted.
168 bool wxDocument::DeleteAllViews()
169 {
170 wxDocManager* manager = GetDocumentManager();
171
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 )
175 {
176 wxView *view = (wxView *)*i;
177 if ( !view->Close() )
178 return false;
179 }
180
181 // all views agreed to close, now do close them
182 if ( m_documentViews.empty() )
183 {
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) )
187 delete this;
188 }
189 else // have views
190 {
191 // as we delete elements we iterate over, don't use the usual "from
192 // begin to end" loop
193 for ( ;; )
194 {
195 wxView *view = (wxView *)*m_documentViews.begin();
196
197 bool isLastOne = m_documentViews.size() == 1;
198
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!
202 delete view;
203
204 if ( isLastOne )
205 break;
206 }
207 }
208
209 return true;
210 }
211
212 wxView *wxDocument::GetFirstView() const
213 {
214 if ( m_documentViews.empty() )
215 return NULL;
216
217 return static_cast<wxView *>(m_documentViews.GetFirst()->GetData());
218 }
219
220 void wxDocument::Modify(bool mod)
221 {
222 if (mod != m_documentModified)
223 {
224 m_documentModified = mod;
225
226 // Allow views to append asterix to the title
227 wxView* view = GetFirstView();
228 if (view) view->OnChangeFilename();
229 }
230 }
231
232 wxDocManager *wxDocument::GetDocumentManager() const
233 {
234 return m_documentTemplate ? m_documentTemplate->GetDocumentManager() : NULL;
235 }
236
237 bool wxDocument::OnNewDocument()
238 {
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
244 // lost) information
245
246 SetDocumentSaved(false);
247
248 const wxString name = GetDocumentManager()->MakeNewDocumentName();
249 SetTitle(name);
250 SetFilename(name, true);
251
252 return true;
253 }
254
255 bool wxDocument::Save()
256 {
257 if ( AlreadySaved() )
258 return true;
259
260 if ( m_documentFile.empty() || !m_savedYet )
261 return SaveAs();
262
263 return OnSaveDocument(m_documentFile);
264 }
265
266 bool wxDocument::SaveAs()
267 {
268 wxDocTemplate *docTemplate = GetDocumentTemplate();
269 if (!docTemplate)
270 return false;
271
272 #ifdef wxHAS_MULTIPLE_FILEDLG_FILTERS
273 wxString filter = docTemplate->GetDescription() + wxT(" (") +
274 docTemplate->GetFileFilter() + wxT(")|") +
275 docTemplate->GetFileFilter();
276
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())
280 {
281 wxList::compatibility_iterator
282 node = docTemplate->GetDocumentManager()->GetTemplates().GetFirst();
283 while (node)
284 {
285 wxDocTemplate *t = (wxDocTemplate*) node->GetData();
286
287 if (t->IsVisible() && t != docTemplate &&
288 t->GetViewClassInfo() == docTemplate->GetViewClassInfo() &&
289 t->GetDocClassInfo() == docTemplate->GetDocClassInfo())
290 {
291 // add a '|' to separate this filter from the previous one
292 if ( !filter.empty() )
293 filter << wxT('|');
294
295 filter << t->GetDescription()
296 << wxT(" (") << t->GetFileFilter() << wxT(") |")
297 << t->GetFileFilter();
298 }
299
300 node = node->GetNext();
301 }
302 }
303 #else
304 wxString filter = docTemplate->GetFileFilter() ;
305 #endif
306
307 wxString defaultDir = docTemplate->GetDirectory();
308 if ( defaultDir.empty() )
309 {
310 defaultDir = wxPathOnly(GetFilename());
311 if ( defaultDir.empty() )
312 defaultDir = GetDocumentManager()->GetLastDirectory();
313 }
314
315 wxString fileName = wxFileSelector(_("Save As"),
316 defaultDir,
317 wxFileNameFromPath(GetFilename()),
318 docTemplate->GetDefaultExtension(),
319 filter,
320 wxFD_SAVE | wxFD_OVERWRITE_PROMPT,
321 GetDocumentWindow());
322
323 if (fileName.empty())
324 return false; // cancelled by user
325
326 // Files that were not saved correctly are not added to the FileHistory.
327 if (!OnSaveDocument(fileName))
328 return false;
329
330 SetTitle(wxFileNameFromPath(fileName));
331 SetFilename(fileName, true); // will call OnChangeFileName automatically
332
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))
336 {
337 GetDocumentManager()->AddFileToHistory(fileName);
338 }
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
341
342 return true;
343 }
344
345 bool wxDocument::OnSaveDocument(const wxString& file)
346 {
347 if ( !file )
348 return false;
349
350 if ( !DoSaveDocument(file) )
351 return false;
352
353 Modify(false);
354 SetFilename(file);
355 SetDocumentSaved(true);
356 #if defined( __WXOSX_MAC__ ) && wxOSX_USE_CARBON
357 wxFileName fn(file) ;
358 fn.MacSetDefaultTypeAndCreator() ;
359 #endif
360 return true;
361 }
362
363 bool wxDocument::OnOpenDocument(const wxString& file)
364 {
365 // notice that there is no need to check the modified flag here for the
366 // reasons explained in OnNewDocument()
367
368 if ( !DoOpenDocument(file) )
369 return false;
370
371 SetFilename(file, true);
372
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);
379
380 UpdateAllViews();
381
382 return true;
383 }
384
385 #if wxUSE_STD_IOSTREAM
386 wxSTD istream& wxDocument::LoadObject(wxSTD istream& stream)
387 #else
388 wxInputStream& wxDocument::LoadObject(wxInputStream& stream)
389 #endif
390 {
391 return stream;
392 }
393
394 #if wxUSE_STD_IOSTREAM
395 wxSTD ostream& wxDocument::SaveObject(wxSTD ostream& stream)
396 #else
397 wxOutputStream& wxDocument::SaveObject(wxOutputStream& stream)
398 #endif
399 {
400 return stream;
401 }
402
403 bool wxDocument::Revert()
404 {
405 if ( wxMessageBox
406 (
407 _("Discard changes and reload the last saved version?"),
408 wxTheApp->GetAppDisplayName(),
409 wxYES_NO | wxCANCEL | wxICON_QUESTION,
410 GetDocumentWindow()
411 ) != wxYES )
412 return false;
413
414 if ( !DoOpenDocument(GetFilename()) )
415 return false;
416
417 Modify(false);
418 UpdateAllViews();
419
420 return true;
421 }
422
423
424 // Get title, or filename if no title, else unnamed
425 #if WXWIN_COMPATIBILITY_2_8
426 bool wxDocument::GetPrintableName(wxString& buf) const
427 {
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();
433
434 return true;
435 }
436 #endif // WXWIN_COMPATIBILITY_2_8
437
438 wxString wxDocument::GetUserReadableName() const
439 {
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
443 wxString name;
444 if ( GetPrintableName(name) )
445 return name;
446 #endif // WXWIN_COMPATIBILITY_2_8
447
448 return DoGetUserReadableName();
449 }
450
451 wxString wxDocument::DoGetUserReadableName() const
452 {
453 if ( !m_documentTitle.empty() )
454 return m_documentTitle;
455
456 if ( !m_documentFile.empty() )
457 return wxFileNameFromPath(m_documentFile);
458
459 return _("unnamed");
460 }
461
462 wxWindow *wxDocument::GetDocumentWindow() const
463 {
464 wxView * const view = GetFirstView();
465
466 return view ? view->GetFrame() : wxTheApp->GetTopWindow();
467 }
468
469 wxCommandProcessor *wxDocument::OnCreateCommandProcessor()
470 {
471 return new wxCommandProcessor;
472 }
473
474 // true if safe to close
475 bool wxDocument::OnSaveModified()
476 {
477 if ( IsModified() )
478 {
479 switch ( wxMessageBox
480 (
481 wxString::Format
482 (
483 _("Do you want to save changes to %s?"),
484 GetUserReadableName()
485 ),
486 wxTheApp->GetAppDisplayName(),
487 wxYES_NO | wxCANCEL | wxICON_QUESTION | wxCENTRE
488 ) )
489 {
490 case wxNO:
491 Modify(false);
492 break;
493
494 case wxYES:
495 return Save();
496
497 case wxCANCEL:
498 return false;
499 }
500 }
501
502 return true;
503 }
504
505 bool wxDocument::Draw(wxDC& WXUNUSED(context))
506 {
507 return true;
508 }
509
510 bool wxDocument::AddView(wxView *view)
511 {
512 if ( !m_documentViews.Member(view) )
513 {
514 m_documentViews.Append(view);
515 OnChangedViewList();
516 }
517 return true;
518 }
519
520 bool wxDocument::RemoveView(wxView *view)
521 {
522 (void)m_documentViews.DeleteObject(view);
523 OnChangedViewList();
524 return true;
525 }
526
527 bool wxDocument::OnCreate(const wxString& WXUNUSED(path), long flags)
528 {
529 return GetDocumentTemplate()->CreateView(this, flags) != NULL;
530 }
531
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()
536 {
537 if ( m_documentViews.empty() && OnSaveModified() )
538 delete this;
539 }
540
541 void wxDocument::UpdateAllViews(wxView *sender, wxObject *hint)
542 {
543 wxList::compatibility_iterator node = m_documentViews.GetFirst();
544 while (node)
545 {
546 wxView *view = (wxView *)node->GetData();
547 if (view != sender)
548 view->OnUpdate(sender, hint);
549 node = node->GetNext();
550 }
551 }
552
553 void wxDocument::NotifyClosing()
554 {
555 wxList::compatibility_iterator node = m_documentViews.GetFirst();
556 while (node)
557 {
558 wxView *view = (wxView *)node->GetData();
559 view->OnClosingDocument();
560 node = node->GetNext();
561 }
562 }
563
564 void wxDocument::SetFilename(const wxString& filename, bool notifyViews)
565 {
566 m_documentFile = filename;
567 OnChangeFilename(notifyViews);
568 }
569
570 void wxDocument::OnChangeFilename(bool notifyViews)
571 {
572 if ( notifyViews )
573 {
574 // Notify the views that the filename has changed
575 wxList::compatibility_iterator node = m_documentViews.GetFirst();
576 while (node)
577 {
578 wxView *view = (wxView *)node->GetData();
579 view->OnChangeFilename();
580 node = node->GetNext();
581 }
582 }
583 }
584
585 bool wxDocument::DoSaveDocument(const wxString& file)
586 {
587 #if wxUSE_STD_IOSTREAM
588 wxSTD ofstream store(file.mb_str(), wxSTD ios::binary);
589 if ( !store )
590 #else
591 wxFileOutputStream store(file);
592 if ( store.GetLastError() != wxSTREAM_NO_ERROR )
593 #endif
594 {
595 wxLogError(_("File \"%s\" could not be opened for writing."), file);
596 return false;
597 }
598
599 if (!SaveObject(store))
600 {
601 wxLogError(_("Failed to save document to the file \"%s\"."), file);
602 return false;
603 }
604
605 return true;
606 }
607
608 bool wxDocument::DoOpenDocument(const wxString& file)
609 {
610 #if wxUSE_STD_IOSTREAM
611 wxSTD ifstream store(file.mb_str(), wxSTD ios::binary);
612 if ( !store )
613 #else
614 wxFileInputStream store(file);
615 if (store.GetLastError() != wxSTREAM_NO_ERROR || !store.IsOk())
616 #endif
617 {
618 wxLogError(_("File \"%s\" could not be opened for reading."), file);
619 return false;
620 }
621
622 #if wxUSE_STD_IOSTREAM
623 LoadObject(store);
624 if ( !store )
625 #else
626 int res = LoadObject(store).GetLastError();
627 if ( res != wxSTREAM_NO_ERROR && res != wxSTREAM_EOF )
628 #endif
629 {
630 wxLogError(_("Failed to read document from the file \"%s\"."), file);
631 return false;
632 }
633
634 return true;
635 }
636
637
638 // ----------------------------------------------------------------------------
639 // Document view
640 // ----------------------------------------------------------------------------
641
642 wxView::wxView()
643 {
644 m_viewDocument = NULL;
645
646 m_viewFrame = NULL;
647
648 m_docChildFrame = NULL;
649 }
650
651 wxView::~wxView()
652 {
653 if (m_viewDocument && GetDocumentManager())
654 GetDocumentManager()->ActivateView(this, false);
655
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 )
662 {
663 // prevent it from doing anything with us
664 m_docChildFrame->SetView(NULL);
665
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
668 //
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();
675 }
676
677 if ( m_viewDocument )
678 m_viewDocument->RemoveView(this);
679 }
680
681 void wxView::SetDocChildFrame(wxDocChildFrameAnyBase *docChildFrame)
682 {
683 SetFrame(docChildFrame ? docChildFrame->GetWindow() : NULL);
684 m_docChildFrame = docChildFrame;
685 }
686
687 bool wxView::TryBefore(wxEvent& event)
688 {
689 wxDocument * const doc = GetDocument();
690 return doc && doc->ProcessEventLocally(event);
691 }
692
693 void wxView::OnActivateView(bool WXUNUSED(activate),
694 wxView *WXUNUSED(activeView),
695 wxView *WXUNUSED(deactiveView))
696 {
697 }
698
699 void wxView::OnPrint(wxDC *dc, wxObject *WXUNUSED(info))
700 {
701 OnDraw(dc);
702 }
703
704 void wxView::OnUpdate(wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint))
705 {
706 }
707
708 void wxView::OnChangeFilename()
709 {
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();
714 if (!win) return;
715
716 wxDocument *doc = GetDocument();
717 if (!doc) return;
718
719 wxString label = doc->GetUserReadableName();
720 if (doc->IsModified())
721 {
722 label += "*";
723 }
724 win->SetLabel(label);
725 }
726
727 void wxView::SetDocument(wxDocument *doc)
728 {
729 m_viewDocument = doc;
730 if (doc)
731 doc->AddView(this);
732 }
733
734 bool wxView::Close(bool deleteWindow)
735 {
736 return OnClose(deleteWindow);
737 }
738
739 void wxView::Activate(bool activate)
740 {
741 if (GetDocument() && GetDocumentManager())
742 {
743 OnActivateView(activate, this, GetDocumentManager()->GetCurrentView());
744 GetDocumentManager()->ActivateView(this, activate);
745 }
746 }
747
748 bool wxView::OnClose(bool WXUNUSED(deleteWindow))
749 {
750 return GetDocument() ? GetDocument()->Close() : true;
751 }
752
753 #if wxUSE_PRINTING_ARCHITECTURE
754 wxPrintout *wxView::OnCreatePrintout()
755 {
756 return new wxDocPrintout(this);
757 }
758 #endif // wxUSE_PRINTING_ARCHITECTURE
759
760 // ----------------------------------------------------------------------------
761 // wxDocTemplate
762 // ----------------------------------------------------------------------------
763
764 wxDocTemplate::wxDocTemplate(wxDocManager *manager,
765 const wxString& descr,
766 const wxString& filter,
767 const wxString& dir,
768 const wxString& ext,
769 const wxString& docTypeName,
770 const wxString& viewTypeName,
771 wxClassInfo *docClassInfo,
772 wxClassInfo *viewClassInfo,
773 long flags)
774 {
775 m_documentManager = manager;
776 m_description = descr;
777 m_directory = dir;
778 m_defaultExt = ext;
779 m_fileFilter = filter;
780 m_flags = flags;
781 m_docTypeName = docTypeName;
782 m_viewTypeName = viewTypeName;
783 m_documentManager->AssociateTemplate(this);
784
785 m_docClassInfo = docClassInfo;
786 m_viewClassInfo = viewClassInfo;
787 }
788
789 wxDocTemplate::~wxDocTemplate()
790 {
791 m_documentManager->DisassociateTemplate(this);
792 }
793
794 // Tries to dynamically construct an object of the right class.
795 wxDocument *wxDocTemplate::CreateDocument(const wxString& path, long flags)
796 {
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();
805
806 return doc && InitDocument(doc, path, flags) ? doc : NULL;
807 }
808
809 bool
810 wxDocTemplate::InitDocument(wxDocument* doc, const wxString& path, long flags)
811 {
812 doc->SetFilename(path);
813 doc->SetDocumentTemplate(this);
814 GetDocumentManager()->AddDocument(doc);
815 doc->SetCommandProcessor(doc->OnCreateCommandProcessor());
816
817 if (doc->OnCreate(path, flags))
818 return true;
819
820 if (GetDocumentManager()->GetDocuments().Member(doc))
821 doc->DeleteAllViews();
822 return false;
823 }
824
825 wxView *wxDocTemplate::CreateView(wxDocument *doc, long flags)
826 {
827 wxScopedPtr<wxView> view(DoCreateView());
828 if ( !view )
829 return NULL;
830
831 view->SetDocument(doc);
832 if ( !view->OnCreate(doc, flags) )
833 return NULL;
834
835 return view.release();
836 }
837
838 // The default (very primitive) format detection: check is the extension is
839 // that of the template
840 bool wxDocTemplate::FileMatchesTemplate(const wxString& path)
841 {
842 wxStringTokenizer parser (GetFileFilter(), wxT(";"));
843 wxString anything = wxT ("*");
844 while (parser.HasMoreTokens())
845 {
846 wxString filter = parser.GetNextToken();
847 wxString filterExt = FindExtension (filter);
848 if ( filter.IsSameAs (anything) ||
849 filterExt.IsSameAs (anything) ||
850 filterExt.IsSameAs (FindExtension (path)) )
851 return true;
852 }
853 return GetDefaultExtension().IsSameAs(FindExtension(path));
854 }
855
856 wxDocument *wxDocTemplate::DoCreateDocument()
857 {
858 if (!m_docClassInfo)
859 return NULL;
860
861 return static_cast<wxDocument *>(m_docClassInfo->CreateObject());
862 }
863
864 wxView *wxDocTemplate::DoCreateView()
865 {
866 if (!m_viewClassInfo)
867 return NULL;
868
869 return static_cast<wxView *>(m_viewClassInfo->CreateObject());
870 }
871
872 // ----------------------------------------------------------------------------
873 // wxDocManager
874 // ----------------------------------------------------------------------------
875
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)
886
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)
891
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)
901
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)
906
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
912 END_EVENT_TABLE()
913
914 wxDocManager* wxDocManager::sm_docManager = NULL;
915
916 wxDocManager::wxDocManager(long WXUNUSED(flags), bool initialize)
917 {
918 sm_docManager = this;
919
920 m_defaultDocumentNameCounter = 1;
921 m_currentView = NULL;
922 m_maxDocsOpen = INT_MAX;
923 m_fileHistory = NULL;
924 if ( initialize )
925 Initialize();
926 }
927
928 wxDocManager::~wxDocManager()
929 {
930 Clear();
931 delete m_fileHistory;
932 sm_docManager = NULL;
933 }
934
935 // closes the specified document
936 bool wxDocManager::CloseDocument(wxDocument* doc, bool force)
937 {
938 if ( !doc->Close() && !force )
939 return false;
940
941 // Implicitly deletes the document when
942 // the last view is deleted
943 doc->DeleteAllViews();
944
945 // Check we're really deleted
946 if (m_docs.Member(doc))
947 delete doc;
948
949 return true;
950 }
951
952 bool wxDocManager::CloseDocuments(bool force)
953 {
954 wxList::compatibility_iterator node = m_docs.GetFirst();
955 while (node)
956 {
957 wxDocument *doc = (wxDocument *)node->GetData();
958 wxList::compatibility_iterator next = node->GetNext();
959
960 if (!CloseDocument(doc, force))
961 return false;
962
963 // This assumes that documents are not connected in
964 // any way, i.e. deleting one document does NOT
965 // delete another.
966 node = next;
967 }
968 return true;
969 }
970
971 bool wxDocManager::Clear(bool force)
972 {
973 if (!CloseDocuments(force))
974 return false;
975
976 m_currentView = NULL;
977
978 wxList::compatibility_iterator node = m_templates.GetFirst();
979 while (node)
980 {
981 wxDocTemplate *templ = (wxDocTemplate*) node->GetData();
982 wxList::compatibility_iterator next = node->GetNext();
983 delete templ;
984 node = next;
985 }
986 return true;
987 }
988
989 bool wxDocManager::Initialize()
990 {
991 m_fileHistory = OnCreateFileHistory();
992 return true;
993 }
994
995 wxString wxDocManager::GetLastDirectory() const
996 {
997 // if we haven't determined the last used directory yet, do it now
998 if ( m_lastDirectory.empty() )
999 {
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);
1003
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() )
1009 {
1010 const wxString lastOpened = m_fileHistory->GetHistoryFile(0);
1011 const wxFileName fn(lastOpened);
1012 if ( fn.DirExists() )
1013 {
1014 self->m_lastDirectory = fn.GetPath();
1015 }
1016 //else: should we try the next one?
1017 }
1018 //else: no history yet
1019
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() )
1023 {
1024 self->m_lastDirectory = wxStandardPaths::Get().GetAppDocumentsDir();
1025 }
1026 }
1027
1028 return m_lastDirectory;
1029 }
1030
1031 wxFileHistory *wxDocManager::OnCreateFileHistory()
1032 {
1033 return new wxFileHistory;
1034 }
1035
1036 void wxDocManager::OnFileClose(wxCommandEvent& WXUNUSED(event))
1037 {
1038 wxDocument *doc = GetCurrentDocument();
1039 if (doc)
1040 CloseDocument(doc);
1041 }
1042
1043 void wxDocManager::OnFileCloseAll(wxCommandEvent& WXUNUSED(event))
1044 {
1045 CloseDocuments(false);
1046 }
1047
1048 void wxDocManager::OnFileNew(wxCommandEvent& WXUNUSED(event))
1049 {
1050 CreateNewDocument();
1051 }
1052
1053 void wxDocManager::OnFileOpen(wxCommandEvent& WXUNUSED(event))
1054 {
1055 if ( !CreateDocument("") )
1056 {
1057 OnOpenFileFailure();
1058 }
1059 }
1060
1061 void wxDocManager::OnFileRevert(wxCommandEvent& WXUNUSED(event))
1062 {
1063 wxDocument *doc = GetCurrentDocument();
1064 if (!doc)
1065 return;
1066 doc->Revert();
1067 }
1068
1069 void wxDocManager::OnFileSave(wxCommandEvent& WXUNUSED(event))
1070 {
1071 wxDocument *doc = GetCurrentDocument();
1072 if (!doc)
1073 return;
1074 doc->Save();
1075 }
1076
1077 void wxDocManager::OnFileSaveAs(wxCommandEvent& WXUNUSED(event))
1078 {
1079 wxDocument *doc = GetCurrentDocument();
1080 if (!doc)
1081 return;
1082 doc->SaveAs();
1083 }
1084
1085 void wxDocManager::OnMRUFile(wxCommandEvent& event)
1086 {
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 + static_cast<int>(m_fileHistory->GetCount()) )
1091 {
1092 DoOpenMRUFile(id - wxID_FILE1);
1093 }
1094 else
1095 {
1096 event.Skip();
1097 }
1098 }
1099
1100 void wxDocManager::DoOpenMRUFile(unsigned n)
1101 {
1102 wxString filename(GetHistoryFile(n));
1103 if ( filename.empty() )
1104 return;
1105
1106 wxString errMsg; // must contain exactly one "%s" if non-empty
1107 if ( wxFile::Exists(filename) )
1108 {
1109 // try to open it
1110 if ( CreateDocument(filename, wxDOC_SILENT) )
1111 return;
1112
1113 errMsg = _("The file '%s' couldn't be opened.");
1114 }
1115 else // file doesn't exist
1116 {
1117 errMsg = _("The file '%s' doesn't exist and couldn't be opened.");
1118 }
1119
1120
1121 wxASSERT_MSG( !errMsg.empty(), "should have an error message" );
1122
1123 // remove the file which we can't open from the MRU list
1124 RemoveFileFromHistory(n);
1125
1126 // and tell the user about it
1127 wxLogError(errMsg + '\n' +
1128 _("It has been removed from the most recently used files list."),
1129 filename);
1130 }
1131
1132 #if wxUSE_PRINTING_ARCHITECTURE
1133
1134 void wxDocManager::OnPrint(wxCommandEvent& WXUNUSED(event))
1135 {
1136 wxView *view = GetActiveView();
1137 if (!view)
1138 return;
1139
1140 wxPrintout *printout = view->OnCreatePrintout();
1141 if (printout)
1142 {
1143 wxPrintDialogData printDialogData(m_pageSetupDialogData.GetPrintData());
1144 wxPrinter printer(&printDialogData);
1145 printer.Print(view->GetFrame(), printout, true);
1146
1147 delete printout;
1148 }
1149 }
1150
1151 void wxDocManager::OnPageSetup(wxCommandEvent& WXUNUSED(event))
1152 {
1153 wxPageSetupDialog dlg(wxTheApp->GetTopWindow(), &m_pageSetupDialogData);
1154 if ( dlg.ShowModal() == wxID_OK )
1155 {
1156 m_pageSetupDialogData = dlg.GetPageSetupData();
1157 }
1158 }
1159
1160 wxPreviewFrame* wxDocManager::CreatePreviewFrame(wxPrintPreviewBase* preview,
1161 wxWindow *parent,
1162 const wxString& title)
1163 {
1164 return new wxPreviewFrame(preview, parent, title);
1165 }
1166
1167 void wxDocManager::OnPreview(wxCommandEvent& WXUNUSED(event))
1168 {
1169 wxBusyCursor busy;
1170 wxView *view = GetActiveView();
1171 if (!view)
1172 return;
1173
1174 wxPrintout *printout = view->OnCreatePrintout();
1175 if (printout)
1176 {
1177 wxPrintDialogData printDialogData(m_pageSetupDialogData.GetPrintData());
1178
1179 // Pass two printout objects: for preview, and possible printing.
1180 wxPrintPreviewBase *
1181 preview = new wxPrintPreview(printout,
1182 view->OnCreatePrintout(),
1183 &printDialogData);
1184 if ( !preview->Ok() )
1185 {
1186 delete preview;
1187 wxLogError(_("Print preview creation failed."));
1188 return;
1189 }
1190
1191 wxPreviewFrame* frame = CreatePreviewFrame(preview,
1192 wxTheApp->GetTopWindow(),
1193 _("Print Preview"));
1194 wxCHECK_RET( frame, "should create a print preview frame" );
1195
1196 frame->Centre(wxBOTH);
1197 frame->Initialize();
1198 frame->Show(true);
1199 }
1200 }
1201 #endif // wxUSE_PRINTING_ARCHITECTURE
1202
1203 void wxDocManager::OnUndo(wxCommandEvent& event)
1204 {
1205 wxCommandProcessor * const cmdproc = GetCurrentCommandProcessor();
1206 if ( !cmdproc )
1207 {
1208 event.Skip();
1209 return;
1210 }
1211
1212 cmdproc->Undo();
1213 }
1214
1215 void wxDocManager::OnRedo(wxCommandEvent& event)
1216 {
1217 wxCommandProcessor * const cmdproc = GetCurrentCommandProcessor();
1218 if ( !cmdproc )
1219 {
1220 event.Skip();
1221 return;
1222 }
1223
1224 cmdproc->Redo();
1225 }
1226
1227 // Handlers for UI update commands
1228
1229 void wxDocManager::OnUpdateFileOpen(wxUpdateUIEvent& event)
1230 {
1231 // CreateDocument() (which is called from OnFileOpen) may succeed
1232 // only when there is at least a template:
1233 event.Enable( GetTemplates().GetCount()>0 );
1234 }
1235
1236 void wxDocManager::OnUpdateDisableIfNoDoc(wxUpdateUIEvent& event)
1237 {
1238 event.Enable( GetCurrentDocument() != NULL );
1239 }
1240
1241 void wxDocManager::OnUpdateFileRevert(wxUpdateUIEvent& event)
1242 {
1243 wxDocument* doc = GetCurrentDocument();
1244 event.Enable(doc && doc->IsModified() && doc->GetDocumentSaved());
1245 }
1246
1247 void wxDocManager::OnUpdateFileNew(wxUpdateUIEvent& event)
1248 {
1249 // CreateDocument() (which is called from OnFileNew) may succeed
1250 // only when there is at least a template:
1251 event.Enable( GetTemplates().GetCount()>0 );
1252 }
1253
1254 void wxDocManager::OnUpdateFileSave(wxUpdateUIEvent& event)
1255 {
1256 wxDocument * const doc = GetCurrentDocument();
1257 event.Enable( doc && !doc->AlreadySaved() );
1258 }
1259
1260 void wxDocManager::OnUpdateUndo(wxUpdateUIEvent& event)
1261 {
1262 wxCommandProcessor * const cmdproc = GetCurrentCommandProcessor();
1263 if ( !cmdproc )
1264 {
1265 event.Enable(false);
1266 return;
1267 }
1268
1269 event.Enable(cmdproc->CanUndo());
1270 cmdproc->SetMenuStrings();
1271 }
1272
1273 void wxDocManager::OnUpdateRedo(wxUpdateUIEvent& event)
1274 {
1275 wxCommandProcessor * const cmdproc = GetCurrentCommandProcessor();
1276 if ( !cmdproc )
1277 {
1278 event.Enable(false);
1279 return;
1280 }
1281
1282 event.Enable(cmdproc->CanRedo());
1283 cmdproc->SetMenuStrings();
1284 }
1285
1286 wxView *wxDocManager::GetActiveView() const
1287 {
1288 wxView *view = GetCurrentView();
1289
1290 if ( !view && !m_docs.empty() )
1291 {
1292 // if we have exactly one document, consider its view to be the current
1293 // one
1294 //
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() )
1300 {
1301 wxDocument *doc = static_cast<wxDocument *>(node->GetData());
1302 view = doc->GetFirstView();
1303 }
1304 //else: we have more than one document
1305 }
1306
1307 return view;
1308 }
1309
1310 bool wxDocManager::TryBefore(wxEvent& event)
1311 {
1312 wxView * const view = GetActiveView();
1313 return view && view->ProcessEventLocally(event);
1314 }
1315
1316 namespace
1317 {
1318
1319 // helper function: return only the visible templates
1320 wxDocTemplates GetVisibleTemplates(const wxList& allTemplates)
1321 {
1322 // select only the visible templates
1323 const size_t totalNumTemplates = allTemplates.GetCount();
1324 wxDocTemplates templates;
1325 if ( totalNumTemplates )
1326 {
1327 templates.reserve(totalNumTemplates);
1328
1329 for ( wxList::const_iterator i = allTemplates.begin(),
1330 end = allTemplates.end();
1331 i != end;
1332 ++i )
1333 {
1334 wxDocTemplate * const temp = (wxDocTemplate *)*i;
1335 if ( temp->IsVisible() )
1336 templates.push_back(temp);
1337 }
1338 }
1339
1340 return templates;
1341 }
1342
1343 } // anonymous namespace
1344
1345 void wxDocManager::ActivateDocument(wxDocument *doc)
1346 {
1347 wxView * const view = doc->GetFirstView();
1348 if ( !view )
1349 return;
1350
1351 view->Activate(true);
1352 if ( wxWindow *win = view->GetFrame() )
1353 win->SetFocus();
1354 }
1355
1356 wxDocument *wxDocManager::CreateDocument(const wxString& pathOrig, long flags)
1357 {
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 )
1364 {
1365 // no templates can be used, can't create document
1366 return NULL;
1367 }
1368
1369
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 )
1375 {
1376 wxASSERT_MSG( !path.empty(),
1377 "using empty path with wxDOC_SILENT doesn't make sense" );
1378
1379 temp = FindTemplateForPath(path);
1380 if ( !temp )
1381 {
1382 wxLogWarning(_("The format of file '%s' couldn't be determined."),
1383 path);
1384 }
1385 }
1386 else // not silent, ask the user
1387 {
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);
1392 else
1393 temp = SelectDocumentPath(&templates[0], numTemplates, path, flags);
1394 }
1395
1396 if ( !temp )
1397 return NULL;
1398
1399 // check whether the document with this path is already opened
1400 if ( !path.empty() )
1401 {
1402 const wxFileName fn(path);
1403 for ( wxList::const_iterator i = m_docs.begin(); i != m_docs.end(); ++i )
1404 {
1405 wxDocument * const doc = (wxDocument*)*i;
1406
1407 if ( fn == doc->GetFilename() )
1408 {
1409 // file already open, just activate it and return
1410 ActivateDocument(doc);
1411 return doc;
1412 }
1413 }
1414 }
1415
1416
1417 // no, we need to create a new document
1418
1419
1420 // if we've reached the max number of docs, close the first one.
1421 if ( (int)GetDocuments().GetCount() >= m_maxDocsOpen )
1422 {
1423 if ( !CloseDocument((wxDocument *)GetDocuments().GetFirst()->GetData()) )
1424 {
1425 // can't open the new document if closing the old one failed
1426 return NULL;
1427 }
1428 }
1429
1430
1431 // do create and initialize the new document finally
1432 wxDocument * const docNew = temp->CreateDocument(path, flags);
1433 if ( !docNew )
1434 return NULL;
1435
1436 docNew->SetDocumentName(temp->GetDocumentName());
1437 docNew->SetDocumentTemplate(temp);
1438
1439 wxTRY
1440 {
1441 // call the appropriate function depending on whether we're creating a
1442 // new file or opening an existing one
1443 if ( !(flags & wxDOC_NEW ? docNew->OnNewDocument()
1444 : docNew->OnOpenDocument(path)) )
1445 {
1446 docNew->DeleteAllViews();
1447 return NULL;
1448 }
1449 }
1450 wxCATCH_ALL( docNew->DeleteAllViews(); throw; )
1451
1452 // add the successfully opened file to MRU, but only if we're going to be
1453 // able to reopen it successfully later which requires the template for
1454 // this document to be retrievable from the file extension
1455 if ( !(flags & wxDOC_NEW) && temp->FileMatchesTemplate(path) )
1456 AddFileToHistory(path);
1457
1458 // at least under Mac (where views are top level windows) it seems to be
1459 // necessary to manually activate the new document to bring it to the
1460 // forefront -- and it shouldn't hurt doing this under the other platforms
1461 ActivateDocument(docNew);
1462
1463 return docNew;
1464 }
1465
1466 wxView *wxDocManager::CreateView(wxDocument *doc, long flags)
1467 {
1468 wxDocTemplates templates(GetVisibleTemplates(m_templates));
1469 const size_t numTemplates = templates.size();
1470
1471 if ( numTemplates == 0 )
1472 return NULL;
1473
1474 wxDocTemplate * const
1475 temp = numTemplates == 1 ? templates[0]
1476 : SelectViewType(&templates[0], numTemplates);
1477
1478 if ( !temp )
1479 return NULL;
1480
1481 wxView *view = temp->CreateView(doc, flags);
1482 if ( view )
1483 view->SetViewName(temp->GetViewName());
1484 return view;
1485 }
1486
1487 // Not yet implemented
1488 void
1489 wxDocManager::DeleteTemplate(wxDocTemplate *WXUNUSED(temp), long WXUNUSED(flags))
1490 {
1491 }
1492
1493 // Not yet implemented
1494 bool wxDocManager::FlushDoc(wxDocument *WXUNUSED(doc))
1495 {
1496 return false;
1497 }
1498
1499 wxDocument *wxDocManager::GetCurrentDocument() const
1500 {
1501 wxView * const view = GetActiveView();
1502 return view ? view->GetDocument() : NULL;
1503 }
1504
1505 wxCommandProcessor *wxDocManager::GetCurrentCommandProcessor() const
1506 {
1507 wxDocument * const doc = GetCurrentDocument();
1508 return doc ? doc->GetCommandProcessor() : NULL;
1509 }
1510
1511 // Make a default name for a new document
1512 #if WXWIN_COMPATIBILITY_2_8
1513 bool wxDocManager::MakeDefaultName(wxString& WXUNUSED(name))
1514 {
1515 // we consider that this function can only be overridden by the user code,
1516 // not called by it as it only makes sense to call it internally, so we
1517 // don't bother to return anything from here
1518 return false;
1519 }
1520 #endif // WXWIN_COMPATIBILITY_2_8
1521
1522 wxString wxDocManager::MakeNewDocumentName()
1523 {
1524 wxString name;
1525
1526 #if WXWIN_COMPATIBILITY_2_8
1527 if ( !MakeDefaultName(name) )
1528 #endif // WXWIN_COMPATIBILITY_2_8
1529 {
1530 name.Printf(_("unnamed%d"), m_defaultDocumentNameCounter);
1531 m_defaultDocumentNameCounter++;
1532 }
1533
1534 return name;
1535 }
1536
1537 // Make a frame title (override this to do something different)
1538 // If docName is empty, a document is not currently active.
1539 wxString wxDocManager::MakeFrameTitle(wxDocument* doc)
1540 {
1541 wxString appName = wxTheApp->GetAppDisplayName();
1542 wxString title;
1543 if (!doc)
1544 title = appName;
1545 else
1546 {
1547 wxString docName = doc->GetUserReadableName();
1548 title = docName + wxString(_(" - ")) + appName;
1549 }
1550 return title;
1551 }
1552
1553
1554 // Not yet implemented
1555 wxDocTemplate *wxDocManager::MatchTemplate(const wxString& WXUNUSED(path))
1556 {
1557 return NULL;
1558 }
1559
1560 // File history management
1561 void wxDocManager::AddFileToHistory(const wxString& file)
1562 {
1563 if (m_fileHistory)
1564 m_fileHistory->AddFileToHistory(file);
1565 }
1566
1567 void wxDocManager::RemoveFileFromHistory(size_t i)
1568 {
1569 if (m_fileHistory)
1570 m_fileHistory->RemoveFileFromHistory(i);
1571 }
1572
1573 wxString wxDocManager::GetHistoryFile(size_t i) const
1574 {
1575 wxString histFile;
1576
1577 if (m_fileHistory)
1578 histFile = m_fileHistory->GetHistoryFile(i);
1579
1580 return histFile;
1581 }
1582
1583 void wxDocManager::FileHistoryUseMenu(wxMenu *menu)
1584 {
1585 if (m_fileHistory)
1586 m_fileHistory->UseMenu(menu);
1587 }
1588
1589 void wxDocManager::FileHistoryRemoveMenu(wxMenu *menu)
1590 {
1591 if (m_fileHistory)
1592 m_fileHistory->RemoveMenu(menu);
1593 }
1594
1595 #if wxUSE_CONFIG
1596 void wxDocManager::FileHistoryLoad(const wxConfigBase& config)
1597 {
1598 if (m_fileHistory)
1599 m_fileHistory->Load(config);
1600 }
1601
1602 void wxDocManager::FileHistorySave(wxConfigBase& config)
1603 {
1604 if (m_fileHistory)
1605 m_fileHistory->Save(config);
1606 }
1607 #endif
1608
1609 void wxDocManager::FileHistoryAddFilesToMenu(wxMenu* menu)
1610 {
1611 if (m_fileHistory)
1612 m_fileHistory->AddFilesToMenu(menu);
1613 }
1614
1615 void wxDocManager::FileHistoryAddFilesToMenu()
1616 {
1617 if (m_fileHistory)
1618 m_fileHistory->AddFilesToMenu();
1619 }
1620
1621 size_t wxDocManager::GetHistoryFilesCount() const
1622 {
1623 return m_fileHistory ? m_fileHistory->GetCount() : 0;
1624 }
1625
1626
1627 // Find out the document template via matching in the document file format
1628 // against that of the template
1629 wxDocTemplate *wxDocManager::FindTemplateForPath(const wxString& path)
1630 {
1631 wxDocTemplate *theTemplate = NULL;
1632
1633 // Find the template which this extension corresponds to
1634 for (size_t i = 0; i < m_templates.GetCount(); i++)
1635 {
1636 wxDocTemplate *temp = (wxDocTemplate *)m_templates.Item(i)->GetData();
1637 if ( temp->FileMatchesTemplate(path) )
1638 {
1639 theTemplate = temp;
1640 break;
1641 }
1642 }
1643 return theTemplate;
1644 }
1645
1646 // Prompts user to open a file, using file specs in templates.
1647 // Must extend the file selector dialog or implement own; OR
1648 // match the extension to the template extension.
1649
1650 wxDocTemplate *wxDocManager::SelectDocumentPath(wxDocTemplate **templates,
1651 int noTemplates,
1652 wxString& path,
1653 long WXUNUSED(flags),
1654 bool WXUNUSED(save))
1655 {
1656 #ifdef wxHAS_MULTIPLE_FILEDLG_FILTERS
1657 wxString descrBuf;
1658
1659 for (int i = 0; i < noTemplates; i++)
1660 {
1661 if (templates[i]->IsVisible())
1662 {
1663 // add a '|' to separate this filter from the previous one
1664 if ( !descrBuf.empty() )
1665 descrBuf << wxT('|');
1666
1667 descrBuf << templates[i]->GetDescription()
1668 << wxT(" (") << templates[i]->GetFileFilter() << wxT(") |")
1669 << templates[i]->GetFileFilter();
1670 }
1671 }
1672 #else
1673 wxString descrBuf = wxT("*.*");
1674 wxUnusedVar(noTemplates);
1675 #endif
1676
1677 int FilterIndex = -1;
1678
1679 wxString pathTmp = wxFileSelectorEx(_("Open File"),
1680 GetLastDirectory(),
1681 wxEmptyString,
1682 &FilterIndex,
1683 descrBuf,
1684 wxFD_OPEN | wxFD_FILE_MUST_EXIST);
1685
1686 wxDocTemplate *theTemplate = NULL;
1687 if (!pathTmp.empty())
1688 {
1689 if (!wxFileExists(pathTmp))
1690 {
1691 wxString msgTitle;
1692 if (!wxTheApp->GetAppDisplayName().empty())
1693 msgTitle = wxTheApp->GetAppDisplayName();
1694 else
1695 msgTitle = wxString(_("File error"));
1696
1697 wxMessageBox(_("Sorry, could not open this file."),
1698 msgTitle,
1699 wxOK | wxICON_EXCLAMATION | wxCENTRE);
1700
1701 path = wxEmptyString;
1702 return NULL;
1703 }
1704
1705 SetLastDirectory(wxPathOnly(pathTmp));
1706
1707 path = pathTmp;
1708
1709 // first choose the template using the extension, if this fails (i.e.
1710 // wxFileSelectorEx() didn't fill it), then use the path
1711 if ( FilterIndex != -1 )
1712 theTemplate = templates[FilterIndex];
1713 if ( !theTemplate )
1714 theTemplate = FindTemplateForPath(path);
1715 if ( !theTemplate )
1716 {
1717 // Since we do not add files with non-default extensions to the
1718 // file history this can only happen if the application changes the
1719 // allowed templates in runtime.
1720 wxMessageBox(_("Sorry, the format for this file is unknown."),
1721 _("Open File"),
1722 wxOK | wxICON_EXCLAMATION | wxCENTRE);
1723 }
1724 }
1725 else
1726 {
1727 path.clear();
1728 }
1729
1730 return theTemplate;
1731 }
1732
1733 wxDocTemplate *wxDocManager::SelectDocumentType(wxDocTemplate **templates,
1734 int noTemplates, bool sort)
1735 {
1736 wxArrayString strings;
1737 wxScopedArray<wxDocTemplate *> data(new wxDocTemplate *[noTemplates]);
1738 int i;
1739 int n = 0;
1740
1741 for (i = 0; i < noTemplates; i++)
1742 {
1743 if (templates[i]->IsVisible())
1744 {
1745 int j;
1746 bool want = true;
1747 for (j = 0; j < n; j++)
1748 {
1749 //filter out NOT unique documents + view combinations
1750 if ( templates[i]->m_docTypeName == data[j]->m_docTypeName &&
1751 templates[i]->m_viewTypeName == data[j]->m_viewTypeName
1752 )
1753 want = false;
1754 }
1755
1756 if ( want )
1757 {
1758 strings.Add(templates[i]->m_description);
1759
1760 data[n] = templates[i];
1761 n ++;
1762 }
1763 }
1764 } // for
1765
1766 if (sort)
1767 {
1768 strings.Sort(); // ascending sort
1769 // Yes, this will be slow, but template lists
1770 // are typically short.
1771 int j;
1772 n = strings.Count();
1773 for (i = 0; i < n; i++)
1774 {
1775 for (j = 0; j < noTemplates; j++)
1776 {
1777 if (strings[i] == templates[j]->m_description)
1778 data[i] = templates[j];
1779 }
1780 }
1781 }
1782
1783 wxDocTemplate *theTemplate;
1784
1785 switch ( n )
1786 {
1787 case 0:
1788 // no visible templates, hence nothing to choose from
1789 theTemplate = NULL;
1790 break;
1791
1792 case 1:
1793 // don't propose the user to choose if he has no choice
1794 theTemplate = data[0];
1795 break;
1796
1797 default:
1798 // propose the user to choose one of several
1799 theTemplate = (wxDocTemplate *)wxGetSingleChoiceData
1800 (
1801 _("Select a document template"),
1802 _("Templates"),
1803 strings,
1804 (void **)data.get()
1805 );
1806 }
1807
1808 return theTemplate;
1809 }
1810
1811 wxDocTemplate *wxDocManager::SelectViewType(wxDocTemplate **templates,
1812 int noTemplates, bool sort)
1813 {
1814 wxArrayString strings;
1815 wxScopedArray<wxDocTemplate *> data(new wxDocTemplate *[noTemplates]);
1816 int i;
1817 int n = 0;
1818
1819 for (i = 0; i < noTemplates; i++)
1820 {
1821 wxDocTemplate *templ = templates[i];
1822 if ( templ->IsVisible() && !templ->GetViewName().empty() )
1823 {
1824 int j;
1825 bool want = true;
1826 for (j = 0; j < n; j++)
1827 {
1828 //filter out NOT unique views
1829 if ( templates[i]->m_viewTypeName == data[j]->m_viewTypeName )
1830 want = false;
1831 }
1832
1833 if ( want )
1834 {
1835 strings.Add(templ->m_viewTypeName);
1836 data[n] = templ;
1837 n ++;
1838 }
1839 }
1840 }
1841
1842 if (sort)
1843 {
1844 strings.Sort(); // ascending sort
1845 // Yes, this will be slow, but template lists
1846 // are typically short.
1847 int j;
1848 n = strings.Count();
1849 for (i = 0; i < n; i++)
1850 {
1851 for (j = 0; j < noTemplates; j++)
1852 {
1853 if (strings[i] == templates[j]->m_viewTypeName)
1854 data[i] = templates[j];
1855 }
1856 }
1857 }
1858
1859 wxDocTemplate *theTemplate;
1860
1861 // the same logic as above
1862 switch ( n )
1863 {
1864 case 0:
1865 theTemplate = NULL;
1866 break;
1867
1868 case 1:
1869 theTemplate = data[0];
1870 break;
1871
1872 default:
1873 theTemplate = (wxDocTemplate *)wxGetSingleChoiceData
1874 (
1875 _("Select a document view"),
1876 _("Views"),
1877 strings,
1878 (void **)data.get()
1879 );
1880
1881 }
1882
1883 return theTemplate;
1884 }
1885
1886 void wxDocManager::AssociateTemplate(wxDocTemplate *temp)
1887 {
1888 if (!m_templates.Member(temp))
1889 m_templates.Append(temp);
1890 }
1891
1892 void wxDocManager::DisassociateTemplate(wxDocTemplate *temp)
1893 {
1894 m_templates.DeleteObject(temp);
1895 }
1896
1897 wxDocTemplate* wxDocManager::FindTemplate(const wxClassInfo* classinfo)
1898 {
1899 for ( wxList::compatibility_iterator node = m_templates.GetFirst();
1900 node;
1901 node = node->GetNext() )
1902 {
1903 wxDocTemplate* t = wxStaticCast(node->GetData(), wxDocTemplate);
1904 if ( t->GetDocClassInfo() == classinfo )
1905 return t;
1906 }
1907
1908 return NULL;
1909 }
1910
1911 // Add and remove a document from the manager's list
1912 void wxDocManager::AddDocument(wxDocument *doc)
1913 {
1914 if (!m_docs.Member(doc))
1915 m_docs.Append(doc);
1916 }
1917
1918 void wxDocManager::RemoveDocument(wxDocument *doc)
1919 {
1920 m_docs.DeleteObject(doc);
1921 }
1922
1923 // Views or windows should inform the document manager
1924 // when a view is going in or out of focus
1925 void wxDocManager::ActivateView(wxView *view, bool activate)
1926 {
1927 if ( activate )
1928 {
1929 m_currentView = view;
1930 }
1931 else // deactivate
1932 {
1933 if ( m_currentView == view )
1934 {
1935 // don't keep stale pointer
1936 m_currentView = NULL;
1937 }
1938 }
1939 }
1940
1941 // ----------------------------------------------------------------------------
1942 // wxDocChildFrameAnyBase
1943 // ----------------------------------------------------------------------------
1944
1945 bool wxDocChildFrameAnyBase::CloseView(wxCloseEvent& event)
1946 {
1947 if ( m_childView )
1948 {
1949 // notice that we must call wxView::Close() and OnClose() called from
1950 // it in any case, even if we know that we are going to close anyhow
1951 if ( !m_childView->Close(false) && event.CanVeto() )
1952 {
1953 event.Veto();
1954 return false;
1955 }
1956
1957 m_childView->Activate(false);
1958
1959 // it is important to reset m_childView frame pointer to NULL before
1960 // deleting it because while normally it is the frame which deletes the
1961 // view when it's closed, the view also closes the frame if it is
1962 // deleted directly not by us as indicated by its doc child frame
1963 // pointer still being set
1964 m_childView->SetDocChildFrame(NULL);
1965 wxDELETE(m_childView);
1966 }
1967
1968 m_childDocument = NULL;
1969
1970 return true;
1971 }
1972
1973 // ----------------------------------------------------------------------------
1974 // wxDocParentFrameAnyBase
1975 // ----------------------------------------------------------------------------
1976
1977 #if wxUSE_PRINTING_ARCHITECTURE
1978
1979 wxDocPrintout::wxDocPrintout(wxView *view, const wxString& title)
1980 : wxPrintout(title)
1981 {
1982 m_printoutView = view;
1983 }
1984
1985 bool wxDocPrintout::OnPrintPage(int WXUNUSED(page))
1986 {
1987 wxDC *dc = GetDC();
1988
1989 // Get the logical pixels per inch of screen and printer
1990 int ppiScreenX, ppiScreenY;
1991 GetPPIScreen(&ppiScreenX, &ppiScreenY);
1992 wxUnusedVar(ppiScreenY);
1993 int ppiPrinterX, ppiPrinterY;
1994 GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
1995 wxUnusedVar(ppiPrinterY);
1996
1997 // This scales the DC so that the printout roughly represents the
1998 // the screen scaling. The text point size _should_ be the right size
1999 // but in fact is too small for some reason. This is a detail that will
2000 // need to be addressed at some point but can be fudged for the
2001 // moment.
2002 float scale = (float)((float)ppiPrinterX/(float)ppiScreenX);
2003
2004 // Now we have to check in case our real page size is reduced
2005 // (e.g. because we're drawing to a print preview memory DC)
2006 int pageWidth, pageHeight;
2007 int w, h;
2008 dc->GetSize(&w, &h);
2009 GetPageSizePixels(&pageWidth, &pageHeight);
2010 wxUnusedVar(pageHeight);
2011
2012 // If printer pageWidth == current DC width, then this doesn't
2013 // change. But w might be the preview bitmap width, so scale down.
2014 float overallScale = scale * (float)(w/(float)pageWidth);
2015 dc->SetUserScale(overallScale, overallScale);
2016
2017 if (m_printoutView)
2018 {
2019 m_printoutView->OnDraw(dc);
2020 }
2021 return true;
2022 }
2023
2024 bool wxDocPrintout::HasPage(int pageNum)
2025 {
2026 return (pageNum == 1);
2027 }
2028
2029 bool wxDocPrintout::OnBeginDocument(int startPage, int endPage)
2030 {
2031 if (!wxPrintout::OnBeginDocument(startPage, endPage))
2032 return false;
2033
2034 return true;
2035 }
2036
2037 void wxDocPrintout::GetPageInfo(int *minPage, int *maxPage,
2038 int *selPageFrom, int *selPageTo)
2039 {
2040 *minPage = 1;
2041 *maxPage = 1;
2042 *selPageFrom = 1;
2043 *selPageTo = 1;
2044 }
2045
2046 #endif // wxUSE_PRINTING_ARCHITECTURE
2047
2048 // ----------------------------------------------------------------------------
2049 // Permits compatibility with existing file formats and functions that
2050 // manipulate files directly
2051 // ----------------------------------------------------------------------------
2052
2053 #if wxUSE_STD_IOSTREAM
2054
2055 bool wxTransferFileToStream(const wxString& filename, wxSTD ostream& stream)
2056 {
2057 #if wxUSE_FFILE
2058 wxFFile file(filename, wxT("rb"));
2059 #elif wxUSE_FILE
2060 wxFile file(filename, wxFile::read);
2061 #endif
2062 if ( !file.IsOpened() )
2063 return false;
2064
2065 char buf[4096];
2066
2067 size_t nRead;
2068 do
2069 {
2070 nRead = file.Read(buf, WXSIZEOF(buf));
2071 if ( file.Error() )
2072 return false;
2073
2074 stream.write(buf, nRead);
2075 if ( !stream )
2076 return false;
2077 }
2078 while ( !file.Eof() );
2079
2080 return true;
2081 }
2082
2083 bool wxTransferStreamToFile(wxSTD istream& stream, const wxString& filename)
2084 {
2085 #if wxUSE_FFILE
2086 wxFFile file(filename, wxT("wb"));
2087 #elif wxUSE_FILE
2088 wxFile file(filename, wxFile::write);
2089 #endif
2090 if ( !file.IsOpened() )
2091 return false;
2092
2093 char buf[4096];
2094 do
2095 {
2096 stream.read(buf, WXSIZEOF(buf));
2097 if ( !stream.bad() ) // fail may be set on EOF, don't use operator!()
2098 {
2099 if ( !file.Write(buf, stream.gcount()) )
2100 return false;
2101 }
2102 }
2103 while ( !stream.eof() );
2104
2105 return true;
2106 }
2107
2108 #else // !wxUSE_STD_IOSTREAM
2109
2110 bool wxTransferFileToStream(const wxString& filename, wxOutputStream& stream)
2111 {
2112 #if wxUSE_FFILE
2113 wxFFile file(filename, wxT("rb"));
2114 #elif wxUSE_FILE
2115 wxFile file(filename, wxFile::read);
2116 #endif
2117 if ( !file.IsOpened() )
2118 return false;
2119
2120 char buf[4096];
2121
2122 size_t nRead;
2123 do
2124 {
2125 nRead = file.Read(buf, WXSIZEOF(buf));
2126 if ( file.Error() )
2127 return false;
2128
2129 stream.Write(buf, nRead);
2130 if ( !stream )
2131 return false;
2132 }
2133 while ( !file.Eof() );
2134
2135 return true;
2136 }
2137
2138 bool wxTransferStreamToFile(wxInputStream& stream, const wxString& filename)
2139 {
2140 #if wxUSE_FFILE
2141 wxFFile file(filename, wxT("wb"));
2142 #elif wxUSE_FILE
2143 wxFile file(filename, wxFile::write);
2144 #endif
2145 if ( !file.IsOpened() )
2146 return false;
2147
2148 char buf[4096];
2149 for ( ;; )
2150 {
2151 stream.Read(buf, WXSIZEOF(buf));
2152
2153 const size_t nRead = stream.LastRead();
2154 if ( !nRead )
2155 {
2156 if ( stream.Eof() )
2157 break;
2158
2159 return false;
2160 }
2161
2162 if ( !file.Write(buf, nRead) )
2163 return false;
2164 }
2165
2166 return true;
2167 }
2168
2169 #endif // wxUSE_STD_IOSTREAM/!wxUSE_STD_IOSTREAM
2170
2171 #endif // wxUSE_DOC_VIEW_ARCHITECTURE