include/wx/propgrid/props.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/propgrid/props.h
   3 // Purpose:     wxPropertyGrid Property Classes
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2007-03-28
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Jaakko Salli
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_PROPGRID_PROPS_H_
  13 #define _WX_PROPGRID_PROPS_H_
  14
  15 #if wxUSE_PROPGRID
  16
  17 // -----------------------------------------------------------------------
  18
  19 class wxArrayEditorDialog;
  20
  21 #include "wx/propgrid/editors.h"
  22
  23 #include "wx/filename.h"
  24 #include "wx/dialog.h"
  25 #include "wx/textctrl.h"
  26 #include "wx/button.h"
  27 #include "wx/listbox.h"
  28
  29 // -----------------------------------------------------------------------
  30
  31 //
  32 // Property class implementation helper macros.
  33 //
  34
  35 #define WX_PG_IMPLEMENT_PROPERTY_CLASS(NAME, UPCLASS, T, T_AS_ARG, EDITOR) \
  36 IMPLEMENT_DYNAMIC_CLASS(NAME, UPCLASS) \
  37 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(NAME, T, EDITOR)
  38
  39 // -----------------------------------------------------------------------
  40
  41 //
  42 // These macros help creating DoGetValidator
  43 #define WX_PG_DOGETVALIDATOR_ENTRY() \
  44     static wxValidator* s_ptr = NULL; \
  45     if ( s_ptr ) return s_ptr;
  46
  47 // Common function exit
  48 #define WX_PG_DOGETVALIDATOR_EXIT(VALIDATOR) \
  49     s_ptr = VALIDATOR; \
  50     wxPGGlobalVars->m_arrValidators.push_back( VALIDATOR ); \
  51     return VALIDATOR;
  52
  53 // -----------------------------------------------------------------------
  54
  55 #ifndef SWIG
  56
  57 /** @class wxPGInDialogValidator
  58     @ingroup classes
  59     Creates and manages a temporary wxTextCtrl for validation purposes.
  60     Uses wxPropertyGrid's current editor, if available.
  61 */
  62 class WXDLLIMPEXP_PROPGRID wxPGInDialogValidator
  63 {
  64 public:
  65     wxPGInDialogValidator()
  66     {
  67         m_textCtrl = NULL;
  68     }
  69
  70     ~wxPGInDialogValidator()
  71     {
  72         if ( m_textCtrl )
  73             m_textCtrl->Destroy();
  74     }
  75
  76     bool DoValidate( wxPropertyGrid* propGrid,
  77                      wxValidator* validator,
  78                      const wxString& value );
  79
  80 private:
  81     wxTextCtrl*         m_textCtrl;
  82 };
  83
  84 #endif  // SWIG
  85
  86
  87 // -----------------------------------------------------------------------
  88 // Property classes
  89 // -----------------------------------------------------------------------
  90
  91 #define wxPG_PROP_PASSWORD  wxPG_PROP_CLASS_SPECIFIC_2
  92
  93 /** @class wxStringProperty
  94     @ingroup classes
  95     Basic property with string value.
  96
  97     <b>Supported special attributes:</b>
  98     - "Password": set to 1 inorder to enable wxTE_PASSWORD on the editor.
  99
 100     @remarks
 101     - If value "<composed>" is set, then actual value is formed (or composed)
 102       from values of child properties.
 103 */
 104 class WXDLLIMPEXP_PROPGRID wxStringProperty : public wxPGProperty
 105 {
 106     WX_PG_DECLARE_PROPERTY_CLASS(wxStringProperty)
 107 public:
 108     wxStringProperty( const wxString& label = wxPG_LABEL,
 109                       const wxString& name = wxPG_LABEL,
 110                       const wxString& value = wxEmptyString );
 111     virtual ~wxStringProperty();
 112
 113     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 114     virtual bool StringToValue( wxVariant& variant,
 115                                 const wxString& text,
 116                                 int argFlags = 0 ) const;
 117
 118     virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
 119
 120     /** This is updated so "<composed>" special value can be handled.
 121     */
 122     virtual void OnSetValue();
 123
 124 protected:
 125 };
 126
 127 // -----------------------------------------------------------------------
 128
 129 #ifndef SWIG
 130 /** Constants used with DoValidation() methods.
 131 */
 132 enum
 133 {
 134     /** Instead of modifying the value, show an error message.
 135     */
 136     wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE      = 0,
 137
 138     /** Modify value, but stick with the limitations.
 139     */
 140     wxPG_PROPERTY_VALIDATION_SATURATE           = 1,
 141
 142     /** Modify value, wrap around on overflow.
 143     */
 144     wxPG_PROPERTY_VALIDATION_WRAP               = 2
 145 };
 146 #endif
 147
 148 // -----------------------------------------------------------------------
 149
 150 /** @class wxIntProperty
 151     @ingroup classes
 152     Basic property with integer value.
 153
 154     Seamlessly supports 64-bit integer (wxLongLong) on overflow.
 155
 156     <b>Example how to use seamless 64-bit integer support</b>
 157
 158       Getting value:
 159
 160       @code
 161           wxLongLong_t value = pg->GetPropertyValueAsLongLong();
 162       @endcode
 163
 164          or
 165
 166       @code
 167           wxLongLong_t value;
 168           wxVariant variant = property->GetValue();
 169           if ( variant.GetType() == "wxLongLong" )
 170               value = wxLongLongFromVariant(variant);
 171           else
 172               value = variant.GetLong();
 173       @endcode
 174
 175       Setting value:
 176
 177        @code
 178           pg->SetPropertyValue(longLongVal);
 179       @endcode
 180
 181          or
 182
 183       @code
 184           property->SetValue(WXVARIANT(longLongVal));
 185       @endcode
 186
 187
 188     <b>Supported special attributes:</b>
 189     - "Min", "Max": Specify acceptable value range.
 190 */
 191 class WXDLLIMPEXP_PROPGRID wxIntProperty : public wxPGProperty
 192 {
 193     WX_PG_DECLARE_PROPERTY_CLASS(wxIntProperty)
 194 public:
 195     wxIntProperty( const wxString& label = wxPG_LABEL,
 196                    const wxString& name = wxPG_LABEL,
 197                    long value = 0 );
 198     virtual ~wxIntProperty();
 199
 200     wxIntProperty( const wxString& label,
 201                    const wxString& name,
 202                    const wxLongLong& value );
 203     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 204     virtual bool StringToValue( wxVariant& variant,
 205                                 const wxString& text,
 206                                 int argFlags = 0 ) const;
 207     virtual bool ValidateValue( wxVariant& value,
 208                                 wxPGValidationInfo& validationInfo ) const;
 209     virtual bool IntToValue( wxVariant& variant,
 210                              int number,
 211                              int argFlags = 0 ) const;
 212     static wxValidator* GetClassValidator();
 213     virtual wxValidator* DoGetValidator() const;
 214
 215     /** Validation helper.
 216     */
 217     static bool DoValidation( const wxPGProperty* property,
 218                               wxLongLong_t& value,
 219                               wxPGValidationInfo* pValidationInfo,
 220                               int mode =
 221                                 wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE );
 222
 223 protected:
 224 };
 225
 226 // -----------------------------------------------------------------------
 227
 228 /** @class wxUIntProperty
 229     @ingroup classes
 230     Basic property with unsigned integer value.
 231     Seamlessly supports 64-bit integer (wxULongLong) on overflow.
 232
 233     <b>Supported special attributes:</b>
 234     - "Min", "Max": Specify acceptable value range.
 235     - "Base": Define base. Valid constants are wxPG_BASE_OCT, wxPG_BASE_DEC,
 236     wxPG_BASE_HEX and wxPG_BASE_HEXL (lowercase characters). Arbitrary bases
 237     are <b>not</b> supported.
 238     - "Prefix": Possible values are wxPG_PREFIX_NONE, wxPG_PREFIX_0x, and
 239     wxPG_PREFIX_DOLLAR_SIGN. Only wxPG_PREFIX_NONE works with Decimal and Octal
 240     numbers.
 241
 242     @remarks
 243     - For example how to use seamless 64-bit integer support, see wxIntProperty
 244     documentation (just use wxULongLong instead of wxLongLong).
 245 */
 246 class WXDLLIMPEXP_PROPGRID wxUIntProperty : public wxPGProperty
 247 {
 248     WX_PG_DECLARE_PROPERTY_CLASS(wxUIntProperty)
 249 public:
 250     wxUIntProperty( const wxString& label = wxPG_LABEL,
 251                     const wxString& name = wxPG_LABEL,
 252                     unsigned long value = 0 );
 253     virtual ~wxUIntProperty();
 254     wxUIntProperty( const wxString& label,
 255                     const wxString& name,
 256                     const wxULongLong& value );
 257     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 258     virtual bool StringToValue( wxVariant& variant,
 259                                 const wxString& text,
 260                                 int argFlags = 0 ) const;
 261     virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
 262     virtual bool ValidateValue( wxVariant& value,
 263                                 wxPGValidationInfo& validationInfo ) const;
 264     virtual bool IntToValue( wxVariant& variant,
 265                              int number,
 266                              int argFlags = 0 ) const;
 267 protected:
 268     wxByte      m_base;
 269     wxByte      m_realBase; // translated to 8,16,etc.
 270     wxByte      m_prefix;
 271 private:
 272     void Init();
 273 };
 274
 275 // -----------------------------------------------------------------------
 276
 277 /** @class wxFloatProperty
 278     @ingroup classes
 279     Basic property with double-precision floating point value.
 280
 281     <b>Supported special attributes:</b>
 282     - "Precision": Sets the (max) precision used when floating point value is
 283     rendered as text. The default -1 means infinite precision.
 284 */
 285 class WXDLLIMPEXP_PROPGRID wxFloatProperty : public wxPGProperty
 286 {
 287     WX_PG_DECLARE_PROPERTY_CLASS(wxFloatProperty)
 288 public:
 289     wxFloatProperty( const wxString& label = wxPG_LABEL,
 290                      const wxString& name = wxPG_LABEL,
 291                      double value = 0.0 );
 292     virtual ~wxFloatProperty();
 293
 294     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 295     virtual bool StringToValue( wxVariant& variant,
 296                                 const wxString& text,
 297                                 int argFlags = 0 ) const;
 298     virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
 299     virtual bool ValidateValue( wxVariant& value,
 300                                 wxPGValidationInfo& validationInfo ) const;
 301
 302     /** Validation helper.
 303     */
 304     static bool DoValidation( const wxPGProperty* property,
 305                               double& value,
 306                               wxPGValidationInfo* pValidationInfo,
 307                               int mode =
 308                                  wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE );
 309     virtual wxValidator* DoGetValidator () const;
 310
 311 protected:
 312     int m_precision;
 313 };
 314
 315 // -----------------------------------------------------------------------
 316
 317 // Exclude class from wxPython bindings
 318 #ifndef SWIG
 319
 320 /** @class wxBoolProperty
 321     @ingroup classes
 322     Basic property with boolean value.
 323
 324     <b>Supported special attributes:</b>
 325     - "UseCheckbox": Set to 1 to use check box editor instead of combo box.
 326     - "UseDClickCycling": Set to 1 to cycle combo box instead showing the list.
 327 */
 328 class WXDLLIMPEXP_PROPGRID wxBoolProperty : public wxPGProperty
 329 {
 330     WX_PG_DECLARE_PROPERTY_CLASS(wxBoolProperty)
 331 public:
 332     wxBoolProperty( const wxString& label = wxPG_LABEL,
 333                     const wxString& name = wxPG_LABEL,
 334                     bool value = false );
 335     virtual ~wxBoolProperty();
 336
 337     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 338     virtual bool StringToValue( wxVariant& variant,
 339                                 const wxString& text,
 340                                 int argFlags = 0 ) const;
 341     virtual bool IntToValue( wxVariant& variant,
 342                              int number, int argFlags = 0 ) const;
 343     virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
 344 };
 345
 346 #endif  // !SWIG
 347
 348 // -----------------------------------------------------------------------
 349
 350 // If set, then selection of choices is static and should not be
 351 // changed (i.e. returns NULL in GetPropertyChoices).
 352 #define wxPG_PROP_STATIC_CHOICES    wxPG_PROP_CLASS_SPECIFIC_1
 353
 354 /** @class wxEnumProperty
 355     @ingroup classes
 356     You can derive custom properties with choices from this class. See
 357     wxBaseEnumProperty for remarks.
 358
 359     @remarks
 360     - Updating private index is important. You can do this either by calling
 361     SetIndex() in IntToValue, and then letting wxBaseEnumProperty::OnSetValue
 362     be called (by not implementing it, or by calling super class function in
 363     it) -OR- you can just call SetIndex in OnSetValue.
 364 */
 365 class WXDLLIMPEXP_PROPGRID wxEnumProperty : public wxPGProperty
 366 {
 367     WX_PG_DECLARE_PROPERTY_CLASS(wxEnumProperty)
 368 public:
 369
 370 #ifndef SWIG
 371     wxEnumProperty( const wxString& label = wxPG_LABEL,
 372                     const wxString& name = wxPG_LABEL,
 373                     const wxChar** labels = NULL,
 374                     const long* values = NULL,
 375                     int value = 0 );
 376     wxEnumProperty( const wxString& label,
 377                     const wxString& name,
 378                     wxPGChoices& choices,
 379                     int value = 0 );
 380
 381     // Special constructor for caching choices (used by derived class)
 382     wxEnumProperty( const wxString& label,
 383                     const wxString& name,
 384                     const wxChar** labels,
 385                     const long* values,
 386                     wxPGChoices* choicesCache,
 387                     int value = 0 );
 388
 389     wxEnumProperty( const wxString& label,
 390                     const wxString& name,
 391                     const wxArrayString& labels,
 392                     const wxArrayInt& values = wxArrayInt(),
 393                     int value = 0 );
 394 #else
 395     wxEnumProperty( const wxString& label = wxPG_LABEL,
 396                     const wxString& name = wxPG_LABEL,
 397                     const wxArrayString& labels = wxArrayString(),
 398                     const wxArrayInt& values = wxArrayInt(),
 399                     int value = 0 );
 400 #endif
 401
 402     virtual ~wxEnumProperty();
 403
 404     size_t GetItemCount() const { return m_choices.GetCount(); }
 405
 406     virtual void OnSetValue();
 407     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 408     virtual bool StringToValue( wxVariant& variant,
 409                                 const wxString& text,
 410                                 int argFlags = 0 ) const;
 411     virtual bool ValidateValue( wxVariant& value,
 412                                 wxPGValidationInfo& validationInfo ) const;
 413
 414     // If wxPG_FULL_VALUE is not set in flags, then the value is interpreted
 415     // as index to choices list. Otherwise, it is actual value.
 416     virtual bool IntToValue( wxVariant& variant,
 417                              int number,
 418                              int argFlags = 0 ) const;
 419
 420     //
 421     // Additional virtuals
 422
 423     // This must be overridden to have non-index based value
 424     virtual int GetIndexForValue( int value ) const;
 425
 426     // GetChoiceSelection needs to overridden since m_index is
 427     // the true index, and various property classes derived from
 428     // this take advantage of it.
 429     virtual int GetChoiceSelection() const { return m_index; }
 430
 431     virtual void OnValidationFailure( wxVariant& pendingValue );
 432
 433 protected:
 434
 435     int GetIndex() const;
 436     void SetIndex( int index );
 437
 438     bool ValueFromString_( wxVariant& value,
 439                            const wxString& text,
 440                            int argFlags ) const;
 441     bool ValueFromInt_( wxVariant& value, int intVal, int argFlags ) const;
 442
 443     static void ResetNextIndex() { ms_nextIndex = -2; }
 444
 445 private:
 446     // This is private so that classes are guaranteed to use GetIndex
 447     // for up-to-date index value.
 448     int                     m_index;
 449
 450     // Relies on ValidateValue being called always before OnSetValue
 451     static int              ms_nextIndex;
 452     static int              ms_prevIndex;
 453 };
 454
 455 // -----------------------------------------------------------------------
 456
 457 /** @class wxEditEnumProperty
 458     @ingroup classes
 459     wxEnumProperty with wxString value and writable combo box editor.
 460
 461     @remarks
 462     Uses int value, similar to wxEnumProperty, unless text entered by user is
 463     is not in choices (in which case string value is used).
 464 */
 465 class WXDLLIMPEXP_PROPGRID wxEditEnumProperty : public wxEnumProperty
 466 {
 467     WX_PG_DECLARE_PROPERTY_CLASS(wxEditEnumProperty)
 468 public:
 469
 470     wxEditEnumProperty( const wxString& label,
 471                         const wxString& name,
 472                         const wxChar** labels,
 473                         const long* values,
 474                         const wxString& value );
 475     wxEditEnumProperty( const wxString& label = wxPG_LABEL,
 476                         const wxString& name = wxPG_LABEL,
 477                         const wxArrayString& labels = wxArrayString(),
 478                         const wxArrayInt& values = wxArrayInt(),
 479                         const wxString& value = wxEmptyString );
 480     wxEditEnumProperty( const wxString& label,
 481                         const wxString& name,
 482                         wxPGChoices& choices,
 483                         const wxString& value = wxEmptyString );
 484
 485     // Special constructor for caching choices (used by derived class)
 486     wxEditEnumProperty( const wxString& label,
 487                         const wxString& name,
 488                         const wxChar** labels,
 489                         const long* values,
 490                         wxPGChoices* choicesCache,
 491                         const wxString& value );
 492
 493     virtual ~wxEditEnumProperty();
 494
 495 protected:
 496 };
 497
 498 // -----------------------------------------------------------------------
 499
 500 /** @class wxFlagsProperty
 501     @ingroup classes
 502     Represents a bit set that fits in a long integer. wxBoolProperty
 503     sub-properties are created for editing individual bits. Textctrl is created
 504     to manually edit the flags as a text; a continous sequence of spaces,
 505     commas and semicolons is considered as a flag id separator.
 506     <b>Note:</b> When changing "choices" (ie. flag labels) of wxFlagsProperty,
 507     you will need to use SetPropertyChoices - otherwise they will not get
 508     updated properly.
 509 */
 510 class WXDLLIMPEXP_PROPGRID wxFlagsProperty : public wxPGProperty
 511 {
 512     WX_PG_DECLARE_PROPERTY_CLASS(wxFlagsProperty)
 513 public:
 514
 515 #ifndef SWIG
 516     wxFlagsProperty( const wxString& label,
 517                      const wxString& name,
 518                      const wxChar** labels,
 519                      const long* values = NULL,
 520                      long value = 0 );
 521     wxFlagsProperty( const wxString& label,
 522                      const wxString& name,
 523                      wxPGChoices& choices,
 524                      long value = 0 );
 525 #endif
 526     wxFlagsProperty( const wxString& label = wxPG_LABEL,
 527                      const wxString& name = wxPG_LABEL,
 528                      const wxArrayString& labels = wxArrayString(),
 529                      const wxArrayInt& values = wxArrayInt(),
 530                      int value = 0 );
 531     virtual ~wxFlagsProperty ();
 532
 533     virtual void OnSetValue();
 534     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 535     virtual bool StringToValue( wxVariant& variant,
 536                                 const wxString& text,
 537                                 int flags ) const;
 538     virtual void ChildChanged( wxVariant& thisValue,
 539                                int childIndex,
 540                                wxVariant& childValue ) const;
 541     virtual void RefreshChildren();
 542
 543     // GetChoiceSelection needs to overridden since m_choices is
 544     // used and value is integer, but it is not index.
 545     virtual int GetChoiceSelection() const { return wxNOT_FOUND; }
 546
 547     // helpers
 548     size_t GetItemCount() const { return m_choices.GetCount(); }
 549     const wxString& GetLabel( size_t ind ) const
 550         { return m_choices.GetLabel(ind); }
 551
 552 protected:
 553     // Used to detect if choices have been changed
 554     wxPGChoicesData*        m_oldChoicesData;
 555
 556     // Needed to properly mark changed sub-properties
 557     long                    m_oldValue;
 558
 559     // Converts string id to a relevant bit.
 560     long IdToBit( const wxString& id ) const;
 561
 562     // Creates children and sets value.
 563     void Init();
 564 };
 565
 566 // -----------------------------------------------------------------------
 567
 568 /** @class wxPGFileDialogAdapter
 569     @ingroup classes
 570 */
 571 class WXDLLIMPEXP_PROPGRID
 572     wxPGFileDialogAdapter : public wxPGEditorDialogAdapter
 573 {
 574 public:
 575     virtual bool DoShowDialog( wxPropertyGrid* propGrid,
 576                                wxPGProperty* property );
 577 };
 578
 579 // -----------------------------------------------------------------------
 580
 581 // Indicates first bit useable by derived properties.
 582 #define wxPG_PROP_SHOW_FULL_FILENAME  wxPG_PROP_CLASS_SPECIFIC_1
 583
 584 /** @class wxFileProperty
 585     @ingroup classes
 586     Like wxLongStringProperty, but the button triggers file selector instead.
 587
 588     <b>Supported special attributes:</b>
 589     - "Wildcard": Sets wildcard (see wxFileDialog for format details), "All
 590     files..." is default.
 591     - "ShowFullPath": Default 1. When 0, only the file name is shown (i.e. drive
 592       and directory are hidden).
 593     - "ShowRelativePath": If set, then the filename is shown relative to the
 594     given path string.
 595     - "InitialPath": Sets the initial path of where to look for files.
 596     - "DialogTitle": Sets a specific title for the dir dialog.
 597 */
 598 class WXDLLIMPEXP_PROPGRID wxFileProperty : public wxPGProperty
 599 {
 600     friend class wxPGFileDialogAdapter;
 601     WX_PG_DECLARE_PROPERTY_CLASS(wxFileProperty)
 602 public:
 603
 604     wxFileProperty( const wxString& label = wxPG_LABEL,
 605                     const wxString& name = wxPG_LABEL,
 606                     const wxString& value = wxEmptyString );
 607     virtual ~wxFileProperty ();
 608
 609     virtual void OnSetValue();
 610     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 611     virtual bool StringToValue( wxVariant& variant,
 612                                 const wxString& text,
 613                                 int argFlags = 0 ) const;
 614     virtual wxPGEditorDialogAdapter* GetEditorDialog() const;
 615     virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
 616
 617     static wxValidator* GetClassValidator();
 618     virtual wxValidator* DoGetValidator() const;
 619
 620     /**
 621         Returns filename to file represented by current value.
 622     */
 623     wxFileName GetFileName() const;
 624
 625 protected:
 626     wxString    m_wildcard;
 627     wxString    m_basePath; // If set, then show path relative to it
 628     wxString    m_initialPath; // If set, start the file dialog here
 629     wxString    m_dlgTitle; // If set, used as title for file dialog
 630     int         m_indFilter; // index to the selected filter
 631 };
 632
 633 // -----------------------------------------------------------------------
 634
 635 #define wxPG_PROP_NO_ESCAPE     wxPG_PROP_CLASS_SPECIFIC_1
 636
 637
 638 /** @class wxPGLongStringDialogAdapter
 639     @ingroup classes
 640 */
 641 class WXDLLIMPEXP_PROPGRID
 642     wxPGLongStringDialogAdapter : public wxPGEditorDialogAdapter
 643 {
 644 public:
 645     virtual bool DoShowDialog( wxPropertyGrid* propGrid,
 646                                wxPGProperty* property );
 647 };
 648
 649
 650 /** @class wxLongStringProperty
 651     @ingroup classes
 652     Like wxStringProperty, but has a button that triggers a small text
 653     editor dialog.
 654 */
 655 class WXDLLIMPEXP_PROPGRID wxLongStringProperty : public wxPGProperty
 656 {
 657     WX_PG_DECLARE_PROPERTY_CLASS(wxLongStringProperty)
 658 public:
 659
 660     wxLongStringProperty( const wxString& label = wxPG_LABEL,
 661                           const wxString& name = wxPG_LABEL,
 662                           const wxString& value = wxEmptyString );
 663     virtual ~wxLongStringProperty();
 664
 665     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 666     virtual bool StringToValue( wxVariant& variant,
 667                                 const wxString& text,
 668                                 int argFlags = 0 ) const;
 669     virtual bool OnEvent( wxPropertyGrid* propgrid,
 670                           wxWindow* primary, wxEvent& event );
 671
 672     // Shows string editor dialog. Value to be edited should be read from
 673     // value, and if dialog is not cancelled, it should be stored back and true
 674     // should be returned if that was the case.
 675     virtual bool OnButtonClick( wxPropertyGrid* propgrid, wxString& value );
 676
 677     static bool DisplayEditorDialog( wxPGProperty* prop,
 678                                      wxPropertyGrid* propGrid,
 679                                      wxString& value );
 680
 681 protected:
 682 };
 683
 684 // -----------------------------------------------------------------------
 685
 686
 687 // Exclude class from wxPython bindings
 688 #ifndef SWIG
 689
 690 /** @class wxDirProperty
 691     @ingroup classes
 692     Like wxLongStringProperty, but the button triggers dir selector instead.
 693
 694     <b>Supported special attributes:</b>
 695     - "DialogMessage": Sets specific message in the dir selector.
 696 */
 697 class WXDLLIMPEXP_PROPGRID wxDirProperty : public wxLongStringProperty
 698 {
 699 #ifndef SWIG
 700     DECLARE_DYNAMIC_CLASS(wxDirProperty)
 701 #endif
 702 public:
 703     wxDirProperty( const wxString& name = wxPG_LABEL,
 704                    const wxString& label = wxPG_LABEL,
 705                    const wxString& value = wxEmptyString );
 706     virtual ~wxDirProperty();
 707
 708     virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
 709     virtual wxValidator* DoGetValidator() const;
 710
 711     virtual bool OnButtonClick ( wxPropertyGrid* propGrid, wxString& value );
 712
 713 protected:
 714     wxString    m_dlgMessage;
 715 };
 716
 717 #endif  // !SWIG
 718
 719 // -----------------------------------------------------------------------
 720
 721 // wxBoolProperty specific flags
 722 #define wxPG_PROP_USE_CHECKBOX      wxPG_PROP_CLASS_SPECIFIC_1
 723 // DCC = Double Click Cycles
 724 #define wxPG_PROP_USE_DCC           wxPG_PROP_CLASS_SPECIFIC_2
 725
 726
 727 // -----------------------------------------------------------------------
 728
 729 /** @class wxArrayStringProperty
 730     @ingroup classes
 731     Property that manages a list of strings.
 732 */
 733 class WXDLLIMPEXP_PROPGRID wxArrayStringProperty : public wxPGProperty
 734 {
 735     WX_PG_DECLARE_PROPERTY_CLASS(wxArrayStringProperty)
 736 public:
 737
 738     wxArrayStringProperty( const wxString& label = wxPG_LABEL,
 739                            const wxString& name = wxPG_LABEL,
 740                            const wxArrayString& value = wxArrayString() );
 741     virtual ~wxArrayStringProperty();
 742
 743     virtual void OnSetValue();
 744     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 745     virtual bool StringToValue( wxVariant& variant,
 746                                 const wxString& text,
 747                                 int argFlags = 0 ) const;
 748     virtual bool OnEvent( wxPropertyGrid* propgrid,
 749                           wxWindow* primary, wxEvent& event );
 750
 751     virtual void GenerateValueAsString();
 752
 753     // Shows string editor dialog. Value to be edited should be read from
 754     // value, and if dialog is not cancelled, it should be stored back and true
 755     // should be returned if that was the case.
 756     virtual bool OnCustomStringEdit( wxWindow* parent, wxString& value );
 757
 758     // Helper.
 759     virtual bool OnButtonClick( wxPropertyGrid* propgrid,
 760                                 wxWindow* primary,
 761                                 const wxChar* cbt );
 762
 763 #ifndef SWIG
 764     // Creates wxArrayEditorDialog for string editing. Called in OnButtonClick.
 765     virtual wxArrayEditorDialog* CreateEditorDialog();
 766 #endif
 767
 768 protected:
 769     wxString        m_display; // Cache for displayed text.
 770 };
 771
 772 // -----------------------------------------------------------------------
 773
 774 #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR_WITH_DECL(PROPNAME, \
 775                                                                     DECL) \
 776 DECL PROPNAME : public wxArrayStringProperty \
 777 { \
 778     WX_PG_DECLARE_PROPERTY_CLASS(PROPNAME) \
 779 public: \
 780     PROPNAME( const wxString& label = wxPG_LABEL, \
 781               const wxString& name = wxPG_LABEL, \
 782               const wxArrayString& value = wxArrayString() ); \
 783     ~PROPNAME(); \
 784     virtual void GenerateValueAsString(); \
 785     virtual bool StringToValue( wxVariant& value, \
 786                                 const wxString& text, int = 0 ) const; \
 787     virtual bool OnEvent( wxPropertyGrid* propgrid, \
 788                           wxWindow* primary, wxEvent& event ); \
 789     virtual bool OnCustomStringEdit( wxWindow* parent, wxString& value ); \
 790     virtual wxValidator* DoGetValidator() const; \
 791 };
 792
 793 #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAM) \
 794 WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAM, class)
 795
 796 #define WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAME, \
 797                                                             DELIMCHAR, \
 798                                                             CUSTBUTTXT) \
 799 WX_PG_IMPLEMENT_PROPERTY_CLASS(PROPNAME, wxArrayStringProperty, \
 800                                wxArrayString, const wxArrayString&, \
 801                                TextCtrlAndButton) \
 802 PROPNAME::PROPNAME( const wxString& label, \
 803                     const wxString& name, \
 804                     const wxArrayString& value ) \
 805     : wxArrayStringProperty(label,name,value) \
 806 { \
 807     PROPNAME::GenerateValueAsString(); \
 808 } \
 809 PROPNAME::~PROPNAME() { } \
 810 void PROPNAME::GenerateValueAsString() \
 811 { \
 812     wxChar delimChar = DELIMCHAR; \
 813     if ( delimChar == wxS('"') ) \
 814         wxArrayStringProperty::GenerateValueAsString(); \
 815     else \
 816         wxPropertyGrid::ArrayStringToString(m_display, \
 817                                             m_value.GetArrayString(), \
 818                                             0,DELIMCHAR,0); \
 819 } \
 820 bool PROPNAME::StringToValue( wxVariant& variant, \
 821                               const wxString& text, int ) const \
 822 { \
 823     wxChar delimChar = DELIMCHAR; \
 824     if ( delimChar == wxS('"') ) \
 825         return wxArrayStringProperty::StringToValue(variant, text, 0); \
 826     \
 827     wxArrayString arr; \
 828     WX_PG_TOKENIZER1_BEGIN(text,DELIMCHAR) \
 829         arr.Add( token ); \
 830     WX_PG_TOKENIZER1_END() \
 831     variant = arr; \
 832     return true; \
 833 } \
 834 bool PROPNAME::OnEvent( wxPropertyGrid* propgrid, \
 835                         wxWindow* primary, wxEvent& event ) \
 836 { \
 837     if ( event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED ) \
 838         return OnButtonClick(propgrid,primary,(const wxChar*) CUSTBUTTXT); \
 839     return false; \
 840 }
 841
 842 #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY(PROPNAME) \
 843 WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAME)
 844
 845 #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_DECL(PROPNAME, DECL) \
 846 WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR_WITH_DECL(PROPNAME, DECL)
 847
 848 #define WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY(PROPNAME,DELIMCHAR,CUSTBUTTXT) \
 849 WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAME, \
 850                                                     DELIMCHAR, \
 851                                                     CUSTBUTTXT) \
 852 wxValidator* PROPNAME::DoGetValidator () const \
 853 { return NULL; }
 854
 855
 856 // -----------------------------------------------------------------------
 857 // wxArrayEditorDialog
 858 // -----------------------------------------------------------------------
 859
 860 #define wxAEDIALOG_STYLE \
 861     (wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER | wxOK | wxCANCEL | wxCENTRE)
 862
 863 class WXDLLIMPEXP_PROPGRID wxArrayEditorDialog : public wxDialog
 864 {
 865 public:
 866     wxArrayEditorDialog();
 867     virtual ~wxArrayEditorDialog() { }
 868
 869     void Init();
 870
 871     wxArrayEditorDialog( wxWindow *parent,
 872                          const wxString& message,
 873                          const wxString& caption,
 874                          long style = wxAEDIALOG_STYLE,
 875                          const wxPoint& pos = wxDefaultPosition,
 876                          const wxSize& sz = wxDefaultSize );
 877
 878     bool Create( wxWindow *parent,
 879                  const wxString& message,
 880                  const wxString& caption,
 881                  long style = wxAEDIALOG_STYLE,
 882                  const wxPoint& pos = wxDefaultPosition,
 883                  const wxSize& sz = wxDefaultSize );
 884
 885     /** Set value modified by dialog.
 886     */
 887     virtual void SetDialogValue( const wxVariant& WXUNUSED(value) )
 888     {
 889         wxFAIL_MSG(wxT("re-implement this member function in derived class"));
 890     }
 891
 892     /** Return value modified by dialog.
 893     */
 894     virtual wxVariant GetDialogValue() const
 895     {
 896         wxFAIL_MSG(wxT("re-implement this member function in derived class"));
 897         return wxVariant();
 898     }
 899
 900     /** Override to return wxValidator to be used with the wxTextCtrl
 901         in dialog. Note that the validator is used in the standard
 902         wx way, ie. it immediately prevents user from entering invalid
 903         input.
 904
 905         @remarks
 906         Dialog frees the validator.
 907     */
 908     virtual wxValidator* GetTextCtrlValidator() const
 909     {
 910         return NULL;
 911     }
 912
 913     // Returns true if array was actually modified
 914     bool IsModified() const { return m_modified; }
 915
 916     //const wxArrayString& GetStrings() const { return m_array; }
 917
 918     // implementation from now on
 919     void OnUpdateClick(wxCommandEvent& event);
 920     void OnAddClick(wxCommandEvent& event);
 921     void OnDeleteClick(wxCommandEvent& event);
 922     void OnListBoxClick(wxCommandEvent& event);
 923     void OnUpClick(wxCommandEvent& event);
 924     void OnDownClick(wxCommandEvent& event);
 925     //void OnCustomEditClick(wxCommandEvent& event);
 926     void OnIdle(wxIdleEvent& event);
 927
 928 protected:
 929     wxTextCtrl*     m_edValue;
 930     wxListBox*      m_lbStrings;
 931
 932     wxButton*       m_butAdd;       // Button pointers
 933     wxButton*       m_butCustom;    // required for disabling/enabling changing.
 934     wxButton*       m_butUpdate;
 935     wxButton*       m_butRemove;
 936     wxButton*       m_butUp;
 937     wxButton*       m_butDown;
 938
 939     //wxArrayString   m_array;
 940
 941     const wxChar*   m_custBtText;
 942     //wxArrayStringPropertyClass*     m_pCallingClass;
 943
 944     bool            m_modified;
 945
 946     unsigned char   m_curFocus;
 947
 948     // These must be overridden - must return true on success.
 949     virtual wxString ArrayGet( size_t index ) = 0;
 950     virtual size_t ArrayGetCount() = 0;
 951     virtual bool ArrayInsert( const wxString& str, int index ) = 0;
 952     virtual bool ArraySet( size_t index, const wxString& str ) = 0;
 953     virtual void ArrayRemoveAt( int index ) = 0;
 954     virtual void ArraySwap( size_t first, size_t second ) = 0;
 955
 956 private:
 957 #ifndef SWIG
 958     DECLARE_DYNAMIC_CLASS_NO_COPY(wxArrayEditorDialog)
 959     DECLARE_EVENT_TABLE()
 960 #endif
 961 };
 962
 963 // -----------------------------------------------------------------------
 964 // wxPGArrayStringEditorDialog
 965 // -----------------------------------------------------------------------
 966
 967 class WXDLLIMPEXP_PROPGRID
 968     wxPGArrayStringEditorDialog : public wxArrayEditorDialog
 969 {
 970 public:
 971     wxPGArrayStringEditorDialog();
 972     virtual ~wxPGArrayStringEditorDialog() { }
 973
 974     void Init();
 975
 976     virtual void SetDialogValue( const wxVariant& value )
 977     {
 978         m_array = value.GetArrayString();
 979     }
 980
 981     virtual wxVariant GetDialogValue() const
 982     {
 983         return m_array;
 984     }
 985
 986     void SetCustomButton( const wxChar* custBtText, wxArrayStringProperty* pcc )
 987     {
 988         m_custBtText = custBtText;
 989         m_pCallingClass = pcc;
 990     }
 991
 992     void OnCustomEditClick(wxCommandEvent& event);
 993
 994 protected:
 995     wxArrayString   m_array;
 996
 997     wxArrayStringProperty*     m_pCallingClass;
 998
 999     virtual wxString ArrayGet( size_t index );
1000     virtual size_t ArrayGetCount();
1001     virtual bool ArrayInsert( const wxString& str, int index );
1002     virtual bool ArraySet( size_t index, const wxString& str );
1003     virtual void ArrayRemoveAt( int index );
1004     virtual void ArraySwap( size_t first, size_t second );
1005
1006 private:
1007 #ifndef SWIG
1008     DECLARE_DYNAMIC_CLASS_NO_COPY(wxPGArrayStringEditorDialog)
1009     DECLARE_EVENT_TABLE()
1010 #endif
1011 };
1012
1013 // -----------------------------------------------------------------------
1014
1015 #endif // wxUSE_PROPGRID
1016
1017 #endif // _WX_PROPGRID_PROPS_H_