git.maemo.org Git - pkg-perl/blob - deb-src/libwx-perl/libwx-perl-0.96/ext/docview/cpp/docview.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        ext/docview/cpp/docview.h
   3 // Purpose:     c++ wrapper for the wx Document/View Framework
   4 // Author:      Simon Flack
   5 // Modified by:
   6 // Created:     28/08/2002
   7 // RCS-ID:      $Id: docview.h 2172 2007-08-17 22:56:36Z mbarbon $
   8 // Copyright:   (c) 2002-2004, 2005-2007 Simon Flack
   9 // Licence:     This program is free software; you can redistribute it and/or
  10 //              modify it under the same terms as Perl itself
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #include <wx/docview.h>
  14 #if wxUSE_MDI_ARCHITECTURE && wxUSE_DOC_VIEW_ARCHITECTURE
  15 #include "wx/docmdi.h"
  16 #endif
  17
  18 #include "cpp/v_cback.h"
  19
  20
  21 // --- Wx::Document ----------------------------------------------------
  22
  23 class wxPliDocument : public wxDocument
  24 {
  25     WXPLI_DECLARE_DYNAMIC_CLASS( wxPliDocument );
  26     WXPLI_DECLARE_V_CBACK();
  27 public:
  28     WXPLI_DEFAULT_CONSTRUCTOR( wxPliDocument, "Wx::Document", true );
  29
  30     DEC_V_CBACK_BOOL__VOID( Close );
  31     DEC_V_CBACK_BOOL__VOID( Save );
  32     DEC_V_CBACK_BOOL__VOID( SaveAs );
  33     DEC_V_CBACK_BOOL__VOID( Revert );
  34
  35     // see helpers.h - wxPliInputStream
  36 #if wxUSE_STD_IOSTREAM
  37     wxSTD ostream& SaveObject( wxSTD ostream& );
  38     wxSTD istream& LoadObject( wxSTD istream& );
  39 #else
  40     wxOutputStream& SaveObject( wxOutputStream& );
  41     wxInputStream& LoadObject( wxInputStream& );
  42 #endif
  43     DEC_V_CBACK_BOOL__WXSTRING( OnSaveDocument );
  44     DEC_V_CBACK_BOOL__WXSTRING( OnOpenDocument );
  45     DEC_V_CBACK_BOOL__VOID( OnNewDocument );
  46     DEC_V_CBACK_BOOL__VOID( OnCloseDocument );
  47
  48     DEC_V_CBACK_BOOL__VOID( OnSaveModified );
  49
  50     bool OnCreate( const wxString&, long );
  51     // ??? OnCreateCommandProcessor/GetCommandProcessor/SetCommandProcessor ???
  52
  53     DEC_V_CBACK_VOID__VOID( OnChangedViewList );
  54     DEC_V_CBACK_BOOL__VOID( DeleteContents );
  55
  56     // ??? Draw() ???
  57
  58     bool IsModified() const;
  59     void  Modify( bool );
  60
  61     bool AddView( wxView* );
  62     bool RemoveView( wxView* );
  63
  64     void UpdateAllViews( wxView* sender=NULL, wxObject* = NULL);
  65     DEC_V_CBACK_VOID__VOID( NotifyClosing );
  66     DEC_V_CBACK_BOOL__VOID( DeleteAllViews );
  67
  68     wxDocManager *GetDocumentManager() const;
  69     wxDocTemplate *GetDocumentTemplate() const;
  70     void SetDocumentTemplate( wxDocTemplate* );
  71
  72 #if WXPERL_W_VERSION_GE( 2, 9, 0 )
  73     DEC_V_CBACK_WXSTRING__VOID_const( GetUserReadableName );
  74 #else
  75     DEC_V_CBACK_BOOL__mWXSTRING_const( GetPrintableName );
  76 #endif
  77
  78     wxWindow *GetDocumentWindow() const;
  79 };
  80
  81
  82 DEF_V_CBACK_BOOL__VOID( wxPliDocument, wxDocument, Close );
  83 DEF_V_CBACK_BOOL__VOID( wxPliDocument, wxDocument, Save );
  84 DEF_V_CBACK_BOOL__VOID( wxPliDocument, wxDocument, SaveAs );
  85 DEF_V_CBACK_BOOL__VOID( wxPliDocument, wxDocument, Revert );
  86
  87 #if wxUSE_STD_IOSTREAM
  88 wxSTD ostream& wxPliDocument::SaveObject( wxSTD ostream& stream )
  89 {
  90     dTHX;
  91     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "SaveObject" ) )
  92     {
  93         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
  94                                            G_DISCARD|G_SCALAR, "o", &stream );
  95     }
  96     return wxDocument::SaveObject( stream );
  97 }
  98
  99 wxSTD istream& wxPliDocument::LoadObject( wxSTD istream& stream )
 100 {
 101     dTHX;
 102     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "LoadObject" ) )
 103     {
 104         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 105                                            G_DISCARD|G_SCALAR, "o", &stream );
 106     }
 107     return wxDocument::LoadObject( stream );
 108 }
 109 #else
 110 wxOutputStream& wxPliDocument::SaveObject( wxOutputStream& stream )
 111 {
 112     dTHX;
 113     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "SaveObject" ) )
 114     {
 115         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 116                                            G_DISCARD|G_SCALAR, "o", &stream );
 117     }
 118     return wxDocument::SaveObject( stream );
 119 }
 120
 121 wxInputStream& wxPliDocument::LoadObject( wxInputStream& stream )
 122 {
 123     dTHX;
 124     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "LoadObject" ) )
 125     {
 126         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 127                                            G_DISCARD|G_SCALAR, "o", &stream );
 128     }
 129     return wxDocument::LoadObject( stream );
 130 }
 131 #endif
 132
 133 DEF_V_CBACK_BOOL__WXSTRING( wxPliDocument, wxDocument, OnSaveDocument );
 134 DEF_V_CBACK_BOOL__WXSTRING( wxPliDocument, wxDocument, OnOpenDocument );
 135 DEF_V_CBACK_BOOL__VOID( wxPliDocument, wxDocument, OnNewDocument );
 136 DEF_V_CBACK_BOOL__VOID( wxPliDocument, wxDocument, OnCloseDocument );
 137 DEF_V_CBACK_BOOL__VOID( wxPliDocument, wxDocument, OnSaveModified );
 138
 139 bool wxPliDocument::OnCreate( const wxString& path, long flags  )
 140 {
 141     dTHX;
 142     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "OnCreate" ) )
 143     {
 144         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 145                                                      G_SCALAR, "Pl",
 146                                                      &path, flags);
 147         bool val = SvTRUE( ret );
 148         SvREFCNT_dec( ret );
 149         return val;
 150     }
 151       return wxDocument::OnCreate( path, flags );
 152 }
 153
 154
 155 DEF_V_CBACK_VOID__VOID( wxPliDocument, wxDocument, OnChangedViewList );
 156 DEF_V_CBACK_BOOL__VOID( wxPliDocument, wxDocument, DeleteContents );
 157 DEF_V_CBACK_BOOL__VOID_const( wxPliDocument, wxDocument, IsModified );
 158
 159 void wxPliDocument::Modify( bool mod )
 160 {
 161     dTHX;
 162     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "Modify" ) )
 163     {
 164         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 165                                            G_DISCARD|G_SCALAR, "b", mod );
 166     }
 167     wxDocument::Modify( mod );
 168 }
 169
 170 bool wxPliDocument::AddView( wxView *view)
 171 {
 172     dTHX;
 173     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "AddView" ) )
 174     {
 175         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 176                                                      G_SCALAR, "O", view );
 177         bool val = SvTRUE( ret );
 178         SvREFCNT_dec( ret );
 179         return val;
 180     }
 181     return wxDocument::AddView( view );
 182 }
 183
 184 bool wxPliDocument::RemoveView( wxView *view )
 185 {
 186     dTHX;
 187     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "RemoveView" ) )
 188     {
 189         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 190                                                      G_SCALAR, "O", view );
 191         bool val = SvTRUE( ret );
 192         SvREFCNT_dec( ret );
 193         return val;
 194     }
 195     return wxDocument::RemoveView( view );
 196 }
 197
 198 void wxPliDocument::UpdateAllViews( wxView *sender, wxObject *hint)
 199 {
 200     dTHX;
 201     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 202                                            "UpdateAllViews" ) )
 203     {
 204         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 205                                            G_DISCARD|G_SCALAR,
 206                                            "OO", sender, hint);
 207     }
 208     wxDocument::UpdateAllViews( sender, hint );
 209 }
 210
 211 DEF_V_CBACK_VOID__VOID( wxPliDocument, wxDocument, NotifyClosing );
 212 DEF_V_CBACK_BOOL__VOID( wxPliDocument, wxDocument, DeleteAllViews );
 213
 214 wxDocManager *wxPliDocument::GetDocumentManager() const
 215 {
 216     dTHX;
 217     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 218                                            "GetDocumentManager" ) )
 219     {
 220         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 221                                                      G_SCALAR, NULL );
 222         wxDocManager* retval =
 223             (wxDocManager*)wxPli_sv_2_object( aTHX_ ret, "Wx::DocManager" );
 224         SvREFCNT_dec( ret );
 225
 226         return retval;
 227     }
 228     return wxDocument::GetDocumentManager();
 229 }
 230
 231 wxDocTemplate *wxPliDocument::GetDocumentTemplate() const
 232 {
 233     dTHX;
 234     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 235                                            "GetDocumentTemplate" ) )
 236     {
 237         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 238                                                      G_SCALAR, NULL );
 239         wxDocTemplate* retval =
 240             (wxDocTemplate*)wxPli_sv_2_object( aTHX_ ret, "Wx::DocTemplate" );
 241         SvREFCNT_dec( ret );
 242
 243         return retval;
 244     }
 245     return wxDocument::GetDocumentTemplate();
 246 }
 247
 248 void wxPliDocument::SetDocumentTemplate( wxDocTemplate *temp )
 249 {
 250     dTHX;
 251     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 252                                            "SetDocumentTemplate" ) )
 253     {
 254         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback, G_SCALAR, "O",
 255                                            temp );
 256     }
 257     wxDocument::SetDocumentTemplate( temp );
 258 }
 259
 260 #if WXPERL_W_VERSION_GE( 2, 9, 0 )
 261 DEF_V_CBACK_WXSTRING__VOID_const( wxPliDocument, wxDocument,
 262                                   GetUserReadableName );
 263 #else
 264 DEF_V_CBACK_BOOL__mWXSTRING_const( wxPliDocument, wxDocument,
 265                                    GetPrintableName );
 266 #endif
 267
 268 wxWindow *wxPliDocument::GetDocumentWindow() const
 269 {
 270     dTHX;
 271     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 272                                            "GetDocumentWindow" ) )
 273     {
 274         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 275                                                      G_SCALAR, NULL );
 276
 277         wxWindow* retval =
 278           (wxWindow*) wxPli_sv_2_object( aTHX_ ret, "Wx::Window" );
 279         SvREFCNT_dec( ret );
 280         return retval;
 281     }
 282     return wxDocument::GetDocumentWindow();
 283 }
 284
 285 WXPLI_IMPLEMENT_DYNAMIC_CLASS( wxPliDocument, wxDocument );
 286
 287
 288 // --- Wx::View -------------------------------------------------
 289
 290
 291 class wxPliView : public wxView
 292 {
 293     WXPLI_DECLARE_DYNAMIC_CLASS( wxPliView );
 294     WXPLI_DECLARE_V_CBACK();
 295 public:
 296     wxPliView( const char* package )
 297        : wxView(),
 298          m_callback( "Wx::View" )
 299     {
 300        m_callback.SetSelf( wxPli_make_object( this, package ), true);
 301     }
 302     ~wxPliView();
 303
 304     void OnActivateView( bool, wxView*, wxView* );
 305     void OnPrint( wxDC*, wxObject* );
 306     void OnUpdate( wxView* sender, wxObject* hint=(wxObject*) NULL );
 307
 308     DEC_V_CBACK_VOID__VOID( OnClosingDocument );
 309     DEC_V_CBACK_VOID__VOID( OnChangeFilename );
 310     bool OnCreate( wxDocument*, long );
 311     bool Close( bool deleteWindow = true );
 312     bool OnClose( bool );
 313
 314     // bool ProcessEvent(wxEvent&);
 315     void Activate( bool );
 316
 317     virtual void OnDraw(wxDC* dc);
 318
 319 #if wxUSE_PRINTING_ARCHITECTURE
 320     wxPrintout* OnCreatePrintout();
 321 #endif
 322 };
 323
 324 wxPliView::~wxPliView() {}
 325
 326 void wxPliView::OnDraw( wxDC* dc )
 327 {
 328 }
 329
 330 void wxPliView::OnActivateView( bool activate, wxView* activeView,
 331                                 wxView* deactiveView)
 332 {
 333     dTHX;
 334     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 335                                            "OnActivateView" ) )
 336     {
 337       wxPliVirtualCallback_CallCallback( aTHX_ &m_callback, G_SCALAR|G_DISCARD,
 338                                          "bOO", activate, activeView,
 339                                          deactiveView);
 340       return;
 341     }
 342   wxView::OnActivateView( activate, activeView, deactiveView);
 343 }
 344
 345
 346 void wxPliView::OnPrint( wxDC* dc, wxObject* info)
 347 {
 348     dTHX;
 349     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "OnPrint" ) )
 350     {
 351       wxPliVirtualCallback_CallCallback( aTHX_ &m_callback, G_SCALAR|G_DISCARD,
 352                                          "OO", dc, info );
 353       return;
 354     }
 355   wxView::OnPrint( dc, info);
 356 }
 357
 358 void wxPliView::OnUpdate( wxView* sender, wxObject* hint )
 359 {
 360     dTHX;
 361     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "OnUpdate" ) )
 362     {
 363       wxPliVirtualCallback_CallCallback( aTHX_ &m_callback, G_SCALAR|G_DISCARD,
 364                                          "OO", sender, hint );
 365       return;
 366     }
 367   wxView::OnUpdate( sender, hint );
 368 }
 369
 370 DEF_V_CBACK_VOID__VOID( wxPliView, wxView, OnClosingDocument );
 371 DEF_V_CBACK_VOID__VOID( wxPliView, wxView, OnChangeFilename );
 372
 373 bool wxPliView::OnCreate( wxDocument* doc, long flags )
 374 {
 375     dTHX;
 376     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "OnCreate" ) )
 377     {
 378       SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 379                                                    G_SCALAR,"Ol", doc, flags );
 380       bool val = SvTRUE( ret );
 381       SvREFCNT_dec( ret );
 382       return val;
 383     }
 384   return wxView::OnCreate( doc, flags );
 385 }
 386
 387 DEF_V_CBACK_BOOL__BOOL( wxPliView, wxView, Close );
 388 DEF_V_CBACK_BOOL__BOOL( wxPliView, wxView, OnClose );
 389
 390 void wxPliView::Activate( bool activate )
 391 {
 392     dTHX;
 393     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "Activate" ) )
 394     {
 395       wxPliVirtualCallback_CallCallback( aTHX_ &m_callback, G_SCALAR|G_DISCARD,
 396                                          "b", activate );
 397       return;
 398     }
 399   wxView::Activate( activate );
 400 }
 401
 402
 403 #if wxUSE_PRINTING_ARCHITECTURE
 404 wxPrintout* wxPliView::OnCreatePrintout()
 405 {
 406     dTHX;
 407     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 408                                            "OnCreatePrintout" ) )
 409     {
 410       SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 411                                                    G_SCALAR, NULL);
 412       wxPrintout* retval =
 413         (wxPrintout*)wxPli_sv_2_object( aTHX_ ret, "Wx::Printout" );
 414       SvREFCNT_dec( ret );
 415       return retval;
 416     }
 417   return wxView::OnCreatePrintout( );
 418 }
 419 #endif
 420
 421 WXPLI_IMPLEMENT_DYNAMIC_CLASS( wxPliView, wxView );
 422
 423
 424
 425
 426 // --- Wx::DocTemplate -------------------------------------------------
 427
 428
 429 class wxPliDocTemplate : public wxDocTemplate
 430 {
 431     WXPLI_DECLARE_DYNAMIC_CLASS( wxPliDocTemplate );
 432     WXPLI_DECLARE_V_CBACK();
 433 public:
 434     wxPliDocTemplate( const char* package, wxDocManager* manager,
 435                       const wxString& descr, const wxString& filter,
 436                       const wxString& dir, const wxString& ext,
 437                       const wxString& docTypeName,
 438                       const wxString& viewTypeName, wxClassInfo* docClassInfo,
 439                       wxClassInfo* viewClassInfo, long flags,
 440                       const wxString& docClassName = wxEmptyString,
 441                       const wxString& viewClassName = wxEmptyString )
 442        : wxDocTemplate( manager, descr, filter, dir, ext, docTypeName,
 443                         viewTypeName, docClassInfo, viewClassInfo, flags ),
 444          m_callback( "Wx::DocTemplate" ),
 445          m_docClassName( docClassName ),
 446          m_viewClassName( viewClassName ),
 447          m_plDocClassInfo( NULL ),
 448          m_plViewClassInfo( NULL )
 449     {
 450         m_hasDocClassInfo = docClassInfo != 0 || !docClassName.empty();
 451         m_hasViewClassInfo = viewClassInfo != 0 || !viewClassName.empty();
 452         m_callback.SetSelf( wxPli_make_object( this, package ), true);
 453         if( !docClassName.empty() )
 454         {
 455 #if wxUSE_EXTENDED_RTTI
 456             m_plDocClassInfo = new wxPliClassInfo( sm_docParents,
 457                                                    docClassName,
 458                                                    sizeof(wxPliDocument),
 459                                                    &fake_constructor, NULL
 460                                                    );
 461 #else
 462             m_plDocClassInfo = new wxClassInfo( docClassName,
 463                                             &wxDocument::ms_classInfo, NULL,
 464                                             sizeof(wxPliDocument),
 465                                             &fake_constructor
 466                                             );
 467 #endif
 468             m_docClassInfo = m_plDocClassInfo;
 469         }
 470         if( !viewClassName.empty() )
 471         {
 472 #if wxUSE_EXTENDED_RTTI
 473             m_plViewClassInfo = new wxPliClassInfo( sm_viewParents,
 474                                                     viewClassName,
 475                                                     sizeof(wxPliView),
 476                                                     &fake_constructor, NULL
 477                                                     );
 478 #else
 479             m_plViewClassInfo = new wxClassInfo( viewClassName,
 480                                              &wxView::ms_classInfo, NULL,
 481                                              sizeof(wxPliView),
 482                                              &fake_constructor
 483                                              );
 484 #endif
 485             m_viewClassInfo = m_plViewClassInfo;
 486         }
 487     }
 488
 489     ~wxPliDocTemplate()
 490     {
 491         delete m_plViewClassInfo;
 492         delete m_plDocClassInfo;
 493     }
 494
 495     wxDocument *CreateDocument( const wxString& path, long flags = 0);
 496     wxView *CreateView( wxDocument*, long );
 497
 498     DEC_V_CBACK_WXSTRING__VOID_const( GetViewName );
 499     DEC_V_CBACK_WXSTRING__VOID_const( GetDocumentName );
 500
 501 private:
 502     static wxString sm_className;
 503     static wxObject* fake_constructor();
 504     static SV* CallConstructor( const wxString& className );
 505 #if wxUSE_EXTENDED_RTTI
 506     static const wxClassInfo* sm_docParents[];
 507     static const wxClassInfo* sm_viewParents[];
 508 #endif
 509 private:
 510     wxString m_docClassName,
 511              m_viewClassName;
 512     wxClassInfo *m_plDocClassInfo,
 513                 *m_plViewClassInfo;
 514     bool m_hasDocClassInfo, m_hasViewClassInfo;
 515
 516     DEC_V_CBACK_BOOL__WXSTRING( FileMatchesTemplate );
 517 };
 518
 519 wxString wxPliDocTemplate::sm_className;
 520 #if wxUSE_EXTENDED_RTTI
 521 const wxClassInfo* wxPliDocTemplate::sm_docParents[] =
 522     { &wxDocument::ms_classInfo, NULL };
 523 const wxClassInfo* wxPliDocTemplate::sm_viewParents[] =
 524     { &wxView::ms_classInfo, NULL };
 525 #endif
 526
 527 wxObject* wxPliDocTemplate::fake_constructor()
 528 {
 529     dTHX;
 530
 531     SV* obj = CallConstructor( sm_className );
 532     wxObject* doc = (wxDocument*)wxPli_sv_2_object( aTHX_ obj, "Wx::Object" );
 533     SvREFCNT_dec( obj );
 534
 535     return doc;
 536 }
 537
 538 SV* wxPliDocTemplate::CallConstructor( const wxString& className )
 539 {
 540     dTHX;
 541     dSP;
 542
 543     ENTER;
 544     SAVETMPS;
 545
 546     char buffer[WXPL_BUF_SIZE];
 547 #if wxUSE_UNICODE
 548     wxConvUTF8.WC2MB( buffer, className, WXPL_BUF_SIZE - 4 );
 549 #else
 550     strcpy( buffer, className.c_str() );
 551 #endif
 552     SV* sv = newSVpv( CHAR_P buffer, 0 );
 553
 554     PUSHMARK(SP);
 555     XPUSHs( sv_2mortal( sv ) );
 556     PUTBACK;
 557
 558     int count = call_method( "new", G_SCALAR );
 559
 560     if( count != 1 )
 561         croak( "Constructor must return exactly 1 value" );
 562
 563     SPAGAIN;
 564     SV* obj = POPs;
 565     SvREFCNT_inc( obj );
 566     PUTBACK;
 567
 568     FREETMPS;
 569     LEAVE;
 570
 571     return obj;
 572 }
 573
 574 wxDocument *wxPliDocTemplate::CreateDocument( const wxString& path,
 575                                               long flags )
 576 {
 577
 578     dTHX;
 579     wxDocument* doc = 0;
 580
 581     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 582                                            "CreateDocument" ) )
 583     {
 584         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 585                                                      G_SCALAR, "Pl", &path,
 586                                                      flags );
 587         doc = (wxDocument*) wxPli_sv_2_object( aTHX_ ret, "Wx::Document" );
 588         SvREFCNT_dec( ret );
 589     }
 590     else
 591     {
 592         sm_className = m_docClassName;
 593         if( m_hasDocClassInfo )
 594             return wxDocTemplate::CreateDocument( path, flags );
 595     }
 596
 597     return doc;
 598 }
 599
 600
 601
 602 wxView *wxPliDocTemplate::CreateView( wxDocument* doc, long flags )
 603 {
 604     dTHX;
 605     wxView* view = 0;
 606
 607     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "CreateView" ) )
 608     {
 609         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 610                                                      G_SCALAR, "Ol", doc,
 611                                                      flags );
 612         view = (wxView*) wxPli_sv_2_object( aTHX_ ret, "Wx::View" );
 613         SvREFCNT_dec( ret );
 614     }
 615     else
 616     {
 617         sm_className = m_viewClassName;
 618         if( m_hasViewClassInfo )
 619             return wxDocTemplate::CreateView( doc, flags );
 620     }
 621
 622     return view;
 623 }
 624
 625 DEF_V_CBACK_WXSTRING__VOID_const( wxPliDocTemplate, wxDocTemplate,
 626                                   GetViewName );
 627 DEF_V_CBACK_WXSTRING__VOID_const( wxPliDocTemplate, wxDocTemplate,
 628                                   GetDocumentName );
 629 DEF_V_CBACK_BOOL__WXSTRING( wxPliDocTemplate, wxDocTemplate,
 630                             FileMatchesTemplate );
 631
 632 WXPLI_IMPLEMENT_DYNAMIC_CLASS( wxPliDocTemplate, wxDocTemplate );
 633
 634
 635
 636
 637
 638
 639 // --- Wx::DocManager -------------------------------------------------
 640
 641
 642 class wxPliDocManager : public wxDocManager
 643 {
 644     WXPLI_DECLARE_DYNAMIC_CLASS( wxPliDocManager );
 645     WXPLI_DECLARE_V_CBACK();
 646 public:
 647     wxPliDocManager(  const char* package, long flags = wxDEFAULT_DOCMAN_FLAGS,
 648                      bool initialize = true)
 649        : wxDocManager(flags, initialize),
 650          m_callback( "Wx::DocManager" )
 651     {
 652        m_callback.SetSelf( wxPli_make_object( this, package ), true);
 653     }
 654     ~wxPliDocManager();
 655
 656     // bool ProcessEvent( wxEvent& );
 657     DEC_V_CBACK_VOID__VOID( OnOpenFileFailure );
 658
 659     wxDocument* CreateDocument( const wxString& path, long flags = 0 );
 660     wxView* CreateView( wxDocument* doc, long flags = 0 );
 661     void DeleteTemplate( wxDocTemplate* temp, long flags = 0 );
 662     bool FlushDoc( wxDocument* );
 663     wxDocTemplate* MatchTemplate( const wxString& );
 664     wxDocTemplate* SelectDocumentPath( wxDocTemplate** templates,
 665                                        int noTemplates, wxString& path,
 666                                        long flags, bool save=false);
 667     wxDocTemplate* SelectDocumentType( wxDocTemplate** templates,
 668                                        int noTemplates, bool sort=false);
 669     wxDocTemplate* SelectViewType( wxDocTemplate** templates, int noTemplates,
 670                                    bool sort=false );
 671     wxDocTemplate* FindTemplateForPath( const wxString& );
 672
 673 #if WXPERL_W_VERSION_GE( 2, 5, 1 )
 674     void ActivateView( wxView*, bool activate = true);
 675 #else
 676     void ActivateView( wxView*, bool activate = true, bool deleting = false);
 677 #endif
 678     // wxView* GetCurrentView() const;
 679
 680 #if WXPERL_W_VERSION_GE( 2, 9, 0 )
 681     DEC_V_CBACK_WXSTRING__VOID( MakeNewDocumentName );
 682 #else
 683     DEC_V_CBACK_BOOL__mWXSTRING( MakeDefaultName );
 684 #endif
 685
 686     wxString MakeFrameTitle( wxDocument* );
 687
 688     wxFileHistory* OnCreateFileHistory();
 689     wxFileHistory* GetFileHistory();
 690
 691     void AddFileToHistory( const wxString& );
 692     void RemoveFileFromHistory( int );
 693 #if WXPERL_W_VERSION_GE( 2, 5, 1 )
 694     size_t GetHistoryFilesCount() const;
 695 #else
 696     int GetNoHistoryFiles() const;
 697 #endif
 698     wxString GetHistoryFile( int ) const;
 699     void FileHistoryUseMenu( wxMenu* );
 700     void FileHistoryRemoveMenu( wxMenu* );
 701 #if wxUSE_CONFIG
 702     // FileHistoryLoad()/Save()
 703 #endif
 704
 705     void FileHistoryAddFilesToMenu();
 706     void FileHistoryAddFilesToMenu( wxMenu* );
 707
 708 };
 709
 710 wxPliDocManager::~wxPliDocManager() {}
 711
 712 wxDocument* wxPliDocManager::CreateDocument( const wxString& path, long flags )
 713 {
 714     dTHX;
 715     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 716                                            "CreateDocument" ) )
 717     {
 718         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 719                                            G_SCALAR, "Pl", &path, flags );
 720         wxDocument* retval =
 721             (wxDocument*)wxPli_sv_2_object( aTHX_ ret, "Wx::Document" );
 722         SvREFCNT_dec( ret );
 723         return retval;
 724     }
 725     return wxDocManager::CreateDocument( path, flags );
 726 }
 727
 728
 729 wxView* wxPliDocManager::CreateView( wxDocument* doc, long flags )
 730 {
 731     dTHX;
 732     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "CreateView" ) )
 733     {
 734         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 735                                                      G_SCALAR, "Ol", doc,
 736                                                      flags );
 737         wxView* retval =
 738             (wxView*)wxPli_sv_2_object( aTHX_ ret, "Wx::View" );
 739         SvREFCNT_dec( ret );
 740         return retval;
 741     }
 742     return wxDocManager::CreateView( doc, flags );
 743 }
 744
 745
 746
 747 void wxPliDocManager::DeleteTemplate( wxDocTemplate* temp, long flags )
 748 {
 749     dTHX;
 750     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 751                                            "DeleteTemplate" ) )
 752     {
 753         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 754                                            G_SCALAR|G_DISCARD, "Ol", &temp,
 755                                            flags );
 756                 return;
 757     }
 758     wxDocManager::DeleteTemplate( temp, flags );
 759 }
 760
 761 bool wxPliDocManager::FlushDoc( wxDocument* doc )
 762 {
 763     dTHX;
 764     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "FlushDoc" ) )
 765     {
 766       SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 767                                                    G_SCALAR, "O", doc );
 768       bool val = SvTRUE( ret );
 769       SvREFCNT_dec( ret );
 770       return val;
 771     }
 772     return wxDocManager::FlushDoc( doc );
 773 }
 774
 775
 776 wxDocTemplate* wxPliDocManager::MatchTemplate( const wxString& path )
 777 {
 778     dTHX;
 779     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 780                                            "MatchTemplate" ) )
 781     {
 782       SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 783                                                    G_SCALAR, "P", &path );
 784       wxDocTemplate* retval =
 785         (wxDocTemplate*)wxPli_sv_2_object( aTHX_ ret, "Wx::DocTemplate" );
 786       SvREFCNT_dec( ret );
 787       return retval;
 788     }
 789   return wxDocManager::MatchTemplate(path);
 790 }
 791
 792 wxDocTemplate* wxPliDocManager::SelectDocumentPath( wxDocTemplate** templates,
 793                                                     int noTemplates,
 794                                                     wxString& path,
 795                                                     long flags, bool save)
 796 {
 797     dTHX;
 798     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 799                                            "SelectDocumentPath" ) )
 800     {
 801         dSP;
 802
 803         ENTER;
 804         SAVETMPS;
 805
 806         // Create a perl arrayref from the list of wxDocTemplates
 807         int i;
 808         AV* arrTemplates = newAV();
 809         for (i = 0; i < noTemplates ; i++)
 810         {
 811             SV* svval = wxPli_object_2_sv( aTHX_ sv_newmortal(),
 812                                            templates[i] );
 813             av_store( arrTemplates, i, svval );
 814             SvREFCNT_inc( svval );
 815         }
 816         SV* template_aref = sv_2mortal( newRV_noinc( (SV*)arrTemplates  ) );
 817
 818         PUSHMARK( SP );
 819         wxPli_push_arguments( aTHX_ &SP, "sSiPlb",
 820                               m_callback.GetSelf(), template_aref,
 821                               noTemplates, &path, flags, save );
 822         PUTBACK;
 823
 824         SV* method = sv_2mortal( newRV_inc( (SV*) m_callback.GetMethod() ) );
 825         int items = call_sv( method, G_ARRAY );
 826
 827         SPAGAIN;
 828
 829         SV* tmp;
 830         if( items == 2 )
 831         {
 832             tmp = POPs;
 833             WXSTRING_INPUT( path, wxString, tmp );  // Set the selected path
 834         }
 835         else if( items == 1 )
 836         {
 837             // valid if user alter the path
 838         }
 839         else
 840         {
 841             croak( "wxPliDocManager::SelectDocumentPath() expected 1"
 842                    " or 2 values, got %i", items );
 843         }
 844
 845         tmp = POPs;
 846         wxDocTemplate* retval =
 847             (wxDocTemplate*)wxPli_sv_2_object( aTHX_ tmp, "Wx::DocTemplate" );
 848
 849         PUTBACK;
 850
 851         FREETMPS;
 852         LEAVE;
 853
 854         return retval; //return the doctemplate
 855     }
 856
 857     return wxDocManager::SelectDocumentPath( templates, noTemplates,
 858                                              path, save );
 859 }
 860
 861
 862 wxDocTemplate* wxPliDocManager::SelectDocumentType( wxDocTemplate** templates,
 863                                                     int noTemplate,
 864                                                     bool sort)
 865 {
 866     dTHX;
 867     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 868                                            "SelectDocumentType" ) )
 869     {
 870       SV *ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 871                                                    G_SCALAR, "Oib", templates,
 872                                                    noTemplate, sort );
 873       wxDocTemplate* retval =
 874         (wxDocTemplate*)wxPli_sv_2_object( aTHX_ ret, "Wx::DocTemplate" );
 875       SvREFCNT_dec( ret );
 876       return retval;
 877     }
 878
 879     return wxDocManager::SelectDocumentType(templates, noTemplate, sort);
 880 }
 881
 882 wxDocTemplate* wxPliDocManager::SelectViewType( wxDocTemplate** templates,
 883                                                 int noTemplate,
 884                                                 bool sort )
 885 {
 886     dTHX;
 887     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 888                                            "SelectViewType" ) )
 889     {
 890       SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 891                                                    G_SCALAR, "Oib", templates,
 892                                                    noTemplate, sort );
 893       wxDocTemplate* retval =
 894         (wxDocTemplate*)wxPli_sv_2_object( aTHX_ ret, "Wx::DocTemplate" );
 895       SvREFCNT_dec( ret );
 896       return retval;
 897     }
 898
 899     return wxDocManager::SelectViewType(templates, noTemplate, sort);
 900 }
 901
 902
 903 wxDocTemplate* wxPliDocManager::FindTemplateForPath( const wxString& path )
 904 {
 905     dTHX;
 906     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 907                                            "FindTemplateForPath" ) )
 908     {
 909       SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 910                                                    G_SCALAR,  "P", &path );
 911       wxDocTemplate* retval =
 912         (wxDocTemplate*)wxPli_sv_2_object( aTHX_ ret, "Wx::DocTemplate" );
 913       SvREFCNT_dec( ret );
 914       return retval;
 915     }
 916   return wxDocManager::FindTemplateForPath( path );
 917 }
 918
 919 #if WXPERL_W_VERSION_GE( 2, 5, 1 )
 920 void wxPliDocManager::ActivateView( wxView* view, bool activate)
 921 {
 922     dTHX;
 923     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 924                                            "ActivateView" ) )
 925     {
 926       wxPliVirtualCallback_CallCallback( aTHX_ &m_callback, G_SCALAR|G_DISCARD,
 927                                          "Ob", view, activate );
 928       return;
 929     }
 930   wxDocManager::ActivateView( view, activate );
 931 }
 932 #else
 933 void wxPliDocManager::ActivateView( wxView* view, bool activate, bool deleting)
 934 {
 935     dTHX;
 936     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 937                                            "ActivateView" ) )
 938     {
 939       wxPliVirtualCallback_CallCallback( aTHX_ &m_callback, G_SCALAR|G_DISCARD,
 940                                          "Obb", view, activate, deleting );
 941       return;
 942     }
 943   wxDocManager::ActivateView( view, activate, deleting );
 944 }
 945 #endif
 946
 947 #if WXPERL_W_VERSION_GE( 2, 9, 0 )
 948 DEF_V_CBACK_WXSTRING__VOID( wxPliDocManager, wxDocManager,
 949                             MakeNewDocumentName );
 950 #else
 951 DEF_V_CBACK_BOOL__mWXSTRING( wxPliDocManager, wxDocManager, MakeDefaultName );
 952 #endif
 953
 954 wxString wxPliDocManager::MakeFrameTitle( wxDocument* doc )
 955 {
 956     dTHX;
 957     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 958                                            "MakeFrameTitle" ) )
 959     {
 960       SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 961                                                    G_SCALAR, "O", doc );
 962       wxString retval;
 963       WXSTRING_INPUT( retval, wxString, ret );
 964       SvREFCNT_dec( ret );
 965       return retval;
 966     }
 967   return wxDocManager::MakeFrameTitle( doc );
 968 }
 969
 970 DEF_V_CBACK_VOID__VOID( wxPliDocManager, wxDocManager, OnOpenFileFailure );
 971
 972 wxFileHistory* wxPliDocManager::OnCreateFileHistory()
 973 {
 974     dTHX;
 975     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 976                                            "OnCreateFileHistory" ) )
 977     {
 978       SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 979                                                    G_SCALAR|G_NOARGS, NULL );
 980       wxFileHistory* retval =
 981         (wxFileHistory*)wxPli_sv_2_object( aTHX_ ret, "Wx::FileHistory" );
 982       SvREFCNT_dec( ret );
 983       return retval;
 984     }
 985   return wxDocManager::OnCreateFileHistory( );
 986 }
 987 wxFileHistory* wxPliDocManager::GetFileHistory()
 988 {
 989     dTHX;
 990     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
 991                                            "GetFileHistory" ) )
 992     {
 993       SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
 994                                                    G_SCALAR|G_NOARGS, NULL );
 995       wxFileHistory* retval =
 996         (wxFileHistory*)wxPli_sv_2_object( aTHX_ ret, "Wx::FileHistory" );
 997       SvREFCNT_dec( ret );
 998       return retval;
 999     }
1000   return wxDocManager::GetFileHistory( );
1001 }
1002
1003 void wxPliDocManager::AddFileToHistory( const wxString& file )
1004 {
1005     dTHX;
1006         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1007                                                "AddFileToHistory" ) )
1008     {
1009         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1010                                            G_SCALAR, "P", &file);
1011         return;
1012     }
1013     wxDocManager::AddFileToHistory( file );
1014 }
1015
1016 void wxPliDocManager::RemoveFileFromHistory( int i )
1017 {
1018     dTHX;
1019         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1020                                                "RemoveFileFromHistory" ) )
1021     {
1022         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1023                                            G_SCALAR|G_DISCARD, "i", i);
1024         return;
1025     }
1026     wxDocManager::RemoveFileFromHistory( i );
1027 }
1028
1029 #if WXPERL_W_VERSION_GE( 2, 5, 1 )
1030 size_t wxPliDocManager::GetHistoryFilesCount() const
1031 #else
1032 int wxPliDocManager::GetNoHistoryFiles() const
1033 #endif
1034 {
1035     dTHX;
1036         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1037 #if WXPERL_W_VERSION_GE( 2, 5, 1 )
1038                                                "GetHistoryFilesCount" ) )
1039 #else
1040                                                "GetNoHistoryFiles" ) )
1041 #endif
1042     {
1043         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1044                                                      G_SCALAR|G_NOARGS, NULL);
1045 #if WXPERL_W_VERSION_GE( 2, 5, 1 )
1046         int retval = (int)SvIV( ret );
1047 #else
1048         size_t retval = (size_t)SvIV( ret );
1049 #endif
1050         SvREFCNT_dec( ret );
1051         return retval;
1052     }
1053 #if WXPERL_W_VERSION_GE( 2, 5, 1 )
1054     return wxDocManager::GetHistoryFilesCount();
1055 #else
1056     return wxDocManager::GetNoHistoryFiles();
1057 #endif
1058 }
1059
1060 wxString wxPliDocManager::GetHistoryFile( int i ) const
1061 {
1062     dTHX;
1063         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1064                                                "GetHistoryFile" ) )
1065     {
1066         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1067                                                      G_SCALAR, "i", i);
1068         wxString retval;
1069         WXSTRING_INPUT( retval, wxString, ret );
1070         SvREFCNT_dec( ret );
1071         return retval;
1072     }
1073     return wxDocManager::GetHistoryFile( i );
1074 }
1075
1076 void wxPliDocManager::FileHistoryUseMenu( wxMenu* menu )
1077 {
1078     dTHX;
1079         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1080                                                "FileHistoryUseMenu" ) )
1081     {
1082         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1083                                            G_SCALAR|G_DISCARD, "O", menu);
1084         return;
1085     }
1086     wxDocManager::FileHistoryUseMenu( menu );
1087 }
1088
1089 void wxPliDocManager::FileHistoryRemoveMenu( wxMenu* menu )
1090 {
1091     dTHX;
1092         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1093                                                "FileHistoryRemoveMenu" ) )
1094     {
1095         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1096                                            G_SCALAR|G_DISCARD, "O", menu);
1097         return;
1098     }
1099     wxDocManager::FileHistoryRemoveMenu( menu );
1100 }
1101
1102 #if wxUSE_CONFIG
1103     // FileHistoryLoad()/Save()
1104 #endif
1105
1106 void wxPliDocManager::FileHistoryAddFilesToMenu()
1107 {
1108     dTHX;
1109         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1110                                                "FileHistoryAddFilesToMenu" ) )
1111     {
1112         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1113                                            G_SCALAR|G_NOARGS|G_DISCARD, NULL);
1114         return;
1115     }
1116     wxDocManager::FileHistoryAddFilesToMenu( );
1117 }
1118
1119 void wxPliDocManager::FileHistoryAddFilesToMenu( wxMenu* menu )
1120 {
1121     dTHX;
1122         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1123                                                "FileHistoryAddFilesToMenu" ) )
1124     {
1125         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1126                                            G_SCALAR|G_DISCARD, "O", menu);
1127         return;
1128     }
1129     wxDocManager::FileHistoryAddFilesToMenu( menu );
1130 }
1131
1132
1133
1134 WXPLI_IMPLEMENT_DYNAMIC_CLASS( wxPliDocManager, wxDocManager );
1135
1136
1137
1138
1139
1140 // --- Wx::DocChildFrame -------------------------------------------------
1141
1142
1143 class wxPliDocChildFrame : public wxDocChildFrame
1144 {
1145     WXPLI_DECLARE_DYNAMIC_CLASS( wxPliDocChildFrame );
1146     WXPLI_DECLARE_V_CBACK();
1147 public:
1148     wxPliDocChildFrame(const char* package, wxDocument* doc, wxView* view,
1149       wxFrame* parent, wxWindowID id, const wxString& title, const wxPoint&
1150       pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
1151       long style = wxDEFAULT_FRAME_STYLE, const wxString& name = wxFrameNameStr)
1152        : wxDocChildFrame(doc, view, parent, id, title, pos, size, style, name),
1153          m_callback( "Wx::DocChildFrame" )
1154     {
1155        m_callback.SetSelf( wxPli_make_object( this, package ), true);
1156     }
1157     ~wxPliDocChildFrame();
1158
1159 };
1160
1161 wxPliDocChildFrame::~wxPliDocChildFrame() {}
1162
1163 WXPLI_IMPLEMENT_DYNAMIC_CLASS( wxPliDocChildFrame, wxDocChildFrame );
1164
1165
1166
1167
1168
1169 // --- Wx::DocParentFrame -------------------------------------------------
1170
1171
1172 class wxPliDocParentFrame : public wxDocParentFrame
1173 {
1174     WXPLI_DECLARE_DYNAMIC_CLASS( wxPliDocParentFrame );
1175     WXPLI_DECLARE_V_CBACK();
1176 public:
1177     wxPliDocParentFrame(const char* package, wxDocManager* manager,
1178       wxFrame *parent, wxWindowID id, const wxString& title,
1179       const wxPoint& pos = wxDefaultPosition,
1180       const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE,
1181       const wxString& name = wxFrameNameStr)
1182        : wxDocParentFrame(manager, parent, id, title, pos, size, style, name),
1183          m_callback( "Wx::DocParentFrame" )
1184     {
1185        m_callback.SetSelf( wxPli_make_object( this, package ), true);
1186     }
1187     ~wxPliDocParentFrame();
1188
1189
1190 };
1191
1192 wxPliDocParentFrame::~wxPliDocParentFrame() {}
1193
1194 WXPLI_IMPLEMENT_DYNAMIC_CLASS( wxPliDocParentFrame, wxDocParentFrame );
1195
1196
1197
1198
1199 // --- Wx::DocMDIChildFrame -------------------------------------------------
1200
1201 #if wxUSE_MDI_ARCHITECTURE && wxUSE_DOC_VIEW_ARCHITECTURE
1202
1203 class wxPliDocMDIChildFrame : public wxDocMDIChildFrame
1204 {
1205     WXPLI_DECLARE_DYNAMIC_CLASS( wxPliDocMDIChildFrame );
1206     WXPLI_DECLARE_V_CBACK();
1207 public:
1208     wxPliDocMDIChildFrame(const char* package, wxDocument* doc, wxView* view,
1209                          wxMDIParentFrame* frame, wxWindowID id,
1210                           const wxString& title, const wxPoint&
1211                           pos = wxDefaultPosition,
1212                           const wxSize& size = wxDefaultSize,
1213                           long style = wxDEFAULT_FRAME_STYLE,
1214                           const wxString& name = wxFrameNameStr)
1215        : wxDocMDIChildFrame(doc, view, frame, id, title, pos,
1216                             size, style, name),
1217          m_callback( "Wx::DocMDIChildFrame" )
1218     {
1219        m_callback.SetSelf( wxPli_make_object( this, package ), true);
1220     }
1221     ~wxPliDocMDIChildFrame();
1222
1223 };
1224
1225 wxPliDocMDIChildFrame::~wxPliDocMDIChildFrame() {}
1226
1227 WXPLI_IMPLEMENT_DYNAMIC_CLASS( wxPliDocMDIChildFrame, wxDocMDIChildFrame );
1228
1229
1230
1231
1232
1233 // --- Wx::DocMDIParentFrame -------------------------------------------------
1234
1235
1236 class wxPliDocMDIParentFrame : public wxDocMDIParentFrame
1237 {
1238     WXPLI_DECLARE_DYNAMIC_CLASS( wxPliDocMDIParentFrame );
1239
1240     WXPLI_DECLARE_V_CBACK();
1241 public:
1242     wxPliDocMDIParentFrame(const char* package, wxDocManager* manager,
1243       wxFrame *parent, wxWindowID id, const wxString& title,
1244       const wxPoint& pos = wxDefaultPosition,
1245       const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE,
1246       const wxString& name = wxFrameNameStr)
1247        : wxDocMDIParentFrame(manager, parent, id, title, pos, size,
1248                              style, name),
1249          m_callback( "Wx::DocMDIParentFrame" )
1250     {
1251        m_callback.SetSelf( wxPli_make_object( this, package ), true);
1252     }
1253     ~wxPliDocMDIParentFrame();
1254
1255 };
1256
1257 wxPliDocMDIParentFrame::~wxPliDocMDIParentFrame() {}
1258
1259
1260 WXPLI_IMPLEMENT_DYNAMIC_CLASS( wxPliDocMDIParentFrame, wxDocMDIParentFrame );
1261
1262 #endif
1263
1264
1265
1266 // --- Wx::FileHistory -------------------------------------------------
1267
1268
1269 class wxPliFileHistory : public wxFileHistory
1270 {
1271     WXPLI_DECLARE_DYNAMIC_CLASS( wxPliFileHistory );
1272     WXPLI_DECLARE_V_CBACK();
1273 public:
1274     wxPliFileHistory(const char* package, int maxfiles = 9)
1275        : wxFileHistory( maxfiles ),
1276          m_callback( "Wx::FileHistory" )
1277     {
1278        m_callback.SetSelf( wxPli_make_object( this, package ), true);
1279     }
1280     ~wxPliFileHistory();
1281
1282     void AddFileToHistory( const wxString& );
1283     void RemoveFileFromHistory( int );
1284     int GetMaxFiles() const;
1285
1286     void UseMenu( wxMenu* );
1287     void RemoveMenu( wxMenu* );
1288
1289 #if wxUSE_CONFIG
1290     void Load( wxConfigBase& );
1291     void Save( wxConfigBase& );
1292 #endif
1293
1294     void AddFilesToMenu();
1295     void AddFilesToMenu( wxMenu* );
1296
1297     wxString GetHistoryFile( int ) const;
1298
1299 #if WXPERL_W_VERSION_GE( 2, 5, 1 )
1300     size_t GetCount() const;
1301 #else
1302     int GetCount() const;
1303 #endif
1304
1305     wxList& GetMenus() const;
1306
1307 };
1308
1309 wxPliFileHistory::~wxPliFileHistory() {}
1310
1311 void wxPliFileHistory::AddFileToHistory( const wxString& file )
1312 {
1313     dTHX;
1314     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1315                                            "AddFileToHistory" ) )
1316     {
1317         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1318                                            G_SCALAR|G_DISCARD, "P", &file );
1319         return;
1320     }
1321     wxFileHistory::AddFileToHistory( file );
1322 }
1323
1324
1325 void wxPliFileHistory::RemoveFileFromHistory( int i )
1326 {
1327     dTHX;
1328     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1329                                            "RemoveFileFromHistory" ) )
1330     {
1331         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1332                                            G_SCALAR|G_DISCARD, "i", i );
1333         return;
1334     }
1335     wxFileHistory::RemoveFileFromHistory( i );
1336 }
1337
1338 int wxPliFileHistory::GetMaxFiles() const
1339 {
1340     dTHX;
1341     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "GetMaxFiles" ) )
1342     {
1343         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1344                                                      G_SCALAR, NULL);
1345         int retval = (int)SvIV( ret );
1346         SvREFCNT_dec( ret );
1347         return retval;
1348     }
1349     return wxFileHistory::GetMaxFiles();
1350 }
1351
1352 void wxPliFileHistory::UseMenu( wxMenu* menu )
1353 {
1354     dTHX;
1355     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "UseMenu" ) )
1356     {
1357         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1358                                            G_SCALAR|G_DISCARD, "O", menu );
1359         return;
1360     }
1361     wxFileHistory:UseMenu( menu );
1362 }
1363
1364 void wxPliFileHistory::RemoveMenu( wxMenu* menu )
1365 {
1366     dTHX;
1367     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "RemoveMenu" ) )
1368     {
1369         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1370                                            G_SCALAR|G_DISCARD, "O", menu );
1371         return;
1372     }
1373     wxFileHistory::UseMenu( menu );
1374 }
1375
1376 #if wxUSE_CONFIG
1377 void wxPliFileHistory::Load( wxConfigBase& config )
1378 {
1379     dTHX;
1380     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "Load" ) )
1381     {
1382         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1383                                            G_SCALAR|G_DISCARD, "o", &config,
1384                                            "Wx::ConfigBase");
1385         return;
1386     }
1387     wxFileHistory::Load( config );
1388 }
1389 void wxPliFileHistory::Save( wxConfigBase& config )
1390 {
1391     dTHX;
1392     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "Save" ) )
1393     {
1394         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1395                                            G_SCALAR|G_DISCARD, "o", &config,
1396                                            "Wx::ConfigBase" );
1397         return;
1398     }
1399     wxFileHistory::Save( config );
1400 }
1401 #endif
1402
1403 void wxPliFileHistory::AddFilesToMenu()
1404 {
1405     dTHX;
1406     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1407                                            "AddFilesToMenu" ) )
1408     {
1409         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1410                                            G_SCALAR|G_DISCARD|G_NOARGS, NULL );
1411         return;
1412     }
1413     wxFileHistory::AddFilesToMenu();
1414 }
1415
1416 void wxPliFileHistory::AddFilesToMenu( wxMenu* menu )
1417 {
1418     dTHX;
1419     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1420                                            "AddFilesToMenu" ) )
1421     {
1422         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1423                                            G_SCALAR|G_DISCARD, "O", menu );
1424         return;
1425     }
1426     wxFileHistory::AddFilesToMenu( menu );
1427 }
1428
1429 wxString wxPliFileHistory::GetHistoryFile( int i ) const
1430 {
1431     dTHX;
1432     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,
1433                                            "GetHistoryFile" ) )
1434     {
1435         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1436                                                      G_SCALAR, "i", i );
1437         wxString retval;
1438         WXSTRING_INPUT( retval, wxString, ret );
1439         SvREFCNT_dec( ret );
1440         return retval;
1441     }
1442     return wxFileHistory::GetHistoryFile( i );
1443 }
1444
1445 #if WXPERL_W_VERSION_GE( 2, 5, 1 )
1446 size_t wxPliFileHistory::GetCount() const
1447 #else
1448 int wxPliFileHistory::GetCount() const
1449 #endif
1450 {
1451     dTHX;
1452     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, "GetCount" ) )
1453     {
1454         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,
1455                                                      G_SCALAR|G_NOARGS, NULL );
1456 #if WXPERL_W_VERSION_GE( 2, 5, 1 )
1457         int retval = (int)SvIV( ret );
1458 #else
1459         size_t retval = (size_t)SvIV( ret );
1460 #endif
1461         SvREFCNT_dec( ret );
1462         return retval;
1463     }
1464     return wxFileHistory::GetCount();
1465 }
1466
1467
1468 WXPLI_IMPLEMENT_DYNAMIC_CLASS( wxPliFileHistory, wxFileHistory );