samples/docview/docview.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        samples/docview/docview.cpp
   3 // Purpose:     Document/view demo
   4 // Author:      Julian Smart
   5 // Modified by: Vadim Zeitlin: merge with the MDI version and general cleanup
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Julian Smart
   9 //              (c) 2008 Vadim Zeitlin
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 /*
  14     This sample show document/view support in wxWidgets.
  15
  16     It can be run in several ways:
  17         * With "--mdi" command line option to use multiple MDI child frames
  18           for the multiple documents (this is the default).
  19         * With "--sdi" command line option to use multiple top level windows
  20           for the multiple documents
  21         * With "--single" command line option to support opening a single
  22           document only
  23
  24     Notice that doing it like this somewhat complicates the code, you could
  25     make things much simpler in your own programs by using either
  26     wxDocParentFrame or wxDocMDIParentFrame unconditionally (and never using
  27     the single mode) instead of supporting all of them as this sample does.
  28  */
  29
  30 // ----------------------------------------------------------------------------
  31 // headers
  32 // ----------------------------------------------------------------------------
  33
  34 // For compilers that support precompilation, includes "wx/wx.h".
  35 #include "wx/wxprec.h"
  36
  37 #ifdef __BORLANDC__
  38     #pragma hdrstop
  39 #endif
  40
  41 #ifndef WX_PRECOMP
  42     #include "wx/wx.h"
  43     #include "wx/stockitem.h"
  44 #endif
  45
  46 #if !wxUSE_DOC_VIEW_ARCHITECTURE
  47     #error You must set wxUSE_DOC_VIEW_ARCHITECTURE to 1 in setup.h!
  48 #endif
  49
  50 #include "wx/docview.h"
  51 #include "wx/docmdi.h"
  52
  53 #include "docview.h"
  54 #include "doc.h"
  55 #include "view.h"
  56
  57 #include "wx/cmdline.h"
  58
  59 #ifdef __WXMAC__
  60     #include "wx/filename.h"
  61 #endif
  62
  63 #if !defined(__WXMSW__) && !defined(__WXPM__)
  64     #include "doc.xpm"
  65     #include "chart.xpm"
  66     #include "notepad.xpm"
  67 #endif
  68
  69 // ----------------------------------------------------------------------------
  70 // MyApp implementation
  71 // ----------------------------------------------------------------------------
  72
  73 IMPLEMENT_APP(MyApp)
  74
  75 BEGIN_EVENT_TABLE(MyApp, wxApp)
  76     EVT_MENU(wxID_ABOUT, MyApp::OnAbout)
  77 END_EVENT_TABLE()
  78
  79 MyApp::MyApp()
  80 {
  81 #if wxUSE_MDI_ARCHITECTURE
  82     m_mode = Mode_MDI;
  83 #else
  84     m_mode = Mode_SDI;
  85 #endif
  86
  87     m_canvas = NULL;
  88     m_menuEdit = NULL;
  89 }
  90
  91 // constants for the command line options names
  92 namespace CmdLineOption
  93 {
  94
  95 const char * const MDI = "mdi";
  96 const char * const SDI = "sdi";
  97 const char * const SINGLE = "single";
  98
  99 } // namespace CmdLineOption
 100
 101 void MyApp::OnInitCmdLine(wxCmdLineParser& parser)
 102 {
 103     wxApp::OnInitCmdLine(parser);
 104
 105     parser.AddSwitch("", CmdLineOption::MDI,
 106                      "run in MDI mode: multiple documents, single window");
 107     parser.AddSwitch("", CmdLineOption::SDI,
 108                      "run in SDI mode: multiple documents, multiple windows");
 109     parser.AddSwitch("", CmdLineOption::SINGLE,
 110                      "run in single document mode");
 111 }
 112
 113 bool MyApp::OnCmdLineParsed(wxCmdLineParser& parser)
 114 {
 115     int numModeOptions = 0;
 116
 117 #if wxUSE_MDI_ARCHITECTURE
 118     if ( parser.Found(CmdLineOption::MDI) )
 119     {
 120         m_mode = Mode_MDI;
 121         numModeOptions++;
 122     }
 123 #endif // wxUSE_MDI_ARCHITECTURE
 124
 125     if ( parser.Found(CmdLineOption::SDI) )
 126     {
 127         m_mode = Mode_SDI;
 128         numModeOptions++;
 129     }
 130
 131     if ( parser.Found(CmdLineOption::SINGLE) )
 132     {
 133         m_mode = Mode_Single;
 134         numModeOptions++;
 135     }
 136
 137     if ( numModeOptions > 1 )
 138     {
 139         wxLogError("Only a single option choosing the mode can be given.");
 140         return false;
 141     }
 142
 143     return wxApp::OnCmdLineParsed(parser);
 144 }
 145
 146 bool MyApp::OnInit()
 147 {
 148     if ( !wxApp::OnInit() )
 149         return false;
 150
 151     SetAppName("DocView Sample");
 152
 153     //// Create a document manager
 154     wxDocManager *docManager = new wxDocManager;
 155
 156     //// Create a template relating drawing documents to their views
 157     new wxDocTemplate(docManager, "Drawing", "*.drw", "", "drw",
 158                       "Drawing Doc", "Drawing View",
 159                       CLASSINFO(DrawingDocument), CLASSINFO(DrawingView));
 160 #if defined( __WXMAC__ )  && wxOSX_USE_CARBON
 161     wxFileName::MacRegisterDefaultTypeAndCreator("drw" , 'WXMB' , 'WXMA');
 162 #endif
 163
 164     if ( m_mode == Mode_Single )
 165     {
 166         // If we've only got one window, we only get to edit one document at a
 167         // time. Therefore no text editing, just doodling.
 168         docManager->SetMaxDocsOpen(1);
 169     }
 170     else // multiple documents mode: allow documents of different types
 171     {
 172         // Create a template relating text documents to their views
 173         new wxDocTemplate(docManager, "Text", "*.txt;*.text", "", "txt;text",
 174                           "Text Doc", "Text View",
 175                           CLASSINFO(TextEditDocument), CLASSINFO(TextEditView));
 176 #if defined( __WXMAC__ ) && wxOSX_USE_CARBON
 177         wxFileName::MacRegisterDefaultTypeAndCreator("txt" , 'TEXT' , 'WXMA');
 178 #endif
 179     }
 180
 181     // create the main frame window
 182     wxFrame *frame;
 183 #if wxUSE_MDI_ARCHITECTURE
 184     if ( m_mode == Mode_MDI )
 185     {
 186         frame = new wxDocMDIParentFrame(docManager, NULL, wxID_ANY,
 187                                         GetAppDisplayName(),
 188                                         wxDefaultPosition,
 189                                         wxSize(500, 400));
 190     }
 191     else
 192 #endif // wxUSE_MDI_ARCHITECTURE
 193     {
 194         frame = new wxDocParentFrame(docManager, NULL, wxID_ANY,
 195                                      GetAppDisplayName(),
 196                                      wxDefaultPosition,
 197                                      wxSize(500, 400));
 198     }
 199
 200     // and its menu bar
 201     wxMenu *menuFile = new wxMenu;
 202
 203     menuFile->Append(wxID_NEW);
 204     menuFile->Append(wxID_OPEN);
 205
 206     if ( m_mode == Mode_Single )
 207         AppendDocumentFileCommands(menuFile, true);
 208
 209     menuFile->AppendSeparator();
 210     menuFile->Append(wxID_EXIT);
 211
 212     // A nice touch: a history of files visited. Use this menu.
 213     docManager->FileHistoryUseMenu(menuFile);
 214
 215     if ( m_mode == Mode_Single )
 216     {
 217         m_canvas = new MyCanvas(NULL, frame);
 218         m_menuEdit = CreateDrawingEditMenu();
 219     }
 220
 221     CreateMenuBarForFrame(frame, menuFile, m_menuEdit);
 222
 223     frame->SetIcon(wxICON(doc));
 224     frame->Centre(wxBOTH);
 225     frame->Show(true);
 226
 227     SetTopWindow(frame);
 228     return true;
 229 }
 230
 231 int MyApp::OnExit()
 232 {
 233     delete wxDocManager::GetDocumentManager();
 234
 235     return wxApp::OnExit();
 236 }
 237
 238 void MyApp::AppendDocumentFileCommands(wxMenu *menu, bool supportsPrinting)
 239 {
 240     menu->Append(wxID_CLOSE);
 241     menu->Append(wxID_SAVE);
 242     menu->Append(wxID_SAVEAS);
 243
 244     if ( supportsPrinting )
 245     {
 246         menu->AppendSeparator();
 247         menu->Append(wxID_PRINT);
 248         menu->Append(wxID_PRINT_SETUP, "Print &Setup...");
 249         menu->Append(wxID_PREVIEW);
 250     }
 251 }
 252
 253 wxMenu *MyApp::CreateDrawingEditMenu()
 254 {
 255     wxMenu * const menu = new wxMenu;
 256     menu->Append(wxID_UNDO);
 257     menu->Append(wxID_REDO);
 258     menu->AppendSeparator();
 259     menu->Append(wxID_CUT, "&Cut last segment");
 260
 261     return menu;
 262 }
 263
 264 void MyApp::CreateMenuBarForFrame(wxFrame *frame, wxMenu *file, wxMenu *edit)
 265 {
 266     wxMenuBar *menubar = new wxMenuBar;
 267
 268     menubar->Append(file, wxGetStockLabel(wxID_FILE));
 269
 270     if ( edit )
 271         menubar->Append(edit, wxGetStockLabel(wxID_EDIT));
 272
 273     wxMenu *help= new wxMenu;
 274     help->Append(wxID_ABOUT);
 275     menubar->Append(help, wxGetStockLabel(wxID_HELP));
 276
 277     frame->SetMenuBar(menubar);
 278 }
 279
 280 wxFrame *MyApp::CreateChildFrame(wxDocument *doc, wxView *view, bool isCanvas)
 281 {
 282     // create a child frame of appropriate class for the current mode
 283     wxFrame *subframe;
 284 #if wxUSE_MDI_ARCHITECTURE
 285     if ( GetMode() == Mode_MDI )
 286     {
 287         subframe = new wxDocMDIChildFrame
 288                        (
 289                             doc,
 290                             view,
 291                             wxStaticCast(GetTopWindow(), wxDocMDIParentFrame),
 292                             wxID_ANY,
 293                             "Child Frame",
 294                             wxDefaultPosition,
 295                             wxSize(300, 300)
 296                        );
 297     }
 298     else
 299 #endif // wxUSE_MDI_ARCHITECTURE
 300     {
 301         subframe = new wxDocChildFrame
 302                        (
 303                             doc,
 304                             view,
 305                             wxStaticCast(GetTopWindow(), wxDocParentFrame),
 306                             wxID_ANY,
 307                             "Child Frame",
 308                             wxDefaultPosition,
 309                             wxSize(300, 300)
 310                        );
 311
 312         subframe->Centre(wxBOTH);
 313     }
 314
 315     wxMenu *menuFile = new wxMenu;
 316
 317     menuFile->Append(wxID_NEW);
 318     menuFile->Append(wxID_OPEN);
 319     AppendDocumentFileCommands(menuFile, isCanvas);
 320     menuFile->AppendSeparator();
 321     menuFile->Append(wxID_EXIT);
 322
 323     wxMenu *menuEdit;
 324     if ( isCanvas )
 325     {
 326         menuEdit = CreateDrawingEditMenu();
 327
 328         doc->GetCommandProcessor()->SetEditMenu(menuEdit);
 329         doc->GetCommandProcessor()->Initialize();
 330     }
 331     else // text frame
 332     {
 333         menuEdit = new wxMenu;
 334         menuEdit->Append(wxID_COPY);
 335         menuEdit->Append(wxID_PASTE);
 336         menuEdit->Append(wxID_SELECTALL);
 337     }
 338
 339     CreateMenuBarForFrame(subframe, menuFile, menuEdit);
 340
 341     subframe->SetIcon(isCanvas ? wxICON(chrt) : wxICON(notepad));
 342
 343     return subframe;
 344 }
 345
 346 void MyApp::OnAbout(wxCommandEvent& WXUNUSED(event))
 347 {
 348     wxString modeName;
 349     switch ( m_mode )
 350     {
 351 #if wxUSE_MDI_ARCHITECTURE
 352         case Mode_MDI:
 353             modeName = "MDI";
 354             break;
 355 #endif // wxUSE_MDI_ARCHITECTURE
 356
 357         case Mode_SDI:
 358             modeName = "SDI";
 359             break;
 360
 361         case Mode_Single:
 362             modeName = "single document";
 363             break;
 364
 365         default:
 366             wxFAIL_MSG( "unknown mode ");
 367     }
 368
 369     wxLogMessage
 370     (
 371         "This is the wxWidgets Document/View Sample\n"
 372         "running in %s mode.\n"
 373         "\n"
 374         "Authors: Julian Smart, Vadim Zeitlin\n"
 375         "\n"
 376         "Usage: docview [--{mdi,sdi,single}]",
 377         modeName
 378     );
 379 }
 380