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