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