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 // 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 // for all others, include the necessary headers (this file is usually all you
  20 // need because it includes almost all "standard" wxWidgets headers)
  21 #ifndef WX_PRECOMP
  22     #include "wx/wx.h"
  23 #endif
  24
  25 // -----------------------------------------------------------------------
  26
  27
  28 #include <wx/propgrid/propgrid.h>
  29 #include <wx/propgrid/advprops.h>
  30
  31 #ifndef WX_PROPGRID_SAMPLEPROPS_H
  32     #include "sampleprops.h"
  33 #endif
  34
  35
  36 // -----------------------------------------------------------------------
  37 // wxFontDataProperty
  38 // -----------------------------------------------------------------------
  39
  40 // Dummy comparison required by value type implementation.
  41 bool operator == (const wxFontData&, const wxFontData&)
  42 {
  43     return FALSE;
  44 }
  45
  46 // Custom version of wxFontProperty that also holds colour in the value.
  47 // Original version by Vladimir Vainer.
  48
  49 #include <wx/fontdlg.h>
  50
  51 IMPLEMENT_VARIANT_OBJECT_SHALLOWCMP(wxFontData)
  52
  53 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFontDataProperty,wxFontProperty,
  54                                wxFontData,const wxFontData&,TextCtrlAndButton)
  55
  56 wxFontDataProperty::wxFontDataProperty( const wxString& label, const wxString& name,
  57    const wxFontData& value ) : wxFontProperty(label,name,value.GetInitialFont())
  58 {
  59     wxFontData fontData(value);
  60
  61     // Fix value.
  62     fontData.SetChosenFont(value.GetInitialFont());
  63     if ( !fontData.GetColour().Ok() )
  64         fontData.SetColour(*wxBLACK);
  65
  66     // Set initial value - should be done in a simpler way like this
  67     // (instead of calling SetValue) in derived (wxObject) properties.
  68     m_value_wxFontData << value;
  69
  70     // Add extra children.
  71     AddPrivateChild( new wxColourProperty(_("Colour"), wxPG_LABEL,
  72                                           fontData.GetColour() ) );
  73 }
  74
  75 wxFontDataProperty::~wxFontDataProperty () { }
  76
  77 void wxFontDataProperty::OnSetValue()
  78 {
  79     if ( m_value.GetType() != "wxFontData" )
  80     {
  81         if ( m_value.GetType() == "wxFont" )
  82         {
  83             wxFont font;
  84             font << m_value;
  85             wxFontData fontData;
  86             fontData.SetChosenFont(font);
  87             if ( !m_value_wxFontData.IsNull() )
  88             {
  89                 wxFontData oldFontData;
  90                 oldFontData << m_value_wxFontData;
  91                 fontData.SetColour(oldFontData.GetColour());
  92             }
  93             else
  94             {
  95                 fontData.SetColour(*wxBLACK);
  96             }
  97             wxVariant variant;
  98             variant << fontData;
  99             m_value_wxFontData = variant;
 100         }
 101         else
 102         {
 103             wxFAIL_MSG(wxT("Value to wxFontDataProperty must be eithe wxFontData or wxFont"));
 104         }
 105     }
 106     else
 107     {
 108         // Set m_value to wxFont so that wxFontProperty methods will work
 109         // correctly.
 110         m_value_wxFontData = m_value;
 111
 112         wxFontData fontData;
 113         fontData << m_value_wxFontData;
 114
 115         wxFont font = fontData.GetChosenFont();
 116         if ( !font.Ok() )
 117             font = wxFont(10,wxSWISS,wxNORMAL,wxNORMAL);
 118
 119         m_value = WXVARIANT(font);
 120     }
 121 }
 122
 123 wxVariant wxFontDataProperty::DoGetValue() const
 124 {
 125     return m_value_wxFontData;
 126 }
 127
 128 // Must re-create font dialog displayer.
 129 bool wxFontDataProperty::OnEvent( wxPropertyGrid* propgrid,
 130                                   wxWindow* WXUNUSED(primary), wxEvent& event )
 131 {
 132     if ( propgrid->IsMainButtonEvent(event) )
 133     {
 134         wxVariant useValue = propgrid->GetUncommittedPropertyValue();
 135
 136         wxFontData fontData;
 137         fontData << useValue;
 138
 139         fontData.SetInitialFont(fontData.GetChosenFont());
 140
 141         wxFontDialog dlg(propgrid, fontData);
 142
 143         if ( dlg.ShowModal() == wxID_OK )
 144         {
 145             wxVariant variant;
 146             variant << dlg.GetFontData();
 147             SetValueInEvent( variant );
 148             return true;
 149         }
 150     }
 151     return false;
 152 }
 153
 154 void wxFontDataProperty::RefreshChildren()
 155 {
 156     wxFontProperty::RefreshChildren();
 157     if ( GetChildCount() < 6 ) // Number is count of wxFontProperty's children + 1.
 158         return;
 159     wxFontData fontData; fontData << m_value_wxFontData;
 160     wxVariant variant; variant << fontData.GetColour();
 161     Item(6)->SetValue( variant );
 162 }
 163
 164 wxVariant wxFontDataProperty::ChildChanged( wxVariant& thisValue,
 165                                             int childIndex,
 166                                             wxVariant& childValue ) const
 167 {
 168     wxFontData fontData;
 169     fontData << thisValue;
 170     wxColour col;
 171     wxVariant variant;
 172
 173     switch ( childIndex )
 174     {
 175         case 6:
 176             col << childValue;
 177             fontData.SetColour( col );
 178             break;
 179         default:
 180             // Transfer from subset to superset.
 181             wxFont font = fontData.GetChosenFont();
 182             variant = WXVARIANT(font);
 183             wxFontProperty::ChildChanged( variant, childIndex, childValue );
 184             font << variant;
 185             fontData.SetChosenFont(font);
 186     }
 187
 188     wxVariant newVariant;
 189     newVariant << fontData;
 190     return newVariant;
 191 }
 192
 193 // -----------------------------------------------------------------------
 194 // wxSizeProperty
 195 // -----------------------------------------------------------------------
 196
 197 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxSizeProperty,wxPGProperty,
 198                                wxSize,const wxSize&,TextCtrl)
 199
 200 wxSizeProperty::wxSizeProperty( const wxString& label, const wxString& name,
 201     const wxSize& value) : wxPGProperty(label,name)
 202 {
 203     SetValueI(value);
 204     AddPrivateChild( new wxIntProperty(wxT("Width"),wxPG_LABEL,value.x) );
 205     AddPrivateChild( new wxIntProperty(wxT("Height"),wxPG_LABEL,value.y) );
 206 }
 207
 208 wxSizeProperty::~wxSizeProperty() { }
 209
 210 void wxSizeProperty::RefreshChildren()
 211 {
 212     if ( !GetChildCount() ) return;
 213     const wxSize& size = wxSizeRefFromVariant(m_value);
 214     Item(0)->SetValue( (long)size.x );
 215     Item(1)->SetValue( (long)size.y );
 216 }
 217
 218 wxVariant wxSizeProperty::ChildChanged( wxVariant& thisValue,
 219                                         int childIndex,
 220                                         wxVariant& childValue ) const
 221 {
 222     wxSize& size = wxSizeRefFromVariant(thisValue);
 223     int val = wxPGVariantToInt(childValue);
 224     switch ( childIndex )
 225     {
 226         case 0: size.x = val; break;
 227         case 1: size.y = val; break;
 228     }
 229     wxVariant newVariant;
 230     newVariant << size;
 231     return newVariant;
 232 }
 233
 234 // -----------------------------------------------------------------------
 235 // wxPointProperty
 236 // -----------------------------------------------------------------------
 237
 238 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxPointProperty,wxPGProperty,
 239                                wxPoint,const wxPoint&,TextCtrl)
 240
 241 wxPointProperty::wxPointProperty( const wxString& label, const wxString& name,
 242     const wxPoint& value) : wxPGProperty(label,name)
 243 {
 244     SetValueI(value);
 245     AddPrivateChild( new wxIntProperty(wxT("X"),wxPG_LABEL,value.x) );
 246     AddPrivateChild( new wxIntProperty(wxT("Y"),wxPG_LABEL,value.y) );
 247 }
 248
 249 wxPointProperty::~wxPointProperty() { }
 250
 251 void wxPointProperty::RefreshChildren()
 252 {
 253     if ( !GetChildCount() ) return;
 254     const wxPoint& point = wxPointRefFromVariant(m_value);
 255     Item(0)->SetValue( (long)point.x );
 256     Item(1)->SetValue( (long)point.y );
 257 }
 258
 259 wxVariant wxPointProperty::ChildChanged( wxVariant& thisValue,
 260                                          int childIndex,
 261                                          wxVariant& childValue ) const
 262 {
 263     wxPoint& point = wxPointRefFromVariant(thisValue);
 264     int val = wxPGVariantToInt(childValue);
 265     switch ( childIndex )
 266     {
 267         case 0: point.x = val; break;
 268         case 1: point.y = val; break;
 269     }
 270     wxVariant newVariant;
 271     newVariant << point;
 272     return newVariant;
 273 }
 274
 275
 276 // -----------------------------------------------------------------------
 277 // Dirs Property
 278 // -----------------------------------------------------------------------
 279
 280 WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(wxDirsProperty,wxT(','),wxT("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 wxArrayEditorDialog
 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, wxArrayEditorDialog)
 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     : wxArrayEditorDialog()
 430 {
 431     Init();
 432 }
 433
 434 void wxArrayDoubleEditorDialog::Init()
 435 {
 436     wxArrayEditorDialog::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                               : wxArrayEditorDialog()
 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 wxArrayEditorDialog::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.length() )
 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