746 lines
25 KiB
C++
746 lines
25 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: xti.cpp
|
|
// Purpose: eXtended RTTI support sample
|
|
// Author: Stefan Csomor, Francesco Montorsi
|
|
// Modified by:
|
|
// Created: 13/5/2007
|
|
// Copyright: (c) Stefan Csomor, Francesco Montorsi
|
|
// Licence: wxWindows licence
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// ============================================================================
|
|
// 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" wxWidgets headers)
|
|
#ifndef WX_PRECOMP
|
|
#include "wx/wx.h"
|
|
#endif
|
|
|
|
#include "wx/wx.h"
|
|
#include "wx/variant.h"
|
|
#include "wx/xml/xml.h"
|
|
#include "wx/frame.h"
|
|
#include "wx/notebook.h"
|
|
#include "wx/event.h"
|
|
#include "wx/spinbutt.h"
|
|
#include "wx/spinctrl.h"
|
|
|
|
#include "wx/xtistrm.h"
|
|
#include "wx/xtixml.h"
|
|
#include "wx/txtstrm.h"
|
|
#include "wx/wfstream.h"
|
|
#include "wx/sstream.h"
|
|
#include "wx/spinctrl.h"
|
|
|
|
#include "classlist.h"
|
|
#include "codereadercallback.h"
|
|
|
|
#if !wxUSE_EXTENDED_RTTI
|
|
#error This sample requires XTI (eXtended RTTI) enabled
|
|
#endif
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// resources
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#ifndef wxHAS_IMAGES_IN_RESOURCES
|
|
#include "../sample.xpm"
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// private classes
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Define a new application type, each program should derive a class from wxApp
|
|
class MyApp : public wxApp
|
|
{
|
|
public:
|
|
virtual bool OnInit();
|
|
};
|
|
|
|
// Define a new frame type: this is going to be our main frame
|
|
class MyFrame : public wxFrame
|
|
{
|
|
public:
|
|
// ctor(s)
|
|
MyFrame(const wxString& title);
|
|
|
|
void OnPersist(wxCommandEvent& event);
|
|
void OnDepersist(wxCommandEvent& event);
|
|
void OnGenerateCode(wxCommandEvent& event);
|
|
void OnDumpClasses(wxCommandEvent& event);
|
|
void OnQuit(wxCommandEvent& event);
|
|
void OnAbout(wxCommandEvent& event);
|
|
|
|
private:
|
|
// any class wishing to process wxWidgets events must use this macro
|
|
wxDECLARE_EVENT_TABLE();
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// constants
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// IDs for the controls and the menu commands
|
|
enum
|
|
{
|
|
// menu items
|
|
Minimal_Persist = wxID_HIGHEST,
|
|
Minimal_Depersist,
|
|
Minimal_GenerateCode,
|
|
Minimal_DumpClasses,
|
|
Minimal_Quit = wxID_EXIT,
|
|
Minimal_About = wxID_ABOUT
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// event tables and other macros for wxWidgets
|
|
// ----------------------------------------------------------------------------
|
|
|
|
wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)
|
|
EVT_MENU(Minimal_Persist, MyFrame::OnPersist)
|
|
EVT_MENU(Minimal_Depersist, MyFrame::OnDepersist)
|
|
EVT_MENU(Minimal_GenerateCode, MyFrame::OnGenerateCode)
|
|
EVT_MENU(Minimal_DumpClasses, MyFrame::OnDumpClasses)
|
|
EVT_MENU(Minimal_Quit, MyFrame::OnQuit)
|
|
EVT_MENU(Minimal_About, MyFrame::OnAbout)
|
|
wxEND_EVENT_TABLE()
|
|
|
|
wxIMPLEMENT_APP(MyApp);
|
|
|
|
// ============================================================================
|
|
// implementation
|
|
// ============================================================================
|
|
|
|
void RegisterFrameRTTI();
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// the application class
|
|
// ----------------------------------------------------------------------------
|
|
|
|
bool MyApp::OnInit()
|
|
{
|
|
if ( !wxApp::OnInit() )
|
|
return false;
|
|
|
|
RegisterFrameRTTI();
|
|
|
|
// create the main application window
|
|
MyFrame *frame = new MyFrame(wxT("Extended RTTI sample"));
|
|
|
|
// and show it (the frames, unlike simple controls, are not shown when
|
|
// created initially)
|
|
frame->Show(true);
|
|
|
|
// success: wxApp::OnRun() will be called which will enter the main message
|
|
// loop and the application will run. If we returned false here, the
|
|
// application would exit immediately.
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// main frame
|
|
// ----------------------------------------------------------------------------
|
|
|
|
MyFrame::MyFrame(const wxString& title)
|
|
: wxFrame(NULL, wxID_ANY, title, wxDefaultPosition, wxSize(300, 200))
|
|
{
|
|
// set the frame icon
|
|
SetIcon(wxICON(sample));
|
|
|
|
#if wxUSE_MENUS
|
|
// create a menu bar
|
|
wxMenu *fileMenu = new wxMenu;
|
|
|
|
// the "About" item should be in the help menu
|
|
wxMenu *helpMenu = new wxMenu;
|
|
helpMenu->Append(Minimal_About, wxT("&About\tF1"), wxT("Show about dialog"));
|
|
|
|
fileMenu->Append(Minimal_Persist, wxT("Persist a wxFrame to XML..."),
|
|
wxT("Creates a wxFrame using wxXTI and saves its description as XML"));
|
|
fileMenu->Append(Minimal_Depersist, wxT("Depersist XML file..."),
|
|
wxT("Loads the description of wxFrame from XML"));
|
|
fileMenu->Append(Minimal_GenerateCode, wxT("Generate code for a wxFrame saved to XML..."),
|
|
wxT("Generates the C++ code which belong to a persisted wxFrame"));
|
|
fileMenu->AppendSeparator();
|
|
fileMenu->Append(Minimal_DumpClasses, wxT("Dump registered classes..."),
|
|
wxT("Dumps the description of all wxWidgets classes registered in XTI"));
|
|
fileMenu->AppendSeparator();
|
|
fileMenu->Append(Minimal_Quit, wxT("E&xit\tAlt-X"), wxT("Quit this program"));
|
|
|
|
// now append the freshly created menu to the menu bar...
|
|
wxMenuBar *menuBar = new wxMenuBar();
|
|
menuBar->Append(fileMenu, wxT("&File"));
|
|
menuBar->Append(helpMenu, wxT("&Help"));
|
|
|
|
// ... and attach this menu bar to the frame
|
|
SetMenuBar(menuBar);
|
|
#endif // wxUSE_MENUS
|
|
|
|
#if wxUSE_STATUSBAR
|
|
// create a status bar just for fun (by default with 1 pane only)
|
|
CreateStatusBar(2);
|
|
SetStatusText(wxT("Welcome to wxWidgets!"));
|
|
#endif // wxUSE_STATUSBAR
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// XTI sample code
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// this is the kind of source code that would end up being generated by a
|
|
// designer corresponding to the information we are setting up via RTTI
|
|
// in the CreateFrameRTTI function:
|
|
//
|
|
// class MyXTIFrame : public wxFrame
|
|
// {
|
|
// public:
|
|
// // construction
|
|
// MyXTIFrame()
|
|
// {
|
|
// Init();
|
|
// m_button = NULL;
|
|
// }
|
|
//
|
|
// bool Create(wxWindow *parent,
|
|
// wxWindowID id,
|
|
// const wxString& title,
|
|
// const wxPoint& pos = wxDefaultPosition,
|
|
// const wxSize& size = wxDefaultSize,
|
|
// long style = wxDEFAULT_FRAME_STYLE,
|
|
// const wxString& name = wxFrameNameStr)
|
|
// {
|
|
// return wxFrame::Create( parent, id, title, pos, size, style, name );
|
|
// }
|
|
//
|
|
// void SetButton( wxButton * button ) { m_button = button; }
|
|
// wxButton* GetButton() const { return m_button; }
|
|
//
|
|
// void ButtonClickHandler( wxEvent & WXUNUSED(event) )
|
|
// {
|
|
// wxMessageBox( "Button Clicked ", "Hi!", wxOK );
|
|
// }
|
|
//
|
|
// protected:
|
|
// wxButton* m_button;
|
|
//
|
|
// wxDECLARE_EVENT_TABLE();
|
|
// wxDECLARE_DYNAMIC_CLASS_NO_COPY(MyXTIFrame);
|
|
// };
|
|
//
|
|
// IMPLEMENT_DYNAMIC_CLASS_XTI(MyXTIFrame, MyXTIFrame, "x.h")
|
|
//
|
|
// WX_BEGIN_PROPERTIES_TABLE(MyXTIFrame)
|
|
// WX_PROPERTY( Button, wxButton*, SetButton, GetButton, )
|
|
// WX_END_PROPERTIES_TABLE()
|
|
//
|
|
// WX_BEGIN_HANDLERS_TABLE(MyXTIFrame)
|
|
// WX_HANDLER( ButtonClickHandler, wxCommandEvent )
|
|
// WX_END_HANDLERS_TABLE()
|
|
//
|
|
// WX_CONSTRUCTOR_5( MyXTIFrame, wxWindow*, Parent, wxWindowID, Id,
|
|
// wxString, Title, wxPoint, Position, wxSize, Size )
|
|
//
|
|
// wxBEGIN_EVENT_TABLE(MyXTIFrame, wxFrame)
|
|
// wxEND_EVENT_TABLE()
|
|
|
|
// the following class "persists" (i.e. saves) a wxFrame into a wxObjectWriter
|
|
|
|
class MyDesignerPersister : public wxObjectWriterCallback
|
|
{
|
|
public:
|
|
MyDesignerPersister( wxDynamicObject * frame)
|
|
{
|
|
m_frame = frame;
|
|
}
|
|
|
|
virtual bool BeforeWriteDelegate( wxObjectWriter *WXUNUSED(writer),
|
|
const wxObject *object,
|
|
const wxClassInfo* WXUNUSED(classInfo),
|
|
const wxPropertyInfo *propInfo,
|
|
const wxObject *&eventSink,
|
|
const wxHandlerInfo* &handlerInfo )
|
|
{
|
|
// this approach would be used if the handler would not
|
|
// be connected really in the designer, so we have to supply
|
|
// the information
|
|
const wxObject* but = wxAnyGetAsObjectPtr( m_frame->GetProperty(wxT("Button")) );
|
|
if ( object == but &&
|
|
propInfo == wxCLASSINFO( wxButton )->FindPropertyInfo(wxT("OnClick")) )
|
|
{
|
|
eventSink = m_frame;
|
|
handlerInfo = m_frame->GetClassInfo()->
|
|
FindHandlerInfo(wxT("ButtonClickHandler"));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private:
|
|
wxDynamicObject *m_frame;
|
|
};
|
|
|
|
// sometimes linkers (at least MSVC and GCC ones) optimize the final EXE
|
|
// even in debug mode pruning the object files which he "thinks" are useless;
|
|
// thus the classes defined in those files won't be available in the XTI
|
|
// table and the program will fail to allocate them.
|
|
// The following macro implements a simple hack to ensure that a given
|
|
// class is linked in.
|
|
//
|
|
// TODO: in wx/link.h there are already similar macros (also more "optimized":
|
|
// don't need the creation of fake object) which however require to use
|
|
// the wxFORCE_LINK_THIS_MODULE() macro inside the source files corresponding
|
|
// to the class being discarded.
|
|
//
|
|
#define wxENSURE_CLASS_IS_LINKED(x) { x test; }
|
|
|
|
void RegisterFrameRTTI()
|
|
{
|
|
// set up the RTTI info for a class (MyXTIFrame) which
|
|
// is not defined anywhere in this program
|
|
wxDynamicClassInfo *dyninfo =
|
|
wx_dynamic_cast( wxDynamicClassInfo *, wxClassInfo::FindClass(wxT("MyXTIFrame")));
|
|
if ( dyninfo == NULL )
|
|
{
|
|
dyninfo = new wxDynamicClassInfo(wxT("myxtiframe.h"),
|
|
wxT("MyXTIFrame"),
|
|
CLASSINFO(wxFrame) );
|
|
|
|
// this class has a property named "Button" and the relative handler:
|
|
dyninfo->AddProperty(wxT("Button"), wxGetTypeInfo((wxButton**) NULL));
|
|
dyninfo->AddHandler(wxT("ButtonClickHandler"),
|
|
NULL /* no instance of the handler method */, CLASSINFO( wxEvent ) );
|
|
}
|
|
}
|
|
|
|
wxDynamicObject* CreateFrameRTTI()
|
|
{
|
|
int baseID = 100;
|
|
wxAny Params[10];
|
|
|
|
// the class is now part of XTI internal table so that we can
|
|
// get a pointer to it just searching it like any other class:
|
|
wxFrame* frame;
|
|
wxClassInfo *info = wxClassInfo::FindClass(wxT("MyXTIFrame"));
|
|
wxASSERT( info );
|
|
wxDynamicObject* frameWrapper =
|
|
wx_dynamic_cast(wxDynamicObject*, info->CreateObject() );
|
|
Params[0] = wxAny((wxWindow*)(NULL));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxString(wxT("This is a frame created from XTI")));
|
|
Params[3] = wxAny(wxPoint(-1,-1));
|
|
Params[4] = wxAny(wxSize(400,300));
|
|
Params[5] = wxAny((long)wxDEFAULT_FRAME_STYLE);
|
|
wxASSERT( info->Create(frameWrapper, 6, Params ));
|
|
frame = wx_dynamic_cast(wxFrame*, frameWrapper->GetSuperClassInstance());
|
|
|
|
#if 1
|
|
// now build a notebook inside it:
|
|
wxNotebook* notebook;
|
|
info = wxClassInfo::FindClass("wxNotebook");
|
|
wxASSERT( info );
|
|
notebook = wxDynamicCast( info->CreateObject(), wxNotebook );
|
|
Params[0] = wxAny((wxWindow*)frame);
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxPoint( 10, 10 ));
|
|
Params[3] = wxAny(wxDefaultSize);
|
|
Params[4] = wxAny((long)0);
|
|
wxASSERT( info->Create(notebook, 5, Params ));
|
|
|
|
// button page
|
|
|
|
wxPanel* panel;
|
|
info = wxClassInfo::FindClass("wxPanel");
|
|
wxASSERT( info );
|
|
panel = wxDynamicCast( info->CreateObject(), wxPanel );
|
|
Params[0] = wxAny((wxWindow*)(notebook));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxPoint(-1,-1));
|
|
Params[3] = wxAny(wxSize(-1,-1));
|
|
Params[4] = wxAny((long)0);
|
|
Params[5] = wxAny(wxString(wxT("Hello")));
|
|
wxASSERT( info->Create(panel, 6, Params ));
|
|
notebook->AddPage( panel, "Buttons" );
|
|
|
|
wxButton* button;
|
|
info = wxClassInfo::FindClass("wxButton");
|
|
wxASSERT( info );
|
|
button = wxDynamicCast( info->CreateObject(), wxButton );
|
|
Params[0] = wxAny((wxWindow*)(panel));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxString(wxT("Click Me!")));
|
|
Params[3] = wxAny(wxPoint( 10, 10 ));
|
|
Params[4] = wxAny(wxSize(-1,-1));
|
|
Params[5] = wxAny((long)0);
|
|
wxASSERT( info->Create(button, 6, Params ));
|
|
frameWrapper->SetProperty( wxT("Button"), wxAny( button ) );
|
|
|
|
// other controls page
|
|
|
|
info = wxClassInfo::FindClass("wxPanel");
|
|
wxASSERT( info );
|
|
panel = wxDynamicCast( info->CreateObject(), wxPanel );
|
|
Params[0] = wxAny((wxWindow*)(notebook));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxPoint(-1,-1));
|
|
Params[3] = wxAny(wxSize(-1,-1));
|
|
Params[4] = wxAny((long)0);
|
|
Params[5] = wxAny(wxString(wxT("Hello")));
|
|
wxASSERT( info->Create(panel, 6, Params ));
|
|
notebook->AddPage( panel, "Other Standard controls" );
|
|
|
|
wxControl* control;
|
|
info = wxClassInfo::FindClass("wxCheckBox");
|
|
wxASSERT( info );
|
|
control = wxDynamicCast( info->CreateObject(), wxControl );
|
|
Params[0] = wxAny((wxWindow*)(panel));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxString(wxT("A Checkbox")));
|
|
Params[3] = wxAny(wxPoint( 10, 10 ));
|
|
Params[4] = wxAny(wxSize(-1,-1));
|
|
Params[5] = wxAny((long)0);
|
|
wxASSERT( info->Create(control, 6, Params ));
|
|
|
|
info = wxClassInfo::FindClass("wxRadioButton");
|
|
wxASSERT( info );
|
|
control = wxDynamicCast( info->CreateObject(), wxControl );
|
|
Params[0] = wxAny((wxWindow*)(panel));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxString(wxT("A Radiobutton")));
|
|
Params[3] = wxAny(wxPoint( 10, 30 ));
|
|
Params[4] = wxAny(wxSize(-1,-1));
|
|
Params[5] = wxAny((long)0);
|
|
wxASSERT( info->Create(control, 6, Params ));
|
|
|
|
control = wxDynamicCast( info->CreateObject(), wxControl );
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxString(wxT("Another One")));
|
|
Params[3] = wxAny(wxPoint( 10, 50 ));
|
|
wxASSERT( info->Create(control, 6, Params ));
|
|
|
|
info = wxClassInfo::FindClass("wxStaticText");
|
|
wxASSERT( info );
|
|
control = wxDynamicCast( info->CreateObject(), wxControl );
|
|
Params[0] = wxAny((wxWindow*)(panel));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxString(wxT("A Static Text!")));
|
|
Params[3] = wxAny(wxPoint( 10, 70 ));
|
|
Params[4] = wxAny(wxSize(-1,-1));
|
|
Params[5] = wxAny((long)0);
|
|
wxASSERT( info->Create(control, 6, Params ));
|
|
|
|
info = wxClassInfo::FindClass("wxStaticBox");
|
|
wxASSERT( info );
|
|
control = wxDynamicCast( info->CreateObject(), wxControl );
|
|
Params[0] = wxAny((wxWindow*)(panel));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxString(wxT("A Static Box")));
|
|
Params[3] = wxAny(wxPoint( 10, 90 ));
|
|
Params[4] = wxAny(wxSize(100,80));
|
|
Params[5] = wxAny((long)0);
|
|
wxASSERT( info->Create(control, 6, Params ));
|
|
|
|
info = wxClassInfo::FindClass("wxTextCtrl");
|
|
wxASSERT( info );
|
|
control = wxDynamicCast( info->CreateObject(), wxControl );
|
|
Params[0] = wxAny((wxWindow*)(panel));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxString(wxT("A Text Control")));
|
|
Params[3] = wxAny(wxPoint( 10, 200 ));
|
|
Params[4] = wxAny(wxSize(-1,-1));
|
|
Params[5] = wxAny((long)0);
|
|
wxASSERT( info->Create(control, 6, Params ));
|
|
|
|
// spins and gauges page
|
|
|
|
info = wxClassInfo::FindClass("wxPanel");
|
|
wxASSERT( info );
|
|
panel = wxDynamicCast( info->CreateObject(), wxPanel );
|
|
Params[0] = wxAny((wxWindow*)(notebook));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxPoint(-1,-1));
|
|
Params[3] = wxAny(wxSize(-1,-1));
|
|
Params[4] = wxAny((long)0);
|
|
Params[5] = wxAny(wxString(wxT("Hello")));
|
|
wxASSERT( info->Create(panel, 6, Params ));
|
|
notebook->AddPage( panel, "Spins and Sliders" );
|
|
|
|
wxENSURE_CLASS_IS_LINKED(wxSpinButton);
|
|
|
|
info = wxClassInfo::FindClass("wxSpinButton");
|
|
wxASSERT( info );
|
|
control = wxDynamicCast( info->CreateObject(), wxControl );
|
|
Params[0] = wxAny((wxWindow*)(panel));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxPoint( 10, 10 ));
|
|
Params[3] = wxAny(wxSize(-1,-1));
|
|
Params[4] = wxAny((long)wxSP_VERTICAL | wxSP_ARROW_KEYS);
|
|
wxASSERT( info->Create(control, 5, Params ));
|
|
|
|
wxENSURE_CLASS_IS_LINKED(wxSpinCtrl);
|
|
|
|
info = wxClassInfo::FindClass("wxSpinCtrl");
|
|
wxASSERT( info );
|
|
control = wxDynamicCast( info->CreateObject(), wxControl );
|
|
Params[0] = wxAny((wxWindow*)(panel));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny(wxString("20"));
|
|
Params[3] = wxAny(wxPoint( 40, 10 ));
|
|
Params[4] = wxAny(wxSize(40,-1));
|
|
Params[5] = wxAny((long) wxSP_ARROW_KEYS);
|
|
wxASSERT( info->Create(control, 6, Params ));
|
|
|
|
// MSVC likes to exclude from link wxGauge...
|
|
wxENSURE_CLASS_IS_LINKED(wxGauge)
|
|
wxENSURE_CLASS_IS_LINKED(wxCheckBox)
|
|
wxENSURE_CLASS_IS_LINKED(wxSpinCtrl)
|
|
|
|
info = wxClassInfo::FindClass("wxGauge");
|
|
|
|
wxASSERT( info );
|
|
control = wxDynamicCast( info->CreateObject(), wxControl );
|
|
Params[0] = wxAny((wxWindow*)(panel));
|
|
Params[1] = wxAny(wxWindowID(baseID++));
|
|
Params[2] = wxAny((int) 100);
|
|
Params[3] = wxAny(wxPoint( 10, 50 ));
|
|
Params[4] = wxAny(wxSize(-1,-1));
|
|
Params[5] = wxAny((long) wxGA_HORIZONTAL);
|
|
wxASSERT( info->Create(control, 6, Params ));
|
|
wx_dynamic_cast(wxGauge*, control)->SetValue(20);
|
|
|
|
#endif
|
|
return frameWrapper;
|
|
}
|
|
|
|
bool SaveFrameRTTI(const wxString &testFileName, wxDynamicObject *frame)
|
|
{
|
|
// setup the XML document
|
|
wxXmlDocument xml;
|
|
wxXmlNode *root = new wxXmlNode(wxXML_ELEMENT_NODE,
|
|
"TestXTI", "This is the content");
|
|
xml.SetRoot(root);
|
|
|
|
// setup the XTI writer and persister
|
|
wxObjectXmlWriter writer(root);
|
|
MyDesignerPersister persister(frame);
|
|
|
|
// write the given wxObject into the XML document
|
|
wxStringToAnyHashMap empty;
|
|
writer.WriteObject( frame, frame->GetClassInfo(), &persister,
|
|
wxString("myTestFrame"), empty );
|
|
|
|
return xml.Save(testFileName);
|
|
}
|
|
|
|
wxDynamicObject* LoadFrameRTTI(const wxString &fileName)
|
|
{
|
|
// load the XML document
|
|
wxXmlDocument xml;
|
|
if (!xml.Load(fileName))
|
|
return NULL;
|
|
|
|
wxXmlNode *root = xml.GetRoot();
|
|
if (root->GetName() != "TestXTI")
|
|
return NULL;
|
|
|
|
// now depersist the wxFrame we saved into it using wxObjectRuntimeReaderCallback
|
|
wxObjectRuntimeReaderCallback Callbacks;
|
|
wxObjectXmlReader Reader( root );
|
|
int obj = Reader.ReadObject( wxString("myTestFrame"), &Callbacks );
|
|
return (wxDynamicObject*)Callbacks.GetObject( obj );
|
|
}
|
|
|
|
bool GenerateFrameRTTICode(const wxString &inFileName, const wxString &outFileName)
|
|
{
|
|
// is loading the streamed out component from xml and writing code that
|
|
// will create the same component
|
|
|
|
wxFFileOutputStream fos( outFileName );
|
|
wxTextOutputStream tos( fos );
|
|
if (!fos.IsOk())
|
|
return false;
|
|
|
|
wxXmlDocument xml;
|
|
if (!xml.Load(inFileName))
|
|
return false;
|
|
|
|
wxXmlNode *root = xml.GetRoot();
|
|
if (root->GetName() != "TestXTI")
|
|
return false;
|
|
|
|
// read the XML file using the wxObjectCodeReaderCallback
|
|
|
|
wxString headerincludes;
|
|
wxString sourcecode;
|
|
wxObjectCodeReaderCallback Callbacks(headerincludes,sourcecode);
|
|
wxObjectXmlReader Reader(root);
|
|
|
|
// ReadObject will return the ID of the object read??
|
|
Reader.ReadObject( wxString("myTestFrame"), &Callbacks );
|
|
|
|
// header preamble
|
|
tos <<
|
|
"#include \"wx/wxprec.h\" \n#ifdef __BORLANDC__\n#pragma hdrstop\n#endif\n#ifndef WX_PRECOMP\n#include \"wx/wx.h\" \n#endif\n\n";
|
|
// add object includes
|
|
tos.WriteString( headerincludes );
|
|
|
|
tos << "\n\nvoid test()\n{";
|
|
tos.WriteString( sourcecode );
|
|
tos << "}";
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// MyFrame event handlers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void MyFrame::OnPersist(wxCommandEvent& WXUNUSED(event))
|
|
{
|
|
// first create a frame using XTI calls
|
|
wxDynamicObject *frame = CreateFrameRTTI();
|
|
if (!frame)
|
|
{
|
|
wxLogError(wxT("Cannot create the XTI frame!"));
|
|
return;
|
|
}
|
|
|
|
// show the frame we're going to save to the user
|
|
wxFrame *trueFrame = wx_dynamic_cast(wxFrame *, frame->GetSuperClassInstance() );
|
|
trueFrame->Show();
|
|
|
|
// ask the user where to save it
|
|
wxFileDialog dlg(this, wxT("Where should the frame be saved?"),
|
|
wxEmptyString, wxT("test.xml"), wxT("XML files (*.xml)|*.xml"),
|
|
wxFD_SAVE);
|
|
if (dlg.ShowModal() == wxID_CANCEL)
|
|
return;
|
|
|
|
// then save it to a test XML file
|
|
if (!SaveFrameRTTI(dlg.GetPath(), frame))
|
|
{
|
|
wxLogError(wxT("Cannot save the XTI frame into '%s'"), dlg.GetPath());
|
|
return;
|
|
}
|
|
|
|
// now simply delete it
|
|
delete frame;
|
|
}
|
|
|
|
void MyFrame::OnDepersist(wxCommandEvent& WXUNUSED(event))
|
|
{
|
|
// ask the user which file to load
|
|
wxFileDialog dlg(this, wxT("Which file contains the frame to depersist?"),
|
|
wxEmptyString, wxT("test.xml"), wxT("XML files (*.xml)|*.xml"),
|
|
wxFD_OPEN);
|
|
if (dlg.ShowModal() == wxID_CANCEL)
|
|
return;
|
|
|
|
wxObject *frame = LoadFrameRTTI(dlg.GetPath());
|
|
if (!frame)
|
|
{
|
|
wxLogError(wxT("Could not depersist the wxFrame from '%s'"), dlg.GetPath());
|
|
return;
|
|
}
|
|
|
|
wxFrame *trueFrame = wx_dynamic_cast(wxFrame*, frame );
|
|
if ( !trueFrame )
|
|
{
|
|
wxDynamicObject* dyno = wx_dynamic_cast(wxDynamicObject*, frame );
|
|
if ( dyno )
|
|
trueFrame = wx_dynamic_cast(wxFrame *, dyno->GetSuperClassInstance() );
|
|
}
|
|
|
|
if ( trueFrame )
|
|
trueFrame->Show();
|
|
else
|
|
wxLogError(wxT("Could not show the frame"));
|
|
}
|
|
|
|
void MyFrame::OnGenerateCode(wxCommandEvent& WXUNUSED(event))
|
|
{
|
|
// ask the user which file to load
|
|
wxFileDialog dlg(this, wxT("Which file contains the frame to work on?"),
|
|
wxEmptyString, wxT("test.xml"), wxT("XML files (*.xml)|*.xml"),
|
|
wxFD_OPEN);
|
|
if (dlg.ShowModal() == wxID_CANCEL)
|
|
return;
|
|
|
|
// ask the user which file to load
|
|
wxFileDialog dlg2(this, wxT("Where should the C++ code be saved?"),
|
|
wxEmptyString, wxT("test.cpp"), wxT("Source files (*.cpp)|*.cpp"),
|
|
wxFD_SAVE);
|
|
if (dlg2.ShowModal() == wxID_CANCEL)
|
|
return;
|
|
|
|
// do generate code
|
|
if (!GenerateFrameRTTICode(dlg.GetPath(), dlg2.GetPath()))
|
|
{
|
|
wxLogError(wxT("Could not generate the code for the frame!"));
|
|
return;
|
|
}
|
|
|
|
// show the generated code
|
|
{
|
|
wxFileInputStream f(dlg2.GetPath());
|
|
wxStringOutputStream str;
|
|
f.Read(str);
|
|
|
|
wxDialog dlg(this, wxID_ANY, wxT("Generated code"),
|
|
wxDefaultPosition, wxDefaultSize,
|
|
wxRESIZE_BORDER|wxDEFAULT_DIALOG_STYLE);
|
|
wxPanel *panel = new wxPanel(&dlg);
|
|
wxSizer *sz = new wxBoxSizer(wxVERTICAL);
|
|
sz->Add(new wxTextCtrl(panel, wxID_ANY, str.GetString(),
|
|
wxDefaultPosition, wxDefaultSize,
|
|
wxTE_MULTILINE|wxTE_READONLY|wxTE_DONTWRAP),
|
|
1, wxGROW|wxALL, 5);
|
|
sz->Add(new wxButton(panel, wxID_OK), 0, wxALIGN_RIGHT|wxALL, 5);
|
|
panel->SetSizerAndFit(sz);
|
|
dlg.ShowModal();
|
|
}
|
|
}
|
|
|
|
void MyFrame::OnDumpClasses(wxCommandEvent& WXUNUSED(event))
|
|
{
|
|
ClassListDialog dlg(this);
|
|
dlg.ShowModal();
|
|
}
|
|
|
|
void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
|
|
{
|
|
// true is to force the frame to close
|
|
Close(true);
|
|
}
|
|
|
|
void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
|
|
{
|
|
wxMessageBox(wxString::Format(
|
|
wxT("Welcome to %s!\n")
|
|
wxT("\n")
|
|
wxT("This sample demonstrates wxWidgets eXtended RTTI (XTI) system."),
|
|
wxVERSION_STRING
|
|
),
|
|
wxT("About wxWidgets XTI sample"),
|
|
wxOK | wxICON_INFORMATION,
|
|
this);
|
|
}
|