[wxWidgets.git] / contrib / samples / svg / svgtest.cpp

// biol75@york.ac.uk (Chris Elliott) March 2000

#ifdef __BIDE__
#define _NO_VCL
#include "condefs.h"
USERC("svg.rc");
//---------------------------------------------------------------------------
#define WinMain WinMain
#endif
/////////////////////////////////////////////////////////////////////////////
// Name:        svgtest.cpp
// Purpose:     SVG sample
// Author:      Chris Elliott
// Modified by:
// RCS-ID:      $Id$
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

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

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

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

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/wx.h"
#include "wx/mdi.h"
#endif

#include <wx/toolbar.h>
#include <wx/svg/dcsvg.h>

#include "mondrian.xpm"									     

#include "bitmaps/new.xpm"
#include "bitmaps/save.xpm"
#include "bitmaps/help.xpm"
#include "SVGlogo24.xpm"
									     
class MyChild;

// Define a new application
class MyApp : public wxApp
{
    public:
        bool OnInit();
};

// Define a new frame
class MyFrame : public wxMDIParentFrame
{
    public:
        int nWinCreated;

        wxList m_children;

        MyFrame(wxWindow *parent, const wxWindowID id, const wxString& title,
            const wxPoint& pos, const wxSize& size, const long style);

        void InitToolBar(wxToolBar* toolBar);

        void OnSize(wxSizeEvent& event);
        void OnAbout(wxCommandEvent& event);
        void OnNewWindow(wxCommandEvent& event);
        void OnQuit(wxCommandEvent& event);
        void OnClose(wxCloseEvent& event);
        void FileSavePicture (wxCommandEvent & WXUNUSED(event) ) ;

        DECLARE_EVENT_TABLE()
};


class MyCanvas : public wxScrolledWindow
{
    public:
        int m_index ;
   
        MyChild * m_child ;
        MyCanvas(wxWindow *parent, const wxPoint& pos, const wxSize& size);
        virtual void OnDraw(wxDC& dc);

        DECLARE_EVENT_TABLE()
};

class MyChild: public wxMDIChildFrame
{
    public:
        MyCanvas *m_canvas;
        MyFrame  *m_frame ;

        //////////////////// Methods

        MyChild(wxMDIParentFrame *parent, const wxString& title, const wxPoint& pos, const wxSize& size, const long style);
        ~MyChild();

        void OnActivate(wxActivateEvent& event);
        void OnQuit(wxCommandEvent& event);
        void OnClose(wxCloseEvent& event);
        bool OnSave(wxString filename) ;

        DECLARE_EVENT_TABLE()
};

// menu items ids
enum
{
    MDI_QUIT = 100,
    MDI_NEW_WINDOW,
    MDI_SAVE,
    MDI_REFRESH,
    MDI_CHILD_QUIT,
    MDI_ABOUT
};


IMPLEMENT_APP(MyApp)

// ---------------------------------------------------------------------------
// global variables
// ---------------------------------------------------------------------------

MyFrame *frame = (MyFrame *) NULL;

// ---------------------------------------------------------------------------
// event tables
// ---------------------------------------------------------------------------

BEGIN_EVENT_TABLE(MyFrame, wxMDIParentFrame)
EVT_MENU(MDI_ABOUT, MyFrame::OnAbout)
EVT_MENU(MDI_NEW_WINDOW, MyFrame::OnNewWindow)
EVT_MENU(MDI_QUIT, MyFrame::OnQuit)
EVT_MENU (MDI_SAVE, MyFrame::FileSavePicture)
EVT_CLOSE(MyFrame::OnClose)

EVT_SIZE(MyFrame::OnSize)
END_EVENT_TABLE()

// ===========================================================================
// implementation
// ===========================================================================

// ---------------------------------------------------------------------------
// MyApp
// ---------------------------------------------------------------------------

// Initialise this in OnInit, not statically
bool MyApp::OnInit()
{
    // Create the main frame window

    frame = new MyFrame((wxFrame *)NULL, -1, wxT("SVG Demo"),
        wxPoint(-1, -1), wxSize(500, 400),
        wxDEFAULT_FRAME_STYLE | wxHSCROLL | wxVSCROLL);
        

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

    file_menu->Append(MDI_NEW_WINDOW, wxT("&New test\tCtrl+N"));
    file_menu->Append(MDI_QUIT, wxT("&Exit\tAlt+X"));

    wxMenu *help_menu = new wxMenu;
    help_menu->Append(MDI_ABOUT, wxT("&About"));

    wxMenuBar *menu_bar = new wxMenuBar;

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

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

#if wxUSE_STATUSBAR
    frame->CreateStatusBar();
#endif // wxUSE_STATUSBAR

    frame->Show(true);

    SetTopWindow(frame);

    return TRUE;
}


// ---------------------------------------------------------------------------
// MyFrame
// ---------------------------------------------------------------------------

// Define my frame constructor
MyFrame::MyFrame(wxWindow *parent, const wxWindowID id, const wxString& title,
    const wxPoint& pos, const wxSize& size, const long style)
        : wxMDIParentFrame(parent, id, title, pos, size, style)
{
    nWinCreated = 0 ;

    // Give it an icon
    SetIcon(wxICON(mondrian));

    CreateToolBar(wxNO_BORDER | wxTB_FLAT | wxTB_HORIZONTAL);
    InitToolBar(GetToolBar());

}


void MyFrame::OnClose(wxCloseEvent& event)
{
    if ( !event.CanVeto() )
    {
        event.Skip();
        return ;
    }
    if ( m_children.GetCount () < 1 )
    {
        event.Skip();
        return ;
    }
    // now try the children
    wxObjectList::compatibility_iterator pNode = m_children.GetFirst ();
    wxObjectList::compatibility_iterator pNext ;
    MyChild * pChild ;
    while ( pNode )
    {
        pNext = pNode -> GetNext ();
        pChild = (MyChild*) pNode -> GetData ();
        if (pChild -> Close ())
        {
            m_children.Erase(pNode) ;
        }
        else
        {
            event.Veto();
            return;
        }
        pNode = pNext ;
    }
    event.Skip();
}


void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    Close();
}


void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event) )
{
    (void)wxMessageBox(wxT("wxWidgets 2.0 SVG 1.0 Test\n")
        wxT("Author: Chris Elliott (c) 2002\n")
        wxT("Usage: svg.exe \nClick File | New to show tests\n\n"), wxT("About SVG Test"));
}


void MyFrame::OnNewWindow(wxCommandEvent& WXUNUSED(event) )
{
    // Make another frame, containing a canvas
    MyChild *subframe ;

    m_children.Append (new MyChild(frame, wxT("SVG Frame"),
        wxPoint(-1, -1), wxSize(-1, -1),
        wxDEFAULT_FRAME_STYLE )   ) ;

    subframe = (MyChild *) m_children.GetLast() -> GetData ();
    wxString title;
    title.Printf(wxT("SVG Test Window %d"), nWinCreated );
    // counts number of children previously, even if now closed
    nWinCreated ++ ;

    // Give it a title and icon
    subframe->SetTitle(title);
    subframe->SetIcon(wxICON(mondrian));

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

    file_menu->Append(MDI_NEW_WINDOW, wxT("&Another test\tCtrl+N"));
    file_menu->Append(MDI_SAVE, wxT("&Save\tCtrl+S"), wxT("Save in SVG format"));
    file_menu->Append(MDI_CHILD_QUIT, wxT("&Close child\tCtrl+F4"));
    file_menu->Append(MDI_QUIT, wxT("&Exit\tAlt+X"));

    wxMenu *help_menu = new wxMenu;
    help_menu->Append(MDI_ABOUT, wxT("&About"));

    wxMenuBar *menu_bar = new wxMenuBar;

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

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

    subframe->Show(TRUE);
}


void MyFrame::OnSize(wxSizeEvent& event)
{
    int w, h;
    GetClientSize(&w, &h);

    GetClientWindow()->SetSize(0, 0, w, h);
    event.Skip();
}


void MyFrame::InitToolBar(wxToolBar* toolBar)
{
    const int maxBitmaps = 3 ;
    wxBitmap* bitmaps[maxBitmaps];

    bitmaps[0] = new wxBitmap( new_xpm );
    bitmaps[1] = new wxBitmap( save_xpm );
    bitmaps[2] = new wxBitmap( help_xpm );

    int width = 16;
    int currentX = 5;

    toolBar->AddTool( MDI_NEW_WINDOW, *(bitmaps[0]), wxNullBitmap, FALSE, currentX, -1, (wxObject *) NULL, wxT("New SVG test window"));
    currentX += width + 5;
    toolBar->AddTool( MDI_SAVE, *bitmaps[1], wxNullBitmap, FALSE, currentX, -1, (wxObject *) NULL, wxT("Save test in SVG format"));
    currentX += width + 5;
    toolBar->AddSeparator();      
    toolBar->AddTool(MDI_ABOUT, *bitmaps[2], wxNullBitmap, TRUE, currentX, -1, (wxObject *) NULL, wxT("Help"));

    toolBar->Realize();

    int i;
    for (i = 0; i < maxBitmaps; i++)
        delete bitmaps[i];
}


void MyFrame::FileSavePicture (wxCommandEvent & WXUNUSED(event) )
{
    MyChild * pChild = (MyChild *)GetActiveChild ();
    if (pChild == NULL) 
    {
        return ;
    }

    wxFileDialog dialog(this, wxT("Save Picture as"), wxEmptyString, pChild->GetTitle(),
        wxT("SVG vector picture files (*.svg)|*.svg"),
        wxSAVE|wxOVERWRITE_PROMPT);

    if (dialog.ShowModal() == wxID_OK)
    {
        if (!pChild -> OnSave ( dialog.GetPath() ))
        {
            return ;
        }
    }
    return ;
}


// Note that MDI_NEW_WINDOW and MDI_ABOUT commands get passed
// to the parent window for processing, so no need to
// duplicate event handlers here.
BEGIN_EVENT_TABLE(MyChild, wxMDIChildFrame)
    EVT_MENU(MDI_CHILD_QUIT, MyChild::OnQuit)
    EVT_CLOSE(MyChild::OnClose)
END_EVENT_TABLE()

BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)

END_EVENT_TABLE()

// ---------------------------------------------------------------------------
// MyCanvas
// ---------------------------------------------------------------------------

// Define a constructor for my canvas
MyCanvas::MyCanvas(wxWindow *parent, const wxPoint& pos, const wxSize& size)
: wxScrolledWindow(parent, -1, pos, size,
wxSUNKEN_BORDER|wxVSCROLL|wxHSCROLL)
{
    m_child = (MyChild *) parent ;
    SetBackgroundColour(wxColour(_T("WHITE")));
    m_index = m_child->m_frame->nWinCreated % 7 ;
}


// Define the repainting behaviour
void MyCanvas::OnDraw(wxDC& dc)
{
    // vars to use ...
#if wxUSE_STATUSBAR
    wxString s ;
#endif // wxUSE_STATUSBAR
    wxPen wP ;
    wxBrush wB ;
    wxPoint points[6];
    wxColour wC;
    wxFont wF ;

    dc.SetFont(*wxSWISS_FONT);
    dc.SetPen(*wxGREEN_PEN);

    
    switch (m_index)
    {
        default:
        case 0:
            // draw lines to make a cross
            dc.DrawLine(0, 0, 200, 200);
            dc.DrawLine(200, 0, 0, 200);
            // draw point colored line and spline
            wP = *wxCYAN_PEN ;
            wP.SetWidth(3);
            dc.SetPen(wP);

            dc.DrawPoint (25,15) ;
            dc.DrawLine(50, 30, 200, 30);
            dc.DrawSpline(50, 200, 50, 100, 200, 10);
#if wxUSE_STATUSBAR
            s = wxT("Green Cross, Cyan Line and spline");
#endif // wxUSE_STATUSBAR
            break ;

        case 1:
            // draw standard shapes
            dc.SetBrush(*wxCYAN_BRUSH);
            dc.SetPen(*wxRED_PEN);
            dc.DrawRectangle(10, 10, 100, 70);
            wB = wxBrush (_T("DARK ORCHID"), wxTRANSPARENT);
            dc.SetBrush (wB);
            dc.DrawRoundedRectangle(50, 50, 100, 70, 20);
            dc.SetBrush (wxBrush(_T("GOLDENROD"), wxSOLID) );
            dc.DrawEllipse(100, 100, 100, 50);

            points[0].x = 100; points[0].y = 200;
            points[1].x = 70; points[1].y = 260;
            points[2].x = 160; points[2].y = 230;
            points[3].x = 40; points[3].y = 230;
            points[4].x = 130; points[4].y = 260;
            points[5].x = 100; points[5].y = 200;

            dc.DrawPolygon(5, points);
            dc.DrawLines (6, points, 160);
#if wxUSE_STATUSBAR
            s = wxT("Blue rectangle, red edge, clear rounded rectangle, gold ellipse, gold and clear stars");
#endif // wxUSE_STATUSBAR
            break ;

        case 2:
            // draw text in Arial or similar font
            dc.DrawLine(50,25,50,35);
            dc.DrawLine(45,30,55,30);
            dc.DrawText(wxT("This is a Swiss-style string"), 50, 30);
            wC = dc.GetTextForeground() ;
            dc.SetTextForeground (_T("FIREBRICK"));
                                 
            // no effect in msw ??
            dc.SetTextBackground (_T("WHEAT"));
            dc.DrawText(wxT("This is a Red string"), 50, 200);
            dc.DrawRotatedText(wxT("This is a 45 deg string"), 50, 200, 45);
            dc.DrawRotatedText(wxT("This is a 90 deg string"), 50, 200, 90);
            wF = wxFont ( 18, wxROMAN, wxITALIC, wxBOLD, FALSE, wxT("Times New Roman"));
            dc.SetFont(wF);
            dc.SetTextForeground (wC) ;
            dc.DrawText(wxT("This is a Times-style string"), 50, 60);
#if wxUSE_STATUSBAR
            s = wxT("Swiss, Times text; red text, rotated and colored orange");
#endif // wxUSE_STATUSBAR
            break ;

        case 3 :
            // four arcs start and end points, center
            dc.SetBrush(*wxGREEN_BRUSH);
            dc.DrawArc ( 200,300, 370,230, 300,300 );
            dc.SetBrush(*wxBLUE_BRUSH);
            dc.DrawArc ( 270-50, 270-86, 270-86, 270-50, 270,270 );
            dc.SetDeviceOrigin(-10,-10);
            dc.DrawArc ( 270-50, 270-86, 270-86, 270-50, 270,270 );
            dc.SetDeviceOrigin(0,0);

            wP.SetColour (_T("CADET BLUE"));
            dc.SetPen(wP);
            dc.DrawArc ( 75,125, 110, 40, 75, 75 );

            wP.SetColour (_T("SALMON"));
            dc.SetPen(wP);
            dc.SetBrush(*wxRED_BRUSH);
            //top left corner, width and height, start and end angle
                                 // 315 same center and x-radius as last pie-arc, half Y radius
            dc.DrawEllipticArc(25,50,100,50,180.0,45.0) ;

            wP = *wxCYAN_PEN ;
            wP.SetWidth(3);
            dc.SetPen(wP);
                                 //wxTRANSPARENT));
            dc.SetBrush (wxBrush (_T("SALMON"),wxSOLID)) ;
            dc.DrawEllipticArc(300,  0,200,100, 0.0,145.0) ;
                                 //same end point
            dc.DrawEllipticArc(300, 50,200,100,90.0,145.0) ;
            dc.DrawEllipticArc(300,100,200,100,90.0,345.0) ;

#if wxUSE_STATUSBAR
            s = wxT("This is an arc test page");
#endif // wxUSE_STATUSBAR
            break ;

        case 4:
            dc.DrawCheckMark ( 30,30,25,25);
            dc.SetBrush (wxBrush (_T("SALMON"),wxTRANSPARENT));
            dc.DrawCheckMark ( 80,50,75,75);
            dc.DrawRectangle ( 80,50,75,75);
#if wxUSE_STATUSBAR
            s = wxT("Two check marks");
#endif // wxUSE_STATUSBAR
            break ;

        case 5:
            wF = wxFont ( 18, wxROMAN, wxITALIC, wxBOLD, FALSE, wxT("Times New Roman"));
            dc.SetFont(wF);
            dc.DrawLine(0, 0, 200, 200);
            dc.DrawLine(200, 0, 0, 200);
            dc.DrawText(wxT("This is an 18pt string"), 50, 60);

            // rescale and draw in blue
            wP = *wxCYAN_PEN ;
            dc.SetPen(wP);
            dc.SetUserScale (2.0,0.5);
            dc.SetDeviceOrigin(200,0);
            dc.DrawLine(0, 0, 200, 200);
            dc.DrawLine(200, 0, 0, 200);
            dc.DrawText(wxT("This is an 18pt string 2 x 0.5 UserScaled"), 50, 60);
            dc.SetUserScale (2.0,2.0);
            dc.SetDeviceOrigin(200,200);
            dc.DrawText(wxT("This is an 18pt string 2 x 2 UserScaled"), 50, 60);

            wP = *wxRED_PEN ;
            dc.SetPen(wP);
            dc.SetUserScale (1.0,1.0);
            dc.SetDeviceOrigin(0,10);
            dc.SetMapMode (wxMM_METRIC) ; //svg ignores this
            dc.DrawLine(0, 0, 200, 200);
            dc.DrawLine(200, 0, 0, 200);
            dc.DrawText(wxT("This is an 18pt string in MapMode"), 50, 60); 
#if wxUSE_STATUSBAR
            s = wxT("Scaling test page");
#endif // wxUSE_STATUSBAR
            break ;

        case 6:
            dc.DrawIcon( wxIcon(mondrian_xpm), 10, 10 );
            dc.DrawBitmap ( wxBitmap(svgbitmap_xpm), 50,15);
#if wxUSE_STATUSBAR
            s = wxT("Icon and Bitmap ");
#endif // wxUSE_STATUSBAR
            break ;

    }
#if wxUSE_STATUSBAR
    m_child->SetStatusText(s);
#endif // wxUSE_STATUSBAR
}


// ---------------------------------------------------------------------------
// MyChild
// ---------------------------------------------------------------------------

MyChild::MyChild(wxMDIParentFrame *parent, const wxString& title,
const wxPoint& pos, const wxSize& size,
const long style)
: wxMDIChildFrame(parent, -1, title, pos, size, style)
{

    m_frame = (MyFrame *) parent ;
#if wxUSE_STATUSBAR
    CreateStatusBar();
    SetStatusText(title);    
#endif // wxUSE_STATUSBAR

    int w, h ;
    GetClientSize ( &w, &h );
    m_canvas = new MyCanvas(this, wxPoint(0, 0),  wxSize (w,h)  );
    // Give it scrollbars
    m_canvas->SetScrollbars(20, 20, 50, 50);

}


MyChild::~MyChild()
{
    m_frame->m_children.DeleteObject(this);
}


void MyChild::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    Close(TRUE);
}


bool MyChild::OnSave(wxString filename)
{
    wxSVGFileDC svgDC (filename, 600, 650) ;
    m_canvas->OnDraw (svgDC);
    return svgDC.Ok();
}


void MyChild::OnActivate(wxActivateEvent& event)
{
    if ( event.GetActive() && m_canvas )
        m_canvas->SetFocus();
}


void MyChild::OnClose(wxCloseEvent& event)
{
    event.Skip();
}
Commit	Line	Data
cdf3a589 CE	1	// biol75@york.ac.uk (Chris Elliott) March 2000
	2
	3	#ifdef __BIDE__
	4	#define _NO_VCL
	5	#include "condefs.h"
	6	USERC("svg.rc");
	7	//---------------------------------------------------------------------------
	8	#define WinMain WinMain
	9	#endif
	10	/////////////////////////////////////////////////////////////////////////////
	11	// Name: svgtest.cpp
	12	// Purpose: SVG sample
	13	// Author: Chris Elliott
	14	// Modified by:
	15	// RCS-ID: $Id$
	16	// Licence: wxWindows license
	17	/////////////////////////////////////////////////////////////////////////////
	18
	19	// ===========================================================================
	20	// declarations
	21	// ===========================================================================
	22
	23	// ---------------------------------------------------------------------------
	24	// headers
	25	// ---------------------------------------------------------------------------
	26
	27	// For compilers that support precompilation, includes "wx/wx.h".
	28	#include "wx/wxprec.h"
	29
	30	#ifdef __BORLANDC__
	31	#pragma hdrstop
	32	#endif
	33
	34	#ifndef WX_PRECOMP
	35	#include "wx/wx.h"
	36	#include "wx/mdi.h"
	37	#endif
	38
	39	#include <wx/toolbar.h>
	40	#include <wx/svg/dcsvg.h>
	41
fa89fbe5	42	#include "mondrian.xpm"
756d3e7f	43
cdf3a589 CE	44	#include "bitmaps/new.xpm"
	45	#include "bitmaps/save.xpm"
	46	#include "bitmaps/help.xpm"
	47	#include "SVGlogo24.xpm"
	48
	49	class MyChild;
	50
	51	// Define a new application
	52	class MyApp : public wxApp
	53	{
	54	public:
	55	bool OnInit();
	56	};
	57
	58	// Define a new frame
	59	class MyFrame : public wxMDIParentFrame
	60	{
	61	public:
	62	int nWinCreated;
	63
	64	wxList m_children;
	65
	66	MyFrame(wxWindow *parent, const wxWindowID id, const wxString& title,
	67	const wxPoint& pos, const wxSize& size, const long style);
	68
	69	void InitToolBar(wxToolBar* toolBar);
	70
	71	void OnSize(wxSizeEvent& event);
	72	void OnAbout(wxCommandEvent& event);
	73	void OnNewWindow(wxCommandEvent& event);
	74	void OnQuit(wxCommandEvent& event);
	75	void OnClose(wxCloseEvent& event);
	76	void FileSavePicture (wxCommandEvent & WXUNUSED(event) ) ;
	77
	78	DECLARE_EVENT_TABLE()
	79	};
	80
	81
	82	class MyCanvas : public wxScrolledWindow
	83	{
	84	public:
	85	int m_index ;
	86
	87	MyChild * m_child ;
	88	MyCanvas(wxWindow *parent, const wxPoint& pos, const wxSize& size);
	89	virtual void OnDraw(wxDC& dc);
	90
	91	DECLARE_EVENT_TABLE()
	92	};
	93
	94	class MyChild: public wxMDIChildFrame
	95	{
	96	public:
	97	MyCanvas *m_canvas;
	98	MyFrame *m_frame ;
	99
	100	//////////////////// Methods
	101
	102	MyChild(wxMDIParentFrame *parent, const wxString& title, const wxPoint& pos, const wxSize& size, const long style);
	103	~MyChild();
	104
	105	void OnActivate(wxActivateEvent& event);
	106	void OnQuit(wxCommandEvent& event);
	107	void OnClose(wxCloseEvent& event);
108	bool OnSave(wxString filename) ;
109
110	DECLARE_EVENT_TABLE()
111	};
112
113	// menu items ids
114	enum
115	{
116	MDI_QUIT = 100,
117	MDI_NEW_WINDOW,
118	MDI_SAVE,
119	MDI_REFRESH,
120	MDI_CHILD_QUIT,
121	MDI_ABOUT
122	};
123
124
125	IMPLEMENT_APP(MyApp)
126
127	// ---------------------------------------------------------------------------
128	// global variables
129	// ---------------------------------------------------------------------------
130
131	MyFrame frame = (MyFrame ) NULL;
132
133	// ---------------------------------------------------------------------------
134	// event tables
135	// ---------------------------------------------------------------------------
136
137	BEGIN_EVENT_TABLE(MyFrame, wxMDIParentFrame)
138	EVT_MENU(MDI_ABOUT, MyFrame::OnAbout)
139	EVT_MENU(MDI_NEW_WINDOW, MyFrame::OnNewWindow)
140	EVT_MENU(MDI_QUIT, MyFrame::OnQuit)
141	EVT_MENU (MDI_SAVE, MyFrame::FileSavePicture)
142	EVT_CLOSE(MyFrame::OnClose)
143
144	EVT_SIZE(MyFrame::OnSize)
145	END_EVENT_TABLE()
146
147	// ===========================================================================
148	// implementation
149	// ===========================================================================
150
151	// ---------------------------------------------------------------------------
152	// MyApp
153	// ---------------------------------------------------------------------------
154
155	// Initialise this in OnInit, not statically
156	bool MyApp::OnInit()
157	{
158	// Create the main frame window
159
160	frame = new MyFrame((wxFrame *)NULL, -1, wxT("SVG Demo"),
161	wxPoint(-1, -1), wxSize(500, 400),
162	wxDEFAULT_FRAME_STYLE \| wxHSCROLL \| wxVSCROLL);
163
164
165	// Make a menubar
166	wxMenu *file_menu = new wxMenu;
167
168	file_menu->Append(MDI_NEW_WINDOW, wxT("&New test\tCtrl+N"));
169	file_menu->Append(MDI_QUIT, wxT("&Exit\tAlt+X"));
170
171	wxMenu *help_menu = new wxMenu;
172	help_menu->Append(MDI_ABOUT, wxT("&About"));
173
174	wxMenuBar *menu_bar = new wxMenuBar;
175
176	menu_bar->Append(file_menu, wxT("&File"));
177	menu_bar->Append(help_menu, wxT("&Help"));
178
179	// Associate the menu bar with the frame
180	frame->SetMenuBar(menu_bar);
181
d96cdd4a	182	#if wxUSE_STATUSBAR
cdf3a589	183	frame->CreateStatusBar();
d96cdd4a	184	#endif // wxUSE_STATUSBAR
cdf3a589	185
d96cdd4a	186	frame->Show(true);
cdf3a589 CE	187
	188	SetTopWindow(frame);
	189
	190	return TRUE;
	191	}
	192
	193
	194	// ---------------------------------------------------------------------------
	195	// MyFrame
	196	// ---------------------------------------------------------------------------
	197
	198	// Define my frame constructor
	199	MyFrame::MyFrame(wxWindow *parent, const wxWindowID id, const wxString& title,
	200	const wxPoint& pos, const wxSize& size, const long style)
	201	: wxMDIParentFrame(parent, id, title, pos, size, style)
	202	{
	203	nWinCreated = 0 ;
	204
	205	// Give it an icon
	206	SetIcon(wxICON(mondrian));
	207
	208	CreateToolBar(wxNO_BORDER \| wxTB_FLAT \| wxTB_HORIZONTAL);
	209	InitToolBar(GetToolBar());
	210
	211	}
	212
	213
	214	void MyFrame::OnClose(wxCloseEvent& event)
	215	{
	216	if ( !event.CanVeto() )
	217	{
	218	event.Skip();
	219	return ;
	220	}
216db41f	221	if ( m_children.GetCount () < 1 )
cdf3a589 CE	222	{
	223	event.Skip();
	224	return ;
	225	}
	226	// now try the children
36ca94a2 WS	227	wxObjectList::compatibility_iterator pNode = m_children.GetFirst ();
36ca94a2 WS	228	wxObjectList::compatibility_iterator pNext ;
cdf3a589 CE	229	MyChild * pChild ;
	230	while ( pNode )
	231	{
	232	pNext = pNode -> GetNext ();
216db41f	233	pChild = (MyChild*) pNode -> GetData ();
cdf3a589 CE	234	if (pChild -> Close ())
cdf3a589 CE	235	{
36ca94a2	236	m_children.Erase(pNode) ;
cdf3a589 CE	237	}
	238	else
	239	{
	240	event.Veto();
	241	return;
	242	}
	243	pNode = pNext ;
	244	}
	245	event.Skip();
	246	}
	247
	248
	249	void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
	250	{
	251	Close();
	252	}
	253
	254
	255	void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event) )
	256	{
be5a51fb	257	(void)wxMessageBox(wxT("wxWidgets 2.0 SVG 1.0 Test\n")
756d3e7f CE	258	wxT("Author: Chris Elliott (c) 2002\n")
756d3e7f CE	259	wxT("Usage: svg.exe \nClick File \| New to show tests\n\n"), wxT("About SVG Test"));
cdf3a589 CE	260	}
	261
	262
	263	void MyFrame::OnNewWindow(wxCommandEvent& WXUNUSED(event) )
	264	{
	265	// Make another frame, containing a canvas
	266	MyChild *subframe ;
	267
	268	m_children.Append (new MyChild(frame, wxT("SVG Frame"),
	269	wxPoint(-1, -1), wxSize(-1, -1),
	270	wxDEFAULT_FRAME_STYLE ) ) ;
	271
216db41f	272	subframe = (MyChild *) m_children.GetLast() -> GetData ();
cdf3a589 CE	273	wxString title;
	274	title.Printf(wxT("SVG Test Window %d"), nWinCreated );
	275	// counts number of children previously, even if now closed
	276	nWinCreated ++ ;
	277
	278	// Give it a title and icon
	279	subframe->SetTitle(title);
	280	subframe->SetIcon(wxICON(mondrian));
	281
	282	// Make a menubar
	283	wxMenu *file_menu = new wxMenu;
	284
	285	file_menu->Append(MDI_NEW_WINDOW, wxT("&Another test\tCtrl+N"));
	286	file_menu->Append(MDI_SAVE, wxT("&Save\tCtrl+S"), wxT("Save in SVG format"));
	287	file_menu->Append(MDI_CHILD_QUIT, wxT("&Close child\tCtrl+F4"));
	288	file_menu->Append(MDI_QUIT, wxT("&Exit\tAlt+X"));
	289
	290	wxMenu *help_menu = new wxMenu;
	291	help_menu->Append(MDI_ABOUT, wxT("&About"));
	292
	293	wxMenuBar *menu_bar = new wxMenuBar;
	294
	295	menu_bar->Append(file_menu, wxT("&File"));
	296	menu_bar->Append(help_menu, wxT("&Help"));
	297
	298	// Associate the menu bar with the frame
	299	subframe->SetMenuBar(menu_bar);
	300
	301	subframe->Show(TRUE);
	302	}
	303
	304
756d3e7f	305	void MyFrame::OnSize(wxSizeEvent& event)
cdf3a589 CE	306	{
	307	int w, h;
	308	GetClientSize(&w, &h);
	309
	310	GetClientWindow()->SetSize(0, 0, w, h);
756d3e7f	311	event.Skip();
cdf3a589 CE	312	}
	313
	314
	315	void MyFrame::InitToolBar(wxToolBar* toolBar)
	316	{
	317	const int maxBitmaps = 3 ;
	318	wxBitmap* bitmaps[maxBitmaps];
	319
	320	bitmaps[0] = new wxBitmap( new_xpm );
	321	bitmaps[1] = new wxBitmap( save_xpm );
	322	bitmaps[2] = new wxBitmap( help_xpm );
	323
	324	int width = 16;
	325	int currentX = 5;
	326
	327	toolBar->AddTool( MDI_NEW_WINDOW, (bitmaps[0]), wxNullBitmap, FALSE, currentX, -1, (wxObject ) NULL, wxT("New SVG test window"));
	328	currentX += width + 5;
	329	toolBar->AddTool( MDI_SAVE, bitmaps[1], wxNullBitmap, FALSE, currentX, -1, (wxObject ) NULL, wxT("Save test in SVG format"));
	330	currentX += width + 5;
	331	toolBar->AddSeparator();
	332	toolBar->AddTool(MDI_ABOUT, bitmaps[2], wxNullBitmap, TRUE, currentX, -1, (wxObject ) NULL, wxT("Help"));
	333
	334	toolBar->Realize();
	335
	336	int i;
	337	for (i = 0; i < maxBitmaps; i++)
	338	delete bitmaps[i];
	339	}
	340
	341
	342	void MyFrame::FileSavePicture (wxCommandEvent & WXUNUSED(event) )
	343	{
	344	MyChild * pChild = (MyChild *)GetActiveChild ();
	345	if (pChild == NULL)
	346	{
	347	return ;
	348	}
	349
	350	wxFileDialog dialog(this, wxT("Save Picture as"), wxEmptyString, pChild->GetTitle(),
	351	wxT("SVG vector picture files (.svg)\|.svg"),
	352	wxSAVE\|wxOVERWRITE_PROMPT);
	353
	354	if (dialog.ShowModal() == wxID_OK)
	355	{
	356	if (!pChild -> OnSave ( dialog.GetPath() ))
	357	{
	358	return ;
	359	}
	360	}
	361	return ;
	362	}
	363
	364
	365	// Note that MDI_NEW_WINDOW and MDI_ABOUT commands get passed
	366	// to the parent window for processing, so no need to
	367	// duplicate event handlers here.
	368	BEGIN_EVENT_TABLE(MyChild, wxMDIChildFrame)
	369	EVT_MENU(MDI_CHILD_QUIT, MyChild::OnQuit)
	370	EVT_CLOSE(MyChild::OnClose)
	371	END_EVENT_TABLE()
	372
	373	BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
	374
	375	END_EVENT_TABLE()
376
377	// ---------------------------------------------------------------------------
378	// MyCanvas
379	// ---------------------------------------------------------------------------
380
381	// Define a constructor for my canvas
382	MyCanvas::MyCanvas(wxWindow *parent, const wxPoint& pos, const wxSize& size)
383	: wxScrolledWindow(parent, -1, pos, size,
384	wxSUNKEN_BORDER\|wxVSCROLL\|wxHSCROLL)
385	{
386	m_child = (MyChild *) parent ;
87728739	387	SetBackgroundColour(wxColour(_T("WHITE")));
cdf3a589 CE	388	m_index = m_child->m_frame->nWinCreated % 7 ;
	389	}
	390
	391
	392	// Define the repainting behaviour
	393	void MyCanvas::OnDraw(wxDC& dc)
	394	{
	395	// vars to use ...
d96cdd4a	396	#if wxUSE_STATUSBAR
cdf3a589	397	wxString s ;
d96cdd4a	398	#endif // wxUSE_STATUSBAR
cdf3a589 CE	399	wxPen wP ;
	400	wxBrush wB ;
	401	wxPoint points[6];
	402	wxColour wC;
	403	wxFont wF ;
	404
	405	dc.SetFont(*wxSWISS_FONT);
	406	dc.SetPen(*wxGREEN_PEN);
	407
	408
	409	switch (m_index)
	410	{
	411	default:
	412	case 0:
	413	// draw lines to make a cross
	414	dc.DrawLine(0, 0, 200, 200);
	415	dc.DrawLine(200, 0, 0, 200);
	416	// draw point colored line and spline
	417	wP = *wxCYAN_PEN ;
	418	wP.SetWidth(3);
	419	dc.SetPen(wP);
	420
	421	dc.DrawPoint (25,15) ;
	422	dc.DrawLine(50, 30, 200, 30);
	423	dc.DrawSpline(50, 200, 50, 100, 200, 10);
d96cdd4a	424	#if wxUSE_STATUSBAR
cdf3a589	425	s = wxT("Green Cross, Cyan Line and spline");
d96cdd4a	426	#endif // wxUSE_STATUSBAR
cdf3a589 CE	427	break ;
	428
	429	case 1:
	430	// draw standard shapes
	431	dc.SetBrush(*wxCYAN_BRUSH);
	432	dc.SetPen(*wxRED_PEN);
	433	dc.DrawRectangle(10, 10, 100, 70);
87728739	434	wB = wxBrush (_T("DARK ORCHID"), wxTRANSPARENT);
cdf3a589 CE	435	dc.SetBrush (wB);
cdf3a589 CE	436	dc.DrawRoundedRectangle(50, 50, 100, 70, 20);
87728739	437	dc.SetBrush (wxBrush(_T("GOLDENROD"), wxSOLID) );
cdf3a589 CE	438	dc.DrawEllipse(100, 100, 100, 50);
	439
	440	points[0].x = 100; points[0].y = 200;
	441	points[1].x = 70; points[1].y = 260;
	442	points[2].x = 160; points[2].y = 230;
	443	points[3].x = 40; points[3].y = 230;
	444	points[4].x = 130; points[4].y = 260;
	445	points[5].x = 100; points[5].y = 200;
	446
	447	dc.DrawPolygon(5, points);
	448	dc.DrawLines (6, points, 160);
d96cdd4a	449	#if wxUSE_STATUSBAR
cdf3a589	450	s = wxT("Blue rectangle, red edge, clear rounded rectangle, gold ellipse, gold and clear stars");
d96cdd4a	451	#endif // wxUSE_STATUSBAR
cdf3a589 CE	452	break ;
	453
	454	case 2:
	455	// draw text in Arial or similar font
	456	dc.DrawLine(50,25,50,35);
	457	dc.DrawLine(45,30,55,30);
	458	dc.DrawText(wxT("This is a Swiss-style string"), 50, 30);
	459	wC = dc.GetTextForeground() ;
87728739	460	dc.SetTextForeground (_T("FIREBRICK"));
cdf3a589 CE	461
cdf3a589 CE	462	// no effect in msw ??
87728739	463	dc.SetTextBackground (_T("WHEAT"));
cdf3a589 CE	464	dc.DrawText(wxT("This is a Red string"), 50, 200);
	465	dc.DrawRotatedText(wxT("This is a 45 deg string"), 50, 200, 45);
	466	dc.DrawRotatedText(wxT("This is a 90 deg string"), 50, 200, 90);
	467	wF = wxFont ( 18, wxROMAN, wxITALIC, wxBOLD, FALSE, wxT("Times New Roman"));
	468	dc.SetFont(wF);
	469	dc.SetTextForeground (wC) ;
	470	dc.DrawText(wxT("This is a Times-style string"), 50, 60);
d96cdd4a	471	#if wxUSE_STATUSBAR
cdf3a589	472	s = wxT("Swiss, Times text; red text, rotated and colored orange");
d96cdd4a	473	#endif // wxUSE_STATUSBAR
cdf3a589 CE	474	break ;
	475
	476	case 3 :
	477	// four arcs start and end points, center
	478	dc.SetBrush(*wxGREEN_BRUSH);
216db41f	479	dc.DrawArc ( 200,300, 370,230, 300,300 );
cdf3a589	480	dc.SetBrush(*wxBLUE_BRUSH);
216db41f	481	dc.DrawArc ( 270-50, 270-86, 270-86, 270-50, 270,270 );
cdf3a589	482	dc.SetDeviceOrigin(-10,-10);
216db41f	483	dc.DrawArc ( 270-50, 270-86, 270-86, 270-50, 270,270 );
cdf3a589 CE	484	dc.SetDeviceOrigin(0,0);
cdf3a589 CE	485
87728739	486	wP.SetColour (_T("CADET BLUE"));
cdf3a589	487	dc.SetPen(wP);
216db41f	488	dc.DrawArc ( 75,125, 110, 40, 75, 75 );
cdf3a589	489
87728739	490	wP.SetColour (_T("SALMON"));
cdf3a589 CE	491	dc.SetPen(wP);
	492	dc.SetBrush(*wxRED_BRUSH);
	493	//top left corner, width and height, start and end angle
	494	// 315 same center and x-radius as last pie-arc, half Y radius
	495	dc.DrawEllipticArc(25,50,100,50,180.0,45.0) ;
	496
	497	wP = *wxCYAN_PEN ;
	498	wP.SetWidth(3);
	499	dc.SetPen(wP);
	500	//wxTRANSPARENT));
87728739	501	dc.SetBrush (wxBrush (_T("SALMON"),wxSOLID)) ;
cdf3a589 CE	502	dc.DrawEllipticArc(300, 0,200,100, 0.0,145.0) ;
	503	//same end point
	504	dc.DrawEllipticArc(300, 50,200,100,90.0,145.0) ;
	505	dc.DrawEllipticArc(300,100,200,100,90.0,345.0) ;
	506
d96cdd4a	507	#if wxUSE_STATUSBAR
cdf3a589	508	s = wxT("This is an arc test page");
d96cdd4a	509	#endif // wxUSE_STATUSBAR
cdf3a589 CE	510	break ;
	511
	512	case 4:
	513	dc.DrawCheckMark ( 30,30,25,25);
87728739	514	dc.SetBrush (wxBrush (_T("SALMON"),wxTRANSPARENT));
cdf3a589 CE	515	dc.DrawCheckMark ( 80,50,75,75);
cdf3a589 CE	516	dc.DrawRectangle ( 80,50,75,75);
d96cdd4a	517	#if wxUSE_STATUSBAR
cdf3a589	518	s = wxT("Two check marks");
d96cdd4a	519	#endif // wxUSE_STATUSBAR
cdf3a589 CE	520	break ;
	521
	522	case 5:
	523	wF = wxFont ( 18, wxROMAN, wxITALIC, wxBOLD, FALSE, wxT("Times New Roman"));
	524	dc.SetFont(wF);
	525	dc.DrawLine(0, 0, 200, 200);
	526	dc.DrawLine(200, 0, 0, 200);
	527	dc.DrawText(wxT("This is an 18pt string"), 50, 60);
	528
	529	// rescale and draw in blue
	530	wP = *wxCYAN_PEN ;
	531	dc.SetPen(wP);
	532	dc.SetUserScale (2.0,0.5);
	533	dc.SetDeviceOrigin(200,0);
	534	dc.DrawLine(0, 0, 200, 200);
	535	dc.DrawLine(200, 0, 0, 200);
	536	dc.DrawText(wxT("This is an 18pt string 2 x 0.5 UserScaled"), 50, 60);
	537	dc.SetUserScale (2.0,2.0);
	538	dc.SetDeviceOrigin(200,200);
	539	dc.DrawText(wxT("This is an 18pt string 2 x 2 UserScaled"), 50, 60);
	540
	541	wP = *wxRED_PEN ;
	542	dc.SetPen(wP);
	543	dc.SetUserScale (1.0,1.0);
	544	dc.SetDeviceOrigin(0,10);
	545	dc.SetMapMode (wxMM_METRIC) ; //svg ignores this
	546	dc.DrawLine(0, 0, 200, 200);
	547	dc.DrawLine(200, 0, 0, 200);
	548	dc.DrawText(wxT("This is an 18pt string in MapMode"), 50, 60);
d96cdd4a	549	#if wxUSE_STATUSBAR
cdf3a589	550	s = wxT("Scaling test page");
d96cdd4a	551	#endif // wxUSE_STATUSBAR
cdf3a589 CE	552	break ;
	553
	554	case 6:
756d3e7f CE	555	dc.DrawIcon( wxIcon(mondrian_xpm), 10, 10 );
756d3e7f CE	556	dc.DrawBitmap ( wxBitmap(svgbitmap_xpm), 50,15);
d96cdd4a	557	#if wxUSE_STATUSBAR
cdf3a589	558	s = wxT("Icon and Bitmap ");
d96cdd4a	559	#endif // wxUSE_STATUSBAR
cdf3a589 CE	560	break ;
	561
	562	}
d96cdd4a	563	#if wxUSE_STATUSBAR
cdf3a589	564	m_child->SetStatusText(s);
d96cdd4a	565	#endif // wxUSE_STATUSBAR
cdf3a589 CE	566	}
	567
	568
	569
	570
	571	// ---------------------------------------------------------------------------
	572	// MyChild
	573	// ---------------------------------------------------------------------------
	574
	575	MyChild::MyChild(wxMDIParentFrame *parent, const wxString& title,
	576	const wxPoint& pos, const wxSize& size,
	577	const long style)
	578	: wxMDIChildFrame(parent, -1, title, pos, size, style)
	579	{
	580
	581	m_frame = (MyFrame *) parent ;
d96cdd4a	582	#if wxUSE_STATUSBAR
cdf3a589 CE	583	CreateStatusBar();
cdf3a589 CE	584	SetStatusText(title);
d96cdd4a	585	#endif // wxUSE_STATUSBAR
cdf3a589 CE	586
	587	int w, h ;
	588	GetClientSize ( &w, &h );
	589	m_canvas = new MyCanvas(this, wxPoint(0, 0), wxSize (w,h) );
	590	// Give it scrollbars
	591	m_canvas->SetScrollbars(20, 20, 50, 50);
	592
	593	}
	594
	595
	596	MyChild::~MyChild()
	597	{
	598	m_frame->m_children.DeleteObject(this);
	599	}
	600
	601
	602	void MyChild::OnQuit(wxCommandEvent& WXUNUSED(event))
	603	{
	604	Close(TRUE);
	605	}
	606
	607
	608	bool MyChild::OnSave(wxString filename)
	609	{
	610	wxSVGFileDC svgDC (filename, 600, 650) ;
	611	m_canvas->OnDraw (svgDC);
	612	return svgDC.Ok();
	613	}
	614
	615
	616
	617	void MyChild::OnActivate(wxActivateEvent& event)
	618	{
	619	if ( event.GetActive() && m_canvas )
	620	m_canvas->SetFocus();
	621	}
	622
	623
	624	void MyChild::OnClose(wxCloseEvent& event)
	625	{
	626	event.Skip();
	627	}