1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Doc/View classes
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
17 #if wxUSE_DOC_VIEW_ARCHITECTURE
20 #include "wx/string.h"
22 #include "wx/filehistory.h"
24 #if wxUSE_PRINTING_ARCHITECTURE
28 class WXDLLIMPEXP_FWD_CORE wxWindow
;
29 class WXDLLIMPEXP_FWD_CORE wxDocument
;
30 class WXDLLIMPEXP_FWD_CORE wxView
;
31 class WXDLLIMPEXP_FWD_CORE wxDocTemplate
;
32 class WXDLLIMPEXP_FWD_CORE wxDocManager
;
33 class WXDLLIMPEXP_FWD_CORE wxPrintInfo
;
34 class WXDLLIMPEXP_FWD_CORE wxCommandProcessor
;
35 class WXDLLIMPEXP_FWD_BASE wxConfigBase
;
37 class wxDocChildFrameAnyBase
;
39 #if wxUSE_STD_IOSTREAM
40 #include "wx/iosfwrap.h"
42 #include "wx/stream.h"
45 // Flags for wxDocManager (can be combined).
52 // Document template flags
55 wxTEMPLATE_VISIBLE
= 1,
56 wxTEMPLATE_INVISIBLE
= 2,
57 wxDEFAULT_TEMPLATE_FLAGS
= wxTEMPLATE_VISIBLE
60 #define wxMAX_FILE_HISTORY 9
62 class WXDLLIMPEXP_CORE wxDocument
: public wxEvtHandler
65 wxDocument(wxDocument
*parent
= NULL
);
66 virtual ~wxDocument();
69 void SetFilename(const wxString
& filename
, bool notifyViews
= false);
70 wxString
GetFilename() const { return m_documentFile
; }
72 void SetTitle(const wxString
& title
) { m_documentTitle
= title
; }
73 wxString
GetTitle() const { return m_documentTitle
; }
75 void SetDocumentName(const wxString
& name
) { m_documentTypeName
= name
; }
76 wxString
GetDocumentName() const { return m_documentTypeName
; }
78 // access the flag indicating whether this document had been already saved,
79 // SetDocumentSaved() is only used internally, don't call it
80 bool GetDocumentSaved() const { return m_savedYet
; }
81 void SetDocumentSaved(bool saved
= true) { m_savedYet
= saved
; }
83 // return true if the document hasn't been modified since the last time it
84 // was saved (implying that it returns false if it was never saved, even if
85 // the document is not modified)
86 bool AlreadySaved() const { return !IsModified() && GetDocumentSaved(); }
90 virtual bool SaveAs();
91 virtual bool Revert();
93 #if wxUSE_STD_IOSTREAM
94 virtual wxSTD ostream
& SaveObject(wxSTD ostream
& stream
);
95 virtual wxSTD istream
& LoadObject(wxSTD istream
& stream
);
97 virtual wxOutputStream
& SaveObject(wxOutputStream
& stream
);
98 virtual wxInputStream
& LoadObject(wxInputStream
& stream
);
101 // Called by wxWidgets
102 virtual bool OnSaveDocument(const wxString
& filename
);
103 virtual bool OnOpenDocument(const wxString
& filename
);
104 virtual bool OnNewDocument();
105 virtual bool OnCloseDocument();
107 // Prompts for saving if about to close a modified document. Returns true
108 // if ok to close the document (may have saved in the meantime, or set
109 // modified to false)
110 virtual bool OnSaveModified();
112 // if you override, remember to call the default
113 // implementation (wxDocument::OnChangeFilename)
114 virtual void OnChangeFilename(bool notifyViews
);
116 // Called by framework if created automatically by the default document
117 // manager: gives document a chance to initialise and (usually) create a
119 virtual bool OnCreate(const wxString
& path
, long flags
);
121 // By default, creates a base wxCommandProcessor.
122 virtual wxCommandProcessor
*OnCreateCommandProcessor();
123 virtual wxCommandProcessor
*GetCommandProcessor() const
124 { return m_commandProcessor
; }
125 virtual void SetCommandProcessor(wxCommandProcessor
*proc
)
126 { m_commandProcessor
= proc
; }
128 // Called after a view is added or removed. The default implementation
129 // deletes the document if this is there are no more views.
130 virtual void OnChangedViewList();
132 // Called from OnCloseDocument(), does nothing by default but may be
133 // overridden. Return value is ignored.
134 virtual bool DeleteContents();
136 virtual bool Draw(wxDC
&);
137 virtual bool IsModified() const { return m_documentModified
; }
138 virtual void Modify(bool mod
);
140 virtual bool AddView(wxView
*view
);
141 virtual bool RemoveView(wxView
*view
);
142 wxList
& GetViews() { return m_documentViews
; }
143 const wxList
& GetViews() const { return m_documentViews
; }
144 wxView
*GetFirstView() const;
146 virtual void UpdateAllViews(wxView
*sender
= NULL
, wxObject
*hint
= NULL
);
147 virtual void NotifyClosing();
149 // Remove all views (because we're closing the document)
150 virtual bool DeleteAllViews();
153 virtual wxDocManager
*GetDocumentManager() const;
154 virtual wxDocTemplate
*GetDocumentTemplate() const
155 { return m_documentTemplate
; }
156 virtual void SetDocumentTemplate(wxDocTemplate
*temp
)
157 { m_documentTemplate
= temp
; }
159 // Get the document name to be shown to the user: the title if there is
160 // any, otherwise the filename if the document was saved and, finally,
161 // "unnamed" otherwise
162 virtual wxString
GetUserReadableName() const;
164 #if WXWIN_COMPATIBILITY_2_8
165 // use GetUserReadableName() instead
166 wxDEPRECATED_BUT_USED_INTERNALLY(
167 virtual bool GetPrintableName(wxString
& buf
) const
169 #endif // WXWIN_COMPATIBILITY_2_8
171 // Returns a window that can be used as a parent for document-related
172 // dialogs. Override if necessary.
173 virtual wxWindow
*GetDocumentWindow() const;
176 wxList m_documentViews
;
177 wxString m_documentFile
;
178 wxString m_documentTitle
;
179 wxString m_documentTypeName
;
180 wxDocTemplate
* m_documentTemplate
;
181 bool m_documentModified
;
182 wxDocument
* m_documentParent
;
183 wxCommandProcessor
* m_commandProcessor
;
186 // Called by OnSaveDocument and OnOpenDocument to implement standard
187 // Save/Load behavior. Re-implement in derived class for custom
189 virtual bool DoSaveDocument(const wxString
& file
);
190 virtual bool DoOpenDocument(const wxString
& file
);
192 // the default implementation of GetUserReadableName()
193 wxString
DoGetUserReadableName() const;
196 DECLARE_ABSTRACT_CLASS(wxDocument
)
197 wxDECLARE_NO_COPY_CLASS(wxDocument
);
200 class WXDLLIMPEXP_CORE wxView
: public wxEvtHandler
206 wxDocument
*GetDocument() const { return m_viewDocument
; }
207 virtual void SetDocument(wxDocument
*doc
);
209 wxString
GetViewName() const { return m_viewTypeName
; }
210 void SetViewName(const wxString
& name
) { m_viewTypeName
= name
; }
212 wxWindow
*GetFrame() const { return m_viewFrame
; }
213 void SetFrame(wxWindow
*frame
) { m_viewFrame
= frame
; }
215 virtual void OnActivateView(bool activate
,
217 wxView
*deactiveView
);
218 virtual void OnDraw(wxDC
*dc
) = 0;
219 virtual void OnPrint(wxDC
*dc
, wxObject
*info
);
220 virtual void OnUpdate(wxView
*sender
, wxObject
*hint
= NULL
);
221 virtual void OnClosingDocument() {}
222 virtual void OnChangeFilename();
224 // Called by framework if created automatically by the default document
225 // manager class: gives view a chance to initialise
226 virtual bool OnCreate(wxDocument
*WXUNUSED(doc
), long WXUNUSED(flags
))
229 // Checks if the view is the last one for the document; if so, asks user
230 // to confirm save data (if modified). If ok, deletes itself and returns
232 virtual bool Close(bool deleteWindow
= true);
234 // Override to do cleanup/veto close
235 virtual bool OnClose(bool deleteWindow
);
237 // A view's window can call this to notify the view it is (in)active.
238 // The function then notifies the document manager.
239 virtual void Activate(bool activate
);
241 wxDocManager
*GetDocumentManager() const
242 { return m_viewDocument
->GetDocumentManager(); }
244 #if wxUSE_PRINTING_ARCHITECTURE
245 virtual wxPrintout
*OnCreatePrintout();
248 // implementation only
249 // -------------------
251 // set the associated frame, it is used to reset its view when we're
253 void SetDocChildFrame(wxDocChildFrameAnyBase
*docChildFrame
);
256 // hook the document into event handlers chain here
257 virtual bool TryBefore(wxEvent
& event
);
259 wxDocument
* m_viewDocument
;
260 wxString m_viewTypeName
;
261 wxWindow
* m_viewFrame
;
263 wxDocChildFrameAnyBase
*m_docChildFrame
;
266 DECLARE_ABSTRACT_CLASS(wxView
)
267 wxDECLARE_NO_COPY_CLASS(wxView
);
270 // Represents user interface (and other) properties of documents and views
271 class WXDLLIMPEXP_CORE wxDocTemplate
: public wxObject
274 friend class WXDLLIMPEXP_FWD_CORE wxDocManager
;
277 // Associate document and view types. They're for identifying what view is
278 // associated with what template/document type
279 wxDocTemplate(wxDocManager
*manager
,
280 const wxString
& descr
,
281 const wxString
& filter
,
284 const wxString
& docTypeName
,
285 const wxString
& viewTypeName
,
286 wxClassInfo
*docClassInfo
= NULL
,
287 wxClassInfo
*viewClassInfo
= NULL
,
288 long flags
= wxDEFAULT_TEMPLATE_FLAGS
);
290 virtual ~wxDocTemplate();
292 // By default, these two member functions dynamically creates document and
293 // view using dynamic instance construction. Override these if you need a
294 // different method of construction.
295 virtual wxDocument
*CreateDocument(const wxString
& path
, long flags
= 0);
296 virtual wxView
*CreateView(wxDocument
*doc
, long flags
= 0);
298 // Helper method for CreateDocument; also allows you to do your own document
300 virtual bool InitDocument(wxDocument
* doc
,
301 const wxString
& path
,
304 wxString
GetDefaultExtension() const { return m_defaultExt
; }
305 wxString
GetDescription() const { return m_description
; }
306 wxString
GetDirectory() const { return m_directory
; }
307 wxDocManager
*GetDocumentManager() const { return m_documentManager
; }
308 void SetDocumentManager(wxDocManager
*manager
)
309 { m_documentManager
= manager
; }
310 wxString
GetFileFilter() const { return m_fileFilter
; }
311 long GetFlags() const { return m_flags
; }
312 virtual wxString
GetViewName() const { return m_viewTypeName
; }
313 virtual wxString
GetDocumentName() const { return m_docTypeName
; }
315 void SetFileFilter(const wxString
& filter
) { m_fileFilter
= filter
; }
316 void SetDirectory(const wxString
& dir
) { m_directory
= dir
; }
317 void SetDescription(const wxString
& descr
) { m_description
= descr
; }
318 void SetDefaultExtension(const wxString
& ext
) { m_defaultExt
= ext
; }
319 void SetFlags(long flags
) { m_flags
= flags
; }
321 bool IsVisible() const { return (m_flags
& wxTEMPLATE_VISIBLE
) != 0; }
323 wxClassInfo
* GetDocClassInfo() const { return m_docClassInfo
; }
324 wxClassInfo
* GetViewClassInfo() const { return m_viewClassInfo
; }
326 virtual bool FileMatchesTemplate(const wxString
& path
);
330 wxString m_fileFilter
;
331 wxString m_directory
;
332 wxString m_description
;
333 wxString m_defaultExt
;
334 wxString m_docTypeName
;
335 wxString m_viewTypeName
;
336 wxDocManager
* m_documentManager
;
338 // For dynamic creation of appropriate instances.
339 wxClassInfo
* m_docClassInfo
;
340 wxClassInfo
* m_viewClassInfo
;
342 // Called by CreateDocument and CreateView to create the actual
343 // document/view object.
345 // By default uses the ClassInfo provided to the constructor. Override
346 // these functions to provide a different method of creation.
347 virtual wxDocument
*DoCreateDocument();
348 virtual wxView
*DoCreateView();
351 DECLARE_CLASS(wxDocTemplate
)
352 wxDECLARE_NO_COPY_CLASS(wxDocTemplate
);
355 // One object of this class may be created in an application, to manage all
356 // the templates and documents.
357 class WXDLLIMPEXP_CORE wxDocManager
: public wxEvtHandler
360 // NB: flags are unused, don't pass wxDOC_XXX to this ctor
361 wxDocManager(long flags
= 0, bool initialize
= true);
362 virtual ~wxDocManager();
364 virtual bool Initialize();
366 // Handlers for common user commands
367 void OnFileClose(wxCommandEvent
& event
);
368 void OnFileCloseAll(wxCommandEvent
& event
);
369 void OnFileNew(wxCommandEvent
& event
);
370 void OnFileOpen(wxCommandEvent
& event
);
371 void OnFileRevert(wxCommandEvent
& event
);
372 void OnFileSave(wxCommandEvent
& event
);
373 void OnFileSaveAs(wxCommandEvent
& event
);
374 #if wxUSE_PRINTING_ARCHITECTURE
375 void OnPrint(wxCommandEvent
& event
);
376 void OnPreview(wxCommandEvent
& event
);
377 void OnPageSetup(wxCommandEvent
& event
);
378 #endif // wxUSE_PRINTING_ARCHITECTURE
379 void OnUndo(wxCommandEvent
& event
);
380 void OnRedo(wxCommandEvent
& event
);
382 // Handlers for UI update commands
383 void OnUpdateFileOpen(wxUpdateUIEvent
& event
);
384 void OnUpdateDisableIfNoDoc(wxUpdateUIEvent
& event
);
385 void OnUpdateFileRevert(wxUpdateUIEvent
& event
);
386 void OnUpdateFileNew(wxUpdateUIEvent
& event
);
387 void OnUpdateFileSave(wxUpdateUIEvent
& event
);
388 void OnUpdateUndo(wxUpdateUIEvent
& event
);
389 void OnUpdateRedo(wxUpdateUIEvent
& event
);
391 // called when file format detection didn't work, can be overridden to do
392 // something in this case
393 virtual void OnOpenFileFailure() { }
395 virtual wxDocument
*CreateDocument(const wxString
& path
, long flags
= 0);
397 // wrapper around CreateDocument() with a more clear name
398 wxDocument
*CreateNewDocument()
399 { return CreateDocument(wxString(), wxDOC_NEW
); }
401 virtual wxView
*CreateView(wxDocument
*doc
, long flags
= 0);
402 virtual void DeleteTemplate(wxDocTemplate
*temp
, long flags
= 0);
403 virtual bool FlushDoc(wxDocument
*doc
);
404 virtual wxDocTemplate
*MatchTemplate(const wxString
& path
);
405 virtual wxDocTemplate
*SelectDocumentPath(wxDocTemplate
**templates
,
406 int noTemplates
, wxString
& path
, long flags
, bool save
= false);
407 virtual wxDocTemplate
*SelectDocumentType(wxDocTemplate
**templates
,
408 int noTemplates
, bool sort
= false);
409 virtual wxDocTemplate
*SelectViewType(wxDocTemplate
**templates
,
410 int noTemplates
, bool sort
= false);
411 virtual wxDocTemplate
*FindTemplateForPath(const wxString
& path
);
413 void AssociateTemplate(wxDocTemplate
*temp
);
414 void DisassociateTemplate(wxDocTemplate
*temp
);
416 wxDocument
*GetCurrentDocument() const;
418 void SetMaxDocsOpen(int n
) { m_maxDocsOpen
= n
; }
419 int GetMaxDocsOpen() const { return m_maxDocsOpen
; }
421 // Add and remove a document from the manager's list
422 void AddDocument(wxDocument
*doc
);
423 void RemoveDocument(wxDocument
*doc
);
425 // closes all currently open documents
426 bool CloseDocuments(bool force
= true);
428 // closes the specified document
429 bool CloseDocument(wxDocument
* doc
, bool force
= false);
431 // Clear remaining documents and templates
432 bool Clear(bool force
= true);
434 // Views or windows should inform the document manager
435 // when a view is going in or out of focus
436 virtual void ActivateView(wxView
*view
, bool activate
= true);
437 virtual wxView
*GetCurrentView() const { return m_currentView
; }
439 wxList
& GetDocuments() { return m_docs
; }
440 wxList
& GetTemplates() { return m_templates
; }
442 // Return the default name for a new document (by default returns strings
443 // in the form "unnamed <counter>" but can be overridden)
444 virtual wxString
MakeNewDocumentName();
446 // Make a frame title (override this to do something different)
447 virtual wxString
MakeFrameTitle(wxDocument
* doc
);
449 virtual wxFileHistory
*OnCreateFileHistory();
450 virtual wxFileHistory
*GetFileHistory() const { return m_fileHistory
; }
452 // File history management
453 virtual void AddFileToHistory(const wxString
& file
);
454 virtual void RemoveFileFromHistory(size_t i
);
455 virtual size_t GetHistoryFilesCount() const;
456 virtual wxString
GetHistoryFile(size_t i
) const;
457 virtual void FileHistoryUseMenu(wxMenu
*menu
);
458 virtual void FileHistoryRemoveMenu(wxMenu
*menu
);
460 virtual void FileHistoryLoad(const wxConfigBase
& config
);
461 virtual void FileHistorySave(wxConfigBase
& config
);
462 #endif // wxUSE_CONFIG
464 virtual void FileHistoryAddFilesToMenu();
465 virtual void FileHistoryAddFilesToMenu(wxMenu
* menu
);
467 wxString
GetLastDirectory() const;
468 void SetLastDirectory(const wxString
& dir
) { m_lastDirectory
= dir
; }
470 // Get the current document manager
471 static wxDocManager
* GetDocumentManager() { return sm_docManager
; }
473 #if WXWIN_COMPATIBILITY_2_8
474 // deprecated, override GetDefaultName() instead
475 wxDEPRECATED_BUT_USED_INTERNALLY(
476 virtual bool MakeDefaultName(wxString
& buf
)
480 #if WXWIN_COMPATIBILITY_2_6
481 // deprecated, use GetHistoryFilesCount() instead
482 wxDEPRECATED( size_t GetNoHistoryFiles() const );
483 #endif // WXWIN_COMPATIBILITY_2_6
487 #if wxUSE_PRINTING_ARCHITECTURE
488 virtual wxPreviewFrame
* CreatePreviewFrame(wxPrintPreviewBase
* preview
,
490 const wxString
& title
);
491 #endif // wxUSE_PRINTING_ARCHITECTURE
493 // hook the currently active view into event handlers chain here
494 virtual bool TryBefore(wxEvent
& event
);
496 // return the command processor for the current document, if any
497 wxCommandProcessor
*GetCurrentCommandProcessor() const;
499 // this method tries to find an active view harder than GetCurrentView():
500 // if the latter is NULL, it also checks if we don't have just a single
501 // view and returns it then
502 wxView
*GetActiveView() const;
505 int m_defaultDocumentNameCounter
;
509 wxView
* m_currentView
;
510 wxFileHistory
* m_fileHistory
;
511 wxString m_lastDirectory
;
512 static wxDocManager
* sm_docManager
;
514 #if wxUSE_PRINTING_ARCHITECTURE
515 wxPageSetupDialogData m_pageSetupDialogData
;
516 #endif // wxUSE_PRINTING_ARCHITECTURE
518 DECLARE_EVENT_TABLE()
519 DECLARE_DYNAMIC_CLASS(wxDocManager
)
520 wxDECLARE_NO_COPY_CLASS(wxDocManager
);
523 #if WXWIN_COMPATIBILITY_2_6
524 inline size_t wxDocManager::GetNoHistoryFiles() const
526 return GetHistoryFilesCount();
528 #endif // WXWIN_COMPATIBILITY_2_6
530 // ----------------------------------------------------------------------------
531 // Base class for child frames -- this is what wxView renders itself into
533 // Notice that this is a mix-in class so it doesn't derive from wxWindow, only
534 // wxDocChildFrameAny does
535 // ----------------------------------------------------------------------------
537 class WXDLLIMPEXP_CORE wxDocChildFrameAnyBase
540 // default ctor, use Create() after it
541 wxDocChildFrameAnyBase()
543 m_childDocument
= NULL
;
548 // full ctor equivalent to using the default one and Create(0
549 wxDocChildFrameAnyBase(wxDocument
*doc
, wxView
*view
, wxWindow
*win
)
551 Create(doc
, view
, win
);
554 // method which must be called for an object created using the default ctor
556 // note that it returns bool just for consistency with Create() methods in
557 // other classes, we never return false from here
558 bool Create(wxDocument
*doc
, wxView
*view
, wxWindow
*win
)
560 m_childDocument
= doc
;
565 view
->SetDocChildFrame(this);
570 // dtor doesn't need to be virtual, an object should never be destroyed via
571 // a pointer to this class
572 ~wxDocChildFrameAnyBase()
574 // prevent the view from deleting us if we're being deleted directly
575 // (and not via Close() + Destroy())
577 m_childView
->SetDocChildFrame(NULL
);
580 wxDocument
*GetDocument() const { return m_childDocument
; }
581 wxView
*GetView() const { return m_childView
; }
582 void SetDocument(wxDocument
*doc
) { m_childDocument
= doc
; }
583 void SetView(wxView
*view
) { m_childView
= view
; }
585 wxWindow
*GetWindow() const { return m_win
; }
588 // we're not a wxEvtHandler but we provide this wxEvtHandler-like function
589 // which is called from TryBefore() of the derived classes to give our view
590 // a chance to process the message before the frame event handlers are used
591 bool TryProcessEvent(wxEvent
& event
)
593 return m_childView
&& m_childView
->ProcessEventLocally(event
);
596 // called from EVT_CLOSE handler in the frame: check if we can close and do
597 // cleanup if so; veto the event otherwise
598 bool CloseView(wxCloseEvent
& event
);
601 wxDocument
* m_childDocument
;
604 // the associated window: having it here is not terribly elegant but it
605 // allows us to avoid having any virtual functions in this class
609 wxDECLARE_NO_COPY_CLASS(wxDocChildFrameAnyBase
);
612 // ----------------------------------------------------------------------------
613 // Template implementing child frame concept using the given wxFrame-like class
615 // This is used to define wxDocChildFrame and wxDocMDIChildFrame: ChildFrame is
616 // a wxFrame or wxMDIChildFrame (although in theory it could be any wxWindow-
617 // derived class as long as it provided a ctor with the same signature as
618 // wxFrame and OnActivate() method) and ParentFrame is either wxFrame or
620 // ----------------------------------------------------------------------------
622 template <class ChildFrame
, class ParentFrame
>
623 class WXDLLIMPEXP_CORE wxDocChildFrameAny
: public ChildFrame
,
624 public wxDocChildFrameAnyBase
627 typedef ChildFrame BaseClass
;
629 // default ctor, use Create after it
630 wxDocChildFrameAny() { }
632 // ctor for a frame showing the given view of the specified document
633 wxDocChildFrameAny(wxDocument
*doc
,
637 const wxString
& title
,
638 const wxPoint
& pos
= wxDefaultPosition
,
639 const wxSize
& size
= wxDefaultSize
,
640 long style
= wxDEFAULT_FRAME_STYLE
,
641 const wxString
& name
= wxFrameNameStr
)
643 Create(doc
, view
, parent
, id
, title
, pos
, size
, style
, name
);
646 bool Create(wxDocument
*doc
,
650 const wxString
& title
,
651 const wxPoint
& pos
= wxDefaultPosition
,
652 const wxSize
& size
= wxDefaultSize
,
653 long style
= wxDEFAULT_FRAME_STYLE
,
654 const wxString
& name
= wxFrameNameStr
)
656 if ( !wxDocChildFrameAnyBase::Create(doc
, view
, this) )
659 if ( !BaseClass::Create(parent
, id
, title
, pos
, size
, style
, name
) )
662 this->Connect(wxEVT_ACTIVATE
,
663 wxActivateEventHandler(wxDocChildFrameAny::OnActivate
));
664 this->Connect(wxEVT_CLOSE_WINDOW
,
665 wxCloseEventHandler(wxDocChildFrameAny::OnCloseWindow
));
670 virtual bool Destroy()
672 // FIXME: why exactly do we do this? to avoid activation events during
673 // destructions maybe?
675 return BaseClass::Destroy();
679 // hook the child view into event handlers chain here
680 virtual bool TryBefore(wxEvent
& event
)
682 return TryProcessEvent(event
) || BaseClass::TryBefore(event
);
686 void OnActivate(wxActivateEvent
& event
)
688 BaseClass::OnActivate(event
);
691 m_childView
->Activate(event
.GetActive());
694 void OnCloseWindow(wxCloseEvent
& event
)
696 if ( CloseView(event
) )
701 wxDECLARE_NO_COPY_TEMPLATE_CLASS_2(wxDocChildFrameAny
,
702 ChildFrame
, ParentFrame
);
705 // ----------------------------------------------------------------------------
706 // A default child frame: we need to define it as a class just for wxRTTI,
707 // otherwise we could simply typedef it
708 // ----------------------------------------------------------------------------
711 // "non dll-interface class 'wxDocChildFrameAny<>' used as base interface
712 // for dll-interface class 'wxDocChildFrame'" -- this is bogus as the
713 // template will be DLL-exported but only once it is used as base class
715 #pragma warning (push)
716 #pragma warning (disable:4275)
719 typedef wxDocChildFrameAny
<wxFrame
, wxFrame
> wxDocChildFrameBase
;
721 class WXDLLIMPEXP_CORE wxDocChildFrame
: public wxDocChildFrameBase
728 wxDocChildFrame(wxDocument
*doc
,
732 const wxString
& title
,
733 const wxPoint
& pos
= wxDefaultPosition
,
734 const wxSize
& size
= wxDefaultSize
,
735 long style
= wxDEFAULT_FRAME_STYLE
,
736 const wxString
& name
= wxFrameNameStr
)
737 : wxDocChildFrameBase(doc
, view
,
738 parent
, id
, title
, pos
, size
, style
, name
)
742 bool Create(wxDocument
*doc
,
746 const wxString
& title
,
747 const wxPoint
& pos
= wxDefaultPosition
,
748 const wxSize
& size
= wxDefaultSize
,
749 long style
= wxDEFAULT_FRAME_STYLE
,
750 const wxString
& name
= wxFrameNameStr
)
752 return wxDocChildFrameBase::Create
755 parent
, id
, title
, pos
, size
, style
, name
760 DECLARE_CLASS(wxDocChildFrame
)
761 wxDECLARE_NO_COPY_CLASS(wxDocChildFrame
);
764 // ----------------------------------------------------------------------------
765 // wxDocParentFrame and related classes.
767 // As with wxDocChildFrame we define a template base class used by both normal
769 // ----------------------------------------------------------------------------
771 // Base class containing type-independent code of wxDocParentFrameAny
773 // Similarly to wxDocChildFrameAnyBase, this class is a mix-in and doesn't
774 // derive from wxWindow.
775 class WXDLLIMPEXP_CORE wxDocParentFrameAnyBase
778 wxDocParentFrameAnyBase() { m_docManager
= NULL
; }
780 wxDocManager
*GetDocumentManager() const { return m_docManager
; }
783 // Open the MRU file with the given index in our associated file history.
785 // This is called from the derived class event handler for the MRU menu
787 void DoOpenMRUFile(unsigned n
);
789 wxDocManager
*m_docManager
;
791 wxDECLARE_NO_COPY_CLASS(wxDocParentFrameAnyBase
);
794 // This is similar to wxDocChildFrameAny and is used to provide common
795 // implementation for both wxDocParentFrame and wxDocMDIParentFrame
796 template <class BaseFrame
>
797 class WXDLLIMPEXP_CORE wxDocParentFrameAny
: public BaseFrame
,
798 public wxDocParentFrameAnyBase
801 wxDocParentFrameAny() { }
802 wxDocParentFrameAny(wxDocManager
*manager
,
805 const wxString
& title
,
806 const wxPoint
& pos
= wxDefaultPosition
,
807 const wxSize
& size
= wxDefaultSize
,
808 long style
= wxDEFAULT_FRAME_STYLE
,
809 const wxString
& name
= wxFrameNameStr
)
811 Create(manager
, frame
, id
, title
, pos
, size
, style
, name
);
814 bool Create(wxDocManager
*manager
,
817 const wxString
& title
,
818 const wxPoint
& pos
= wxDefaultPosition
,
819 const wxSize
& size
= wxDefaultSize
,
820 long style
= wxDEFAULT_FRAME_STYLE
,
821 const wxString
& name
= wxFrameNameStr
)
823 m_docManager
= manager
;
825 if ( !BaseFrame::Create(frame
, id
, title
, pos
, size
, style
, name
) )
828 this->Connect(wxID_EXIT
, wxEVT_COMMAND_MENU_SELECTED
,
829 wxCommandEventHandler(wxDocParentFrameAny::OnExit
));
830 this->Connect(wxID_FILE1
, wxID_FILE9
, wxEVT_COMMAND_MENU_SELECTED
,
831 wxCommandEventHandler(wxDocParentFrameAny::OnMRUFile
));
832 this->Connect(wxEVT_CLOSE_WINDOW
,
833 wxCloseEventHandler(wxDocParentFrameAny::OnCloseWindow
));
839 // hook the document manager into event handling chain here
840 virtual bool TryBefore(wxEvent
& event
)
842 if ( m_docManager
&& m_docManager
->ProcessEventLocally(event
) )
845 return BaseFrame::TryBefore(event
);
849 void OnExit(wxCommandEvent
& WXUNUSED(event
))
854 void OnMRUFile(wxCommandEvent
& event
)
856 DoOpenMRUFile(event
.GetId() - wxID_FILE1
);
859 void OnCloseWindow(wxCloseEvent
& event
)
861 if ( m_docManager
&& !m_docManager
->Clear(!event
.CanVeto()) )
863 // The user decided not to close finally, abort.
868 // Just skip the event, base class handler will destroy the window.
874 wxDECLARE_NO_COPY_CLASS(wxDocParentFrameAny
);
877 typedef wxDocParentFrameAny
<wxFrame
> wxDocParentFrameBase
;
879 class WXDLLIMPEXP_CORE wxDocParentFrame
: public wxDocParentFrameBase
882 wxDocParentFrame() : wxDocParentFrameBase() { }
884 wxDocParentFrame(wxDocManager
*manager
,
887 const wxString
& title
,
888 const wxPoint
& pos
= wxDefaultPosition
,
889 const wxSize
& size
= wxDefaultSize
,
890 long style
= wxDEFAULT_FRAME_STYLE
,
891 const wxString
& name
= wxFrameNameStr
)
892 : wxDocParentFrameBase(manager
,
893 parent
, id
, title
, pos
, size
, style
, name
)
897 bool Create(wxDocManager
*manager
,
900 const wxString
& title
,
901 const wxPoint
& pos
= wxDefaultPosition
,
902 const wxSize
& size
= wxDefaultSize
,
903 long style
= wxDEFAULT_FRAME_STYLE
,
904 const wxString
& name
= wxFrameNameStr
)
906 return wxDocParentFrameBase::Create(manager
,
908 pos
, size
, style
, name
);
912 DECLARE_CLASS(wxDocParentFrame
)
913 wxDECLARE_NO_COPY_CLASS(wxDocParentFrame
);
917 // reenable warning 4275
918 #pragma warning (pop)
921 // ----------------------------------------------------------------------------
922 // Provide simple default printing facilities
923 // ----------------------------------------------------------------------------
925 #if wxUSE_PRINTING_ARCHITECTURE
926 class WXDLLIMPEXP_CORE wxDocPrintout
: public wxPrintout
929 wxDocPrintout(wxView
*view
= NULL
, const wxString
& title
= wxT("Printout"));
931 // implement wxPrintout methods
932 virtual bool OnPrintPage(int page
);
933 virtual bool HasPage(int page
);
934 virtual bool OnBeginDocument(int startPage
, int endPage
);
935 virtual void GetPageInfo(int *minPage
, int *maxPage
,
936 int *selPageFrom
, int *selPageTo
);
938 virtual wxView
*GetView() { return m_printoutView
; }
941 wxView
* m_printoutView
;
944 DECLARE_DYNAMIC_CLASS(wxDocPrintout
)
945 wxDECLARE_NO_COPY_CLASS(wxDocPrintout
);
947 #endif // wxUSE_PRINTING_ARCHITECTURE
949 // For compatibility with existing file formats:
950 // converts from/to a stream to/from a temporary file.
951 #if wxUSE_STD_IOSTREAM
952 bool WXDLLIMPEXP_CORE
953 wxTransferFileToStream(const wxString
& filename
, wxSTD ostream
& stream
);
954 bool WXDLLIMPEXP_CORE
955 wxTransferStreamToFile(wxSTD istream
& stream
, const wxString
& filename
);
957 bool WXDLLIMPEXP_CORE
958 wxTransferFileToStream(const wxString
& filename
, wxOutputStream
& stream
);
959 bool WXDLLIMPEXP_CORE
960 wxTransferStreamToFile(wxInputStream
& stream
, const wxString
& filename
);
961 #endif // wxUSE_STD_IOSTREAM
964 // these flags are not used anywhere by wxWidgets and kept only for an unlikely
965 // case of existing user code using them for its own purposes
966 #ifdef WXWIN_COMPATIBILITY_2_8
971 wxDEFAULT_DOCMAN_FLAGS
= wxDOC_SDI
973 #endif // WXWIN_COMPATIBILITY_2_8
975 #endif // wxUSE_DOC_VIEW_ARCHITECTURE