]> git.saurik.com Git - wxWidgets.git/blob - src/common/docview.cpp
cleanup - reformat
[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:
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 #ifndef WX_PRECOMP
30 #include "wx/string.h"
31 #include "wx/utils.h"
32 #include "wx/app.h"
33 #include "wx/dc.h"
34 #include "wx/dialog.h"
35 #include "wx/menu.h"
36 #include "wx/list.h"
37 #include "wx/filedlg.h"
38 #include "wx/intl.h"
39 #include "wx/log.h"
40 #endif
41
42 #include "wx/ffile.h"
43
44 #ifdef __WXMAC__
45 #include "wx/filename.h"
46 #endif
47
48 #ifdef __WXGTK__
49 #include "wx/mdi.h"
50 #endif
51
52 #if wxUSE_PRINTING_ARCHITECTURE
53 #include "wx/prntbase.h"
54 #include "wx/printdlg.h"
55 #endif
56
57 #include "wx/msgdlg.h"
58 #include "wx/choicdlg.h"
59 #include "wx/docview.h"
60 #include "wx/confbase.h"
61 #include "wx/file.h"
62 #include "wx/cmdproc.h"
63
64 #include <stdio.h>
65 #include <string.h>
66
67 #if wxUSE_STD_IOSTREAM
68 #include "wx/ioswrap.h"
69 #if wxUSE_IOSTREAMH
70 #include <fstream.h>
71 #else
72 #include <fstream>
73 #endif
74 #else
75 #include "wx/wfstream.h"
76 #endif
77
78 // ----------------------------------------------------------------------------
79 // wxWidgets macros
80 // ----------------------------------------------------------------------------
81
82 IMPLEMENT_ABSTRACT_CLASS(wxDocument, wxEvtHandler)
83 IMPLEMENT_ABSTRACT_CLASS(wxView, wxEvtHandler)
84 IMPLEMENT_ABSTRACT_CLASS(wxDocTemplate, wxObject)
85 IMPLEMENT_DYNAMIC_CLASS(wxDocManager, wxEvtHandler)
86 IMPLEMENT_CLASS(wxDocChildFrame, wxFrame)
87 IMPLEMENT_CLASS(wxDocParentFrame, wxFrame)
88
89 #if wxUSE_PRINTING_ARCHITECTURE
90 IMPLEMENT_DYNAMIC_CLASS(wxDocPrintout, wxPrintout)
91 #endif
92
93 IMPLEMENT_DYNAMIC_CLASS(wxFileHistory, wxObject)
94
95 // ----------------------------------------------------------------------------
96 // function prototypes
97 // ----------------------------------------------------------------------------
98
99 static inline wxString FindExtension(const wxChar *path);
100 static wxWindow* wxFindSuitableParent(void);
101
102 // ----------------------------------------------------------------------------
103 // local constants
104 // ----------------------------------------------------------------------------
105
106 static const wxChar *s_MRUEntryFormat = wxT("&%d %s");
107
108 // ============================================================================
109 // implementation
110 // ============================================================================
111
112 // ----------------------------------------------------------------------------
113 // local functions
114 // ----------------------------------------------------------------------------
115
116 static wxString FindExtension(const wxChar *path)
117 {
118 wxString ext;
119 wxSplitPath(path, NULL, NULL, &ext);
120
121 // VZ: extensions are considered not case sensitive - is this really a good
122 // idea?
123 return ext.MakeLower();
124 }
125
126 // ----------------------------------------------------------------------------
127 // Definition of wxDocument
128 // ----------------------------------------------------------------------------
129
130 wxDocument::wxDocument(wxDocument *parent)
131 {
132 m_documentModified = false;
133 m_documentParent = parent;
134 m_documentTemplate = (wxDocTemplate *) NULL;
135 m_commandProcessor = (wxCommandProcessor*) NULL;
136 m_savedYet = false;
137 }
138
139 bool wxDocument::DeleteContents()
140 {
141 return true;
142 }
143
144 wxDocument::~wxDocument()
145 {
146 DeleteContents();
147
148 if (m_commandProcessor)
149 delete m_commandProcessor;
150
151 if (GetDocumentManager())
152 GetDocumentManager()->RemoveDocument(this);
153
154 // Not safe to do here, since it'll invoke virtual view functions
155 // expecting to see valid derived objects: and by the time we get here,
156 // we've called destructors higher up.
157 //DeleteAllViews();
158 }
159
160 bool wxDocument::Close()
161 {
162 if (OnSaveModified())
163 return OnCloseDocument();
164 else
165 return false;
166 }
167
168 bool wxDocument::OnCloseDocument()
169 {
170 // Tell all views that we're about to close
171 NotifyClosing();
172 DeleteContents();
173 Modify(false);
174 return true;
175 }
176
177 // Note that this implicitly deletes the document when the last view is
178 // deleted.
179 bool wxDocument::DeleteAllViews()
180 {
181 wxDocManager* manager = GetDocumentManager();
182
183 // first check if all views agree to be closed
184 const wxList::iterator end = m_documentViews.end();
185 for ( wxList::iterator i = m_documentViews.begin(); i != end; ++i )
186 {
187 wxView *view = (wxView *)*i;
188 if ( !view->Close() )
189 return false;
190 }
191
192 // all views agreed to close, now do close them
193 if ( m_documentViews.empty() )
194 {
195 // normally the document would be implicitly deleted when the last view
196 // is, but if don't have any views, do it here instead
197 if ( manager && manager->GetDocuments().Member(this) )
198 delete this;
199 }
200 else // have views
201 {
202 // as we delete elements we iterate over, don't use the usual "from
203 // begin to end" loop
204 for ( ;; )
205 {
206 wxView *view = (wxView *)*m_documentViews.begin();
207
208 bool isLastOne = m_documentViews.size() == 1;
209
210 // this always deletes the node implicitly and if this is the last
211 // view also deletes this object itself (also implicitly, great),
212 // so we can't test for m_documentViews.empty() after calling this!
213 delete view;
214
215 if ( isLastOne )
216 break;
217 }
218 }
219
220 return true;
221 }
222
223 wxView *wxDocument::GetFirstView() const
224 {
225 if (m_documentViews.GetCount() == 0)
226 return (wxView *) NULL;
227 return (wxView *)m_documentViews.GetFirst()->GetData();
228 }
229
230 wxDocManager *wxDocument::GetDocumentManager() const
231 {
232 return (m_documentTemplate ? m_documentTemplate->GetDocumentManager() : (wxDocManager*) NULL);
233 }
234
235 bool wxDocument::OnNewDocument()
236 {
237 if (!OnSaveModified())
238 return false;
239
240 if (OnCloseDocument()==false) return false;
241 DeleteContents();
242 Modify(false);
243 SetDocumentSaved(false);
244
245 wxString name;
246 GetDocumentManager()->MakeDefaultName(name);
247 SetTitle(name);
248 SetFilename(name, true);
249
250 return true;
251 }
252
253 bool wxDocument::Save()
254 {
255 if (!IsModified() && m_savedYet)
256 return true;
257
258 if ( m_documentFile.empty() || !m_savedYet )
259 return SaveAs();
260
261 return OnSaveDocument(m_documentFile);
262 }
263
264 bool wxDocument::SaveAs()
265 {
266 wxDocTemplate *docTemplate = GetDocumentTemplate();
267 if (!docTemplate)
268 return false;
269
270 #if defined(__WXMSW__) || defined(__WXGTK__) || defined(__WXMAC__)
271 wxString filter = docTemplate->GetDescription() + wxT(" (") + docTemplate->GetFileFilter() + wxT(")|") + docTemplate->GetFileFilter();
272
273 // Now see if there are some other template with identical view and document
274 // classes, whose filters may also be used.
275
276 if (docTemplate->GetViewClassInfo() && docTemplate->GetDocClassInfo())
277 {
278 wxList::compatibility_iterator node = wxDocManager::GetDocumentManager()->GetTemplates().GetFirst();
279 while (node)
280 {
281 wxDocTemplate *t = (wxDocTemplate*) node->GetData();
282
283 if (t->IsVisible() && t != docTemplate &&
284 t->GetViewClassInfo() == docTemplate->GetViewClassInfo() &&
285 t->GetDocClassInfo() == docTemplate->GetDocClassInfo())
286 {
287 // add a '|' to separate this filter from the previous one
288 if ( !filter.empty() )
289 filter << wxT('|');
290
291 filter << t->GetDescription() << wxT(" (") << t->GetFileFilter() << wxT(") |")
292 << t->GetFileFilter();
293 }
294
295 node = node->GetNext();
296 }
297 }
298 #else
299 wxString filter = docTemplate->GetFileFilter() ;
300 #endif
301 wxString tmp = wxFileSelector(_("Save as"),
302 docTemplate->GetDirectory(),
303 wxFileNameFromPath(GetFilename()),
304 docTemplate->GetDefaultExtension(),
305 filter,
306 wxSAVE | wxOVERWRITE_PROMPT,
307 GetDocumentWindow());
308
309 if (tmp.empty())
310 return false;
311
312 wxString fileName(tmp);
313 wxString path, name, ext;
314 wxSplitPath(fileName, & path, & name, & ext);
315
316 if (ext.empty())
317 {
318 fileName += wxT(".");
319 fileName += docTemplate->GetDefaultExtension();
320 }
321
322 SetFilename(fileName);
323 SetTitle(wxFileNameFromPath(fileName));
324
325 // Notify the views that the filename has changed
326 wxList::compatibility_iterator node = m_documentViews.GetFirst();
327 while (node)
328 {
329 wxView *view = (wxView *)node->GetData();
330 view->OnChangeFilename();
331 node = node->GetNext();
332 }
333
334 // Files that were not saved correctly are not added to the FileHistory.
335 if (!OnSaveDocument(m_documentFile))
336 return false;
337
338 // A file that doesn't use the default extension of its document template cannot be opened
339 // via the FileHistory, so we do not add it.
340 if (docTemplate->FileMatchesTemplate(fileName))
341 {
342 GetDocumentManager()->AddFileToHistory(fileName);
343 }
344 else
345 {
346 // The user will probably not be able to open the file again, so
347 // we could warn about the wrong file-extension here.
348 }
349 return true;
350 }
351
352 bool wxDocument::OnSaveDocument(const wxString& file)
353 {
354 if ( !file )
355 return false;
356
357 if ( !DoSaveDocument(file) )
358 return false;
359
360 Modify(false);
361 SetFilename(file);
362 SetDocumentSaved(true);
363 #ifdef __WXMAC__
364 wxFileName fn(file) ;
365 fn.MacSetDefaultTypeAndCreator() ;
366 #endif
367 return true;
368 }
369
370 bool wxDocument::OnOpenDocument(const wxString& file)
371 {
372 if (!OnSaveModified())
373 return false;
374
375 if ( !DoOpenDocument(file) )
376 return false;
377
378 SetFilename(file, true);
379 Modify(false);
380 m_savedYet = true;
381
382 UpdateAllViews();
383
384 return true;
385 }
386
387 #if wxUSE_STD_IOSTREAM
388 wxSTD istream& wxDocument::LoadObject(wxSTD istream& stream)
389 #else
390 wxInputStream& wxDocument::LoadObject(wxInputStream& stream)
391 #endif
392 {
393 return stream;
394 }
395
396 #if wxUSE_STD_IOSTREAM
397 wxSTD ostream& wxDocument::SaveObject(wxSTD ostream& stream)
398 #else
399 wxOutputStream& wxDocument::SaveObject(wxOutputStream& stream)
400 #endif
401 {
402 return stream;
403 }
404
405 bool wxDocument::Revert()
406 {
407 return false;
408 }
409
410
411 // Get title, or filename if no title, else unnamed
412 bool wxDocument::GetPrintableName(wxString& buf) const
413 {
414 if (!m_documentTitle.empty())
415 {
416 buf = m_documentTitle;
417 return true;
418 }
419 else if (!m_documentFile.empty())
420 {
421 buf = wxFileNameFromPath(m_documentFile);
422 return true;
423 }
424 else
425 {
426 buf = _("unnamed");
427 return true;
428 }
429 }
430
431 wxWindow *wxDocument::GetDocumentWindow() const
432 {
433 wxView *view = GetFirstView();
434 if (view)
435 return view->GetFrame();
436 else
437 return wxTheApp->GetTopWindow();
438 }
439
440 wxCommandProcessor *wxDocument::OnCreateCommandProcessor()
441 {
442 return new wxCommandProcessor;
443 }
444
445 // true if safe to close
446 bool wxDocument::OnSaveModified()
447 {
448 if (IsModified())
449 {
450 wxString title;
451 GetPrintableName(title);
452
453 wxString msgTitle;
454 if (!wxTheApp->GetAppName().empty())
455 msgTitle = wxTheApp->GetAppName();
456 else
457 msgTitle = wxString(_("Warning"));
458
459 wxString prompt;
460 prompt.Printf(_("Do you want to save changes to document %s?"),
461 (const wxChar *)title);
462 int res = wxMessageBox(prompt, msgTitle,
463 wxYES_NO|wxCANCEL|wxICON_QUESTION,
464 GetDocumentWindow());
465 if (res == wxNO)
466 {
467 Modify(false);
468 return true;
469 }
470 else if (res == wxYES)
471 return Save();
472 else if (res == wxCANCEL)
473 return false;
474 }
475 return true;
476 }
477
478 bool wxDocument::Draw(wxDC& WXUNUSED(context))
479 {
480 return true;
481 }
482
483 bool wxDocument::AddView(wxView *view)
484 {
485 if (!m_documentViews.Member(view))
486 {
487 m_documentViews.Append(view);
488 OnChangedViewList();
489 }
490 return true;
491 }
492
493 bool wxDocument::RemoveView(wxView *view)
494 {
495 (void)m_documentViews.DeleteObject(view);
496 OnChangedViewList();
497 return true;
498 }
499
500 bool wxDocument::OnCreate(const wxString& WXUNUSED(path), long flags)
501 {
502 if (GetDocumentTemplate()->CreateView(this, flags))
503 return true;
504 else
505 return false;
506 }
507
508 // Called after a view is added or removed.
509 // The default implementation deletes the document if
510 // there are no more views.
511 void wxDocument::OnChangedViewList()
512 {
513 if (m_documentViews.GetCount() == 0)
514 {
515 if (OnSaveModified())
516 {
517 delete this;
518 }
519 }
520 }
521
522 void wxDocument::UpdateAllViews(wxView *sender, wxObject *hint)
523 {
524 wxList::compatibility_iterator node = m_documentViews.GetFirst();
525 while (node)
526 {
527 wxView *view = (wxView *)node->GetData();
528 if (view != sender)
529 view->OnUpdate(sender, hint);
530 node = node->GetNext();
531 }
532 }
533
534 void wxDocument::NotifyClosing()
535 {
536 wxList::compatibility_iterator node = m_documentViews.GetFirst();
537 while (node)
538 {
539 wxView *view = (wxView *)node->GetData();
540 view->OnClosingDocument();
541 node = node->GetNext();
542 }
543 }
544
545 void wxDocument::SetFilename(const wxString& filename, bool notifyViews)
546 {
547 m_documentFile = filename;
548 if ( notifyViews )
549 {
550 // Notify the views that the filename has changed
551 wxList::compatibility_iterator node = m_documentViews.GetFirst();
552 while (node)
553 {
554 wxView *view = (wxView *)node->GetData();
555 view->OnChangeFilename();
556 node = node->GetNext();
557 }
558 }
559 }
560
561 bool wxDocument::DoSaveDocument(const wxString& file)
562 {
563 wxString msgTitle;
564 if (!wxTheApp->GetAppName().empty())
565 msgTitle = wxTheApp->GetAppName();
566 else
567 msgTitle = wxString(_("File error"));
568
569 #if wxUSE_STD_IOSTREAM
570 wxSTD ofstream store(file.mb_str(), wxSTD ios::binary);
571 if (store.fail() || store.bad())
572 #else
573 wxFileOutputStream store(file);
574 if (store.GetLastError() != wxSTREAM_NO_ERROR)
575 #endif
576 {
577 (void)wxMessageBox(_("Sorry, could not open this file for saving."), msgTitle, wxOK | wxICON_EXCLAMATION,
578 GetDocumentWindow());
579 // Saving error
580 return false;
581 }
582 if (!SaveObject(store))
583 {
584 (void)wxMessageBox(_("Sorry, could not save this file."), msgTitle, wxOK | wxICON_EXCLAMATION,
585 GetDocumentWindow());
586 // Saving error
587 return false;
588 }
589
590 return true;
591 }
592
593 bool wxDocument::DoOpenDocument(const wxString& file)
594 {
595 #if wxUSE_STD_IOSTREAM
596 wxSTD ifstream store(file.mb_str(), wxSTD ios::binary);
597 if (!store.fail() && !store.bad())
598 #else
599 wxFileInputStream store(file);
600 if (store.GetLastError() == wxSTREAM_NO_ERROR)
601 #endif
602 {
603 #if wxUSE_STD_IOSTREAM
604 LoadObject(store);
605 if ( !!store || store.eof() )
606 #else
607 int res = LoadObject(store).GetLastError();
608 if ( res == wxSTREAM_NO_ERROR || res == wxSTREAM_EOF )
609 #endif
610 return true;
611 }
612
613 wxLogError(_("Sorry, could not open this file."));
614 return false;
615 }
616
617
618 // ----------------------------------------------------------------------------
619 // Document view
620 // ----------------------------------------------------------------------------
621
622 wxView::wxView()
623 {
624 m_viewDocument = (wxDocument*) NULL;
625
626 m_viewFrame = (wxFrame *) NULL;
627 }
628
629 wxView::~wxView()
630 {
631 GetDocumentManager()->ActivateView(this, false);
632 m_viewDocument->RemoveView(this);
633 }
634
635 // Extend event processing to search the document's event table
636 bool wxView::ProcessEvent(wxEvent& event)
637 {
638 if ( !GetDocument() || !GetDocument()->ProcessEvent(event) )
639 return wxEvtHandler::ProcessEvent(event);
640
641 return true;
642 }
643
644 void wxView::OnActivateView(bool WXUNUSED(activate), wxView *WXUNUSED(activeView), wxView *WXUNUSED(deactiveView))
645 {
646 }
647
648 void wxView::OnPrint(wxDC *dc, wxObject *WXUNUSED(info))
649 {
650 OnDraw(dc);
651 }
652
653 void wxView::OnUpdate(wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint))
654 {
655 }
656
657 void wxView::OnChangeFilename()
658 {
659 // GetFrame can return wxWindow rather than wxTopLevelWindow due to
660 // generic MDI implementation so use SetLabel rather than SetTitle.
661 // It should cause SetTitle() for top level windows.
662 wxWindow *win = GetFrame();
663 if (!win) return;
664
665 wxDocument *doc = GetDocument();
666 if (!doc) return;
667
668 wxString name;
669 doc->GetPrintableName(name);
670 win->SetLabel(name);
671 }
672
673 void wxView::SetDocument(wxDocument *doc)
674 {
675 m_viewDocument = doc;
676 if (doc)
677 doc->AddView(this);
678 }
679
680 bool wxView::Close(bool deleteWindow)
681 {
682 if (OnClose(deleteWindow))
683 return true;
684 else
685 return false;
686 }
687
688 void wxView::Activate(bool activate)
689 {
690 if (GetDocument() && GetDocumentManager())
691 {
692 OnActivateView(activate, this, GetDocumentManager()->GetCurrentView());
693 GetDocumentManager()->ActivateView(this, activate);
694 }
695 }
696
697 bool wxView::OnClose(bool WXUNUSED(deleteWindow))
698 {
699 return GetDocument() ? GetDocument()->Close() : true;
700 }
701
702 #if wxUSE_PRINTING_ARCHITECTURE
703 wxPrintout *wxView::OnCreatePrintout()
704 {
705 return new wxDocPrintout(this);
706 }
707 #endif // wxUSE_PRINTING_ARCHITECTURE
708
709 // ----------------------------------------------------------------------------
710 // wxDocTemplate
711 // ----------------------------------------------------------------------------
712
713 wxDocTemplate::wxDocTemplate(wxDocManager *manager,
714 const wxString& descr,
715 const wxString& filter,
716 const wxString& dir,
717 const wxString& ext,
718 const wxString& docTypeName,
719 const wxString& viewTypeName,
720 wxClassInfo *docClassInfo,
721 wxClassInfo *viewClassInfo,
722 long flags)
723 {
724 m_documentManager = manager;
725 m_description = descr;
726 m_directory = dir;
727 m_defaultExt = ext;
728 m_fileFilter = filter;
729 m_flags = flags;
730 m_docTypeName = docTypeName;
731 m_viewTypeName = viewTypeName;
732 m_documentManager->AssociateTemplate(this);
733
734 m_docClassInfo = docClassInfo;
735 m_viewClassInfo = viewClassInfo;
736 }
737
738 wxDocTemplate::~wxDocTemplate()
739 {
740 m_documentManager->DisassociateTemplate(this);
741 }
742
743 // Tries to dynamically construct an object of the right class.
744 wxDocument *wxDocTemplate::CreateDocument(const wxString& path, long flags)
745 {
746 wxDocument *doc = DoCreateDocument();
747 if ( doc == NULL )
748 return (wxDocument *) NULL;
749
750 if (InitDocument(doc, path, flags))
751 {
752 return doc;
753 }
754 else
755 {
756 return (wxDocument *) NULL;
757 }
758 }
759
760 bool wxDocTemplate::InitDocument(wxDocument* doc, const wxString& path, long flags)
761 {
762 doc->SetFilename(path);
763 doc->SetDocumentTemplate(this);
764 GetDocumentManager()->AddDocument(doc);
765 doc->SetCommandProcessor(doc->OnCreateCommandProcessor());
766
767 if (doc->OnCreate(path, flags))
768 return true;
769 else
770 {
771 if (GetDocumentManager()->GetDocuments().Member(doc))
772 doc->DeleteAllViews();
773 return false;
774 }
775 }
776
777 wxView *wxDocTemplate::CreateView(wxDocument *doc, long flags)
778 {
779 wxView *view = DoCreateView();
780 if ( view == NULL )
781 return (wxView *) NULL;
782
783 view->SetDocument(doc);
784 if (view->OnCreate(doc, flags))
785 {
786 return view;
787 }
788 else
789 {
790 delete view;
791 return (wxView *) NULL;
792 }
793 }
794
795 // The default (very primitive) format detection: check is the extension is
796 // that of the template
797 bool wxDocTemplate::FileMatchesTemplate(const wxString& path)
798 {
799 return GetDefaultExtension().IsSameAs(FindExtension(path));
800 }
801
802 wxDocument *wxDocTemplate::DoCreateDocument()
803 {
804 if (!m_docClassInfo)
805 return (wxDocument *) NULL;
806
807 return (wxDocument *)m_docClassInfo->CreateObject();
808 }
809
810 wxView *wxDocTemplate::DoCreateView()
811 {
812 if (!m_viewClassInfo)
813 return (wxView *) NULL;
814
815 return (wxView *)m_viewClassInfo->CreateObject();
816 }
817
818 // ----------------------------------------------------------------------------
819 // wxDocManager
820 // ----------------------------------------------------------------------------
821
822 BEGIN_EVENT_TABLE(wxDocManager, wxEvtHandler)
823 EVT_MENU(wxID_OPEN, wxDocManager::OnFileOpen)
824 EVT_MENU(wxID_CLOSE, wxDocManager::OnFileClose)
825 EVT_MENU(wxID_CLOSE_ALL, wxDocManager::OnFileCloseAll)
826 EVT_MENU(wxID_REVERT, wxDocManager::OnFileRevert)
827 EVT_MENU(wxID_NEW, wxDocManager::OnFileNew)
828 EVT_MENU(wxID_SAVE, wxDocManager::OnFileSave)
829 EVT_MENU(wxID_SAVEAS, wxDocManager::OnFileSaveAs)
830 EVT_MENU(wxID_UNDO, wxDocManager::OnUndo)
831 EVT_MENU(wxID_REDO, wxDocManager::OnRedo)
832
833 EVT_UPDATE_UI(wxID_OPEN, wxDocManager::OnUpdateFileOpen)
834 EVT_UPDATE_UI(wxID_CLOSE, wxDocManager::OnUpdateFileClose)
835 EVT_UPDATE_UI(wxID_CLOSE_ALL, wxDocManager::OnUpdateFileClose)
836 EVT_UPDATE_UI(wxID_REVERT, wxDocManager::OnUpdateFileRevert)
837 EVT_UPDATE_UI(wxID_NEW, wxDocManager::OnUpdateFileNew)
838 EVT_UPDATE_UI(wxID_SAVE, wxDocManager::OnUpdateFileSave)
839 EVT_UPDATE_UI(wxID_SAVEAS, wxDocManager::OnUpdateFileSaveAs)
840 EVT_UPDATE_UI(wxID_UNDO, wxDocManager::OnUpdateUndo)
841 EVT_UPDATE_UI(wxID_REDO, wxDocManager::OnUpdateRedo)
842
843 #if wxUSE_PRINTING_ARCHITECTURE
844 EVT_MENU(wxID_PRINT, wxDocManager::OnPrint)
845 EVT_MENU(wxID_PREVIEW, wxDocManager::OnPreview)
846
847 EVT_UPDATE_UI(wxID_PRINT, wxDocManager::OnUpdatePrint)
848 EVT_UPDATE_UI(wxID_PREVIEW, wxDocManager::OnUpdatePreview)
849 #endif
850 END_EVENT_TABLE()
851
852 wxDocManager* wxDocManager::sm_docManager = (wxDocManager*) NULL;
853
854 wxDocManager::wxDocManager(long flags, bool initialize)
855 {
856 m_defaultDocumentNameCounter = 1;
857 m_flags = flags;
858 m_currentView = (wxView *) NULL;
859 m_maxDocsOpen = 10000;
860 m_fileHistory = (wxFileHistory *) NULL;
861 if (initialize)
862 Initialize();
863 sm_docManager = this;
864 }
865
866 wxDocManager::~wxDocManager()
867 {
868 Clear();
869 if (m_fileHistory)
870 delete m_fileHistory;
871 sm_docManager = (wxDocManager*) NULL;
872 }
873
874 // closes the specified document
875 bool wxDocManager::CloseDocument(wxDocument* doc, bool force)
876 {
877 if (doc->Close() || force)
878 {
879 // Implicitly deletes the document when
880 // the last view is deleted
881 doc->DeleteAllViews();
882
883 // Check we're really deleted
884 if (m_docs.Member(doc))
885 delete doc;
886
887 return true;
888 }
889 return false;
890 }
891
892 bool wxDocManager::CloseDocuments(bool force)
893 {
894 wxList::compatibility_iterator node = m_docs.GetFirst();
895 while (node)
896 {
897 wxDocument *doc = (wxDocument *)node->GetData();
898 wxList::compatibility_iterator next = node->GetNext();
899
900 if (!CloseDocument(doc, force))
901 return false;
902
903 // This assumes that documents are not connected in
904 // any way, i.e. deleting one document does NOT
905 // delete another.
906 node = next;
907 }
908 return true;
909 }
910
911 bool wxDocManager::Clear(bool force)
912 {
913 if (!CloseDocuments(force))
914 return false;
915
916 m_currentView = NULL;
917
918 wxList::compatibility_iterator node = m_templates.GetFirst();
919 while (node)
920 {
921 wxDocTemplate *templ = (wxDocTemplate*) node->GetData();
922 wxList::compatibility_iterator next = node->GetNext();
923 delete templ;
924 node = next;
925 }
926 return true;
927 }
928
929 bool wxDocManager::Initialize()
930 {
931 m_fileHistory = OnCreateFileHistory();
932 return true;
933 }
934
935 wxFileHistory *wxDocManager::OnCreateFileHistory()
936 {
937 return new wxFileHistory;
938 }
939
940 void wxDocManager::OnFileClose(wxCommandEvent& WXUNUSED(event))
941 {
942 wxDocument *doc = GetCurrentDocument();
943 if (!doc)
944 return;
945 if (doc->Close())
946 {
947 doc->DeleteAllViews();
948 if (m_docs.Member(doc))
949 delete doc;
950 }
951 }
952
953 void wxDocManager::OnFileCloseAll(wxCommandEvent& WXUNUSED(event))
954 {
955 CloseDocuments(false);
956 }
957
958 void wxDocManager::OnFileNew(wxCommandEvent& WXUNUSED(event))
959 {
960 CreateDocument( wxEmptyString, wxDOC_NEW );
961 }
962
963 void wxDocManager::OnFileOpen(wxCommandEvent& WXUNUSED(event))
964 {
965 if ( !CreateDocument( wxEmptyString, 0) )
966 {
967 OnOpenFileFailure();
968 }
969 }
970
971 void wxDocManager::OnFileRevert(wxCommandEvent& WXUNUSED(event))
972 {
973 wxDocument *doc = GetCurrentDocument();
974 if (!doc)
975 return;
976 doc->Revert();
977 }
978
979 void wxDocManager::OnFileSave(wxCommandEvent& WXUNUSED(event))
980 {
981 wxDocument *doc = GetCurrentDocument();
982 if (!doc)
983 return;
984 doc->Save();
985 }
986
987 void wxDocManager::OnFileSaveAs(wxCommandEvent& WXUNUSED(event))
988 {
989 wxDocument *doc = GetCurrentDocument();
990 if (!doc)
991 return;
992 doc->SaveAs();
993 }
994
995 void wxDocManager::OnPrint(wxCommandEvent& WXUNUSED(event))
996 {
997 #if wxUSE_PRINTING_ARCHITECTURE
998 wxView *view = GetCurrentView();
999 if (!view)
1000 return;
1001
1002 wxPrintout *printout = view->OnCreatePrintout();
1003 if (printout)
1004 {
1005 wxPrinter printer;
1006 printer.Print(view->GetFrame(), printout, true);
1007
1008 delete printout;
1009 }
1010 #endif // wxUSE_PRINTING_ARCHITECTURE
1011 }
1012
1013 void wxDocManager::OnPreview(wxCommandEvent& WXUNUSED(event))
1014 {
1015 #if wxUSE_PRINTING_ARCHITECTURE
1016 wxView *view = GetCurrentView();
1017 if (!view)
1018 return;
1019
1020 wxPrintout *printout = view->OnCreatePrintout();
1021 if (printout)
1022 {
1023 // Pass two printout objects: for preview, and possible printing.
1024 wxPrintPreviewBase *preview = new wxPrintPreview(printout, view->OnCreatePrintout());
1025 if ( !preview->Ok() )
1026 {
1027 delete preview;
1028 wxMessageBox( _("Sorry, print preview needs a printer to be installed.") );
1029 return;
1030 }
1031
1032 wxPreviewFrame *frame = new wxPreviewFrame(preview, (wxFrame *)wxTheApp->GetTopWindow(), _("Print Preview"),
1033 wxPoint(100, 100), wxSize(600, 650));
1034 frame->Centre(wxBOTH);
1035 frame->Initialize();
1036 frame->Show(true);
1037 }
1038 #endif // wxUSE_PRINTING_ARCHITECTURE
1039 }
1040
1041 void wxDocManager::OnUndo(wxCommandEvent& event)
1042 {
1043 wxDocument *doc = GetCurrentDocument();
1044 if (!doc)
1045 return;
1046 if (doc->GetCommandProcessor())
1047 doc->GetCommandProcessor()->Undo();
1048 else
1049 event.Skip();
1050 }
1051
1052 void wxDocManager::OnRedo(wxCommandEvent& event)
1053 {
1054 wxDocument *doc = GetCurrentDocument();
1055 if (!doc)
1056 return;
1057 if (doc->GetCommandProcessor())
1058 doc->GetCommandProcessor()->Redo();
1059 else
1060 event.Skip();
1061 }
1062
1063 // Handlers for UI update commands
1064
1065 void wxDocManager::OnUpdateFileOpen(wxUpdateUIEvent& event)
1066 {
1067 event.Enable( true );
1068 }
1069
1070 void wxDocManager::OnUpdateFileClose(wxUpdateUIEvent& event)
1071 {
1072 wxDocument *doc = GetCurrentDocument();
1073 event.Enable( (doc != (wxDocument*) NULL) );
1074 }
1075
1076 void wxDocManager::OnUpdateFileRevert(wxUpdateUIEvent& event)
1077 {
1078 wxDocument *doc = GetCurrentDocument();
1079 event.Enable( (doc != (wxDocument*) NULL) );
1080 }
1081
1082 void wxDocManager::OnUpdateFileNew(wxUpdateUIEvent& event)
1083 {
1084 event.Enable( true );
1085 }
1086
1087 void wxDocManager::OnUpdateFileSave(wxUpdateUIEvent& event)
1088 {
1089 wxDocument *doc = GetCurrentDocument();
1090 event.Enable( doc && doc->IsModified() );
1091 }
1092
1093 void wxDocManager::OnUpdateFileSaveAs(wxUpdateUIEvent& event)
1094 {
1095 wxDocument *doc = GetCurrentDocument();
1096 event.Enable( (doc != (wxDocument*) NULL) );
1097 }
1098
1099 void wxDocManager::OnUpdateUndo(wxUpdateUIEvent& event)
1100 {
1101 wxDocument *doc = GetCurrentDocument();
1102 if (!doc)
1103 event.Enable(false);
1104 else if (!doc->GetCommandProcessor())
1105 event.Skip();
1106 else
1107 {
1108 event.Enable( doc->GetCommandProcessor()->CanUndo() );
1109 doc->GetCommandProcessor()->SetMenuStrings();
1110 }
1111 }
1112
1113 void wxDocManager::OnUpdateRedo(wxUpdateUIEvent& event)
1114 {
1115 wxDocument *doc = GetCurrentDocument();
1116 if (!doc)
1117 event.Enable(false);
1118 else if (!doc->GetCommandProcessor())
1119 event.Skip();
1120 else
1121 {
1122 event.Enable( doc->GetCommandProcessor()->CanRedo() );
1123 doc->GetCommandProcessor()->SetMenuStrings();
1124 }
1125 }
1126
1127 void wxDocManager::OnUpdatePrint(wxUpdateUIEvent& event)
1128 {
1129 wxDocument *doc = GetCurrentDocument();
1130 event.Enable( (doc != (wxDocument*) NULL) );
1131 }
1132
1133 void wxDocManager::OnUpdatePreview(wxUpdateUIEvent& event)
1134 {
1135 wxDocument *doc = GetCurrentDocument();
1136 event.Enable( (doc != (wxDocument*) NULL) );
1137 }
1138
1139 wxView *wxDocManager::GetCurrentView() const
1140 {
1141 if (m_currentView)
1142 return m_currentView;
1143 if (m_docs.GetCount() == 1)
1144 {
1145 wxDocument* doc = (wxDocument*) m_docs.GetFirst()->GetData();
1146 return doc->GetFirstView();
1147 }
1148 return (wxView *) NULL;
1149 }
1150
1151 // Extend event processing to search the view's event table
1152 bool wxDocManager::ProcessEvent(wxEvent& event)
1153 {
1154 wxView* view = GetCurrentView();
1155 if (view)
1156 {
1157 if (view->ProcessEvent(event))
1158 return true;
1159 }
1160 return wxEvtHandler::ProcessEvent(event);
1161 }
1162
1163 wxDocument *wxDocManager::CreateDocument(const wxString& path, long flags)
1164 {
1165 wxDocTemplate **templates = new wxDocTemplate *[m_templates.GetCount()];
1166 int n = 0;
1167
1168 for (size_t i = 0; i < m_templates.GetCount(); i++)
1169 {
1170 wxDocTemplate *temp = (wxDocTemplate *)(m_templates.Item(i)->GetData());
1171 if (temp->IsVisible())
1172 {
1173 templates[n] = temp;
1174 n ++;
1175 }
1176 }
1177 if (n == 0)
1178 {
1179 delete[] templates;
1180 return (wxDocument *) NULL;
1181 }
1182
1183 wxDocument* docToClose = NULL;
1184
1185 // If we've reached the max number of docs, close the
1186 // first one.
1187 if ( (int)GetDocuments().GetCount() >= m_maxDocsOpen )
1188 {
1189 wxDocument *doc = (wxDocument *)GetDocuments().GetFirst()->GetData();
1190 docToClose = doc;
1191 }
1192
1193 // New document: user chooses a template, unless there's only one.
1194 if (flags & wxDOC_NEW)
1195 {
1196 if (n == 1)
1197 {
1198 if (docToClose)
1199 {
1200 if (!CloseDocument(docToClose, false))
1201 {
1202 delete[] templates;
1203 return NULL;
1204 }
1205 }
1206
1207 wxDocTemplate *temp = templates[0];
1208 delete[] templates;
1209 wxDocument *newDoc = temp->CreateDocument(path, flags);
1210
1211 if (newDoc)
1212 {
1213 newDoc->SetDocumentName(temp->GetDocumentName());
1214 newDoc->SetDocumentTemplate(temp);
1215 if (!newDoc->OnNewDocument() )
1216 {
1217 // Document is implicitly deleted by DeleteAllViews
1218 newDoc->DeleteAllViews();
1219 return NULL;
1220 }
1221 }
1222 return newDoc;
1223 }
1224
1225 wxDocTemplate *temp = SelectDocumentType(templates, n);
1226 delete[] templates;
1227 if (temp)
1228 {
1229 if (docToClose)
1230 {
1231 if (!CloseDocument(docToClose, false))
1232 {
1233 return NULL;
1234 }
1235 }
1236
1237 wxDocument *newDoc = temp->CreateDocument(path, flags);
1238
1239 if (newDoc)
1240 {
1241 newDoc->SetDocumentName(temp->GetDocumentName());
1242 newDoc->SetDocumentTemplate(temp);
1243 if (!newDoc->OnNewDocument() )
1244 {
1245 // Document is implicitly deleted by DeleteAllViews
1246 newDoc->DeleteAllViews();
1247 return NULL;
1248 }
1249 }
1250 return newDoc;
1251 }
1252 else
1253 return (wxDocument *) NULL;
1254 }
1255
1256 // Existing document
1257 wxDocTemplate *temp;
1258
1259 wxString path2 = path;
1260
1261 if (flags & wxDOC_SILENT)
1262 {
1263 temp = FindTemplateForPath(path2);
1264 if (!temp)
1265 {
1266 // Since we do not add files with non-default extensions to the FileHistory this
1267 // can only happen if the application changes the allowed templates in runtime.
1268 (void)wxMessageBox(_("Sorry, the format for this file is unknown."),
1269 _("Open File"),
1270 wxOK | wxICON_EXCLAMATION, wxFindSuitableParent());
1271 }
1272 }
1273 else
1274 temp = SelectDocumentPath(templates, n, path2, flags);
1275
1276 delete[] templates;
1277
1278 if (temp)
1279 {
1280 if (docToClose)
1281 {
1282 if (!CloseDocument(docToClose, false))
1283 {
1284 return NULL;
1285 }
1286 }
1287
1288 //see if this file is already open
1289 for (size_t i = 0; i < GetDocuments().GetCount(); ++i)
1290 {
1291 wxDocument* currentDoc = (wxDocument*)(GetDocuments().Item(i)->GetData());
1292 #ifdef __WXMSW__
1293 //file paths are case-insensitive on Windows
1294 if (path2.CmpNoCase(currentDoc->GetFilename()) == 0)
1295 #else
1296 if (path2.Cmp(currentDoc->GetFilename()) == 0)
1297 #endif
1298 {
1299 //file already open. Just activate it and return
1300 if (currentDoc->GetFirstView())
1301 {
1302 ActivateView(currentDoc->GetFirstView(), true);
1303 if (currentDoc->GetDocumentWindow())
1304 currentDoc->GetDocumentWindow()->SetFocus();
1305 return currentDoc;
1306 }
1307 }
1308 }
1309
1310 wxDocument *newDoc = temp->CreateDocument(path2, flags);
1311 if (newDoc)
1312 {
1313 newDoc->SetDocumentName(temp->GetDocumentName());
1314 newDoc->SetDocumentTemplate(temp);
1315 if (!newDoc->OnOpenDocument(path2))
1316 {
1317 newDoc->DeleteAllViews();
1318 // delete newDoc; // Implicitly deleted by DeleteAllViews
1319 return (wxDocument *) NULL;
1320 }
1321 // A file that doesn't use the default extension of its document
1322 // template cannot be opened via the FileHistory, so we do not
1323 // add it.
1324 if (temp->FileMatchesTemplate(path2))
1325 AddFileToHistory(path2);
1326 }
1327 return newDoc;
1328 }
1329
1330 return (wxDocument *) NULL;
1331 }
1332
1333 wxView *wxDocManager::CreateView(wxDocument *doc, long flags)
1334 {
1335 wxDocTemplate **templates = new wxDocTemplate *[m_templates.GetCount()];
1336 int n =0;
1337
1338 for (size_t i = 0; i < m_templates.GetCount(); i++)
1339 {
1340 wxDocTemplate *temp = (wxDocTemplate *)(m_templates.Item(i)->GetData());
1341 if (temp->IsVisible())
1342 {
1343 if (temp->GetDocumentName() == doc->GetDocumentName())
1344 {
1345 templates[n] = temp;
1346 n ++;
1347 }
1348 }
1349 }
1350 if (n == 0)
1351 {
1352 delete[] templates;
1353 return (wxView *) NULL;
1354 }
1355 if (n == 1)
1356 {
1357 wxDocTemplate *temp = templates[0];
1358 delete[] templates;
1359 wxView *view = temp->CreateView(doc, flags);
1360 if (view)
1361 view->SetViewName(temp->GetViewName());
1362 return view;
1363 }
1364
1365 wxDocTemplate *temp = SelectViewType(templates, n);
1366 delete[] templates;
1367 if (temp)
1368 {
1369 wxView *view = temp->CreateView(doc, flags);
1370 if (view)
1371 view->SetViewName(temp->GetViewName());
1372 return view;
1373 }
1374 else
1375 return (wxView *) NULL;
1376 }
1377
1378 // Not yet implemented
1379 void wxDocManager::DeleteTemplate(wxDocTemplate *WXUNUSED(temp), long WXUNUSED(flags))
1380 {
1381 }
1382
1383 // Not yet implemented
1384 bool wxDocManager::FlushDoc(wxDocument *WXUNUSED(doc))
1385 {
1386 return false;
1387 }
1388
1389 wxDocument *wxDocManager::GetCurrentDocument() const
1390 {
1391 wxView *view = GetCurrentView();
1392 if (view)
1393 return view->GetDocument();
1394 else
1395 return (wxDocument *) NULL;
1396 }
1397
1398 // Make a default document name
1399 bool wxDocManager::MakeDefaultName(wxString& name)
1400 {
1401 name.Printf(_("unnamed%d"), m_defaultDocumentNameCounter);
1402 m_defaultDocumentNameCounter++;
1403
1404 return true;
1405 }
1406
1407 // Make a frame title (override this to do something different)
1408 // If docName is empty, a document is not currently active.
1409 wxString wxDocManager::MakeFrameTitle(wxDocument* doc)
1410 {
1411 wxString appName = wxTheApp->GetAppName();
1412 wxString title;
1413 if (!doc)
1414 title = appName;
1415 else
1416 {
1417 wxString docName;
1418 doc->GetPrintableName(docName);
1419 title = docName + wxString(_(" - ")) + appName;
1420 }
1421 return title;
1422 }
1423
1424
1425 // Not yet implemented
1426 wxDocTemplate *wxDocManager::MatchTemplate(const wxString& WXUNUSED(path))
1427 {
1428 return (wxDocTemplate *) NULL;
1429 }
1430
1431 // File history management
1432 void wxDocManager::AddFileToHistory(const wxString& file)
1433 {
1434 if (m_fileHistory)
1435 m_fileHistory->AddFileToHistory(file);
1436 }
1437
1438 void wxDocManager::RemoveFileFromHistory(size_t i)
1439 {
1440 if (m_fileHistory)
1441 m_fileHistory->RemoveFileFromHistory(i);
1442 }
1443
1444 wxString wxDocManager::GetHistoryFile(size_t i) const
1445 {
1446 wxString histFile;
1447
1448 if (m_fileHistory)
1449 histFile = m_fileHistory->GetHistoryFile(i);
1450
1451 return histFile;
1452 }
1453
1454 void wxDocManager::FileHistoryUseMenu(wxMenu *menu)
1455 {
1456 if (m_fileHistory)
1457 m_fileHistory->UseMenu(menu);
1458 }
1459
1460 void wxDocManager::FileHistoryRemoveMenu(wxMenu *menu)
1461 {
1462 if (m_fileHistory)
1463 m_fileHistory->RemoveMenu(menu);
1464 }
1465
1466 #if wxUSE_CONFIG
1467 void wxDocManager::FileHistoryLoad(wxConfigBase& config)
1468 {
1469 if (m_fileHistory)
1470 m_fileHistory->Load(config);
1471 }
1472
1473 void wxDocManager::FileHistorySave(wxConfigBase& config)
1474 {
1475 if (m_fileHistory)
1476 m_fileHistory->Save(config);
1477 }
1478 #endif
1479
1480 void wxDocManager::FileHistoryAddFilesToMenu(wxMenu* menu)
1481 {
1482 if (m_fileHistory)
1483 m_fileHistory->AddFilesToMenu(menu);
1484 }
1485
1486 void wxDocManager::FileHistoryAddFilesToMenu()
1487 {
1488 if (m_fileHistory)
1489 m_fileHistory->AddFilesToMenu();
1490 }
1491
1492 size_t wxDocManager::GetHistoryFilesCount() const
1493 {
1494 return m_fileHistory ? m_fileHistory->GetCount() : 0;
1495 }
1496
1497
1498 // Find out the document template via matching in the document file format
1499 // against that of the template
1500 wxDocTemplate *wxDocManager::FindTemplateForPath(const wxString& path)
1501 {
1502 wxDocTemplate *theTemplate = (wxDocTemplate *) NULL;
1503
1504 // Find the template which this extension corresponds to
1505 for (size_t i = 0; i < m_templates.GetCount(); i++)
1506 {
1507 wxDocTemplate *temp = (wxDocTemplate *)m_templates.Item(i)->GetData();
1508 if ( temp->FileMatchesTemplate(path) )
1509 {
1510 theTemplate = temp;
1511 break;
1512 }
1513 }
1514 return theTemplate;
1515 }
1516
1517 // Try to get a more suitable parent frame than the top window,
1518 // for selection dialogs. Otherwise you may get an unexpected
1519 // window being activated when a dialog is shown.
1520 static wxWindow* wxFindSuitableParent()
1521 {
1522 wxWindow* parent = wxTheApp->GetTopWindow();
1523
1524 wxWindow* focusWindow = wxWindow::FindFocus();
1525 if (focusWindow)
1526 {
1527 while (focusWindow &&
1528 !focusWindow->IsKindOf(CLASSINFO(wxDialog)) &&
1529 !focusWindow->IsKindOf(CLASSINFO(wxFrame)))
1530
1531 focusWindow = focusWindow->GetParent();
1532
1533 if (focusWindow)
1534 parent = focusWindow;
1535 }
1536 return parent;
1537 }
1538
1539 // Prompts user to open a file, using file specs in templates.
1540 // Must extend the file selector dialog or implement own; OR
1541 // match the extension to the template extension.
1542
1543 wxDocTemplate *wxDocManager::SelectDocumentPath(wxDocTemplate **templates,
1544 #if defined(__WXMSW__) || defined(__WXGTK__) || defined(__WXMAC__)
1545 int noTemplates,
1546 #else
1547 int WXUNUSED(noTemplates),
1548 #endif
1549 wxString& path,
1550 long WXUNUSED(flags),
1551 bool WXUNUSED(save))
1552 {
1553 // We can only have multiple filters in Windows and GTK
1554 #if defined(__WXMSW__) || defined(__WXGTK__) || defined(__WXMAC__)
1555 wxString descrBuf;
1556
1557 int i;
1558 for (i = 0; i < noTemplates; i++)
1559 {
1560 if (templates[i]->IsVisible())
1561 {
1562 // add a '|' to separate this filter from the previous one
1563 if ( !descrBuf.empty() )
1564 descrBuf << wxT('|');
1565
1566 descrBuf << templates[i]->GetDescription()
1567 << wxT(" (") << templates[i]->GetFileFilter() << wxT(") |")
1568 << templates[i]->GetFileFilter();
1569 }
1570 }
1571 #else
1572 wxString descrBuf = wxT("*.*");
1573 #endif
1574
1575 int FilterIndex = -1;
1576
1577 wxWindow* parent = wxFindSuitableParent();
1578
1579 wxString pathTmp = wxFileSelectorEx(_("Select a file"),
1580 m_lastDirectory,
1581 wxEmptyString,
1582 &FilterIndex,
1583 descrBuf,
1584 0,
1585 parent);
1586
1587 wxDocTemplate *theTemplate = (wxDocTemplate *)NULL;
1588 if (!pathTmp.empty())
1589 {
1590 if (!wxFileExists(pathTmp))
1591 {
1592 wxString msgTitle;
1593 if (!wxTheApp->GetAppName().empty())
1594 msgTitle = wxTheApp->GetAppName();
1595 else
1596 msgTitle = wxString(_("File error"));
1597
1598 (void)wxMessageBox(_("Sorry, could not open this file."), msgTitle, wxOK | wxICON_EXCLAMATION,
1599 parent);
1600
1601 path = wxEmptyString;
1602 return (wxDocTemplate *) NULL;
1603 }
1604 m_lastDirectory = wxPathOnly(pathTmp);
1605
1606 path = pathTmp;
1607
1608 // first choose the template using the extension, if this fails (i.e.
1609 // wxFileSelectorEx() didn't fill it), then use the path
1610 if ( FilterIndex != -1 )
1611 theTemplate = templates[FilterIndex];
1612 if ( !theTemplate )
1613 theTemplate = FindTemplateForPath(path);
1614 if ( !theTemplate )
1615 {
1616 // Since we do not add files with non-default extensions to the FileHistory this
1617 // can only happen if the application changes the allowed templates in runtime.
1618 (void)wxMessageBox(_("Sorry, the format for this file is unknown."),
1619 _("Open File"),
1620 wxOK | wxICON_EXCLAMATION, wxFindSuitableParent());
1621 }
1622 }
1623 else
1624 {
1625 path = wxEmptyString;
1626 }
1627
1628 return theTemplate;
1629 }
1630
1631 wxDocTemplate *wxDocManager::SelectDocumentType(wxDocTemplate **templates,
1632 int noTemplates, bool sort)
1633 {
1634 wxArrayString strings;
1635 wxDocTemplate **data = new wxDocTemplate *[noTemplates];
1636 int i;
1637 int n = 0;
1638
1639 for (i = 0; i < noTemplates; i++)
1640 {
1641 if (templates[i]->IsVisible())
1642 {
1643 int j;
1644 bool want = true;
1645 for (j = 0; j < n; j++)
1646 {
1647 //filter out NOT unique documents + view combinations
1648 if ( templates[i]->m_docTypeName == data[j]->m_docTypeName &&
1649 templates[i]->m_viewTypeName == data[j]->m_viewTypeName
1650 )
1651 want = false;
1652 }
1653
1654 if ( want )
1655 {
1656 strings.Add(templates[i]->m_description);
1657
1658 data[n] = templates[i];
1659 n ++;
1660 }
1661 }
1662 } // for
1663
1664 if (sort)
1665 {
1666 strings.Sort(); // ascending sort
1667 // Yes, this will be slow, but template lists
1668 // are typically short.
1669 int j;
1670 n = strings.Count();
1671 for (i = 0; i < n; i++)
1672 {
1673 for (j = 0; j < noTemplates; j++)
1674 {
1675 if (strings[i] == templates[j]->m_description)
1676 data[i] = templates[j];
1677 }
1678 }
1679 }
1680
1681 wxDocTemplate *theTemplate;
1682
1683 switch ( n )
1684 {
1685 case 0:
1686 // no visible templates, hence nothing to choose from
1687 theTemplate = NULL;
1688 break;
1689
1690 case 1:
1691 // don't propose the user to choose if he heas no choice
1692 theTemplate = data[0];
1693 break;
1694
1695 default:
1696 // propose the user to choose one of several
1697 theTemplate = (wxDocTemplate *)wxGetSingleChoiceData
1698 (
1699 _("Select a document template"),
1700 _("Templates"),
1701 strings,
1702 (void **)data,
1703 wxFindSuitableParent()
1704 );
1705 }
1706
1707 delete[] data;
1708
1709 return theTemplate;
1710 }
1711
1712 wxDocTemplate *wxDocManager::SelectViewType(wxDocTemplate **templates,
1713 int noTemplates, bool sort)
1714 {
1715 wxArrayString strings;
1716 wxDocTemplate **data = new wxDocTemplate *[noTemplates];
1717 int i;
1718 int n = 0;
1719
1720 for (i = 0; i < noTemplates; i++)
1721 {
1722 wxDocTemplate *templ = templates[i];
1723 if ( templ->IsVisible() && !templ->GetViewName().empty() )
1724 {
1725 int j;
1726 bool want = true;
1727 for (j = 0; j < n; j++)
1728 {
1729 //filter out NOT unique views
1730 if ( templates[i]->m_viewTypeName == data[j]->m_viewTypeName )
1731 want = false;
1732 }
1733
1734 if ( want )
1735 {
1736 strings.Add(templ->m_viewTypeName);
1737 data[n] = templ;
1738 n ++;
1739 }
1740 }
1741 }
1742
1743 if (sort)
1744 {
1745 strings.Sort(); // ascending sort
1746 // Yes, this will be slow, but template lists
1747 // are typically short.
1748 int j;
1749 n = strings.Count();
1750 for (i = 0; i < n; i++)
1751 {
1752 for (j = 0; j < noTemplates; j++)
1753 {
1754 if (strings[i] == templates[j]->m_viewTypeName)
1755 data[i] = templates[j];
1756 }
1757 }
1758 }
1759
1760 wxDocTemplate *theTemplate;
1761
1762 // the same logic as above
1763 switch ( n )
1764 {
1765 case 0:
1766 theTemplate = (wxDocTemplate *)NULL;
1767 break;
1768
1769 case 1:
1770 theTemplate = data[0];
1771 break;
1772
1773 default:
1774 theTemplate = (wxDocTemplate *)wxGetSingleChoiceData
1775 (
1776 _("Select a document view"),
1777 _("Views"),
1778 strings,
1779 (void **)data,
1780 wxFindSuitableParent()
1781 );
1782
1783 }
1784
1785 delete[] data;
1786 return theTemplate;
1787 }
1788
1789 void wxDocManager::AssociateTemplate(wxDocTemplate *temp)
1790 {
1791 if (!m_templates.Member(temp))
1792 m_templates.Append(temp);
1793 }
1794
1795 void wxDocManager::DisassociateTemplate(wxDocTemplate *temp)
1796 {
1797 m_templates.DeleteObject(temp);
1798 }
1799
1800 // Add and remove a document from the manager's list
1801 void wxDocManager::AddDocument(wxDocument *doc)
1802 {
1803 if (!m_docs.Member(doc))
1804 m_docs.Append(doc);
1805 }
1806
1807 void wxDocManager::RemoveDocument(wxDocument *doc)
1808 {
1809 m_docs.DeleteObject(doc);
1810 }
1811
1812 // Views or windows should inform the document manager
1813 // when a view is going in or out of focus
1814 void wxDocManager::ActivateView(wxView *view, bool activate)
1815 {
1816 if ( activate )
1817 {
1818 m_currentView = view;
1819 }
1820 else // deactivate
1821 {
1822 if ( m_currentView == view )
1823 {
1824 // don't keep stale pointer
1825 m_currentView = (wxView *) NULL;
1826 }
1827 }
1828 }
1829
1830 // ----------------------------------------------------------------------------
1831 // Default document child frame
1832 // ----------------------------------------------------------------------------
1833
1834 BEGIN_EVENT_TABLE(wxDocChildFrame, wxFrame)
1835 EVT_ACTIVATE(wxDocChildFrame::OnActivate)
1836 EVT_CLOSE(wxDocChildFrame::OnCloseWindow)
1837 END_EVENT_TABLE()
1838
1839 wxDocChildFrame::wxDocChildFrame(wxDocument *doc,
1840 wxView *view,
1841 wxFrame *frame,
1842 wxWindowID id,
1843 const wxString& title,
1844 const wxPoint& pos,
1845 const wxSize& size,
1846 long style,
1847 const wxString& name)
1848 : wxFrame(frame, id, title, pos, size, style, name)
1849 {
1850 m_childDocument = doc;
1851 m_childView = view;
1852 if (view)
1853 view->SetFrame(this);
1854 }
1855
1856 // Extend event processing to search the view's event table
1857 bool wxDocChildFrame::ProcessEvent(wxEvent& event)
1858 {
1859 if (m_childView)
1860 m_childView->Activate(true);
1861
1862 if ( !m_childView || ! m_childView->ProcessEvent(event) )
1863 {
1864 // Only hand up to the parent if it's a menu command
1865 if (!event.IsKindOf(CLASSINFO(wxCommandEvent)) || !GetParent() || !GetParent()->ProcessEvent(event))
1866 return wxEvtHandler::ProcessEvent(event);
1867 else
1868 return true;
1869 }
1870 else
1871 return true;
1872 }
1873
1874 void wxDocChildFrame::OnActivate(wxActivateEvent& event)
1875 {
1876 wxFrame::OnActivate(event);
1877
1878 if (m_childView)
1879 m_childView->Activate(event.GetActive());
1880 }
1881
1882 void wxDocChildFrame::OnCloseWindow(wxCloseEvent& event)
1883 {
1884 if (m_childView)
1885 {
1886 bool ans = event.CanVeto()
1887 ? m_childView->Close(false) // false means don't delete associated window
1888 : true; // Must delete.
1889
1890 if (ans)
1891 {
1892 m_childView->Activate(false);
1893 delete m_childView;
1894 m_childView = (wxView *) NULL;
1895 m_childDocument = (wxDocument *) NULL;
1896
1897 this->Destroy();
1898 }
1899 else
1900 event.Veto();
1901 }
1902 else
1903 event.Veto();
1904 }
1905
1906 // ----------------------------------------------------------------------------
1907 // Default parent frame
1908 // ----------------------------------------------------------------------------
1909
1910 BEGIN_EVENT_TABLE(wxDocParentFrame, wxFrame)
1911 EVT_MENU(wxID_EXIT, wxDocParentFrame::OnExit)
1912 EVT_MENU_RANGE(wxID_FILE1, wxID_FILE9, wxDocParentFrame::OnMRUFile)
1913 EVT_CLOSE(wxDocParentFrame::OnCloseWindow)
1914 END_EVENT_TABLE()
1915
1916 wxDocParentFrame::wxDocParentFrame(wxDocManager *manager,
1917 wxFrame *frame,
1918 wxWindowID id,
1919 const wxString& title,
1920 const wxPoint& pos,
1921 const wxSize& size,
1922 long style,
1923 const wxString& name)
1924 : wxFrame(frame, id, title, pos, size, style, name)
1925 {
1926 m_docManager = manager;
1927 }
1928
1929 void wxDocParentFrame::OnExit(wxCommandEvent& WXUNUSED(event))
1930 {
1931 Close();
1932 }
1933
1934 void wxDocParentFrame::OnMRUFile(wxCommandEvent& event)
1935 {
1936 int n = event.GetId() - wxID_FILE1; // the index in MRU list
1937 wxString filename(m_docManager->GetHistoryFile(n));
1938 if ( !filename.empty() )
1939 {
1940 // verify that the file exists before doing anything else
1941 if ( wxFile::Exists(filename) )
1942 {
1943 // try to open it
1944 if (!m_docManager->CreateDocument(filename, wxDOC_SILENT))
1945 {
1946 // remove the file from the MRU list. The user should already be notified.
1947 m_docManager->RemoveFileFromHistory(n);
1948
1949 wxLogError(_("The file '%s' couldn't be opened.\nIt has been removed from the most recently used files list."),
1950 filename.c_str());
1951 }
1952 }
1953 else
1954 {
1955 // remove the bogus filename from the MRU list and notify the user
1956 // about it
1957 m_docManager->RemoveFileFromHistory(n);
1958
1959 wxLogError(_("The file '%s' doesn't exist and couldn't be opened.\nIt has been removed from the most recently used files list."),
1960 filename.c_str());
1961 }
1962 }
1963 }
1964
1965 // Extend event processing to search the view's event table
1966 bool wxDocParentFrame::ProcessEvent(wxEvent& event)
1967 {
1968 // Try the document manager, then do default processing
1969 if (!m_docManager || !m_docManager->ProcessEvent(event))
1970 return wxEvtHandler::ProcessEvent(event);
1971 else
1972 return true;
1973 }
1974
1975 // Define the behaviour for the frame closing
1976 // - must delete all frames except for the main one.
1977 void wxDocParentFrame::OnCloseWindow(wxCloseEvent& event)
1978 {
1979 if (m_docManager->Clear(!event.CanVeto()))
1980 {
1981 this->Destroy();
1982 }
1983 else
1984 event.Veto();
1985 }
1986
1987 #if wxUSE_PRINTING_ARCHITECTURE
1988
1989 wxDocPrintout::wxDocPrintout(wxView *view, const wxString& title)
1990 : wxPrintout(title)
1991 {
1992 m_printoutView = view;
1993 }
1994
1995 bool wxDocPrintout::OnPrintPage(int WXUNUSED(page))
1996 {
1997 wxDC *dc = GetDC();
1998
1999 // Get the logical pixels per inch of screen and printer
2000 int ppiScreenX, ppiScreenY;
2001 GetPPIScreen(&ppiScreenX, &ppiScreenY);
2002 wxUnusedVar(ppiScreenY);
2003 int ppiPrinterX, ppiPrinterY;
2004 GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
2005 wxUnusedVar(ppiPrinterY);
2006
2007 // This scales the DC so that the printout roughly represents the
2008 // the screen scaling. The text point size _should_ be the right size
2009 // but in fact is too small for some reason. This is a detail that will
2010 // need to be addressed at some point but can be fudged for the
2011 // moment.
2012 float scale = (float)((float)ppiPrinterX/(float)ppiScreenX);
2013
2014 // Now we have to check in case our real page size is reduced
2015 // (e.g. because we're drawing to a print preview memory DC)
2016 int pageWidth, pageHeight;
2017 int w, h;
2018 dc->GetSize(&w, &h);
2019 GetPageSizePixels(&pageWidth, &pageHeight);
2020 wxUnusedVar(pageHeight);
2021
2022 // If printer pageWidth == current DC width, then this doesn't
2023 // change. But w might be the preview bitmap width, so scale down.
2024 float overallScale = scale * (float)(w/(float)pageWidth);
2025 dc->SetUserScale(overallScale, overallScale);
2026
2027 if (m_printoutView)
2028 {
2029 m_printoutView->OnDraw(dc);
2030 }
2031 return true;
2032 }
2033
2034 bool wxDocPrintout::HasPage(int pageNum)
2035 {
2036 return (pageNum == 1);
2037 }
2038
2039 bool wxDocPrintout::OnBeginDocument(int startPage, int endPage)
2040 {
2041 if (!wxPrintout::OnBeginDocument(startPage, endPage))
2042 return false;
2043
2044 return true;
2045 }
2046
2047 void wxDocPrintout::GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo)
2048 {
2049 *minPage = 1;
2050 *maxPage = 1;
2051 *selPageFrom = 1;
2052 *selPageTo = 1;
2053 }
2054
2055 #endif // wxUSE_PRINTING_ARCHITECTURE
2056
2057 // ----------------------------------------------------------------------------
2058 // File history processor
2059 // ----------------------------------------------------------------------------
2060
2061 static inline wxChar* MYcopystring(const wxString& s)
2062 {
2063 wxChar* copy = new wxChar[s.length() + 1];
2064 return wxStrcpy(copy, s.c_str());
2065 }
2066
2067 static inline wxChar* MYcopystring(const wxChar* s)
2068 {
2069 wxChar* copy = new wxChar[wxStrlen(s) + 1];
2070 return wxStrcpy(copy, s);
2071 }
2072
2073 wxFileHistory::wxFileHistory(size_t maxFiles, wxWindowID idBase)
2074 {
2075 m_fileMaxFiles = maxFiles;
2076 m_idBase = idBase;
2077 m_fileHistoryN = 0;
2078 m_fileHistory = new wxChar *[m_fileMaxFiles];
2079 }
2080
2081 wxFileHistory::~wxFileHistory()
2082 {
2083 size_t i;
2084 for (i = 0; i < m_fileHistoryN; i++)
2085 delete[] m_fileHistory[i];
2086 delete[] m_fileHistory;
2087 }
2088
2089 // File history management
2090 void wxFileHistory::AddFileToHistory(const wxString& file)
2091 {
2092 size_t i;
2093
2094 // Check we don't already have this file
2095 for (i = 0; i < m_fileHistoryN; i++)
2096 {
2097 #if defined( __WXMSW__ ) // Add any other OSes with case insensitive file names
2098 wxString testString;
2099 if ( m_fileHistory[i] )
2100 testString = m_fileHistory[i];
2101 if ( m_fileHistory[i] && ( file.Lower() == testString.Lower() ) )
2102 #else
2103 if ( m_fileHistory[i] && ( file == m_fileHistory[i] ) )
2104 #endif
2105 {
2106 // we do have it, move it to the top of the history
2107 RemoveFileFromHistory (i);
2108 AddFileToHistory (file);
2109 return;
2110 }
2111 }
2112
2113 // if we already have a full history, delete the one at the end
2114 if ( m_fileMaxFiles == m_fileHistoryN )
2115 {
2116 RemoveFileFromHistory (m_fileHistoryN - 1);
2117 AddFileToHistory (file);
2118 return;
2119 }
2120
2121 // Add to the project file history:
2122 // Move existing files (if any) down so we can insert file at beginning.
2123 if (m_fileHistoryN < m_fileMaxFiles)
2124 {
2125 wxList::compatibility_iterator node = m_fileMenus.GetFirst();
2126 while (node)
2127 {
2128 wxMenu* menu = (wxMenu*) node->GetData();
2129 if ( m_fileHistoryN == 0 && menu->GetMenuItemCount() )
2130 {
2131 menu->AppendSeparator();
2132 }
2133 menu->Append(m_idBase+m_fileHistoryN, _("[EMPTY]"));
2134 node = node->GetNext();
2135 }
2136 m_fileHistoryN ++;
2137 }
2138 // Shuffle filenames down
2139 for (i = (m_fileHistoryN-1); i > 0; i--)
2140 {
2141 m_fileHistory[i] = m_fileHistory[i-1];
2142 }
2143 m_fileHistory[0] = MYcopystring(file);
2144
2145 // this is the directory of the last opened file
2146 wxString pathCurrent;
2147 wxSplitPath( m_fileHistory[0], &pathCurrent, NULL, NULL );
2148 for (i = 0; i < m_fileHistoryN; i++)
2149 {
2150 if ( m_fileHistory[i] )
2151 {
2152 // if in same directory just show the filename; otherwise the full
2153 // path
2154 wxString pathInMenu, path, filename, ext;
2155 wxSplitPath( m_fileHistory[i], &path, &filename, &ext );
2156 if ( path == pathCurrent )
2157 {
2158 pathInMenu = filename;
2159 if ( !ext.empty() )
2160 pathInMenu = pathInMenu + wxFILE_SEP_EXT + ext;
2161 }
2162 else
2163 {
2164 // absolute path; could also set relative path
2165 pathInMenu = m_fileHistory[i];
2166 }
2167
2168 // we need to quote '&' characters which are used for mnemonics
2169 pathInMenu.Replace(_T("&"), _T("&&"));
2170 wxString buf;
2171 buf.Printf(s_MRUEntryFormat, i + 1, pathInMenu.c_str());
2172 wxList::compatibility_iterator node = m_fileMenus.GetFirst();
2173 while (node)
2174 {
2175 wxMenu* menu = (wxMenu*) node->GetData();
2176 menu->SetLabel(m_idBase + i, buf);
2177 node = node->GetNext();
2178 }
2179 }
2180 }
2181 }
2182
2183 void wxFileHistory::RemoveFileFromHistory(size_t i)
2184 {
2185 wxCHECK_RET( i < m_fileHistoryN,
2186 wxT("invalid index in wxFileHistory::RemoveFileFromHistory") );
2187
2188 // delete the element from the array (could use memmove() too...)
2189 delete [] m_fileHistory[i];
2190
2191 size_t j;
2192 for ( j = i; j < m_fileHistoryN - 1; j++ )
2193 {
2194 m_fileHistory[j] = m_fileHistory[j + 1];
2195 }
2196
2197 wxList::compatibility_iterator node = m_fileMenus.GetFirst();
2198 while ( node )
2199 {
2200 wxMenu* menu = (wxMenu*) node->GetData();
2201
2202 // shuffle filenames up
2203 wxString buf;
2204 for ( j = i; j < m_fileHistoryN - 1; j++ )
2205 {
2206 buf.Printf(s_MRUEntryFormat, j + 1, m_fileHistory[j]);
2207 menu->SetLabel(m_idBase + j, buf);
2208 }
2209
2210 node = node->GetNext();
2211
2212 // delete the last menu item which is unused now
2213 wxWindowID lastItemId = m_idBase + wx_truncate_cast(wxWindowID, m_fileHistoryN) - 1;
2214 if (menu->FindItem(lastItemId))
2215 {
2216 menu->Delete(lastItemId);
2217 }
2218
2219 // delete the last separator too if no more files are left
2220 if ( m_fileHistoryN == 1 )
2221 {
2222 wxMenuItemList::compatibility_iterator nodeLast = menu->GetMenuItems().GetLast();
2223 if ( nodeLast )
2224 {
2225 wxMenuItem *menuItem = nodeLast->GetData();
2226 if ( menuItem->IsSeparator() )
2227 {
2228 menu->Delete(menuItem);
2229 }
2230 //else: should we search backwards for the last separator?
2231 }
2232 //else: menu is empty somehow
2233 }
2234 }
2235
2236 m_fileHistoryN--;
2237 }
2238
2239 wxString wxFileHistory::GetHistoryFile(size_t i) const
2240 {
2241 wxString s;
2242 if ( i < m_fileHistoryN )
2243 {
2244 s = m_fileHistory[i];
2245 }
2246 else
2247 {
2248 wxFAIL_MSG( wxT("bad index in wxFileHistory::GetHistoryFile") );
2249 }
2250
2251 return s;
2252 }
2253
2254 void wxFileHistory::UseMenu(wxMenu *menu)
2255 {
2256 if (!m_fileMenus.Member(menu))
2257 m_fileMenus.Append(menu);
2258 }
2259
2260 void wxFileHistory::RemoveMenu(wxMenu *menu)
2261 {
2262 m_fileMenus.DeleteObject(menu);
2263 }
2264
2265 #if wxUSE_CONFIG
2266 void wxFileHistory::Load(wxConfigBase& config)
2267 {
2268 m_fileHistoryN = 0;
2269 wxString buf;
2270 buf.Printf(wxT("file%d"), (int)m_fileHistoryN+1);
2271 wxString historyFile;
2272 while ((m_fileHistoryN < m_fileMaxFiles) && config.Read(buf, &historyFile) && (!historyFile.empty()))
2273 {
2274 m_fileHistory[m_fileHistoryN] = MYcopystring((const wxChar*) historyFile);
2275 m_fileHistoryN ++;
2276 buf.Printf(wxT("file%d"), (int)m_fileHistoryN+1);
2277 historyFile = wxEmptyString;
2278 }
2279 AddFilesToMenu();
2280 }
2281
2282 void wxFileHistory::Save(wxConfigBase& config)
2283 {
2284 size_t i;
2285 for (i = 0; i < m_fileMaxFiles; i++)
2286 {
2287 wxString buf;
2288 buf.Printf(wxT("file%d"), (int)i+1);
2289 if (i < m_fileHistoryN)
2290 config.Write(buf, wxString(m_fileHistory[i]));
2291 else
2292 config.Write(buf, wxEmptyString);
2293 }
2294 }
2295 #endif // wxUSE_CONFIG
2296
2297 void wxFileHistory::AddFilesToMenu()
2298 {
2299 if (m_fileHistoryN > 0)
2300 {
2301 wxList::compatibility_iterator node = m_fileMenus.GetFirst();
2302 while (node)
2303 {
2304 wxMenu* menu = (wxMenu*) node->GetData();
2305 if (menu->GetMenuItemCount())
2306 {
2307 menu->AppendSeparator();
2308 }
2309
2310 size_t i;
2311 for (i = 0; i < m_fileHistoryN; i++)
2312 {
2313 if (m_fileHistory[i])
2314 {
2315 wxString buf;
2316 buf.Printf(s_MRUEntryFormat, i+1, m_fileHistory[i]);
2317 menu->Append(m_idBase+i, buf);
2318 }
2319 }
2320 node = node->GetNext();
2321 }
2322 }
2323 }
2324
2325 void wxFileHistory::AddFilesToMenu(wxMenu* menu)
2326 {
2327 if (m_fileHistoryN > 0)
2328 {
2329 if (menu->GetMenuItemCount())
2330 {
2331 menu->AppendSeparator();
2332 }
2333
2334 size_t i;
2335 for (i = 0; i < m_fileHistoryN; i++)
2336 {
2337 if (m_fileHistory[i])
2338 {
2339 wxString buf;
2340 buf.Printf(s_MRUEntryFormat, i+1, m_fileHistory[i]);
2341 menu->Append(m_idBase+i, buf);
2342 }
2343 }
2344 }
2345 }
2346
2347 // ----------------------------------------------------------------------------
2348 // Permits compatibility with existing file formats and functions that
2349 // manipulate files directly
2350 // ----------------------------------------------------------------------------
2351
2352 #if wxUSE_STD_IOSTREAM
2353
2354 bool wxTransferFileToStream(const wxString& filename, wxSTD ostream& stream)
2355 {
2356 wxFFile file(filename, _T("rb"));
2357 if ( !file.IsOpened() )
2358 return false;
2359
2360 char buf[4096];
2361
2362 size_t nRead;
2363 do
2364 {
2365 nRead = file.Read(buf, WXSIZEOF(buf));
2366 if ( file.Error() )
2367 return false;
2368
2369 stream.write(buf, nRead);
2370 if ( !stream )
2371 return false;
2372 }
2373 while ( !file.Eof() );
2374
2375 return true;
2376 }
2377
2378 bool wxTransferStreamToFile(wxSTD istream& stream, const wxString& filename)
2379 {
2380 wxFFile file(filename, _T("wb"));
2381 if ( !file.IsOpened() )
2382 return false;
2383
2384 char buf[4096];
2385 do
2386 {
2387 stream.read(buf, WXSIZEOF(buf));
2388 if ( !stream.bad() ) // fail may be set on EOF, don't use operator!()
2389 {
2390 if ( !file.Write(buf, stream.gcount()) )
2391 return false;
2392 }
2393 }
2394 while ( !stream.eof() );
2395
2396 return true;
2397 }
2398
2399 #else // !wxUSE_STD_IOSTREAM
2400
2401 bool wxTransferFileToStream(const wxString& filename, wxOutputStream& stream)
2402 {
2403 wxFFile file(filename, _T("rb"));
2404 if ( !file.IsOpened() )
2405 return false;
2406
2407 char buf[4096];
2408
2409 size_t nRead;
2410 do
2411 {
2412 nRead = file.Read(buf, WXSIZEOF(buf));
2413 if ( file.Error() )
2414 return false;
2415
2416 stream.Write(buf, nRead);
2417 if ( !stream )
2418 return false;
2419 }
2420 while ( !file.Eof() );
2421
2422 return true;
2423 }
2424
2425 bool wxTransferStreamToFile(wxInputStream& stream, const wxString& filename)
2426 {
2427 wxFFile file(filename, _T("wb"));
2428 if ( !file.IsOpened() )
2429 return false;
2430
2431 char buf[4096];
2432 do
2433 {
2434 stream.Read(buf, WXSIZEOF(buf));
2435
2436 const size_t nRead = stream.LastRead();
2437 if ( !nRead || !file.Write(buf, nRead) )
2438 return false;
2439 }
2440 while ( !stream.Eof() );
2441
2442 return true;
2443 }
2444
2445 #endif // wxUSE_STD_IOSTREAM/!wxUSE_STD_IOSTREAM
2446
2447 #endif // wxUSE_DOC_VIEW_ARCHITECTURE