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