include/wx/docview.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        docview.h
   3 // Purpose:     Doc/View classes
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_DOCH__
  13 #define _WX_DOCH__
  14
  15 #ifdef __GNUG__
  16 #pragma interface "docview.h"
  17 #endif
  18
  19 #include "wx/defs.h"
  20 #include "wx/list.h"
  21 #include "wx/cmndata.h"
  22 #include "wx/string.h"
  23
  24 #if wxUSE_PRINTING_ARCHITECTURE
  25 #include "wx/print.h"
  26 #endif
  27
  28 class WXDLLEXPORT wxWindow;
  29 class WXDLLEXPORT wxDocument;
  30 class WXDLLEXPORT wxView;
  31 class WXDLLEXPORT wxDocTemplate;
  32 class WXDLLEXPORT wxDocManager;
  33 class WXDLLEXPORT wxPrintInfo;
  34 class WXDLLEXPORT wxCommand;
  35 class WXDLLEXPORT wxCommandProcessor;
  36 class WXDLLEXPORT wxFileHistory;
  37 #if wxUSE_CONFIG
  38 class WXDLLEXPORT wxConfigBase;
  39 #endif
  40
  41 #if wxUSE_IOSTREAMH
  42 // N.B. BC++ doesn't have istream.h, ostream.h
  43 #  include <iostream.h>
  44 #else
  45 #  include <istream>
  46 #  include <ostream>
  47 #  ifdef __VISUALC__
  48       using namespace std;
  49 #  endif
  50 #endif
  51
  52 // Document manager flags
  53 #define wxDOC_SDI       1
  54 #define wxDOC_MDI       2
  55 #define wxDOC_NEW       4
  56 #define wxDOC_SILENT    8
  57 #define wxDEFAULT_DOCMAN_FLAGS      wxDOC_SDI
  58
  59 // Document template flags
  60 #define wxTEMPLATE_VISIBLE      1
  61 #define wxTEMPLATE_INVISIBLE    2
  62 #define wxDEFAULT_TEMPLATE_FLAGS    wxTEMPLATE_VISIBLE
  63
  64 #define wxMAX_FILE_HISTORY      9
  65
  66 class WXDLLEXPORT wxDocument : public wxEvtHandler
  67 {
  68   DECLARE_ABSTRACT_CLASS(wxDocument)
  69  public:
  70   wxDocument(wxDocument *parent = (wxDocument *) NULL);
  71   ~wxDocument(void);
  72
  73   void SetFilename(const wxString& filename, bool notifyViews = FALSE);
  74   inline wxString GetFilename(void) const { return m_documentFile; }
  75   inline void SetTitle(const wxString& title) { m_documentTitle = title; };
  76   inline wxString GetTitle(void) const { return m_documentTitle; }
  77   inline void SetDocumentName(const wxString& name) { m_documentTypeName = name; };
  78   inline wxString GetDocumentName(void) const { return m_documentTypeName; }
  79   // Has the document been saved yet?
  80   inline bool GetDocumentSaved(void) { return m_savedYet; }
  81   inline void SetDocumentSaved(bool saved = TRUE) { m_savedYet = saved; }
  82
  83   virtual bool Close(void);
  84   virtual bool Save(void);
  85   virtual bool SaveAs(void);
  86   virtual bool Revert(void);
  87
  88   virtual ostream& SaveObject(ostream& stream);
  89   virtual istream& LoadObject(istream& stream);
  90
  91   // Called by wxWindows
  92   virtual bool OnSaveDocument(const wxString& filename);
  93   virtual bool OnOpenDocument(const wxString& filename);
  94   virtual bool OnNewDocument(void);
  95   virtual bool OnCloseDocument(void);
  96
  97   // Prompts for saving if about to close a modified document.
  98   // Returns TRUE if ok to close the document (may have saved in the
  99   // meantime, or set modified to FALSE)
 100   virtual bool OnSaveModified(void);
 101
 102   // Called by framework if created automatically by the
 103   // default document manager: gives document a chance to
 104   // initialise and (usually) create a view
 105   virtual bool OnCreate(const wxString& path, long flags);
 106
 107   // By default, creates a base wxCommandProcessor.
 108   virtual wxCommandProcessor *OnCreateCommandProcessor(void);
 109   virtual inline wxCommandProcessor *GetCommandProcessor(void) const { return m_commandProcessor; }
 110   virtual inline void SetCommandProcessor(wxCommandProcessor *proc) { m_commandProcessor = proc; }
 111
 112   // Called after a view is added or removed.
 113   // The default implementation deletes the document if this
 114   // is there are no more views.
 115   virtual void OnChangedViewList(void);
 116
 117   virtual bool DeleteContents(void);
 118
 119   virtual bool Draw(wxDC&);
 120   virtual inline bool IsModified(void) const { return m_documentModified; }
 121   virtual inline void Modify(bool mod) { m_documentModified = mod; }
 122
 123   virtual bool AddView(wxView *view);
 124   virtual bool RemoveView(wxView *view);
 125   inline wxList& GetViews(void) const { return (wxList&) m_documentViews; }
 126   wxView *GetFirstView(void) const;
 127
 128   virtual void UpdateAllViews(wxView *sender = (wxView *) NULL, wxObject *hint = (wxObject *) NULL);
 129
 130   // Remove all views (because we're closing the document)
 131   virtual bool DeleteAllViews(void);
 132
 133   // Other stuff
 134   virtual wxDocManager *GetDocumentManager(void) const;
 135   virtual inline wxDocTemplate *GetDocumentTemplate(void) const { return m_documentTemplate; }
 136   virtual inline void SetDocumentTemplate(wxDocTemplate *temp) { m_documentTemplate = temp; }
 137
 138   // Get title, or filename if no title, else [unnamed]
 139   virtual bool GetPrintableName(wxString& buf) const;
 140
 141   // Returns a window that can be used as a parent for document-related
 142   // dialogs. Override if necessary.
 143   virtual wxWindow *GetDocumentWindow(void) const;
 144  protected:
 145   wxList                m_documentViews;
 146   wxString              m_documentFile;
 147   wxString              m_documentTitle;
 148   wxString              m_documentTypeName;
 149   wxDocTemplate*        m_documentTemplate;
 150   bool                  m_documentModified;
 151   wxDocument*           m_documentParent;
 152   wxCommandProcessor*   m_commandProcessor;
 153   bool                  m_savedYet;
 154 };
 155
 156 class WXDLLEXPORT wxView: public wxEvtHandler
 157 {
 158   DECLARE_ABSTRACT_CLASS(wxView)
 159  public:
 160   wxView(wxDocument *doc = (wxDocument *) NULL);
 161   ~wxView(void);
 162
 163   inline wxDocument *GetDocument(void) const { return m_viewDocument; }
 164   void SetDocument(wxDocument *doc);
 165
 166   inline wxString GetViewName(void) const { return m_viewTypeName; }
 167   void SetViewName(const wxString& name) { m_viewTypeName = name; };
 168
 169   inline wxFrame *GetFrame(void) const { return m_viewFrame ; }
 170   inline void SetFrame(wxFrame *frame) { m_viewFrame = frame; }
 171
 172   virtual void OnActivateView(bool activate, wxView *activeView, wxView *deactiveView);
 173   virtual void OnDraw(wxDC *dc) = 0;
 174   virtual void OnPrint(wxDC *dc, wxObject *info);
 175   virtual void OnUpdate(wxView *sender, wxObject *hint = (wxObject *) NULL);
 176   virtual void OnChangeFilename(void);
 177
 178   // Called by framework if created automatically by the
 179   // default document manager class: gives view a chance to
 180   // initialise
 181   virtual bool OnCreate(wxDocument *WXUNUSED(doc), long WXUNUSED(flags)) { return TRUE; };
 182
 183   // Checks if the view is the last one for the document; if so,
 184   // asks user to confirm save data (if modified). If ok,
 185   // deletes itself and returns TRUE.
 186   virtual bool Close(bool deleteWindow = TRUE);
 187
 188   // Override to do cleanup/veto close
 189   virtual bool OnClose(bool deleteWindow);
 190
 191 #if WXWIN_COMPATIBILITY
 192   // Defeat compiler warning
 193   bool OnClose(void) { return wxEvtHandler::OnClose(); }
 194 #endif
 195
 196   // Extend event processing to search the document's event table
 197   virtual bool ProcessEvent(wxEvent& event);
 198
 199   // A view's window can call this to notify the view it is (in)active.
 200   // The function then notifies the document manager.
 201   virtual void Activate(bool activate);
 202
 203   wxDocManager *GetDocumentManager(void) const
 204     { return m_viewDocument->GetDocumentManager(); }
 205
 206 #if wxUSE_PRINTING_ARCHITECTURE
 207   virtual wxPrintout *OnCreatePrintout(void);
 208 #endif
 209
 210  protected:
 211   wxDocument*       m_viewDocument;
 212   wxString          m_viewTypeName;
 213   wxFrame*          m_viewFrame;
 214 };
 215
 216 // Represents user interface (and other) properties of documents and views
 217 class WXDLLEXPORT wxDocTemplate: public wxObject
 218 {
 219   DECLARE_CLASS(wxDocTemplate)
 220
 221  friend class WXDLLEXPORT wxDocManager;
 222
 223  public:
 224
 225   // Associate document and view types.
 226   // They're for identifying what view is associated with what
 227   // template/document type
 228   wxDocTemplate(wxDocManager *manager, const wxString& descr, const wxString& filter, const wxString& dir,
 229      const wxString& ext, const wxString& docTypeName, const wxString& viewTypeName,
 230      wxClassInfo *docClassInfo = (wxClassInfo *) NULL, wxClassInfo *viewClassInfo = (wxClassInfo *)NULL,
 231      long flags = wxDEFAULT_TEMPLATE_FLAGS);
 232
 233   ~wxDocTemplate(void);
 234
 235   // By default, these two member functions dynamically creates document
 236   // and view using dynamic instance construction.
 237   // Override these if you need a different method of construction.
 238   virtual wxDocument *CreateDocument(const wxString& path, long flags = 0);
 239   virtual wxView *CreateView(wxDocument *doc, long flags = 0);
 240
 241   inline wxString GetDefaultExtension(void) const { return m_defaultExt; };
 242   inline wxString GetDescription(void) const { return m_description; }
 243   inline wxString GetDirectory(void) const { return m_directory; };
 244   inline wxDocManager *GetDocumentManager(void) const { return m_documentManager; }
 245   inline void SetDocumentManager(wxDocManager *manager) { m_documentManager = manager; }
 246   inline wxString GetFileFilter(void) const { return m_fileFilter; };
 247   inline long GetFlags(void) const { return m_flags; };
 248   virtual wxString GetViewName(void) const { return m_viewTypeName; }
 249   virtual wxString GetDocumentName(void) const { return m_docTypeName; }
 250
 251   inline void SetFileFilter(const wxString& filter) { m_fileFilter = filter; };
 252   inline void SetDirectory(const wxString& dir) { m_directory = dir; };
 253   inline void SetDescription(const wxString& descr) { m_description = descr; };
 254   inline void SetDefaultExtension(const wxString& ext) { m_defaultExt = ext; };
 255   inline void SetFlags(long flags) { m_flags = flags; };
 256
 257   inline bool IsVisible(void) const { return ((m_flags & wxTEMPLATE_VISIBLE) == wxTEMPLATE_VISIBLE); }
 258
 259  protected:
 260   long              m_flags;
 261   wxString          m_fileFilter;
 262   wxString          m_directory;
 263   wxString          m_description;
 264   wxString          m_defaultExt;
 265   wxString          m_docTypeName;
 266   wxString          m_viewTypeName;
 267   wxDocManager*     m_documentManager;
 268
 269   // For dynamic creation of appropriate instances.
 270   wxClassInfo*      m_docClassInfo;
 271   wxClassInfo*      m_viewClassInfo;
 272
 273 };
 274
 275 // One object of this class may be created in an application,
 276 // to manage all the templates and documents.
 277 class WXDLLEXPORT wxDocManager: public wxEvtHandler
 278 {
 279   DECLARE_DYNAMIC_CLASS(wxDocManager)
 280  public:
 281   wxDocManager(long flags = wxDEFAULT_DOCMAN_FLAGS, bool initialize = TRUE);
 282   ~wxDocManager(void);
 283
 284   virtual bool Initialize(void);
 285
 286   // Handlers for common user commands
 287 //   virtual void OldOnMenuCommand(int command);
 288
 289   void OnFileClose(wxCommandEvent& event);
 290   void OnFileNew(wxCommandEvent& event);
 291   void OnFileOpen(wxCommandEvent& event);
 292   void OnFileRevert(wxCommandEvent& event);
 293   void OnFileSave(wxCommandEvent& event);
 294   void OnFileSaveAs(wxCommandEvent& event);
 295   void OnPrint(wxCommandEvent& event);
 296   void OnPrintSetup(wxCommandEvent& event);
 297   void OnPreview(wxCommandEvent& event);
 298   void OnUndo(wxCommandEvent& event);
 299   void OnRedo(wxCommandEvent& event);
 300
 301   // Extend event processing to search the view's event table
 302   virtual bool ProcessEvent(wxEvent& event);
 303
 304   virtual wxDocument *CreateDocument(const wxString& path, long flags = 0);
 305   virtual wxView *CreateView(wxDocument *doc, long flags = 0);
 306   virtual void DeleteTemplate(wxDocTemplate *temp, long flags = 0);
 307   virtual bool FlushDoc(wxDocument *doc);
 308   virtual wxDocTemplate *MatchTemplate(const wxString& path);
 309   virtual wxDocTemplate *SelectDocumentPath(wxDocTemplate **templates,
 310     int noTemplates, wxString& path, long flags, bool save = FALSE);
 311   virtual wxDocTemplate *SelectDocumentType(wxDocTemplate **templates,
 312     int noTemplates);
 313   virtual wxDocTemplate *SelectViewType(wxDocTemplate **templates,
 314     int noTemplates);
 315   virtual wxDocTemplate *FindTemplateForPath(const wxString& path);
 316
 317   void AssociateTemplate(wxDocTemplate *temp);
 318   void DisassociateTemplate(wxDocTemplate *temp);
 319
 320   wxDocument *GetCurrentDocument(void) const;
 321
 322   inline void SetMaxDocsOpen(int n) { m_maxDocsOpen = n; }
 323   inline int GetMaxDocsOpen(void) const { return m_maxDocsOpen; }
 324
 325   // Add and remove a document from the manager's list
 326   void AddDocument(wxDocument *doc);
 327   void RemoveDocument(wxDocument *doc);
 328
 329   // Clear remaining documents and templates
 330   bool Clear(bool force = TRUE);
 331
 332   // Views or windows should inform the document manager
 333   // when a view is going in or out of focus
 334   virtual void ActivateView(wxView *view, bool activate = TRUE, bool deleting = FALSE);
 335   virtual wxView *GetCurrentView(void) const;
 336
 337   virtual inline wxList& GetDocuments(void) const { return (wxList&) m_docs; }
 338
 339   // Make a default document name
 340   virtual bool MakeDefaultName(wxString& buf);
 341
 342   virtual wxFileHistory *OnCreateFileHistory(void);
 343   virtual inline wxFileHistory *GetFileHistory(void) const { return m_fileHistory; }
 344
 345   // File history management
 346   virtual void AddFileToHistory(const wxString& file);
 347   virtual int GetNoHistoryFiles(void) const;
 348   virtual wxString GetHistoryFile(int i) const;
 349   virtual void FileHistoryUseMenu(wxMenu *menu);
 350   virtual void FileHistoryRemoveMenu(wxMenu *menu);
 351 #if wxUSE_CONFIG
 352   virtual void FileHistoryLoad(wxConfigBase& config);
 353   virtual void FileHistorySave(wxConfigBase& config);
 354 #endif
 355   virtual void FileHistoryAddFilesToMenu();
 356   virtual void FileHistoryAddFilesToMenu(wxMenu* menu);
 357  protected:
 358   long              m_flags;
 359   int               m_defaultDocumentNameCounter;
 360   int               m_maxDocsOpen;
 361   wxList            m_docs;
 362   wxList            m_templates;
 363   wxView*           m_currentView;
 364   wxFileHistory*    m_fileHistory;
 365
 366 DECLARE_EVENT_TABLE()
 367 };
 368
 369 /*
 370  * A default child frame
 371  */
 372
 373 class WXDLLEXPORT wxDocChildFrame: public wxFrame
 374 {
 375   DECLARE_CLASS(wxDocChildFrame)
 376
 377  public:
 378   wxDocChildFrame(wxDocument *doc, wxView *view, wxFrame *frame, wxWindowID id, const wxString& title,
 379     const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
 380     long type = wxDEFAULT_FRAME_STYLE, const wxString& name = "frame");
 381   ~wxDocChildFrame(void);
 382
 383   // Extend event processing to search the view's event table
 384   virtual bool ProcessEvent(wxEvent& event);
 385
 386   void OnActivate(wxActivateEvent& event);
 387   void OnCloseWindow(wxCloseEvent& event);
 388
 389   inline wxDocument *GetDocument(void) const { return m_childDocument; }
 390   inline wxView *GetView(void) const { return m_childView; }
 391   inline void SetDocument(wxDocument *doc) { m_childDocument = doc; }
 392   inline void SetView(wxView *view) { m_childView = view; }
 393  protected:
 394   wxDocument*       m_childDocument;
 395   wxView*           m_childView;
 396
 397 DECLARE_EVENT_TABLE()
 398
 399 };
 400
 401 /*
 402  * A default parent frame
 403  */
 404
 405 class WXDLLEXPORT wxDocParentFrame: public wxFrame
 406 {
 407   DECLARE_CLASS(wxDocParentFrame)
 408  public:
 409   wxDocParentFrame(wxDocManager *manager, wxFrame *frame, wxWindowID id, const wxString& title,
 410     const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
 411     long type = wxDEFAULT_FRAME_STYLE, const wxString& name = "frame");
 412
 413   // Extend event processing to search the document manager's event table
 414   virtual bool ProcessEvent(wxEvent& event);
 415
 416   wxDocManager *GetDocumentManager(void) const { return m_docManager; }
 417
 418   void OnExit(wxCommandEvent& event);
 419   void OnMRUFile(wxCommandEvent& event);
 420   void OnCloseWindow(wxCloseEvent& event);
 421
 422  protected:
 423   wxDocManager *m_docManager;
 424
 425 DECLARE_EVENT_TABLE()
 426 };
 427
 428 /*
 429  * Provide simple default printing facilities
 430  */
 431
 432 #if wxUSE_PRINTING_ARCHITECTURE
 433 class WXDLLEXPORT wxDocPrintout: public wxPrintout
 434 {
 435   DECLARE_DYNAMIC_CLASS(wxDocPrintout)
 436  public:
 437   wxDocPrintout(wxView *view = (wxView *) NULL, const wxString& title = "Printout");
 438   bool OnPrintPage(int page);
 439   bool HasPage(int page);
 440   bool OnBeginDocument(int startPage, int endPage);
 441   void GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo);
 442
 443   virtual inline wxView *GetView(void) { return m_printoutView; }
 444  protected:
 445   wxView*       m_printoutView;
 446 };
 447 #endif
 448
 449 /*
 450  * Command processing framework
 451  */
 452
 453 class WXDLLEXPORT wxCommand: public wxObject
 454 {
 455   DECLARE_CLASS(wxCommand)
 456  public:
 457   wxCommand(bool canUndoIt = FALSE, const wxString& name = "");
 458   ~wxCommand(void);
 459
 460   // Override this to perform a command
 461   virtual bool Do(void) = 0;
 462
 463   // Override this to undo a command
 464   virtual bool Undo(void) = 0;
 465
 466   virtual inline bool CanUndo(void) const { return m_canUndo; }
 467   virtual inline wxString GetName(void) const { return m_commandName; }
 468  protected:
 469   bool              m_canUndo;
 470   wxString          m_commandName;
 471 };
 472
 473 class WXDLLEXPORT wxCommandProcessor: public wxObject
 474 {
 475   DECLARE_DYNAMIC_CLASS(wxCommandProcessor)
 476  public:
 477   wxCommandProcessor(int maxCommands = 100);
 478   ~wxCommandProcessor(void);
 479
 480   // Pass a command to the processor. The processor calls Do();
 481   // if successful, is appended to the command history unless
 482   // storeIt is FALSE.
 483   virtual bool Submit(wxCommand *command, bool storeIt = TRUE);
 484   virtual bool Undo(void);
 485   virtual bool Redo(void);
 486   virtual bool CanUndo(void) const;
 487   virtual bool CanRedo(void) const;
 488
 489   // Call this to manage an edit menu.
 490   inline void SetEditMenu(wxMenu *menu) { m_commandEditMenu = menu; }
 491   inline wxMenu *GetEditMenu(void) const { return m_commandEditMenu; }
 492   virtual void SetMenuStrings(void);
 493   virtual void Initialize(void);
 494
 495   inline wxList& GetCommands(void) const { return (wxList&) m_commands; }
 496   inline int GetMaxCommands(void) const { return m_maxNoCommands; }
 497   virtual void ClearCommands(void);
 498
 499  protected:
 500   int           m_maxNoCommands;
 501   wxList        m_commands;
 502   wxNode*       m_currentCommand;
 503   wxMenu*       m_commandEditMenu;
 504 };
 505
 506 // File history management
 507
 508 class WXDLLEXPORT wxFileHistory: public wxObject
 509 {
 510   DECLARE_DYNAMIC_CLASS(wxFileHistory)
 511  public:
 512   wxFileHistory(int maxFiles = 9);
 513   ~wxFileHistory(void);
 514
 515 // Operations
 516   virtual void AddFileToHistory(const wxString& file);
 517   virtual int GetMaxFiles(void) const { return m_fileMaxFiles; }
 518   virtual void UseMenu(wxMenu *menu);
 519
 520   // Remove menu from the list (MDI child may be closing)
 521   virtual void RemoveMenu(wxMenu *menu);
 522
 523 #if wxUSE_CONFIG
 524   virtual void Load(wxConfigBase& config);
 525   virtual void Save(wxConfigBase& config);
 526 #endif
 527
 528   virtual void AddFilesToMenu();
 529   virtual void AddFilesToMenu(wxMenu* menu); // Single menu
 530
 531 // Accessors
 532   virtual wxString GetHistoryFile(int i) const;
 533
 534   // A synonym for GetNoHistoryFiles
 535   virtual int GetCount() const { return m_fileHistoryN; }
 536   inline int GetNoHistoryFiles(void) const { return m_fileHistoryN; }
 537
 538   inline wxList& GetMenus() const { return (wxList&) m_fileMenus; }
 539
 540  protected:
 541   // Last n files
 542   char**            m_fileHistory;
 543   // Number of files saved
 544   int               m_fileHistoryN;
 545   // Menus to maintain (may need several for an MDI app)
 546   wxList            m_fileMenus;
 547   // Max files to maintain
 548   int               m_fileMaxFiles;
 549 };
 550
 551 // For compatibility with existing file formats:
 552 // converts from/to a stream to/from a temporary file.
 553 bool WXDLLEXPORT wxTransferFileToStream(const wxString& filename, ostream& stream);
 554 bool WXDLLEXPORT wxTransferStreamToFile(istream& stream, const wxString& filename);
 555
 556
 557 #endif