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