src/propgrid/property.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/propgrid/property.cpp
   3 // Purpose:     wxPGProperty and related support classes
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2008-08-23
   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/dcmemory.h"
  32     #include "wx/pen.h"
  33     #include "wx/brush.h"
  34     #include "wx/settings.h"
  35     #include "wx/intl.h"
  36 #endif
  37
  38 #include "wx/propgrid/propgrid.h"
  39
  40
  41 #define PWC_CHILD_SUMMARY_LIMIT         16 // Maximum number of children summarized in a parent property's
  42                                            // value field.
  43
  44 #define PWC_CHILD_SUMMARY_CHAR_LIMIT    64 // Character limit of summary field when not editing
  45
  46 #if wxPG_COMPATIBILITY_1_4
  47
  48 // Used to establish backwards compatiblity
  49 const char* g_invalidStringContent = "@__TOTALLY_INVALID_STRING__@";
  50
  51 #endif
  52
  53 // -----------------------------------------------------------------------
  54
  55 static void wxPGDrawFocusRect( wxDC& dc, const wxRect& rect )
  56 {
  57 #if defined(__WXMSW__) && !defined(__WXWINCE__)
  58     // FIXME: Use DrawFocusRect code above (currently it draws solid line
  59     //   for caption focus but works ok for other stuff).
  60     //   Also, it seems that this code may not work in future wx versions.
  61     dc.SetLogicalFunction(wxINVERT);
  62
  63     wxPen pen(*wxBLACK,1,wxDOT);
  64     pen.SetCap(wxCAP_BUTT);
  65     dc.SetPen(pen);
  66     dc.SetBrush(*wxTRANSPARENT_BRUSH);
  67
  68     dc.DrawRectangle(rect);
  69
  70     dc.SetLogicalFunction(wxCOPY);
  71 #else
  72     dc.SetLogicalFunction(wxINVERT);
  73
  74     dc.SetPen(wxPen(*wxBLACK,1,wxDOT));
  75     dc.SetBrush(*wxTRANSPARENT_BRUSH);
  76
  77     dc.DrawRectangle(rect);
  78
  79     dc.SetLogicalFunction(wxCOPY);
  80 #endif
  81 }
  82
  83 // -----------------------------------------------------------------------
  84 // wxPGCellRenderer
  85 // -----------------------------------------------------------------------
  86
  87 wxSize wxPGCellRenderer::GetImageSize( const wxPGProperty* WXUNUSED(property),
  88                                        int WXUNUSED(column),
  89                                        int WXUNUSED(item) ) const
  90 {
  91      return wxSize(0, 0);
  92 }
  93
  94 void wxPGCellRenderer::DrawText( wxDC& dc, const wxRect& rect,
  95                                  int xOffset, const wxString& text ) const
  96 {
  97     dc.DrawText( text,
  98                  rect.x+xOffset+wxPG_XBEFORETEXT,
  99                  rect.y+((rect.height-dc.GetCharHeight())/2) );
 100 }
 101
 102 void wxPGCellRenderer::DrawEditorValue( wxDC& dc, const wxRect& rect,
 103                                         int xOffset, const wxString& text,
 104                                         wxPGProperty* property,
 105                                         const wxPGEditor* editor ) const
 106 {
 107     int yOffset = ((rect.height-dc.GetCharHeight())/2);
 108
 109     if ( editor )
 110     {
 111         wxRect rect2(rect);
 112         rect2.x += xOffset;
 113         rect2.y += yOffset;
 114         rect2.height -= yOffset;
 115         editor->DrawValue( dc, rect2, property, text );
 116     }
 117     else
 118     {
 119         dc.DrawText( text,
 120                      rect.x+xOffset+wxPG_XBEFORETEXT,
 121                      rect.y+yOffset );
 122     }
 123 }
 124
 125 void wxPGCellRenderer::DrawCaptionSelectionRect( wxDC& dc, int x, int y, int w, int h ) const
 126 {
 127     wxRect focusRect(x,y+((h-dc.GetCharHeight())/2),w,h);
 128     wxPGDrawFocusRect(dc,focusRect);
 129 }
 130
 131 int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell& cell, int flags ) const
 132 {
 133     int imageWidth = 0;
 134
 135     // If possible, use cell colours
 136     if ( !(flags & DontUseCellBgCol) )
 137     {
 138         dc.SetPen(cell.GetBgCol());
 139         dc.SetBrush(cell.GetBgCol());
 140     }
 141
 142     if ( !(flags & DontUseCellFgCol) )
 143     {
 144         dc.SetTextForeground(cell.GetFgCol());
 145     }
 146
 147     // Draw Background, but only if not rendering in control
 148     // (as control already has rendered correct background).
 149     if ( !(flags & (Control|ChoicePopup)) )
 150         dc.DrawRectangle(rect);
 151
 152     // Use cell font, if provided
 153     const wxFont& font = cell.GetFont();
 154     if ( font.IsOk() )
 155         dc.SetFont(font);
 156
 157     const wxBitmap& bmp = cell.GetBitmap();
 158     if ( bmp.Ok() &&
 159         // Do not draw oversized bitmap outside choice popup
 160          ((flags & ChoicePopup) || bmp.GetHeight() < rect.height )
 161         )
 162     {
 163         dc.DrawBitmap( bmp,
 164                        rect.x + wxPG_CONTROL_MARGIN + wxCC_CUSTOM_IMAGE_MARGIN1,
 165                        rect.y + wxPG_CUSTOM_IMAGE_SPACINGY,
 166                        true );
 167         imageWidth = bmp.GetWidth();
 168     }
 169
 170     return imageWidth;
 171 }
 172
 173 void wxPGCellRenderer::PostDrawCell( wxDC& dc,
 174                                      const wxPropertyGrid* propGrid,
 175                                      const wxPGCell& cell,
 176                                      int WXUNUSED(flags) ) const
 177 {
 178     // Revert font
 179     const wxFont& font = cell.GetFont();
 180     if ( font.IsOk() )
 181         dc.SetFont(propGrid->GetFont());
 182 }
 183
 184 // -----------------------------------------------------------------------
 185 // wxPGDefaultRenderer
 186 // -----------------------------------------------------------------------
 187
 188 void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
 189                                   const wxPropertyGrid* propertyGrid, wxPGProperty* property,
 190                                   int column, int item, int flags ) const
 191 {
 192     bool isUnspecified = property->IsValueUnspecified();
 193
 194     if ( column == 1 && item == -1 )
 195     {
 196         int cmnVal = property->GetCommonValue();
 197         if ( cmnVal >= 0 )
 198         {
 199             // Common Value
 200             if ( !isUnspecified )
 201                 DrawText( dc, rect, 0, propertyGrid->GetCommonValueLabel(cmnVal) );
 202             return;
 203         }
 204     }
 205
 206     const wxPGEditor* editor = NULL;
 207     const wxPGCell* cell = NULL;
 208
 209     wxString text;
 210     int imageWidth = 0;
 211     int preDrawFlags = flags;
 212
 213     property->GetDisplayInfo(column, item, flags, &text, &cell);
 214
 215     imageWidth = PreDrawCell( dc, rect, *cell, preDrawFlags );
 216
 217     if ( column == 1 )
 218     {
 219         editor = property->GetColumnEditor(column);
 220
 221         if ( !isUnspecified )
 222         {
 223             // Regular property value
 224
 225             wxSize imageSize = propertyGrid->GetImageSize(property, item);
 226
 227             wxPGPaintData paintdata;
 228             paintdata.m_parent = propertyGrid;
 229             paintdata.m_choiceItem = item;
 230
 231             if ( imageSize.x > 0 )
 232             {
 233                 wxRect imageRect(rect.x + wxPG_CONTROL_MARGIN + wxCC_CUSTOM_IMAGE_MARGIN1,
 234                                  rect.y+wxPG_CUSTOM_IMAGE_SPACINGY,
 235                                  wxPG_CUSTOM_IMAGE_WIDTH,
 236                                  rect.height-(wxPG_CUSTOM_IMAGE_SPACINGY*2));
 237
 238                 dc.SetPen( wxPen(propertyGrid->GetCellTextColour(), 1, wxSOLID) );
 239
 240                 paintdata.m_drawnWidth = imageSize.x;
 241                 paintdata.m_drawnHeight = imageSize.y;
 242
 243                 property->OnCustomPaint( dc, imageRect, paintdata );
 244
 245                 imageWidth = paintdata.m_drawnWidth;
 246             }
 247
 248             text = property->GetValueAsString();
 249
 250             // Add units string?
 251             if ( propertyGrid->GetColumnCount() <= 2 )
 252             {
 253                 wxString unitsString = property->GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
 254                 if ( unitsString.length() )
 255                     text = wxString::Format(wxS("%s %s"), text.c_str(), unitsString.c_str() );
 256             }
 257         }
 258
 259         if ( text.length() == 0 )
 260         {
 261             // Try to show inline help if no text
 262             wxVariant vInlineHelp = property->GetAttribute(wxPGGlobalVars->m_strInlineHelp);
 263             if ( !vInlineHelp.IsNull() )
 264             {
 265                 text = vInlineHelp.GetString();
 266                 dc.SetTextForeground(propertyGrid->GetCellDisabledTextColour());
 267             }
 268         }
 269     }
 270
 271     int imageOffset = property->GetImageOffset(imageWidth);
 272
 273     DrawEditorValue( dc, rect, imageOffset, text, property, editor );
 274
 275     // active caption gets nice dotted rectangle
 276     if ( property->IsCategory() /*&& column == 0*/ )
 277     {
 278         if ( flags & Selected )
 279         {
 280             if ( imageOffset > 0 )
 281             {
 282                 imageOffset -= DEFAULT_IMAGE_OFFSET_INCREMENT;
 283                 imageOffset += wxCC_CUSTOM_IMAGE_MARGIN2 + 4;
 284             }
 285
 286             DrawCaptionSelectionRect( dc,
 287                                       rect.x+wxPG_XBEFORETEXT-wxPG_CAPRECTXMARGIN+imageOffset,
 288                                       rect.y-wxPG_CAPRECTYMARGIN+1,
 289                                       ((wxPropertyCategory*)property)->GetTextExtent(propertyGrid,
 290                                                                                      propertyGrid->GetCaptionFont())
 291                                       +(wxPG_CAPRECTXMARGIN*2),
 292                                       propertyGrid->GetFontHeight()+(wxPG_CAPRECTYMARGIN*2) );
 293         }
 294     }
 295
 296     PostDrawCell(dc, propertyGrid, *cell, preDrawFlags);
 297 }
 298
 299 wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
 300                                           int column,
 301                                           int item ) const
 302 {
 303     if ( property && column == 1 )
 304     {
 305         if ( item == -1 )
 306         {
 307             wxBitmap* bmp = property->GetValueImage();
 308
 309             if ( bmp && bmp->Ok() )
 310                 return wxSize(bmp->GetWidth(),bmp->GetHeight());
 311         }
 312     }
 313     return wxSize(0,0);
 314 }
 315
 316 // -----------------------------------------------------------------------
 317 // wxPGCellData
 318 // -----------------------------------------------------------------------
 319
 320 wxPGCellData::wxPGCellData()
 321     : wxObjectRefData()
 322 {
 323     m_hasValidText = false;
 324 }
 325
 326 // -----------------------------------------------------------------------
 327 // wxPGCell
 328 // -----------------------------------------------------------------------
 329
 330 wxPGCell::wxPGCell()
 331     : wxObject()
 332 {
 333 }
 334
 335 wxPGCell::wxPGCell( const wxString& text,
 336                     const wxBitmap& bitmap,
 337                     const wxColour& fgCol,
 338                     const wxColour& bgCol )
 339     : wxObject()
 340 {
 341     wxPGCellData* data = new wxPGCellData();
 342     m_refData = data;
 343     data->m_text = text;
 344     data->m_bitmap = bitmap;
 345     data->m_fgCol = fgCol;
 346     data->m_bgCol = bgCol;
 347     data->m_hasValidText = true;
 348 }
 349
 350 wxObjectRefData *wxPGCell::CloneRefData( const wxObjectRefData *data ) const
 351 {
 352     wxPGCellData* c = new wxPGCellData();
 353     const wxPGCellData* o = (const wxPGCellData*) data;
 354     c->m_text = o->m_text;
 355     c->m_bitmap = o->m_bitmap;
 356     c->m_fgCol = o->m_fgCol;
 357     c->m_bgCol = o->m_bgCol;
 358     c->m_hasValidText = o->m_hasValidText;
 359     return c;
 360 }
 361
 362 void wxPGCell::SetText( const wxString& text )
 363 {
 364     AllocExclusive();
 365
 366     GetData()->SetText(text);
 367 }
 368
 369 void wxPGCell::SetBitmap( const wxBitmap& bitmap )
 370 {
 371     AllocExclusive();
 372
 373     GetData()->SetBitmap(bitmap);
 374 }
 375
 376 void wxPGCell::SetFgCol( const wxColour& col )
 377 {
 378     AllocExclusive();
 379
 380     GetData()->SetFgCol(col);
 381 }
 382
 383 void wxPGCell::SetFont( const wxFont& font )
 384 {
 385     AllocExclusive();
 386
 387     GetData()->SetFont(font);
 388 }
 389
 390 void wxPGCell::SetBgCol( const wxColour& col )
 391 {
 392     AllocExclusive();
 393
 394     GetData()->SetBgCol(col);
 395 }
 396
 397 void wxPGCell::MergeFrom( const wxPGCell& srcCell )
 398 {
 399     AllocExclusive();
 400
 401     wxPGCellData* data = GetData();
 402
 403     if ( srcCell.HasText() )
 404         data->SetText(srcCell.GetText());
 405
 406     if ( srcCell.GetFgCol().IsOk() )
 407         data->SetFgCol(srcCell.GetFgCol());
 408
 409     if ( srcCell.GetBgCol().IsOk() )
 410         data->SetBgCol(srcCell.GetBgCol());
 411
 412     if ( srcCell.GetBitmap().IsOk() )
 413         data->SetBitmap(srcCell.GetBitmap());
 414 }
 415
 416 // -----------------------------------------------------------------------
 417 // wxPGProperty
 418 // -----------------------------------------------------------------------
 419
 420 IMPLEMENT_ABSTRACT_CLASS(wxPGProperty, wxObject)
 421
 422 wxString* wxPGProperty::sm_wxPG_LABEL = NULL;
 423
 424 void wxPGProperty::Init()
 425 {
 426     m_commonValue = -1;
 427     m_arrIndex = 0xFFFF;
 428     m_parent = NULL;
 429
 430     m_parentState = NULL;
 431
 432     m_clientData = NULL;
 433     m_clientObject = NULL;
 434
 435     m_customEditor = NULL;
 436 #if wxUSE_VALIDATORS
 437     m_validator = NULL;
 438 #endif
 439     m_valueBitmap = NULL;
 440
 441     m_maxLen = 0; // infinite maximum length
 442
 443     m_flags = wxPG_PROP_PROPERTY;
 444
 445     m_depth = 1;
 446
 447     SetExpanded(true);
 448 }
 449
 450
 451 void wxPGProperty::Init( const wxString& label, const wxString& name )
 452 {
 453     // We really need to check if &label and &name are NULL pointers
 454     // (this can if we are called before property grid has been initalized)
 455
 456     if ( (&label) != NULL && label != wxPG_LABEL )
 457         m_label = label;
 458
 459     if ( (&name) != NULL && name != wxPG_LABEL )
 460         DoSetName( name );
 461     else
 462         DoSetName( m_label );
 463
 464     Init();
 465 }
 466
 467 void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState,
 468                                    wxPropertyGrid* propgrid )
 469 {
 470     //
 471     // Called after property has been added to grid or page
 472     // (so propgrid can be NULL, too).
 473
 474     wxPGProperty* parent = m_parent;
 475     bool parentIsRoot = parent->IsKindOf(CLASSINFO(wxPGRootProperty));
 476
 477     m_parentState = pageState;
 478
 479 #if wxPG_COMPATIBILITY_1_4
 480     // Make sure deprecated virtual functions are not implemented
 481     wxString s = GetValueAsString( 0xFFFF );
 482     wxASSERT_MSG( s == g_invalidStringContent,
 483                   "Implement ValueToString() instead of GetValueAsString()" );
 484 #endif
 485
 486     if ( !parentIsRoot && !parent->IsCategory() )
 487     {
 488         m_cells = parent->m_cells;
 489     }
 490
 491     // If in hideable adding mode, or if assigned parent is hideable, then
 492     // make this one hideable.
 493     if (
 494          ( !parentIsRoot && parent->HasFlag(wxPG_PROP_HIDDEN) ) ||
 495          ( propgrid && (propgrid->HasInternalFlag(wxPG_FL_ADDING_HIDEABLES)) )
 496        )
 497         SetFlag( wxPG_PROP_HIDDEN );
 498
 499     // Set custom image flag.
 500     int custImgHeight = OnMeasureImage().y;
 501     if ( custImgHeight < 0 )
 502     {
 503         SetFlag(wxPG_PROP_CUSTOMIMAGE);
 504     }
 505
 506     if ( propgrid && (propgrid->HasFlag(wxPG_LIMITED_EDITING)) )
 507         SetFlag(wxPG_PROP_NOEDITOR);
 508
 509     // Make sure parent has some parental flags
 510     if ( !parent->HasFlag(wxPG_PROP_PARENTAL_FLAGS) )
 511         parent->SetParentalType(wxPG_PROP_MISC_PARENT);
 512
 513     if ( !IsCategory() )
 514     {
 515         // This is not a category.
 516
 517         // Depth.
 518         //
 519         unsigned char depth = 1;
 520         if ( !parentIsRoot )
 521         {
 522             depth = parent->m_depth;
 523             if ( !parent->IsCategory() )
 524                 depth++;
 525         }
 526         m_depth = depth;
 527         unsigned char greyDepth = depth;
 528
 529         if ( !parentIsRoot )
 530         {
 531             wxPropertyCategory* pc;
 532
 533             if ( parent->IsCategory() )
 534                 pc = (wxPropertyCategory* ) parent;
 535             else
 536                 // This conditional compile is necessary to
 537                 // bypass some compiler bug.
 538                 pc = pageState->GetPropertyCategory(parent);
 539
 540             if ( pc )
 541                 greyDepth = pc->GetDepth();
 542             else
 543                 greyDepth = parent->m_depthBgCol;
 544         }
 545
 546         m_depthBgCol = greyDepth;
 547     }
 548     else
 549     {
 550         // This is a category.
 551
 552         // depth
 553         unsigned char depth = 1;
 554         if ( !parentIsRoot )
 555         {
 556             depth = parent->m_depth + 1;
 557         }
 558         m_depth = depth;
 559         m_depthBgCol = depth;
 560     }
 561
 562     //
 563     // Has initial children
 564     if ( GetChildCount() )
 565     {
 566         // Check parental flags
 567         wxASSERT_MSG( ((m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
 568                             wxPG_PROP_AGGREGATE) ||
 569                       ((m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
 570                             wxPG_PROP_MISC_PARENT),
 571                       "wxPGProperty parental flags set incorrectly at "
 572                       "this time" );
 573
 574         if ( HasFlag(wxPG_PROP_AGGREGATE) )
 575         {
 576             // Properties with private children are not expanded by default.
 577             SetExpanded(false);
 578         }
 579         else if ( propgrid && propgrid->HasFlag(wxPG_HIDE_MARGIN) )
 580         {
 581             // ...unless it cannot be expanded by user and therefore must
 582             // remain visible at all times
 583             SetExpanded(true);
 584         }
 585
 586         //
 587         // Prepare children recursively
 588         for ( unsigned int i=0; i<GetChildCount(); i++ )
 589         {
 590             wxPGProperty* child = Item(i);
 591             child->InitAfterAdded(pageState, pageState->GetGrid());
 592         }
 593
 594         if ( propgrid && (propgrid->GetExtraStyle() & wxPG_EX_AUTO_UNSPECIFIED_VALUES) )
 595             SetFlagRecursively(wxPG_PROP_AUTO_UNSPECIFIED, true);
 596     }
 597 }
 598
 599 wxPGProperty::wxPGProperty()
 600     : wxObject()
 601 {
 602     Init();
 603 }
 604
 605
 606 wxPGProperty::wxPGProperty( const wxString& label, const wxString& name )
 607     : wxObject()
 608 {
 609     Init( label, name );
 610 }
 611
 612
 613 wxPGProperty::~wxPGProperty()
 614 {
 615     delete m_clientObject;
 616
 617     Empty();  // this deletes items
 618
 619     delete m_valueBitmap;
 620 #if wxUSE_VALIDATORS
 621     delete m_validator;
 622 #endif
 623
 624     // This makes it easier for us to detect dangling pointers
 625     m_parent = NULL;
 626 }
 627
 628
 629 bool wxPGProperty::IsSomeParent( wxPGProperty* candidate ) const
 630 {
 631     wxPGProperty* parent = m_parent;
 632     do
 633     {
 634         if ( parent == candidate )
 635             return true;
 636         parent = parent->m_parent;
 637     } while ( parent );
 638     return false;
 639 }
 640
 641 void wxPGProperty::SetName( const wxString& newName )
 642 {
 643     wxPropertyGrid* pg = GetGrid();
 644
 645     if ( pg )
 646         pg->SetPropertyName(this, newName);
 647     else
 648         DoSetName(newName);
 649 }
 650
 651 wxString wxPGProperty::GetName() const
 652 {
 653     wxPGProperty* parent = GetParent();
 654
 655     if ( !m_name.length() || !parent || parent->IsCategory() || parent->IsRoot() )
 656         return m_name;
 657
 658     return m_parent->GetName() + wxS(".") + m_name;
 659 }
 660
 661 wxPropertyGrid* wxPGProperty::GetGrid() const
 662 {
 663     if ( !m_parentState )
 664         return NULL;
 665     return m_parentState->GetGrid();
 666 }
 667
 668 int wxPGProperty::Index( const wxPGProperty* p ) const
 669 {
 670     for ( unsigned int i = 0; i<m_children.size(); i++ )
 671     {
 672         if ( p == m_children[i] )
 673             return i;
 674     }
 675     return wxNOT_FOUND;
 676 }
 677
 678 bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const
 679 {
 680     return true;
 681 }
 682
 683 void wxPGProperty::OnSetValue()
 684 {
 685 }
 686
 687 void wxPGProperty::RefreshChildren ()
 688 {
 689 }
 690
 691 void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )
 692 {
 693 }
 694
 695 void wxPGProperty::GetDisplayInfo( unsigned int column,
 696                                    int choiceIndex,
 697                                    int flags,
 698                                    wxString* pString,
 699                                    const wxPGCell** pCell )
 700 {
 701     const wxPGCell* cell = NULL;
 702
 703     if ( !(flags & wxPGCellRenderer::ChoicePopup) )
 704     {
 705         // Not painting listi of choice popups, so get text from property
 706         cell = &GetCell(column);
 707         if ( cell->HasText() )
 708         {
 709             *pString = cell->GetText();
 710         }
 711         else
 712         {
 713             if ( column == 0 )
 714                 *pString = GetLabel();
 715             else if ( column == 1 )
 716                 *pString = GetDisplayedString();
 717             else if ( column == 2 )
 718                 *pString = GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
 719         }
 720     }
 721     else
 722     {
 723         wxASSERT( column == 1 );
 724
 725         if ( choiceIndex != wxNOT_FOUND )
 726         {
 727             const wxPGChoiceEntry& entry = m_choices[choiceIndex];
 728             if ( entry.GetBitmap().IsOk() ||
 729                  entry.GetFgCol().IsOk() ||
 730                  entry.GetBgCol().IsOk() )
 731                 cell = &entry;
 732             *pString = m_choices.GetLabel(choiceIndex);
 733         }
 734     }
 735
 736     if ( !cell )
 737         cell = &GetCell(column);
 738
 739     wxASSERT_MSG( cell->GetData(),
 740                   wxString::Format("Invalid cell for property %s",
 741                                    GetName().c_str()) );
 742
 743     *pCell = cell;
 744 }
 745
 746 /*
 747 wxString wxPGProperty::GetColumnText( unsigned int col, int choiceIndex ) const
 748 {
 749
 750     if ( col != 1 || choiceIndex == wxNOT_FOUND )
 751     {
 752         const wxPGCell& cell = GetCell(col);
 753         if ( cell->HasText() )
 754         {
 755             return cell->GetText();
 756         }
 757         else
 758         {
 759             if ( col == 0 )
 760                 return GetLabel();
 761             else if ( col == 1 )
 762                 return GetDisplayedString();
 763             else if ( col == 2 )
 764                 return GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
 765         }
 766     }
 767     else
 768     {
 769         // Use choice
 770         return m_choices.GetLabel(choiceIndex);
 771     }
 772
 773     return wxEmptyString;
 774 }
 775 */
 776
 777 void wxPGProperty::DoGenerateComposedValue( wxString& text,
 778                                             int argFlags,
 779                                             const wxVariantList* valueOverrides,
 780                                             wxPGHashMapS2S* childResults ) const
 781 {
 782     int i;
 783     int iMax = m_children.size();
 784
 785     text.clear();
 786     if ( iMax == 0 )
 787         return;
 788
 789     if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
 790          !(argFlags & wxPG_FULL_VALUE) )
 791         iMax = PWC_CHILD_SUMMARY_LIMIT;
 792
 793     int iMaxMinusOne = iMax-1;
 794
 795     if ( !IsTextEditable() )
 796         argFlags |= wxPG_UNEDITABLE_COMPOSITE_FRAGMENT;
 797
 798     wxPGProperty* curChild = m_children[0];
 799
 800     bool overridesLeft = false;
 801     wxVariant overrideValue;
 802     wxVariantList::const_iterator node;
 803
 804     if ( valueOverrides )
 805     {
 806         node = valueOverrides->begin();
 807         if ( node != valueOverrides->end() )
 808         {
 809             overrideValue = *node;
 810             overridesLeft = true;
 811         }
 812     }
 813
 814     for ( i = 0; i < iMax; i++ )
 815     {
 816         wxVariant childValue;
 817
 818         wxString childLabel = curChild->GetLabel();
 819
 820         // Check for value override
 821         if ( overridesLeft && overrideValue.GetName() == childLabel )
 822         {
 823             if ( !overrideValue.IsNull() )
 824                 childValue = overrideValue;
 825             else
 826                 childValue = curChild->GetValue();
 827             ++node;
 828             if ( node != valueOverrides->end() )
 829                 overrideValue = *node;
 830             else
 831                 overridesLeft = false;
 832         }
 833         else
 834         {
 835             childValue = curChild->GetValue();
 836         }
 837
 838         wxString s;
 839         if ( !childValue.IsNull() )
 840         {
 841             if ( overridesLeft &&
 842                  curChild->HasFlag(wxPG_PROP_COMPOSED_VALUE) &&
 843                  childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
 844             {
 845                 wxVariantList& childList = childValue.GetList();
 846                 DoGenerateComposedValue(s, argFlags|wxPG_COMPOSITE_FRAGMENT,
 847                                         &childList, childResults);
 848             }
 849             else
 850             {
 851                 s = curChild->ValueToString(childValue,
 852                                             argFlags|wxPG_COMPOSITE_FRAGMENT);
 853             }
 854         }
 855
 856         if ( childResults && curChild->GetChildCount() )
 857             (*childResults)[curChild->GetName()] = s;
 858
 859         bool skip = false;
 860         if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && !s.length() )
 861             skip = true;
 862
 863         if ( !curChild->GetChildCount() || skip )
 864             text += s;
 865         else
 866             text += wxS("[") + s + wxS("]");
 867
 868         if ( i < iMaxMinusOne )
 869         {
 870             if ( text.length() > PWC_CHILD_SUMMARY_CHAR_LIMIT &&
 871                  !(argFlags & wxPG_EDITABLE_VALUE) &&
 872                  !(argFlags & wxPG_FULL_VALUE) )
 873                 break;
 874
 875             if ( !skip )
 876             {
 877                 if ( !curChild->GetChildCount() )
 878                     text += wxS("; ");
 879                 else
 880                     text += wxS(" ");
 881             }
 882
 883             curChild = m_children[i+1];
 884         }
 885     }
 886
 887     if ( (unsigned int)i < m_children.size() )
 888     {
 889         if ( !text.EndsWith(wxS("; ")) )
 890             text += wxS("; ...");
 891         else
 892             text += wxS("...");
 893     }
 894 }
 895
 896 wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value),
 897                                       int argFlags ) const
 898 {
 899     wxCHECK_MSG( GetChildCount() > 0,
 900                  wxString(),
 901                  "If user property does not have any children, it must "
 902                  "override GetValueAsString" );
 903
 904     // FIXME: Currently code below only works if value is actually m_value
 905     wxASSERT_MSG( argFlags & wxPG_VALUE_IS_CURRENT,
 906                   "Sorry, currently default wxPGProperty::ValueToString() "
 907                   "implementation only works if value is m_value." );
 908
 909     wxString text;
 910     DoGenerateComposedValue(text, argFlags);
 911     return text;
 912 }
 913
 914 wxString wxPGProperty::GetValueAsString( int argFlags ) const
 915 {
 916 #if wxPG_COMPATIBILITY_1_4
 917     // This is backwards compatibility test
 918     // That is, to make sure this function is not overridden
 919     // (instead, ValueToString() should be).
 920     if ( argFlags == 0xFFFF )
 921     {
 922         // Do not override! (for backwards compliancy)
 923         return g_invalidStringContent;
 924     }
 925 #endif
 926
 927     if ( IsValueUnspecified() )
 928         return wxEmptyString;
 929
 930     if ( m_commonValue == -1 )
 931     {
 932         wxVariant value(GetValue());
 933         return ValueToString(value, argFlags|wxPG_VALUE_IS_CURRENT);
 934     }
 935
 936     //
 937     // Return common value's string representation
 938     wxPropertyGrid* pg = GetGrid();
 939     const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue);
 940
 941     if ( argFlags & wxPG_FULL_VALUE )
 942     {
 943         return cv->GetLabel();
 944     }
 945     else if ( argFlags & wxPG_EDITABLE_VALUE )
 946     {
 947         return cv->GetEditableText();
 948     }
 949     else
 950     {
 951         return cv->GetLabel();
 952     }
 953 }
 954
 955 wxString wxPGProperty::GetValueString( int argFlags ) const
 956 {
 957     return GetValueAsString(argFlags);
 958 }
 959
 960 bool wxPGProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
 961 {
 962     variant = (long)number;
 963     return true;
 964 }
 965
 966 // Convert semicolon delimited tokens into child values.
 967 bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
 968 {
 969     if ( !GetChildCount() )
 970         return false;
 971
 972     unsigned int curChild = 0;
 973
 974     unsigned int iMax = m_children.size();
 975
 976     if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
 977          !(argFlags & wxPG_FULL_VALUE) )
 978         iMax = PWC_CHILD_SUMMARY_LIMIT;
 979
 980     bool changed = false;
 981
 982     wxString token;
 983     size_t pos = 0;
 984
 985     // Its best only to add non-empty group items
 986     bool addOnlyIfNotEmpty = false;
 987     const wxChar delimeter = wxS(';');
 988
 989     size_t tokenStart = 0xFFFFFF;
 990
 991     wxVariantList temp_list;
 992     wxVariant list(temp_list);
 993
 994     int propagatedFlags = argFlags & (wxPG_REPORT_ERROR|wxPG_PROGRAMMATIC_VALUE);
 995
 996     wxLogTrace("propgrid",
 997                wxT(">> %s.StringToValue('%s')"), GetLabel(), text);
 998
 999     wxString::const_iterator it = text.begin();
1000     wxUniChar a;
1001
1002     if ( it != text.end() )
1003         a = *it;
1004     else
1005         a = 0;
1006
1007     for ( ;; )
1008     {
1009         // How many units we iterate string forward at the end of loop?
1010         // We need to keep track of this or risk going to negative
1011         // with it-- operation.
1012         unsigned int strPosIncrement = 1;
1013
1014         if ( tokenStart != 0xFFFFFF )
1015         {
1016             // Token is running
1017             if ( a == delimeter || a == 0 )
1018             {
1019                 token = text.substr(tokenStart,pos-tokenStart);
1020                 token.Trim(true);
1021                 size_t len = token.length();
1022
1023                 if ( !addOnlyIfNotEmpty || len > 0 )
1024                 {
1025                     const wxPGProperty* child = Item(curChild);
1026                     wxVariant variant(child->GetValue());
1027                     wxString childName = child->GetBaseName();
1028
1029                     wxLogTrace("propgrid",
1030                                wxT("token = '%s', child = %s"),
1031                                token, childName);
1032
1033                     // Add only if editable or setting programmatically
1034                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
1035                          !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
1036                     {
1037                         if ( len > 0 )
1038                         {
1039                             if ( child->StringToValue(variant, token,
1040                                  propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
1041                             {
1042                                 // We really need to set the variant's name
1043                                 // *after* child->StringToValue() has been
1044                                 // called, since variant's value may be set by
1045                                 // assigning another variant into it, which
1046                                 // then usually causes name to be copied (ie.
1047                                 // usually cleared) as well. wxBoolProperty
1048                                 // being case in point with its use of
1049                                 // wxPGVariant_Bool macro as an optimization.
1050                                 variant.SetName(childName);
1051                                 list.Append(variant);
1052
1053                                 changed = true;
1054                             }
1055                         }
1056                         else
1057                         {
1058                             // Empty, becomes unspecified
1059                             variant.MakeNull();
1060                             variant.SetName(childName);
1061                             list.Append(variant);
1062                             changed = true;
1063                         }
1064                     }
1065
1066                     curChild++;
1067                     if ( curChild >= iMax )
1068                         break;
1069                 }
1070
1071                 tokenStart = 0xFFFFFF;
1072             }
1073         }
1074         else
1075         {
1076             // Token is not running
1077             if ( a != wxS(' ') )
1078             {
1079
1080                 addOnlyIfNotEmpty = false;
1081
1082                 // Is this a group of tokens?
1083                 if ( a == wxS('[') )
1084                 {
1085                     int depth = 1;
1086
1087                     if ( it != text.end() ) ++it;
1088                     pos++;
1089                     size_t startPos = pos;
1090
1091                     // Group item - find end
1092                     while ( it != text.end() && depth > 0 )
1093                     {
1094                         a = *it;
1095                         ++it;
1096                         pos++;
1097
1098                         if ( a == wxS(']') )
1099                             depth--;
1100                         else if ( a == wxS('[') )
1101                             depth++;
1102                     }
1103
1104                     token = text.substr(startPos,pos-startPos-1);
1105
1106                     if ( !token.length() )
1107                         break;
1108
1109                     const wxPGProperty* child = Item(curChild);
1110
1111                     wxVariant oldChildValue = child->GetValue();
1112                     wxVariant variant(oldChildValue);
1113
1114                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
1115                          !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
1116                     {
1117                         wxString childName = child->GetBaseName();
1118
1119                         bool stvRes = child->StringToValue( variant, token,
1120                                                             propagatedFlags );
1121                         if ( stvRes || (variant != oldChildValue) )
1122                         {
1123                             variant.SetName(childName);
1124                             list.Append(variant);
1125
1126                             changed = true;
1127                         }
1128                         else
1129                         {
1130                             // No changes...
1131                         }
1132                     }
1133
1134                     curChild++;
1135                     if ( curChild >= iMax )
1136                         break;
1137
1138                     addOnlyIfNotEmpty = true;
1139
1140                     tokenStart = 0xFFFFFF;
1141                 }
1142                 else
1143                 {
1144                     tokenStart = pos;
1145
1146                     if ( a == delimeter )
1147                         strPosIncrement -= 1;
1148                 }
1149             }
1150         }
1151
1152         if ( a == 0 )
1153             break;
1154
1155         it += strPosIncrement;
1156
1157         if ( it != text.end() )
1158         {
1159             a = *it;
1160         }
1161         else
1162         {
1163             a = 0;
1164         }
1165
1166         pos += strPosIncrement;
1167     }
1168
1169     if ( changed )
1170         variant = list;
1171
1172     return changed;
1173 }
1174
1175 bool wxPGProperty::SetValueFromString( const wxString& text, int argFlags )
1176 {
1177     wxVariant variant(m_value);
1178     bool res = StringToValue(variant, text, argFlags);
1179     if ( res )
1180         SetValue(variant);
1181     return res;
1182 }
1183
1184 bool wxPGProperty::SetValueFromInt( long number, int argFlags )
1185 {
1186     wxVariant variant(m_value);
1187     bool res = IntToValue(variant, number, argFlags);
1188     if ( res )
1189         SetValue(variant);
1190     return res;
1191 }
1192
1193 wxSize wxPGProperty::OnMeasureImage( int WXUNUSED(item) ) const
1194 {
1195     if ( m_valueBitmap )
1196         return wxSize(m_valueBitmap->GetWidth(),-1);
1197
1198     return wxSize(0,0);
1199 }
1200
1201 int wxPGProperty::GetImageOffset( int imageWidth ) const
1202 {
1203     int imageOffset = 0;
1204
1205     if ( imageWidth )
1206     {
1207         // Do not increment offset too much for wide images
1208         if ( imageWidth <= (wxPG_CUSTOM_IMAGE_WIDTH+5) )
1209             imageOffset = imageWidth + DEFAULT_IMAGE_OFFSET_INCREMENT;
1210         else
1211             imageOffset = imageWidth + 1;
1212     }
1213
1214     return imageOffset;
1215 }
1216
1217 wxPGCellRenderer* wxPGProperty::GetCellRenderer( int WXUNUSED(column) ) const
1218 {
1219     return wxPGGlobalVars->m_defaultRenderer;
1220 }
1221
1222 void wxPGProperty::OnCustomPaint( wxDC& dc,
1223                                   const wxRect& rect,
1224                                   wxPGPaintData& )
1225 {
1226     wxBitmap* bmp = m_valueBitmap;
1227
1228     wxCHECK_RET( bmp && bmp->Ok(), wxT("invalid bitmap") );
1229
1230     wxCHECK_RET( rect.x >= 0, wxT("unexpected measure call") );
1231
1232     dc.DrawBitmap(*bmp,rect.x,rect.y);
1233 }
1234
1235 const wxPGEditor* wxPGProperty::DoGetEditorClass() const
1236 {
1237     return wxPGEditor_TextCtrl;
1238 }
1239
1240 // Default extra property event handling - that is, none at all.
1241 bool wxPGProperty::OnEvent( wxPropertyGrid*, wxWindow*, wxEvent& )
1242 {
1243     return false;
1244 }
1245
1246
1247 void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
1248 {
1249     // If auto unspecified values are not wanted (via window or property style),
1250     // then get default value instead of wxNullVariant.
1251     if ( value.IsNull() && (flags & wxPG_SETVAL_BY_USER) &&
1252          !UsesAutoUnspecified() )
1253     {
1254         value = GetDefaultValue();
1255     }
1256
1257     if ( !value.IsNull() )
1258     {
1259         wxVariant tempListVariant;
1260
1261         SetCommonValue(-1);
1262         // List variants are reserved a special purpose
1263         // as intermediate containers for child values
1264         // of properties with children.
1265         if ( value.GetType() == wxPG_VARIANT_TYPE_LIST )
1266         {
1267             //
1268             // However, situation is different for composed string properties
1269             if ( HasFlag(wxPG_PROP_COMPOSED_VALUE) )
1270             {
1271                 tempListVariant = value;
1272                 pList = &tempListVariant;
1273             }
1274
1275             wxVariant newValue;
1276             AdaptListToValue(value, &newValue);
1277             value = newValue;
1278             //wxLogDebug(wxT(">> %s.SetValue() adapted list value to type '%s'"),GetName().c_str(),value.GetType().c_str());
1279         }
1280
1281         if ( HasFlag( wxPG_PROP_AGGREGATE) )
1282             flags |= wxPG_SETVAL_AGGREGATED;
1283
1284         if ( pList && !pList->IsNull() )
1285         {
1286             wxASSERT( pList->GetType() == wxPG_VARIANT_TYPE_LIST );
1287             wxASSERT( GetChildCount() );
1288             wxASSERT( !IsCategory() );
1289
1290             wxVariantList& list = pList->GetList();
1291             wxVariantList::iterator node;
1292             unsigned int i = 0;
1293
1294             //wxLogDebug(wxT(">> %s.SetValue() pList parsing"),GetName().c_str());
1295
1296             // Children in list can be in any order, but we will give hint to
1297             // GetPropertyByNameWH(). This optimizes for full list parsing.
1298             for ( node = list.begin(); node != list.end(); ++node )
1299             {
1300                 wxVariant& childValue = *((wxVariant*)*node);
1301                 wxPGProperty* child = GetPropertyByNameWH(childValue.GetName(), i);
1302                 if ( child )
1303                 {
1304                     //wxLogDebug(wxT("%i: child = %s, childValue.GetType()=%s"),i,child->GetBaseName().c_str(),childValue.GetType().c_str());
1305                     if ( childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
1306                     {
1307                         if ( child->HasFlag(wxPG_PROP_AGGREGATE) && !(flags & wxPG_SETVAL_AGGREGATED) )
1308                         {
1309                             wxVariant listRefCopy = childValue;
1310                             child->SetValue(childValue, &listRefCopy, flags|wxPG_SETVAL_FROM_PARENT);
1311                         }
1312                         else
1313                         {
1314                             wxVariant oldVal = child->GetValue();
1315                             child->SetValue(oldVal, &childValue, flags|wxPG_SETVAL_FROM_PARENT);
1316                         }
1317                     }
1318                     else if ( child->GetValue() != childValue )
1319                     {
1320                         // For aggregate properties, we will trust RefreshChildren()
1321                         // to update child values.
1322                         if ( !HasFlag(wxPG_PROP_AGGREGATE) )
1323                             child->SetValue(childValue, NULL, flags|wxPG_SETVAL_FROM_PARENT);
1324                         if ( flags & wxPG_SETVAL_BY_USER )
1325                             child->SetFlag(wxPG_PROP_MODIFIED);
1326                     }
1327                 }
1328                 i++;
1329             }
1330         }
1331
1332         if ( !value.IsNull() )
1333         {
1334             m_value = value;
1335             OnSetValue();
1336         }
1337
1338         if ( flags & wxPG_SETVAL_BY_USER )
1339             SetFlag(wxPG_PROP_MODIFIED);
1340
1341         if ( HasFlag(wxPG_PROP_AGGREGATE) )
1342             RefreshChildren();
1343     }
1344     else
1345     {
1346         if ( m_commonValue != -1 )
1347         {
1348             wxPropertyGrid* pg = GetGrid();
1349             if ( !pg || m_commonValue != pg->GetUnspecifiedCommonValue() )
1350                 SetCommonValue(-1);
1351         }
1352
1353         m_value = value;
1354
1355         // Set children to unspecified, but only if aggregate or
1356         // value is <composed>
1357         if ( AreChildrenComponents() )
1358         {
1359             unsigned int i;
1360             for ( i=0; i<GetChildCount(); i++ )
1361                 Item(i)->SetValue(value, NULL, flags|wxPG_SETVAL_FROM_PARENT);
1362         }
1363     }
1364
1365     if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
1366         UpdateParentValues();
1367
1368     //
1369     // Update editor control
1370     //
1371
1372     // We need to check for these, otherwise GetGrid() may fail.
1373     if ( flags & wxPG_SETVAL_REFRESH_EDITOR )
1374     {
1375         RefreshEditor();
1376         wxPropertyGrid* pg = GetGridIfDisplayed();
1377         if ( pg )
1378             pg->DrawItemAndValueRelated(this);
1379     }
1380 }
1381
1382
1383 void wxPGProperty::SetValueInEvent( wxVariant value ) const
1384 {
1385     GetGrid()->ValueChangeInEvent(value);
1386 }
1387
1388 void wxPGProperty::SetFlagRecursively( FlagType flag, bool set )
1389 {
1390     ChangeFlag(flag, set);
1391
1392     unsigned int i;
1393     for ( i = 0; i < GetChildCount(); i++ )
1394         Item(i)->SetFlagRecursively(flag, set);
1395 }
1396
1397 void wxPGProperty::RefreshEditor()
1398 {
1399     if ( !m_parent )
1400         return;
1401
1402     wxPropertyGrid* pg = GetGrid();
1403     if ( pg && pg->GetSelectedProperty() == this )
1404         pg->RefreshEditor();
1405 }
1406
1407 wxVariant wxPGProperty::GetDefaultValue() const
1408 {
1409     wxVariant defVal = GetAttribute(wxPG_ATTR_DEFAULT_VALUE);
1410     if ( !defVal.IsNull() )
1411         return defVal;
1412
1413     wxVariant value = GetValue();
1414
1415     if ( !value.IsNull() )
1416     {
1417         wxString valueType(value.GetType());
1418
1419         if ( valueType == wxPG_VARIANT_TYPE_LONG )
1420             return wxPGVariant_Zero;
1421         if ( valueType == wxPG_VARIANT_TYPE_STRING )
1422             return wxPGVariant_EmptyString;
1423         if ( valueType == wxPG_VARIANT_TYPE_BOOL )
1424             return wxPGVariant_False;
1425         if ( valueType == wxPG_VARIANT_TYPE_DOUBLE )
1426             return wxVariant(0.0);
1427         if ( valueType == wxPG_VARIANT_TYPE_ARRSTRING )
1428             return wxVariant(wxArrayString());
1429         if ( valueType == wxS("wxLongLong") )
1430             return WXVARIANT(wxLongLong(0));
1431         if ( valueType == wxS("wxULongLong") )
1432             return WXVARIANT(wxULongLong(0));
1433         if ( valueType == wxS("wxColour") )
1434             return WXVARIANT(*wxBLACK);
1435 #if wxUSE_DATETIME
1436         if ( valueType == wxPG_VARIANT_TYPE_DATETIME )
1437             return wxVariant(wxDateTime::Now());
1438 #endif
1439         if ( valueType == wxS("wxFont") )
1440             return WXVARIANT(*wxNORMAL_FONT);
1441         if ( valueType == wxS("wxPoint") )
1442             return WXVARIANT(wxPoint(0, 0));
1443         if ( valueType == wxS("wxSize") )
1444             return WXVARIANT(wxSize(0, 0));
1445     }
1446
1447     return wxVariant();
1448 }
1449
1450 void wxPGProperty::EnsureCells( unsigned int column )
1451 {
1452     if ( column >= m_cells.size() )
1453     {
1454         // Fill empty slots with default cells
1455         wxPropertyGrid* pg = GetGrid();
1456         wxPGCell defaultCell;
1457
1458         // Work around possible VC6 bug by using intermediate variables
1459         const wxPGCell& propDefCell = pg->GetPropertyDefaultCell();
1460         const wxPGCell& catDefCell = pg->GetCategoryDefaultCell();
1461
1462         if ( !HasFlag(wxPG_PROP_CATEGORY) )
1463             defaultCell = propDefCell;
1464         else
1465             defaultCell = catDefCell;
1466
1467         // TODO: Replace with resize() call
1468         unsigned int cellCountMax = column+1;
1469
1470         for ( unsigned int i=m_cells.size(); i<cellCountMax; i++ )
1471             m_cells.push_back(defaultCell);
1472     }
1473 }
1474
1475 void wxPGProperty::SetCell( int column,
1476                             const wxPGCell& cell )
1477 {
1478     EnsureCells(column);
1479
1480     m_cells[column] = cell;
1481 }
1482
1483 void wxPGProperty::AdaptiveSetCell( unsigned int firstCol,
1484                                     unsigned int lastCol,
1485                                     const wxPGCell& cell,
1486                                     const wxPGCell& srcData,
1487                                     wxPGCellData* unmodCellData,
1488                                     FlagType ignoreWithFlags,
1489                                     bool recursively )
1490 {
1491     //
1492     // Sets cell in memory optimizing fashion. That is, if
1493     // current cell data matches unmodCellData, we will
1494     // simply get reference to data from cell. Otherwise,
1495     // cell information from srcData is merged into current.
1496     //
1497
1498     if ( !(m_flags & ignoreWithFlags) && !IsRoot() )
1499     {
1500         EnsureCells(lastCol);
1501
1502         for ( unsigned int col=firstCol; col<=lastCol; col++ )
1503         {
1504             if ( m_cells[col].GetData() == unmodCellData )
1505             {
1506                 // Data matches... use cell directly
1507                 m_cells[col] = cell;
1508             }
1509             else
1510             {
1511                 // Data did not match... merge valid information
1512                 m_cells[col].MergeFrom(srcData);
1513             }
1514         }
1515     }
1516
1517     if ( recursively )
1518     {
1519         for ( unsigned int i=0; i<GetChildCount(); i++ )
1520             Item(i)->AdaptiveSetCell( firstCol,
1521                                       lastCol,
1522                                       cell,
1523                                       srcData,
1524                                       unmodCellData,
1525                                       ignoreWithFlags,
1526                                       recursively );
1527     }
1528 }
1529
1530 const wxPGCell& wxPGProperty::GetCell( unsigned int column ) const
1531 {
1532     if ( m_cells.size() > column )
1533         return m_cells[column];
1534
1535     wxPropertyGrid* pg = GetGrid();
1536
1537     if ( IsCategory() )
1538         return pg->GetCategoryDefaultCell();
1539
1540     return pg->GetPropertyDefaultCell();
1541 }
1542
1543 wxPGCell& wxPGProperty::GetOrCreateCell( unsigned int column )
1544 {
1545     EnsureCells(column);
1546     return m_cells[column];
1547 }
1548
1549 void wxPGProperty::SetBackgroundColour( const wxColour& colour,
1550                                         int flags )
1551 {
1552     wxPGProperty* firstProp = this;
1553     bool recursively = flags & wxPG_RECURSE ? true : false;
1554
1555     //
1556     // If category is tried to set recursively, skip it and only
1557     // affect the children.
1558     if ( recursively )
1559     {
1560         while ( firstProp->IsCategory() )
1561         {
1562             if ( !firstProp->GetChildCount() )
1563                 return;
1564             firstProp = firstProp->Item(0);
1565         }
1566     }
1567
1568     wxPGCell& firstCell = firstProp->GetCell(0);
1569     wxPGCellData* firstCellData = firstCell.GetData();
1570
1571     wxPGCell newCell(firstCell);
1572     newCell.SetBgCol(colour);
1573     wxPGCell srcCell;
1574     srcCell.SetBgCol(colour);
1575
1576     AdaptiveSetCell( 0,
1577                      GetParentState()->GetColumnCount()-1,
1578                      newCell,
1579                      srcCell,
1580                      firstCellData,
1581                      recursively ? wxPG_PROP_CATEGORY : 0,
1582                      recursively );
1583 }
1584
1585 void wxPGProperty::SetTextColour( const wxColour& colour,
1586                                   int flags )
1587 {
1588     wxPGProperty* firstProp = this;
1589     bool recursively = flags & wxPG_RECURSE ? true : false;
1590
1591     //
1592     // If category is tried to set recursively, skip it and only
1593     // affect the children.
1594     if ( recursively )
1595     {
1596         while ( firstProp->IsCategory() )
1597         {
1598             if ( !firstProp->GetChildCount() )
1599                 return;
1600             firstProp = firstProp->Item(0);
1601         }
1602     }
1603
1604     wxPGCell& firstCell = firstProp->GetCell(0);
1605     wxPGCellData* firstCellData = firstCell.GetData();
1606
1607     wxPGCell newCell(firstCell);
1608     newCell.SetFgCol(colour);
1609     wxPGCell srcCell;
1610     srcCell.SetFgCol(colour);
1611
1612     AdaptiveSetCell( 0,
1613                      GetParentState()->GetColumnCount()-1,
1614                      newCell,
1615                      srcCell,
1616                      firstCellData,
1617                      recursively ? wxPG_PROP_CATEGORY : 0,
1618                      recursively );
1619 }
1620
1621 wxPGEditorDialogAdapter* wxPGProperty::GetEditorDialog() const
1622 {
1623     return NULL;
1624 }
1625
1626 bool wxPGProperty::DoSetAttribute( const wxString& WXUNUSED(name), wxVariant& WXUNUSED(value) )
1627 {
1628     return false;
1629 }
1630
1631 void wxPGProperty::SetAttribute( const wxString& name, wxVariant value )
1632 {
1633     if ( DoSetAttribute( name, value ) )
1634     {
1635         // Support working without grid, when possible
1636         if ( wxPGGlobalVars->HasExtraStyle( wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES ) )
1637             return;
1638     }
1639
1640     m_attributes.Set( name, value );
1641 }
1642
1643 void wxPGProperty::SetAttributes( const wxPGAttributeStorage& attributes )
1644 {
1645     wxPGAttributeStorage::const_iterator it = attributes.StartIteration();
1646     wxVariant variant;
1647
1648     while ( attributes.GetNext(it, variant) )
1649         SetAttribute( variant.GetName(), variant );
1650 }
1651
1652 wxVariant wxPGProperty::DoGetAttribute( const wxString& WXUNUSED(name) ) const
1653 {
1654     return wxVariant();
1655 }
1656
1657
1658 wxVariant wxPGProperty::GetAttribute( const wxString& name ) const
1659 {
1660     return m_attributes.FindValue(name);
1661 }
1662
1663 wxString wxPGProperty::GetAttribute( const wxString& name, const wxString& defVal ) const
1664 {
1665     wxVariant variant = m_attributes.FindValue(name);
1666
1667     if ( !variant.IsNull() )
1668         return variant.GetString();
1669
1670     return defVal;
1671 }
1672
1673 long wxPGProperty::GetAttributeAsLong( const wxString& name, long defVal ) const
1674 {
1675     wxVariant variant = m_attributes.FindValue(name);
1676
1677     if ( variant.IsNull() )
1678         return defVal;
1679
1680     return variant.GetLong();
1681 }
1682
1683 double wxPGProperty::GetAttributeAsDouble( const wxString& name, double defVal ) const
1684 {
1685     wxVariant variant = m_attributes.FindValue(name);
1686
1687     if ( variant.IsNull() )
1688         return defVal;
1689
1690     return variant.GetDouble();
1691 }
1692
1693 wxVariant wxPGProperty::GetAttributesAsList() const
1694 {
1695     wxVariantList tempList;
1696     wxVariant v( tempList, wxString::Format(wxS("@%s@attr"),m_name.c_str()) );
1697
1698     wxPGAttributeStorage::const_iterator it = m_attributes.StartIteration();
1699     wxVariant variant;
1700
1701     while ( m_attributes.GetNext(it, variant) )
1702         v.Append(variant);
1703
1704     return v;
1705 }
1706
1707 // Slots of utility flags are NULL
1708 const unsigned int gs_propFlagToStringSize = 14;
1709
1710 static const wxChar* const gs_propFlagToString[gs_propFlagToStringSize] = {
1711     NULL,
1712     wxT("DISABLED"),
1713     wxT("HIDDEN"),
1714     NULL,
1715     wxT("NOEDITOR"),
1716     wxT("COLLAPSED"),
1717     NULL,
1718     NULL,
1719     NULL,
1720     NULL,
1721     NULL,
1722     NULL,
1723     NULL,
1724     NULL
1725 };
1726
1727 wxString wxPGProperty::GetFlagsAsString( FlagType flagsMask ) const
1728 {
1729     wxString s;
1730     int relevantFlags = m_flags & flagsMask & wxPG_STRING_STORED_FLAGS;
1731     FlagType a = 1;
1732
1733     unsigned int i = 0;
1734     for ( i=0; i<gs_propFlagToStringSize; i++ )
1735     {
1736         if ( relevantFlags & a )
1737         {
1738             const wxChar* fs = gs_propFlagToString[i];
1739             wxASSERT(fs);
1740             if ( s.length() )
1741                 s << wxS("|");
1742             s << fs;
1743         }
1744         a = a << 1;
1745     }
1746
1747     return s;
1748 }
1749
1750 void wxPGProperty::SetFlagsFromString( const wxString& str )
1751 {
1752     FlagType flags = 0;
1753
1754     WX_PG_TOKENIZER1_BEGIN(str, wxS('|'))
1755         unsigned int i;
1756         for ( i=0; i<gs_propFlagToStringSize; i++ )
1757         {
1758             const wxChar* fs = gs_propFlagToString[i];
1759             if ( fs && str == fs )
1760             {
1761                 flags |= (1<<i);
1762                 break;
1763             }
1764         }
1765     WX_PG_TOKENIZER1_END()
1766
1767     m_flags = (m_flags & ~wxPG_STRING_STORED_FLAGS) | flags;
1768 }
1769
1770 wxValidator* wxPGProperty::DoGetValidator() const
1771 {
1772     return NULL;
1773 }
1774
1775 int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
1776 {
1777     wxPropertyGrid* pg = GetGrid();
1778     int sel = GetChoiceSelection();
1779
1780     int newSel = sel;
1781
1782     if ( index == wxNOT_FOUND )
1783         index = m_choices.GetCount();
1784
1785     if ( index <= sel )
1786         newSel++;
1787
1788     m_choices.Insert(label, index, value);
1789
1790     if ( sel != newSel )
1791         SetChoiceSelection(newSel);
1792
1793     if ( this == pg->GetSelection() )
1794         GetEditorClass()->InsertItem(pg->GetEditorControl(),label,index);
1795
1796     return index;
1797 }
1798
1799
1800 void wxPGProperty::DeleteChoice( int index )
1801 {
1802     wxPropertyGrid* pg = GetGrid();
1803
1804     int sel = GetChoiceSelection();
1805     int newSel = sel;
1806
1807     // Adjust current value
1808     if ( sel == index )
1809     {
1810         SetValueToUnspecified();
1811         newSel = 0;
1812     }
1813     else if ( index < sel )
1814     {
1815         newSel--;
1816     }
1817
1818     m_choices.RemoveAt(index);
1819
1820     if ( sel != newSel )
1821         SetChoiceSelection(newSel);
1822
1823     if ( this == pg->GetSelection() )
1824         GetEditorClass()->DeleteItem(pg->GetEditorControl(), index);
1825 }
1826
1827 int wxPGProperty::GetChoiceSelection() const
1828 {
1829     wxVariant value = GetValue();
1830     wxString valueType = value.GetType();
1831     int index = wxNOT_FOUND;
1832
1833     if ( IsValueUnspecified() || !m_choices.GetCount() )
1834         return wxNOT_FOUND;
1835
1836     if ( valueType == wxPG_VARIANT_TYPE_LONG )
1837     {
1838         index = value.GetLong();
1839     }
1840     else if ( valueType == wxPG_VARIANT_TYPE_STRING )
1841     {
1842         index = m_choices.Index(value.GetString());
1843     }
1844     else if ( valueType == wxPG_VARIANT_TYPE_BOOL )
1845     {
1846         index = value.GetBool()? 1 : 0;
1847     }
1848
1849     return index;
1850 }
1851
1852 void wxPGProperty::SetChoiceSelection( int newValue )
1853 {
1854     // Changes value of a property with choices, but only
1855     // works if the value type is long or string.
1856     wxString valueType = GetValue().GetType();
1857
1858     wxCHECK_RET( m_choices.IsOk(), wxT("invalid choiceinfo") );
1859
1860     if ( valueType == wxPG_VARIANT_TYPE_STRING )
1861     {
1862         SetValue( m_choices.GetLabel(newValue) );
1863     }
1864     else  // if ( valueType == wxPG_VARIANT_TYPE_LONG )
1865     {
1866         SetValue( (long) newValue );
1867     }
1868 }
1869
1870 bool wxPGProperty::SetChoices( wxPGChoices& choices )
1871 {
1872     m_choices.Assign(choices);
1873
1874     {
1875         // This may be needed to trigger some initialization
1876         // (but don't do it if property is somewhat uninitialized)
1877         wxVariant defVal = GetDefaultValue();
1878         if ( defVal.IsNull() )
1879             return false;
1880
1881         SetValue(defVal);
1882     }
1883
1884     return true;
1885 }
1886
1887
1888 const wxPGEditor* wxPGProperty::GetEditorClass() const
1889 {
1890     const wxPGEditor* editor;
1891
1892     if ( !m_customEditor )
1893     {
1894         editor = DoGetEditorClass();
1895     }
1896     else
1897         editor = m_customEditor;
1898
1899     //
1900     // Maybe override editor if common value specified
1901     if ( GetDisplayedCommonValueCount() )
1902     {
1903         // TextCtrlAndButton -> ComboBoxAndButton
1904         if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlAndButtonEditor)) )
1905             editor = wxPGEditor_ChoiceAndButton;
1906
1907         // TextCtrl -> ComboBox
1908         else if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlEditor)) )
1909             editor = wxPGEditor_ComboBox;
1910     }
1911
1912     return editor;
1913 }
1914
1915 bool wxPGProperty::HasVisibleChildren() const
1916 {
1917     unsigned int i;
1918
1919     for ( i=0; i<GetChildCount(); i++ )
1920     {
1921         wxPGProperty* child = Item(i);
1922
1923         if ( !child->HasFlag(wxPG_PROP_HIDDEN) )
1924             return true;
1925     }
1926
1927     return false;
1928 }
1929
1930 bool wxPGProperty::RecreateEditor()
1931 {
1932     wxPropertyGrid* pg = GetGrid();
1933     wxASSERT(pg);
1934
1935     wxPGProperty* selected = pg->GetSelection();
1936     if ( this == selected )
1937     {
1938         pg->DoSelectProperty(this, wxPG_SEL_FORCE);
1939         return true;
1940     }
1941     return false;
1942 }
1943
1944
1945 void wxPGProperty::SetValueImage( wxBitmap& bmp )
1946 {
1947     delete m_valueBitmap;
1948
1949     if ( &bmp && bmp.Ok() )
1950     {
1951         // Resize the image
1952         wxSize maxSz = GetGrid()->GetImageSize();
1953         wxSize imSz(bmp.GetWidth(),bmp.GetHeight());
1954
1955         if ( imSz.y != maxSz.y )
1956         {
1957             // Create a memory DC
1958             wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth());
1959
1960             wxMemoryDC dc;
1961             dc.SelectObject(*bmpNew);
1962
1963             // Scale
1964             // FIXME: This is ugly - use image or wait for scaling patch.
1965             double scaleY = (double)maxSz.y / (double)imSz.y;
1966
1967             dc.SetUserScale(scaleY, scaleY);
1968
1969             dc.DrawBitmap(bmp, 0, 0);
1970
1971             m_valueBitmap = bmpNew;
1972         }
1973         else
1974         {
1975             m_valueBitmap = new wxBitmap(bmp);
1976         }
1977
1978         m_flags |= wxPG_PROP_CUSTOMIMAGE;
1979     }
1980     else
1981     {
1982         m_valueBitmap = NULL;
1983         m_flags &= ~(wxPG_PROP_CUSTOMIMAGE);
1984     }
1985 }
1986
1987
1988 wxPGProperty* wxPGProperty::GetMainParent() const
1989 {
1990     const wxPGProperty* curChild = this;
1991     const wxPGProperty* curParent = m_parent;
1992
1993     while ( curParent && !curParent->IsCategory() )
1994     {
1995         curChild = curParent;
1996         curParent = curParent->m_parent;
1997     }
1998
1999     return (wxPGProperty*) curChild;
2000 }
2001
2002
2003 const wxPGProperty* wxPGProperty::GetLastVisibleSubItem() const
2004 {
2005     //
2006     // Returns last visible sub-item, recursively.
2007     if ( !IsExpanded() || !GetChildCount() )
2008         return this;
2009
2010     return Last()->GetLastVisibleSubItem();
2011 }
2012
2013
2014 bool wxPGProperty::IsVisible() const
2015 {
2016     const wxPGProperty* parent;
2017
2018     if ( HasFlag(wxPG_PROP_HIDDEN) )
2019         return false;
2020
2021     for ( parent = GetParent(); parent != NULL; parent = parent->GetParent() )
2022     {
2023         if ( !parent->IsExpanded() || parent->HasFlag(wxPG_PROP_HIDDEN) )
2024             return false;
2025     }
2026
2027     return true;
2028 }
2029
2030 wxPropertyGrid* wxPGProperty::GetGridIfDisplayed() const
2031 {
2032     wxPropertyGridPageState* state = GetParentState();
2033     if ( !state )
2034         return NULL;
2035     wxPropertyGrid* propGrid = state->GetGrid();
2036     if ( state == propGrid->GetState() )
2037         return propGrid;
2038     return NULL;
2039 }
2040
2041
2042 int wxPGProperty::GetY2( int lh ) const
2043 {
2044     const wxPGProperty* parent;
2045     const wxPGProperty* child = this;
2046
2047     int y = 0;
2048
2049     for ( parent = GetParent(); parent != NULL; parent = child->GetParent() )
2050     {
2051         if ( !parent->IsExpanded() )
2052             return -1;
2053         y += parent->GetChildrenHeight(lh, child->GetIndexInParent());
2054         y += lh;
2055         child = parent;
2056     }
2057
2058     y -= lh;  // need to reduce one level
2059
2060     return y;
2061 }
2062
2063
2064 int wxPGProperty::GetY() const
2065 {
2066     return GetY2(GetGrid()->GetRowHeight());
2067 }
2068
2069 // This is used by Insert etc.
2070 void wxPGProperty::DoAddChild( wxPGProperty* prop, int index,
2071                                bool correct_mode )
2072 {
2073     if ( index < 0 || (size_t)index >= m_children.size() )
2074     {
2075         if ( correct_mode ) prop->m_arrIndex = m_children.size();
2076         m_children.push_back( prop );
2077     }
2078     else
2079     {
2080         m_children.insert( m_children.begin()+index, prop);
2081         if ( correct_mode ) FixIndicesOfChildren( index );
2082     }
2083
2084     prop->m_parent = this;
2085 }
2086
2087 void wxPGProperty::DoPreAddChild( int index, wxPGProperty* prop )
2088 {
2089     wxASSERT_MSG( prop->GetBaseName().length(),
2090                   "Property's children must have unique, non-empty "
2091                   "names within their scope" );
2092
2093     prop->m_arrIndex = index;
2094     m_children.insert( m_children.begin()+index,
2095                        prop );
2096
2097     int custImgHeight = prop->OnMeasureImage().y;
2098     if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
2099         prop->m_flags |= wxPG_PROP_CUSTOMIMAGE;
2100
2101     prop->m_parent = this;
2102 }
2103
2104 void wxPGProperty::AddPrivateChild( wxPGProperty* prop )
2105 {
2106     if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
2107         SetParentalType(wxPG_PROP_AGGREGATE);
2108
2109     wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
2110                     wxPG_PROP_AGGREGATE,
2111                   "Do not mix up AddPrivateChild() calls with other "
2112                   "property adders." );
2113
2114     DoPreAddChild( m_children.size(), prop );
2115 }
2116
2117 #if wxPG_COMPATIBILITY_1_4
2118 void wxPGProperty::AddChild( wxPGProperty* prop )
2119 {
2120     AddPrivateChild(prop);
2121 }
2122 #endif
2123
2124 wxPGProperty* wxPGProperty::InsertChild( int index,
2125                                          wxPGProperty* childProperty )
2126 {
2127     if ( index < 0 )
2128         index = m_children.size();
2129
2130     if ( m_parentState )
2131     {
2132         m_parentState->DoInsert(this, index, childProperty);
2133     }
2134     else
2135     {
2136         if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
2137             SetParentalType(wxPG_PROP_MISC_PARENT);
2138
2139         wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
2140                         wxPG_PROP_MISC_PARENT,
2141                       "Do not mix up AddPrivateChild() calls with other "
2142                       "property adders." );
2143
2144         DoPreAddChild( index, childProperty );
2145     }
2146
2147     return childProperty;
2148 }
2149
2150 void wxPGProperty::RemoveChild( wxPGProperty* p )
2151 {
2152     wxArrayPGProperty::iterator it;
2153     wxArrayPGProperty& children = m_children;
2154
2155     for ( it=children.begin(); it != children.end(); it++ )
2156     {
2157         if ( *it == p )
2158         {
2159             children.erase(it);
2160             break;
2161         }
2162     }
2163 }
2164
2165 void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
2166 {
2167     wxASSERT( GetChildCount() );
2168     wxASSERT( !IsCategory() );
2169
2170     *value = GetValue();
2171
2172     if ( !list.GetCount() )
2173         return;
2174
2175     wxASSERT( GetChildCount() >= (unsigned int)list.GetCount() );
2176
2177     bool allChildrenSpecified;
2178
2179     // Don't fully update aggregate properties unless all children have
2180     // specified value
2181     if ( HasFlag(wxPG_PROP_AGGREGATE) )
2182         allChildrenSpecified = AreAllChildrenSpecified(&list);
2183     else
2184         allChildrenSpecified = true;
2185
2186     wxVariant childValue = list[0];
2187     unsigned int i;
2188     unsigned int n = 0;
2189
2190     //wxLogDebug(wxT(">> %s.AdaptListToValue()"),GetBaseName().c_str());
2191
2192     for ( i=0; i<GetChildCount(); i++ )
2193     {
2194         const wxPGProperty* child = Item(i);
2195
2196         if ( childValue.GetName() == child->GetBaseName() )
2197         {
2198             //wxLogDebug(wxT("  %s(n=%i), %s"),childValue.GetName().c_str(),n,childValue.GetType().c_str());
2199
2200             if ( childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
2201             {
2202                 wxVariant cv2(child->GetValue());
2203                 child->AdaptListToValue(childValue, &cv2);
2204                 childValue = cv2;
2205             }
2206
2207             if ( allChildrenSpecified )
2208             {
2209                 *value = ChildChanged(*value, i, childValue);
2210             }
2211
2212             n++;
2213             if ( n == (unsigned int)list.GetCount() )
2214                 break;
2215             childValue = list[n];
2216         }
2217     }
2218 }
2219
2220
2221 void wxPGProperty::FixIndicesOfChildren( unsigned int starthere )
2222 {
2223     size_t i;
2224     for ( i=starthere;i<GetChildCount();i++)
2225         Item(i)->m_arrIndex = i;
2226 }
2227
2228
2229 // Returns (direct) child property with given name (or NULL if not found)
2230 wxPGProperty* wxPGProperty::GetPropertyByName( const wxString& name ) const
2231 {
2232     size_t i;
2233
2234     for ( i=0; i<GetChildCount(); i++ )
2235     {
2236         wxPGProperty* p = Item(i);
2237         if ( p->m_name == name )
2238             return p;
2239     }
2240
2241     // Does it have point, then?
2242     int pos = name.Find(wxS('.'));
2243     if ( pos <= 0 )
2244         return NULL;
2245
2246     wxPGProperty* p = GetPropertyByName(name. substr(0,pos));
2247
2248     if ( !p || !p->GetChildCount() )
2249         return NULL;
2250
2251     return p->GetPropertyByName(name.substr(pos+1,name.length()-pos-1));
2252 }
2253
2254 wxPGProperty* wxPGProperty::GetPropertyByNameWH( const wxString& name, unsigned int hintIndex ) const
2255 {
2256     unsigned int i = hintIndex;
2257
2258     if ( i >= GetChildCount() )
2259         i = 0;
2260
2261     unsigned int lastIndex = i - 1;
2262
2263     if ( lastIndex >= GetChildCount() )
2264         lastIndex = GetChildCount() - 1;
2265
2266     for (;;)
2267     {
2268         wxPGProperty* p = Item(i);
2269         if ( p->m_name == name )
2270             return p;
2271
2272         if ( i == lastIndex )
2273             break;
2274
2275         i++;
2276         if ( i == GetChildCount() )
2277             i = 0;
2278     };
2279
2280     return NULL;
2281 }
2282
2283 int wxPGProperty::GetChildrenHeight( int lh, int iMax_ ) const
2284 {
2285     // Returns height of children, recursively, and
2286     // by taking expanded/collapsed status into account.
2287     //
2288     // iMax is used when finding property y-positions.
2289     //
2290     unsigned int i = 0;
2291     int h = 0;
2292
2293     if ( iMax_ == -1 )
2294         iMax_ = GetChildCount();
2295
2296     unsigned int iMax = iMax_;
2297
2298     wxASSERT( iMax <= GetChildCount() );
2299
2300     if ( !IsExpanded() && GetParent() )
2301         return 0;
2302
2303     while ( i < iMax )
2304     {
2305         wxPGProperty* pwc = (wxPGProperty*) Item(i);
2306
2307         if ( !pwc->HasFlag(wxPG_PROP_HIDDEN) )
2308         {
2309             if ( !pwc->IsExpanded() ||
2310                  pwc->GetChildCount() == 0 )
2311                 h += lh;
2312             else
2313                 h += pwc->GetChildrenHeight(lh) + lh;
2314         }
2315
2316         i++;
2317     }
2318
2319     return h;
2320 }
2321
2322 wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y,
2323                                         unsigned int lh,
2324                                         unsigned int* nextItemY ) const
2325 {
2326     wxASSERT( nextItemY );
2327
2328     // Linear search at the moment
2329     //
2330     // nextItemY = y of next visible property, final value will be written back.
2331     wxPGProperty* result = NULL;
2332     wxPGProperty* current = NULL;
2333     unsigned int iy = *nextItemY;
2334     unsigned int i = 0;
2335     unsigned int iMax = GetChildCount();
2336
2337     while ( i < iMax )
2338     {
2339         wxPGProperty* pwc = Item(i);
2340
2341         if ( !pwc->HasFlag(wxPG_PROP_HIDDEN) )
2342         {
2343             // Found?
2344             if ( y < iy )
2345             {
2346                 result = current;
2347                 break;
2348             }
2349
2350             iy += lh;
2351
2352             if ( pwc->IsExpanded() &&
2353                  pwc->GetChildCount() > 0 )
2354             {
2355                 result = (wxPGProperty*) pwc->GetItemAtY( y, lh, &iy );
2356                 if ( result )
2357                     break;
2358             }
2359
2360             current = pwc;
2361         }
2362
2363         i++;
2364     }
2365
2366     // Found?
2367     if ( !result && y < iy )
2368         result = current;
2369
2370     *nextItemY = iy;
2371
2372     /*
2373     if ( current )
2374     {
2375         wxLogDebug(wxT("%s::GetItemAtY(%i) -> %s"),this->GetLabel().c_str(),y,current->GetLabel().c_str());
2376     }
2377     else
2378     {
2379         wxLogDebug(wxT("%s::GetItemAtY(%i) -> NULL"),this->GetLabel().c_str(),y);
2380     }
2381     */
2382
2383     return (wxPGProperty*) result;
2384 }
2385
2386 void wxPGProperty::Empty()
2387 {
2388     size_t i;
2389     if ( !HasFlag(wxPG_PROP_CHILDREN_ARE_COPIES) )
2390     {
2391         for ( i=0; i<GetChildCount(); i++ )
2392         {
2393             delete m_children[i];
2394         }
2395     }
2396
2397     m_children.clear();
2398 }
2399
2400 wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y ) const
2401 {
2402     unsigned int nextItem;
2403     return GetItemAtY( y, GetGrid()->GetRowHeight(), &nextItem);
2404 }
2405
2406 void wxPGProperty::DeleteChildren()
2407 {
2408     wxPropertyGridPageState* state = m_parentState;
2409
2410     while ( GetChildCount() )
2411     {
2412         wxPGProperty* child = Item(GetChildCount()-1);
2413         state->DoDelete(child, true);
2414     }
2415 }
2416
2417 wxVariant wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
2418                                       int WXUNUSED(childIndex),
2419                                       wxVariant& WXUNUSED(childValue) ) const
2420 {
2421     return wxNullVariant;
2422 }
2423
2424 bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
2425 {
2426     unsigned int i;
2427
2428     const wxVariantList* pList = NULL;
2429     wxVariantList::const_iterator node;
2430
2431     if ( pendingList )
2432     {
2433         pList = &pendingList->GetList();
2434         node = pList->begin();
2435     }
2436
2437     for ( i=0; i<GetChildCount(); i++ )
2438     {
2439         wxPGProperty* child = Item(i);
2440         const wxVariant* listValue = NULL;
2441         wxVariant value;
2442
2443         if ( pendingList )
2444         {
2445             const wxString& childName = child->GetBaseName();
2446
2447             for ( ; node != pList->end(); ++node )
2448             {
2449                 const wxVariant& item = *((const wxVariant*)*node);
2450                 if ( item.GetName() == childName )
2451                 {
2452                     listValue = &item;
2453                     value = item;
2454                     break;
2455                 }
2456             }
2457         }
2458
2459         if ( !listValue )
2460             value = child->GetValue();
2461
2462         if ( value.IsNull() )
2463             return false;
2464
2465         // Check recursively
2466         if ( child->GetChildCount() )
2467         {
2468             const wxVariant* childList = NULL;
2469
2470             if ( listValue && listValue->GetType() == wxPG_VARIANT_TYPE_LIST )
2471                 childList = listValue;
2472
2473             if ( !child->AreAllChildrenSpecified((wxVariant*)childList) )
2474                 return false;
2475         }
2476     }
2477
2478     return true;
2479 }
2480
2481 wxPGProperty* wxPGProperty::UpdateParentValues()
2482 {
2483     wxPGProperty* parent = m_parent;
2484     if ( parent && parent->HasFlag(wxPG_PROP_COMPOSED_VALUE) &&
2485          !parent->IsCategory() && !parent->IsRoot() )
2486     {
2487         wxString s;
2488         parent->DoGenerateComposedValue(s);
2489         parent->m_value = s;
2490         return parent->UpdateParentValues();
2491     }
2492     return this;
2493 }
2494
2495 bool wxPGProperty::IsTextEditable() const
2496 {
2497     if ( HasFlag(wxPG_PROP_READONLY) )
2498         return false;
2499
2500     if ( HasFlag(wxPG_PROP_NOEDITOR) &&
2501          (GetChildCount() ||
2502           wxString(GetEditorClass()->GetClassInfo()->GetClassName()).EndsWith(wxS("Button")))
2503        )
2504         return false;
2505
2506     return true;
2507 }
2508
2509 // Call after fixed sub-properties added/removed after creation.
2510 // if oldSelInd >= 0 and < new max items, then selection is
2511 // moved to it. Note: oldSelInd -2 indicates that this property
2512 // should be selected.
2513 void wxPGProperty::SubPropsChanged( int oldSelInd )
2514 {
2515     wxPropertyGridPageState* state = GetParentState();
2516     wxPropertyGrid* grid = state->GetGrid();
2517
2518     //
2519     // Re-repare children (recursively)
2520     for ( unsigned int i=0; i<GetChildCount(); i++ )
2521     {
2522         wxPGProperty* child = Item(i);
2523         child->InitAfterAdded(state, grid);
2524     }
2525
2526     wxPGProperty* sel = NULL;
2527     if ( oldSelInd >= (int)m_children.size() )
2528         oldSelInd = (int)m_children.size() - 1;
2529
2530     if ( oldSelInd >= 0 )
2531         sel = m_children[oldSelInd];
2532     else if ( oldSelInd == -2 )
2533         sel = this;
2534
2535     if ( sel )
2536         state->DoSelectProperty(sel);
2537
2538     if ( state == grid->GetState() )
2539     {
2540         grid->GetPanel()->Refresh();
2541     }
2542 }
2543
2544 // -----------------------------------------------------------------------
2545 // wxPGRootProperty
2546 // -----------------------------------------------------------------------
2547
2548 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPGRootProperty,none,TextCtrl)
2549 IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
2550
2551
2552 wxPGRootProperty::wxPGRootProperty( const wxString& name )
2553     : wxPGProperty()
2554 {
2555     m_name = name;
2556     m_label = m_name;
2557     SetParentalType(0);
2558     m_depth = 0;
2559 }
2560
2561
2562 wxPGRootProperty::~wxPGRootProperty()
2563 {
2564 }
2565
2566
2567 // -----------------------------------------------------------------------
2568 // wxPropertyCategory
2569 // -----------------------------------------------------------------------
2570
2571 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPropertyCategory,none,TextCtrl)
2572 IMPLEMENT_DYNAMIC_CLASS(wxPropertyCategory, wxPGProperty)
2573
2574 void wxPropertyCategory::Init()
2575 {
2576     // don't set colour - prepareadditem method should do this
2577     SetParentalType(wxPG_PROP_CATEGORY);
2578     m_capFgColIndex = 1;
2579     m_textExtent = -1;
2580 }
2581
2582 wxPropertyCategory::wxPropertyCategory()
2583     : wxPGProperty()
2584 {
2585     Init();
2586 }
2587
2588
2589 wxPropertyCategory::wxPropertyCategory( const wxString &label, const wxString& name )
2590     : wxPGProperty(label,name)
2591 {
2592     Init();
2593 }
2594
2595
2596 wxPropertyCategory::~wxPropertyCategory()
2597 {
2598 }
2599
2600
2601 wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
2602                                             int WXUNUSED(argFlags) ) const
2603 {
2604     return wxEmptyString;
2605 }
2606
2607 int wxPropertyCategory::GetTextExtent( const wxWindow* wnd, const wxFont& font ) const
2608 {
2609     if ( m_textExtent > 0 )
2610         return m_textExtent;
2611     int x = 0, y = 0;
2612     ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font );
2613     return x;
2614 }
2615
2616 void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font )
2617 {
2618     int x = 0, y = 0;
2619     wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font );
2620     m_textExtent = x;
2621 }
2622
2623 // -----------------------------------------------------------------------
2624 // wxPGChoices
2625 // -----------------------------------------------------------------------
2626
2627 wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, int value )
2628 {
2629     AllocExclusive();
2630
2631     wxPGChoiceEntry entry(label, value);
2632     return m_data->Insert( -1, entry );
2633 }
2634
2635 // -----------------------------------------------------------------------
2636
2637 wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, const wxBitmap& bitmap, int value )
2638 {
2639     AllocExclusive();
2640
2641     wxPGChoiceEntry entry(label, value);
2642     entry.SetBitmap(bitmap);
2643     return m_data->Insert( -1, entry );
2644 }
2645
2646 // -----------------------------------------------------------------------
2647
2648 wxPGChoiceEntry& wxPGChoices::Insert( const wxPGChoiceEntry& entry, int index )
2649 {
2650     AllocExclusive();
2651
2652     return m_data->Insert( index, entry );
2653 }
2654
2655 // -----------------------------------------------------------------------
2656
2657 wxPGChoiceEntry& wxPGChoices::Insert( const wxString& label, int index, int value )
2658 {
2659     AllocExclusive();
2660
2661     wxPGChoiceEntry entry(label, value);
2662     return m_data->Insert( index, entry );
2663 }
2664
2665 // -----------------------------------------------------------------------
2666
2667 wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value )
2668 {
2669     AllocExclusive();
2670
2671     size_t index = 0;
2672
2673     while ( index < GetCount() )
2674     {
2675         int cmpRes = GetLabel(index).Cmp(label);
2676         if ( cmpRes > 0 )
2677             break;
2678         index++;
2679     }
2680
2681     wxPGChoiceEntry entry(label, value);
2682     return m_data->Insert( index, entry );
2683 }
2684
2685 // -----------------------------------------------------------------------
2686
2687 void wxPGChoices::Add( const wxChar* const* labels, const ValArrItem* values )
2688 {
2689     AllocExclusive();
2690
2691     unsigned int itemcount = 0;
2692     const wxChar* const* p = &labels[0];
2693     while ( *p ) { p++; itemcount++; }
2694
2695     unsigned int i;
2696     for ( i = 0; i < itemcount; i++ )
2697     {
2698         int value = i;
2699         if ( values )
2700             value = values[i];
2701         wxPGChoiceEntry entry(labels[i], value);
2702         m_data->Insert( i, entry );
2703     }
2704 }
2705
2706 // -----------------------------------------------------------------------
2707
2708 void wxPGChoices::Add( const wxArrayString& arr, const wxArrayInt& arrint )
2709 {
2710     AllocExclusive();
2711
2712     unsigned int i;
2713     unsigned int itemcount = arr.size();
2714
2715     for ( i = 0; i < itemcount; i++ )
2716     {
2717         int value = i;
2718         if ( &arrint && arrint.size() )
2719             value = arrint[i];
2720         wxPGChoiceEntry entry(arr[i], value);
2721         m_data->Insert( i, entry );
2722     }
2723 }
2724
2725 // -----------------------------------------------------------------------
2726
2727 void wxPGChoices::RemoveAt(size_t nIndex, size_t count)
2728 {
2729     AllocExclusive();
2730
2731     wxASSERT( m_data->GetRefCount() != -1 );
2732     m_data->m_items.erase(m_data->m_items.begin()+nIndex,
2733                           m_data->m_items.begin()+nIndex+count);
2734 }
2735
2736 // -----------------------------------------------------------------------
2737
2738 void wxPGChoices::Clear()
2739 {
2740     if ( m_data != wxPGChoicesEmptyData )
2741     {
2742         AllocExclusive();
2743         m_data->Clear();
2744     }
2745 }
2746
2747 // -----------------------------------------------------------------------
2748
2749 int wxPGChoices::Index( const wxString& str ) const
2750 {
2751     if ( IsOk() )
2752     {
2753         unsigned int i;
2754         for ( i=0; i< m_data->GetCount(); i++ )
2755         {
2756             const wxPGChoiceEntry& entry = m_data->Item(i);
2757             if ( entry.HasText() && entry.GetText() == str )
2758                 return i;
2759         }
2760     }
2761     return -1;
2762 }
2763
2764 // -----------------------------------------------------------------------
2765
2766 int wxPGChoices::Index( int val ) const
2767 {
2768     if ( IsOk() )
2769     {
2770         unsigned int i;
2771         for ( i=0; i< m_data->GetCount(); i++ )
2772         {
2773             const wxPGChoiceEntry& entry = m_data->Item(i);
2774             if ( entry.GetValue() == val )
2775                 return i;
2776         }
2777     }
2778     return -1;
2779 }
2780
2781 // -----------------------------------------------------------------------
2782
2783 wxArrayString wxPGChoices::GetLabels() const
2784 {
2785     wxArrayString arr;
2786     unsigned int i;
2787
2788     if ( this && IsOk() )
2789         for ( i=0; i<GetCount(); i++ )
2790             arr.push_back(GetLabel(i));
2791
2792     return arr;
2793 }
2794
2795 // -----------------------------------------------------------------------
2796
2797 wxArrayInt wxPGChoices::GetValuesForStrings( const wxArrayString& strings ) const
2798 {
2799     wxArrayInt arr;
2800
2801     if ( IsOk() )
2802     {
2803         unsigned int i;
2804         for ( i=0; i< strings.size(); i++ )
2805         {
2806             int index = Index(strings[i]);
2807             if ( index >= 0 )
2808                 arr.Add(GetValue(index));
2809             else
2810                 arr.Add(wxPG_INVALID_VALUE);
2811         }
2812     }
2813
2814     return arr;
2815 }
2816
2817 // -----------------------------------------------------------------------
2818
2819 wxArrayInt wxPGChoices::GetIndicesForStrings( const wxArrayString& strings,
2820                                               wxArrayString* unmatched ) const
2821 {
2822     wxArrayInt arr;
2823
2824     if ( IsOk() )
2825     {
2826         unsigned int i;
2827         for ( i=0; i< strings.size(); i++ )
2828         {
2829             const wxString& str = strings[i];
2830             int index = Index(str);
2831             if ( index >= 0 )
2832                 arr.Add(index);
2833             else if ( unmatched )
2834                 unmatched->Add(str);
2835         }
2836     }
2837
2838     return arr;
2839 }
2840
2841 // -----------------------------------------------------------------------
2842
2843 void wxPGChoices::AllocExclusive()
2844 {
2845     EnsureData();
2846
2847     if ( m_data->GetRefCount() != 1 )
2848     {
2849         wxPGChoicesData* data = new wxPGChoicesData();
2850         data->CopyDataFrom(m_data);
2851         Free();
2852         m_data = data;
2853     }
2854 }
2855
2856 // -----------------------------------------------------------------------
2857
2858 void wxPGChoices::AssignData( wxPGChoicesData* data )
2859 {
2860     Free();
2861
2862     if ( data != wxPGChoicesEmptyData )
2863     {
2864         m_data = data;
2865         data->IncRef();
2866     }
2867 }
2868
2869 // -----------------------------------------------------------------------
2870
2871 void wxPGChoices::Init()
2872 {
2873     m_data = wxPGChoicesEmptyData;
2874 }
2875
2876 // -----------------------------------------------------------------------
2877
2878 void wxPGChoices::Free()
2879 {
2880     if ( m_data != wxPGChoicesEmptyData )
2881     {
2882         m_data->DecRef();
2883         m_data = wxPGChoicesEmptyData;
2884     }
2885 }
2886
2887 // -----------------------------------------------------------------------
2888 // wxPGAttributeStorage
2889 // -----------------------------------------------------------------------
2890
2891 wxPGAttributeStorage::wxPGAttributeStorage()
2892 {
2893 }
2894
2895 wxPGAttributeStorage::~wxPGAttributeStorage()
2896 {
2897     wxPGHashMapS2P::iterator it;
2898
2899     for ( it = m_map.begin(); it != m_map.end(); ++it )
2900     {
2901         wxVariantData* data = (wxVariantData*) it->second;
2902         data->DecRef();
2903     }
2904 }
2905
2906 void wxPGAttributeStorage::Set( const wxString& name, const wxVariant& value )
2907 {
2908     wxVariantData* data = value.GetData();
2909
2910     // Free old, if any
2911     wxPGHashMapS2P::iterator it = m_map.find(name);
2912     if ( it != m_map.end() )
2913     {
2914         ((wxVariantData*)it->second)->DecRef();
2915
2916         if ( !data )
2917         {
2918             // If Null variant, just remove from set
2919             m_map.erase(it);
2920             return;
2921         }
2922     }
2923
2924     if ( data )
2925     {
2926         data->IncRef();
2927
2928         m_map[name] = data;
2929     }
2930 }
2931
2932 #endif  // wxUSE_PROPGRID