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