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 };
 453
 454 // -----------------------------------------------------------------------
 455
 456 /** @class wxEditEnumProperty
 457     @ingroup classes
 458     wxEnumProperty with wxString value and writable combo box editor.
 459
 460     @remarks
 461     Uses int value, similar to wxEnumProperty, unless text entered by user is
 462     is not in choices (in which case string value is used).
 463 */
 464 class WXDLLIMPEXP_PROPGRID wxEditEnumProperty : public wxEnumProperty
 465 {
 466     WX_PG_DECLARE_PROPERTY_CLASS(wxEditEnumProperty)
 467 public:
 468
 469     wxEditEnumProperty( const wxString& label,
 470                         const wxString& name,
 471                         const wxChar** labels,
 472                         const long* values,
 473                         const wxString& value );
 474     wxEditEnumProperty( const wxString& label = wxPG_LABEL,
 475                         const wxString& name = wxPG_LABEL,
 476                         const wxArrayString& labels = wxArrayString(),
 477                         const wxArrayInt& values = wxArrayInt(),
 478                         const wxString& value = wxEmptyString );
 479     wxEditEnumProperty( const wxString& label,
 480                         const wxString& name,
 481                         wxPGChoices& choices,
 482                         const wxString& value = wxEmptyString );
 483
 484     // Special constructor for caching choices (used by derived class)
 485     wxEditEnumProperty( const wxString& label,
 486                         const wxString& name,
 487                         const wxChar** labels,
 488                         const long* values,
 489                         wxPGChoices* choicesCache,
 490                         const wxString& value );
 491
 492     virtual ~wxEditEnumProperty();
 493
 494 protected:
 495 };
 496
 497 // -----------------------------------------------------------------------
 498
 499 /** @class wxFlagsProperty
 500     @ingroup classes
 501     Represents a bit set that fits in a long integer. wxBoolProperty
 502     sub-properties are created for editing individual bits. Textctrl is created
 503     to manually edit the flags as a text; a continous sequence of spaces,
 504     commas and semicolons is considered as a flag id separator.
 505     <b>Note:</b> When changing "choices" (ie. flag labels) of wxFlagsProperty,
 506     you will need to use SetPropertyChoices - otherwise they will not get
 507     updated properly.
 508 */
 509 class WXDLLIMPEXP_PROPGRID wxFlagsProperty : public wxPGProperty
 510 {
 511     WX_PG_DECLARE_PROPERTY_CLASS(wxFlagsProperty)
 512 public:
 513
 514 #ifndef SWIG
 515     wxFlagsProperty( const wxString& label,
 516                      const wxString& name,
 517                      const wxChar** labels,
 518                      const long* values = NULL,
 519                      long value = 0 );
 520     wxFlagsProperty( const wxString& label,
 521                      const wxString& name,
 522                      wxPGChoices& choices,
 523                      long value = 0 );
 524 #endif
 525     wxFlagsProperty( const wxString& label = wxPG_LABEL,
 526                      const wxString& name = wxPG_LABEL,
 527                      const wxArrayString& labels = wxArrayString(),
 528                      const wxArrayInt& values = wxArrayInt(),
 529                      int value = 0 );
 530     virtual ~wxFlagsProperty ();
 531
 532     virtual void OnSetValue();
 533     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 534     virtual bool StringToValue( wxVariant& variant,
 535                                 const wxString& text,
 536                                 int flags ) const;
 537     virtual void ChildChanged( wxVariant& thisValue,
 538                                int childIndex,
 539                                wxVariant& childValue ) const;
 540     virtual void RefreshChildren();
 541
 542     // GetChoiceSelection needs to overridden since m_choices is
 543     // used and value is integer, but it is not index.
 544     virtual int GetChoiceSelection() const { return wxNOT_FOUND; }
 545
 546     // helpers
 547     size_t GetItemCount() const { return m_choices.GetCount(); }
 548     const wxString& GetLabel( size_t ind ) const
 549         { return m_choices.GetLabel(ind); }
 550
 551 protected:
 552     // Used to detect if choices have been changed
 553     wxPGChoicesData*        m_oldChoicesData;
 554
 555     // Needed to properly mark changed sub-properties
 556     long                    m_oldValue;
 557
 558     // Converts string id to a relevant bit.
 559     long IdToBit( const wxString& id ) const;
 560
 561     // Creates children and sets value.
 562     void Init();
 563 };
 564
 565 // -----------------------------------------------------------------------
 566
 567 /** @class wxPGFileDialogAdapter
 568     @ingroup classes
 569 */
 570 class WXDLLIMPEXP_PROPGRID
 571     wxPGFileDialogAdapter : public wxPGEditorDialogAdapter
 572 {
 573 public:
 574     virtual bool DoShowDialog( wxPropertyGrid* propGrid,
 575                                wxPGProperty* property );
 576 };
 577
 578 // -----------------------------------------------------------------------
 579
 580 // Indicates first bit useable by derived properties.
 581 #define wxPG_PROP_SHOW_FULL_FILENAME  wxPG_PROP_CLASS_SPECIFIC_1
 582
 583 /** @class wxFileProperty
 584     @ingroup classes
 585     Like wxLongStringProperty, but the button triggers file selector instead.
 586
 587     <b>Supported special attributes:</b>
 588     - "Wildcard": Sets wildcard (see wxFileDialog for format details), "All
 589     files..." is default.
 590     - "ShowFullPath": Default 1. When 0, only the file name is shown (i.e. drive
 591       and directory are hidden).
 592     - "ShowRelativePath": If set, then the filename is shown relative to the
 593     given path string.
 594     - "InitialPath": Sets the initial path of where to look for files.
 595     - "DialogTitle": Sets a specific title for the dir dialog.
 596 */
 597 class WXDLLIMPEXP_PROPGRID wxFileProperty : public wxPGProperty
 598 {
 599     friend class wxPGFileDialogAdapter;
 600     WX_PG_DECLARE_PROPERTY_CLASS(wxFileProperty)
 601 public:
 602
 603     wxFileProperty( const wxString& label = wxPG_LABEL,
 604                     const wxString& name = wxPG_LABEL,
 605                     const wxString& value = wxEmptyString );
 606     virtual ~wxFileProperty ();
 607
 608     virtual void OnSetValue();
 609     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 610     virtual bool StringToValue( wxVariant& variant,
 611                                 const wxString& text,
 612                                 int argFlags = 0 ) const;
 613     virtual wxPGEditorDialogAdapter* GetEditorDialog() const;
 614     virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
 615
 616     static wxValidator* GetClassValidator();
 617     virtual wxValidator* DoGetValidator() const;
 618
 619     /**
 620         Returns filename to file represented by current value.
 621     */
 622     wxFileName GetFileName() const;
 623
 624 protected:
 625     wxString    m_wildcard;
 626     wxString    m_basePath; // If set, then show path relative to it
 627     wxString    m_initialPath; // If set, start the file dialog here
 628     wxString    m_dlgTitle; // If set, used as title for file dialog
 629     int         m_indFilter; // index to the selected filter
 630 };
 631
 632 // -----------------------------------------------------------------------
 633
 634 #define wxPG_PROP_NO_ESCAPE     wxPG_PROP_CLASS_SPECIFIC_1
 635
 636
 637 /** @class wxPGLongStringDialogAdapter
 638     @ingroup classes
 639 */
 640 class WXDLLIMPEXP_PROPGRID
 641     wxPGLongStringDialogAdapter : public wxPGEditorDialogAdapter
 642 {
 643 public:
 644     virtual bool DoShowDialog( wxPropertyGrid* propGrid,
 645                                wxPGProperty* property );
 646 };
 647
 648
 649 /** @class wxLongStringProperty
 650     @ingroup classes
 651     Like wxStringProperty, but has a button that triggers a small text
 652     editor dialog.
 653 */
 654 class WXDLLIMPEXP_PROPGRID wxLongStringProperty : public wxPGProperty
 655 {
 656     WX_PG_DECLARE_PROPERTY_CLASS(wxLongStringProperty)
 657 public:
 658
 659     wxLongStringProperty( const wxString& label = wxPG_LABEL,
 660                           const wxString& name = wxPG_LABEL,
 661                           const wxString& value = wxEmptyString );
 662     virtual ~wxLongStringProperty();
 663
 664     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 665     virtual bool StringToValue( wxVariant& variant,
 666                                 const wxString& text,
 667                                 int argFlags = 0 ) const;
 668     virtual bool OnEvent( wxPropertyGrid* propgrid,
 669                           wxWindow* primary, wxEvent& event );
 670
 671     // Shows string editor dialog. Value to be edited should be read from
 672     // value, and if dialog is not cancelled, it should be stored back and true
 673     // should be returned if that was the case.
 674     virtual bool OnButtonClick( wxPropertyGrid* propgrid, wxString& value );
 675
 676     static bool DisplayEditorDialog( wxPGProperty* prop,
 677                                      wxPropertyGrid* propGrid,
 678                                      wxString& value );
 679
 680 protected:
 681 };
 682
 683 // -----------------------------------------------------------------------
 684
 685
 686 // Exclude class from wxPython bindings
 687 #ifndef SWIG
 688
 689 /** @class wxDirProperty
 690     @ingroup classes
 691     Like wxLongStringProperty, but the button triggers dir selector instead.
 692
 693     <b>Supported special attributes:</b>
 694     - "DialogMessage": Sets specific message in the dir selector.
 695 */
 696 class WXDLLIMPEXP_PROPGRID wxDirProperty : public wxLongStringProperty
 697 {
 698 #ifndef SWIG
 699     DECLARE_DYNAMIC_CLASS(wxDirProperty)
 700 #endif
 701 public:
 702     wxDirProperty( const wxString& name = wxPG_LABEL,
 703                    const wxString& label = wxPG_LABEL,
 704                    const wxString& value = wxEmptyString );
 705     virtual ~wxDirProperty();
 706
 707     virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
 708     virtual wxValidator* DoGetValidator() const;
 709
 710     virtual bool OnButtonClick ( wxPropertyGrid* propGrid, wxString& value );
 711
 712 protected:
 713     wxString    m_dlgMessage;
 714 };
 715
 716 #endif  // !SWIG
 717
 718 // -----------------------------------------------------------------------
 719
 720 // wxBoolProperty specific flags
 721 #define wxPG_PROP_USE_CHECKBOX      wxPG_PROP_CLASS_SPECIFIC_1
 722 // DCC = Double Click Cycles
 723 #define wxPG_PROP_USE_DCC           wxPG_PROP_CLASS_SPECIFIC_2
 724
 725
 726 // -----------------------------------------------------------------------
 727
 728 /** @class wxArrayStringProperty
 729     @ingroup classes
 730     Property that manages a list of strings.
 731 */
 732 class WXDLLIMPEXP_PROPGRID wxArrayStringProperty : public wxPGProperty
 733 {
 734     WX_PG_DECLARE_PROPERTY_CLASS(wxArrayStringProperty)
 735 public:
 736
 737     wxArrayStringProperty( const wxString& label = wxPG_LABEL,
 738                            const wxString& name = wxPG_LABEL,
 739                            const wxArrayString& value = wxArrayString() );
 740     virtual ~wxArrayStringProperty();
 741
 742     virtual void OnSetValue();
 743     virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
 744     virtual bool StringToValue( wxVariant& variant,
 745                                 const wxString& text,
 746                                 int argFlags = 0 ) const;
 747     virtual bool OnEvent( wxPropertyGrid* propgrid,
 748                           wxWindow* primary, wxEvent& event );
 749
 750     virtual void GenerateValueAsString();
 751
 752     // Shows string editor dialog. Value to be edited should be read from
 753     // value, and if dialog is not cancelled, it should be stored back and true
 754     // should be returned if that was the case.
 755     virtual bool OnCustomStringEdit( wxWindow* parent, wxString& value );
 756
 757     // Helper.
 758     virtual bool OnButtonClick( wxPropertyGrid* propgrid,
 759                                 wxWindow* primary,
 760                                 const wxChar* cbt );
 761
 762 #ifndef SWIG
 763     // Creates wxArrayEditorDialog for string editing. Called in OnButtonClick.
 764     virtual wxArrayEditorDialog* CreateEditorDialog();
 765 #endif
 766
 767 protected:
 768     wxString        m_display; // Cache for displayed text.
 769 };
 770
 771 // -----------------------------------------------------------------------
 772
 773 #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR_WITH_DECL(PROPNAME, \
 774                                                                     DECL) \
 775 DECL PROPNAME : public wxArrayStringProperty \
 776 { \
 777     WX_PG_DECLARE_PROPERTY_CLASS(PROPNAME) \
 778 public: \
 779     PROPNAME( const wxString& label = wxPG_LABEL, \
 780               const wxString& name = wxPG_LABEL, \
 781               const wxArrayString& value = wxArrayString() ); \
 782     ~PROPNAME(); \
 783     virtual void GenerateValueAsString(); \
 784     virtual bool StringToValue( wxVariant& value, \
 785                                 const wxString& text, int = 0 ) const; \
 786     virtual bool OnEvent( wxPropertyGrid* propgrid, \
 787                           wxWindow* primary, wxEvent& event ); \
 788     virtual bool OnCustomStringEdit( wxWindow* parent, wxString& value ); \
 789     virtual wxValidator* DoGetValidator() const; \
 790 };
 791
 792 #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAM) \
 793 WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAM, class)
 794
 795 #define WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAME, \
 796                                                             DELIMCHAR, \
 797                                                             CUSTBUTTXT) \
 798 WX_PG_IMPLEMENT_PROPERTY_CLASS(PROPNAME, wxArrayStringProperty, \
 799                                wxArrayString, const wxArrayString&, \
 800                                TextCtrlAndButton) \
 801 PROPNAME::PROPNAME( const wxString& label, \
 802                     const wxString& name, \
 803                     const wxArrayString& value ) \
 804     : wxArrayStringProperty(label,name,value) \
 805 { \
 806     PROPNAME::GenerateValueAsString(); \
 807 } \
 808 PROPNAME::~PROPNAME() { } \
 809 void PROPNAME::GenerateValueAsString() \
 810 { \
 811     wxChar delimChar = DELIMCHAR; \
 812     if ( delimChar == wxS('"') ) \
 813         wxArrayStringProperty::GenerateValueAsString(); \
 814     else \
 815         wxPropertyGrid::ArrayStringToString(m_display, \
 816                                             m_value.GetArrayString(), \
 817                                             0,DELIMCHAR,0); \
 818 } \
 819 bool PROPNAME::StringToValue( wxVariant& variant, \
 820                               const wxString& text, int ) const \
 821 { \
 822     wxChar delimChar = DELIMCHAR; \
 823     if ( delimChar == wxS('"') ) \
 824         return wxArrayStringProperty::StringToValue(variant, text, 0); \
 825     \
 826     wxArrayString arr; \
 827     WX_PG_TOKENIZER1_BEGIN(text,DELIMCHAR) \
 828         arr.Add( token ); \
 829     WX_PG_TOKENIZER1_END() \
 830     variant = arr; \
 831     return true; \
 832 } \
 833 bool PROPNAME::OnEvent( wxPropertyGrid* propgrid, \
 834                         wxWindow* primary, wxEvent& event ) \
 835 { \
 836     if ( event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED ) \
 837         return OnButtonClick(propgrid,primary,(const wxChar*) CUSTBUTTXT); \
 838     return false; \
 839 }
 840
 841 #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY(PROPNAME) \
 842 WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAME)
 843
 844 #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_DECL(PROPNAME, DECL) \
 845 WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR_WITH_DECL(PROPNAME, DECL)
 846
 847 #define WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY(PROPNAME,DELIMCHAR,CUSTBUTTXT) \
 848 WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAME, \
 849                                                     DELIMCHAR, \
 850                                                     CUSTBUTTXT) \
 851 wxValidator* PROPNAME::DoGetValidator () const \
 852 { return NULL; }
 853
 854
 855 // -----------------------------------------------------------------------
 856 // wxArrayEditorDialog
 857 // -----------------------------------------------------------------------
 858
 859 #define wxAEDIALOG_STYLE \
 860     (wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER | wxOK | wxCANCEL | wxCENTRE)
 861
 862 class WXDLLIMPEXP_PROPGRID wxArrayEditorDialog : public wxDialog
 863 {
 864 public:
 865     wxArrayEditorDialog();
 866     virtual ~wxArrayEditorDialog() { }
 867
 868     void Init();
 869
 870     wxArrayEditorDialog( wxWindow *parent,
 871                          const wxString& message,
 872                          const wxString& caption,
 873                          long style = wxAEDIALOG_STYLE,
 874                          const wxPoint& pos = wxDefaultPosition,
 875                          const wxSize& sz = wxDefaultSize );
 876
 877     bool Create( wxWindow *parent,
 878                  const wxString& message,
 879                  const wxString& caption,
 880                  long style = wxAEDIALOG_STYLE,
 881                  const wxPoint& pos = wxDefaultPosition,
 882                  const wxSize& sz = wxDefaultSize );
 883
 884     /** Set value modified by dialog.
 885     */
 886     virtual void SetDialogValue( const wxVariant& WXUNUSED(value) )
 887     {
 888         wxFAIL_MSG(wxT("re-implement this member function in derived class"));
 889     }
 890
 891     /** Return value modified by dialog.
 892     */
 893     virtual wxVariant GetDialogValue() const
 894     {
 895         wxFAIL_MSG(wxT("re-implement this member function in derived class"));
 896         return wxVariant();
 897     }
 898
 899     /** Override to return wxValidator to be used with the wxTextCtrl
 900         in dialog. Note that the validator is used in the standard
 901         wx way, ie. it immediately prevents user from entering invalid
 902         input.
 903
 904         @remarks
 905         Dialog frees the validator.
 906     */
 907     virtual wxValidator* GetTextCtrlValidator() const
 908     {
 909         return NULL;
 910     }
 911
 912     // Returns true if array was actually modified
 913     bool IsModified() const { return m_modified; }
 914
 915     //const wxArrayString& GetStrings() const { return m_array; }
 916
 917     // implementation from now on
 918     void OnUpdateClick(wxCommandEvent& event);
 919     void OnAddClick(wxCommandEvent& event);
 920     void OnDeleteClick(wxCommandEvent& event);
 921     void OnListBoxClick(wxCommandEvent& event);
 922     void OnUpClick(wxCommandEvent& event);
 923     void OnDownClick(wxCommandEvent& event);
 924     //void OnCustomEditClick(wxCommandEvent& event);
 925     void OnIdle(wxIdleEvent& event);
 926
 927 protected:
 928     wxTextCtrl*     m_edValue;
 929     wxListBox*      m_lbStrings;
 930
 931     wxButton*       m_butAdd;       // Button pointers
 932     wxButton*       m_butCustom;    // required for disabling/enabling changing.
 933     wxButton*       m_butUpdate;
 934     wxButton*       m_butRemove;
 935     wxButton*       m_butUp;
 936     wxButton*       m_butDown;
 937
 938     //wxArrayString   m_array;
 939
 940     const wxChar*   m_custBtText;
 941     //wxArrayStringPropertyClass*     m_pCallingClass;
 942
 943     bool            m_modified;
 944
 945     unsigned char   m_curFocus;
 946
 947     // These must be overridden - must return true on success.
 948     virtual wxString ArrayGet( size_t index ) = 0;
 949     virtual size_t ArrayGetCount() = 0;
 950     virtual bool ArrayInsert( const wxString& str, int index ) = 0;
 951     virtual bool ArraySet( size_t index, const wxString& str ) = 0;
 952     virtual void ArrayRemoveAt( int index ) = 0;
 953     virtual void ArraySwap( size_t first, size_t second ) = 0;
 954
 955 private:
 956 #ifndef SWIG
 957     DECLARE_DYNAMIC_CLASS_NO_COPY(wxArrayEditorDialog)
 958     DECLARE_EVENT_TABLE()
 959 #endif
 960 };
 961
 962 // -----------------------------------------------------------------------
 963 // wxPGArrayStringEditorDialog
 964 // -----------------------------------------------------------------------
 965
 966 class WXDLLIMPEXP_PROPGRID
 967     wxPGArrayStringEditorDialog : public wxArrayEditorDialog
 968 {
 969 public:
 970     wxPGArrayStringEditorDialog();
 971     virtual ~wxPGArrayStringEditorDialog() { }
 972
 973     void Init();
 974
 975     virtual void SetDialogValue( const wxVariant& value )
 976     {
 977         m_array = value.GetArrayString();
 978     }
 979
 980     virtual wxVariant GetDialogValue() const
 981     {
 982         return m_array;
 983     }
 984
 985     void SetCustomButton( const wxChar* custBtText, wxArrayStringProperty* pcc )
 986     {
 987         m_custBtText = custBtText;
 988         m_pCallingClass = pcc;
 989     }
 990
 991     void OnCustomEditClick(wxCommandEvent& event);
 992
 993 protected:
 994     wxArrayString   m_array;
 995
 996     wxArrayStringProperty*     m_pCallingClass;
 997
 998     virtual wxString ArrayGet( size_t index );
 999     virtual size_t ArrayGetCount();
1000     virtual bool ArrayInsert( const wxString& str, int index );
1001     virtual bool ArraySet( size_t index, const wxString& str );
1002     virtual void ArrayRemoveAt( int index );
1003     virtual void ArraySwap( size_t first, size_t second );
1004
1005 private:
1006 #ifndef SWIG
1007     DECLARE_DYNAMIC_CLASS_NO_COPY(wxPGArrayStringEditorDialog)
1008     DECLARE_EVENT_TABLE()
1009 #endif
1010 };
1011
1012 // -----------------------------------------------------------------------
1013
1014 #endif // wxUSE_PROPGRID
1015
1016 #endif // _WX_PROPGRID_PROPS_H_