git.saurik.com Git - wxWidgets.git/blob

1 /////////////////////////////////////////////////////////////////////////////

2 // Name: xti.cpp

3 // Purpose: eXtended RTTI support sample

4 // Author: Stefan Csomor, Francesco Montorsi

5 // Modified by:

6 // Created: 13/5/2007

7 // Copyright: (c) Stefan Csomor, Francesco Montorsi

8 // Licence: wxWindows licence

9 /////////////////////////////////////////////////////////////////////////////

11 // ============================================================================

12 // declarations

13 // ============================================================================

15 // ----------------------------------------------------------------------------

16 // headers

17 // ----------------------------------------------------------------------------

19 // For compilers that support precompilation, includes "wx/wx.h".

20 #include "wx/wxprec.h"

22 #ifdef __BORLANDC__

23 #pragma hdrstop

24 #endif

26 // for all others, include the necessary headers (this file is usually all you

27 // need because it includes almost all "standard" wxWidgets headers)

28 #ifndef WX_PRECOMP

29 #include "wx/wx.h"

30 #endif

32 #include "wx/wx.h"

33 #include "wx/variant.h"

34 #include "wx/xml/xml.h"

35 #include "wx/frame.h"

36 #include "wx/notebook.h"

37 #include "wx/event.h"

38 #include "wx/spinbutt.h"

39 #include "wx/spinctrl.h"

41 #include "wx/xtistrm.h"

42 #include "wx/xtixml.h"

43 #include "wx/txtstrm.h"

44 #include "wx/wfstream.h"

45 #include "wx/sstream.h"

46 #include "wx/spinctrl.h"

48 #include "classlist.h"

49 #include "codereadercallback.h"

51 #if !wxUSE_EXTENDED_RTTI

52 #error This sample requires XTI (eXtended RTTI) enabled

53 #endif

56 // ----------------------------------------------------------------------------

57 // resources

58 // ----------------------------------------------------------------------------

60 #ifndef wxHAS_IMAGES_IN_RESOURCES

61 #include "../sample.xpm"

62 #endif

64 // ----------------------------------------------------------------------------

65 // private classes

66 // ----------------------------------------------------------------------------

68 // Define a new application type, each program should derive a class from wxApp

69 class MyApp : public wxApp

70 {

71 public:

72 virtual bool OnInit();

73 };

75 // Define a new frame type: this is going to be our main frame

76 class MyFrame : public wxFrame

77 {

78 public:

79 // 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);

89 private:

90 // any class wishing to process wxWidgets events must use this macro

91 wxDECLARE_EVENT_TABLE();

92 };

94 // ----------------------------------------------------------------------------

95 // constants

96 // ----------------------------------------------------------------------------

98 // IDs for the controls and the menu commands

99 enum

100 {

101 // menu items

102 Minimal_Persist = wxID_HIGHEST,

103 Minimal_Depersist,

104 Minimal_GenerateCode,

105 Minimal_DumpClasses,

106 Minimal_Quit = wxID_EXIT,

107 Minimal_About = wxID_ABOUT

108 };

109

110 // ----------------------------------------------------------------------------

111 // event tables and other macros for wxWidgets

112 // ----------------------------------------------------------------------------

113

114 BEGIN_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)

121 END_EVENT_TABLE()

122

123 wxIMPLEMENT_APP(MyApp);

124

125 // ============================================================================

126 // implementation

127 // ============================================================================

128

129 void RegisterFrameRTTI();

130

131 // ----------------------------------------------------------------------------

132 // the application class

133 // ----------------------------------------------------------------------------

134

 bool MyApp::OnInit()

136 {

     if ( !wxApp::OnInit() )

138 return false;

139

140 RegisterFrameRTTI();

141

142 // create the main application window

     MyFrame *frame = new MyFrame(wxT("Extended RTTI sample"));

144

145 // and show it (the frames, unlike simple controls, are not shown when

146 // created initially)

     frame->Show(true);

148

149 // success: wxApp::OnRun() will be called which will enter the main message

150 // loop and the application will run. If we returned false here, the

151 // application would exit immediately.

152 return true;

153 }

154

155 // ----------------------------------------------------------------------------

156 // main frame

157 // ----------------------------------------------------------------------------

158

 MyFrame::MyFrame(const wxString& title)

     : wxFrame(NULL, wxID_ANY, title, wxDefaultPosition, wxSize(300, 200))

161 {

162 // set the frame icon

     SetIcon(wxICON(sample));

164

165 #if wxUSE_MENUS

166 // create a menu bar

167 wxMenu *fileMenu = new wxMenu;

168

169 // the "About" item should be in the help menu

170 wxMenu *helpMenu = new wxMenu;

     helpMenu->Append(Minimal_About, wxT("&About\tF1"), wxT("Show about dialog"));

172

     fileMenu->Append(Minimal_Persist, wxT("Persist a wxFrame to XML..."), 

174 wxT("Creates a wxFrame using wxXTI and saves its description as XML"));

     fileMenu->Append(Minimal_Depersist, wxT("Depersist XML file..."), 

176 wxT("Loads the description of wxFrame from XML"));

     fileMenu->Append(Minimal_GenerateCode, wxT("Generate code for a wxFrame saved to XML..."), 

178 wxT("Generates the C++ code which belong to a persisted wxFrame"));

179 fileMenu->AppendSeparator();

     fileMenu->Append(Minimal_DumpClasses, wxT("Dump registered classes..."), 

181 wxT("Dumps the description of all wxWidgets classes registered in XTI"));

182 fileMenu->AppendSeparator();

     fileMenu->Append(Minimal_Quit, wxT("E&xit\tAlt-X"), wxT("Quit this program"));

184

185 // now append the freshly created menu to the menu bar...

     wxMenuBar *menuBar = new wxMenuBar();

     menuBar->Append(fileMenu, wxT("&File"));

     menuBar->Append(helpMenu, wxT("&Help"));

189

190 // ... and attach this menu bar to the frame

191 SetMenuBar(menuBar);

192 #endif // wxUSE_MENUS

193

194 #if wxUSE_STATUSBAR

195 // create a status bar just for fun (by default with 1 pane only)

196 CreateStatusBar(2);

     SetStatusText(wxT("Welcome to wxWidgets!"));

198 #endif // wxUSE_STATUSBAR

199 }

200

201

202

203 // ----------------------------------------------------------------------------

204 // XTI sample code

205 // ----------------------------------------------------------------------------

206

207 // this is the kind of source code that would end up being generated by a

208 // designer corresponding to the information we are setting up via RTTI

209 // in the CreateFrameRTTI function:

210 //

211 // class MyXTIFrame : public wxFrame

212 // {

213 // public:

214 // // construction

215 // MyXTIFrame()

216 // {

217 // Init();

218 // m_button = NULL;

219 // }

220 //

221 // bool Create(wxWindow *parent,

222 // wxWindowID id,

223 // const wxString& title,

224 // const wxPoint& pos = wxDefaultPosition,

225 // const wxSize& size = wxDefaultSize,

226 // long style = wxDEFAULT_FRAME_STYLE,

227 // const wxString& name = wxFrameNameStr)

228 // {

229 // return wxFrame::Create( parent, id, title, pos, size, style, name );

230 // }

231 //

232 // void SetButton( wxButton * button ) { m_button = button; }

233 // wxButton* GetButton() const { return m_button; }

234 //

235 // void ButtonClickHandler( wxEvent & WXUNUSED(event) )

236 // {

237 // wxMessageBox( "Button Clicked ", "Hi!", wxOK );

238 // }

239 //

240 // protected:

241 // wxButton* m_button;

242 //

243 // DECLARE_EVENT_TABLE()

244 // DECLARE_DYNAMIC_CLASS_NO_COPY(MyXTIFrame)

245 // };

246 //

247 // IMPLEMENT_DYNAMIC_CLASS_XTI(MyXTIFrame, MyXTIFrame, "x.h")

248 //

249 // WX_BEGIN_PROPERTIES_TABLE(MyXTIFrame)

250 // WX_PROPERTY( Button, wxButton*, SetButton, GetButton, )

251 // WX_END_PROPERTIES_TABLE()

252 //

253 // WX_BEGIN_HANDLERS_TABLE(MyXTIFrame)

254 // WX_HANDLER( ButtonClickHandler, wxCommandEvent )

255 // WX_END_HANDLERS_TABLE()

256 //

257 // WX_CONSTRUCTOR_5( MyXTIFrame, wxWindow*, Parent, wxWindowID, Id,

258 // wxString, Title, wxPoint, Position, wxSize, Size )

259 //

260 // BEGIN_EVENT_TABLE(MyXTIFrame, wxFrame)

261 // END_EVENT_TABLE()

262

263 // the following class "persists" (i.e. saves) a wxFrame into a wxObjectWriter

264

265 class MyDesignerPersister : public wxObjectWriterCallback

266 {

267 public:

268 MyDesignerPersister( wxDynamicObject * frame)

269 {

270 m_frame = frame;

271 }

272

     virtual bool BeforeWriteDelegate( wxObjectWriter *WXUNUSED(writer),

274 const wxObject *object,

                                     const wxClassInfo* WXUNUSED(classInfo), 

276 const wxPropertyInfo *propInfo,

277 const wxObject *&eventSink,

278 const wxHandlerInfo* &handlerInfo )

279 {

280 // this approach would be used if the handler would not

281 // be connected really in the designer, so we have to supply

282 // the information

         const wxObject* but = wxAnyGetAsObjectPtr( m_frame->GetProperty(wxT("Button")) );

284 if ( object == but &&

              propInfo == wxCLASSINFO( wxButton )->FindPropertyInfo(wxT("OnClick")) )

286 {

287 eventSink = m_frame;

288 handlerInfo = m_frame->GetClassInfo()->

                 FindHandlerInfo(wxT("ButtonClickHandler"));

290 return true;

291 }

292 return false;

293 }

294

295 private:

296 wxDynamicObject *m_frame;

297 };

298

299 // sometimes linkers (at least MSVC and GCC ones) optimize the final EXE

300 // even in debug mode pruning the object files which he "thinks" are useless;

301 // thus the classes defined in those files won't be available in the XTI

302 // table and the program will fail to allocate them.

303 // The following macro implements a simple hack to ensure that a given

304 // class is linked in.

305 //

306 // TODO: in wx/link.h there are already similar macros (also more "optimized":

307 // don't need the creation of fake object) which however require to use

308 // the wxFORCE_LINK_THIS_MODULE() macro inside the source files corresponding

309 // to the class being discarded.

310 //

311 #define wxENSURE_CLASS_IS_LINKED(x) { x test; }

312

313 void RegisterFrameRTTI()

314 {

315 // set up the RTTI info for a class (MyXTIFrame) which

316 // is not defined anywhere in this program

317 wxDynamicClassInfo *dyninfo =

         wx_dynamic_cast( wxDynamicClassInfo *, wxClassInfo::FindClass(wxT("MyXTIFrame")));

319 if ( dyninfo == NULL )

320 {

         dyninfo = new wxDynamicClassInfo(wxT("myxtiframe.h"),

322 wxT("MyXTIFrame"),

323 CLASSINFO(wxFrame) );

324

325 // 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 ) );

329 }

330 }

331

332 wxDynamicObject* CreateFrameRTTI()

333 {

334 int baseID = 100;

335 wxAny Params[10];

336

337 // the class is now part of XTI internal table so that we can

338 // get a pointer to it just searching it like any other class:

339 wxFrame* frame;

     wxClassInfo *info = wxClassInfo::FindClass(wxT("MyXTIFrame"));

341 wxASSERT( info );

342 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());

352

353 #if 1

354 // now build a notebook inside it:

355 wxNotebook* notebook;

     info = wxClassInfo::FindClass("wxNotebook");

357 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 ));

365

366 // button page

367

368 wxPanel* panel;

     info = wxClassInfo::FindClass("wxPanel");

370 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" );

380

381 wxButton* button;

     info = wxClassInfo::FindClass("wxButton");

383 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 ) );

393

394 // other controls page

395

     info = wxClassInfo::FindClass("wxPanel");

397 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" );

407

408 wxControl* control;

     info = wxClassInfo::FindClass("wxCheckBox");

410 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 ));

419

     info = wxClassInfo::FindClass("wxRadioButton");

421 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 ));

430

     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 ));

436

     info = wxClassInfo::FindClass("wxStaticText");

438 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 ));

447

     info = wxClassInfo::FindClass("wxStaticBox");

449 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 ));

458

     info = wxClassInfo::FindClass("wxTextCtrl");

460 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 ));

469

470 // spins and gauges page

471

     info = wxClassInfo::FindClass("wxPanel");

473 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" );

483

484 wxENSURE_CLASS_IS_LINKED(wxSpinButton);

485

     info = wxClassInfo::FindClass("wxSpinButton");

487 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 ));

495

496 wxENSURE_CLASS_IS_LINKED(wxSpinCtrl);

497

     info = wxClassInfo::FindClass("wxSpinCtrl");

499 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 ));

508

509 // MSVC likes to exclude from link wxGauge...

510 wxENSURE_CLASS_IS_LINKED(wxGauge)

511 wxENSURE_CLASS_IS_LINKED(wxCheckBox)

512 wxENSURE_CLASS_IS_LINKED(wxSpinCtrl)

513

     info = wxClassInfo::FindClass("wxGauge");

515

516 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);

526

527 #endif

528 return frameWrapper;

529 }

530

 bool SaveFrameRTTI(const wxString &testFileName, wxDynamicObject *frame)

532 {

533 // setup the XML document

534 wxXmlDocument xml;

     wxXmlNode *root = new wxXmlNode(wxXML_ELEMENT_NODE, 

536 "TestXTI", "This is the content");

537 xml.SetRoot(root);

538

539 // setup the XTI writer and persister

540 wxObjectXmlWriter writer(root);

541 MyDesignerPersister persister(frame);

542

543 // write the given wxObject into the XML document

544 wxStringToAnyHashMap empty;

     writer.WriteObject( frame, frame->GetClassInfo(), &persister, 

                         wxString("myTestFrame"), empty );

547

     return xml.Save(testFileName);

549 }

550

 wxDynamicObject* LoadFrameRTTI(const wxString &fileName)

552 {

553 // load the XML document

554 wxXmlDocument xml;

     if (!xml.Load(fileName))

556 return NULL;

557

     wxXmlNode *root = xml.GetRoot();

     if (root->GetName() != "TestXTI")

560 return NULL;

561

562 // now depersist the wxFrame we saved into it using wxObjectRuntimeReaderCallback

563 wxObjectRuntimeReaderCallback Callbacks;

564 wxObjectXmlReader Reader( root );

     int obj = Reader.ReadObject( wxString("myTestFrame"), &Callbacks );

     return (wxDynamicObject*)Callbacks.GetObject( obj );

567 }

568

 bool GenerateFrameRTTICode(const wxString &inFileName, const wxString &outFileName)

570 {

571 // is loading the streamed out component from xml and writing code that

572 // will create the same component

573

574 wxFFileOutputStream fos( outFileName );

575 wxTextOutputStream tos( fos );

     if (!fos.IsOk())

577 return false;

578

579 wxXmlDocument xml;

     if (!xml.Load(inFileName))

581 return false;

582

     wxXmlNode *root = xml.GetRoot();

     if (root->GetName() != "TestXTI")

585 return false;

586

587 // read the XML file using the wxObjectCodeReaderCallback

588

589 wxString headerincludes;

590 wxString sourcecode;

591 wxObjectCodeReaderCallback Callbacks(headerincludes,sourcecode);

592 wxObjectXmlReader Reader(root);

593

594 // ReadObject will return the ID of the object read??

     Reader.ReadObject( wxString("myTestFrame"), &Callbacks );

596

597 // header preamble

598 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";

600 // add object includes

601 tos.WriteString( headerincludes );

602

     tos << "\n\nvoid test()\n{";

604 tos.WriteString( sourcecode );

605 tos << "}";

606 return true;

607 }

612 // ----------------------------------------------------------------------------

613 // MyFrame event handlers

614 // ----------------------------------------------------------------------------

615

 void MyFrame::OnPersist(wxCommandEvent& WXUNUSED(event))

617 {

618 // first create a frame using XTI calls

619 wxDynamicObject *frame = CreateFrameRTTI();

620 if (!frame)

621 {

         wxLogError(wxT("Cannot create the XTI frame!"));

623 return;

624 }

625

626 // show the frame we're going to save to the user

     wxFrame *trueFrame = wx_dynamic_cast(wxFrame *, frame->GetSuperClassInstance() );

628 trueFrame->Show();

629

630 // 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"), 

633 wxFD_SAVE);

     if (dlg.ShowModal() == wxID_CANCEL)

635 return;

636

637 // then save it to a test XML file

     if (!SaveFrameRTTI(dlg.GetPath(), frame))

639 {

         wxLogError(wxT("Cannot save the XTI frame into '%s'"), dlg.GetPath());

641 return;

642 }

643

644 // now simply delete it

645 delete frame;

646 }

647

 void MyFrame::OnDepersist(wxCommandEvent& WXUNUSED(event))

649 {

650 // 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"), 

653 wxFD_OPEN);

     if (dlg.ShowModal() == wxID_CANCEL)

655 return;

656

     wxObject *frame = LoadFrameRTTI(dlg.GetPath());

658 if (!frame)

659 {

         wxLogError(wxT("Could not depersist the wxFrame from '%s'"), dlg.GetPath());

661 return;

662 }

663

     wxFrame *trueFrame = wx_dynamic_cast(wxFrame*, frame );

665 if ( !trueFrame )

666 {

         wxDynamicObject* dyno = wx_dynamic_cast(wxDynamicObject*, frame );

668 if ( dyno )

             trueFrame = wx_dynamic_cast(wxFrame *, dyno->GetSuperClassInstance() );

670 }

671

672 if ( trueFrame )

673 trueFrame->Show();

674 else

         wxLogError(wxT("Could not show the frame"));

676 }

677

 void MyFrame::OnGenerateCode(wxCommandEvent& WXUNUSED(event))

679 {

680 // 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"), 

683 wxFD_OPEN);

     if (dlg.ShowModal() == wxID_CANCEL)

685 return;

686

687 // 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"), 

690 wxFD_SAVE);

     if (dlg2.ShowModal() == wxID_CANCEL)

692 return;

693

694 // do generate code

     if (!GenerateFrameRTTICode(dlg.GetPath(), dlg2.GetPath()))

696 {

         wxLogError(wxT("Could not generate the code for the frame!"));

698 return;

699 }

700

701 // show the generated code

702 {

         wxFileInputStream f(dlg2.GetPath());

704 wxStringOutputStream str;

705 f.Read(str);

706

         wxDialog dlg(this, wxID_ANY, wxT("Generated code"), 

708 wxDefaultPosition, wxDefaultSize,

709 wxRESIZE_BORDER|wxDEFAULT_DIALOG_STYLE);

         wxPanel *panel = new wxPanel(&dlg);

         wxSizer *sz = new wxBoxSizer(wxVERTICAL);

         sz->Add(new wxTextCtrl(panel, wxID_ANY, str.GetString(), 

713 wxDefaultPosition, wxDefaultSize,

714 wxTE_MULTILINE|wxTE_READONLY|wxTE_DONTWRAP),

                 1, wxGROW|wxALL, 5);

         sz->Add(new wxButton(panel, wxID_OK), 0, wxALIGN_RIGHT|wxALL, 5);

717 panel->SetSizerAndFit(sz);

718 dlg.ShowModal();

719 }

720 }

721

 void MyFrame::OnDumpClasses(wxCommandEvent& WXUNUSED(event))

723 {

724 ClassListDialog dlg(this);

725 dlg.ShowModal();

726 }

727

 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))

729 {

730 // true is to force the frame to close

731 Close(true);

732 }

733

 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))

735 {

     wxMessageBox(wxString::Format(

                     wxT("Welcome to %s!\n")

                     wxT("\n")

739 wxT("This sample demonstrates wxWidgets eXtended RTTI (XTI) system."),

740 wxVERSION_STRING

741 ),

742 wxT("About wxWidgets XTI sample"),

743 wxOK | wxICON_INFORMATION,

744 this);

745 }