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