include/wx/propgrid/propgriddefs.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/propgrid/propgriddefs.h
   3 // Purpose:     wxPropertyGrid miscellaneous definitions
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2008-08-31
   7 // RCS-ID:      $Id:
   8 // Copyright:   (c) Jaakko Salli
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_PROPGRID_PROPGRIDDEFS_H_
  13 #define _WX_PROPGRID_PROPGRIDDEFS_H_
  14
  15 #include "wx/dynarray.h"
  16 #include "wx/hashmap.h"
  17 #include "wx/variant.h"
  18 #include "wx/longlong.h"
  19 #include "wx/clntdata.h"
  20
  21 // -----------------------------------------------------------------------
  22
  23 //
  24 // Here are some platform dependent defines
  25 // NOTE: More in propertygrid.cpp
  26 //
  27
  28 #ifndef SWIG
  29
  30 #if defined(__WXMSW__)
  31
  32     // space between vertical line and value text
  33     #define wxPG_XBEFORETEXT            4
  34     // space between vertical line and value editor control
  35     #define wxPG_XBEFOREWIDGET          1
  36
  37     // x position adjustment for wxTextCtrl (and like)
  38     #define wxPG_TEXTCTRLXADJUST        3
  39
  40     // comment to use bitmap buttons
  41     #define wxPG_ICON_WIDTH             9
  42     // 1 if wxRendererNative should be employed
  43     #define wxPG_USE_RENDERER_NATIVE    0
  44
  45     // 1 to use double-buffer that guarantees flicker-free painting
  46     #define wxPG_DOUBLE_BUFFER          1
  47
  48     // Enable tooltips
  49     #define wxPG_SUPPORT_TOOLTIPS       1
  50
  51     // width of optional bitmap/image in front of property
  52     #define wxPG_CUSTOM_IMAGE_WIDTH     20
  53
  54     // 1 to create controls out of sight, hide them, and then move them into
  55     // correct position
  56     #define wxPG_CREATE_CONTROLS_HIDDEN 0
  57
  58     // 1 if splitter drag detect margin and control cannot overlap
  59     #define wxPG_NO_CHILD_EVT_MOTION    0
  60
  61     // If 1, then setting empty tooltip actually hides it
  62     #define wxPG_ALLOW_EMPTY_TOOLTIPS   1
  63
  64     #define wxPG_NAT_BUTTON_BORDER_ANY          1
  65     #define wxPG_NAT_BUTTON_BORDER_X            1
  66     #define wxPG_NAT_BUTTON_BORDER_Y            1
  67
  68     // If 1 then controls are refreshed after selected was drawn.
  69     #define wxPG_REFRESH_CONTROLS_AFTER_REPAINT 0
  70
  71 #elif defined(__WXGTK__)
  72
  73     // space between vertical line and value text
  74     #define wxPG_XBEFORETEXT            5
  75     // space between vertical line and value editor control
  76     #define wxPG_XBEFOREWIDGET          1
  77
  78     // x position adjustment for wxTextCtrl (and like)
  79     #define wxPG_TEXTCTRLXADJUST        3
  80
  81     // comment to use bitmap buttons
  82     #define wxPG_ICON_WIDTH             9
  83     // 1 if wxRendererNative should be employed
  84     #define wxPG_USE_RENDERER_NATIVE    0
  85
  86     // 1 to use double-buffer that guarantees flicker-free painting
  87     #define wxPG_DOUBLE_BUFFER          1
  88
  89     // Enable tooltips
  90     #define wxPG_SUPPORT_TOOLTIPS       1
  91
  92     // width of optional bitmap/image in front of property
  93     #define wxPG_CUSTOM_IMAGE_WIDTH     20
  94
  95     // 1 to create controls out of sight, hide them, and then move them into
  96     // correct position
  97     #define wxPG_CREATE_CONTROLS_HIDDEN 0
  98
  99     // 1 if splitter drag detect margin and control cannot overlap
 100     #define wxPG_NO_CHILD_EVT_MOTION    1
 101
 102     // If 1, then setting empty tooltip actually hides it
 103     #define wxPG_ALLOW_EMPTY_TOOLTIPS   0
 104
 105     #define wxPG_NAT_BUTTON_BORDER_ANY      1
 106     #define wxPG_NAT_BUTTON_BORDER_X        1
 107     #define wxPG_NAT_BUTTON_BORDER_Y        1
 108
 109     // If 1 then controls are refreshed after selected was drawn.
 110     #define wxPG_REFRESH_CONTROLS_AFTER_REPAINT 1
 111
 112 #elif defined(__WXMAC__)
 113
 114     // space between vertical line and value text
 115     #define wxPG_XBEFORETEXT            4
 116     // space between vertical line and value editor widget
 117     #define wxPG_XBEFOREWIDGET          1
 118
 119     // x position adjustment for wxTextCtrl (and like)
 120     #define wxPG_TEXTCTRLXADJUST        3
 121
 122     // comment to use bitmap buttons
 123     #define wxPG_ICON_WIDTH             11
 124     // 1 if wxRendererNative should be employed
 125     #define wxPG_USE_RENDERER_NATIVE    1
 126
 127     // 1 to use double-buffer that guarantees flicker-free painting
 128     #define wxPG_DOUBLE_BUFFER          0
 129
 130     // Enable tooltips
 131     #define wxPG_SUPPORT_TOOLTIPS       1
 132
 133     // width of optional bitmap/image in front of property
 134     #define wxPG_CUSTOM_IMAGE_WIDTH     20
 135
 136     // 1 to create controls out of sight, hide them, and then move them into
 137     // correct position
 138     #define wxPG_CREATE_CONTROLS_HIDDEN 0
 139
 140     // 1 if splitter drag detect margin and control cannot overlap
 141     #define wxPG_NO_CHILD_EVT_MOTION    0
 142
 143     // If 1, then setting empty tooltip actually hides it
 144     #define wxPG_ALLOW_EMPTY_TOOLTIPS   1
 145
 146     #define wxPG_NAT_BUTTON_BORDER_ANY      0
 147     #define wxPG_NAT_BUTTON_BORDER_X        0
 148     #define wxPG_NAT_BUTTON_BORDER_Y        0
 149
 150     // If 1 then controls are refreshed after selected was drawn.
 151     #define wxPG_REFRESH_CONTROLS_AFTER_REPAINT 0
 152
 153 #else // defaults
 154
 155     // space between vertical line and value text
 156     #define wxPG_XBEFORETEXT            5
 157     // space between vertical line and value editor widget
 158     #define wxPG_XBEFOREWIDGET          1
 159
 160     // x position adjustment for wxTextCtrl (and like)
 161     #define wxPG_TEXTCTRLXADJUST        3
 162
 163     // comment to use bitmap buttons
 164     #define wxPG_ICON_WIDTH             9
 165     // 1 if wxRendererNative should be employed
 166     #define wxPG_USE_RENDERER_NATIVE    0
 167
 168     // 1 to use double-buffer that guarantees flicker-free painting
 169     #define wxPG_DOUBLE_BUFFER          0
 170
 171     // Enable tooltips
 172     #define wxPG_SUPPORT_TOOLTIPS       0
 173
 174     // width of optional bitmap/image in front of property
 175     #define wxPG_CUSTOM_IMAGE_WIDTH     20
 176
 177     // 1 to create controls out of sight, hide them, and then move them into
 178     // correct position
 179     #define wxPG_CREATE_CONTROLS_HIDDEN 0
 180
 181     // 1 if splitter drag detect margin and control cannot overlap
 182     #define wxPG_NO_CHILD_EVT_MOTION    1
 183
 184     // If 1, then setting empty tooltip actually hides it
 185     #define wxPG_ALLOW_EMPTY_TOOLTIPS   0
 186
 187     #define wxPG_NAT_BUTTON_BORDER_ANY      0
 188     #define wxPG_NAT_BUTTON_BORDER_X        0
 189     #define wxPG_NAT_BUTTON_BORDER_Y        0
 190
 191     // If 1 then controls are refreshed after selected was drawn.
 192     #define wxPG_REFRESH_CONTROLS_AFTER_REPAINT 1
 193 #endif // platform
 194
 195
 196 #define wxPG_CONTROL_MARGIN             0 // space between splitter and control
 197
 198 #define wxCC_CUSTOM_IMAGE_MARGIN1       4  // before image
 199 #define wxCC_CUSTOM_IMAGE_MARGIN2       5  // after image
 200
 201 #define wxPG_DRAG_MARGIN                30
 202
 203 #if wxPG_NO_CHILD_EVT_MOTION
 204     #define wxPG_SPLITTERX_DETECTMARGIN1    3 // this much on left
 205     #define wxPG_SPLITTERX_DETECTMARGIN2    2 // this much on right
 206 #else
 207     #define wxPG_SPLITTERX_DETECTMARGIN1    3 // this much on left
 208     #define wxPG_SPLITTERX_DETECTMARGIN2    2 // this much on right
 209 #endif
 210
 211 // Use this macro to generate standard custom image height from
 212 #define wxPG_STD_CUST_IMAGE_HEIGHT(LINEHEIGHT)  (LINEHEIGHT-3)
 213
 214
 215 #if defined(__WXWINCE__)
 216     #define wxPG_SMALL_SCREEN       1
 217     #undef wxPG_DOUBLE_BUFFER
 218     #define wxPG_DOUBLE_BUFFER      0
 219 #else
 220     #define wxPG_SMALL_SCREEN       0
 221 #endif
 222
 223 #endif // #ifndef SWIG
 224
 225 // Undefine wxPG_ICON_WIDTH to use supplied xpm bitmaps instead
 226 // (for tree buttons)
 227 //#undef wxPG_ICON_WIDTH
 228
 229 // Need to force disable tooltips?
 230 #if !wxUSE_TOOLTIPS
 231     #undef wxPG_SUPPORT_TOOLTIPS
 232     #define wxPG_SUPPORT_TOOLTIPS       0
 233 #endif
 234
 235 // Set 1 to include advanced properties (wxFontProperty, wxColourProperty, etc.)
 236 #ifndef wxPG_INCLUDE_ADVPROPS
 237     #define wxPG_INCLUDE_ADVPROPS           1
 238 #endif
 239
 240 // Set 1 to include checkbox editor class
 241 #define wxPG_INCLUDE_CHECKBOX           1
 242
 243 // -----------------------------------------------------------------------
 244
 245
 246 // wxPG_CHECK_FOO_DBG - debug check with message that does not
 247 //                      interrupt program flow.
 248 #define wxPG_CHECK_RET_DBG(A,B) \
 249     if ( !(A) ) { wxLogWarning(B); return; }
 250 #define wxPG_CHECK_MSG_DBG(A,B,C) \
 251     if ( !(A) ) { wxLogWarning(C); return B; }
 252
 253
 254 class wxPGEditor;
 255 class wxPGProperty;
 256 class wxPropertyCategory;
 257 class wxPGChoices;
 258 class wxPropertyGridPageState;
 259 class wxPGCell;
 260 class wxPGCellRenderer;
 261 class wxPGChoiceEntry;
 262 class wxPGPropArgCls;
 263 class wxPropertyGridInterface;
 264 class wxPropertyGrid;
 265 class wxPropertyGridEvent;
 266 class wxPropertyGridManager;
 267 class wxPGOwnerDrawnComboBox;
 268 class wxPGCustomComboControl;
 269 class wxPGEditorDialogAdapter;
 270 struct wxPGValidationInfo;
 271
 272
 273 // -----------------------------------------------------------------------
 274
 275 /** @section propgrid_misc wxPropertyGrid Miscellanous
 276
 277     This section describes some miscellanous values, types and macros.
 278     @{
 279 */
 280
 281 #ifndef SWIG
 282     // Used to tell wxPGProperty to use label as name as well
 283     #define wxPG_LABEL              (*wxPGProperty::sm_wxPG_LABEL)
 284     // This is the value placed in wxPGProperty::sm_wxPG_LABEL
 285     #define wxPG_LABEL_STRING       wxS("@!")
 286     #define wxPG_NULL_BITMAP        wxNullBitmap
 287     #define wxPG_COLOUR_BLACK       (*wxBLACK)
 288 #else
 289     #define wxPG_NULL_BITMAP        wxBitmap_NULL
 290     #define wxPG_COLOUR_BLACK       wxColour_BLACK
 291 #endif // #ifndef SWIG
 292
 293 /** Convert Red, Green and Blue to a single 32-bit value.
 294 */
 295 #define wxPG_COLOUR(R,G,B) ((wxUint32)(R+(G<<8)+(B<<16)))
 296
 297
 298 /** If property is supposed to have custom-painted image, then returning
 299     this in OnMeasureImage() will usually be enough.
 300 */
 301 #define wxPG_DEFAULT_IMAGE_SIZE             wxSize(-1, -1)
 302
 303
 304 typedef wxString wxPGCachedString;
 305
 306 /** @}
 307 */
 308
 309 // -----------------------------------------------------------------------
 310
 311 // Used to indicate wxPGChoices::Add etc that the value is actually not given
 312 // by the caller.
 313 #define wxPG_INVALID_VALUE      INT_MAX
 314
 315 // -----------------------------------------------------------------------
 316
 317 #ifndef SWIG
 318
 319 #if wxUSE_STL
 320 typedef std::vector<wxPGProperty*> wxArrayPGProperty;
 321 #else
 322 WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(wxPGProperty*, wxArrayPGProperty,
 323                                   wxBaseArrayPtrVoid,
 324                                   class WXDLLIMPEXP_PROPGRID);
 325 #endif
 326
 327 // Always use wxString based hashmap with unicode, stl, swig and GCC 4.0+
 328 WX_DECLARE_STRING_HASH_MAP_WITH_DECL(void*,
 329                                      wxPGHashMapS2P,
 330                                      class WXDLLIMPEXP_PROPGRID);
 331
 332
 333 WX_DECLARE_VOIDPTR_HASH_MAP_WITH_DECL(void*,
 334                                       wxPGHashMapP2P,
 335                                       class WXDLLIMPEXP_PROPGRID);
 336
 337 WX_DECLARE_HASH_MAP_WITH_DECL(wxInt32,
 338                               wxInt32,
 339                               wxIntegerHash,
 340                               wxIntegerEqual,
 341                               wxPGHashMapI2I,
 342                               class WXDLLIMPEXP_PROPGRID);
 343
 344 #endif // #ifndef SWIG
 345
 346 // -----------------------------------------------------------------------
 347
 348 enum wxPG_GETPROPERTYVALUES_FLAGS
 349 {
 350
 351 /** Flags for wxPropertyGridInterface::GetPropertyValues */
 352 wxPG_KEEP_STRUCTURE               = 0x00000010,
 353
 354 /** Flags for wxPropertyGrid::SetPropertyAttribute() etc */
 355 wxPG_RECURSE                      = 0x00000020,
 356
 357 /** Include attributes for GetPropertyValues. */
 358 wxPG_INC_ATTRIBUTES               = 0x00000040,
 359
 360 /** Used when first starting recursion. */
 361 wxPG_RECURSE_STARTS               = 0x00000080,
 362
 363 /** Force value change. */
 364 wxPG_FORCE                        = 0x00000100
 365
 366 };
 367
 368 /** Flags for wxPropertyGrid::SetPropertyAttribute() etc */
 369 #define wxPG_DONT_RECURSE         0x00000000
 370
 371 // -----------------------------------------------------------------------
 372
 373 // Misc argument flags.
 374 enum wxPG_MISC_ARG_FLAGS
 375 {
 376     // Get/Store full value instead of displayed value.
 377     wxPG_FULL_VALUE                     = 0x00000001,
 378
 379     wxPG_REPORT_ERROR                   = 0x00000002,
 380
 381     wxPG_PROPERTY_SPECIFIC              = 0x00000004,
 382
 383     // Get/Store editable value instead of displayed one (should only be
 384     // different in the case of common values)
 385     wxPG_EDITABLE_VALUE                 = 0x00000008,
 386
 387     // Used when dealing with fragments of composite string value
 388     wxPG_COMPOSITE_FRAGMENT             = 0x00000010,
 389
 390     // Means property for which final string value is for can not really be
 391     // edited.
 392     wxPG_UNEDITABLE_COMPOSITE_FRAGMENT  = 0x00000020
 393 };
 394
 395 // -----------------------------------------------------------------------
 396
 397 // wxPGProperty::SetValue() flags
 398 enum wxPG_SETVALUE_FLAGS
 399 {
 400     wxPG_SETVAL_REFRESH_EDITOR      = 0x0001,
 401     wxPG_SETVAL_AGGREGATED          = 0x0002,
 402     wxPG_SETVAL_FROM_PARENT         = 0x0004
 403 };
 404
 405 // -----------------------------------------------------------------------
 406
 407 //
 408 // Valid constants for wxPG_UINT_BASE attribute
 409 // (long because of wxVariant constructor)
 410 #define wxPG_BASE_OCT                       (long)8
 411 #define wxPG_BASE_DEC                       (long)10
 412 #define wxPG_BASE_HEX                       (long)16
 413 #define wxPG_BASE_HEXL                      (long)32
 414
 415 //
 416 // Valid constants for wxPG_UINT_PREFIX attribute
 417 #define wxPG_PREFIX_NONE                    (long)0
 418 #define wxPG_PREFIX_0x                      (long)1
 419 #define wxPG_PREFIX_DOLLAR_SIGN             (long)2
 420
 421 // -----------------------------------------------------------------------
 422 // Editor class.
 423
 424 #ifndef SWIG
 425
 426 // Editor accessor.
 427 #define wxPG_EDITOR(T)          wxPGEditor_##T
 428
 429 // Declare editor class, with optional part.
 430 #define WX_PG_DECLARE_EDITOR_WITH_DECL(EDITOR,DECL) \
 431 extern DECL wxPGEditor* wxPGEditor_##EDITOR; \
 432 extern DECL wxPGEditor* wxPGConstruct##EDITOR##EditorClass();
 433
 434 // Declare editor class.
 435 #define WX_PG_DECLARE_EDITOR(EDITOR) \
 436 extern wxPGEditor* wxPGEditor_##EDITOR; \
 437 extern wxPGEditor* wxPGConstruct##EDITOR##EditorClass();
 438
 439 // Declare builtin editor classes.
 440 WX_PG_DECLARE_EDITOR_WITH_DECL(TextCtrl,WXDLLIMPEXP_PROPGRID)
 441 WX_PG_DECLARE_EDITOR_WITH_DECL(Choice,WXDLLIMPEXP_PROPGRID)
 442 WX_PG_DECLARE_EDITOR_WITH_DECL(ComboBox,WXDLLIMPEXP_PROPGRID)
 443 WX_PG_DECLARE_EDITOR_WITH_DECL(TextCtrlAndButton,WXDLLIMPEXP_PROPGRID)
 444 #if wxPG_INCLUDE_CHECKBOX
 445 WX_PG_DECLARE_EDITOR_WITH_DECL(CheckBox,WXDLLIMPEXP_PROPGRID)
 446 #endif
 447 WX_PG_DECLARE_EDITOR_WITH_DECL(ChoiceAndButton,WXDLLIMPEXP_PROPGRID)
 448
 449 #endif  // !SWIG
 450
 451 // -----------------------------------------------------------------------
 452
 453 #ifndef SWIG
 454
 455 /** @class wxPGVariantData
 456     @ingroup classes
 457     wxVariantData with additional functionality.
 458
 459     It is usually enough to use supplied to macros to automatically generate
 460     variant data class. Like so:
 461
 462     @code
 463
 464     // In header
 465     WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataMyClass,  // Name of the class
 466                                MyClass,  // Name of the data type
 467                                wxEMPTY_PARAMETER_VALUE)  // Declaration
 468
 469     // In source
 470     WX_PG_IMPLEMENT_VARIANT_DATA(wxPGVariantDataMyClass, MyClass)
 471
 472     @endcode
 473
 474     If your class is derived from wxObject, it is recommended that you use
 475     wxObject-versions of the macros (WX_PG_DECLARE_WXOBJECT_VARIANT_DATA and
 476     WX_PG_IMPLEMENT_WXOBJECT_VARIANT_DATA).
 477
 478 */
 479 class WXDLLIMPEXP_PROPGRID wxPGVariantData : public wxVariantData
 480 {
 481 public:
 482     virtual void* GetValuePtr() = 0;
 483     virtual wxVariant GetDefaultValue() const = 0;
 484 protected:
 485 };
 486
 487
 488 //
 489 // With wxWidgets 2.9 and later we demand native C++ RTTI support
 490 #ifdef wxNO_RTTI
 491     #error "You need to enable compiler RTTI support for wxPropertyGrid"
 492 #endif
 493 #define WX_PG_DECLARE_DYNAMIC_CLASS_VARIANTDATA(A)
 494 #define WX_PG_IMPLEMENT_DYNAMIC_CLASS_VARIANTDATA(A, B)
 495 typedef const std::type_info* wxPGVariantDataClassInfo;
 496 #define wxPGVariantDataGetClassInfo(A) (&typeid(*A))
 497 #define wxPG_VARIANT_EQ(A, B) \
 498     ( ((A).GetData() && \
 499        (B).GetData() && typeid(*(A).GetData()) == typeid(*(B).GetData()) && \
 500        (A == B)) || !((A).GetData() && (B).GetData()) )
 501
 502 #ifndef wxDynamicCastVariantData
 503     #define wxDynamicCastVariantData wxDynamicCast
 504 #endif
 505
 506
 507 inline void wxPGDoesNothing() {}
 508
 509
 510 #define _WX_PG_IMPLEMENT_VARIANT_DATA_CLASS(CLASSNAME, \
 511                                             DATATYPE, \
 512                                             AS_ARG, \
 513                                             AS_ARG_CONST, \
 514                                             CTOR_CODE, \
 515                                             DEFAULT_VALUE, \
 516                                             SET_CODE) \
 517     WX_PG_DECLARE_DYNAMIC_CLASS_VARIANTDATA(CLASSNAME) \
 518 protected: \
 519     DATATYPE m_value; \
 520 public: \
 521     CLASSNAME() { CTOR_CODE; } \
 522     CLASSNAME(AS_ARG_CONST value) { CTOR_CODE; SET_CODE; m_value = value; } \
 523     DATATYPE GetValue() const { return m_value; } \
 524     AS_ARG_CONST GetValueRef() const { return m_value; } \
 525     AS_ARG GetValueRef() { return m_value; } \
 526     void SetValue(AS_ARG_CONST value) { SET_CODE; m_value = value; } \
 527     virtual bool Eq(wxVariantData&) const { return false; } \
 528     virtual wxString GetType() const { return wxS(#DATATYPE); } \
 529     virtual wxVariantData* Clone() { return new CLASSNAME; } \
 530     virtual bool Read(wxString &) { return false; } \
 531     virtual bool Write(wxString &) const { return true; } \
 532     virtual wxVariant GetDefaultValue() const { return DEFAULT_VALUE; }
 533
 534 //
 535 // Macro WXVARIANT allows creation of wxVariant from any type supported by
 536 // wxWidgets internally, and of all types created using
 537 // WX_PG_DECLARE_VARIANT_DATA.
 538 template<class T>
 539 wxVariant WXVARIANT( const T& value )
 540 {
 541     return wxVariant((void*)&value);
 542 }
 543
 544 template<> inline wxVariant WXVARIANT( const int& value )
 545     { return wxVariant((long)value); }
 546 template<> inline wxVariant WXVARIANT( const long& value )
 547     { return wxVariant(value); }
 548 template<> inline wxVariant WXVARIANT( const bool& value )
 549     { return wxVariant(value); }
 550 template<> inline wxVariant WXVARIANT( const double& value )
 551     { return wxVariant(value); }
 552 template<> inline wxVariant WXVARIANT( const wxArrayString& value )
 553     { return wxVariant(value); }
 554 template<> inline wxVariant WXVARIANT( const wxString& value )
 555     { return wxVariant(value); }
 556 #if wxUSE_DATETIME
 557 template<> inline wxVariant WXVARIANT( const wxDateTime& value )
 558     { return wxVariant(value); }
 559 #endif
 560
 561 #define _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER_DECL(CLASSNAME) \
 562     extern int CLASSNAME##_d_;
 563 #define _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER(CLASSNAME) \
 564     int CLASSNAME##_d_;
 565
 566 #define _WX_PG_IMPLEMENT_VARIANT_DATA(CLASSNAME, \
 567                                       DATATYPE, \
 568                                       AS_ARG, \
 569                                       AS_CONST_ARG, \
 570                                       NULLVAL, \
 571                                       BASECLASS) \
 572 _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER(CLASSNAME) \
 573 WX_PG_IMPLEMENT_DYNAMIC_CLASS_VARIANTDATA(CLASSNAME, BASECLASS) \
 574 AS_ARG operator <<( AS_ARG value, const wxVariant &variant ) \
 575 { \
 576     CLASSNAME *data = wxDynamicCastVariantData( variant.GetData(), CLASSNAME ); \
 577     wxASSERT( data ); \
 578     value = data->GetValue(); \
 579     return value; \
 580 } \
 581 wxVariant& operator <<( wxVariant &variant, AS_CONST_ARG value ) \
 582 { \
 583     CLASSNAME *data = new CLASSNAME( value ); \
 584     variant.SetData( data ); \
 585     return variant; \
 586 } \
 587 AS_ARG DATATYPE##FromVariant( const wxVariant& v ) \
 588 { \
 589     CLASSNAME *data = wxDynamicCastVariantData( v.GetData(), CLASSNAME ); \
 590     if ( !data ) \
 591         return NULLVAL; \
 592     return data->GetValueRef(); \
 593 } \
 594 wxVariant DATATYPE##ToVariant( AS_CONST_ARG value ) \
 595 { \
 596     wxVariant variant( new CLASSNAME( value ) ); \
 597     return variant; \
 598 }
 599
 600 #define WX_PG_IMPLEMENT_VARIANT_DATA(CLASSNAME, DATATYPE) \
 601 class CLASSNAME : public wxPGVariantData \
 602 { \
 603 _WX_PG_IMPLEMENT_VARIANT_DATA_CLASS(CLASSNAME, DATATYPE, DATATYPE&, \
 604                                     const DATATYPE&, wxPGDoesNothing(), \
 605                                     wxVariant(new CLASSNAME(DATATYPE())), \
 606                                     wxPGDoesNothing()) \
 607 public: \
 608     virtual void* GetValuePtr() { return (void*)&m_value; } \
 609 }; \
 610 _WX_PG_IMPLEMENT_VARIANT_DATA(CLASSNAME, \
 611                               DATATYPE, \
 612                               DATATYPE&, \
 613                               const DATATYPE&, \
 614                               (DATATYPE&)*((DATATYPE*)NULL), \
 615                               wxPGVariantData)
 616
 617 #define WX_PG_IMPLEMENT_WXOBJECT_VARIANT_DATA(CLASSNAME, DATATYPE) \
 618 class CLASSNAME : public wxPGVariantData \
 619 { \
 620 _WX_PG_IMPLEMENT_VARIANT_DATA_CLASS(CLASSNAME, DATATYPE, DATATYPE&, \
 621                                     const DATATYPE&, wxPGDoesNothing(), \
 622                                     wxVariant(new CLASSNAME(DATATYPE())), \
 623                                     wxPGDoesNothing()) \
 624 public: \
 625     virtual void* GetValuePtr() { return (void*)&m_value; } \
 626     virtual wxClassInfo* GetValueClassInfo() \
 627         { return m_value.GetClassInfo(); } \
 628 }; \
 629 _WX_PG_IMPLEMENT_VARIANT_DATA(CLASSNAME, DATATYPE, DATATYPE&, \
 630                               const DATATYPE&, \
 631                               (DATATYPE&)*((DATATYPE*)NULL), \
 632                               wxPGVariantData)
 633
 634
 635 #define WX_PG_DECLARE_VARIANT_DATA(CLASSNAME, DATATYPE, DECL) \
 636 DECL DATATYPE& operator <<( DATATYPE& value, const wxVariant &variant ); \
 637 DECL wxVariant& operator <<( wxVariant &variant, const DATATYPE& value ); \
 638 DECL DATATYPE& DATATYPE##FromVariant( const wxVariant& variant ); \
 639 DECL wxVariant DATATYPE##ToVariant( const DATATYPE& value ); \
 640 template<> inline wxVariant WXVARIANT( const DATATYPE& value ) \
 641     { return DATATYPE##ToVariant(value); } \
 642 DECL _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER_DECL(CLASSNAME);
 643
 644 #define WX_PG_DECLARE_WXOBJECT_VARIANT_DATA WX_PG_DECLARE_VARIANT_DATA
 645
 646 #define WX_PG_DECLARE_PTR_VARIANT_DATA(CLASSNAME, DATATYPE, DECL) \
 647 DECL DATATYPE* operator <<( DATATYPE* value, const wxVariant &variant ); \
 648 DECL wxVariant& operator <<( wxVariant &variant, DATATYPE* value ); \
 649 DECL DATATYPE* DATATYPE##FromVariant( const wxVariant& variant ); \
 650 DECL wxVariant DATATYPE##ToVariant( DATATYPE* value ); \
 651 DECL _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER_DECL(CLASSNAME);
 652
 653
 654 #define WX_PG_IMPLEMENT_PTR_VARIANT_DATA(CLASSNAME, DATATYPE, DEFAULT) \
 655 class CLASSNAME : public wxPGVariantData \
 656 { \
 657 _WX_PG_IMPLEMENT_VARIANT_DATA_CLASS(CLASSNAME, DATATYPE*, DATATYPE*, \
 658                                     DATATYPE*, m_value = NULL, \
 659                                     DEFAULT, \
 660                                     if (m_value) Py_DECREF(m_value); \
 661                                     if (!value) value = Py_None; \
 662                                     Py_INCREF(value) ) \
 663     ~CLASSNAME() { if (m_value) Py_DECREF(m_value); } \
 664 public: \
 665     virtual void* GetValuePtr() { return (void*)m_value; } \
 666 }; \
 667 _WX_PG_IMPLEMENT_VARIANT_DATA(CLASSNAME, DATATYPE, DATATYPE*, DATATYPE*, \
 668                               NULL, wxPGVariantData)
 669
 670
 671 WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataPoint, wxPoint, WXDLLIMPEXP_PROPGRID)
 672 WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataSize, wxSize, WXDLLIMPEXP_PROPGRID)
 673 WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataArrayInt,
 674                            wxArrayInt, WXDLLIMPEXP_PROPGRID)
 675 WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataLongLong,
 676                            wxLongLong, WXDLLIMPEXP_PROPGRID)
 677 WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataULongLong,
 678                            wxULongLong, WXDLLIMPEXP_PROPGRID)
 679
 680 WX_PG_DECLARE_WXOBJECT_VARIANT_DATA(wxPGVariantDataFont,
 681                                     wxFont, WXDLLIMPEXP_PROPGRID)
 682 template<> inline wxVariant WXVARIANT( const wxColour& value )
 683 {
 684     wxVariant variant;
 685     variant << value;
 686     return variant;
 687 }
 688
 689 #define WX_PG_VARIANT_GETVALUEREF(P, T) \
 690     (*((T*)((wxPGVariantData*)(P.GetData()))->GetValuePtr()))
 691
 692 // Safely converts a wxVariant to (long) int. Supports converting from string
 693 // and boolean as well.
 694 WXDLLIMPEXP_PROPGRID
 695 long wxPGVariantToInt( const wxVariant& variant, long defVal = 1 );
 696
 697 // Safely converts a wxVariant to wxLongLong_t. Returns true on success.
 698 WXDLLIMPEXP_PROPGRID
 699 bool wxPGVariantToLongLong( const wxVariant& variant, wxLongLong_t* pResult );
 700
 701 // Safely converts a wxVariant to wxULongLong_t. Returns true on success.
 702 WXDLLIMPEXP_PROPGRID
 703 bool wxPGVariantToULongLong( const wxVariant& variant, wxULongLong_t* pResult );
 704
 705 // Safely converts a wxVariant to double. Supports converting from string and
 706 // wxLongLong as well.
 707 WXDLLIMPEXP_PROPGRID
 708 bool wxPGVariantToDouble( const wxVariant& variant, double* pResult );
 709
 710 #endif // !SWIG
 711
 712 // -----------------------------------------------------------------------
 713
 714 #ifndef SWIG
 715
 716 WXDLLIMPEXP_PROPGRID
 717 wxObject*
 718 wxPG_VariantToWxObject( const wxVariant& variant, wxClassInfo* classInfo );
 719
 720 //
 721 // Redefine wxGetVariantCast to also take propertygrid variantdata
 722 // classes into account.
 723 //
 724 #undef wxGetVariantCast
 725 #define wxGetVariantCast(var,classname) \
 726     (classname*)wxPG_VariantToWxObject(var,&classname::ms_classInfo)
 727
 728 // TODO: After a while, remove this.
 729 #define WX_PG_VARIANT_TO_WXOBJECT(VARIANT,CLASSNAME) \
 730     (CLASSNAME*)wxPG_VariantToWxObject(VARIANT,&CLASSNAME::ms_classInfo)
 731
 732 #endif // !SWIG
 733
 734 // -----------------------------------------------------------------------
 735
 736 #ifndef SWIG
 737
 738 //
 739 // Tokenizer macros.
 740 // NOTE: I have made two versions - worse ones (performance and consistency
 741 //   wise) use wxStringTokenizer and better ones (may have unfound bugs)
 742 //   use custom code.
 743 //
 744
 745 #include "wx/tokenzr.h"
 746
 747 // TOKENIZER1 can be done with wxStringTokenizer
 748 #define WX_PG_TOKENIZER1_BEGIN(WXSTRING,DELIMITER) \
 749     wxStringTokenizer tkz(WXSTRING,DELIMITER,wxTOKEN_RET_EMPTY); \
 750     while ( tkz.HasMoreTokens() ) \
 751     { \
 752         wxString token = tkz.GetNextToken(); \
 753         token.Trim(true); \
 754         token.Trim(false);
 755
 756 #define WX_PG_TOKENIZER1_END() \
 757     }
 758
 759
 760 //
 761 // 2nd version: tokens are surrounded by DELIMITERs (for example, C-style
 762 // strings). TOKENIZER2 must use custom code (a class) for full compliance with
 763 // " surrounded strings with \" inside.
 764 //
 765 // class implementation is in propgrid.cpp
 766 //
 767
 768 class WXDLLIMPEXP_PROPGRID wxPGStringTokenizer
 769 {
 770 public:
 771     wxPGStringTokenizer( const wxString& str, wxChar delimeter );
 772     ~wxPGStringTokenizer();
 773
 774     bool HasMoreTokens(); // not const so we can do some stuff in it
 775     wxString GetNextToken();
 776
 777 protected:
 778     const wxString*             m_str;
 779     wxString::const_iterator    m_curPos;
 780     wxString                    m_readyToken;
 781     wxUniChar                   m_delimeter;
 782 };
 783
 784 #define WX_PG_TOKENIZER2_BEGIN(WXSTRING,DELIMITER) \
 785     wxPGStringTokenizer tkz(WXSTRING,DELIMITER); \
 786     while ( tkz.HasMoreTokens() ) \
 787     { \
 788         wxString token = tkz.GetNextToken();
 789
 790 #define WX_PG_TOKENIZER2_END() \
 791     }
 792
 793 #endif
 794
 795 // -----------------------------------------------------------------------
 796
 797 #endif // _WX_PROPGRID_PROPGRIDDEFS_H_