src/propgrid/props.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/propgrid/props.cpp
   3 // Purpose:     Basic Property Classes
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2005-05-14
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Jaakko Salli
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx/wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_PROPGRID
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/defs.h"
  23     #include "wx/object.h"
  24     #include "wx/hash.h"
  25     #include "wx/string.h"
  26     #include "wx/log.h"
  27     #include "wx/event.h"
  28     #include "wx/window.h"
  29     #include "wx/panel.h"
  30     #include "wx/dc.h"
  31     #include "wx/dcclient.h"
  32     #include "wx/dcmemory.h"
  33     #include "wx/button.h"
  34     #include "wx/pen.h"
  35     #include "wx/brush.h"
  36     #include "wx/cursor.h"
  37     #include "wx/dialog.h"
  38     #include "wx/settings.h"
  39     #include "wx/msgdlg.h"
  40     #include "wx/choice.h"
  41     #include "wx/stattext.h"
  42     #include "wx/scrolwin.h"
  43     #include "wx/dirdlg.h"
  44     #include "wx/combobox.h"
  45     #include "wx/layout.h"
  46     #include "wx/sizer.h"
  47     #include "wx/textdlg.h"
  48     #include "wx/filedlg.h"
  49     #include "wx/intl.h"
  50 #endif
  51
  52 #include "wx/filename.h"
  53
  54 #include "wx/propgrid/propgrid.h"
  55
  56 #define wxPG_CUSTOM_IMAGE_WIDTH     20 // for wxColourProperty etc.
  57
  58
  59 // -----------------------------------------------------------------------
  60 // wxStringProperty
  61 // -----------------------------------------------------------------------
  62
  63 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxStringProperty,wxPGProperty,
  64                                wxString,const wxString&,TextCtrl)
  65
  66 wxStringProperty::wxStringProperty( const wxString& label,
  67                                     const wxString& name,
  68                                     const wxString& value )
  69     : wxPGProperty(label,name)
  70 {
  71     SetValue(value);
  72 }
  73
  74 void wxStringProperty::OnSetValue()
  75 {
  76     if ( !m_value.IsNull() && m_value.GetString() == wxS("<composed>") )
  77         SetFlag(wxPG_PROP_COMPOSED_VALUE);
  78
  79     if ( HasFlag(wxPG_PROP_COMPOSED_VALUE) )
  80     {
  81         wxString s;
  82         DoGenerateComposedValue(s);
  83         m_value = s;
  84     }
  85 }
  86
  87 wxStringProperty::~wxStringProperty() { }
  88
  89 wxString wxStringProperty::ValueToString( wxVariant& value,
  90                                           int argFlags ) const
  91 {
  92     wxString s = value.GetString();
  93
  94     if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE) )
  95     {
  96         // Value stored in m_value is non-editable, non-full value
  97         if ( (argFlags & wxPG_FULL_VALUE) || (argFlags & wxPG_EDITABLE_VALUE) )
  98         {
  99             // Calling this under incorrect conditions will fail
 100             wxASSERT_MSG( argFlags & wxPG_VALUE_IS_CURRENT,
 101                           "Sorry, currently default wxPGProperty::ValueToString() "
 102                           "implementation only works if value is m_value." );
 103
 104             DoGenerateComposedValue(s, argFlags);
 105         }
 106
 107         return s;
 108     }
 109
 110     // If string is password and value is for visual purposes,
 111     // then return asterisks instead the actual string.
 112     if ( (m_flags & wxPG_PROP_PASSWORD) && !(argFlags & (wxPG_FULL_VALUE|wxPG_EDITABLE_VALUE)) )
 113         return wxString(wxChar('*'), s.Length());
 114
 115     return s;
 116 }
 117
 118 bool wxStringProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
 119 {
 120     if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE) )
 121         return wxPGProperty::StringToValue(variant, text, argFlags);
 122
 123     if ( variant != text )
 124     {
 125         variant = text;
 126         return true;
 127     }
 128
 129     return false;
 130 }
 131
 132 bool wxStringProperty::DoSetAttribute( const wxString& name, wxVariant& value )
 133 {
 134     if ( name == wxPG_STRING_PASSWORD )
 135     {
 136         m_flags &= ~(wxPG_PROP_PASSWORD);
 137         if ( wxPGVariantToInt(value) ) m_flags |= wxPG_PROP_PASSWORD;
 138         RecreateEditor();
 139         return false;
 140     }
 141     return true;
 142 }
 143
 144 // -----------------------------------------------------------------------
 145 // wxIntProperty
 146 // -----------------------------------------------------------------------
 147
 148 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxIntProperty,wxPGProperty,
 149                                long,long,TextCtrl)
 150
 151 wxIntProperty::wxIntProperty( const wxString& label, const wxString& name,
 152     long value ) : wxPGProperty(label,name)
 153 {
 154     SetValue(value);
 155 }
 156
 157 wxIntProperty::wxIntProperty( const wxString& label, const wxString& name,
 158     const wxLongLong& value ) : wxPGProperty(label,name)
 159 {
 160     SetValue(WXVARIANT(value));
 161 }
 162
 163 wxIntProperty::~wxIntProperty() { }
 164
 165 wxString wxIntProperty::ValueToString( wxVariant& value,
 166                                        int WXUNUSED(argFlags) ) const
 167 {
 168     if ( value.GetType() == wxPG_VARIANT_TYPE_LONG )
 169     {
 170         return wxString::Format(wxS("%li"),value.GetLong());
 171     }
 172     else if ( value.GetType() == wxLongLong_VariantType )
 173     {
 174             wxLongLong ll;
 175         ll << value;
 176             return ll.ToString();
 177     }
 178
 179     return wxEmptyString;
 180 }
 181
 182 bool wxIntProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
 183 {
 184     wxString s;
 185     long value32;
 186
 187     if ( text.length() == 0 )
 188     {
 189         variant.MakeNull();
 190         return true;
 191     }
 192
 193     // We know it is a number, but let's still check
 194     // the return value.
 195     if ( text.IsNumber() )
 196     {
 197         // Remove leading zeroes, so that the number is not interpreted as octal
 198         wxString::const_iterator i = text.begin();
 199         wxString::const_iterator iMax = text.end() - 1;  // Let's allow one, last zero though
 200
 201         int firstNonZeroPos = 0;
 202
 203         for ( ; i != iMax; i++ )
 204         {
 205             wxChar c = *i;
 206             if ( c != wxS('0') && c != wxS(' ') )
 207                 break;
 208             firstNonZeroPos++;
 209         }
 210
 211         wxString useText = text.substr(firstNonZeroPos, text.length() - firstNonZeroPos);
 212
 213         wxString variantType = variant.GetType();
 214         bool isPrevLong = variantType == wxPG_VARIANT_TYPE_LONG;
 215
 216         wxLongLong_t value64 = 0;
 217
 218         if ( useText.ToLongLong(&value64, 10) &&
 219              ( value64 >= INT_MAX || value64 <= INT_MIN )
 220            )
 221         {
 222             bool doChangeValue = isPrevLong;
 223
 224             if ( !isPrevLong && variantType == wxLongLong_VariantType )
 225             {
 226                 wxLongLong oldValue;
 227                 oldValue << variant;
 228                 if ( oldValue.GetValue() != value64 )
 229                     doChangeValue = true;
 230             }
 231
 232             if ( doChangeValue )
 233             {
 234                 wxLongLong ll(value64);
 235                 variant << ll;
 236                 return true;
 237             }
 238         }
 239
 240         if ( useText.ToLong( &value32, 0 ) )
 241         {
 242             if ( !isPrevLong || variant != value32 )
 243             {
 244                 variant = value32;
 245                 return true;
 246             }
 247         }
 248     }
 249     else if ( argFlags & wxPG_REPORT_ERROR )
 250     {
 251     }
 252     return false;
 253 }
 254
 255 bool wxIntProperty::IntToValue( wxVariant& variant, int value, int WXUNUSED(argFlags) ) const
 256 {
 257     if ( variant.GetType() != wxPG_VARIANT_TYPE_LONG || variant != (long)value )
 258     {
 259         variant = (long)value;
 260         return true;
 261     }
 262     return false;
 263 }
 264
 265 bool wxIntProperty::DoValidation( const wxPGProperty* property, wxLongLong_t& value, wxPGValidationInfo* pValidationInfo, int mode )
 266 {
 267     // Check for min/max
 268     wxLongLong_t min = wxINT64_MIN;
 269     wxLongLong_t max = wxINT64_MAX;
 270     wxVariant variant;
 271     bool minOk = false;
 272     bool maxOk = false;
 273
 274     variant = property->GetAttribute(wxPGGlobalVars->m_strMin);
 275     if ( !variant.IsNull() )
 276     {
 277         wxPGVariantToLongLong(variant, &min);
 278         minOk = true;
 279     }
 280
 281     variant = property->GetAttribute(wxPGGlobalVars->m_strMax);
 282     if ( !variant.IsNull() )
 283     {
 284         wxPGVariantToLongLong(variant, &max);
 285         maxOk = true;
 286     }
 287
 288     if ( minOk )
 289     {
 290         if ( value < min )
 291         {
 292             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )
 293                 pValidationInfo->SetFailureMessage(
 294                     wxString::Format(_("Value must be %lld or higher"),min)
 295                     );
 296             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
 297                 value = min;
 298             else
 299                 value = max - (min - value);
 300             return false;
 301         }
 302     }
 303
 304     if ( maxOk )
 305     {
 306         if ( value > max )
 307         {
 308             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )
 309                 pValidationInfo->SetFailureMessage(
 310                     wxString::Format(_("Value must be %lld or higher"),min)
 311                     );
 312             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
 313                 value = max;
 314             else
 315                 value = min + (value - max);
 316             return false;
 317         }
 318     }
 319     return true;
 320 }
 321
 322 bool wxIntProperty::ValidateValue( wxVariant& value, wxPGValidationInfo& validationInfo ) const
 323 {
 324     wxLongLong_t ll;
 325     if ( wxPGVariantToLongLong(value, &ll) )
 326         return DoValidation(this, ll, &validationInfo, wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE);
 327     return true;
 328 }
 329
 330 wxValidator* wxIntProperty::GetClassValidator()
 331 {
 332 #if wxUSE_VALIDATORS
 333     WX_PG_DOGETVALIDATOR_ENTRY()
 334
 335     // Atleast wxPython 2.6.2.1 required that the string argument is given
 336     static wxString v;
 337     wxTextValidator* validator = new wxTextValidator(wxFILTER_NUMERIC,&v);
 338
 339     WX_PG_DOGETVALIDATOR_EXIT(validator)
 340 #else
 341     return NULL;
 342 #endif
 343 }
 344
 345 wxValidator* wxIntProperty::DoGetValidator() const
 346 {
 347     return GetClassValidator();
 348 }
 349
 350 // -----------------------------------------------------------------------
 351 // wxUIntProperty
 352 // -----------------------------------------------------------------------
 353
 354
 355 #define wxPG_UINT_TEMPLATE_MAX 8
 356
 357 static const wxChar* gs_uintTemplates32[wxPG_UINT_TEMPLATE_MAX] = {
 358     wxT("%x"),wxT("0x%x"),wxT("$%x"),
 359     wxT("%X"),wxT("0x%X"),wxT("$%X"),
 360     wxT("%u"),wxT("%o")
 361 };
 362
 363 static const wxChar* gs_uintTemplates64[wxPG_UINT_TEMPLATE_MAX] = {
 364     wxT("%") wxLongLongFmtSpec wxT("x"),
 365     wxT("0x%") wxLongLongFmtSpec wxT("x"),
 366     wxT("$%") wxLongLongFmtSpec wxT("x"),
 367     wxT("%") wxLongLongFmtSpec wxT("X"),
 368     wxT("0x%") wxLongLongFmtSpec wxT("X"),
 369     wxT("$%") wxLongLongFmtSpec wxT("X"),
 370     wxT("%") wxLongLongFmtSpec wxT("u"),
 371     wxT("%") wxLongLongFmtSpec wxT("o")
 372 };
 373
 374 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxUIntProperty,wxPGProperty,
 375                                long,unsigned long,TextCtrl)
 376
 377 void wxUIntProperty::Init()
 378 {
 379     m_base = 6; // This is magic number for dec base (must be same as in setattribute)
 380     m_realBase = 10;
 381     m_prefix = wxPG_PREFIX_NONE;
 382 }
 383
 384 wxUIntProperty::wxUIntProperty( const wxString& label, const wxString& name,
 385     unsigned long value ) : wxPGProperty(label,name)
 386 {
 387     Init();
 388     SetValue((long)value);
 389 }
 390
 391 wxUIntProperty::wxUIntProperty( const wxString& label, const wxString& name,
 392     const wxULongLong& value ) : wxPGProperty(label,name)
 393 {
 394     Init();
 395     SetValue(WXVARIANT(value));
 396 }
 397
 398 wxUIntProperty::~wxUIntProperty() { }
 399
 400 wxString wxUIntProperty::ValueToString( wxVariant& value,
 401                                         int WXUNUSED(argFlags) ) const
 402 {
 403     size_t index = m_base + m_prefix;
 404     if ( index >= wxPG_UINT_TEMPLATE_MAX )
 405         index = wxPG_BASE_DEC;
 406
 407     if ( value.GetType() == wxPG_VARIANT_TYPE_LONG )
 408     {
 409         return wxString::Format(gs_uintTemplates32[index], (unsigned long)value.GetLong());
 410     }
 411
 412     wxULongLong ull;
 413     ull << value;
 414
 415     return wxString::Format(gs_uintTemplates64[index], ull.GetValue());
 416 }
 417
 418 bool wxUIntProperty::StringToValue( wxVariant& variant, const wxString& text, int WXUNUSED(argFlags) ) const
 419 {
 420     wxString variantType = variant.GetType();
 421     bool isPrevLong = variantType == wxPG_VARIANT_TYPE_LONG;
 422
 423     if ( text.length() == 0 )
 424     {
 425         variant.MakeNull();
 426         return true;
 427     }
 428
 429     size_t start = 0;
 430     if ( text[0] == wxS('$') )
 431         start++;
 432
 433     wxULongLong_t value64 = 0;
 434     wxString s = text.substr(start, text.length() - start);
 435
 436     if ( s.ToULongLong(&value64, (unsigned int)m_realBase) )
 437     {
 438         if ( value64 >= LONG_MAX )
 439         {
 440             bool doChangeValue = isPrevLong;
 441
 442             if ( !isPrevLong && variantType == wxULongLong_VariantType )
 443             {
 444                 wxULongLong oldValue;
 445                 oldValue << variant;
 446                 if ( oldValue.GetValue() != value64 )
 447                     doChangeValue = true;
 448             }
 449
 450             if ( doChangeValue )
 451             {
 452                 wxULongLong ull(value64);
 453                 variant << ull;
 454                 return true;
 455             }
 456         }
 457         else
 458         {
 459             unsigned long value32 = wxLongLong(value64).GetLo();
 460             if ( !isPrevLong || m_value != (long)value32 )
 461             {
 462                 variant = (long)value32;
 463                 return true;
 464             }
 465         }
 466
 467     }
 468     return false;
 469 }
 470
 471 bool wxUIntProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
 472 {
 473     if ( variant != (long)number )
 474     {
 475         variant = (long)number;
 476         return true;
 477     }
 478     return false;
 479 }
 480
 481 #ifdef ULLONG_MAX
 482   #define wxUINT64_MAX ULLONG_MAX
 483   #define wxUINT64_MIN wxULL(0)
 484 #else
 485   #define wxUINT64_MAX wxULL(0xFFFFFFFFFFFFFFFF)
 486   #define wxUINT64_MIN wxULL(0)
 487 #endif
 488
 489 bool wxUIntProperty::ValidateValue( wxVariant& value, wxPGValidationInfo& validationInfo ) const
 490 {
 491     // Check for min/max
 492     wxULongLong_t ll;
 493     if ( wxPGVariantToULongLong(value, &ll) )
 494     {
 495         wxULongLong_t min = wxUINT64_MIN;
 496         wxULongLong_t max = wxUINT64_MAX;
 497         wxVariant variant;
 498
 499         variant = GetAttribute(wxPGGlobalVars->m_strMin);
 500         if ( !variant.IsNull() )
 501         {
 502             wxPGVariantToULongLong(variant, &min);
 503             if ( ll < min )
 504             {
 505                 validationInfo.SetFailureMessage(
 506                     wxString::Format(_("Value must be %llu or higher"),min)
 507                     );
 508                 return false;
 509             }
 510         }
 511         variant = GetAttribute(wxPGGlobalVars->m_strMax);
 512         if ( !variant.IsNull() )
 513         {
 514             wxPGVariantToULongLong(variant, &max);
 515             if ( ll > max )
 516             {
 517                 validationInfo.SetFailureMessage(
 518                     wxString::Format(_("Value must be %llu or less"),max)
 519                     );
 520                 return false;
 521             }
 522         }
 523     }
 524     return true;
 525 }
 526
 527 bool wxUIntProperty::DoSetAttribute( const wxString& name, wxVariant& value )
 528 {
 529     if ( name == wxPG_UINT_BASE )
 530     {
 531         int val = value.GetLong();
 532
 533         m_realBase = (wxByte) val;
 534         if ( m_realBase > 16 )
 535             m_realBase = 16;
 536
 537         //
 538         // Translate logical base to a template array index
 539         m_base = 7; // oct
 540         if ( val == wxPG_BASE_HEX )
 541             m_base = 3;
 542         else if ( val == wxPG_BASE_DEC )
 543             m_base = 6;
 544         else if ( val == wxPG_BASE_HEXL )
 545             m_base = 0;
 546         return true;
 547     }
 548     else if ( name == wxPG_UINT_PREFIX )
 549     {
 550         m_prefix = (wxByte) value.GetLong();
 551         return true;
 552     }
 553     return false;
 554 }
 555
 556 // -----------------------------------------------------------------------
 557 // wxFloatProperty
 558 // -----------------------------------------------------------------------
 559
 560 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFloatProperty,wxPGProperty,
 561                                double,double,TextCtrl)
 562
 563 wxFloatProperty::wxFloatProperty( const wxString& label,
 564                                             const wxString& name,
 565                                             double value )
 566     : wxPGProperty(label,name)
 567 {
 568     m_precision = -1;
 569     SetValue(value);
 570 }
 571
 572 wxFloatProperty::~wxFloatProperty() { }
 573
 574 // This helper method provides standard way for floating point-using
 575 // properties to convert values to string.
 576 void wxPropertyGrid::DoubleToString(wxString& target,
 577                                     double value,
 578                                     int precision,
 579                                     bool removeZeroes,
 580                                     wxString* precTemplate)
 581 {
 582     if ( precision >= 0 )
 583     {
 584         wxString text1;
 585         if (!precTemplate)
 586             precTemplate = &text1;
 587
 588         if ( !precTemplate->length() )
 589         {
 590             *precTemplate = wxS("%.");
 591             *precTemplate << wxString::Format( wxS("%i"), precision );
 592             *precTemplate << wxS('f');
 593         }
 594
 595         target.Printf( precTemplate->c_str(), value );
 596     }
 597     else
 598     {
 599         target.Printf( wxS("%f"), value );
 600     }
 601
 602     if ( removeZeroes && precision != 0 && target.length() )
 603     {
 604         // Remove excess zeroes (do not remove this code just yet,
 605         // since sprintf can't do the same consistently across platforms).
 606         wxString::const_iterator i = target.end() - 1;
 607         size_t new_len = target.length() - 1;
 608
 609         for ( ; i != target.begin(); i-- )
 610         {
 611             if ( *i != wxS('0') )
 612                 break;
 613             new_len--;
 614         }
 615
 616         wxChar cur_char = *i;
 617         if ( cur_char != wxS('.') && cur_char != wxS(',') )
 618             new_len++;
 619
 620         if ( new_len != target.length() )
 621             target.resize(new_len);
 622     }
 623 }
 624
 625 wxString wxFloatProperty::ValueToString( wxVariant& value,
 626                                          int argFlags ) const
 627 {
 628     wxString text;
 629     if ( !value.IsNull() )
 630     {
 631         wxPropertyGrid::DoubleToString(text,
 632                                        value,
 633                                        m_precision,
 634                                        !(argFlags & wxPG_FULL_VALUE),
 635                                        (wxString*) NULL);
 636     }
 637     return text;
 638 }
 639
 640 bool wxFloatProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
 641 {
 642     wxString s;
 643     double value;
 644
 645     if ( text.length() == 0 )
 646     {
 647         variant.MakeNull();
 648         return true;
 649     }
 650
 651     bool res = text.ToDouble(&value);
 652     if ( res )
 653     {
 654         if ( variant != value )
 655         {
 656             variant = value;
 657             return true;
 658         }
 659     }
 660     else if ( argFlags & wxPG_REPORT_ERROR )
 661     {
 662     }
 663     return false;
 664 }
 665
 666 bool wxFloatProperty::DoValidation( const wxPGProperty* property, double& value, wxPGValidationInfo* pValidationInfo, int mode )
 667 {
 668     // Check for min/max
 669     double min = (double)wxINT64_MIN;
 670     double max = (double)wxINT64_MAX;
 671     wxVariant variant;
 672     bool minOk = false;
 673     bool maxOk = false;
 674
 675     variant = property->GetAttribute(wxPGGlobalVars->m_strMin);
 676     if ( !variant.IsNull() )
 677     {
 678         wxPGVariantToDouble(variant, &min);
 679         minOk = true;
 680     }
 681
 682     variant = property->GetAttribute(wxPGGlobalVars->m_strMax);
 683     if ( !variant.IsNull() )
 684     {
 685         wxPGVariantToDouble(variant, &max);
 686         maxOk = true;
 687     }
 688
 689     if ( minOk )
 690     {
 691         if ( value < min )
 692         {
 693             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )
 694                 pValidationInfo->SetFailureMessage(
 695                     wxString::Format(_("Value must be %f or higher"),min)
 696                     );
 697             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
 698                 value = min;
 699             else
 700                 value = max - (min - value);
 701             return false;
 702         }
 703     }
 704
 705     if ( maxOk )
 706     {
 707         wxPGVariantToDouble(variant, &max);
 708         if ( value > max )
 709         {
 710             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )
 711                 pValidationInfo->SetFailureMessage(
 712                     wxString::Format(_("Value must be %f or less"),max)
 713                     );
 714             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
 715                 value = max;
 716             else
 717                 value = min + (value - max);
 718             return false;
 719         }
 720     }
 721     return true;
 722 }
 723
 724 bool wxFloatProperty::ValidateValue( wxVariant& value, wxPGValidationInfo& validationInfo ) const
 725 {
 726     double fpv;
 727     if ( wxPGVariantToDouble(value, &fpv) )
 728         return DoValidation(this, fpv, &validationInfo, wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE);
 729     return true;
 730 }
 731
 732 bool wxFloatProperty::DoSetAttribute( const wxString& name, wxVariant& value )
 733 {
 734     if ( name == wxPG_FLOAT_PRECISION )
 735     {
 736         m_precision = value.GetLong();
 737         return true;
 738     }
 739     return false;
 740 }
 741
 742 wxValidator* wxFloatProperty::DoGetValidator() const
 743 {
 744     return wxIntProperty::GetClassValidator();
 745 }
 746
 747 // -----------------------------------------------------------------------
 748 // wxBoolProperty
 749 // -----------------------------------------------------------------------
 750
 751 // We cannot use standard WX_PG_IMPLEMENT_PROPERTY_CLASS macro, since
 752 // there is a custom GetEditorClass.
 753
 754 IMPLEMENT_DYNAMIC_CLASS(wxBoolProperty, wxPGProperty)
 755
 756 const wxPGEditor* wxBoolProperty::DoGetEditorClass() const
 757 {
 758     // Select correct editor control.
 759 #if wxPG_INCLUDE_CHECKBOX
 760     if ( !(m_flags & wxPG_PROP_USE_CHECKBOX) )
 761         return wxPGEditor_Choice;
 762     return wxPGEditor_CheckBox;
 763 #else
 764     return wxPGEditor_Choice;
 765 #endif
 766 }
 767
 768 wxBoolProperty::wxBoolProperty( const wxString& label, const wxString& name, bool value ) :
 769     wxPGProperty(label,name)
 770 {
 771     m_choices.Assign(wxPGGlobalVars->m_boolChoices);
 772
 773     SetValue(wxPGVariant_Bool(value));
 774
 775     m_flags |= wxPG_PROP_USE_DCC;
 776 }
 777
 778 wxBoolProperty::~wxBoolProperty() { }
 779
 780 wxString wxBoolProperty::ValueToString( wxVariant& value,
 781                                         int argFlags ) const
 782 {
 783     bool boolValue = value.GetBool();
 784
 785     // As a fragment of composite string value,
 786     // make it a little more readable.
 787     if ( argFlags & wxPG_COMPOSITE_FRAGMENT )
 788     {
 789         if ( boolValue )
 790         {
 791             return m_label;
 792         }
 793         else
 794         {
 795             if ( argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT )
 796                 return wxEmptyString;
 797
 798             wxString notFmt;
 799             if ( wxPGGlobalVars->m_autoGetTranslation )
 800                 notFmt = _("Not %s");
 801             else
 802                 notFmt = wxS("Not %s");
 803
 804             return wxString::Format(notFmt.c_str(), m_label.c_str());
 805         }
 806     }
 807
 808     if ( !(argFlags & wxPG_FULL_VALUE) )
 809     {
 810         return wxPGGlobalVars->m_boolChoices[boolValue?1:0].GetText();
 811     }
 812
 813     wxString text;
 814
 815     if ( boolValue ) text = wxS("true");
 816     else text = wxS("false");
 817
 818     return text;
 819 }
 820
 821 bool wxBoolProperty::StringToValue( wxVariant& variant, const wxString& text, int WXUNUSED(argFlags) ) const
 822 {
 823     bool boolValue = false;
 824     if ( text.CmpNoCase(wxPGGlobalVars->m_boolChoices[1].GetText()) == 0 ||
 825          text.CmpNoCase(wxS("true")) == 0 ||
 826          text.CmpNoCase(m_label) == 0 )
 827         boolValue = true;
 828
 829     if ( text.length() == 0 )
 830     {
 831         variant.MakeNull();
 832         return true;
 833     }
 834
 835     if ( variant != boolValue )
 836     {
 837         variant = wxPGVariant_Bool(boolValue);
 838         return true;
 839     }
 840     return false;
 841 }
 842
 843 bool wxBoolProperty::IntToValue( wxVariant& variant, int value, int ) const
 844 {
 845     bool boolValue = value ? true : false;
 846
 847     if ( variant != boolValue )
 848     {
 849         variant = wxPGVariant_Bool(boolValue);
 850         return true;
 851     }
 852     return false;
 853 }
 854
 855 bool wxBoolProperty::DoSetAttribute( const wxString& name, wxVariant& value )
 856 {
 857 #if wxPG_INCLUDE_CHECKBOX
 858     if ( name == wxPG_BOOL_USE_CHECKBOX )
 859     {
 860         int ival = wxPGVariantToInt(value);
 861         if ( ival )
 862             m_flags |= wxPG_PROP_USE_CHECKBOX;
 863         else
 864             m_flags &= ~(wxPG_PROP_USE_CHECKBOX);
 865         return true;
 866     }
 867 #endif
 868     if ( name == wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING )
 869     {
 870         int ival = wxPGVariantToInt(value);
 871         if ( ival )
 872             m_flags |= wxPG_PROP_USE_DCC;
 873         else
 874             m_flags &= ~(wxPG_PROP_USE_DCC);
 875         return true;
 876     }
 877     return false;
 878 }
 879
 880 // -----------------------------------------------------------------------
 881 // wxBaseEnumProperty
 882 // -----------------------------------------------------------------------
 883
 884 int wxBaseEnumProperty::ms_nextIndex = -2;
 885
 886 wxBaseEnumProperty::wxBaseEnumProperty( const wxString& label, const wxString& name )
 887     : wxPGProperty(label,name)
 888 {
 889     m_value = wxPGVariant_Zero;
 890 }
 891
 892 /** If has values array, then returns number at index with value -
 893     otherwise just returns the value.
 894 */
 895 int wxBaseEnumProperty::GetIndexForValue( int value ) const
 896 {
 897     return value;
 898 }
 899
 900 void wxBaseEnumProperty::OnSetValue()
 901 {
 902     wxString variantType = m_value.GetType();
 903
 904     if ( variantType == wxPG_VARIANT_TYPE_LONG )
 905         ValueFromInt_( m_value, m_value.GetLong(), wxPG_FULL_VALUE );
 906     else if ( variantType == wxPG_VARIANT_TYPE_STRING )
 907         ValueFromString_( m_value, m_value.GetString(), 0 );
 908     else
 909         wxASSERT( false );
 910
 911     if ( ms_nextIndex != -2 )
 912     {
 913         m_index = ms_nextIndex;
 914         ms_nextIndex = -2;
 915     }
 916 }
 917
 918 bool wxBaseEnumProperty::ValidateValue( wxVariant& value, wxPGValidationInfo& WXUNUSED(validationInfo) ) const
 919 {
 920     // Make sure string value is in the list,
 921     // unless property has string as preferred value type
 922     // To reduce code size, use conversion here as well
 923     if ( value.GetType() == wxPG_VARIANT_TYPE_STRING &&
 924          !this->IsKindOf(CLASSINFO(wxEditEnumProperty)) )
 925         return ValueFromString_( value, value.GetString(), wxPG_PROPERTY_SPECIFIC );
 926
 927     return true;
 928 }
 929
 930 wxString wxBaseEnumProperty::ValueToString( wxVariant& value,
 931                                             int WXUNUSED(argFlags) ) const
 932 {
 933     if ( value.GetType() == wxPG_VARIANT_TYPE_STRING )
 934         return value.GetString();
 935
 936     int index = m_choices.Index(value.GetLong());
 937     if ( index < 0 )
 938         return wxEmptyString;
 939
 940     return m_choices.GetLabel(index);
 941 }
 942
 943 bool wxBaseEnumProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
 944 {
 945     return ValueFromString_( variant, text, argFlags );
 946 }
 947
 948 bool wxBaseEnumProperty::IntToValue( wxVariant& variant, int intVal, int argFlags ) const
 949 {
 950     return ValueFromInt_( variant, intVal, argFlags );
 951 }
 952
 953 bool wxBaseEnumProperty::ValueFromString_( wxVariant& value, const wxString& text, int argFlags ) const
 954 {
 955     size_t i = 0;
 956     const wxString* entryLabel;
 957     int entryValue;
 958     int useIndex = -1;
 959     long useValue = 0;
 960
 961     entryLabel = GetEntry(i, &entryValue);
 962     while ( entryLabel )
 963     {
 964         if ( text.CmpNoCase(*entryLabel) == 0 )
 965         {
 966             useIndex = (int)i;
 967             useValue = (long)entryValue;
 968             break;
 969         }
 970
 971         i++;
 972         entryLabel = GetEntry(i, &entryValue);
 973     }
 974
 975     bool asText = false;
 976
 977     bool isEdit = this->IsKindOf(CLASSINFO(wxEditEnumProperty));
 978
 979     // If text not any of the choices, store as text instead
 980     // (but only if we are wxEditEnumProperty)
 981     if ( useIndex == -1 &&
 982          (value.GetType() != wxPG_VARIANT_TYPE_STRING || (m_value.GetString() != text)) &&
 983          isEdit )
 984     {
 985         asText = true;
 986     }
 987
 988     int setAsNextIndex = -2;
 989
 990     if ( asText )
 991     {
 992         setAsNextIndex = -1;
 993         value = text;
 994     }
 995     else if ( m_index != useIndex )
 996     {
 997         if ( useIndex != -1 )
 998         {
 999             setAsNextIndex = useIndex;
1000             value = (long)useValue;
1001         }
1002         else
1003         {
1004             setAsNextIndex = -1;
1005             value = wxPGVariant_MinusOne;
1006         }
1007     }
1008
1009     if ( setAsNextIndex != -2 )
1010     {
1011         // If wxPG_PROPERTY_SPECIFIC is set, then this is done for
1012         // validation purposes only, and index must not be changed
1013         if ( !(argFlags & wxPG_PROPERTY_SPECIFIC) )
1014             ms_nextIndex = setAsNextIndex;
1015
1016         if ( isEdit || setAsNextIndex != -1 )
1017             return true;
1018         else
1019             return false;
1020     }
1021     return false;
1022 }
1023
1024 bool wxBaseEnumProperty::ValueFromInt_( wxVariant& variant, int intVal, int argFlags ) const
1025 {
1026     // If wxPG_FULL_VALUE is *not* in argFlags, then intVal is index from combo box.
1027     //
1028     ms_nextIndex = -2;
1029
1030     if ( argFlags & wxPG_FULL_VALUE )
1031     {
1032         ms_nextIndex = GetIndexForValue( intVal );
1033     }
1034     else
1035     {
1036         if ( m_index != intVal )
1037         {
1038             ms_nextIndex = intVal;
1039         }
1040     }
1041
1042     if ( ms_nextIndex != -2 )
1043     {
1044         if ( !(argFlags & wxPG_FULL_VALUE) )
1045             GetEntry(intVal, &intVal);
1046
1047         variant = (long)intVal;
1048
1049         return true;
1050     }
1051
1052     return false;
1053 }
1054
1055 void wxBaseEnumProperty::SetIndex( int index )
1056 {
1057     ms_nextIndex = -2;
1058     m_index = index;
1059 }
1060
1061 int wxBaseEnumProperty::GetIndex() const
1062 {
1063     if ( ms_nextIndex != -2 )
1064         return ms_nextIndex;
1065     return m_index;
1066 }
1067
1068 // -----------------------------------------------------------------------
1069 // wxEnumProperty
1070 // -----------------------------------------------------------------------
1071
1072 IMPLEMENT_DYNAMIC_CLASS(wxEnumProperty, wxPGProperty)
1073
1074 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxEnumProperty,long,Choice)
1075
1076 wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name, const wxChar** labels,
1077     const long* values, int value ) : wxBaseEnumProperty(label,name)
1078 {
1079     SetIndex(0);
1080
1081     if ( labels )
1082     {
1083         m_choices.Add(labels,values);
1084
1085         if ( GetItemCount() )
1086             SetValue( (long)value );
1087     }
1088 }
1089
1090 wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name, const wxChar** labels,
1091     const long* values, wxPGChoices* choicesCache, int value )
1092     : wxBaseEnumProperty(label,name)
1093 {
1094     SetIndex(0);
1095
1096     wxASSERT( choicesCache );
1097
1098     if ( choicesCache->IsOk() )
1099     {
1100         m_choices.Assign( *choicesCache );
1101         m_value = wxPGVariant_Zero;
1102     }
1103     else if ( labels )
1104     {
1105         m_choices.Add(labels,values);
1106
1107         if ( GetItemCount() )
1108             SetValue( (long)value );
1109     }
1110 }
1111
1112 wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name,
1113     const wxArrayString& labels, const wxArrayInt& values, int value ) : wxBaseEnumProperty(label,name)
1114 {
1115     SetIndex(0);
1116
1117     if ( &labels && labels.size() )
1118     {
1119         m_choices.Set(labels, values);
1120
1121         if ( GetItemCount() )
1122             SetValue( (long)value );
1123     }
1124 }
1125
1126 wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name,
1127     wxPGChoices& choices, int value )
1128     : wxBaseEnumProperty(label,name)
1129 {
1130     m_choices.Assign( choices );
1131
1132     if ( GetItemCount() )
1133         SetValue( (long)value );
1134 }
1135
1136 int wxEnumProperty::GetIndexForValue( int value ) const
1137 {
1138     if ( !m_choices.IsOk() )
1139         return -1;
1140
1141     if ( m_choices.HasValues() )
1142     {
1143         int intVal = m_choices.Index(value);
1144         if ( intVal >= 0 )
1145             return intVal;
1146     }
1147
1148     return value;
1149 }
1150
1151 wxEnumProperty::~wxEnumProperty ()
1152 {
1153 }
1154
1155 const wxString* wxEnumProperty::GetEntry( size_t index, int* pvalue ) const
1156 {
1157     if ( m_choices.IsOk() && index < m_choices.GetCount() )
1158     {
1159         int value = (int)index;
1160         if ( m_choices.HasValue(index) )
1161             value = m_choices.GetValue(index);
1162
1163         if ( pvalue )
1164             *pvalue = value;
1165
1166         return &m_choices.GetLabel(index);
1167     }
1168     return (const wxString*) NULL;
1169 }
1170
1171 // -----------------------------------------------------------------------
1172 // wxEditEnumProperty
1173 // -----------------------------------------------------------------------
1174
1175 IMPLEMENT_DYNAMIC_CLASS(wxEditEnumProperty, wxPGProperty)
1176
1177 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxEditEnumProperty,wxString,ComboBox)
1178
1179 wxEditEnumProperty::wxEditEnumProperty( const wxString& label, const wxString& name, const wxChar** labels,
1180     const long* values, const wxString& value )
1181     : wxEnumProperty(label,name,labels,values,0)
1182 {
1183     SetValue( value );
1184 }
1185
1186 wxEditEnumProperty::wxEditEnumProperty( const wxString& label, const wxString& name, const wxChar** labels,
1187     const long* values, wxPGChoices* choicesCache, const wxString& value )
1188     : wxEnumProperty(label,name,labels,values,choicesCache,0)
1189 {
1190     SetValue( value );
1191 }
1192
1193 wxEditEnumProperty::wxEditEnumProperty( const wxString& label, const wxString& name,
1194     const wxArrayString& labels, const wxArrayInt& values, const wxString& value )
1195     : wxEnumProperty(label,name,labels,values,0)
1196 {
1197     SetValue( value );
1198 }
1199
1200 wxEditEnumProperty::wxEditEnumProperty( const wxString& label, const wxString& name,
1201     wxPGChoices& choices, const wxString& value )
1202     : wxEnumProperty(label,name,choices,0)
1203 {
1204     SetValue( value );
1205 }
1206
1207 wxEditEnumProperty::~wxEditEnumProperty()
1208 {
1209 }
1210
1211 // -----------------------------------------------------------------------
1212 // wxFlagsProperty
1213 // -----------------------------------------------------------------------
1214
1215 IMPLEMENT_DYNAMIC_CLASS(wxFlagsProperty,wxPGProperty)
1216
1217 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxFlagsProperty,long,TextCtrl)
1218
1219 void wxFlagsProperty::Init()
1220 {
1221     SetParentalType(wxPG_PROP_AGGREGATE);
1222
1223     long value = m_value;
1224
1225     //
1226     // Generate children
1227     //
1228     unsigned int i;
1229
1230     unsigned int prevChildCount = m_children.size();
1231
1232     int oldSel = -1;
1233     if ( prevChildCount )
1234     {
1235         wxPropertyGridPageState* state = GetParentState();
1236
1237         // State safety check (it may be NULL in immediate parent)
1238         wxASSERT( state );
1239
1240         if ( state )
1241         {
1242             wxPGProperty* selected = state->GetSelection();
1243             if ( selected )
1244             {
1245                 if ( selected->GetParent() == this )
1246                     oldSel = selected->GetIndexInParent();
1247                 else if ( selected == this )
1248                     oldSel = -2;
1249             }
1250         }
1251         state->DoClearSelection();
1252     }
1253
1254     // Delete old children
1255     for ( i=0; i<prevChildCount; i++ )
1256         delete m_children[i];
1257
1258     m_children.clear();
1259
1260     if ( m_choices.IsOk() )
1261     {
1262         const wxPGChoices& choices = m_choices;
1263
1264         for ( i=0; i<GetItemCount(); i++ )
1265         {
1266             bool child_val;
1267             if ( choices.HasValue(i) )
1268                 child_val = ( value & choices.GetValue(i) )?true:false;
1269             else
1270                 child_val = ( value & (1<<i) )?true:false;
1271
1272             wxPGProperty* boolProp;
1273             wxString label = GetLabel(i);
1274
1275         #if wxUSE_INTL
1276             if ( wxPGGlobalVars->m_autoGetTranslation )
1277             {
1278                 boolProp = new wxBoolProperty( ::wxGetTranslation(label), label, child_val );
1279             }
1280             else
1281         #endif
1282             {
1283                 boolProp = new wxBoolProperty( label, label, child_val );
1284             }
1285             AddChild(boolProp);
1286         }
1287
1288         m_oldChoicesData = m_choices.GetDataPtr();
1289     }
1290
1291     m_oldValue = m_value;
1292
1293     if ( prevChildCount )
1294         SubPropsChanged(oldSel);
1295 }
1296
1297 wxFlagsProperty::wxFlagsProperty( const wxString& label, const wxString& name,
1298     const wxChar** labels, const long* values, long value ) : wxPGProperty(label,name)
1299 {
1300     m_oldChoicesData = (wxPGChoicesData*) NULL;
1301
1302     if ( labels )
1303     {
1304         m_choices.Set(labels,values);
1305
1306         wxASSERT( GetItemCount() );
1307
1308         SetValue( value );
1309     }
1310     else
1311     {
1312         m_value = wxPGVariant_Zero;
1313     }
1314 }
1315
1316 wxFlagsProperty::wxFlagsProperty( const wxString& label, const wxString& name,
1317         const wxArrayString& labels, const wxArrayInt& values, int value )
1318     : wxPGProperty(label,name)
1319 {
1320     m_oldChoicesData = (wxPGChoicesData*) NULL;
1321
1322     if ( &labels && labels.size() )
1323     {
1324         m_choices.Set(labels,values);
1325
1326         wxASSERT( GetItemCount() );
1327
1328         SetValue( (long)value );
1329     }
1330     else
1331     {
1332         m_value = wxPGVariant_Zero;
1333     }
1334 }
1335
1336 wxFlagsProperty::wxFlagsProperty( const wxString& label, const wxString& name,
1337     wxPGChoices& choices, long value )
1338     : wxPGProperty(label,name)
1339 {
1340     m_oldChoicesData = (wxPGChoicesData*) NULL;
1341
1342     if ( choices.IsOk() )
1343     {
1344         m_choices.Assign(choices);
1345
1346         wxASSERT( GetItemCount() );
1347
1348         SetValue( value );
1349     }
1350     else
1351     {
1352         m_value = wxPGVariant_Zero;
1353     }
1354 }
1355
1356 wxFlagsProperty::~wxFlagsProperty()
1357 {
1358 }
1359
1360 void wxFlagsProperty::OnSetValue()
1361 {
1362     if ( !m_choices.IsOk() || !GetItemCount() )
1363     {
1364         m_value = wxPGVariant_Zero;
1365     }
1366     else
1367     {
1368         long val = m_value.GetLong();
1369
1370         long fullFlags = 0;
1371
1372         // normalize the value (i.e. remove extra flags)
1373         unsigned int i;
1374         const wxPGChoices& choices = m_choices;
1375         for ( i = 0; i < GetItemCount(); i++ )
1376         {
1377             if ( choices.HasValue(i) )
1378                 fullFlags |= choices.GetValue(i);
1379             else
1380                 fullFlags |= (1<<i);
1381         }
1382
1383         val &= fullFlags;
1384
1385         m_value = val;
1386
1387         // Need to (re)init now?
1388         if ( GetChildCount() != GetItemCount() ||
1389              m_choices.GetDataPtr() != m_oldChoicesData )
1390         {
1391             Init();
1392         }
1393     }
1394
1395     long newFlags = m_value;
1396
1397     if ( newFlags != m_oldValue )
1398     {
1399         // Set child modified states
1400         unsigned int i;
1401         const wxPGChoices& choices = m_choices;
1402         for ( i = 0; i<GetItemCount(); i++ )
1403         {
1404             int flag;
1405
1406             if ( choices.HasValue(i) )
1407                 flag = choices.GetValue(i);
1408             else
1409                 flag = (1<<i);
1410
1411             if ( (newFlags & flag) != (m_oldValue & flag) )
1412                 Item(i)->SetFlag( wxPG_PROP_MODIFIED );
1413         }
1414
1415         m_oldValue = newFlags;
1416     }
1417 }
1418
1419 wxString wxFlagsProperty::ValueToString( wxVariant& value,
1420                                          int WXUNUSED(argFlags) ) const
1421 {
1422     wxString text;
1423
1424     if ( !m_choices.IsOk() )
1425         return text;
1426
1427     long flags = value;
1428     unsigned int i;
1429     const wxPGChoices& choices = m_choices;
1430
1431     for ( i = 0; i < GetItemCount(); i++ )
1432     {
1433         int doAdd;
1434         if ( choices.HasValue(i) )
1435             doAdd = ( flags & choices.GetValue(i) );
1436         else
1437             doAdd = ( flags & (1<<i) );
1438
1439         if ( doAdd )
1440         {
1441             text += choices.GetLabel(i);
1442             text += wxS(", ");
1443         }
1444     }
1445
1446     // remove last comma
1447     if ( text.Len() > 1 )
1448         text.Truncate ( text.Len() - 2 );
1449
1450     return text;
1451 }
1452
1453 // Translate string into flag tokens
1454 bool wxFlagsProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
1455 {
1456     if ( !m_choices.IsOk() )
1457         return false;
1458
1459     long newFlags = 0;
1460
1461     // semicolons are no longer valid delimeters
1462     WX_PG_TOKENIZER1_BEGIN(text,wxS(','))
1463
1464         if ( token.length() )
1465         {
1466             // Determine which one it is
1467             long bit = IdToBit( token );
1468
1469             if ( bit != -1 )
1470             {
1471                 // Changed?
1472                 newFlags |= bit;
1473             }
1474             else
1475             {
1476                 break;
1477             }
1478         }
1479
1480     WX_PG_TOKENIZER1_END()
1481
1482     if ( variant != (long)newFlags )
1483     {
1484         variant = (long)newFlags;
1485         return true;
1486     }
1487
1488     return false;
1489 }
1490
1491 // Converts string id to a relevant bit.
1492 long wxFlagsProperty::IdToBit( const wxString& id ) const
1493 {
1494     unsigned int i;
1495     for ( i = 0; i < GetItemCount(); i++ )
1496     {
1497         if ( id == GetLabel(i) )
1498         {
1499             if ( m_choices.HasValue(i) )
1500                 return m_choices.GetValue(i);
1501             return (1<<i);
1502         }
1503     }
1504     return -1;
1505 }
1506
1507 void wxFlagsProperty::RefreshChildren()
1508 {
1509     if ( !m_choices.IsOk() || !GetChildCount() ) return;
1510
1511     int flags = m_value.GetLong();
1512
1513     const wxPGChoices& choices = m_choices;
1514     unsigned int i;
1515     for ( i = 0; i < GetItemCount(); i++ )
1516     {
1517         long flag;
1518
1519         if ( choices.HasValue(i) )
1520             flag = choices.GetValue(i);
1521         else
1522             flag = (1<<i);
1523
1524         long subVal = flags & flag;
1525         wxPGProperty* p = Item(i);
1526
1527         if ( subVal != (m_oldValue & flag) )
1528             p->SetFlag( wxPG_PROP_MODIFIED );
1529
1530         p->SetValue( subVal?true:false );
1531     }
1532
1533     m_oldValue = flags;
1534 }
1535
1536 void wxFlagsProperty::ChildChanged( wxVariant& thisValue, int childIndex, wxVariant& childValue ) const
1537 {
1538     long oldValue = thisValue.GetLong();
1539     long val = childValue.GetLong();
1540     unsigned long vi = (1<<childIndex);
1541     if ( m_choices.HasValue(childIndex) ) vi = m_choices.GetValue(childIndex);
1542     if ( val )
1543         thisValue = (long)(oldValue | vi);
1544     else
1545         thisValue = (long)(oldValue & ~(vi));
1546 }
1547
1548 // -----------------------------------------------------------------------
1549 // wxDirProperty
1550 // -----------------------------------------------------------------------
1551
1552 IMPLEMENT_DYNAMIC_CLASS(wxDirProperty, wxLongStringProperty)
1553
1554 wxDirProperty::wxDirProperty( const wxString& name, const wxString& label, const wxString& value )
1555   : wxLongStringProperty(name,label,value)
1556 {
1557     m_flags |= wxPG_PROP_NO_ESCAPE;
1558 }
1559
1560 wxDirProperty::~wxDirProperty() { }
1561
1562 wxValidator* wxDirProperty::DoGetValidator() const
1563 {
1564     return wxFileProperty::GetClassValidator();
1565 }
1566
1567 bool wxDirProperty::OnButtonClick( wxPropertyGrid* propGrid, wxString& value )
1568 {
1569     // Update property value from editor, if necessary
1570     wxSize dlg_sz(300,400);
1571
1572     wxString dlgMessage(m_dlgMessage);
1573     if ( dlgMessage.empty() )
1574         dlgMessage = _("Choose a directory:");
1575     wxDirDialog dlg( propGrid,
1576                      dlgMessage,
1577                      value,
1578                      0,
1579 #if !wxPG_SMALL_SCREEN
1580                      propGrid->GetGoodEditorDialogPosition(this,dlg_sz),
1581                      dlg_sz
1582 #else
1583                      wxDefaultPosition,
1584                      wxDefaultSize
1585 #endif
1586                     );
1587
1588     if ( dlg.ShowModal() == wxID_OK )
1589     {
1590         value = dlg.GetPath();
1591         return true;
1592     }
1593     return false;
1594 }
1595
1596 bool wxDirProperty::DoSetAttribute( const wxString& name, wxVariant& value )
1597 {
1598     if ( name == wxPG_DIR_DIALOG_MESSAGE )
1599     {
1600         m_dlgMessage = value.GetString();
1601         return true;
1602     }
1603     return false;
1604 }
1605
1606 // -----------------------------------------------------------------------
1607 // wxPGFileDialogAdapter
1608 // -----------------------------------------------------------------------
1609
1610 bool wxPGFileDialogAdapter::DoShowDialog( wxPropertyGrid* propGrid, wxPGProperty* property )
1611 {
1612     wxFileProperty* fileProp = NULL;
1613     wxString path;
1614     int indFilter = -1;
1615
1616     if ( property->IsKindOf(CLASSINFO(wxFileProperty)) )
1617     {
1618         fileProp = ((wxFileProperty*)property);
1619         wxFileName filename = fileProp->GetValue().GetString();
1620         path = filename.GetPath();
1621         indFilter = fileProp->m_indFilter;
1622
1623         if ( !path.length() && fileProp->m_basePath.length() )
1624             path = fileProp->m_basePath;
1625     }
1626     else
1627     {
1628         wxFileName fn(property->GetValue().GetString());
1629         path = fn.GetPath();
1630     }
1631
1632     wxFileDialog dlg( propGrid->GetPanel(),
1633                       property->GetAttribute(wxS("DialogTitle"), _("Choose a file")),
1634                       property->GetAttribute(wxS("InitialPath"), path),
1635                       wxEmptyString,
1636                       property->GetAttribute(wxPG_FILE_WILDCARD, _("All files (*.*)|*.*")),
1637                       0,
1638                       wxDefaultPosition );
1639
1640     if ( indFilter >= 0 )
1641         dlg.SetFilterIndex( indFilter );
1642
1643     if ( dlg.ShowModal() == wxID_OK )
1644     {
1645         if ( fileProp )
1646             fileProp->m_indFilter = dlg.GetFilterIndex();
1647         SetValue( dlg.GetPath() );
1648         return true;
1649     }
1650     return false;
1651 }
1652
1653 // -----------------------------------------------------------------------
1654 // wxFileProperty
1655 // -----------------------------------------------------------------------
1656
1657 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFileProperty,wxPGProperty,
1658                                wxString,const wxString&,TextCtrlAndButton)
1659
1660 wxFileProperty::wxFileProperty( const wxString& label, const wxString& name,
1661     const wxString& value ) : wxPGProperty(label,name)
1662 {
1663     m_flags |= wxPG_PROP_SHOW_FULL_FILENAME;
1664     m_indFilter = -1;
1665     SetAttribute( wxPG_FILE_WILDCARD, _("All files (*.*)|*.*") );
1666
1667     SetValue(value);
1668 }
1669
1670 wxFileProperty::~wxFileProperty() {}
1671
1672 #if wxUSE_VALIDATORS
1673
1674 wxValidator* wxFileProperty::GetClassValidator()
1675 {
1676     WX_PG_DOGETVALIDATOR_ENTRY()
1677
1678     // Atleast wxPython 2.6.2.1 required that the string argument is given
1679     static wxString v;
1680     wxTextValidator* validator = new wxTextValidator(wxFILTER_EXCLUDE_CHAR_LIST,&v);
1681
1682     wxArrayString exChars;
1683     exChars.Add(wxS("?"));
1684     exChars.Add(wxS("*"));
1685     exChars.Add(wxS("|"));
1686     exChars.Add(wxS("<"));
1687     exChars.Add(wxS(">"));
1688     exChars.Add(wxS("\""));
1689
1690     validator->SetExcludes(exChars);
1691
1692     WX_PG_DOGETVALIDATOR_EXIT(validator)
1693 }
1694
1695 wxValidator* wxFileProperty::DoGetValidator() const
1696 {
1697     return GetClassValidator();
1698 }
1699
1700 #endif
1701
1702 void wxFileProperty::OnSetValue()
1703 {
1704     const wxString& fnstr = m_value.GetString();
1705
1706     wxFileName filename = fnstr;
1707
1708     if ( !filename.HasName() )
1709     {
1710         m_value = wxPGVariant_EmptyString;
1711     }
1712
1713     // Find index for extension.
1714     if ( m_indFilter < 0 && fnstr.length() )
1715     {
1716         wxString ext = filename.GetExt();
1717         int curind = 0;
1718         size_t pos = 0;
1719         size_t len = m_wildcard.length();
1720
1721         pos = m_wildcard.find(wxS("|"), pos);
1722         while ( pos != wxString::npos && pos < (len-3) )
1723         {
1724             size_t ext_begin = pos + 3;
1725
1726             pos = m_wildcard.find(wxS("|"), ext_begin);
1727             if ( pos == wxString::npos )
1728                 pos = len;
1729             wxString found_ext = m_wildcard.substr(ext_begin, pos-ext_begin);
1730
1731             if ( found_ext.length() > 0 )
1732             {
1733                 if ( found_ext[0] == wxS('*') )
1734                 {
1735                     m_indFilter = curind;
1736                     break;
1737                 }
1738                 if ( ext.CmpNoCase(found_ext) == 0 )
1739                 {
1740                     m_indFilter = curind;
1741                     break;
1742                 }
1743             }
1744
1745             if ( pos != len )
1746                 pos = m_wildcard.find(wxS("|"), pos+1);
1747
1748             curind++;
1749         }
1750     }
1751 }
1752
1753 wxFileName wxFileProperty::GetFileName() const
1754 {
1755     wxFileName filename;
1756
1757     if ( !m_value.IsNull() )
1758         filename = m_value.GetString();
1759
1760     return filename;
1761 }
1762
1763 wxString wxFileProperty::ValueToString( wxVariant& value,
1764                                         int argFlags ) const
1765 {
1766     wxFileName filename = value.GetString();
1767
1768     if ( !filename.HasName() )
1769         return wxEmptyString;
1770
1771     wxString fullName = filename.GetFullName();
1772     if ( !fullName.length() )
1773         return wxEmptyString;
1774
1775     if ( argFlags & wxPG_FULL_VALUE )
1776     {
1777         return filename.GetFullPath();
1778     }
1779     else if ( m_flags & wxPG_PROP_SHOW_FULL_FILENAME )
1780     {
1781         if ( m_basePath.Length() )
1782         {
1783             wxFileName fn2(filename);
1784             fn2.MakeRelativeTo(m_basePath);
1785             return fn2.GetFullPath();
1786         }
1787         return filename.GetFullPath();
1788     }
1789
1790     return filename.GetFullName();
1791 }
1792
1793 wxPGEditorDialogAdapter* wxFileProperty::GetEditorDialog() const
1794 {
1795     return new wxPGFileDialogAdapter();
1796 }
1797
1798 bool wxFileProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
1799 {
1800     wxFileName filename = variant.GetString();
1801
1802     if ( (m_flags & wxPG_PROP_SHOW_FULL_FILENAME) || (argFlags & wxPG_FULL_VALUE) )
1803     {
1804         if ( filename != text )
1805         {
1806             variant = text;
1807             return true;
1808         }
1809     }
1810     else
1811     {
1812         if ( filename.GetFullName() != text )
1813         {
1814             wxFileName fn = filename;
1815             fn.SetFullName(text);
1816             variant = fn.GetFullPath();
1817             return true;
1818         }
1819     }
1820
1821     return false;
1822 }
1823
1824 bool wxFileProperty::DoSetAttribute( const wxString& name, wxVariant& value )
1825 {
1826     // Return false on some occasions to make sure those attribs will get
1827     // stored in m_attributes.
1828     if ( name == wxPG_FILE_SHOW_FULL_PATH )
1829     {
1830         if ( wxPGVariantToInt(value) )
1831             m_flags |= wxPG_PROP_SHOW_FULL_FILENAME;
1832         else
1833             m_flags &= ~(wxPG_PROP_SHOW_FULL_FILENAME);
1834         return true;
1835     }
1836     else if ( name == wxPG_FILE_WILDCARD )
1837     {
1838         m_wildcard = value.GetString();
1839     }
1840     else if ( name == wxPG_FILE_SHOW_RELATIVE_PATH )
1841     {
1842         m_basePath = value.GetString();
1843
1844         // Make sure wxPG_FILE_SHOW_FULL_PATH is also set
1845         m_flags |= wxPG_PROP_SHOW_FULL_FILENAME;
1846     }
1847     else if ( name == wxPG_FILE_INITIAL_PATH )
1848     {
1849         m_initialPath = value.GetString();
1850         return true;
1851     }
1852     else if ( name == wxPG_FILE_DIALOG_TITLE )
1853     {
1854         m_dlgTitle = value.GetString();
1855         return true;
1856     }
1857     return false;
1858 }
1859
1860 // -----------------------------------------------------------------------
1861 // wxPGLongStringDialogAdapter
1862 // -----------------------------------------------------------------------
1863
1864 bool wxPGLongStringDialogAdapter::DoShowDialog( wxPropertyGrid* propGrid, wxPGProperty* property )
1865 {
1866     wxString val1 = property->GetValueAsString(0);
1867     wxString val_orig = val1;
1868
1869     wxString value;
1870     if ( !property->HasFlag(wxPG_PROP_NO_ESCAPE) )
1871         wxPropertyGrid::ExpandEscapeSequences(value, val1);
1872     else
1873         value = wxString(val1);
1874
1875     // Run editor dialog.
1876     if ( wxLongStringProperty::DisplayEditorDialog(property, propGrid, value) )
1877     {
1878         if ( !property->HasFlag(wxPG_PROP_NO_ESCAPE) )
1879             wxPropertyGrid::CreateEscapeSequences(val1,value);
1880         else
1881             val1 = value;
1882
1883         if ( val1 != val_orig )
1884         {
1885             SetValue( val1 );
1886             return true;
1887         }
1888     }
1889     return false;
1890 }
1891
1892 // -----------------------------------------------------------------------
1893 // wxLongStringProperty
1894 // -----------------------------------------------------------------------
1895
1896 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxLongStringProperty,wxPGProperty,
1897                                wxString,const wxString&,TextCtrlAndButton)
1898
1899 wxLongStringProperty::wxLongStringProperty( const wxString& label, const wxString& name,
1900     const wxString& value ) : wxPGProperty(label,name)
1901 {
1902     SetValue(value);
1903 }
1904
1905 wxLongStringProperty::~wxLongStringProperty() {}
1906
1907 wxString wxLongStringProperty::ValueToString( wxVariant& value,
1908                                               int WXUNUSED(argFlags) ) const
1909 {
1910     return value;
1911 }
1912
1913 bool wxLongStringProperty::OnEvent( wxPropertyGrid* propGrid, wxWindow* WXUNUSED(primary),
1914                                     wxEvent& event )
1915 {
1916     if ( propGrid->IsMainButtonEvent(event) )
1917     {
1918         // Update the value
1919         wxVariant useValue = propGrid->GetUncommittedPropertyValue();
1920
1921         wxString val1 = useValue.GetString();
1922         wxString val_orig = val1;
1923
1924         wxString value;
1925         if ( !(m_flags & wxPG_PROP_NO_ESCAPE) )
1926             wxPropertyGrid::ExpandEscapeSequences(value,val1);
1927         else
1928             value = wxString(val1);
1929
1930         // Run editor dialog.
1931         if ( OnButtonClick(propGrid,value) )
1932         {
1933             if ( !(m_flags & wxPG_PROP_NO_ESCAPE) )
1934                 wxPropertyGrid::CreateEscapeSequences(val1,value);
1935             else
1936                 val1 = value;
1937
1938             if ( val1 != val_orig )
1939             {
1940                 SetValueInEvent( val1 );
1941                 return true;
1942             }
1943         }
1944     }
1945     return false;
1946 }
1947
1948 bool wxLongStringProperty::OnButtonClick( wxPropertyGrid* propGrid, wxString& value )
1949 {
1950     return DisplayEditorDialog(this, propGrid, value);
1951 }
1952
1953 bool wxLongStringProperty::DisplayEditorDialog( wxPGProperty* prop, wxPropertyGrid* propGrid, wxString& value )
1954
1955 {
1956     // launch editor dialog
1957     wxDialog* dlg = new wxDialog(propGrid,-1,prop->GetLabel(),wxDefaultPosition,wxDefaultSize,
1958                                  wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER|wxCLIP_CHILDREN);
1959
1960     dlg->SetFont(propGrid->GetFont()); // To allow entering chars of the same set as the propGrid
1961
1962     // Multi-line text editor dialog.
1963 #if !wxPG_SMALL_SCREEN
1964     const int spacing = 8;
1965 #else
1966     const int spacing = 4;
1967 #endif
1968     wxBoxSizer* topsizer = new wxBoxSizer( wxVERTICAL );
1969     wxBoxSizer* rowsizer = new wxBoxSizer( wxHORIZONTAL );
1970     wxTextCtrl* ed = new wxTextCtrl(dlg,11,value,
1971         wxDefaultPosition,wxDefaultSize,wxTE_MULTILINE);
1972
1973     rowsizer->Add( ed, 1, wxEXPAND|wxALL, spacing );
1974     topsizer->Add( rowsizer, 1, wxEXPAND, 0 );
1975     rowsizer = new wxBoxSizer( wxHORIZONTAL );
1976     const int but_sz_flags =
1977         wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL|wxBOTTOM|wxLEFT|wxRIGHT;
1978     rowsizer->Add( new wxButton(dlg,wxID_OK,_("Ok")),
1979         0, but_sz_flags, spacing );
1980     rowsizer->Add( new wxButton(dlg,wxID_CANCEL,_("Cancel")),
1981         0, but_sz_flags, spacing );
1982     topsizer->Add( rowsizer, 0, wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL, 0 );
1983
1984     dlg->SetSizer( topsizer );
1985     topsizer->SetSizeHints( dlg );
1986
1987 #if !wxPG_SMALL_SCREEN
1988     dlg->SetSize(400,300);
1989
1990     dlg->Move( propGrid->GetGoodEditorDialogPosition(prop,dlg->GetSize()) );
1991 #endif
1992
1993     int res = dlg->ShowModal();
1994
1995     if ( res == wxID_OK )
1996     {
1997         value = ed->GetValue();
1998         dlg->Destroy();
1999         return true;
2000     }
2001     dlg->Destroy();
2002     return false;
2003 }
2004
2005 bool wxLongStringProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
2006 {
2007     if ( variant != text )
2008     {
2009         variant = text;
2010         return true;
2011     }
2012     return false;
2013 }
2014
2015 // -----------------------------------------------------------------------
2016 // wxArrayEditorDialog
2017 // -----------------------------------------------------------------------
2018
2019 BEGIN_EVENT_TABLE(wxArrayEditorDialog, wxDialog)
2020     EVT_IDLE(wxArrayEditorDialog::OnIdle)
2021     EVT_LISTBOX(24, wxArrayEditorDialog::OnListBoxClick)
2022     EVT_TEXT_ENTER(21, wxArrayEditorDialog::OnAddClick)
2023     EVT_BUTTON(22, wxArrayEditorDialog::OnAddClick)
2024     EVT_BUTTON(23, wxArrayEditorDialog::OnDeleteClick)
2025     EVT_BUTTON(25, wxArrayEditorDialog::OnUpClick)
2026     EVT_BUTTON(26, wxArrayEditorDialog::OnDownClick)
2027     EVT_BUTTON(27, wxArrayEditorDialog::OnUpdateClick)
2028     //EVT_BUTTON(28, wxArrayEditorDialog::OnCustomEditClick)
2029 END_EVENT_TABLE()
2030
2031 IMPLEMENT_ABSTRACT_CLASS(wxArrayEditorDialog, wxDialog)
2032
2033 #include "wx/statline.h"
2034
2035 // -----------------------------------------------------------------------
2036
2037 void wxArrayEditorDialog::OnIdle(wxIdleEvent& event)
2038 {
2039     //
2040     // Do control focus detection here.
2041     //
2042
2043     wxWindow* focused = FindFocus();
2044
2045     // This strange focus thing is a workaround for wxGTK wxListBox focus
2046     // reporting bug.
2047     if ( m_curFocus == 0 && focused != m_edValue &&
2048          focused != m_butAdd && focused != m_butUpdate &&
2049          m_lbStrings->GetSelection() >= 0 )
2050     {
2051         // ListBox was just focused.
2052         m_butAdd->Enable(false);
2053         m_butUpdate->Enable(false);
2054         m_butRemove->Enable(true);
2055         m_butUp->Enable(true);
2056         m_butDown->Enable(true);
2057         m_curFocus = 1;
2058     }
2059     else if ( (m_curFocus == 1 && focused == m_edValue) /*|| m_curFocus == 2*/ )
2060     {
2061         // TextCtrl was just focused.
2062         m_butAdd->Enable(true);
2063         bool upd_enable = false;
2064         if ( m_lbStrings->GetCount() && m_lbStrings->GetSelection() >= 0 )
2065             upd_enable = true;
2066         m_butUpdate->Enable(upd_enable);
2067         m_butRemove->Enable(false);
2068         m_butUp->Enable(false);
2069         m_butDown->Enable(false);
2070         m_curFocus = 0;
2071     }
2072
2073     event.Skip();
2074 }
2075
2076 // -----------------------------------------------------------------------
2077
2078 wxArrayEditorDialog::wxArrayEditorDialog()
2079     : wxDialog()
2080 {
2081     Init();
2082 }
2083
2084 // -----------------------------------------------------------------------
2085
2086 void wxArrayEditorDialog::Init()
2087 {
2088     m_custBtText = (const wxChar*) NULL;
2089 }
2090
2091 // -----------------------------------------------------------------------
2092
2093 wxArrayEditorDialog::wxArrayEditorDialog( wxWindow *parent,
2094                                           const wxString& message,
2095                                           const wxString& caption,
2096                                           long style,
2097                                           const wxPoint& pos,
2098                                           const wxSize& sz )
2099     : wxDialog()
2100 {
2101     Init();
2102     Create(parent,message,caption,style,pos,sz);
2103 }
2104
2105 // -----------------------------------------------------------------------
2106
2107 bool wxArrayEditorDialog::Create( wxWindow *parent,
2108                                   const wxString& message,
2109                                   const wxString& caption,
2110                                   long style,
2111                                   const wxPoint& pos,
2112                                   const wxSize& sz )
2113 {
2114     // On wxMAC the dialog shows incorrectly if style is not exactly wxCAPTION
2115     // FIXME: This should be only a temporary fix.
2116 #ifdef __WXMAC__
2117     int useStyle = wxCAPTION;
2118 #else
2119     int useStyle = style;
2120 #endif
2121
2122     bool res = wxDialog::Create(parent, wxID_ANY, caption, pos, sz, useStyle);
2123
2124     SetFont(parent->GetFont()); // To allow entering chars of the same set as the propGrid
2125
2126 #if !wxPG_SMALL_SCREEN
2127     const int spacing = 4;
2128 #else
2129     const int spacing = 3;
2130 #endif
2131
2132     m_modified = false;
2133
2134     m_curFocus = 1;
2135
2136     const int but_sz_flags =
2137         wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL|wxALL; //wxBOTTOM|wxLEFT|wxRIGHT;
2138
2139     wxBoxSizer* topsizer = new wxBoxSizer( wxVERTICAL );
2140
2141     // Message
2142     if ( message.length() )
2143         topsizer->Add( new wxStaticText(this,-1,message),
2144             0, wxALIGN_LEFT|wxALIGN_CENTRE_VERTICAL|wxALL, spacing );
2145
2146     // String editor
2147     wxBoxSizer* rowsizer = new wxBoxSizer( wxHORIZONTAL );
2148     m_edValue = new wxTextCtrl(this,21,wxEmptyString,
2149         wxDefaultPosition,wxDefaultSize,wxTE_PROCESS_ENTER);
2150     wxValidator* validator = GetTextCtrlValidator();
2151     if ( validator )
2152     {
2153         m_edValue->SetValidator( *validator );
2154         delete validator;
2155     }
2156     rowsizer->Add( m_edValue,
2157         1, wxALIGN_LEFT|wxALIGN_CENTRE_VERTICAL|wxALL, spacing );
2158
2159     // Add button
2160     m_butAdd = new wxButton(this,22,_("Add"));
2161     rowsizer->Add( m_butAdd,
2162         0, wxALIGN_LEFT|wxALIGN_CENTRE_VERTICAL|wxTOP|wxBOTTOM|wxRIGHT, spacing );
2163     topsizer->Add( rowsizer, 0, wxEXPAND, spacing );
2164
2165     // Separator line
2166     topsizer->Add( new wxStaticLine(this,-1),
2167         0, wxEXPAND|wxBOTTOM|wxLEFT|wxRIGHT, spacing );
2168
2169     rowsizer = new wxBoxSizer( wxHORIZONTAL );
2170
2171     // list box
2172     m_lbStrings = new wxListBox(this, 24, wxDefaultPosition, wxDefaultSize);
2173     unsigned int i;
2174     for ( i=0; i<ArrayGetCount(); i++ )
2175         m_lbStrings->Append( ArrayGet(i) );
2176     rowsizer->Add( m_lbStrings, 1, wxEXPAND|wxRIGHT, spacing );
2177
2178     // Manipulator buttons
2179     wxBoxSizer* colsizer = new wxBoxSizer( wxVERTICAL );
2180     m_butCustom = (wxButton*) NULL;
2181     if ( m_custBtText )
2182     {
2183         m_butCustom = new wxButton(this,28,::wxGetTranslation(m_custBtText));
2184         colsizer->Add( m_butCustom,
2185             0, wxALIGN_CENTER|wxTOP/*wxALIGN_LEFT|wxALIGN_CENTRE_VERTICAL|wxTOP|wxBOTTOM|wxRIGHT*/,
2186             spacing );
2187     }
2188     m_butUpdate = new wxButton(this,27,_("Update"));
2189     colsizer->Add( m_butUpdate,
2190         0, wxALIGN_CENTER|wxTOP, spacing );
2191     m_butRemove = new wxButton(this,23,_("Remove"));
2192     colsizer->Add( m_butRemove,
2193         0, wxALIGN_CENTER|wxTOP, spacing );
2194     m_butUp = new wxButton(this,25,_("Up"));
2195     colsizer->Add( m_butUp,
2196         0, wxALIGN_CENTER|wxTOP, spacing );
2197     m_butDown = new wxButton(this,26,_("Down"));
2198     colsizer->Add( m_butDown,
2199         0, wxALIGN_CENTER|wxTOP, spacing );
2200     rowsizer->Add( colsizer, 0, 0, spacing );
2201
2202     topsizer->Add( rowsizer, 1, wxLEFT|wxRIGHT|wxEXPAND, spacing );
2203
2204     // Separator line
2205     topsizer->Add( new wxStaticLine(this,-1),
2206         0, wxEXPAND|wxTOP|wxLEFT|wxRIGHT, spacing );
2207
2208     // buttons
2209     rowsizer = new wxBoxSizer( wxHORIZONTAL );
2210     /*
2211     const int but_sz_flags =
2212         wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL|wxBOTTOM|wxLEFT|wxRIGHT;
2213     */
2214     rowsizer->Add( new wxButton(this,wxID_OK,_("Ok")),
2215         0, but_sz_flags, spacing );
2216     rowsizer->Add( new wxButton(this,wxID_CANCEL,_("Cancel")),
2217         0, but_sz_flags, spacing );
2218     topsizer->Add( rowsizer, 0, wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL, 0 );
2219
2220     m_edValue->SetFocus();
2221
2222     SetSizer( topsizer );
2223     topsizer->SetSizeHints( this );
2224
2225 #if !wxPG_SMALL_SCREEN
2226     if ( sz.x == wxDefaultSize.x &&
2227          sz.y == wxDefaultSize.y )
2228         SetSize( wxSize(275,360) );
2229     else
2230         SetSize(sz);
2231 #endif
2232
2233     return res;
2234 }
2235
2236 // -----------------------------------------------------------------------
2237
2238 void wxArrayEditorDialog::OnAddClick(wxCommandEvent& )
2239 {
2240     wxString text = m_edValue->GetValue();
2241     if ( text.length() )
2242     {
2243         if ( ArrayInsert( text, -1 ) )
2244         {
2245             m_lbStrings->Append( text );
2246             m_modified = true;
2247             m_edValue->Clear();
2248         }
2249     }
2250 }
2251
2252 // -----------------------------------------------------------------------
2253
2254 void wxArrayEditorDialog::OnDeleteClick(wxCommandEvent& )
2255 {
2256     int index = m_lbStrings->GetSelection();
2257     if ( index >= 0 )
2258     {
2259         ArrayRemoveAt( index );
2260         m_lbStrings->Delete ( index );
2261         m_modified = true;
2262     }
2263 }
2264
2265 // -----------------------------------------------------------------------
2266
2267 void wxArrayEditorDialog::OnUpClick(wxCommandEvent& )
2268 {
2269     int index = m_lbStrings->GetSelection();
2270     if ( index > 0 )
2271     {
2272         ArraySwap(index-1,index);
2273         /*wxString old_str = m_array[index-1];
2274         wxString new_str = m_array[index];
2275         m_array[index-1] = new_str;
2276         m_array[index] = old_str;*/
2277         m_lbStrings->SetString ( index-1, ArrayGet(index-1) );
2278         m_lbStrings->SetString ( index, ArrayGet(index) );
2279         m_lbStrings->SetSelection ( index-1 );
2280         m_modified = true;
2281     }
2282 }
2283
2284 // -----------------------------------------------------------------------
2285
2286 void wxArrayEditorDialog::OnDownClick(wxCommandEvent& )
2287 {
2288     int index = m_lbStrings->GetSelection();
2289     int lastStringIndex = ((int) m_lbStrings->GetCount()) - 1;
2290     if ( index >= 0 && index < lastStringIndex )
2291     {
2292         ArraySwap(index,index+1);
2293         /*wxString old_str = m_array[index+1];
2294         wxString new_str = m_array[index];
2295         m_array[index+1] = new_str;
2296         m_array[index] = old_str;*/
2297         m_lbStrings->SetString ( index+1, ArrayGet(index+1) );
2298         m_lbStrings->SetString ( index, ArrayGet(index) );
2299         m_lbStrings->SetSelection ( index+1 );
2300         m_modified = true;
2301     }
2302 }
2303
2304 // -----------------------------------------------------------------------
2305
2306 void wxArrayEditorDialog::OnUpdateClick(wxCommandEvent& )
2307 {
2308     int index = m_lbStrings->GetSelection();
2309     if ( index >= 0 )
2310     {
2311         wxString str = m_edValue->GetValue();
2312         if ( ArraySet(index,str) )
2313         {
2314             m_lbStrings->SetString ( index, str );
2315             //m_array[index] = str;
2316             m_modified = true;
2317         }
2318     }
2319 }
2320
2321 // -----------------------------------------------------------------------
2322
2323 void wxArrayEditorDialog::OnListBoxClick(wxCommandEvent& )
2324 {
2325     int index = m_lbStrings->GetSelection();
2326     if ( index >= 0 )
2327     {
2328         m_edValue->SetValue( m_lbStrings->GetString(index) );
2329     }
2330 }
2331
2332 // -----------------------------------------------------------------------
2333 // wxPGArrayStringEditorDialog
2334 // -----------------------------------------------------------------------
2335
2336 IMPLEMENT_DYNAMIC_CLASS(wxPGArrayStringEditorDialog, wxArrayEditorDialog)
2337
2338 BEGIN_EVENT_TABLE(wxPGArrayStringEditorDialog, wxArrayEditorDialog)
2339     EVT_BUTTON(28, wxPGArrayStringEditorDialog::OnCustomEditClick)
2340 END_EVENT_TABLE()
2341
2342 // -----------------------------------------------------------------------
2343
2344 wxString wxPGArrayStringEditorDialog::ArrayGet( size_t index )
2345 {
2346     return m_array[index];
2347 }
2348
2349 size_t wxPGArrayStringEditorDialog::ArrayGetCount()
2350 {
2351     return m_array.size();
2352 }
2353
2354 bool wxPGArrayStringEditorDialog::ArrayInsert( const wxString& str, int index )
2355 {
2356     if (index<0)
2357         m_array.Add(str);
2358     else
2359         m_array.Insert(str,index);
2360     return true;
2361 }
2362
2363 bool wxPGArrayStringEditorDialog::ArraySet( size_t index, const wxString& str )
2364 {
2365     m_array[index] = str;
2366     return true;
2367 }
2368
2369 void wxPGArrayStringEditorDialog::ArrayRemoveAt( int index )
2370 {
2371     m_array.RemoveAt(index);
2372 }
2373
2374 void wxPGArrayStringEditorDialog::ArraySwap( size_t first, size_t second )
2375 {
2376     wxString old_str = m_array[first];
2377     wxString new_str = m_array[second];
2378     m_array[first] = new_str;
2379     m_array[second] = old_str;
2380 }
2381
2382 wxPGArrayStringEditorDialog::wxPGArrayStringEditorDialog()
2383     : wxArrayEditorDialog()
2384 {
2385     Init();
2386 }
2387
2388 void wxPGArrayStringEditorDialog::Init()
2389 {
2390     m_pCallingClass = (wxArrayStringProperty*) NULL;
2391 }
2392
2393 void wxPGArrayStringEditorDialog::OnCustomEditClick(wxCommandEvent& )
2394 {
2395     wxASSERT( m_pCallingClass );
2396     wxString str = m_edValue->GetValue();
2397     if ( m_pCallingClass->OnCustomStringEdit(m_parent,str) )
2398     {
2399         //m_edValue->SetValue ( str );
2400         m_lbStrings->Append ( str );
2401         m_array.Add ( str );
2402         m_modified = true;
2403     }
2404 }
2405
2406 // -----------------------------------------------------------------------
2407 // wxArrayStringProperty
2408 // -----------------------------------------------------------------------
2409
2410 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxArrayStringProperty,  // Property name
2411                                wxPGProperty,  // Property we inherit from
2412                                wxArrayString,  // Value type name
2413                                const wxArrayString&,  // Value type, as given in constructor
2414                                TextCtrlAndButton)  // Initial editor
2415
2416 wxArrayStringProperty::wxArrayStringProperty( const wxString& label,
2417                                                         const wxString& name,
2418                                                         const wxArrayString& array )
2419     : wxPGProperty(label,name)
2420 {
2421     SetValue( array );
2422 }
2423
2424 wxArrayStringProperty::~wxArrayStringProperty() { }
2425
2426 void wxArrayStringProperty::OnSetValue()
2427 {
2428     GenerateValueAsString();
2429 }
2430
2431 #define ARRSTRPROP_ARRAY_TO_STRING(STRING,ARRAY) \
2432     wxPropertyGrid::ArrayStringToString(STRING,ARRAY,wxS('"'),wxS('"'),1)
2433
2434 wxString wxArrayStringProperty::ValueToString( wxVariant& WXUNUSED(value),
2435                                                int argFlags ) const
2436 {
2437     //
2438     // If this is called from GetValueAsString(), return cached string
2439     if ( argFlags & wxPG_VALUE_IS_CURRENT )
2440     {
2441         return m_display;
2442     }
2443
2444     wxArrayString arr = m_value.GetArrayString();
2445     wxString s;
2446     ARRSTRPROP_ARRAY_TO_STRING(s, arr);
2447     return s;
2448 }
2449
2450 // Converts wxArrayString to a string separated by delimeters and spaces.
2451 // preDelim is useful for "str1" "str2" style. Set flags to 1 to do slash
2452 // conversion.
2453 void wxPropertyGrid::ArrayStringToString( wxString& dst, const wxArrayString& src,
2454                                           wxChar preDelim, wxChar postDelim,
2455                                           int flags )
2456 {
2457     wxString pdr;
2458
2459     unsigned int i;
2460     unsigned int itemCount = src.size();
2461
2462     wxChar preas[2];
2463
2464     dst.Empty();
2465
2466     if ( !preDelim )
2467         preas[0] = 0;
2468     else if ( (flags & 1) )
2469     {
2470         preas[0] = preDelim;
2471         preas[1] = 0;
2472         pdr = wxS("\\");
2473         pdr += preDelim;
2474     }
2475
2476     if ( itemCount )
2477         dst.append( preas );
2478
2479     wxASSERT( postDelim );
2480     wxString postDelimStr(postDelim);
2481     //wxString preDelimStr(preDelim);
2482
2483     for ( i = 0; i < itemCount; i++ )
2484     {
2485         wxString str( src.Item(i) );
2486
2487         // Do some character conversion.
2488         // Convertes \ to \\ and <preDelim> to \<preDelim>
2489         // Useful when preDelim and postDelim are "\"".
2490         if ( flags & 1 )
2491         {
2492             str.Replace( wxS("\\"), wxS("\\\\"), true );
2493             if ( pdr.length() )
2494                 str.Replace( preas, pdr, true );
2495         }
2496
2497         dst.append( str );
2498
2499         if ( i < (itemCount-1) )
2500         {
2501             dst.append( postDelimStr );
2502             dst.append( wxS(" ") );
2503             dst.append( preas );
2504         }
2505         else if ( preDelim )
2506             dst.append( postDelimStr );
2507     }
2508 }
2509
2510 void wxArrayStringProperty::GenerateValueAsString()
2511 {
2512     wxArrayString arr = m_value.GetArrayString();
2513     ARRSTRPROP_ARRAY_TO_STRING(m_display, arr);
2514 }
2515
2516 // Default implementation doesn't do anything.
2517 bool wxArrayStringProperty::OnCustomStringEdit( wxWindow*, wxString& )
2518 {
2519     return false;
2520 }
2521
2522 wxArrayEditorDialog* wxArrayStringProperty::CreateEditorDialog()
2523 {
2524     return new wxPGArrayStringEditorDialog();
2525 }
2526
2527 bool wxArrayStringProperty::OnButtonClick( wxPropertyGrid* propGrid,
2528                                            wxWindow* WXUNUSED(primaryCtrl),
2529                                            const wxChar* cbt )
2530 {
2531     // Update the value
2532     wxVariant useValue = propGrid->GetUncommittedPropertyValue();
2533
2534     if ( !propGrid->EditorValidate() )
2535         return false;
2536
2537     // Create editor dialog.
2538     wxArrayEditorDialog* dlg = CreateEditorDialog();
2539 #if wxUSE_VALIDATORS
2540     wxValidator* validator = GetValidator();
2541     wxPGInDialogValidator dialogValidator;
2542 #endif
2543
2544     wxPGArrayStringEditorDialog* strEdDlg = wxDynamicCast(dlg, wxPGArrayStringEditorDialog);
2545
2546     if ( strEdDlg )
2547         strEdDlg->SetCustomButton(cbt, this);
2548
2549     dlg->SetDialogValue( useValue );
2550     dlg->Create(propGrid, wxEmptyString, m_label);
2551
2552 #if !wxPG_SMALL_SCREEN
2553     dlg->Move( propGrid->GetGoodEditorDialogPosition(this,dlg->GetSize()) );
2554 #endif
2555
2556     bool retVal;
2557
2558     for (;;)
2559     {
2560         retVal = false;
2561
2562         int res = dlg->ShowModal();
2563
2564         if ( res == wxID_OK && dlg->IsModified() )
2565         {
2566             wxVariant value = dlg->GetDialogValue();
2567             if ( !value.IsNull() )
2568             {
2569                 wxArrayString actualValue = value.GetArrayString();
2570                 wxString tempStr;
2571                 ARRSTRPROP_ARRAY_TO_STRING(tempStr, actualValue);
2572             #if wxUSE_VALIDATORS
2573                 if ( dialogValidator.DoValidate( propGrid, validator, tempStr ) )
2574             #endif
2575                 {
2576                     SetValueInEvent( actualValue );
2577                     retVal = true;
2578                     break;
2579                 }
2580             }
2581             else
2582                 break;
2583         }
2584         else
2585             break;
2586     }
2587
2588     delete dlg;
2589
2590     return retVal;
2591 }
2592
2593 bool wxArrayStringProperty::OnEvent( wxPropertyGrid* propGrid,
2594                                      wxWindow* primary,
2595                                      wxEvent& event )
2596 {
2597     if ( propGrid->IsMainButtonEvent(event) )
2598         return OnButtonClick(propGrid,primary,(const wxChar*) NULL);
2599     return false;
2600 }
2601
2602 bool wxArrayStringProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
2603 {
2604     wxArrayString arr;
2605
2606     WX_PG_TOKENIZER2_BEGIN(text,wxS('"'))
2607
2608         // Need to replace backslashes with empty characters
2609         // (opposite what is done in GenerateValueString).
2610         token.Replace ( wxS("\\"), wxEmptyString, true );
2611
2612         arr.Add( token );
2613
2614     WX_PG_TOKENIZER2_END()
2615
2616     variant = arr;
2617
2618     return true;
2619 }
2620
2621 // -----------------------------------------------------------------------
2622 // wxPGInDialogValidator
2623 // -----------------------------------------------------------------------
2624
2625 #if wxUSE_VALIDATORS
2626 bool wxPGInDialogValidator::DoValidate( wxPropertyGrid* propGrid,
2627                                         wxValidator* validator,
2628                                         const wxString& value )
2629 {
2630     if ( !validator )
2631         return true;
2632
2633     wxTextCtrl* tc = m_textCtrl;
2634
2635     if ( !tc )
2636     {
2637         {
2638             tc = new wxTextCtrl( propGrid, wxPG_SUBID_TEMP1, wxEmptyString,
2639                                  wxPoint(30000,30000));
2640             tc->Hide();
2641         }
2642
2643         m_textCtrl = tc;
2644     }
2645
2646     tc->SetValue(value);
2647
2648     validator->SetWindow(tc);
2649     bool res = validator->Validate(propGrid);
2650
2651     return res;
2652 }
2653 #else
2654 bool wxPGInDialogValidator::DoValidate( wxPropertyGrid* WXUNUSED(propGrid),
2655                                         wxValidator* WXUNUSED(validator),
2656                                         const wxString& WXUNUSED(value) )
2657 {
2658     return true;
2659 }
2660 #endif
2661
2662 // -----------------------------------------------------------------------
2663
2664 #endif  // wxUSE_PROPGRID