src/propgrid/propgridpagestate.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/propgrid/propgridpagestate.cpp
   3 // Purpose:     wxPropertyGridPageState class
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2008-08-24
   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/intl.h"
  35     #include "wx/stopwatch.h"
  36 #endif
  37
  38 // This define is necessary to prevent macro clearing
  39 #define __wxPG_SOURCE_FILE__
  40
  41 #include "wx/propgrid/propgridpagestate.h"
  42 #include "wx/propgrid/propgrid.h"
  43 #include "wx/propgrid/editors.h"
  44
  45 #define wxPG_DEFAULT_SPLITTERX      110
  46
  47
  48 // -----------------------------------------------------------------------
  49 // wxPropertyGridIterator
  50 // -----------------------------------------------------------------------
  51
  52 void wxPropertyGridIteratorBase::Init( wxPropertyGridPageState* state, int flags, wxPGProperty* property, int dir  )
  53 {
  54     wxASSERT( dir == 1 || dir == -1 );
  55
  56     m_state = state;
  57     m_baseParent = state->DoGetRoot();
  58     if ( !property && m_baseParent->GetChildCount() )
  59         property = m_baseParent->Item(0);
  60
  61     m_property = property;
  62
  63     wxPG_ITERATOR_CREATE_MASKS(flags, m_itemExMask, m_parentExMask)
  64
  65     // Need to skip first?
  66     if ( property && (property->GetFlags() & m_itemExMask) )
  67     {
  68         if ( dir == 1 )
  69             Next();
  70         else
  71             Prev();
  72     }
  73 }
  74
  75 void wxPropertyGridIteratorBase::Init( wxPropertyGridPageState* state, int flags, int startPos, int dir  )
  76 {
  77     wxPGProperty* property = NULL;
  78
  79     if ( startPos == wxTOP )
  80     {
  81         if ( dir == 0 )
  82             dir = 1;
  83     }
  84     else if ( startPos == wxBOTTOM )
  85     {
  86         property = state->GetLastItem(flags);
  87         if ( dir == 0 )
  88             dir = -1;
  89     }
  90     else
  91     {
  92         wxFAIL_MSG("Only supported starting positions are wxTOP and wxBOTTOM");
  93     }
  94
  95     Init( state, flags, property, dir );
  96 }
  97
  98 void wxPropertyGridIteratorBase::Assign( const wxPropertyGridIteratorBase& it )
  99 {
 100     m_property = it.m_property;
 101     m_state = it.m_state;
 102     m_baseParent = it.m_baseParent;
 103     m_itemExMask = it.m_itemExMask;
 104     m_parentExMask = it.m_parentExMask;
 105 }
 106
 107 void wxPropertyGridIteratorBase::Prev()
 108 {
 109     wxPGProperty* property = m_property;
 110     if ( !property )
 111         return;
 112
 113     wxPGProperty* parent = property->GetParent();
 114     wxASSERT( parent );
 115     unsigned int index = property->GetIndexInParent();
 116
 117     if ( index > 0 )
 118     {
 119         // Previous sibling
 120         index--;
 121
 122         property = parent->Item(index);
 123
 124         // Go to last children?
 125         if ( property->GetChildCount() &&
 126              wxPG_ITERATOR_PARENTEXMASK_TEST(property, m_parentExMask) )
 127         {
 128             // First child
 129             property = property->Last();
 130         }
 131     }
 132     else
 133     {
 134         // Up to a parent
 135         if ( parent == m_baseParent )
 136         {
 137             m_property = NULL;
 138             return;
 139         }
 140         else
 141         {
 142             property = parent;
 143         }
 144     }
 145
 146     m_property = property;
 147
 148     // If property does not match our criteria, skip it
 149     if ( property->GetFlags() & m_itemExMask )
 150         Prev();
 151 }
 152
 153 void wxPropertyGridIteratorBase::Next( bool iterateChildren )
 154 {
 155     wxPGProperty* property = m_property;
 156     if ( !property )
 157         return;
 158
 159     if ( property->GetChildCount() &&
 160          wxPG_ITERATOR_PARENTEXMASK_TEST(property, m_parentExMask) &&
 161          iterateChildren )
 162     {
 163         // First child
 164         property = property->Item(0);
 165     }
 166     else
 167     {
 168         wxPGProperty* parent = property->GetParent();
 169         wxASSERT( parent );
 170         unsigned int index = property->GetIndexInParent() + 1;
 171
 172         if ( index < parent->GetChildCount() )
 173         {
 174             // Next sibling
 175             property = parent->Item(index);
 176         }
 177         else
 178         {
 179             // Next sibling of parent
 180             if ( parent == m_baseParent )
 181             {
 182                 m_property = NULL;
 183             }
 184             else
 185             {
 186                 m_property = parent;
 187                 Next(false);
 188             }
 189             return;
 190         }
 191     }
 192
 193     m_property = property;
 194
 195     // If property does not match our criteria, skip it
 196     if ( property->GetFlags() & m_itemExMask )
 197         Next();
 198 }
 199
 200 // -----------------------------------------------------------------------
 201 // wxPropertyGridPageState
 202 // -----------------------------------------------------------------------
 203
 204 wxPropertyGridPageState::wxPropertyGridPageState()
 205 {
 206     m_pPropGrid = NULL;
 207     m_regularArray.SetParentState(this);
 208     m_properties = &m_regularArray;
 209     m_abcArray = NULL;
 210     m_currentCategory = NULL;
 211     m_width = 0;
 212     m_virtualHeight = 0;
 213     m_lastCaptionBottomnest = 1;
 214     m_itemsAdded = 0;
 215     m_anyModified = 0;
 216     m_vhCalcPending = 0;
 217     m_colWidths.push_back( wxPG_DEFAULT_SPLITTERX );
 218     m_colWidths.push_back( wxPG_DEFAULT_SPLITTERX );
 219     m_fSplitterX = wxPG_DEFAULT_SPLITTERX;
 220
 221     m_isSplitterPreSet = false;
 222     m_dontCenterSplitter = false;
 223
 224     // By default, we only have the 'value' column editable
 225     m_editableColumns.push_back(1);
 226 }
 227
 228 // -----------------------------------------------------------------------
 229
 230 wxPropertyGridPageState::~wxPropertyGridPageState()
 231 {
 232     delete m_abcArray;
 233 }
 234
 235 // -----------------------------------------------------------------------
 236
 237 void wxPropertyGridPageState::InitNonCatMode()
 238 {
 239     if ( !m_abcArray )
 240     {
 241         m_abcArray = new wxPGRootProperty(wxS("<Root_NonCat>"));
 242         m_abcArray->SetParentState(this);
 243         m_abcArray->SetFlag(wxPG_PROP_CHILDREN_ARE_COPIES);
 244     }
 245
 246     // Must be called when state::m_properties still points to regularArray.
 247     wxPGProperty* oldProperties = m_properties;
 248
 249     // Must use temp value in state::m_properties for item iteration loop
 250     // to run as expected.
 251     m_properties = &m_regularArray;
 252
 253     if ( m_properties->GetChildCount() )
 254     {
 255         //
 256         // Prepare m_abcArray
 257         wxPropertyGridIterator it( this, wxPG_ITERATE_PROPERTIES );
 258
 259         for ( ; !it.AtEnd(); it.Next() )
 260         {
 261             wxPGProperty* p = it.GetProperty();
 262             wxPGProperty* parent = p->GetParent();
 263             if ( parent->IsCategory() || parent->IsRoot() )
 264             {
 265                 m_abcArray->DoAddChild(p);
 266                 p->m_parent = &m_regularArray;
 267             }
 268         }
 269     }
 270
 271     m_properties = oldProperties;
 272 }
 273
 274 // -----------------------------------------------------------------------
 275
 276 void wxPropertyGridPageState::DoClear()
 277 {
 278     if ( m_pPropGrid && m_pPropGrid->GetState() == this  )
 279     {
 280         m_pPropGrid->ClearSelection(false);
 281     }
 282     else
 283     {
 284         m_selection.clear();
 285     }
 286
 287     m_regularArray.Empty();
 288     if ( m_abcArray )
 289         m_abcArray->Empty();
 290
 291     m_dictName.clear();
 292
 293     m_currentCategory = NULL;
 294     m_lastCaptionBottomnest = 1;
 295     m_itemsAdded = 0;
 296
 297     m_virtualHeight = 0;
 298     m_vhCalcPending = 0;
 299 }
 300
 301 // -----------------------------------------------------------------------
 302
 303 void wxPropertyGridPageState::CalculateFontAndBitmapStuff( int WXUNUSED(vspacing) )
 304 {
 305     wxPropertyGrid* propGrid = GetGrid();
 306
 307     VirtualHeightChanged();
 308
 309     // Recalculate caption text extents.
 310     unsigned int i;
 311
 312     for ( i=0;i<m_regularArray.GetChildCount();i++ )
 313     {
 314         wxPGProperty* p =m_regularArray.Item(i);
 315
 316         if ( p->IsCategory() )
 317             ((wxPropertyCategory*)p)->CalculateTextExtent(propGrid, propGrid->GetCaptionFont());
 318     }
 319 }
 320
 321 // -----------------------------------------------------------------------
 322
 323 void wxPropertyGridPageState::SetVirtualWidth( int width )
 324 {
 325     // Sometimes width less than 0 is offered. Let's make things easy for
 326     // everybody and deal with it here.
 327     if ( width < 0 )
 328         width = 0;
 329
 330     wxPropertyGrid* pg = GetGrid();
 331     int gw = pg->GetClientSize().x;
 332     if ( width < gw )
 333         width = gw;
 334
 335     m_width = width;
 336 }
 337
 338 // -----------------------------------------------------------------------
 339
 340 void wxPropertyGridPageState::OnClientWidthChange( int newWidth, int widthChange, bool fromOnResize )
 341 {
 342     wxPropertyGrid* pg = GetGrid();
 343
 344     if ( pg->HasVirtualWidth() )
 345     {
 346         if ( m_width < newWidth )
 347             SetVirtualWidth( newWidth );
 348
 349         CheckColumnWidths(widthChange);
 350     }
 351     else
 352     {
 353         SetVirtualWidth( newWidth );
 354
 355         // This should be done before splitter auto centering
 356         // NOTE: Splitter auto-centering is done in this function.
 357         if ( !fromOnResize )
 358             widthChange = 0;
 359         CheckColumnWidths(widthChange);
 360
 361         if ( !m_isSplitterPreSet && m_dontCenterSplitter )
 362         {
 363             long timeSinceCreation = (::wxGetLocalTimeMillis() - GetGrid()->m_timeCreated).ToLong();
 364
 365             // If too long, don't set splitter
 366             if ( timeSinceCreation < 250 )
 367             {
 368                 if ( m_properties->GetChildCount() )
 369                 {
 370                     SetSplitterLeft( false );
 371                 }
 372                 else
 373                 {
 374                     DoSetSplitterPosition( newWidth / 2 );
 375                     m_isSplitterPreSet = false;
 376                 }
 377             }
 378         }
 379     }
 380 }
 381
 382 // -----------------------------------------------------------------------
 383 // wxPropertyGridPageState item iteration methods
 384 // -----------------------------------------------------------------------
 385
 386 wxPGProperty* wxPropertyGridPageState::GetLastItem( int flags )
 387 {
 388     if ( !m_properties->GetChildCount() )
 389         return NULL;
 390
 391     wxPG_ITERATOR_CREATE_MASKS(flags, int itemExMask, int parentExMask)
 392
 393     // First, get last child of last parent
 394     wxPGProperty* pwc = (wxPGProperty*)m_properties->Last();
 395     while ( pwc->GetChildCount() &&
 396             wxPG_ITERATOR_PARENTEXMASK_TEST(pwc, parentExMask) )
 397         pwc = (wxPGProperty*) pwc->Last();
 398
 399     // Then, if it doesn't fit our criteria, back up until we find something that does
 400     if ( pwc->GetFlags() & itemExMask )
 401     {
 402         wxPropertyGridIterator it( this, flags, pwc );
 403         for ( ; !it.AtEnd(); it.Prev() )
 404             ;
 405         pwc = (wxPGProperty*) it.GetProperty();
 406     }
 407
 408     return pwc;
 409 }
 410
 411 wxPropertyCategory* wxPropertyGridPageState::GetPropertyCategory( const wxPGProperty* p ) const
 412 {
 413     const wxPGProperty* parent = (const wxPGProperty*)p;
 414     const wxPGProperty* grandparent = (const wxPGProperty*)parent->GetParent();
 415     do
 416     {
 417         parent = grandparent;
 418         grandparent = (wxPGProperty*)parent->GetParent();
 419         if ( parent->IsCategory() && grandparent )
 420             return (wxPropertyCategory*)parent;
 421     } while ( grandparent );
 422
 423     return NULL;
 424 }
 425
 426 // -----------------------------------------------------------------------
 427 // wxPropertyGridPageState GetPropertyXXX methods
 428 // -----------------------------------------------------------------------
 429
 430 wxPGProperty* wxPropertyGridPageState::GetPropertyByLabel( const wxString& label,
 431                                                            wxPGProperty* parent ) const
 432 {
 433
 434     size_t i;
 435
 436     if ( !parent ) parent = (wxPGProperty*) &m_regularArray;
 437
 438     for ( i=0; i<parent->GetChildCount(); i++ )
 439     {
 440         wxPGProperty* p = parent->Item(i);
 441         if ( p->m_label == label )
 442             return p;
 443         // Check children recursively.
 444         if ( p->GetChildCount() )
 445         {
 446             p = GetPropertyByLabel(label,(wxPGProperty*)p);
 447             if ( p )
 448                 return p;
 449         }
 450     }
 451
 452     return NULL;
 453 }
 454
 455 // -----------------------------------------------------------------------
 456
 457 wxPGProperty* wxPropertyGridPageState::BaseGetPropertyByName( const wxString& name ) const
 458 {
 459     wxPGHashMapS2P::const_iterator it;
 460     it = m_dictName.find(name);
 461     if ( it != m_dictName.end() )
 462         return (wxPGProperty*) it->second;
 463     return NULL;
 464 }
 465
 466 // -----------------------------------------------------------------------
 467
 468 void wxPropertyGridPageState::DoSetPropertyName( wxPGProperty* p,
 469                                                  const wxString& newName )
 470 {
 471     wxCHECK_RET( p, wxT("invalid property id") );
 472
 473     wxPGProperty* parent = p->GetParent();
 474
 475     if ( parent->IsCategory() || parent->IsRoot() )
 476     {
 477         if ( p->GetBaseName().length() )
 478             m_dictName.erase( p->GetBaseName() );
 479         if ( newName.length() )
 480             m_dictName[newName] = (void*) p;
 481     }
 482
 483     p->DoSetName(newName);
 484 }
 485
 486 // -----------------------------------------------------------------------
 487 // wxPropertyGridPageState global operations
 488 // -----------------------------------------------------------------------
 489
 490 // -----------------------------------------------------------------------
 491 // Item iteration macros
 492 //   NB: Nowadays only needed for alphabetic/categoric mode switching.
 493 // -----------------------------------------------------------------------
 494
 495 //#define II_INVALID_I    0x00FFFFFF
 496
 497 #define ITEM_ITERATION_VARIABLES \
 498     wxPGProperty* parent; \
 499     unsigned int i; \
 500     unsigned int iMax;
 501
 502 #define ITEM_ITERATION_INIT_FROM_THE_TOP \
 503     parent = m_properties; \
 504     i = 0;
 505
 506 #if 0
 507 #define ITEM_ITERATION_INIT(startparent, startindex, state) \
 508     parent = startparent; \
 509     i = (unsigned int)startindex; \
 510     if ( parent == NULL ) \
 511     { \
 512         parent = state->m_properties; \
 513         i = 0; \
 514     }
 515 #endif
 516
 517 #define ITEM_ITERATION_LOOP_BEGIN \
 518     do \
 519     { \
 520         iMax = parent->GetChildCount(); \
 521         while ( i < iMax ) \
 522         {  \
 523             wxPGProperty* p = parent->Item(i);
 524
 525 #define ITEM_ITERATION_LOOP_END \
 526             if ( p->GetChildCount() ) \
 527             { \
 528                 i = 0; \
 529                 parent = (wxPGProperty*)p; \
 530                 iMax = parent->GetChildCount(); \
 531             } \
 532             else \
 533                 i++; \
 534         } \
 535         i = parent->m_arrIndex + 1; \
 536         parent = parent->m_parent; \
 537     } \
 538     while ( parent != NULL );
 539
 540 bool wxPropertyGridPageState::EnableCategories( bool enable )
 541 {
 542     //
 543     // NB: We can't use wxPropertyGridIterator in this
 544     //     function, since it depends on m_arrIndexes,
 545     //     which, among other things, is being fixed here.
 546     //
 547     ITEM_ITERATION_VARIABLES
 548
 549     if ( enable )
 550     {
 551         //
 552         // Enable categories
 553         //
 554
 555         if ( !IsInNonCatMode() )
 556             return false;
 557
 558         m_properties = &m_regularArray;
 559
 560         // fix parents, indexes, and depths
 561         ITEM_ITERATION_INIT_FROM_THE_TOP
 562
 563         ITEM_ITERATION_LOOP_BEGIN
 564
 565             p->m_arrIndex = i;
 566
 567             p->m_parent = parent;
 568
 569             // If parent was category, and this is not,
 570             // then the depth stays the same.
 571             if ( parent->IsCategory() &&
 572                  !p->IsCategory() )
 573                 p->m_depth = parent->m_depth;
 574             else
 575                 p->m_depth = parent->m_depth + 1;
 576
 577         ITEM_ITERATION_LOOP_END
 578
 579     }
 580     else
 581     {
 582         //
 583         // Disable categories
 584         //
 585
 586         if ( IsInNonCatMode() )
 587             return false;
 588
 589         // Create array, if necessary.
 590         if ( !m_abcArray )
 591             InitNonCatMode();
 592
 593         m_properties = m_abcArray;
 594
 595         // fix parents, indexes, and depths
 596         ITEM_ITERATION_INIT_FROM_THE_TOP
 597
 598         ITEM_ITERATION_LOOP_BEGIN
 599
 600             p->m_arrIndex = i;
 601
 602             p->m_parent = parent;
 603
 604             p->m_depth = parent->m_depth + 1;
 605
 606         ITEM_ITERATION_LOOP_END
 607     }
 608
 609     VirtualHeightChanged();
 610
 611     if ( m_pPropGrid->GetState() == this )
 612         m_pPropGrid->RecalculateVirtualSize();
 613
 614     return true;
 615 }
 616
 617 // -----------------------------------------------------------------------
 618
 619 static int wxPG_SortFunc_ByFunction(wxPGProperty **pp1, wxPGProperty **pp2)
 620 {
 621     wxPGProperty *p1 = *pp1;
 622     wxPGProperty *p2 = *pp2;
 623     wxPropertyGrid* pg = p1->GetGrid();
 624     wxPGSortCallback sortFunction = pg->GetSortFunction();
 625     return sortFunction(pg, p1, p2);
 626 }
 627
 628 static int wxPG_SortFunc_ByLabel(wxPGProperty **pp1, wxPGProperty **pp2)
 629 {
 630     wxPGProperty *p1 = *pp1;
 631     wxPGProperty *p2 = *pp2;
 632     return p1->GetLabel().CmpNoCase( p2->GetLabel() );
 633 }
 634
 635 #if 0
 636 //
 637 // For wxVector w/ wxUSE_STL=1, you would use code like this instead:
 638 //
 639
 640 #include <algorithm>
 641
 642 static bool wxPG_SortFunc_ByFunction(wxPGProperty *p1, wxPGProperty *p2)
 643 {
 644     wxPropertyGrid* pg = p1->GetGrid();
 645     wxPGSortCallback sortFunction = pg->GetSortFunction();
 646     return sortFunction(pg, p1, p2) < 0;
 647 }
 648
 649 static bool wxPG_SortFunc_ByLabel(wxPGProperty *p1, wxPGProperty *p2)
 650 {
 651     return p1->GetLabel().CmpNoCase( p2->GetLabel() ) < 0;
 652 }
 653 #endif
 654
 655 void wxPropertyGridPageState::DoSortChildren( wxPGProperty* p,
 656                                               int flags )
 657 {
 658     if ( !p )
 659         p = m_properties;
 660
 661     // Can only sort items with children
 662     if ( !p->GetChildCount() )
 663         return;
 664
 665     // Never sort children of aggregate properties
 666     if ( p->HasFlag(wxPG_PROP_AGGREGATE) )
 667         return;
 668
 669     if ( (flags & wxPG_SORT_TOP_LEVEL_ONLY)
 670          && !p->IsCategory() && !p->IsRoot() )
 671         return;
 672
 673     if ( GetGrid()->GetSortFunction() )
 674         p->m_children.Sort( wxPG_SortFunc_ByFunction );
 675     else
 676         p->m_children.Sort( wxPG_SortFunc_ByLabel );
 677
 678 #if 0
 679     //
 680     // For wxVector w/ wxUSE_STL=1, you would use code like this instead:
 681     //
 682     if ( GetGrid()->GetSortFunction() )
 683         std::sort(p->m_children.begin(), p->m_children.end(),
 684                   wxPG_SortFunc_ByFunction);
 685     else
 686         std::sort(p->m_children.begin(), p->m_children.end(),
 687                   wxPG_SortFunc_ByLabel);
 688 #endif
 689
 690     // Fix indices
 691     p->FixIndicesOfChildren();
 692
 693     if ( flags & wxPG_RECURSE )
 694     {
 695         // Apply sort recursively
 696         for ( unsigned int i=0; i<p->GetChildCount(); i++ )
 697             DoSortChildren(p->Item(i), flags);
 698     }
 699 }
 700
 701 // -----------------------------------------------------------------------
 702
 703 void wxPropertyGridPageState::DoSort( int flags )
 704 {
 705     DoSortChildren( m_properties, flags | wxPG_RECURSE );
 706
 707     // We used to sort categories as well here also if in non-categorized
 708     // mode, but doing would naturally cause child indices to become
 709     // corrupted.
 710 }
 711
 712 // -----------------------------------------------------------------------
 713
 714 bool wxPropertyGridPageState::PrepareAfterItemsAdded()
 715 {
 716     if ( !m_itemsAdded ) return false;
 717
 718     wxPropertyGrid* pg = GetGrid();
 719
 720     m_itemsAdded = 0;
 721
 722     if ( pg->HasFlag(wxPG_AUTO_SORT) )
 723         DoSort(wxPG_SORT_TOP_LEVEL_ONLY);
 724
 725     return true;
 726 }
 727
 728 // -----------------------------------------------------------------------
 729 // wxPropertyGridPageState splitter, column and hittest functions
 730 // -----------------------------------------------------------------------
 731
 732 wxPGProperty* wxPropertyGridPageState::DoGetItemAtY( int y ) const
 733 {
 734     // Outside?
 735     if ( y < 0 )
 736         return NULL;
 737
 738     unsigned int a = 0;
 739     return m_properties->GetItemAtY(y, GetGrid()->m_lineHeight, &a);
 740 }
 741
 742 // -----------------------------------------------------------------------
 743
 744 wxPropertyGridHitTestResult
 745 wxPropertyGridPageState::HitTest( const wxPoint&pt ) const
 746 {
 747     wxPropertyGridHitTestResult result;
 748     result.m_column = HitTestH( pt.x, &result.m_splitter,
 749                                 &result.m_splitterHitOffset );
 750     result.m_property = DoGetItemAtY( pt.y );
 751     return result;
 752 }
 753
 754 // -----------------------------------------------------------------------
 755
 756 // Used by SetSplitterLeft() and DotFitColumns()
 757 int wxPropertyGridPageState::GetColumnFitWidth(wxClientDC& dc,
 758                                            wxPGProperty* pwc,
 759                                            unsigned int col,
 760                                            bool subProps) const
 761 {
 762     wxPropertyGrid* pg = m_pPropGrid;
 763     size_t i;
 764     int maxW = 0;
 765     int w, h;
 766
 767     for ( i=0; i<pwc->GetChildCount(); i++ )
 768     {
 769         wxPGProperty* p = pwc->Item(i);
 770         if ( !p->IsCategory() )
 771         {
 772             const wxPGCell* cell = NULL;
 773             wxString text;
 774             p->GetDisplayInfo(col, -1, 0, &text, &cell);
 775             dc.GetTextExtent(text, &w, &h);
 776             if ( col == 0 )
 777                 w += ( ((int)p->m_depth-1) * pg->m_subgroup_extramargin );
 778
 779             // account for the bitmap
 780             if ( col == 1 )
 781                 w += p->GetImageOffset(pg->GetImageRect(p, -1).GetWidth());
 782
 783
 784             w += (wxPG_XBEFORETEXT*2);
 785
 786             if ( w > maxW )
 787                 maxW = w;
 788         }
 789
 790         if ( p->GetChildCount() &&
 791              ( subProps || p->IsCategory() ) )
 792         {
 793             w = GetColumnFitWidth( dc, p, col, subProps );
 794
 795             if ( w > maxW )
 796                 maxW = w;
 797         }
 798     }
 799
 800     return maxW;
 801 }
 802
 803 int wxPropertyGridPageState::DoGetSplitterPosition( int splitterColumn ) const
 804 {
 805     int n = GetGrid()->m_marginWidth;
 806     int i;
 807     for ( i=0; i<=splitterColumn; i++ )
 808         n += m_colWidths[i];
 809     return n;
 810 }
 811
 812 int wxPropertyGridPageState::GetColumnMinWidth( int WXUNUSED(column) ) const
 813 {
 814     return wxPG_DRAG_MARGIN;
 815 }
 816
 817 void wxPropertyGridPageState::PropagateColSizeDec( int column,
 818                                                    int decrease,
 819                                                    int dir )
 820 {
 821     int origWidth = m_colWidths[column];
 822     m_colWidths[column] -= decrease;
 823     int min = GetColumnMinWidth(column);
 824     int more = 0;
 825     if ( m_colWidths[column] < min )
 826     {
 827         more = decrease - (origWidth - min);
 828         m_colWidths[column] = min;
 829     }
 830
 831     //
 832     // FIXME: Causes erratic splitter changing, so as a workaround
 833     //        disabled if two or less columns.
 834
 835     if ( m_colWidths.size() <= 2 )
 836         return;
 837
 838     column += dir;
 839     if ( more && column < (int)m_colWidths.size() && column >= 0 )
 840         PropagateColSizeDec( column, more, dir );
 841 }
 842
 843 void wxPropertyGridPageState::DoSetSplitterPosition( int newXPos,
 844                                                      int splitterColumn,
 845                                                      bool WXUNUSED(allPages),
 846                                                      bool fromAutoCenter )
 847 {
 848     wxPropertyGrid* pg = GetGrid();
 849
 850     int adjust = newXPos - DoGetSplitterPosition(splitterColumn);
 851
 852     if ( !pg->HasVirtualWidth() )
 853     {
 854         // No virtual width
 855         int otherColumn;
 856         if ( adjust > 0 )
 857         {
 858             otherColumn = splitterColumn + 1;
 859             if ( otherColumn == (int)m_colWidths.size() )
 860                 otherColumn = 0;
 861             m_colWidths[splitterColumn] += adjust;
 862             PropagateColSizeDec( otherColumn, adjust, 1 );
 863         }
 864         else
 865         {
 866             otherColumn = splitterColumn + 1;
 867             if ( otherColumn == (int)m_colWidths.size() )
 868                 otherColumn = 0;
 869             m_colWidths[otherColumn] -= adjust;
 870             PropagateColSizeDec( splitterColumn, -adjust, -1 );
 871         }
 872     }
 873     else
 874     {
 875         m_colWidths[splitterColumn] += adjust;
 876     }
 877
 878     if ( splitterColumn == 0 )
 879         m_fSplitterX = (double) newXPos;
 880
 881     if ( !fromAutoCenter )
 882     {
 883         // Don't allow initial splitter auto-positioning after this.
 884         m_isSplitterPreSet = true;
 885
 886         CheckColumnWidths();
 887     }
 888 }
 889
 890 // Moves splitter so that all labels are visible, but just.
 891 void wxPropertyGridPageState::SetSplitterLeft( bool subProps )
 892 {
 893     wxPropertyGrid* pg = GetGrid();
 894     wxClientDC dc(pg);
 895     dc.SetFont(pg->GetFont());
 896
 897     int maxW = GetColumnFitWidth(dc, m_properties, 0, subProps);
 898
 899     if ( maxW > 0 )
 900     {
 901         maxW += pg->m_marginWidth;
 902         DoSetSplitterPosition( maxW );
 903     }
 904
 905     m_dontCenterSplitter = true;
 906 }
 907
 908 wxSize wxPropertyGridPageState::DoFitColumns( bool WXUNUSED(allowGridResize) )
 909 {
 910     wxPropertyGrid* pg = GetGrid();
 911     wxClientDC dc(pg);
 912     dc.SetFont(pg->GetFont());
 913
 914     int marginWidth = pg->m_marginWidth;
 915     int accWid = marginWidth;
 916     int maxColWidth = 500;
 917
 918     for ( unsigned int col=0; col < GetColumnCount(); col++ )
 919     {
 920         int fitWid = GetColumnFitWidth(dc, m_properties, col, true);
 921         int colMinWidth = GetColumnMinWidth(col);
 922         if ( fitWid < colMinWidth )
 923             fitWid = colMinWidth;
 924         else if ( fitWid > maxColWidth )
 925             fitWid = maxColWidth;
 926
 927         m_colWidths[col] = fitWid;
 928
 929         accWid += fitWid;
 930     }
 931
 932     // Expand last one to fill the width
 933     int remaining = m_width - accWid;
 934     m_colWidths[GetColumnCount()-1] += remaining;
 935
 936     m_dontCenterSplitter = true;
 937
 938     int firstSplitterX = marginWidth + m_colWidths[0];
 939     m_fSplitterX = (double) firstSplitterX;
 940
 941     // Don't allow initial splitter auto-positioning after this.
 942     if ( pg->GetState() == this )
 943     {
 944         pg->SetSplitterPosition(firstSplitterX, false);
 945         pg->Refresh();
 946     }
 947
 948     int x, y;
 949     pg->GetVirtualSize(&x, &y);
 950
 951     return wxSize(accWid, y);
 952 }
 953
 954 void wxPropertyGridPageState::CheckColumnWidths( int widthChange )
 955 {
 956     if ( m_width == 0 )
 957         return;
 958
 959     wxPropertyGrid* pg = GetGrid();
 960
 961     unsigned int i;
 962     unsigned int lastColumn = m_colWidths.size() - 1;
 963     int width = m_width;
 964     int clientWidth = pg->GetClientSize().x;
 965
 966     //
 967     // Column to reduce, if needed. Take last one that exceeds minimum width.
 968     int reduceCol = -1;
 969
 970     wxLogTrace("propgrid",
 971                wxS("ColumnWidthCheck (virtualWidth: %i, clientWidth: %i)"),
 972                width, clientWidth);
 973
 974     //
 975     // Check min sizes
 976     for ( i=0; i<m_colWidths.size(); i++ )
 977     {
 978         int min = GetColumnMinWidth(i);
 979         if ( m_colWidths[i] <= min )
 980         {
 981             m_colWidths[i] = min;
 982         }
 983         else
 984         {
 985             // Always reduce the last column that is larger than minimum size
 986             // (looks nicer, even with auto-centering enabled).
 987             reduceCol = i;
 988         }
 989     }
 990
 991     int colsWidth = pg->m_marginWidth;
 992     for ( i=0; i<m_colWidths.size(); i++ )
 993         colsWidth += m_colWidths[i];
 994
 995     wxLogTrace("propgrid",
 996                wxS("  HasVirtualWidth: %i  colsWidth: %i"),
 997                (int)pg->HasVirtualWidth(), colsWidth);
 998
 999     // Then mode-based requirement
1000     if ( !pg->HasVirtualWidth() )
1001     {
1002         int widthHigher = width - colsWidth;
1003
1004         // Adapt colsWidth to width
1005         if ( colsWidth < width )
1006         {
1007             // Increase column
1008             wxLogTrace("propgrid",
1009                        wxS("  Adjust last column to %i"),
1010                        m_colWidths[lastColumn] + widthHigher);
1011             m_colWidths[lastColumn] = m_colWidths[lastColumn] + widthHigher;
1012         }
1013         else if ( colsWidth > width )
1014         {
1015             // Reduce column
1016             if ( reduceCol != -1 )
1017             {
1018                 wxLogTrace("propgrid",
1019                            wxT("  Reduce column %i (by %i)"),
1020                            reduceCol, -widthHigher);
1021
1022                 // Reduce widest column, and recheck
1023                 m_colWidths[reduceCol] = m_colWidths[reduceCol] + widthHigher;
1024                 CheckColumnWidths();
1025             }
1026         }
1027     }
1028     else
1029     {
1030         // Only check colsWidth against clientWidth
1031         if ( colsWidth < clientWidth )
1032         {
1033             m_colWidths[lastColumn] = m_colWidths[lastColumn] + (clientWidth-colsWidth);
1034         }
1035
1036         m_width = colsWidth;
1037
1038         // If width changed, recalculate virtual size
1039         if ( pg->GetState() == this )
1040             pg->RecalculateVirtualSize();
1041     }
1042
1043     for ( i=0; i<m_colWidths.size(); i++ )
1044     {
1045         wxLogTrace("propgrid", wxS("col%i: %i"), i, m_colWidths[i]);
1046     }
1047
1048     // Auto center splitter
1049     if ( !m_dontCenterSplitter && m_colWidths.size() == 2 )
1050     {
1051         float centerX = (float)(pg->m_width/2);
1052         float splitterX;
1053
1054         if ( m_fSplitterX < 0.0 )
1055         {
1056             splitterX = centerX;
1057         }
1058         else if ( widthChange )
1059         {
1060             //float centerX = float(pg->GetSize().x) * 0.5;
1061
1062             // Recenter?
1063             splitterX = m_fSplitterX + (float(widthChange) * 0.5);
1064             float deviation = fabs(centerX - splitterX);
1065
1066             // If deviating from center, adjust towards it
1067             if ( deviation > 20.0 )
1068             {
1069                 if ( splitterX > centerX)
1070                     splitterX -= 2;
1071                 else
1072                     splitterX += 2;
1073             }
1074         }
1075         else
1076         {
1077             // No width change, just keep sure we keep splitter position intact
1078             splitterX = m_fSplitterX;
1079             float deviation = fabs(centerX - splitterX);
1080             if ( deviation > 50.0 )
1081             {
1082                 splitterX = centerX;
1083             }
1084         }
1085
1086         DoSetSplitterPosition((int)splitterX, 0, false, true);
1087
1088         m_fSplitterX = splitterX; // needed to retain accuracy
1089     }
1090 }
1091
1092 void wxPropertyGridPageState::SetColumnCount( int colCount )
1093 {
1094     wxASSERT( colCount >= 2 );
1095     m_colWidths.SetCount( colCount, wxPG_DRAG_MARGIN );
1096     if ( m_colWidths.size() > (unsigned int)colCount )
1097         m_colWidths.RemoveAt( m_colWidths.size(), m_colWidths.size() - colCount );
1098
1099     if ( m_pPropGrid->GetState() == this )
1100         m_pPropGrid->RecalculateVirtualSize();
1101     else
1102         CheckColumnWidths();
1103 }
1104
1105 // Returns column index, -1 for margin
1106 int wxPropertyGridPageState::HitTestH( int x, int* pSplitterHit, int* pSplitterHitOffset ) const
1107 {
1108     int cx = GetGrid()->m_marginWidth;
1109     int col = -1;
1110     int prevSplitter = -1;
1111
1112     while ( x > cx )
1113     {
1114         col++;
1115         if ( col >= (int)m_colWidths.size() )
1116         {
1117             *pSplitterHit = -1;
1118             return col;
1119         }
1120         prevSplitter = cx;
1121         cx += m_colWidths[col];
1122     }
1123
1124     // Near prev. splitter
1125     if ( col >= 1 )
1126     {
1127         int diff = x - prevSplitter;
1128         if ( abs(diff) < wxPG_SPLITTERX_DETECTMARGIN1 )
1129         {
1130             *pSplitterHit = col - 1;
1131             *pSplitterHitOffset = diff;
1132             return col;
1133         }
1134     }
1135
1136     // Near next splitter
1137     int nextSplitter = cx;
1138     if ( col < (int)(m_colWidths.size()-1) )
1139     {
1140         int diff = x - nextSplitter;
1141         if ( abs(diff) < wxPG_SPLITTERX_DETECTMARGIN1 )
1142         {
1143             *pSplitterHit = col;
1144             *pSplitterHitOffset = diff;
1145             return col;
1146         }
1147     }
1148
1149     *pSplitterHit = -1;
1150     return col;
1151 }
1152
1153 bool wxPropertyGridPageState::ArePropertiesAdjacent( wxPGProperty* prop1,
1154                                                      wxPGProperty* prop2,
1155                                                      int iterFlags ) const
1156 {
1157     const wxPGProperty* ap1 =
1158         wxPropertyGridConstIterator::OneStep(this,
1159                                              iterFlags,
1160                                              prop1,
1161                                              1);
1162     if ( ap1 && ap1 == prop2 )
1163         return true;
1164
1165     const wxPGProperty* ap2 =
1166         wxPropertyGridConstIterator::OneStep(this,
1167                                              iterFlags,
1168                                              prop1,
1169                                              -1);
1170     if ( ap2 && ap2 == prop2 )
1171         return true;
1172
1173     return false;
1174 }
1175
1176 // -----------------------------------------------------------------------
1177 // wxPropertyGridPageState property value setting and getting
1178 // -----------------------------------------------------------------------
1179
1180 bool wxPropertyGridPageState::DoSetPropertyValueString( wxPGProperty* p, const wxString& value )
1181 {
1182     if ( p )
1183     {
1184         int flags = wxPG_REPORT_ERROR|wxPG_FULL_VALUE|wxPG_PROGRAMMATIC_VALUE;
1185
1186         wxVariant variant = p->GetValueRef();
1187         bool res;
1188
1189         if ( p->GetMaxLength() <= 0 )
1190             res = p->StringToValue( variant, value, flags );
1191         else
1192             res = p->StringToValue( variant, value.Mid(0,p->GetMaxLength()), flags );
1193
1194         if ( res )
1195         {
1196             p->SetValue(variant);
1197             if ( p == m_pPropGrid->GetSelection() &&
1198                  this == m_pPropGrid->GetState() )
1199                 m_pPropGrid->RefreshEditor();
1200         }
1201
1202         return true;
1203     }
1204     return false;
1205 }
1206
1207 // -----------------------------------------------------------------------
1208
1209 bool wxPropertyGridPageState::DoSetPropertyValue( wxPGProperty* p, wxVariant& value )
1210 {
1211     if ( p )
1212     {
1213         p->SetValue(value);
1214         if ( p == m_pPropGrid->GetSelection() &&
1215              this == m_pPropGrid->GetState() )
1216             m_pPropGrid->RefreshEditor();
1217
1218         return true;
1219     }
1220     return false;
1221 }
1222
1223 // -----------------------------------------------------------------------
1224
1225 bool wxPropertyGridPageState::DoSetPropertyValueWxObjectPtr( wxPGProperty* p, wxObject* value )
1226 {
1227     if ( p )
1228     {
1229         // wnd_primary has to be given so the control can be updated as well.
1230         wxVariant v(value);
1231         DoSetPropertyValue(p, v);
1232         return true;
1233     }
1234     return false;
1235 }
1236
1237 // -----------------------------------------------------------------------
1238 // wxPropertyGridPageState property operations
1239 // -----------------------------------------------------------------------
1240
1241 bool wxPropertyGridPageState::DoIsPropertySelected( wxPGProperty* prop ) const
1242 {
1243     const wxArrayPGProperty& selection = m_selection;
1244
1245     for ( unsigned int i=0; i<selection.size(); i++ )
1246     {
1247         if ( selection[i] == prop )
1248             return true;
1249     }
1250
1251     return false;
1252 }
1253
1254 // -----------------------------------------------------------------------
1255
1256 void wxPropertyGridPageState::DoRemoveFromSelection( wxPGProperty* prop )
1257 {
1258     for ( unsigned int i=0; i<m_selection.size(); i++ )
1259     {
1260         if ( m_selection[i] == prop )
1261         {
1262             wxPropertyGrid* pg = m_pPropGrid;
1263             if ( i == 0 && pg->GetState() == this )
1264             {
1265                 // If first item (ie. one with the active editor) was
1266                 // deselected, then we need to take some extra measures.
1267                 wxArrayPGProperty sel = m_selection;
1268                 sel.erase( sel.begin() + i );
1269
1270                 wxPGProperty* newFirst;
1271                 if ( sel.size() )
1272                     newFirst = sel[0];
1273                 else
1274                     newFirst = NULL;
1275
1276                 pg->DoSelectProperty(newFirst,
1277                                      wxPG_SEL_DONT_SEND_EVENT);
1278
1279                 m_selection = sel;
1280
1281                 pg->Refresh();
1282             }
1283             else
1284             {
1285                 m_selection.erase( m_selection.begin() + i );
1286             }
1287             return;
1288         }
1289     }
1290 }
1291
1292 // -----------------------------------------------------------------------
1293
1294 bool wxPropertyGridPageState::DoCollapse( wxPGProperty* p )
1295 {
1296     wxCHECK_MSG( p, false, wxT("invalid property id") );
1297
1298     if ( !p->GetChildCount() ) return false;
1299
1300     if ( !p->IsExpanded() ) return false;
1301
1302     p->SetExpanded(false);
1303
1304     VirtualHeightChanged();
1305
1306     return true;
1307 }
1308
1309 // -----------------------------------------------------------------------
1310
1311 bool wxPropertyGridPageState::DoExpand( wxPGProperty* p )
1312 {
1313     wxCHECK_MSG( p, false, wxT("invalid property id") );
1314
1315     if ( !p->GetChildCount() ) return false;
1316
1317     if ( p->IsExpanded() ) return false;
1318
1319     p->SetExpanded(true);
1320
1321     VirtualHeightChanged();
1322
1323     return true;
1324 }
1325
1326 // -----------------------------------------------------------------------
1327
1328 bool wxPropertyGridPageState::DoSelectProperty( wxPGProperty* p, unsigned int flags )
1329 {
1330     if ( this == m_pPropGrid->GetState() )
1331         return m_pPropGrid->DoSelectProperty( p, flags );
1332
1333     DoSetSelection(p);
1334     return true;
1335 }
1336
1337 // -----------------------------------------------------------------------
1338
1339 bool wxPropertyGridPageState::DoHideProperty( wxPGProperty* p, bool hide, int flags )
1340 {
1341     if ( !hide )
1342         p->ClearFlag( wxPG_PROP_HIDDEN );
1343     else
1344         p->SetFlag( wxPG_PROP_HIDDEN );
1345
1346     if ( flags & wxPG_RECURSE )
1347     {
1348         unsigned int i;
1349         for ( i = 0; i < p->GetChildCount(); i++ )
1350             DoHideProperty(p->Item(i), hide, flags | wxPG_RECURSE_STARTS);
1351     }
1352
1353     VirtualHeightChanged();
1354
1355     return true;
1356 }
1357
1358 // -----------------------------------------------------------------------
1359
1360 bool wxPropertyGridPageState::DoEnableProperty( wxPGProperty* p, bool enable )
1361 {
1362     if ( p )
1363     {
1364         if ( enable )
1365         {
1366             if ( !(p->m_flags & wxPG_PROP_DISABLED) )
1367                 return false;
1368
1369             // Enabling
1370
1371             p->m_flags &= ~(wxPG_PROP_DISABLED);
1372         }
1373         else
1374         {
1375             if ( p->m_flags & wxPG_PROP_DISABLED )
1376                 return false;
1377
1378             // Disabling
1379
1380             p->m_flags |= wxPG_PROP_DISABLED;
1381
1382         }
1383
1384         // Apply same to sub-properties as well
1385         unsigned int i;
1386         for ( i = 0; i < p->GetChildCount(); i++ )
1387             DoEnableProperty( p->Item(i), enable );
1388
1389         return true;
1390     }
1391     return false;
1392 }
1393
1394 // -----------------------------------------------------------------------
1395 // wxPropertyGridPageState wxVariant related routines
1396 // -----------------------------------------------------------------------
1397
1398 // Returns list of wxVariant objects (non-categories and non-sub-properties only).
1399 // Never includes sub-properties (unless they are parented by wxParentProperty).
1400 wxVariant wxPropertyGridPageState::DoGetPropertyValues( const wxString& listname,
1401                                                     wxPGProperty* baseparent,
1402                                                     long flags ) const
1403 {
1404     wxPGProperty* pwc = (wxPGProperty*) baseparent;
1405
1406     // Root is the default base-parent.
1407     if ( !pwc )
1408         pwc = m_properties;
1409
1410     wxVariantList tempList;
1411     wxVariant v( tempList, listname );
1412
1413     if ( pwc->GetChildCount() )
1414     {
1415         if ( flags & wxPG_KEEP_STRUCTURE )
1416         {
1417             wxASSERT( !pwc->HasFlag(wxPG_PROP_AGGREGATE) );
1418
1419             size_t i;
1420             for ( i=0; i<pwc->GetChildCount(); i++ )
1421             {
1422                 wxPGProperty* p = pwc->Item(i);
1423                 if ( !p->GetChildCount() || p->HasFlag(wxPG_PROP_AGGREGATE) )
1424                 {
1425                     wxVariant variant = p->GetValue();
1426                     variant.SetName( p->GetBaseName() );
1427                     v.Append( variant );
1428                 }
1429                 else
1430                 {
1431                     v.Append( DoGetPropertyValues(p->m_name,p,flags|wxPG_KEEP_STRUCTURE) );
1432                 }
1433                 if ( (flags & wxPG_INC_ATTRIBUTES) && p->m_attributes.GetCount() )
1434                     v.Append( p->GetAttributesAsList() );
1435             }
1436         }
1437         else
1438         {
1439             wxPropertyGridConstIterator it( this, wxPG_ITERATE_DEFAULT, pwc->Item(0) );
1440             it.SetBaseParent( pwc );
1441
1442             for ( ; !it.AtEnd(); it.Next() )
1443             {
1444                 const wxPGProperty* p = it.GetProperty();
1445
1446                 // Use a trick to ignore wxParentProperty itself, but not its sub-properties.
1447                 if ( !p->GetChildCount() || p->HasFlag(wxPG_PROP_AGGREGATE) )
1448                 {
1449                     wxVariant variant = p->GetValue();
1450                     variant.SetName( p->GetName() );
1451                     v.Append( variant );
1452                     if ( (flags & wxPG_INC_ATTRIBUTES) && p->m_attributes.GetCount() )
1453                         v.Append( p->GetAttributesAsList() );
1454                 }
1455             }
1456         }
1457     }
1458
1459     return v;
1460 }
1461
1462 // -----------------------------------------------------------------------
1463
1464 void wxPropertyGridPageState::DoSetPropertyValues( const wxVariantList& list, wxPGProperty* defaultCategory )
1465 {
1466     unsigned char origFrozen = 1;
1467
1468     if ( m_pPropGrid->GetState() == this )
1469     {
1470         origFrozen = m_pPropGrid->m_frozen;
1471         if ( !origFrozen ) m_pPropGrid->Freeze();
1472     }
1473
1474     wxPropertyCategory* use_category = (wxPropertyCategory*)defaultCategory;
1475
1476     if ( !use_category )
1477         use_category = (wxPropertyCategory*)m_properties;
1478
1479     // Let's iterate over the list of variants.
1480     wxVariantList::const_iterator node;
1481     int numSpecialEntries = 0;
1482
1483     //
1484     // Second pass for special entries
1485     for ( node = list.begin(); node != list.end(); ++node )
1486     {
1487         wxVariant *current = (wxVariant*)*node;
1488
1489         // Make sure it is wxVariant.
1490         wxASSERT( current );
1491         wxASSERT( wxStrcmp(current->GetClassInfo()->GetClassName(),wxT("wxVariant")) == 0 );
1492
1493         const wxString& name = current->GetName();
1494         if ( name.length() > 0 )
1495         {
1496             //
1497             // '@' signified a special entry
1498             if ( name[0] == wxS('@') )
1499             {
1500                 numSpecialEntries++;
1501             }
1502             else
1503             {
1504                 wxPGProperty* foundProp = BaseGetPropertyByName(name);
1505                 if ( foundProp )
1506                 {
1507                     wxPGProperty* p = foundProp;
1508
1509                     // If it was a list, we still have to go through it.
1510                     if ( wxStrcmp(current->GetType(), wxS("list")) == 0 )
1511                     {
1512                         DoSetPropertyValues( current->GetList(),
1513                                 p->IsCategory()?p:(NULL)
1514                             );
1515                     }
1516                     else
1517                     {
1518                         wxASSERT_LEVEL_2_MSG(
1519                             wxStrcmp(current->GetType(), p->GetValue().GetType()) == 0,
1520                             wxString::Format(
1521                                 wxS("setting value of property \"%s\" from variant"),
1522                                 p->GetName().c_str())
1523                         );
1524
1525                         p->SetValue(*current);
1526                     }
1527                 }
1528                 else
1529                 {
1530                     // Is it list?
1531                     if ( current->GetType() != wxS("list") )
1532                     {
1533                         // Not.
1534                     }
1535                     else
1536                     {
1537                         // Yes, it is; create a sub category and append contents there.
1538                         wxPGProperty* newCat = DoInsert(use_category,-1,new wxPropertyCategory(current->GetName(),wxPG_LABEL));
1539                         DoSetPropertyValues( current->GetList(), newCat );
1540                     }
1541                 }
1542             }
1543         }
1544     }
1545
1546     if ( numSpecialEntries )
1547     {
1548         for ( node = list.begin(); node != list.end(); ++node )
1549         {
1550             wxVariant *current = (wxVariant*)*node;
1551
1552             const wxString& name = current->GetName();
1553             if ( name.length() > 0 )
1554             {
1555                 //
1556                 // '@' signified a special entry
1557                 if ( name[0] == wxS('@') )
1558                 {
1559                     numSpecialEntries--;
1560
1561                     size_t pos2 = name.rfind(wxS('@'));
1562                     if ( pos2 > 0 && pos2 < (name.size()-1) )
1563                     {
1564                         wxString propName = name.substr(1, pos2-1);
1565                         wxString entryType = name.substr(pos2+1, wxString::npos);
1566
1567                         if ( entryType == wxS("attr") )
1568                         {
1569                             //
1570                             // List of attributes
1571                             wxPGProperty* foundProp = BaseGetPropertyByName(propName);
1572                             if ( foundProp )
1573                             {
1574                                 wxASSERT( current->GetType() == wxPG_VARIANT_TYPE_LIST );
1575
1576                                 wxVariantList& list2 = current->GetList();
1577                                 wxVariantList::const_iterator node2;
1578
1579                                 for ( node2 = list2.begin(); node2 != list2.end(); ++node2 )
1580                                 {
1581                                     wxVariant *attr = (wxVariant*)*node2;
1582                                     foundProp->SetAttribute( attr->GetName(), *attr );
1583                                 }
1584                             }
1585                             else
1586                             {
1587                                 // ERROR: No such property: 'propName'
1588                             }
1589                         }
1590                     }
1591                     else
1592                     {
1593                         // ERROR: Special entry requires name of format @<propname>@<entrytype>
1594                     }
1595                 }
1596             }
1597
1598             if ( !numSpecialEntries )
1599                 break;
1600         }
1601     }
1602
1603     if ( !origFrozen )
1604     {
1605         m_pPropGrid->Thaw();
1606
1607         if ( this == m_pPropGrid->GetState() )
1608             m_pPropGrid->RefreshEditor();
1609     }
1610
1611 }
1612
1613 // -----------------------------------------------------------------------
1614 // wxPropertyGridPageState property adding and removal
1615 // -----------------------------------------------------------------------
1616
1617 bool wxPropertyGridPageState::PrepareToAddItem( wxPGProperty* property,
1618                                                 wxPGProperty* scheduledParent )
1619 {
1620     wxPropertyGrid* propGrid = m_pPropGrid;
1621
1622     // This will allow better behavior.
1623     if ( scheduledParent == m_properties )
1624         scheduledParent = NULL;
1625
1626     if ( scheduledParent && !scheduledParent->IsCategory() )
1627     {
1628         wxASSERT_MSG( property->GetBaseName().length(),
1629                       "Property's children must have unique, non-empty names within their scope" );
1630     }
1631
1632     property->m_parentState = this;
1633
1634     if ( property->IsCategory() )
1635     {
1636
1637         // Parent of a category must be either root or another category
1638         // (otherwise Bad Things might happen).
1639         wxASSERT_MSG( scheduledParent == NULL ||
1640                       scheduledParent == m_properties ||
1641                       scheduledParent->IsCategory(),
1642                  wxT("Parent of a category must be either root or another category."));
1643
1644         // If we already have category with same name, delete given property
1645         // and use it instead as most recent caption item.
1646         wxPGProperty* found_id = BaseGetPropertyByName( property->GetBaseName() );
1647         if ( found_id )
1648         {
1649             wxPropertyCategory* pwc = (wxPropertyCategory*) found_id;
1650             if ( pwc->IsCategory() ) // Must be a category.
1651             {
1652                 delete property;
1653                 m_currentCategory = pwc;
1654                 return false;
1655             }
1656         }
1657     }
1658
1659 #if wxDEBUG_LEVEL
1660     // Warn for identical names in debug mode.
1661     if ( BaseGetPropertyByName(property->GetName()) &&
1662          (!scheduledParent || scheduledParent->IsCategory()) )
1663     {
1664         wxFAIL_MSG(wxString::Format(
1665             "wxPropertyGrid item with name \"%s\" already exists",
1666             property->GetName()));
1667
1668         wxPGGlobalVars->m_warnings++;
1669     }
1670 #endif // wxDEBUG_LEVEL
1671
1672     // Make sure nothing is selected.
1673     if ( propGrid )
1674         propGrid->ClearSelection(false);
1675
1676     // NULL parent == root parent
1677     if ( !scheduledParent )
1678         scheduledParent = DoGetRoot();
1679
1680     property->m_parent = scheduledParent;
1681
1682     property->InitAfterAdded(this, propGrid);
1683
1684     if ( property->IsCategory() )
1685     {
1686         wxPropertyCategory* pc = wxStaticCast(property, wxPropertyCategory);
1687
1688         m_currentCategory = pc;
1689
1690         // Calculate text extent for category caption
1691         if ( propGrid )
1692             pc->CalculateTextExtent(propGrid, propGrid->GetCaptionFont());
1693     }
1694
1695     return true;
1696 }
1697
1698 // -----------------------------------------------------------------------
1699
1700 wxPGProperty* wxPropertyGridPageState::DoAppend( wxPGProperty* property )
1701 {
1702     wxPropertyCategory* cur_cat = m_currentCategory;
1703     if ( property->IsCategory() )
1704         cur_cat = NULL;
1705
1706     return DoInsert( cur_cat, -1, property );
1707 }
1708
1709 // -----------------------------------------------------------------------
1710
1711 wxPGProperty* wxPropertyGridPageState::DoInsert( wxPGProperty* parent, int index, wxPGProperty* property )
1712 {
1713     if ( !parent )
1714         parent = m_properties;
1715
1716     wxCHECK_MSG( !parent->HasFlag(wxPG_PROP_AGGREGATE),
1717                  wxNullProperty,
1718                  wxT("when adding properties to fixed parents, use BeginAddChildren and EndAddChildren.") );
1719
1720     bool res = PrepareToAddItem( property, (wxPropertyCategory*)parent );
1721
1722     // PrepareToAddItem() may just decide to use use current category
1723     // instead of adding new one.
1724     if ( !res )
1725         return m_currentCategory;
1726
1727     bool parentIsRoot = parent->IsRoot();
1728     bool parentIsCategory = parent->IsCategory();
1729
1730     // Note that item must be added into current mode later.
1731
1732     // If parent is wxParentProperty, just stick it in...
1733     // If parent is root (m_properties), then...
1734     //   In categoric mode: Add as last item in m_abcArray (if not category).
1735     //                      Add to given index in m_regularArray.
1736     //   In non-cat mode:   Add as last item in m_regularArray.
1737     //                      Add to given index in m_abcArray.
1738     // If parent is category, then...
1739     //   1) Add to given category in given index.
1740     //   2) Add as last item in m_abcArray.
1741
1742     if ( m_properties == &m_regularArray )
1743     {
1744         // We are currently in Categorized mode
1745
1746         // Only add non-categories to m_abcArray.
1747         if ( m_abcArray && !property->IsCategory() &&
1748              (parentIsCategory || parentIsRoot) )
1749         {
1750             m_abcArray->DoAddChild( property, -1, false );
1751         }
1752
1753         // Add to current mode.
1754         parent->DoAddChild( property, index, true );
1755     }
1756     else
1757     {
1758         // We are currently in Non-categorized/Alphabetic mode
1759
1760         if ( parentIsCategory )
1761             // Parent is category.
1762             parent->DoAddChild( property, index, false );
1763         else if ( parentIsRoot )
1764             // Parent is root.
1765             m_regularArray.DoAddChild( property, -1, false );
1766
1767         // Add to current mode
1768         if ( !property->IsCategory() )
1769             m_abcArray->DoAddChild( property, index, true );
1770     }
1771
1772     // category stuff
1773     if ( property->IsCategory() )
1774     {
1775         // This is a category caption item.
1776
1777         // Last caption is not the bottom one (this info required by append)
1778         m_lastCaptionBottomnest = 0;
1779     }
1780
1781     // Only add name to hashmap if parent is root or category
1782     if ( property->m_name.length() &&
1783         (parentIsCategory || parentIsRoot) )
1784         m_dictName[property->m_name] = (void*) property;
1785
1786     VirtualHeightChanged();
1787
1788     property->UpdateParentValues();
1789
1790     m_itemsAdded = 1;
1791
1792     return property;
1793 }
1794
1795 // -----------------------------------------------------------------------
1796
1797 void wxPropertyGridPageState::DoDelete( wxPGProperty* item, bool doDelete )
1798 {
1799     wxCHECK_RET( item->GetParent(),
1800         wxT("this property was already deleted") );
1801
1802     wxCHECK_RET( item != &m_regularArray && item != m_abcArray,
1803         wxT("wxPropertyGrid: Do not attempt to remove the root item.") );
1804
1805     unsigned int indinparent = item->GetIndexInParent();
1806
1807     wxPGProperty* pwc = (wxPGProperty*)item;
1808     wxPGProperty* parent = item->GetParent();
1809
1810     wxCHECK_RET( !parent->HasFlag(wxPG_PROP_AGGREGATE),
1811         wxT("wxPropertyGrid: Do not attempt to remove sub-properties.") );
1812
1813     wxASSERT( item->GetParentState() == this );
1814
1815     wxPropertyGrid* pg = GetGrid();
1816
1817     if ( DoIsPropertySelected(item) )
1818     {
1819         if ( pg && pg->GetState() == this )
1820         {
1821             pg->DoRemoveFromSelection(item,
1822                 wxPG_SEL_DELETING|wxPG_SEL_NOVALIDATE);
1823         }
1824         else
1825         {
1826             DoRemoveFromSelection(item);
1827         }
1828     }
1829
1830     item->SetFlag(wxPG_PROP_BEING_DELETED);
1831
1832     // Delete children
1833     if ( item->GetChildCount() && !item->HasFlag(wxPG_PROP_AGGREGATE) )
1834     {
1835         // deleting a category
1836         if ( item->IsCategory() )
1837         {
1838             if ( pwc == m_currentCategory )
1839                 m_currentCategory = NULL;
1840         }
1841
1842         item->DeleteChildren();
1843     }
1844
1845     if ( !IsInNonCatMode() )
1846     {
1847         // categorized mode - non-categorized array
1848
1849         // Remove from non-cat array
1850         if ( !item->IsCategory() &&
1851              (parent->IsCategory() || parent->IsRoot()) )
1852         {
1853             if ( m_abcArray )
1854                 m_abcArray->RemoveChild(item);
1855         }
1856
1857         // categorized mode - categorized array
1858         wxArrayPGProperty& parentsChildren = parent->m_children;
1859         parentsChildren.erase( parentsChildren.begin() + indinparent );
1860         item->m_parent->FixIndicesOfChildren();
1861     }
1862     else
1863     {
1864         // non-categorized mode - categorized array
1865
1866         // We need to find location of item.
1867         wxPGProperty* cat_parent = &m_regularArray;
1868         int cat_index = m_regularArray.GetChildCount();
1869         size_t i;
1870         for ( i = 0; i < m_regularArray.GetChildCount(); i++ )
1871         {
1872             wxPGProperty* p = m_regularArray.Item(i);
1873             if ( p == item ) { cat_index = i; break; }
1874             if ( p->IsCategory() )
1875             {
1876                 int subind = ((wxPGProperty*)p)->Index(item);
1877                 if ( subind != wxNOT_FOUND )
1878                 {
1879                     cat_parent = ((wxPGProperty*)p);
1880                     cat_index = subind;
1881                     break;
1882                 }
1883             }
1884         }
1885         cat_parent->m_children.erase(cat_parent->m_children.begin()+cat_index);
1886
1887         // non-categorized mode - non-categorized array
1888         if ( !item->IsCategory() )
1889         {
1890             wxASSERT( item->m_parent == m_abcArray );
1891             wxArrayPGProperty& parentsChildren = item->m_parent->m_children;
1892             parentsChildren.erase(parentsChildren.begin() + indinparent);
1893             item->m_parent->FixIndicesOfChildren(indinparent);
1894         }
1895     }
1896
1897     if ( item->GetBaseName().length() &&
1898          (parent->IsCategory() || parent->IsRoot()) )
1899         m_dictName.erase(item->GetBaseName());
1900
1901     // We need to clear parent grid's m_propHover, if it matches item
1902     if ( pg && pg->m_propHover == item )
1903         pg->m_propHover = NULL;
1904
1905     // We can actually delete it now
1906     if ( doDelete )
1907         delete item;
1908
1909     m_itemsAdded = 1; // Not a logical assignment (but required nonetheless).
1910
1911     VirtualHeightChanged();
1912 }
1913
1914 // -----------------------------------------------------------------------
1915
1916 #endif  // wxUSE_PROPGRID