src/common/docview.cpp

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