src/common/docview.cpp

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