gwj / po_oopc · Files

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWindows headers)
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif

#include "wx/txtstrm.h"

#if !wxUSE_DOC_VIEW_ARCHITECTURE
#error You must set wxUSE_DOC_VIEW_ARCHITECTURE to 1 in setup.h!
#endif
#include "wx/cmdproc.h"
#include "wx/docmdi.h"
#include "wx/docview.h"
#include "wx/mdi.h"

#include <fstream>
#include <iostream>
#include <list>
using namespace std;

// ----------------------------------------------------------------------------
// resources
// ----------------------------------------------------------------------------

// the application icon (under Windows and OS/2 it is in resources)
#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__) ||        \
    defined(__WXMGL__) || defined(__WXX11__)
#include "mondrian.xpm"
#endif

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------
// Define a new application

class MyFrame;

class MyApp : public wxApp {
  private:
    MyFrame* frame;

  public:
    MyApp(void);
    bool OnInit(void);
    int OnExit(void);
    MyFrame* GetMainFrame(void);
    wxMDIChildFrame* CreateChildFrame(wxDocument* doc, wxView* view,
                                      bool isCanvas);

  protected:
    wxDocManager* m_docManager;
};

DECLARE_APP(MyApp)

// Define a new frame
class MyCanvas;
class MyFrame : public wxDocMDIParentFrame {
    DECLARE_CLASS(MyFrame)
  public:
    MyFrame(wxDocManager* manager, wxFrame* frame, const wxString& title,
            const wxPoint& pos, const wxSize& size, long type);

    void OnAbout(wxCommandEvent& event);
    MyCanvas* CreateCanvas(wxView* view, wxMDIChildFrame* parent);

    DECLARE_EVENT_TABLE()
};

class MyCanvas : public wxScrolledWindow {};

class DrawingDocument : public wxDocument {
    DECLARE_DYNAMIC_CLASS(DrawingDocument)
};

class DrawingView : public wxView {
  public:
    MyCanvas* canvas;

    DrawingView()
    {
        canvas = (MyCanvas*)NULL;
    }
    ~DrawingView() {}

    bool OnCreate(wxDocument* doc, long flags);
    void OnDraw(wxDC* dc);
    void OnUpdate(wxView* sender, wxObject* hint = (wxObject*)NULL);
    bool OnClose(bool deleteWindow = TRUE);

    void OnCut(wxCommandEvent& event);

  private:
    DECLARE_DYNAMIC_CLASS(DrawingView)
    DECLARE_EVENT_TABLE()
};

#define DOCVIEW_CUT 1
#define DOCVIEW_ABOUT 2

// ----------------------------------------------------------------------------
// implementations
// ----------------------------------------------------------------------------

IMPLEMENT_APP(MyApp)

MyApp::MyApp(void)
{
    m_docManager = (wxDocManager*)NULL;
}

MyFrame* MyApp::GetMainFrame(void)
{
    return frame;
}

bool MyApp::OnInit(void)
{
    //// Create a document manager
    m_docManager = new wxDocManager;

    //// Create a template relating drawing documents to their views
    (void)new wxDocTemplate((wxDocManager*)m_docManager, _T("Drawing"),
                            _T("*.drw"), _T(""), _T("drw"), _T("Drawing Doc"),
                            _T("Drawing View"), CLASSINFO(DrawingDocument),
                            CLASSINFO(DrawingView));

    //// Create the main frame window
    frame = new MyFrame((wxDocManager*)m_docManager, (wxFrame*)NULL,
                        _T("DocView Demo"), wxPoint(0, 0), wxSize(500, 400),
                        wxDEFAULT_FRAME_STYLE);

    //// Give it an icon (this is ignored in MDI mode: uses resources)
#ifdef __WXMSW__
    frame->SetIcon(wxIcon(_T("doc")));
#endif
#ifdef __X__
    frame->SetIcon(wxIcon(_T("doc.xbm")));
#endif

    //// Make a menubar
    wxMenu* file_menu = new wxMenu;

    file_menu->Append(wxID_NEW, _T("&New...\tCtrl-N"));
    file_menu->Append(wxID_OPEN, _T("&Open...\tCtrl-X"));

    file_menu->AppendSeparator();
    file_menu->Append(wxID_EXIT, _T("E&xit\tAlt-X"));

    // A nice touch: a history of files visited. Use this menu.
    m_docManager->FileHistoryUseMenu(file_menu);

    wxMenu* help_menu = new wxMenu;
    help_menu->Append(DOCVIEW_ABOUT, _T("&About\tF1"));

    wxMenuBar* menu_bar = new wxMenuBar;

    menu_bar->Append(file_menu, _T("&File"));
    menu_bar->Append(help_menu, _T("&Help"));

    //// Associate the menu bar with the frame
    frame->SetMenuBar(menu_bar);

    frame->Centre(wxBOTH);
    frame->Show(TRUE);

    SetTopWindow(frame);
    return TRUE;
}

int MyApp::OnExit(void)
{
    delete m_docManager;
    return 0;
}

/*
 * Centralised code for creating a document frame.
 * Called from view.cpp, when a view is created.
 */

wxMDIChildFrame* MyApp::CreateChildFrame(wxDocument* doc, wxView* view,
                                         bool isCanvas)
{
    //// Make a child frame
    wxDocMDIChildFrame* subframe = new wxDocMDIChildFrame(
        doc, view, GetMainFrame(), -1, _T("Child Frame"), wxDefaultPosition,
        wxDefaultSize, wxDEFAULT_FRAME_STYLE | wxMAXIMIZE);

#ifdef __WXMSW__
    subframe->SetIcon(wxString(isCanvas ? _T("chart") : _T("notepad")));
#endif
#ifdef __X__
    subframe->SetIcon(wxIcon(_T("doc.xbm")));
#endif

    //// Make a menubar
    wxMenu* file_menu = new wxMenu;

    file_menu->Append(wxID_NEW, _T("&New..."));
    file_menu->Append(wxID_OPEN, _T("&Open..."));
    file_menu->Append(wxID_CLOSE, _T("&Close"));
    file_menu->Append(wxID_SAVE, _T("&Save"));
    file_menu->Append(wxID_SAVEAS, _T("Save &As..."));

    if (isCanvas) {
        file_menu->AppendSeparator();
        file_menu->Append(wxID_PRINT, _T("&Print..."));
        file_menu->Append(wxID_PRINT_SETUP, _T("Print &Setup..."));
        file_menu->Append(wxID_PREVIEW, _T("Print Pre&view"));
    }

    file_menu->AppendSeparator();
    file_menu->Append(wxID_EXIT, _T("E&xit"));

    wxMenu* edit_menu = (wxMenu*)NULL;

    if (isCanvas) {
        edit_menu = new wxMenu;
        edit_menu->Append(wxID_UNDO, _T("&Undo"));
        edit_menu->Append(wxID_REDO, _T("&Redo"));
        edit_menu->AppendSeparator();
        edit_menu->Append(DOCVIEW_CUT, _T("&Cut last segment"));

        doc->GetCommandProcessor()->SetEditMenu(edit_menu);
    }

    wxMenu* help_menu = new wxMenu;
    help_menu->Append(DOCVIEW_ABOUT, _T("&About"));

    wxMenuBar* menu_bar = new wxMenuBar;

    menu_bar->Append(file_menu, _T("&File"));
    if (isCanvas)
        menu_bar->Append(edit_menu, _T("&Edit"));
    menu_bar->Append(help_menu, _T("&Help"));

    //// Associate the menu bar with the frame
    subframe->SetMenuBar(menu_bar);

    return subframe;
}

/*
 * This is the top-level window of the application.
 */

IMPLEMENT_CLASS(MyFrame, wxDocMDIParentFrame)
BEGIN_EVENT_TABLE(MyFrame, wxDocMDIParentFrame)
EVT_MENU(DOCVIEW_ABOUT, MyFrame::OnAbout)
END_EVENT_TABLE()

MyFrame::MyFrame(wxDocManager* manager, wxFrame* frame, const wxString& title,
                 const wxPoint& pos, const wxSize& size, long type)
    : wxDocMDIParentFrame(manager, frame, -1, title, pos, size, type,
                          _T("myFrame"))
{
}

void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
    (void)wxMessageBox(
        _T("DocView Demo\nAuthor: Julian Smart\nUsage: docview.exe"),
        _T("About DocView"));
}

// Creates a canvas. Called from view.cpp when a new drawing
// view is created.
MyCanvas* MyFrame::CreateCanvas(wxView* view, wxMDIChildFrame* parent)
{
    int width, height;
    parent->GetClientSize(&width, &height);

    // Non-retained canvas
    MyCanvas* canvas = (MyCanvas*)new wxScrolledWindow(
        parent, -1, wxPoint(0, 0), wxSize(width, height), 0);
    canvas->SetCursor(wxCursor(wxCURSOR_PENCIL));

    // Give it scrollbars
    canvas->SetScrollbars(20, 20, 50, 50);

    return canvas;
}

IMPLEMENT_DYNAMIC_CLASS(DrawingDocument, wxDocument)

IMPLEMENT_DYNAMIC_CLASS(DrawingView, wxView)

BEGIN_EVENT_TABLE(DrawingView, wxView)
EVT_MENU(DOCVIEW_CUT, DrawingView::OnCut)
END_EVENT_TABLE()

// What to do when a view is created. Creates actual
// windows for displaying the view.
bool DrawingView::OnCreate(wxDocument* doc, long WXUNUSED(flags))
{
    wxMDIChildFrame* frame = wxGetApp().CreateChildFrame(doc, this, TRUE);
    frame->SetTitle(_T("DrawingView"));

    canvas = wxGetApp().GetMainFrame()->CreateCanvas(this, frame);
    SetFrame(frame);
#ifdef __X__
    // X seems to require a forced resize
    int x, y;
    frame->GetSize(&x, &y);
    frame->SetSize(-1, -1, x, y);
#endif
    frame->Show(TRUE);
    Activate(TRUE);

    return TRUE;
}

// Sneakily gets used for default print/preview
// as well as drawing on the screen.
void DrawingView::OnDraw(wxDC* dc) {}

void DrawingView::OnUpdate(wxView* WXUNUSED(sender), wxObject* WXUNUSED(hint))
{
    if (canvas)
        canvas->Refresh();
}

// Clean up windows used for displaying the view.
bool DrawingView::OnClose(bool deleteWindow)
{
    if (!GetDocument()->Close())
        return FALSE;

    // Clear the canvas in  case we're in single-window mode,
    // and the canvas stays.
    canvas = (MyCanvas*)NULL;

    Activate(FALSE);

    if (deleteWindow)
        delete GetFrame();

    SetFrame((wxFrame*)NULL);
    return TRUE;
}

void DrawingView::OnCut(wxCommandEvent& WXUNUSED(event)) {}