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