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