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