src/common/docview.cpp

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