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