samples/propgrid/sampleprops.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        samples/propgrid/sampleprops.cpp
   3 // Purpose:     wxPropertyGrid Sample Properties
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2006-03-05
   7 // Copyright:   (c) Jaakko Salli
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // For compilers that support precompilation, includes "wx/wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 // for all others, include the necessary headers (this file is usually all you
  19 // need because it includes almost all "standard" wxWidgets headers)
  20 #ifndef WX_PRECOMP
  21     #include "wx/wx.h"
  22 #endif
  23
  24 #include "wx/fontdlg.h"
  25
  26 // -----------------------------------------------------------------------
  27
  28
  29 #include <wx/propgrid/propgrid.h>
  30 #include <wx/propgrid/advprops.h>
  31
  32 #ifndef WX_PROPGRID_SAMPLEPROPS_H
  33     #include "sampleprops.h"
  34 #endif
  35
  36
  37 // -----------------------------------------------------------------------
  38 // wxFontDataProperty
  39 // -----------------------------------------------------------------------
  40
  41 // Dummy comparison required by value type implementation.
  42 bool operator == (const wxFontData&, const wxFontData&)
  43 {
  44     return FALSE;
  45 }
  46
  47 // Custom version of wxFontProperty that also holds colour in the value.
  48 // Original version by Vladimir Vainer.
  49
  50 IMPLEMENT_VARIANT_OBJECT_SHALLOWCMP(wxFontData)
  51
  52 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFontDataProperty,wxFontProperty,
  53                                wxFontData,const wxFontData&,TextCtrlAndButton)
  54
  55 wxFontDataProperty::wxFontDataProperty( const wxString& label, const wxString& name,
  56    const wxFontData& value ) : wxFontProperty(label,name,value.GetInitialFont())
  57 {
  58     wxFontData fontData(value);
  59
  60     // Fix value.
  61     fontData.SetChosenFont(value.GetInitialFont());
  62     if ( !fontData.GetColour().IsOk() )
  63         fontData.SetColour(*wxBLACK);
  64
  65     // Set initial value - should be done in a simpler way like this
  66     // (instead of calling SetValue) in derived (wxObject) properties.
  67     m_value_wxFontData << value;
  68
  69     // Add extra children.
  70     AddPrivateChild( new wxColourProperty(_("Colour"), wxPG_LABEL,
  71                                           fontData.GetColour() ) );
  72 }
  73
  74 wxFontDataProperty::~wxFontDataProperty () { }
  75
  76 void wxFontDataProperty::OnSetValue()
  77 {
  78     if ( m_value.GetType() != "wxFontData" )
  79     {
  80         if ( m_value.GetType() == "wxFont" )
  81         {
  82             wxFont font;
  83             font << m_value;
  84             wxFontData fontData;
  85             fontData.SetChosenFont(font);
  86             if ( !m_value_wxFontData.IsNull() )
  87             {
  88                 wxFontData oldFontData;
  89                 oldFontData << m_value_wxFontData;
  90                 fontData.SetColour(oldFontData.GetColour());
  91             }
  92             else
  93             {
  94                 fontData.SetColour(*wxBLACK);
  95             }
  96             wxVariant variant;
  97             variant << fontData;
  98             m_value_wxFontData = variant;
  99         }
 100         else
 101         {
 102             wxFAIL_MSG(wxT("Value to wxFontDataProperty must be eithe wxFontData or wxFont"));
 103         }
 104     }
 105     else
 106     {
 107         // Set m_value to wxFont so that wxFontProperty methods will work
 108         // correctly.
 109         m_value_wxFontData = m_value;
 110
 111         wxFontData fontData;
 112         fontData << m_value_wxFontData;
 113
 114         wxFont font = fontData.GetChosenFont();
 115         if ( !font.IsOk() )
 116             font = wxFont(10,wxSWISS,wxNORMAL,wxNORMAL);
 117
 118         m_value = WXVARIANT(font);
 119     }
 120 }
 121
 122 wxVariant wxFontDataProperty::DoGetValue() const
 123 {
 124     return m_value_wxFontData;
 125 }
 126
 127 // Must re-create font dialog displayer.
 128 bool wxFontDataProperty::OnEvent( wxPropertyGrid* propgrid,
 129                                   wxWindow* WXUNUSED(primary), wxEvent& event )
 130 {
 131     if ( propgrid->IsMainButtonEvent(event) )
 132     {
 133         wxVariant useValue = propgrid->GetUncommittedPropertyValue();
 134
 135         wxFontData fontData;
 136         fontData << useValue;
 137
 138         fontData.SetInitialFont(fontData.GetChosenFont());
 139
 140         wxFontDialog dlg(propgrid, fontData);
 141
 142         if ( dlg.ShowModal() == wxID_OK )
 143         {
 144             wxVariant variant;
 145             variant << dlg.GetFontData();
 146             SetValueInEvent( variant );
 147             return true;
 148         }
 149     }
 150     return false;
 151 }
 152
 153 void wxFontDataProperty::RefreshChildren()
 154 {
 155     wxFontProperty::RefreshChildren();
 156     if ( GetChildCount() < 6 ) // Number is count of wxFontProperty's children + 1.
 157         return;
 158     wxFontData fontData; fontData << m_value_wxFontData;
 159     wxVariant variant; variant << fontData.GetColour();
 160     Item(6)->SetValue( variant );
 161 }
 162
 163 wxVariant wxFontDataProperty::ChildChanged( wxVariant& thisValue,
 164                                             int childIndex,
 165                                             wxVariant& childValue ) const
 166 {
 167     wxFontData fontData;
 168     fontData << thisValue;
 169     wxColour col;
 170     wxVariant variant;
 171
 172     switch ( childIndex )
 173     {
 174         case 6:
 175             col << childValue;
 176             fontData.SetColour( col );
 177             break;
 178         default:
 179             // Transfer from subset to superset.
 180             wxFont font = fontData.GetChosenFont();
 181             variant = WXVARIANT(font);
 182             wxFontProperty::ChildChanged( variant, childIndex, childValue );
 183             font << variant;
 184             fontData.SetChosenFont(font);
 185     }
 186
 187     wxVariant newVariant;
 188     newVariant << fontData;
 189     return newVariant;
 190 }
 191
 192 // -----------------------------------------------------------------------
 193 // wxSizeProperty
 194 // -----------------------------------------------------------------------
 195
 196 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxSizeProperty,wxPGProperty,
 197                                wxSize,const wxSize&,TextCtrl)
 198
 199 wxSizeProperty::wxSizeProperty( const wxString& label, const wxString& name,
 200     const wxSize& value) : wxPGProperty(label,name)
 201 {
 202     SetValueI(value);
 203     AddPrivateChild( new wxIntProperty(wxT("Width"),wxPG_LABEL,value.x) );
 204     AddPrivateChild( new wxIntProperty(wxT("Height"),wxPG_LABEL,value.y) );
 205 }
 206
 207 wxSizeProperty::~wxSizeProperty() { }
 208
 209 void wxSizeProperty::RefreshChildren()
 210 {
 211     if ( !GetChildCount() ) return;
 212     const wxSize& size = wxSizeRefFromVariant(m_value);
 213     Item(0)->SetValue( (long)size.x );
 214     Item(1)->SetValue( (long)size.y );
 215 }
 216
 217 wxVariant wxSizeProperty::ChildChanged( wxVariant& thisValue,
 218                                         int childIndex,
 219                                         wxVariant& childValue ) const
 220 {
 221     wxSize& size = wxSizeRefFromVariant(thisValue);
 222     int val = childValue.GetLong();
 223     switch ( childIndex )
 224     {
 225         case 0: size.x = val; break;
 226         case 1: size.y = val; break;
 227     }
 228     wxVariant newVariant;
 229     newVariant << size;
 230     return newVariant;
 231 }
 232
 233 // -----------------------------------------------------------------------
 234 // wxPointProperty
 235 // -----------------------------------------------------------------------
 236
 237 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxPointProperty,wxPGProperty,
 238                                wxPoint,const wxPoint&,TextCtrl)
 239
 240 wxPointProperty::wxPointProperty( const wxString& label, const wxString& name,
 241     const wxPoint& value) : wxPGProperty(label,name)
 242 {
 243     SetValueI(value);
 244     AddPrivateChild( new wxIntProperty(wxT("X"),wxPG_LABEL,value.x) );
 245     AddPrivateChild( new wxIntProperty(wxT("Y"),wxPG_LABEL,value.y) );
 246 }
 247
 248 wxPointProperty::~wxPointProperty() { }
 249
 250 void wxPointProperty::RefreshChildren()
 251 {
 252     if ( !GetChildCount() ) return;
 253     const wxPoint& point = wxPointRefFromVariant(m_value);
 254     Item(0)->SetValue( (long)point.x );
 255     Item(1)->SetValue( (long)point.y );
 256 }
 257
 258 wxVariant wxPointProperty::ChildChanged( wxVariant& thisValue,
 259                                          int childIndex,
 260                                          wxVariant& childValue ) const
 261 {
 262     wxPoint& point = wxPointRefFromVariant(thisValue);
 263     int val = childValue.GetLong();
 264     switch ( childIndex )
 265     {
 266         case 0: point.x = val; break;
 267         case 1: point.y = val; break;
 268     }
 269     wxVariant newVariant;
 270     newVariant << point;
 271     return newVariant;
 272 }
 273
 274
 275 // -----------------------------------------------------------------------
 276 // Dirs Property
 277 // -----------------------------------------------------------------------
 278
 279 WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(wxDirsProperty, ',',
 280                                                     "Browse")
 281
 282 #if wxUSE_VALIDATORS
 283
 284 wxValidator* wxDirsProperty::DoGetValidator() const
 285 {
 286     return wxFileProperty::GetClassValidator();
 287 }
 288
 289 #endif
 290
 291
 292 bool wxDirsProperty::OnCustomStringEdit( wxWindow* parent, wxString& value )
 293 {
 294     wxDirDialog dlg(parent,
 295                     _("Select a directory to be added to the list:"),
 296                     value,
 297                     0);
 298
 299     if ( dlg.ShowModal() == wxID_OK )
 300     {
 301         value = dlg.GetPath();
 302         return TRUE;
 303     }
 304     return FALSE;
 305 }
 306
 307 // -----------------------------------------------------------------------
 308 // wxArrayDoubleEditorDialog
 309 // -----------------------------------------------------------------------
 310
 311
 312 //
 313 // You can *almost* convert wxArrayDoubleEditorDialog to wxArrayXXXEditorDialog
 314 // by replacing each ArrayDouble with ArrayXXX.
 315 //
 316
 317 class wxArrayDoubleEditorDialog : public wxPGArrayEditorDialog
 318 {
 319 public:
 320     wxArrayDoubleEditorDialog();
 321
 322     void Init();
 323
 324     wxArrayDoubleEditorDialog(wxWindow *parent,
 325                               const wxString& message,
 326                               const wxString& caption,
 327                               wxArrayDouble& array,
 328                               long style = wxAEDIALOG_STYLE,
 329                               const wxPoint& pos = wxDefaultPosition,
 330                               const wxSize& sz = wxDefaultSize );
 331
 332     bool Create(wxWindow *parent,
 333                 const wxString& message,
 334                 const wxString& caption,
 335                 wxArrayDouble& array,
 336                 long style = wxAEDIALOG_STYLE,
 337                 const wxPoint& pos = wxDefaultPosition,
 338                 const wxSize& sz = wxDefaultSize );
 339
 340     const wxArrayDouble& GetArray() const { return m_array; }
 341
 342     // Extra method for this type of array
 343     void SetPrecision ( int precision )
 344     {
 345         m_precision = precision;
 346         m_dtoaTemplate.Empty();
 347     }
 348
 349 protected:
 350     // Mandatory array of type
 351     wxArrayDouble   m_array;
 352
 353     // Use this to avoid extra wxString creation+Printf
 354     // on double-to-wxString conversion.
 355     wxString        m_dtoaTemplate;
 356
 357     int             m_precision;
 358
 359     // Mandatory overridden methods
 360     virtual wxString ArrayGet( size_t index );
 361     virtual size_t ArrayGetCount();
 362     virtual bool ArrayInsert( const wxString& str, int index );
 363     virtual bool ArraySet( size_t index, const wxString& str );
 364     virtual void ArrayRemoveAt( int index );
 365     virtual void ArraySwap( size_t first, size_t second );
 366
 367 private:
 368     DECLARE_DYNAMIC_CLASS_NO_COPY(wxArrayDoubleEditorDialog)
 369 };
 370
 371 IMPLEMENT_DYNAMIC_CLASS(wxArrayDoubleEditorDialog, wxPGArrayEditorDialog)
 372
 373 //
 374 // Array dialog array access and manipulation
 375 //
 376
 377 wxString wxArrayDoubleEditorDialog::ArrayGet( size_t index )
 378 {
 379     wxString str;
 380     wxPropertyGrid::DoubleToString(str,m_array[index],m_precision,true,&m_dtoaTemplate);
 381     return str;
 382 }
 383
 384 size_t wxArrayDoubleEditorDialog::ArrayGetCount()
 385 {
 386     return m_array.GetCount();
 387 }
 388
 389 bool wxArrayDoubleEditorDialog::ArrayInsert( const wxString& str, int index )
 390 {
 391     double d;
 392     if ( !str.ToDouble(&d) )
 393         return FALSE;
 394
 395     if (index<0)
 396         m_array.Add(d);
 397     else
 398         m_array.Insert(d,index);
 399     return TRUE;
 400 }
 401
 402 bool wxArrayDoubleEditorDialog::ArraySet( size_t index, const wxString& str )
 403 {
 404     double d;
 405     if ( !str.ToDouble(&d) )
 406         return FALSE;
 407     m_array[index] = d;
 408     return TRUE;
 409 }
 410
 411 void wxArrayDoubleEditorDialog::ArrayRemoveAt( int index )
 412 {
 413     m_array.RemoveAt(index);
 414 }
 415
 416 void wxArrayDoubleEditorDialog::ArraySwap( size_t first, size_t second )
 417 {
 418     double a = m_array[first];
 419     double b = m_array[second];
 420     m_array[first] = b;
 421     m_array[second] = a;
 422 }
 423
 424 //
 425 // Array dialog construction etc.
 426 //
 427
 428 wxArrayDoubleEditorDialog::wxArrayDoubleEditorDialog()
 429     : wxPGArrayEditorDialog()
 430 {
 431     Init();
 432 }
 433
 434 void wxArrayDoubleEditorDialog::Init()
 435 {
 436     wxPGArrayEditorDialog::Init();
 437     SetPrecision(-1);
 438 }
 439
 440 wxArrayDoubleEditorDialog::wxArrayDoubleEditorDialog(wxWindow *parent,
 441                               const wxString& message,
 442                               const wxString& caption,
 443                               wxArrayDouble& array,
 444                               long style,
 445                               const wxPoint& pos,
 446                               const wxSize& sz )
 447                               : wxPGArrayEditorDialog()
 448 {
 449     Init();
 450     Create(parent,message,caption,array,style,pos,sz);
 451 }
 452
 453 bool wxArrayDoubleEditorDialog::Create(wxWindow *parent,
 454                 const wxString& message,
 455                 const wxString& caption,
 456                 wxArrayDouble& array,
 457                 long style,
 458                 const wxPoint& pos,
 459                 const wxSize& sz )
 460 {
 461
 462     m_array = array;
 463
 464     return wxPGArrayEditorDialog::Create (parent,message,caption,style,pos,sz);
 465 }
 466
 467 // -----------------------------------------------------------------------
 468 // wxArrayDoubleProperty
 469 // -----------------------------------------------------------------------
 470
 471 #include <math.h> // for fabs
 472
 473 // Comparison required by value type implementation.
 474 bool operator == (const wxArrayDouble& a, const wxArrayDouble& b)
 475 {
 476     if ( a.GetCount() != b.GetCount() )
 477         return FALSE;
 478
 479     size_t i;
 480
 481     for ( i=0; i<a.GetCount(); i++ )
 482     {
 483         // Can't do direct equality comparison with floating point numbers.
 484         if ( fabs(a[i] - b[i]) > 0.0000000001 )
 485         {
 486             //wxLogDebug(wxT("%f != %f"),a[i],b[i]);
 487             return FALSE;
 488         }
 489     }
 490     return TRUE;
 491 }
 492
 493 WX_PG_IMPLEMENT_VARIANT_DATA_DUMMY_EQ(wxArrayDouble)
 494
 495 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxArrayDoubleProperty,
 496                                wxPGProperty,
 497                                wxArrayDouble,
 498                                const wxArrayDouble&,
 499                                TextCtrlAndButton)
 500
 501
 502 wxArrayDoubleProperty::wxArrayDoubleProperty (const wxString& label,
 503                                                         const wxString& name,
 504                                                         const wxArrayDouble& array )
 505     : wxPGProperty(label,name)
 506 {
 507     m_precision = -1;
 508
 509     //
 510     // Need to figure out delimiter needed for this locale
 511     // (ie. can't use comma when comma acts as decimal point in float).
 512     wxChar use_delimiter = wxT(',');
 513
 514     if (wxString::Format(wxT("%.2f"),12.34).Find(use_delimiter) >= 0)
 515         use_delimiter = wxT(';');
 516
 517     m_delimiter = use_delimiter;
 518
 519     SetValue( WXVARIANT(array) );
 520 }
 521
 522 wxArrayDoubleProperty::~wxArrayDoubleProperty () { }
 523
 524 void wxArrayDoubleProperty::OnSetValue()
 525 {
 526     // Generate cached display string, to optimize grid drawing
 527     GenerateValueAsString( m_display, m_precision, true );
 528 }
 529
 530 wxString wxArrayDoubleProperty::ValueToString( wxVariant& value,
 531                                                int argFlags ) const
 532 {
 533     wxString s;
 534
 535     if ( argFlags & wxPG_FULL_VALUE )
 536     {
 537         GenerateValueAsString(s,-1,false);
 538     }
 539     else
 540     {
 541         //
 542         // Display cached string only if value truly matches m_value
 543         if ( value.GetData() == m_value.GetData() )
 544             return m_display;
 545         else
 546             GenerateValueAsString( s, m_precision, true );
 547     }
 548
 549     return s;
 550 }
 551
 552 void wxArrayDoubleProperty::GenerateValueAsString( wxString& target, int prec, bool removeZeroes ) const
 553 {
 554     wxString s;
 555     wxString template_str;
 556     wxChar between[3] = wxT(", ");
 557     size_t i;
 558
 559     between[0] = m_delimiter;
 560
 561     target.Empty();
 562
 563     const wxArrayDouble& value = wxArrayDoubleRefFromVariant(m_value);
 564
 565     for ( i=0; i<value.GetCount(); i++ )
 566     {
 567
 568         wxPropertyGrid::DoubleToString(s,value[i],prec,removeZeroes,&template_str);
 569
 570         target += s;
 571
 572         if ( i<(value.GetCount()-1) )
 573             target += between;
 574     }
 575 }
 576
 577 bool wxArrayDoubleProperty::OnEvent( wxPropertyGrid* propgrid,
 578                                      wxWindow* WXUNUSED(primary),
 579                                      wxEvent& event)
 580 {
 581     if ( propgrid->IsMainButtonEvent(event) )
 582     {
 583         // Update the value in case of last minute changes
 584         wxVariant useValue = propgrid->GetUncommittedPropertyValue();
 585
 586         wxArrayDouble& value = wxArrayDoubleRefFromVariant(useValue);
 587
 588         // Create editor dialog.
 589         wxArrayDoubleEditorDialog dlg;
 590         dlg.SetPrecision(m_precision);
 591         dlg.Create( propgrid, wxEmptyString, m_label, value );
 592         dlg.Move( propgrid->GetGoodEditorDialogPosition(this,dlg.GetSize()) );
 593
 594         // Execute editor dialog
 595         int res = dlg.ShowModal();
 596         if ( res == wxID_OK && dlg.IsModified() )
 597         {
 598             SetValueInEvent( WXVARIANT(dlg.GetArray()) );
 599             return true;
 600         }
 601         return false;
 602     }
 603     return false;
 604 }
 605
 606 bool wxArrayDoubleProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
 607 {
 608     double tval;
 609     wxString tstr;
 610     // Add values to a temporary array so that in case
 611     // of error we can opt not to use them.
 612     wxArrayDouble new_array;
 613
 614     bool ok = true;
 615
 616     wxChar delimiter = m_delimiter;
 617
 618     WX_PG_TOKENIZER1_BEGIN(text,delimiter)
 619
 620         if ( !token.empty() )
 621         {
 622
 623             // If token was invalid, exit the loop now
 624             if ( !token.ToDouble(&tval) )
 625             {
 626                 tstr.Printf ( _("\"%s\" is not a floating-point number."), token.c_str() );
 627                 ok = false;
 628                 break;
 629             }
 630             // TODO: Put validator code here
 631
 632             new_array.Add(tval);
 633
 634         }
 635
 636     WX_PG_TOKENIZER1_END()
 637
 638     // When invalid token found, show error message and don't change anything
 639     if ( !ok )
 640     {
 641         //ShowError( tstr );
 642         return false;
 643     }
 644
 645     if ( !(wxArrayDoubleRefFromVariant(m_value) == new_array) )
 646     {
 647         variant = WXVARIANT(new_array);
 648         return true;
 649     }
 650
 651     return false;
 652 }
 653
 654 bool wxArrayDoubleProperty::DoSetAttribute( const wxString& name, wxVariant& value )
 655 {
 656     if ( name == wxPG_FLOAT_PRECISION )
 657     {
 658         m_precision = value.GetLong();
 659         GenerateValueAsString( m_display, m_precision, true );
 660         return true;
 661     }
 662     return false;
 663 }
 664