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         if ( !isUnspecified )
 220         {
 221             editor = property->GetColumnEditor(column);
 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 ( imageWidth > 0 )
 281             {
 282                 imageOffset -= DEFAULT_IMAGE_OFFSET_INCREMENT;
 283                 imageWidth += 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                                         bool recursively )
1551 {
1552     wxPGProperty* firstProp = this;
1553
1554     //
1555     // If category is tried to set recursively, skip it and only
1556     // affect the children.
1557     if ( recursively )
1558     {
1559         while ( firstProp->IsCategory() )
1560         {
1561             if ( !firstProp->GetChildCount() )
1562                 return;
1563             firstProp = firstProp->Item(0);
1564         }
1565     }
1566
1567     wxPGCell& firstCell = firstProp->GetCell(0);
1568     wxPGCellData* firstCellData = firstCell.GetData();
1569
1570     wxPGCell newCell(firstCell);
1571     newCell.SetBgCol(colour);
1572     wxPGCell srcCell;
1573     srcCell.SetBgCol(colour);
1574
1575     AdaptiveSetCell( 0,
1576                      GetParentState()->GetColumnCount()-1,
1577                      newCell,
1578                      srcCell,
1579                      firstCellData,
1580                      recursively ? wxPG_PROP_CATEGORY : 0,
1581                      recursively );
1582 }
1583
1584 void wxPGProperty::SetTextColour( const wxColour& colour,
1585                                   bool recursively )
1586 {
1587     wxPGProperty* firstProp = this;
1588
1589     //
1590     // If category is tried to set recursively, skip it and only
1591     // affect the children.
1592     if ( recursively )
1593     {
1594         while ( firstProp->IsCategory() )
1595         {
1596             if ( !firstProp->GetChildCount() )
1597                 return;
1598             firstProp = firstProp->Item(0);
1599         }
1600     }
1601
1602     wxPGCell& firstCell = firstProp->GetCell(0);
1603     wxPGCellData* firstCellData = firstCell.GetData();
1604
1605     wxPGCell newCell(firstCell);
1606     newCell.SetFgCol(colour);
1607     wxPGCell srcCell;
1608     srcCell.SetFgCol(colour);
1609
1610     AdaptiveSetCell( 0,
1611                      GetParentState()->GetColumnCount()-1,
1612                      newCell,
1613                      srcCell,
1614                      firstCellData,
1615                      recursively ? wxPG_PROP_CATEGORY : 0,
1616                      recursively );
1617 }
1618
1619 wxPGEditorDialogAdapter* wxPGProperty::GetEditorDialog() const
1620 {
1621     return NULL;
1622 }
1623
1624 bool wxPGProperty::DoSetAttribute( const wxString& WXUNUSED(name), wxVariant& WXUNUSED(value) )
1625 {
1626     return false;
1627 }
1628
1629 void wxPGProperty::SetAttribute( const wxString& name, wxVariant value )
1630 {
1631     if ( DoSetAttribute( name, value ) )
1632     {
1633         // Support working without grid, when possible
1634         if ( wxPGGlobalVars->HasExtraStyle( wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES ) )
1635             return;
1636     }
1637
1638     m_attributes.Set( name, value );
1639 }
1640
1641 void wxPGProperty::SetAttributes( const wxPGAttributeStorage& attributes )
1642 {
1643     wxPGAttributeStorage::const_iterator it = attributes.StartIteration();
1644     wxVariant variant;
1645
1646     while ( attributes.GetNext(it, variant) )
1647         SetAttribute( variant.GetName(), variant );
1648 }
1649
1650 wxVariant wxPGProperty::DoGetAttribute( const wxString& WXUNUSED(name) ) const
1651 {
1652     return wxVariant();
1653 }
1654
1655
1656 wxVariant wxPGProperty::GetAttribute( const wxString& name ) const
1657 {
1658     return m_attributes.FindValue(name);
1659 }
1660
1661 wxString wxPGProperty::GetAttribute( const wxString& name, const wxString& defVal ) const
1662 {
1663     wxVariant variant = m_attributes.FindValue(name);
1664
1665     if ( !variant.IsNull() )
1666         return variant.GetString();
1667
1668     return defVal;
1669 }
1670
1671 long wxPGProperty::GetAttributeAsLong( const wxString& name, long defVal ) const
1672 {
1673     wxVariant variant = m_attributes.FindValue(name);
1674
1675     if ( variant.IsNull() )
1676         return defVal;
1677
1678     return variant.GetLong();
1679 }
1680
1681 double wxPGProperty::GetAttributeAsDouble( const wxString& name, double defVal ) const
1682 {
1683     wxVariant variant = m_attributes.FindValue(name);
1684
1685     if ( variant.IsNull() )
1686         return defVal;
1687
1688     return variant.GetDouble();
1689 }
1690
1691 wxVariant wxPGProperty::GetAttributesAsList() const
1692 {
1693     wxVariantList tempList;
1694     wxVariant v( tempList, wxString::Format(wxS("@%s@attr"),m_name.c_str()) );
1695
1696     wxPGAttributeStorage::const_iterator it = m_attributes.StartIteration();
1697     wxVariant variant;
1698
1699     while ( m_attributes.GetNext(it, variant) )
1700         v.Append(variant);
1701
1702     return v;
1703 }
1704
1705 // Slots of utility flags are NULL
1706 const unsigned int gs_propFlagToStringSize = 14;
1707
1708 static const wxChar* gs_propFlagToString[gs_propFlagToStringSize] = {
1709     NULL,
1710     wxT("DISABLED"),
1711     wxT("HIDDEN"),
1712     NULL,
1713     wxT("NOEDITOR"),
1714     wxT("COLLAPSED"),
1715     NULL,
1716     NULL,
1717     NULL,
1718     NULL,
1719     NULL,
1720     NULL,
1721     NULL,
1722     NULL
1723 };
1724
1725 wxString wxPGProperty::GetFlagsAsString( FlagType flagsMask ) const
1726 {
1727     wxString s;
1728     int relevantFlags = m_flags & flagsMask & wxPG_STRING_STORED_FLAGS;
1729     FlagType a = 1;
1730
1731     unsigned int i = 0;
1732     for ( i=0; i<gs_propFlagToStringSize; i++ )
1733     {
1734         if ( relevantFlags & a )
1735         {
1736             const wxChar* fs = gs_propFlagToString[i];
1737             wxASSERT(fs);
1738             if ( s.length() )
1739                 s << wxS("|");
1740             s << fs;
1741         }
1742         a = a << 1;
1743     }
1744
1745     return s;
1746 }
1747
1748 void wxPGProperty::SetFlagsFromString( const wxString& str )
1749 {
1750     FlagType flags = 0;
1751
1752     WX_PG_TOKENIZER1_BEGIN(str, wxS('|'))
1753         unsigned int i;
1754         for ( i=0; i<gs_propFlagToStringSize; i++ )
1755         {
1756             const wxChar* fs = gs_propFlagToString[i];
1757             if ( fs && str == fs )
1758             {
1759                 flags |= (1<<i);
1760                 break;
1761             }
1762         }
1763     WX_PG_TOKENIZER1_END()
1764
1765     m_flags = (m_flags & ~wxPG_STRING_STORED_FLAGS) | flags;
1766 }
1767
1768 wxValidator* wxPGProperty::DoGetValidator() const
1769 {
1770     return NULL;
1771 }
1772
1773 int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
1774 {
1775     wxPropertyGrid* pg = GetGrid();
1776     int sel = GetChoiceSelection();
1777
1778     int newSel = sel;
1779
1780     if ( index == wxNOT_FOUND )
1781         index = m_choices.GetCount();
1782
1783     if ( index <= sel )
1784         newSel++;
1785
1786     m_choices.Insert(label, index, value);
1787
1788     if ( sel != newSel )
1789         SetChoiceSelection(newSel);
1790
1791     if ( this == pg->GetSelection() )
1792         GetEditorClass()->InsertItem(pg->GetEditorControl(),label,index);
1793
1794     return index;
1795 }
1796
1797
1798 void wxPGProperty::DeleteChoice( int index )
1799 {
1800     wxPropertyGrid* pg = GetGrid();
1801
1802     int sel = GetChoiceSelection();
1803     int newSel = sel;
1804
1805     // Adjust current value
1806     if ( sel == index )
1807     {
1808         SetValueToUnspecified();
1809         newSel = 0;
1810     }
1811     else if ( index < sel )
1812     {
1813         newSel--;
1814     }
1815
1816     m_choices.RemoveAt(index);
1817
1818     if ( sel != newSel )
1819         SetChoiceSelection(newSel);
1820
1821     if ( this == pg->GetSelection() )
1822         GetEditorClass()->DeleteItem(pg->GetEditorControl(), index);
1823 }
1824
1825 int wxPGProperty::GetChoiceSelection() const
1826 {
1827     wxVariant value = GetValue();
1828     wxString valueType = value.GetType();
1829     int index = wxNOT_FOUND;
1830
1831     if ( IsValueUnspecified() || !m_choices.GetCount() )
1832         return wxNOT_FOUND;
1833
1834     if ( valueType == wxPG_VARIANT_TYPE_LONG )
1835     {
1836         index = value.GetLong();
1837     }
1838     else if ( valueType == wxPG_VARIANT_TYPE_STRING )
1839     {
1840         index = m_choices.Index(value.GetString());
1841     }
1842     else if ( valueType == wxPG_VARIANT_TYPE_BOOL )
1843     {
1844         index = value.GetBool()? 1 : 0;
1845     }
1846
1847     return index;
1848 }
1849
1850 void wxPGProperty::SetChoiceSelection( int newValue )
1851 {
1852     // Changes value of a property with choices, but only
1853     // works if the value type is long or string.
1854     wxString valueType = GetValue().GetType();
1855
1856     wxCHECK_RET( m_choices.IsOk(), wxT("invalid choiceinfo") );
1857
1858     if ( valueType == wxPG_VARIANT_TYPE_STRING )
1859     {
1860         SetValue( m_choices.GetLabel(newValue) );
1861     }
1862     else  // if ( valueType == wxPG_VARIANT_TYPE_LONG )
1863     {
1864         SetValue( (long) newValue );
1865     }
1866 }
1867
1868 bool wxPGProperty::SetChoices( wxPGChoices& choices )
1869 {
1870     m_choices.Assign(choices);
1871
1872     {
1873         // This may be needed to trigger some initialization
1874         // (but don't do it if property is somewhat uninitialized)
1875         wxVariant defVal = GetDefaultValue();
1876         if ( defVal.IsNull() )
1877             return false;
1878
1879         SetValue(defVal);
1880     }
1881
1882     return true;
1883 }
1884
1885
1886 const wxPGEditor* wxPGProperty::GetEditorClass() const
1887 {
1888     const wxPGEditor* editor;
1889
1890     if ( !m_customEditor )
1891     {
1892         editor = DoGetEditorClass();
1893     }
1894     else
1895         editor = m_customEditor;
1896
1897     //
1898     // Maybe override editor if common value specified
1899     if ( GetDisplayedCommonValueCount() )
1900     {
1901         // TextCtrlAndButton -> ComboBoxAndButton
1902         if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlAndButtonEditor)) )
1903             editor = wxPGEditor_ChoiceAndButton;
1904
1905         // TextCtrl -> ComboBox
1906         else if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlEditor)) )
1907             editor = wxPGEditor_ComboBox;
1908     }
1909
1910     return editor;
1911 }
1912
1913 bool wxPGProperty::HasVisibleChildren() const
1914 {
1915     unsigned int i;
1916
1917     for ( i=0; i<GetChildCount(); i++ )
1918     {
1919         wxPGProperty* child = Item(i);
1920
1921         if ( !child->HasFlag(wxPG_PROP_HIDDEN) )
1922             return true;
1923     }
1924
1925     return false;
1926 }
1927
1928 bool wxPGProperty::RecreateEditor()
1929 {
1930     wxPropertyGrid* pg = GetGrid();
1931     wxASSERT(pg);
1932
1933     wxPGProperty* selected = pg->GetSelection();
1934     if ( this == selected )
1935     {
1936         pg->DoSelectProperty(this, wxPG_SEL_FORCE);
1937         return true;
1938     }
1939     return false;
1940 }
1941
1942
1943 void wxPGProperty::SetValueImage( wxBitmap& bmp )
1944 {
1945     delete m_valueBitmap;
1946
1947     if ( &bmp && bmp.Ok() )
1948     {
1949         // Resize the image
1950         wxSize maxSz = GetGrid()->GetImageSize();
1951         wxSize imSz(bmp.GetWidth(),bmp.GetHeight());
1952
1953         if ( imSz.y != maxSz.y )
1954         {
1955             // Create a memory DC
1956             wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth());
1957
1958             wxMemoryDC dc;
1959             dc.SelectObject(*bmpNew);
1960
1961             // Scale
1962             // FIXME: This is ugly - use image or wait for scaling patch.
1963             double scaleY = (double)maxSz.y / (double)imSz.y;
1964
1965             dc.SetUserScale(scaleY, scaleY);
1966
1967             dc.DrawBitmap(bmp, 0, 0);
1968
1969             m_valueBitmap = bmpNew;
1970         }
1971         else
1972         {
1973             m_valueBitmap = new wxBitmap(bmp);
1974         }
1975
1976         m_flags |= wxPG_PROP_CUSTOMIMAGE;
1977     }
1978     else
1979     {
1980         m_valueBitmap = NULL;
1981         m_flags &= ~(wxPG_PROP_CUSTOMIMAGE);
1982     }
1983 }
1984
1985
1986 wxPGProperty* wxPGProperty::GetMainParent() const
1987 {
1988     const wxPGProperty* curChild = this;
1989     const wxPGProperty* curParent = m_parent;
1990
1991     while ( curParent && !curParent->IsCategory() )
1992     {
1993         curChild = curParent;
1994         curParent = curParent->m_parent;
1995     }
1996
1997     return (wxPGProperty*) curChild;
1998 }
1999
2000
2001 const wxPGProperty* wxPGProperty::GetLastVisibleSubItem() const
2002 {
2003     //
2004     // Returns last visible sub-item, recursively.
2005     if ( !IsExpanded() || !GetChildCount() )
2006         return this;
2007
2008     return Last()->GetLastVisibleSubItem();
2009 }
2010
2011
2012 bool wxPGProperty::IsVisible() const
2013 {
2014     const wxPGProperty* parent;
2015
2016     if ( HasFlag(wxPG_PROP_HIDDEN) )
2017         return false;
2018
2019     for ( parent = GetParent(); parent != NULL; parent = parent->GetParent() )
2020     {
2021         if ( !parent->IsExpanded() || parent->HasFlag(wxPG_PROP_HIDDEN) )
2022             return false;
2023     }
2024
2025     return true;
2026 }
2027
2028 wxPropertyGrid* wxPGProperty::GetGridIfDisplayed() const
2029 {
2030     wxPropertyGridPageState* state = GetParentState();
2031     if ( !state )
2032         return NULL;
2033     wxPropertyGrid* propGrid = state->GetGrid();
2034     if ( state == propGrid->GetState() )
2035         return propGrid;
2036     return NULL;
2037 }
2038
2039
2040 int wxPGProperty::GetY2( int lh ) const
2041 {
2042     const wxPGProperty* parent;
2043     const wxPGProperty* child = this;
2044
2045     int y = 0;
2046
2047     for ( parent = GetParent(); parent != NULL; parent = child->GetParent() )
2048     {
2049         if ( !parent->IsExpanded() )
2050             return -1;
2051         y += parent->GetChildrenHeight(lh, child->GetIndexInParent());
2052         y += lh;
2053         child = parent;
2054     }
2055
2056     y -= lh;  // need to reduce one level
2057
2058     return y;
2059 }
2060
2061
2062 int wxPGProperty::GetY() const
2063 {
2064     return GetY2(GetGrid()->GetRowHeight());
2065 }
2066
2067 // This is used by Insert etc.
2068 void wxPGProperty::DoAddChild( wxPGProperty* prop, int index,
2069                                bool correct_mode )
2070 {
2071     if ( index < 0 || (size_t)index >= m_children.size() )
2072     {
2073         if ( correct_mode ) prop->m_arrIndex = m_children.size();
2074         m_children.push_back( prop );
2075     }
2076     else
2077     {
2078         m_children.insert( m_children.begin()+index, prop);
2079         if ( correct_mode ) FixIndicesOfChildren( index );
2080     }
2081
2082     prop->m_parent = this;
2083 }
2084
2085 void wxPGProperty::DoPreAddChild( int index, wxPGProperty* prop )
2086 {
2087     wxASSERT_MSG( prop->GetBaseName().length(),
2088                   "Property's children must have unique, non-empty "
2089                   "names within their scope" );
2090
2091     prop->m_arrIndex = index;
2092     m_children.insert( m_children.begin()+index,
2093                        prop );
2094
2095     int custImgHeight = prop->OnMeasureImage().y;
2096     if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
2097         prop->m_flags |= wxPG_PROP_CUSTOMIMAGE;
2098
2099     prop->m_parent = this;
2100 }
2101
2102 void wxPGProperty::AddPrivateChild( wxPGProperty* prop )
2103 {
2104     if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
2105         SetParentalType(wxPG_PROP_AGGREGATE);
2106
2107     wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
2108                     wxPG_PROP_AGGREGATE,
2109                   "Do not mix up AddPrivateChild() calls with other "
2110                   "property adders." );
2111
2112     DoPreAddChild( m_children.size(), prop );
2113 }
2114
2115 #if wxPG_COMPATIBILITY_1_4
2116 void wxPGProperty::AddChild( wxPGProperty* prop )
2117 {
2118     AddPrivateChild(prop);
2119 }
2120 #endif
2121
2122 wxPGProperty* wxPGProperty::InsertChild( int index,
2123                                          wxPGProperty* childProperty )
2124 {
2125     if ( index < 0 )
2126         index = m_children.size();
2127
2128     if ( m_parentState )
2129     {
2130         m_parentState->DoInsert(this, index, childProperty);
2131     }
2132     else
2133     {
2134         if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
2135             SetParentalType(wxPG_PROP_MISC_PARENT);
2136
2137         wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
2138                         wxPG_PROP_MISC_PARENT,
2139                       "Do not mix up AddPrivateChild() calls with other "
2140                       "property adders." );
2141
2142         DoPreAddChild( index, childProperty );
2143     }
2144
2145     return childProperty;
2146 }
2147
2148 void wxPGProperty::RemoveChild( wxPGProperty* p )
2149 {
2150     wxArrayPGProperty::iterator it;
2151     wxArrayPGProperty& children = m_children;
2152
2153     for ( it=children.begin(); it != children.end(); it++ )
2154     {
2155         if ( *it == p )
2156         {
2157             children.erase(it);
2158             break;
2159         }
2160     }
2161 }
2162
2163 void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
2164 {
2165     wxASSERT( GetChildCount() );
2166     wxASSERT( !IsCategory() );
2167
2168     *value = GetValue();
2169
2170     if ( !list.GetCount() )
2171         return;
2172
2173     wxASSERT( GetChildCount() >= (unsigned int)list.GetCount() );
2174
2175     bool allChildrenSpecified;
2176
2177     // Don't fully update aggregate properties unless all children have
2178     // specified value
2179     if ( HasFlag(wxPG_PROP_AGGREGATE) )
2180         allChildrenSpecified = AreAllChildrenSpecified(&list);
2181     else
2182         allChildrenSpecified = true;
2183
2184     wxVariant childValue = list[0];
2185     unsigned int i;
2186     unsigned int n = 0;
2187
2188     //wxLogDebug(wxT(">> %s.AdaptListToValue()"),GetBaseName().c_str());
2189
2190     for ( i=0; i<GetChildCount(); i++ )
2191     {
2192         const wxPGProperty* child = Item(i);
2193
2194         if ( childValue.GetName() == child->GetBaseName() )
2195         {
2196             //wxLogDebug(wxT("  %s(n=%i), %s"),childValue.GetName().c_str(),n,childValue.GetType().c_str());
2197
2198             if ( childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
2199             {
2200                 wxVariant cv2(child->GetValue());
2201                 child->AdaptListToValue(childValue, &cv2);
2202                 childValue = cv2;
2203             }
2204
2205             if ( allChildrenSpecified )
2206             {
2207                 *value = ChildChanged(*value, i, childValue);
2208             }
2209
2210             n++;
2211             if ( n == (unsigned int)list.GetCount() )
2212                 break;
2213             childValue = list[n];
2214         }
2215     }
2216 }
2217
2218
2219 void wxPGProperty::FixIndicesOfChildren( unsigned int starthere )
2220 {
2221     size_t i;
2222     for ( i=starthere;i<GetChildCount();i++)
2223         Item(i)->m_arrIndex = i;
2224 }
2225
2226
2227 // Returns (direct) child property with given name (or NULL if not found)
2228 wxPGProperty* wxPGProperty::GetPropertyByName( const wxString& name ) const
2229 {
2230     size_t i;
2231
2232     for ( i=0; i<GetChildCount(); i++ )
2233     {
2234         wxPGProperty* p = Item(i);
2235         if ( p->m_name == name )
2236             return p;
2237     }
2238
2239     // Does it have point, then?
2240     int pos = name.Find(wxS('.'));
2241     if ( pos <= 0 )
2242         return NULL;
2243
2244     wxPGProperty* p = GetPropertyByName(name. substr(0,pos));
2245
2246     if ( !p || !p->GetChildCount() )
2247         return NULL;
2248
2249     return p->GetPropertyByName(name.substr(pos+1,name.length()-pos-1));
2250 }
2251
2252 wxPGProperty* wxPGProperty::GetPropertyByNameWH( const wxString& name, unsigned int hintIndex ) const
2253 {
2254     unsigned int i = hintIndex;
2255
2256     if ( i >= GetChildCount() )
2257         i = 0;
2258
2259     unsigned int lastIndex = i - 1;
2260
2261     if ( lastIndex >= GetChildCount() )
2262         lastIndex = GetChildCount() - 1;
2263
2264     for (;;)
2265     {
2266         wxPGProperty* p = Item(i);
2267         if ( p->m_name == name )
2268             return p;
2269
2270         if ( i == lastIndex )
2271             break;
2272
2273         i++;
2274         if ( i == GetChildCount() )
2275             i = 0;
2276     };
2277
2278     return NULL;
2279 }
2280
2281 int wxPGProperty::GetChildrenHeight( int lh, int iMax_ ) const
2282 {
2283     // Returns height of children, recursively, and
2284     // by taking expanded/collapsed status into account.
2285     //
2286     // iMax is used when finding property y-positions.
2287     //
2288     unsigned int i = 0;
2289     int h = 0;
2290
2291     if ( iMax_ == -1 )
2292         iMax_ = GetChildCount();
2293
2294     unsigned int iMax = iMax_;
2295
2296     wxASSERT( iMax <= GetChildCount() );
2297
2298     if ( !IsExpanded() && GetParent() )
2299         return 0;
2300
2301     while ( i < iMax )
2302     {
2303         wxPGProperty* pwc = (wxPGProperty*) Item(i);
2304
2305         if ( !pwc->HasFlag(wxPG_PROP_HIDDEN) )
2306         {
2307             if ( !pwc->IsExpanded() ||
2308                  pwc->GetChildCount() == 0 )
2309                 h += lh;
2310             else
2311                 h += pwc->GetChildrenHeight(lh) + lh;
2312         }
2313
2314         i++;
2315     }
2316
2317     return h;
2318 }
2319
2320 wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y,
2321                                         unsigned int lh,
2322                                         unsigned int* nextItemY ) const
2323 {
2324     wxASSERT( nextItemY );
2325
2326     // Linear search at the moment
2327     //
2328     // nextItemY = y of next visible property, final value will be written back.
2329     wxPGProperty* result = NULL;
2330     wxPGProperty* current = NULL;
2331     unsigned int iy = *nextItemY;
2332     unsigned int i = 0;
2333     unsigned int iMax = GetChildCount();
2334
2335     while ( i < iMax )
2336     {
2337         wxPGProperty* pwc = Item(i);
2338
2339         if ( !pwc->HasFlag(wxPG_PROP_HIDDEN) )
2340         {
2341             // Found?
2342             if ( y < iy )
2343             {
2344                 result = current;
2345                 break;
2346             }
2347
2348             iy += lh;
2349
2350             if ( pwc->IsExpanded() &&
2351                  pwc->GetChildCount() > 0 )
2352             {
2353                 result = (wxPGProperty*) pwc->GetItemAtY( y, lh, &iy );
2354                 if ( result )
2355                     break;
2356             }
2357
2358             current = pwc;
2359         }
2360
2361         i++;
2362     }
2363
2364     // Found?
2365     if ( !result && y < iy )
2366         result = current;
2367
2368     *nextItemY = iy;
2369
2370     /*
2371     if ( current )
2372     {
2373         wxLogDebug(wxT("%s::GetItemAtY(%i) -> %s"),this->GetLabel().c_str(),y,current->GetLabel().c_str());
2374     }
2375     else
2376     {
2377         wxLogDebug(wxT("%s::GetItemAtY(%i) -> NULL"),this->GetLabel().c_str(),y);
2378     }
2379     */
2380
2381     return (wxPGProperty*) result;
2382 }
2383
2384 void wxPGProperty::Empty()
2385 {
2386     size_t i;
2387     if ( !HasFlag(wxPG_PROP_CHILDREN_ARE_COPIES) )
2388     {
2389         for ( i=0; i<GetChildCount(); i++ )
2390         {
2391             delete m_children[i];
2392         }
2393     }
2394
2395     m_children.clear();
2396 }
2397
2398 wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y ) const
2399 {
2400     unsigned int nextItem;
2401     return GetItemAtY( y, GetGrid()->GetRowHeight(), &nextItem);
2402 }
2403
2404 void wxPGProperty::DeleteChildren()
2405 {
2406     wxPropertyGridPageState* state = m_parentState;
2407
2408     while ( GetChildCount() )
2409     {
2410         wxPGProperty* child = Item(GetChildCount()-1);
2411         state->DoDelete(child, true);
2412     }
2413 }
2414
2415 wxVariant wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
2416                                       int WXUNUSED(childIndex),
2417                                       wxVariant& WXUNUSED(childValue) ) const
2418 {
2419     return wxNullVariant;
2420 }
2421
2422 bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
2423 {
2424     unsigned int i;
2425
2426     const wxVariantList* pList = NULL;
2427     wxVariantList::const_iterator node;
2428
2429     if ( pendingList )
2430     {
2431         pList = &pendingList->GetList();
2432         node = pList->begin();
2433     }
2434
2435     for ( i=0; i<GetChildCount(); i++ )
2436     {
2437         wxPGProperty* child = Item(i);
2438         const wxVariant* listValue = NULL;
2439         wxVariant value;
2440
2441         if ( pendingList )
2442         {
2443             const wxString& childName = child->GetBaseName();
2444
2445             for ( ; node != pList->end(); ++node )
2446             {
2447                 const wxVariant& item = *((const wxVariant*)*node);
2448                 if ( item.GetName() == childName )
2449                 {
2450                     listValue = &item;
2451                     value = item;
2452                     break;
2453                 }
2454             }
2455         }
2456
2457         if ( !listValue )
2458             value = child->GetValue();
2459
2460         if ( value.IsNull() )
2461             return false;
2462
2463         // Check recursively
2464         if ( child->GetChildCount() )
2465         {
2466             const wxVariant* childList = NULL;
2467
2468             if ( listValue && listValue->GetType() == wxPG_VARIANT_TYPE_LIST )
2469                 childList = listValue;
2470
2471             if ( !child->AreAllChildrenSpecified((wxVariant*)childList) )
2472                 return false;
2473         }
2474     }
2475
2476     return true;
2477 }
2478
2479 wxPGProperty* wxPGProperty::UpdateParentValues()
2480 {
2481     wxPGProperty* parent = m_parent;
2482     if ( parent && parent->HasFlag(wxPG_PROP_COMPOSED_VALUE) &&
2483          !parent->IsCategory() && !parent->IsRoot() )
2484     {
2485         wxString s;
2486         parent->DoGenerateComposedValue(s);
2487         parent->m_value = s;
2488         return parent->UpdateParentValues();
2489     }
2490     return this;
2491 }
2492
2493 bool wxPGProperty::IsTextEditable() const
2494 {
2495     if ( HasFlag(wxPG_PROP_READONLY) )
2496         return false;
2497
2498     if ( HasFlag(wxPG_PROP_NOEDITOR) &&
2499          (GetChildCount() ||
2500           wxString(GetEditorClass()->GetClassInfo()->GetClassName()).EndsWith(wxS("Button")))
2501        )
2502         return false;
2503
2504     return true;
2505 }
2506
2507 // Call after fixed sub-properties added/removed after creation.
2508 // if oldSelInd >= 0 and < new max items, then selection is
2509 // moved to it. Note: oldSelInd -2 indicates that this property
2510 // should be selected.
2511 void wxPGProperty::SubPropsChanged( int oldSelInd )
2512 {
2513     wxPropertyGridPageState* state = GetParentState();
2514     wxPropertyGrid* grid = state->GetGrid();
2515
2516     //
2517     // Re-repare children (recursively)
2518     for ( unsigned int i=0; i<GetChildCount(); i++ )
2519     {
2520         wxPGProperty* child = Item(i);
2521         child->InitAfterAdded(state, grid);
2522     }
2523
2524     wxPGProperty* sel = NULL;
2525     if ( oldSelInd >= (int)m_children.size() )
2526         oldSelInd = (int)m_children.size() - 1;
2527
2528     if ( oldSelInd >= 0 )
2529         sel = m_children[oldSelInd];
2530     else if ( oldSelInd == -2 )
2531         sel = this;
2532
2533     if ( sel )
2534         state->DoSelectProperty(sel);
2535
2536     if ( state == grid->GetState() )
2537     {
2538         grid->GetPanel()->Refresh();
2539     }
2540 }
2541
2542 // -----------------------------------------------------------------------
2543 // wxPGRootProperty
2544 // -----------------------------------------------------------------------
2545
2546 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPGRootProperty,none,TextCtrl)
2547 IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
2548
2549
2550 wxPGRootProperty::wxPGRootProperty( const wxString& name )
2551     : wxPGProperty()
2552 {
2553     m_name = name;
2554     m_label = m_name;
2555     SetParentalType(0);
2556     m_depth = 0;
2557 }
2558
2559
2560 wxPGRootProperty::~wxPGRootProperty()
2561 {
2562 }
2563
2564
2565 // -----------------------------------------------------------------------
2566 // wxPropertyCategory
2567 // -----------------------------------------------------------------------
2568
2569 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPropertyCategory,none,TextCtrl)
2570 IMPLEMENT_DYNAMIC_CLASS(wxPropertyCategory, wxPGProperty)
2571
2572 void wxPropertyCategory::Init()
2573 {
2574     // don't set colour - prepareadditem method should do this
2575     SetParentalType(wxPG_PROP_CATEGORY);
2576     m_capFgColIndex = 1;
2577     m_textExtent = -1;
2578 }
2579
2580 wxPropertyCategory::wxPropertyCategory()
2581     : wxPGProperty()
2582 {
2583     Init();
2584 }
2585
2586
2587 wxPropertyCategory::wxPropertyCategory( const wxString &label, const wxString& name )
2588     : wxPGProperty(label,name)
2589 {
2590     Init();
2591 }
2592
2593
2594 wxPropertyCategory::~wxPropertyCategory()
2595 {
2596 }
2597
2598
2599 wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
2600                                             int WXUNUSED(argFlags) ) const
2601 {
2602     return wxEmptyString;
2603 }
2604
2605 int wxPropertyCategory::GetTextExtent( const wxWindow* wnd, const wxFont& font ) const
2606 {
2607     if ( m_textExtent > 0 )
2608         return m_textExtent;
2609     int x = 0, y = 0;
2610     ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font );
2611     return x;
2612 }
2613
2614 void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font )
2615 {
2616     int x = 0, y = 0;
2617     wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font );
2618     m_textExtent = x;
2619 }
2620
2621 // -----------------------------------------------------------------------
2622 // wxPGChoices
2623 // -----------------------------------------------------------------------
2624
2625 wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, int value )
2626 {
2627     AllocExclusive();
2628
2629     wxPGChoiceEntry entry(label, value);
2630     return m_data->Insert( -1, entry );
2631 }
2632
2633 // -----------------------------------------------------------------------
2634
2635 wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, const wxBitmap& bitmap, int value )
2636 {
2637     AllocExclusive();
2638
2639     wxPGChoiceEntry entry(label, value);
2640     entry.SetBitmap(bitmap);
2641     return m_data->Insert( -1, entry );
2642 }
2643
2644 // -----------------------------------------------------------------------
2645
2646 wxPGChoiceEntry& wxPGChoices::Insert( const wxPGChoiceEntry& entry, int index )
2647 {
2648     AllocExclusive();
2649
2650     return m_data->Insert( index, entry );
2651 }
2652
2653 // -----------------------------------------------------------------------
2654
2655 wxPGChoiceEntry& wxPGChoices::Insert( const wxString& label, int index, int value )
2656 {
2657     AllocExclusive();
2658
2659     wxPGChoiceEntry entry(label, value);
2660     return m_data->Insert( index, entry );
2661 }
2662
2663 // -----------------------------------------------------------------------
2664
2665 wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value )
2666 {
2667     AllocExclusive();
2668
2669     size_t index = 0;
2670
2671     while ( index < GetCount() )
2672     {
2673         int cmpRes = GetLabel(index).Cmp(label);
2674         if ( cmpRes > 0 )
2675             break;
2676         index++;
2677     }
2678
2679     wxPGChoiceEntry entry(label, value);
2680     return m_data->Insert( index, entry );
2681 }
2682
2683 // -----------------------------------------------------------------------
2684
2685 void wxPGChoices::Add( const wxChar** labels, const ValArrItem* values )
2686 {
2687     AllocExclusive();
2688
2689     unsigned int itemcount = 0;
2690     const wxChar** p = &labels[0];
2691     while ( *p ) { p++; itemcount++; }
2692
2693     unsigned int i;
2694     for ( i = 0; i < itemcount; i++ )
2695     {
2696         int value = i;
2697         if ( values )
2698             value = values[i];
2699         wxPGChoiceEntry entry(labels[i], value);
2700         m_data->Insert( i, entry );
2701     }
2702 }
2703
2704 // -----------------------------------------------------------------------
2705
2706 void wxPGChoices::Add( const wxArrayString& arr, const wxArrayInt& arrint )
2707 {
2708     AllocExclusive();
2709
2710     unsigned int i;
2711     unsigned int itemcount = arr.size();
2712
2713     for ( i = 0; i < itemcount; i++ )
2714     {
2715         int value = i;
2716         if ( &arrint && arrint.size() )
2717             value = arrint[i];
2718         wxPGChoiceEntry entry(arr[i], value);
2719         m_data->Insert( i, entry );
2720     }
2721 }
2722
2723 // -----------------------------------------------------------------------
2724
2725 void wxPGChoices::RemoveAt(size_t nIndex, size_t count)
2726 {
2727     AllocExclusive();
2728
2729     wxASSERT( m_data->GetRefCount() != -1 );
2730     m_data->m_items.erase(m_data->m_items.begin()+nIndex,
2731                           m_data->m_items.begin()+nIndex+count);
2732 }
2733
2734 // -----------------------------------------------------------------------
2735
2736 void wxPGChoices::Clear()
2737 {
2738     if ( m_data != wxPGChoicesEmptyData )
2739     {
2740         AllocExclusive();
2741         m_data->Clear();
2742     }
2743 }
2744
2745 // -----------------------------------------------------------------------
2746
2747 int wxPGChoices::Index( const wxString& str ) const
2748 {
2749     if ( IsOk() )
2750     {
2751         unsigned int i;
2752         for ( i=0; i< m_data->GetCount(); i++ )
2753         {
2754             const wxPGChoiceEntry& entry = m_data->Item(i);
2755             if ( entry.HasText() && entry.GetText() == str )
2756                 return i;
2757         }
2758     }
2759     return -1;
2760 }
2761
2762 // -----------------------------------------------------------------------
2763
2764 int wxPGChoices::Index( int val ) const
2765 {
2766     if ( IsOk() )
2767     {
2768         unsigned int i;
2769         for ( i=0; i< m_data->GetCount(); i++ )
2770         {
2771             const wxPGChoiceEntry& entry = m_data->Item(i);
2772             if ( entry.GetValue() == val )
2773                 return i;
2774         }
2775     }
2776     return -1;
2777 }
2778
2779 // -----------------------------------------------------------------------
2780
2781 wxArrayString wxPGChoices::GetLabels() const
2782 {
2783     wxArrayString arr;
2784     unsigned int i;
2785
2786     if ( this && IsOk() )
2787         for ( i=0; i<GetCount(); i++ )
2788             arr.push_back(GetLabel(i));
2789
2790     return arr;
2791 }
2792
2793 // -----------------------------------------------------------------------
2794
2795 wxArrayInt wxPGChoices::GetValuesForStrings( const wxArrayString& strings ) const
2796 {
2797     wxArrayInt arr;
2798
2799     if ( IsOk() )
2800     {
2801         unsigned int i;
2802         for ( i=0; i< strings.size(); i++ )
2803         {
2804             int index = Index(strings[i]);
2805             if ( index >= 0 )
2806                 arr.Add(GetValue(index));
2807             else
2808                 arr.Add(wxPG_INVALID_VALUE);
2809         }
2810     }
2811
2812     return arr;
2813 }
2814
2815 // -----------------------------------------------------------------------
2816
2817 wxArrayInt wxPGChoices::GetIndicesForStrings( const wxArrayString& strings,
2818                                               wxArrayString* unmatched ) const
2819 {
2820     wxArrayInt arr;
2821
2822     if ( IsOk() )
2823     {
2824         unsigned int i;
2825         for ( i=0; i< strings.size(); i++ )
2826         {
2827             const wxString& str = strings[i];
2828             int index = Index(str);
2829             if ( index >= 0 )
2830                 arr.Add(index);
2831             else if ( unmatched )
2832                 unmatched->Add(str);
2833         }
2834     }
2835
2836     return arr;
2837 }
2838
2839 // -----------------------------------------------------------------------
2840
2841 void wxPGChoices::AllocExclusive()
2842 {
2843     EnsureData();
2844
2845     if ( m_data->GetRefCount() != 1 )
2846     {
2847         wxPGChoicesData* data = new wxPGChoicesData();
2848         data->CopyDataFrom(m_data);
2849         Free();
2850         m_data = data;
2851     }
2852 }
2853
2854 // -----------------------------------------------------------------------
2855
2856 void wxPGChoices::AssignData( wxPGChoicesData* data )
2857 {
2858     Free();
2859
2860     if ( data != wxPGChoicesEmptyData )
2861     {
2862         m_data = data;
2863         data->IncRef();
2864     }
2865 }
2866
2867 // -----------------------------------------------------------------------
2868
2869 void wxPGChoices::Init()
2870 {
2871     m_data = wxPGChoicesEmptyData;
2872 }
2873
2874 // -----------------------------------------------------------------------
2875
2876 void wxPGChoices::Free()
2877 {
2878     if ( m_data != wxPGChoicesEmptyData )
2879     {
2880         m_data->DecRef();
2881         m_data = wxPGChoicesEmptyData;
2882     }
2883 }
2884
2885 // -----------------------------------------------------------------------
2886 // wxPGAttributeStorage
2887 // -----------------------------------------------------------------------
2888
2889 wxPGAttributeStorage::wxPGAttributeStorage()
2890 {
2891 }
2892
2893 wxPGAttributeStorage::~wxPGAttributeStorage()
2894 {
2895     wxPGHashMapS2P::iterator it;
2896
2897     for ( it = m_map.begin(); it != m_map.end(); ++it )
2898     {
2899         wxVariantData* data = (wxVariantData*) it->second;
2900         data->DecRef();
2901     }
2902 }
2903
2904 void wxPGAttributeStorage::Set( const wxString& name, const wxVariant& value )
2905 {
2906     wxVariantData* data = value.GetData();
2907
2908     // Free old, if any
2909     wxPGHashMapS2P::iterator it = m_map.find(name);
2910     if ( it != m_map.end() )
2911     {
2912         ((wxVariantData*)it->second)->DecRef();
2913
2914         if ( !data )
2915         {
2916             // If Null variant, just remove from set
2917             m_map.erase(it);
2918             return;
2919         }
2920     }
2921
2922     if ( data )
2923     {
2924         data->IncRef();
2925
2926         m_map[name] = data;
2927     }
2928 }
2929
2930 #endif  // wxUSE_PROPGRID