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