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