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

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        cpp/v_cback.h
   3 // Purpose:     callback helper class for virtual functions
   4 // Author:      Mattia Barbon
   5 // Modified by:
   6 // Created:     29/10/2000
   7 // RCS-ID:      $Id: v_cback.h 2533 2009-03-08 19:03:35Z mbarbon $
   8 // Copyright:   (c) 2000-2007, 2009 Mattia Barbon
   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 #ifndef _WXPERL_V_CBACK_H
  14 #define _WXPERL_V_CBACK_H
  15
  16 #include <stddef.h>
  17
  18 class wxAutoSV
  19 {
  20 public:
  21     wxAutoSV( pTHX_ SV* sv )
  22         : m_sv( sv )
  23 #ifdef MULTIPLICITY
  24         , vTHX( aTHX )
  25 #endif
  26     { }
  27     ~wxAutoSV() { SvREFCNT_dec( m_sv ); }
  28
  29     operator SV*() { return m_sv; }
  30     operator const SV*() const { return m_sv; }
  31     operator bool() const { return m_sv != NULL; }
  32     bool operator !() const { return m_sv == NULL; }
  33     SV* operator->() { return m_sv; }
  34     const SV* operator->() const { return m_sv; }
  35 private:
  36     SV* m_sv;
  37 #ifdef MULTIPLICITY
  38     #undef register
  39     #define register
  40     pTHXx;
  41     #undef register
  42 #endif
  43 };
  44
  45 #define wxPliFCback wxPliVirtualCallback_FindCallback
  46 #define wxPliCCback wxPliVirtualCallback_CallCallback
  47
  48 class wxPliVirtualCallback : public wxPliSelfRef
  49 {
  50 public:
  51     wxPliVirtualCallback( const char* package );
  52
  53     // these aren't really const functions, but we will need
  54     // to declare m_method mutable...
  55     bool FindCallback( pTHX_ const char* name ) const;
  56     SV* CallCallback( pTHX_ I32 flags, const char* argtypes,
  57                       va_list& arglist ) const;
  58     CV* GetMethod() const { return m_method; }
  59
  60     bool IsOk() const { return GetSelf() && m_package; }
  61 public:
  62     const char* m_package;
  63     HV* m_stash;
  64     CV* m_method;
  65 };
  66
  67 inline wxPliVirtualCallback::wxPliVirtualCallback( const char* package )
  68 {
  69     m_package = package;
  70     m_self = 0;
  71     m_stash = 0;
  72 }
  73
  74 // declare/define callbacks for commonly used signatures
  75
  76 #define wxPli_NOCONST
  77 #define wxPli_CONST const
  78 #define wxPli_VOID
  79
  80 #define DEC_V_CBACK_BOOL__WXDRAGRESULT( METHOD ) \
  81   bool METHOD( wxDragResult )
  82
  83 #define DEF_V_CBACK_BOOL__WXDRAGRESULT( CLASS, BASE, METHOD ) \
  84   bool CLASS::METHOD( wxDragResult p1 )                                       \
  85   {                                                                           \
  86     dTHX;                                                                     \
  87     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) )     \
  88     {                                                                         \
  89         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,       \
  90                                                      G_SCALAR,                \
  91                                "i", p1 );                                     \
  92         bool val = SvTRUE( ret );                                             \
  93         SvREFCNT_dec( ret );                                                  \
  94         return val;                                                           \
  95     } else                                                                    \
  96         return BASE::METHOD( p1 );                                            \
  97   }
  98
  99 #define DEC_V_CBACK_WXDRAGRESULT__WXCOORD_WXCOORD_WXDRAGRESULT( METHOD ) \
 100   wxDragResult METHOD( wxCoord, wxCoord, wxDragResult )
 101
 102 #define DEF_V_CBACK_WXDRAGRESULT__WXCOORD_WXCOORD_WXDRAGRESULT( CLASS, BASE, METHOD ) \
 103   wxDragResult CLASS::METHOD( wxCoord p1, wxCoord p2, wxDragResult p3 )       \
 104   {                                                                           \
 105     dTHX;                                                                     \
 106     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) )     \
 107     {                                                                         \
 108         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,       \
 109                                                      G_SCALAR,                \
 110                                                      "lli", p1, p2, p3 );     \
 111         wxDragResult val = (wxDragResult)SvIV( ret );                         \
 112         SvREFCNT_dec( ret );                                                  \
 113         return val;                                                           \
 114     } else                                                                    \
 115         return BASE::METHOD( p1, p2, p3 );                                    \
 116   }
 117
 118 #define DEF_V_CBACK_WXDRAGRESULT__WXCOORD_WXCOORD_WXDRAGRESULT_pure( CLASS, BASE, METHOD ) \
 119   wxDragResult CLASS::METHOD( wxCoord p1, wxCoord p2,                         \
 120                               wxDragResult p3 )                               \
 121   {                                                                           \
 122     dTHX;                                                                     \
 123     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) )     \
 124     {                                                                         \
 125         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,       \
 126                                                      G_SCALAR,                \
 127                                                      "lli", p1, p2, p3 );     \
 128         wxDragResult val = (wxDragResult)SvIV( ret );                         \
 129         SvREFCNT_dec( ret );                                                  \
 130         return val;                                                           \
 131     } else                                                                    \
 132         return wxDragNone;                                                    \
 133   }
 134
 135 #define DEC_V_CBACK_BOOL__WXCOORD_WXCOORD( METHOD ) \
 136   bool METHOD( wxCoord, wxCoord )
 137
 138 #define DEF_V_CBACK_BOOL__WXCOORD_WXCOORD( CLASS, BASE, METHOD ) \
 139   bool CLASS::METHOD( wxCoord p1, wxCoord p2 )                                \
 140   {                                                                           \
 141     dTHX;                                                                     \
 142     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) )     \
 143     {                                                                         \
 144         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,       \
 145                                                      G_SCALAR,                \
 146                                                      "ll", p1, p2 );          \
 147         bool val = SvTRUE( ret );                                             \
 148         SvREFCNT_dec( ret );                                                  \
 149         return val;                                                           \
 150     } else                                                                    \
 151         return BASE::METHOD( p1, p2 );                                        \
 152   }
 153
 154 #define DEC_V_CBACK_BOOL__WXCOORD_WXCOORD_WXSTRING( METHOD ) \
 155   bool METHOD( wxCoord, wxCoord, const wxString& )
 156
 157 #define DEF_V_CBACK_BOOL__WXCOORD_WXCOORD_WXSTRING_pure( CLASS, BASE, METHOD ) \
 158   bool CLASS::METHOD( wxCoord p1, wxCoord p2, const wxString& p3 )\
 159   {                                                                           \
 160     dTHX;                                                                     \
 161     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) )     \
 162     {                                                                         \
 163         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,       \
 164                                                      G_SCALAR,                \
 165                                                      "llP", p1, p2, &p3 );    \
 166         bool val = SvTRUE( ret );                                             \
 167         SvREFCNT_dec( ret );                                                  \
 168         return val;                                                           \
 169     } else                                                                    \
 170         return false;                                                         \
 171   }
 172
 173 #define DEC_V_CBACK_BOOL__WXCOORD_WXCOORD_WXARRAYSTRING( METHOD ) \
 174   bool METHOD( wxCoord, wxCoord, const wxArrayString& )
 175
 176 #define DEF_V_CBACK_BOOL__WXCOORD_WXCOORD_WXARRAYSTRING_pure( CLASS, BASE, METHOD )\
 177   bool CLASS::METHOD( wxCoord p1, wxCoord p2, const wxArrayString& p3 ) \
 178   {                                                                           \
 179     dTHX;                                                                     \
 180     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) )     \
 181     {                                                                         \
 182         AV* av = newAV();                                                     \
 183         size_t i, max = p3.GetCount();                                        \
 184                                                                               \
 185         for( i = 0; i < max; ++i )                                            \
 186         {                                                                     \
 187             SV* sv = newSViv( 0 );                                            \
 188             const wxString& tmp = p3[ i ];                                    \
 189             WXSTRING_OUTPUT( tmp, sv );                                       \
 190             av_store( av, i, sv );                                            \
 191         }                                                                     \
 192         SV* rv = newRV_noinc( (SV*) av );                                     \
 193         SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,       \
 194                                                      G_SCALAR,                \
 195                                                      "lls", p1, p2, rv );     \
 196         bool val = SvTRUE( ret );                                             \
 197         SvREFCNT_dec( ret );                                                  \
 198         return val;                                                           \
 199     } else                                                                    \
 200         return false;                                                         \
 201   }
 202
 203 #define DEC_V_CBACK_WXSTRING__WXSTRING_INT( METHOD ) \
 204   wxString METHOD( const wxString&, int )
 205
 206 #define DEC_V_CBACK_WXFSFILEP__WXFILESYSTEM_WXSTRING( METHOD ) \
 207   wxFSFile* METHOD( wxFileSystem&, const wxString& )
 208
 209 #define DEC_V_CBACK_VOID__WXLOGLEVEL_CWXCHARP_TIMET( METHOD ) \
 210   void METHOD( wxLogLevel, const wxChar*, time_t )
 211
 212 #define DEF_V_CBACK_VOID__WXLOGLEVEL_CWXCHARP_TIMET( CLASS, BASE, METHOD )\
 213   void CLASS::METHOD( wxLogLevel p1, const wxChar* p2, time_t p3 )            \
 214   {                                                                           \
 215     dTHX;                                                                     \
 216     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) )     \
 217     {                                                                         \
 218         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback, G_VOID,         \
 219                                            "iwl", int(p1), p2, long(p3) );    \
 220     }                                                                         \
 221     BASE::METHOD( p1, p2, p3 );                                               \
 222   }
 223
 224 #define DEC_V_CBACK_VOID__CWXCHARP_TIMET( METHOD ) \
 225   void METHOD( const wxChar*, time_t )
 226
 227 #define DEF_V_CBACK_VOID__CWXCHARP_TIMET( CLASS, BASE, METHOD )\
 228   void CLASS::METHOD( const wxChar* p1, time_t p2 )                           \
 229   {                                                                           \
 230     dTHX;                                                                     \
 231     if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) )     \
 232     {                                                                         \
 233         wxPliVirtualCallback_CallCallback( aTHX_ &m_callback, G_VOID,         \
 234                                            "wl", p1, long(p2) );              \
 235     }                                                                         \
 236     BASE::METHOD( p1, p2 );                                                   \
 237   }
 238
 239 // ANY METH(int, int, int)
 240 #define DEC_V_CBACK_ANY__INT_INT_INT_( RET, METHOD, CONST ) \
 241     RET METHOD( int, int, int ) CONST
 242
 243 #define DEF_V_CBACK_ANY__INT_INT_INT_( RET, CVT, CLASS, CALLBASE, METHOD, CONST )\
 244     RET CLASS::METHOD( int p1, int p2, int p3 ) CONST                        \
 245     {                                                                        \
 246         dTHX;                                                                \
 247         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) )\
 248         {                                                                    \
 249             wxAutoSV ret( aTHX_ wxPliCCback( aTHX_ &m_callback, G_SCALAR,    \
 250                                              "iii", p1, p2, p3 ) );          \
 251             return CVT;                                                      \
 252         } else                                                               \
 253             CALLBASE;                                                        \
 254     }
 255
 256 // bool METH(int, int, const wxString&)
 257 #define DEC_V_CBACK_BOOL__INT_INT_WXSTRING_( METHOD, CONST ) \
 258     bool METHOD( int, int, const wxString& ) CONST
 259
 260 #define DEF_V_CBACK_BOOL__INT_INT_WXSTRING_( CLASS, CALLBASE, METHOD, CONST )\
 261     bool CLASS::METHOD( int p1, int p2, const wxString& p3 ) CONST           \
 262     {                                                                        \
 263         dTHX;                                                                \
 264         if( wxPliFCback( aTHX_ &m_callback, #METHOD ) )                      \
 265         {                                                                    \
 266             wxAutoSV ret( aTHX_ wxPliCCback( aTHX_ &m_callback, G_SCALAR,    \
 267                                              "iiP", p1, p2, &p3 ) );         \
 268             return SvTRUE( ret );                                            \
 269         } else                                                               \
 270             CALLBASE;                                                        \
 271     }
 272
 273 #define DEC_V_CBACK_BOOL__INT_INT_WXSTRING( METHOD ) \
 274     DEC_V_CBACK_BOOL__INT_INT_WXSTRING_( METHOD, wxPli_NOCONST )
 275
 276 #define DEF_V_CBACK_BOOL__INT_INT_WXSTRING( CLASS, BASE, METHOD ) \
 277     DEF_V_CBACK_BOOL__INT_INT_WXSTRING_( CLASS, return BASE::METHOD(p1, p2, p3), METHOD, wxPli_NOCONST )
 278
 279 #define DEF_V_CBACK_BOOL__INT_INT_WXSTRING_pure( CLASS, BASE, METHOD ) \
 280     DEF_V_CBACK_BOOL__INT_INT_WXSTRING_( CLASS, return false, METHOD, wxPli_NOCONST )
 281
 282 // void METH(const wxString&)
 283 #define DEC_V_CBACK_VOID__WXSTRING( METHOD )                                  \
 284     DEC_V_CBACK_ANY__WXSTRING_( void, METHOD, wxPli_NOCONST )
 285
 286 #define DEC_V_CBACK_VOID__WXSTRING_const( METHOD ) \
 287     DEC_V_CBACK_ANY__WXSTRING_( void, METHOD, wxPli_CONST )
 288
 289 #define DEF_V_CBACK_VOID__WXSTRING( CLASS, BASE, METHOD ) \
 290     DEF_V_CBACK_ANY__WXSTRING_( void, ;, CLASS, BASE::METHOD(p1), METHOD, wxPli_NOCONST )
 291
 292 #define DEF_V_CBACK_VOID__WXSTRING_pure( CLASS, BASE, METHOD ) \
 293     DEF_V_CBACK_ANY__WXSTRING_( void, ;, CLASS, return, METHOD, wxPli_NOCONST )
 294
 295 #define DEF_V_CBACK_VOID__WXSTRING_const( CLASS, BASE, METHOD ) \
 296     DEF_V_CBACK_ANY__WXSTRING_( void, ;, CLASS, BASE::METHOD(p1), METHOD, wxPli_CONST )
 297
 298 // bool METH(const wxString&)
 299 #define DEC_V_CBACK_BOOL__WXSTRING( METHOD )                                  \
 300     DEC_V_CBACK_ANY__WXSTRING_( bool, METHOD, wxPli_NOCONST )
 301
 302 #define DEC_V_CBACK_BOOL__WXSTRING_const( METHOD ) \
 303     DEC_V_CBACK_ANY__WXSTRING_( bool, METHOD, wxPli_CONST )
 304
 305 #define DEF_V_CBACK_BOOL__WXSTRING( CLASS, BASE, METHOD ) \
 306     DEF_V_CBACK_ANY__WXSTRING_( bool, SvTRUE( ret ), CLASS, return BASE::METHOD(p1), METHOD, wxPli_NOCONST )
 307
 308 #define DEF_V_CBACK_BOOL__WXSTRING_pure( CLASS, BASE, METHOD ) \
 309     DEF_V_CBACK_ANY__WXSTRING_( bool, SvTRUE( ret ), CLASS, return false, METHOD, wxPli_NOCONST )
 310
 311 #define DEF_V_CBACK_BOOL__WXSTRING_const( CLASS, BASE, METHOD ) \
 312     DEF_V_CBACK_ANY__WXSTRING_( bool, SvTRUE( ret ), CLASS, return BASE::METHOD(p1), METHOD, wxPli_CONST )
 313
 314 // bool METH(wxObject*)
 315 #define DEF_V_CBACK_BOOL__WXOBJECTs_( T1, CLASS, CALLBASE, METHOD, CONST )   \
 316     bool CLASS::METHOD( T1 p1 ) CONST                                        \
 317     {                                                                        \
 318         dTHX;                                                                \
 319         if( wxPliFCback( aTHX_ &m_callback, #METHOD ) )                      \
 320         {                                                                    \
 321             wxAutoSV ret( aTHX_ wxPliCCback( aTHX_ &m_callback,              \
 322                           G_SCALAR, "O", &p1 ) );                            \
 323             return SvTRUE( ret );                                            \
 324         } else                                                               \
 325             CALLBASE;                                                        \
 326     }
 327
 328 #define DEF_V_CBACK_BOOL__WXOBJECTsP_( T1, CLASS, CALLBASE, METHOD, CONST )  \
 329     bool CLASS::METHOD( T1 p1 ) CONST                                        \
 330     {                                                                        \
 331         dTHX;                                                                \
 332         if( wxPliFCback( aTHX_ &m_callback, #METHOD ) )                      \
 333         {                                                                    \
 334             wxAutoSV ret( aTHX_ wxPliCCback( aTHX_ &m_callback,              \
 335                           G_SCALAR, "O", p1 ) );                             \
 336             return SvTRUE( ret );                                            \
 337         } else                                                               \
 338             CALLBASE;                                                        \
 339     }
 340
 341 // bool METH(wxString&)
 342 #define DEC_V_CBACK_BOOL__mWXSTRING_( METHOD, CONST )                         \
 343     bool METHOD(wxString&) CONST
 344
 345 #define DEF_V_CBACK_BOOL__mWXSTRING_( CLASS, CALLBASE, METHOD, CONST )        \
 346     bool CLASS::METHOD(wxString& p1) CONST                                    \
 347     {                                                                         \
 348         dTHX;                                                                 \
 349         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback,             \
 350                                                #METHOD ) )                    \
 351         {                                                                     \
 352             SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,   \
 353                                                          G_SCALAR, "P",       \
 354                                                          &p1 );               \
 355                                                                               \
 356             wxString tmp;                                                     \
 357             WXSTRING_INPUT( tmp, const char *, ret );                         \
 358             p1 = tmp;                                                         \
 359                                                                               \
 360             bool val = SvTRUE( ret );                                         \
 361             SvREFCNT_dec( ret );                                              \
 362             return val;                                                       \
 363         }                                                                     \
 364         else                                                                  \
 365             CALLBASE;                                                         \
 366     }
 367
 368 #define DEC_V_CBACK_BOOL__mWXSTRING( METHOD ) \
 369     DEC_V_CBACK_BOOL__mWXSTRING_( METHOD, wxPli_NOCONST )
 370
 371 #define DEC_V_CBACK_BOOL__mWXSTRING_const( METHOD ) \
 372     DEC_V_CBACK_BOOL__mWXSTRING_( METHOD, wxPli_CONST )
 373
 374 #define DEF_V_CBACK_BOOL__mWXSTRING( CLASS, BASE, METHOD ) \
 375     DEF_V_CBACK_BOOL__mWXSTRING_( CLASS, return BASE::METHOD(p1), METHOD, wxPli_NOCONST )
 376
 377 #define DEF_V_CBACK_BOOL__mWXSTRING_pure( CLASS, BASE, METHOD ) \
 378     DEF_V_CBACK_BOOL__mWXSTRING_( CLASS, return false, METHOD, wxPli_NOCONST )
 379
 380 #define DEF_V_CBACK_BOOL__mWXSTRING_const( CLASS, BASE, METHOD ) \
 381     DEF_V_CBACK_BOOL__mWXSTRING_( CLASS, return BASE::METHOD(p1), METHOD, wxPli_CONST )
 382
 383 // ANY METH()
 384 #define DEC_V_CBACK_ANY__VOID_( RET, METHOD, CONST )                          \
 385     RET METHOD() CONST
 386
 387 #define DEF_V_CBACK_ANY__VOID_( RET, CVT, CLASS, CALLBASE, METHOD, CONST ) \
 388     RET CLASS::METHOD() CONST                                                 \
 389     {                                                                         \
 390         dTHX;                                                                 \
 391         if( wxPliFCback( aTHX_ &m_callback, #METHOD ) )                       \
 392         {                                                                     \
 393             wxAutoSV ret( aTHX_ wxPliCCback( aTHX_ &m_callback, G_SCALAR,     \
 394                                              NULL ) );                        \
 395             return CVT;                                                       \
 396         }                                                                     \
 397         else                                                                  \
 398             CALLBASE;                                                         \
 399     }
 400
 401 // void METH()
 402 #define DEC_V_CBACK_VOID__VOID_( METHOD, CONST ) \
 403     void METHOD() CONST
 404
 405 #define DEF_V_CBACK_VOID__VOID_( CLASS, CALLBASE, METHOD, CONST )             \
 406     void CLASS::METHOD() CONST                                                \
 407     {                                                                         \
 408         dTHX;                                                                 \
 409         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) ) \
 410         {                                                                     \
 411               wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,           \
 412                                                  G_SCALAR|G_DISCARD, NULL );  \
 413         } else                                                                \
 414             CALLBASE;                                                         \
 415     }
 416
 417 #define DEC_V_CBACK_VOID__VOID( METHOD ) \
 418     DEC_V_CBACK_VOID__VOID_( METHOD, wxPli_NOCONST )
 419
 420 #define DEF_V_CBACK_VOID__VOID( CLASS, BASE, METHOD ) \
 421     DEF_V_CBACK_VOID__VOID_( CLASS, BASE::METHOD(), METHOD, wxPli_NOCONST )
 422
 423 #define DEF_V_CBACK_VOID__VOID_pure( CLASS, BASE, METHOD ) \
 424     DEF_V_CBACK_VOID__VOID_( CLASS, return, METHOD, wxPli_NOCONST )
 425
 426 // void METH(int, int, bool)
 427 #define DEC_V_CBACK_VOID__INT_INT_BOOL_( METHOD, CONST ) \
 428     void METHOD( int, int, bool ) CONST
 429
 430 #define DEF_V_CBACK_VOID__INT_INT_BOOL_( CLASS, CALLBASE, METHOD, CONST )\
 431     void CLASS::METHOD( int p1, int p2, bool p3 ) CONST                      \
 432     {                                                                        \
 433         dTHX;                                                                \
 434         if( wxPliFCback( aTHX_ &m_callback, #METHOD ) )                      \
 435         {                                                                    \
 436             wxPliCCback( aTHX_ &m_callback, G_SCALAR|G_DISCARD, "iib",       \
 437                          p1, p2, p3 );                                       \
 438         } else                                                               \
 439             CALLBASE;                                                        \
 440     }
 441
 442 #define DEC_V_CBACK_VOID__INT_INT_BOOL( METHOD ) \
 443     DEC_V_CBACK_VOID__INT_INT_BOOL_( METHOD, wxPli_NOCONST )
 444
 445 #define DEF_V_CBACK_VOID__INT_INT_BOOL( CLASS, BASE, METHOD ) \
 446     DEF_V_CBACK_VOID__INT_INT_BOOL_( CLASS, BASE::METHOD(p1, p2, p3), METHOD, wxPli_NOCONST )
 447
 448 #define DEF_V_CBACK_VOID__INT_INT_BOOL_pure( CLASS, BASE, METHOD ) \
 449     DEF_V_CBACK_VOID__INT_INT_BOOL_( CLASS, return, METHOD, wxPli_NOCONST )
 450
 451 // void METH(int, int, double)
 452 #define DEC_V_CBACK_VOID__INT_INT_DOUBLE_( METHOD, CONST ) \
 453     void METHOD( int, int, double ) CONST
 454
 455 #define DEF_V_CBACK_VOID__INT_INT_DOUBLE_( CLASS, CALLBASE, METHOD, CONST )\
 456     void CLASS::METHOD( int p1, int p2, double p3 ) CONST                    \
 457     {                                                                        \
 458         dTHX;                                                                \
 459         if( wxPliFCback( aTHX_ &m_callback, #METHOD ) )                      \
 460         {                                                                    \
 461             wxPliCCback( aTHX_ &m_callback, G_SCALAR|G_DISCARD, "iid",       \
 462                          p1, p2, p3 );                                       \
 463         } else                                                               \
 464             CALLBASE;                                                        \
 465     }
 466
 467 #define DEC_V_CBACK_VOID__INT_INT_DOUBLE( METHOD ) \
 468     DEC_V_CBACK_VOID__INT_INT_DOUBLE_( METHOD, wxPli_NOCONST )
 469
 470 #define DEF_V_CBACK_VOID__INT_INT_DOUBLE( CLASS, BASE, METHOD ) \
 471     DEF_V_CBACK_VOID__INT_INT_DOUBLE_( CLASS, BASE::METHOD(p1, p2, p3), METHOD, wxPli_NOCONST )
 472
 473 #define DEF_V_CBACK_VOID__INT_INT_DOUBLE_pure( CLASS, BASE, METHOD ) \
 474     DEF_V_CBACK_VOID__INT_INT_DOUBLE_( CLASS, return, METHOD, wxPli_NOCONST )
 475
 476 // void METH(int, int, wxString)
 477 #define DEC_V_CBACK_VOID__INT_INT_WXSTRING_( METHOD, CONST ) \
 478     void METHOD( int, int, const wxString& ) CONST
 479
 480 #define DEF_V_CBACK_VOID__INT_INT_WXSTRING_( CLASS, CALLBASE, METHOD, CONST )\
 481     void CLASS::METHOD( int p1, int p2, const wxString& p3 ) CONST           \
 482     {                                                                        \
 483         dTHX;                                                                \
 484         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) )\
 485         {                                                                    \
 486               wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,          \
 487                                                  G_SCALAR|G_DISCARD, "iiP",  \
 488                                                  p1, p2, &p3 );              \
 489         } else                                                               \
 490             CALLBASE;                                                        \
 491     }
 492
 493 #define DEC_V_CBACK_VOID__INT_INT_WXSTRING( METHOD ) \
 494     DEC_V_CBACK_VOID__INT_INT_WXSTRING_( METHOD, wxPli_NOCONST )
 495
 496 #define DEF_V_CBACK_VOID__INT_INT_WXSTRING( CLASS, BASE, METHOD ) \
 497     DEF_V_CBACK_VOID__INT_INT_WXSTRING_( CLASS, BASE::METHOD(p1, p2, p3), METHOD, wxPli_NOCONST )
 498
 499 #define DEF_V_CBACK_VOID__INT_INT_WXSTRING_pure( CLASS, BASE, METHOD ) \
 500     DEF_V_CBACK_VOID__INT_INT_WXSTRING_( CLASS, return, METHOD, wxPli_NOCONST )
 501
 502 // void METH(int, const wxString&)
 503 #define DEC_V_CBACK_VOID__INT_WXSTRING_( METHOD, CONST ) \
 504     void METHOD( int, const wxString& ) CONST
 505
 506 #define DEF_V_CBACK_VOID__INT_WXSTRING_( CLASS, CALLBASE, METHOD, CONST )\
 507     void CLASS::METHOD( int p1, const wxString& p2 ) CONST                   \
 508     {                                                                        \
 509         dTHX;                                                                \
 510         if( wxPliFCback( aTHX_ &m_callback, #METHOD ) )                      \
 511         {                                                                    \
 512             wxPliCCback( aTHX_ &m_callback, G_SCALAR|G_DISCARD,              \
 513                          "iP", p1, &p2 );                                    \
 514         } else                                                               \
 515             CALLBASE;                                                        \
 516     }
 517
 518 #define DEC_V_CBACK_VOID__INT_WXSTRING( METHOD ) \
 519     DEC_V_CBACK_VOID__INT_WXSTRING_( METHOD, wxPli_NOCONST )
 520
 521 #define DEF_V_CBACK_VOID__INT_WXSTRING( CLASS, BASE, METHOD ) \
 522     DEF_V_CBACK_VOID__INT_WXSTRING_( CLASS, BASE::METHOD(p1, p2), METHOD, wxPli_NOCONST )
 523
 524 #define DEF_V_CBACK_VOID__INT_WXSTRING_pure( CLASS, BASE, METHOD ) \
 525     DEF_V_CBACK_VOID__INT_WXSTRING_( CLASS, return, METHOD, wxPli_NOCONST )
 526
 527 // void METH(wxGrid*)
 528 #define DEC_V_CBACK_VOID__WXGRID_( METHOD, CONST ) \
 529     void METHOD( wxGrid* ) CONST
 530
 531 #define DEF_V_CBACK_VOID__WXGRID_( CLASS, CALLBASE, METHOD, CONST ) \
 532     DEF_V_CBACK_VOID__WXOBJECTsP_( wxGrid*, CLASS, CALLBASE, METHOD, CONST )
 533
 534 #define DEC_V_CBACK_VOID__WXGRID( METHOD ) \
 535     DEC_V_CBACK_VOID__WXGRID_( METHOD, wxPli_NOCONST )
 536
 537 #define DEF_V_CBACK_VOID__WXGRID( CLASS, BASE, METHOD ) \
 538     DEF_V_CBACK_VOID__WXOBJECTsP_( wxGrid*, CLASS, BASE::METHOD(p1), METHOD, wxPli_NOCONST )
 539
 540 #define DEF_V_CBACK_VOID__WXGRID_pure( CLASS, BASE, METHOD ) \
 541     DEF_V_CBACK_VOID__WXOBJECTsP_( wxGrid*, CLASS, return, METHOD, wxPli_NOCONST )
 542
 543 // void METH(wxWindow*)
 544 #define DEC_V_CBACK_VOID__WXWINDOW_( METHOD, CONST ) \
 545     void METHOD( wxWindow* ) CONST
 546
 547 #define DEF_V_CBACK_VOID__WXWINDOW_( CLASS, CALLBASE, METHOD, CONST ) \
 548     DEF_V_CBACK_VOID__WXOBJECTsP_( wxWindow*, CLASS, CALLBASE, METHOD, CONST )
 549
 550 #define DEC_V_CBACK_VOID__WXWINDOW( METHOD ) \
 551     DEC_V_CBACK_VOID__WXWINDOW_( METHOD, wxPli_NOCONST )
 552
 553 #define DEF_V_CBACK_VOID__WXWINDOW( CLASS, BASE, METHOD ) \
 554     DEF_V_CBACK_VOID__WXOBJECTsP_( wxWindow*, CLASS, BASE::METHOD(p1), METHOD, wxPli_NOCONST )
 555
 556 #define DEF_V_CBACK_VOID__WXWINDOW_pure( CLASS, BASE, METHOD ) \
 557     DEF_V_CBACK_VOID__WXOBJECTsP_( wxWindow*, CLASS, return, METHOD, wxPli_NOCONST )
 558
 559 // bool METH(wxWindow*)
 560 #define DEC_V_CBACK_BOOL__WXWINDOW_( METHOD, CONST ) \
 561     bool METHOD( wxWindow* ) CONST
 562
 563 #define DEF_V_CBACK_BOOL__WXWINDOW_( CLASS, CALLBASE, METHOD, CONST ) \
 564     DEF_V_CBACK_BOOL__WXOBJECTsP_( wxWindow*, CLASS, CALLBASE, METHOD, CONST )
 565
 566 #define DEC_V_CBACK_BOOL__WXWINDOW( METHOD ) \
 567     DEC_V_CBACK_BOOL__WXWINDOW_( METHOD, wxPli_NOCONST )
 568
 569 #define DEF_V_CBACK_BOOL__WXWINDOW( CLASS, BASE, METHOD ) \
 570     DEF_V_CBACK_BOOL__WXOBJECTsP_( wxWindow*, CLASS, BASE::METHOD(p1), METHOD, wxPli_NOCONST )
 571
 572 #define DEF_V_CBACK_BOOL__WXWINDOW_pure( CLASS, BASE, METHOD ) \
 573     DEF_V_CBACK_BOOL__WXOBJECTsP_( wxWindow*, CLASS, return false, METHOD, wxPli_NOCONST )
 574
 575 // void METH(wxObject*)
 576 #define DEF_V_CBACK_VOID__WXOBJECTsP_( T1, CLASS, CALLBASE, METHOD, CONST )  \
 577     void CLASS::METHOD( T1 p1 ) CONST                                        \
 578     {                                                                        \
 579         dTHX;                                                                \
 580         if( wxPliFCback( aTHX_ &m_callback, #METHOD ) )                      \
 581         {                                                                    \
 582             wxPliCCback( aTHX_ &m_callback, G_SCALAR|G_DISCARD, "O", p1 );   \
 583         } else                                                               \
 584             CALLBASE;                                                        \
 585     }
 586
 587 // wxGrid* METH()
 588 #define DEC_V_CBACK_WXGRID__VOID_( METHOD, CONST ) \
 589     wxGrid* METHOD() CONST
 590
 591 #define DEF_V_CBACK_WXGRID__VOID_( CLASS, CALLBASE, METHOD, CONST ) \
 592     DEF_V_CBACK_WXOBJECTsP__VOID_( wxGrid*, Wx::Grid, CLASS, CALLBASE, METHOD, CONST )
 593
 594 #define DEC_V_CBACK_WXGRID__VOID_const( METHOD ) \
 595     DEC_V_CBACK_WXGRID__VOID_( METHOD, wxPli_CONST )
 596
 597 #define DEF_V_CBACK_WXGRID__VOID_const( CLASS, BASE, METHOD ) \
 598     DEF_V_CBACK_WXGRID__VOID_( CLASS, return BASE::METHOD(), METHOD, wxPli_CONST )
 599
 600 // wxWindow* METH()
 601 #define DEC_V_CBACK_WXWINDOW__VOID_( METHOD, CONST ) \
 602     wxWindow* METHOD() CONST
 603
 604 #define DEF_V_CBACK_WXWINDOW__VOID_( CLASS, CALLBASE, METHOD, CONST ) \
 605     DEF_V_CBACK_WXOBJECTsP__VOID_( wxWindow*, Wx::Window, CLASS, CALLBASE, METHOD, CONST )
 606
 607 #define DEC_V_CBACK_WXWINDOW__VOID( METHOD ) \
 608     DEC_V_CBACK_WXWINDOW__VOID_( METHOD, wxPli_NOCONST )
 609
 610 #define DEC_V_CBACK_WXWINDOW__VOID_const( METHOD ) \
 611     DEC_V_CBACK_WXWINDOW__VOID_( METHOD, wxPli_CONST )
 612
 613 #define DEF_V_CBACK_WXWINDOW__VOID_const( CLASS, BASE, METHOD ) \
 614     DEF_V_CBACK_WXWINDOW__VOID_( CLASS, return BASE::METHOD(), METHOD, wxPli_CONST )
 615
 616 #define DEF_V_CBACK_WXWINDOW__VOID_pure( CLASS, BASE, METHOD ) \
 617     DEF_V_CBACK_WXWINDOW__VOID_( CLASS, return NULL, METHOD, wxPli_NOCONST )
 618
 619 // wxObject* METH()
 620 #define DEF_V_CBACK_WXOBJECTsP__VOID_( TR, TRC, CLASS, CALLBASE, METHOD, CONST )\
 621     TR CLASS::METHOD() CONST                                                 \
 622     {                                                                        \
 623         dTHX;                                                                \
 624         if( wxPliFCback( aTHX_ &m_callback, #METHOD ) )                      \
 625         {                                                                    \
 626             wxAutoSV ret( aTHX_ wxPliCCback( aTHX_ &m_callback, G_SCALAR,    \
 627                                              NULL ) );                       \
 628             return (TR)wxPli_sv_2_object( aTHX_ ret, #TRC );                 \
 629         } else                                                               \
 630             CALLBASE;                                                        \
 631     }
 632
 633 // wxString METH()
 634 #define DEC_V_CBACK_WXSTRING__VOID_( METHOD, CONST ) \
 635     wxString METHOD() CONST
 636
 637 #define DEF_V_CBACK_WXSTRING__VOID_( CLASS, CALLBASE, METHOD, CONST )         \
 638     wxString CLASS::METHOD() CONST                                            \
 639     {                                                                         \
 640         dTHX;                                                                 \
 641         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) ) \
 642         {                                                                     \
 643             SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,   \
 644                                                          G_SCALAR, NULL );    \
 645             wxString val;                                                     \
 646             WXSTRING_INPUT( val, wxString, ret );                             \
 647             SvREFCNT_dec( ret );                                              \
 648             return val;                                                       \
 649         }                                                                     \
 650         else                                                                  \
 651             CALLBASE;                                                         \
 652     }
 653
 654 #define DEC_V_CBACK_WXSTRING__VOID( METHOD ) \
 655     DEC_V_CBACK_WXSTRING__VOID_( METHOD, wxPli_NOCONST )
 656
 657 #define DEC_V_CBACK_WXSTRING__VOID_const( METHOD ) \
 658     DEC_V_CBACK_WXSTRING__VOID_( METHOD, wxPli_CONST )
 659
 660 #define DEF_V_CBACK_WXSTRING__VOID( CLASS, BASE, METHOD ) \
 661     DEF_V_CBACK_WXSTRING__VOID_( CLASS, return BASE::METHOD(), METHOD, wxPli_NOCONST )
 662
 663 #define DEF_V_CBACK_WXSTRING__VOID_const( CLASS, BASE, METHOD ) \
 664     DEF_V_CBACK_WXSTRING__VOID_( CLASS, return BASE::METHOD(), METHOD, wxPli_CONST )
 665
 666 #define DEF_V_CBACK_WXSTRING__VOID_pure( CLASS, BASE, METHOD ) \
 667     DEF_V_CBACK_WXSTRING__VOID_( CLASS, return wxEmptyString, METHOD, wxPli_NOCONST )
 668
 669 #define DEF_V_CBACK_WXSTRING__VOID_const_pure( CLASS, BASE, METHOD ) \
 670     DEF_V_CBACK_WXSTRING__VOID_( CLASS, return wxEmptyString, METHOD, wxPli_CONST )
 671
 672 // wxString METH(int)
 673 #define DEC_V_CBACK_WXSTRING__INT_( METHOD, CONST ) \
 674     wxString METHOD( int ) CONST
 675
 676 #define DEF_V_CBACK_WXSTRING__INT_( CLASS, CALLBASE, METHOD, CONST )         \
 677     wxString CLASS::METHOD( int p1 ) CONST                                   \
 678     {                                                                        \
 679         dTHX;                                                                \
 680         if( wxPliFCback( aTHX_ &m_callback, #METHOD ) )                      \
 681         {                                                                    \
 682             wxAutoSV ret( aTHX_ wxPliCCback( aTHX_ &m_callback, G_SCALAR,    \
 683                                              "i", p1 ) );                    \
 684             wxString val;                                                    \
 685             WXSTRING_INPUT( val, wxString, ret );                            \
 686             return val;                                                      \
 687         }                                                                    \
 688         else                                                                 \
 689             CALLBASE;                                                        \
 690     }
 691
 692 #define DEC_V_CBACK_WXSTRING__INT( METHOD ) \
 693     DEC_V_CBACK_WXSTRING__INT_( METHOD, wxPli_NOCONST )
 694
 695 #define DEF_V_CBACK_WXSTRING__INT( CLASS, BASE, METHOD ) \
 696     DEF_V_CBACK_WXSTRING__INT_( CLASS, return BASE::METHOD(p1), METHOD, wxPli_NOCONST )
 697
 698 #define DEF_V_CBACK_WXSTRING__INT_pure( CLASS, BASE, METHOD ) \
 699     DEF_V_CBACK_WXSTRING__INT_( CLASS, return wxEmptyString, METHOD, wxPli_NOCONST )
 700
 701 // wxString METH(int, int)
 702 #define DEC_V_CBACK_WXSTRING__INT_INT_( METHOD, CONST ) \
 703     wxString METHOD( int, int ) CONST
 704
 705 #define DEF_V_CBACK_WXSTRING__INT_INT_( CLASS, CALLBASE, METHOD, CONST )     \
 706     wxString CLASS::METHOD( int p1, int p2 ) CONST                           \
 707     {                                                                        \
 708         dTHX;                                                                \
 709         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) )\
 710         {                                                                    \
 711             SV* ret = wxPliVirtualCallback_CallCallback( aTHX_ &m_callback,  \
 712                                                          G_SCALAR, "ii",     \
 713                                                          p1, p2 );           \
 714             wxString val;                                                    \
 715             WXSTRING_INPUT( val, wxString, ret );                            \
 716             SvREFCNT_dec( ret );                                             \
 717             return val;                                                      \
 718         }                                                                    \
 719         else                                                                 \
 720             CALLBASE;                                                        \
 721     }
 722
 723 #define DEC_V_CBACK_WXSTRING__INT_INT( METHOD ) \
 724     DEC_V_CBACK_WXSTRING__INT_INT_( METHOD, wxPli_NOCONST )
 725
 726 #define DEF_V_CBACK_WXSTRING__INT_INT( CLASS, BASE, METHOD ) \
 727     DEF_V_CBACK_WXSTRING__INT_INT_( CLASS, return BASE::METHOD(p1, p2), METHOD, wxPli_NOCONST )
 728
 729 #define DEF_V_CBACK_WXSTRING__INT_INT_pure( CLASS, BASE, METHOD ) \
 730     DEF_V_CBACK_WXSTRING__INT_INT_( CLASS, return wxEmptyString, METHOD, wxPli_NOCONST )
 731
 732 // ANY METH( wxKeyEvent& )
 733 #define DEC_V_CBACK_ANY__WXKEYEVENT_( RET, METHOD, CONST ) \
 734   RET METHOD( wxKeyEvent& event ) CONST
 735
 736 #define DEF_V_CBACK_ANY__WXKEYEVENT_( RET, CVT, CLASS, CALLBASE, METHOD, CONST )\
 737     RET CLASS::METHOD( wxKeyEvent& p1 ) CONST                                 \
 738     {                                                                         \
 739         dTHX;                                                                 \
 740         if( wxPliVirtualCallback_FindCallback( aTHX_ &m_callback, #METHOD ) ) \
 741         {                                                                     \
 742             SV* evt = wxPli_object_2_sv( aTHX_ newSViv( 0 ), &p1 );           \
 743             wxAutoSV ret( aTHX_ wxPliCCback( aTHX_ &m_callback, G_SCALAR,     \
 744                                              "S", evt ) );                    \
 745             sv_setiv( SvRV( evt ), 0 );                                       \
 746             SvREFCNT_dec( evt );                                              \
 747             return CVT;                                                       \
 748         } else                                                                \
 749             CALLBASE;                                                         \
 750     }
 751
 752 #include "cpp/v_cback_def.h"
 753
 754 #endif // _WXPERL_V_CBACK_H
 755
 756 // Local variables: //
 757 // mode: c++ //
 758 // End: //