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