]> git.saurik.com Git - wxWidgets.git/blob - src/propgrid/propgridiface.cpp
Remove all lines containing cvs/svn "$Id$" keyword.
[wxWidgets.git] / src / propgrid / propgridiface.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/propgrid/propgridiface.cpp
3 // Purpose: wxPropertyGridInterface class
4 // Author: Jaakko Salli
5 // Modified by:
6 // Created: 2008-08-24
7 // Copyright: (c) Jaakko Salli
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 // For compilers that support precompilation, includes "wx/wx.h".
12 #include "wx/wxprec.h"
13
14 #ifdef __BORLANDC__
15 #pragma hdrstop
16 #endif
17
18 #if wxUSE_PROPGRID
19
20 #ifndef WX_PRECOMP
21 #include "wx/defs.h"
22 #include "wx/object.h"
23 #include "wx/hash.h"
24 #include "wx/string.h"
25 #include "wx/log.h"
26 #include "wx/event.h"
27 #include "wx/window.h"
28 #include "wx/panel.h"
29 #include "wx/dc.h"
30 #include "wx/dcmemory.h"
31 #include "wx/button.h"
32 #include "wx/pen.h"
33 #include "wx/brush.h"
34 #include "wx/settings.h"
35 #include "wx/sizer.h"
36 #include "wx/intl.h"
37 #endif
38
39 #include "wx/propgrid/property.h"
40 #include "wx/propgrid/propgrid.h"
41
42
43 const wxChar *wxPGTypeName_long = wxT("long");
44 const wxChar *wxPGTypeName_bool = wxT("bool");
45 const wxChar *wxPGTypeName_double = wxT("double");
46 const wxChar *wxPGTypeName_wxString = wxT("string");
47 const wxChar *wxPGTypeName_void = wxT("void*");
48 const wxChar *wxPGTypeName_wxArrayString = wxT("arrstring");
49
50
51 // ----------------------------------------------------------------------------
52 // VariantDatas
53 // ----------------------------------------------------------------------------
54
55 WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED(wxPoint, WXDLLIMPEXP_PROPGRID)
56 WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED(wxSize, WXDLLIMPEXP_PROPGRID)
57 WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED_DUMMY_EQ(wxArrayInt, WXDLLIMPEXP_PROPGRID)
58 IMPLEMENT_VARIANT_OBJECT_EXPORTED(wxFont, WXDLLIMPEXP_PROPGRID)
59
60 // -----------------------------------------------------------------------
61 // wxPGPropArgCls
62 // -----------------------------------------------------------------------
63
64 wxPGProperty* wxPGPropArgCls::GetPtr( wxPropertyGridInterface* iface ) const
65 {
66 if ( m_flags == IsProperty )
67 {
68 wxASSERT_MSG( m_ptr.property, wxT("invalid property ptr") );
69 return m_ptr.property;
70 }
71 else if ( m_flags & IsWxString )
72 return iface->GetPropertyByNameA(*m_ptr.stringName);
73 else if ( m_flags & IsCharPtr )
74 return iface->GetPropertyByNameA(m_ptr.charName);
75 else if ( m_flags & IsWCharPtr )
76 return iface->GetPropertyByNameA(m_ptr.wcharName);
77
78 return NULL;
79 }
80
81 // -----------------------------------------------------------------------
82 // wxPropertyGridInterface
83 // -----------------------------------------------------------------------
84
85 void wxPropertyGridInterface::RefreshGrid( wxPropertyGridPageState* state )
86 {
87 if ( !state )
88 state = m_pState;
89
90 wxPropertyGrid* grid = state->GetGrid();
91 if ( grid->GetState() == state && !grid->IsFrozen() )
92 {
93 grid->Refresh();
94 }
95 }
96
97 // -----------------------------------------------------------------------
98
99 wxPGProperty* wxPropertyGridInterface::Append( wxPGProperty* property )
100 {
101 wxPGProperty* retp = m_pState->DoAppend(property);
102
103 wxPropertyGrid* grid = m_pState->GetGrid();
104 if ( grid )
105 grid->RefreshGrid();
106
107 return retp;
108 }
109
110 // -----------------------------------------------------------------------
111
112 wxPGProperty* wxPropertyGridInterface::AppendIn( wxPGPropArg id, wxPGProperty* newproperty )
113 {
114 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
115 wxPGProperty* pwc = (wxPGProperty*) p;
116 wxPGProperty* retp = m_pState->DoInsert(pwc, pwc->GetChildCount(), newproperty);
117 return retp;
118 }
119
120 // -----------------------------------------------------------------------
121
122 wxPGProperty* wxPropertyGridInterface::Insert( wxPGPropArg id, wxPGProperty* property )
123 {
124 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
125 wxPGProperty* retp = m_pState->DoInsert(p->GetParent(), p->GetIndexInParent(), property);
126 RefreshGrid();
127 return retp;
128 }
129
130 // -----------------------------------------------------------------------
131
132 wxPGProperty* wxPropertyGridInterface::Insert( wxPGPropArg id, int index, wxPGProperty* newproperty )
133 {
134 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
135 wxPGProperty* retp = m_pState->DoInsert((wxPGProperty*)p,index,newproperty);
136 RefreshGrid();
137 return retp;
138 }
139
140 // -----------------------------------------------------------------------
141
142 void wxPropertyGridInterface::DeleteProperty( wxPGPropArg id )
143 {
144 wxPG_PROP_ARG_CALL_PROLOG()
145
146 wxPropertyGridPageState* state = p->GetParentState();
147
148 state->DoDelete( p, true );
149
150 RefreshGrid(state);
151 }
152
153 // -----------------------------------------------------------------------
154
155 wxPGProperty* wxPropertyGridInterface::RemoveProperty( wxPGPropArg id )
156 {
157 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
158
159 wxCHECK( !p->GetChildCount() || p->HasFlag(wxPG_PROP_AGGREGATE),
160 wxNullProperty);
161
162 wxPropertyGridPageState* state = p->GetParentState();
163
164 state->DoDelete( p, false );
165
166 RefreshGrid(state);
167
168 return p;
169 }
170
171 // -----------------------------------------------------------------------
172
173 wxPGProperty* wxPropertyGridInterface::ReplaceProperty( wxPGPropArg id, wxPGProperty* property )
174 {
175 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
176
177 wxPGProperty* replaced = p;
178 wxCHECK_MSG( replaced && property,
179 wxNullProperty,
180 wxT("NULL property") );
181 wxCHECK_MSG( !replaced->IsCategory(),
182 wxNullProperty,
183 wxT("cannot replace this type of property") );
184 wxCHECK_MSG( !m_pState->IsInNonCatMode(),
185 wxNullProperty,
186 wxT("cannot replace properties in alphabetic mode") );
187
188 // Get address to the slot
189 wxPGProperty* parent = replaced->GetParent();
190 int ind = replaced->GetIndexInParent();
191
192 wxPropertyGridPageState* state = replaced->GetParentState();
193 DeleteProperty(replaced); // Must use generic Delete
194 state->DoInsert(parent,ind,property);
195
196 return property;
197 }
198
199 // -----------------------------------------------------------------------
200 // wxPropertyGridInterface property operations
201 // -----------------------------------------------------------------------
202
203 wxPGProperty* wxPropertyGridInterface::GetSelection() const
204 {
205 return m_pState->GetSelection();
206 }
207
208 // -----------------------------------------------------------------------
209
210 bool wxPropertyGridInterface::ClearSelection( bool validation )
211 {
212 bool res = DoClearSelection(validation, wxPG_SEL_DONT_SEND_EVENT);
213 wxPropertyGrid* pg = GetPropertyGrid();
214 if ( pg )
215 pg->Refresh();
216 return res;
217 }
218
219 // -----------------------------------------------------------------------
220
221 bool wxPropertyGridInterface::DoClearSelection( bool validation,
222 int selFlags )
223 {
224 if ( !validation )
225 selFlags |= wxPG_SEL_NOVALIDATE;
226
227 wxPropertyGridPageState* state = m_pState;
228
229 if ( state )
230 {
231 wxPropertyGrid* pg = state->GetGrid();
232 if ( pg->GetState() == state )
233 return pg->DoSelectProperty(NULL, selFlags);
234 else
235 state->DoSetSelection(NULL);
236 }
237
238 return true;
239 }
240
241 // -----------------------------------------------------------------------
242
243 void wxPropertyGridInterface::LimitPropertyEditing( wxPGPropArg id, bool limit )
244 {
245 wxPG_PROP_ARG_CALL_PROLOG()
246
247 m_pState->DoLimitPropertyEditing(p, limit);
248 RefreshProperty(p);
249 }
250
251 // -----------------------------------------------------------------------
252
253 bool wxPropertyGridInterface::EnableProperty( wxPGPropArg id, bool enable )
254 {
255 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
256
257 wxPropertyGridPageState* state = p->GetParentState();
258 wxPropertyGrid* grid = state->GetGrid();
259
260 if ( enable )
261 {
262 if ( !(p->m_flags & wxPG_PROP_DISABLED) )
263 return false;
264
265 // If active, Set active Editor.
266 if ( grid && grid->GetState() == state && p == grid->GetSelection() )
267 grid->DoSelectProperty( p, wxPG_SEL_FORCE );
268 }
269 else
270 {
271 if ( p->m_flags & wxPG_PROP_DISABLED )
272 return false;
273
274 // If active, Disable as active Editor.
275 if ( grid && grid->GetState() == state && p == grid->GetSelection() )
276 grid->DoSelectProperty( p, wxPG_SEL_FORCE );
277 }
278
279 p->DoEnable(enable);
280
281 RefreshProperty( p );
282
283 return true;
284 }
285
286 // -----------------------------------------------------------------------
287
288 bool wxPropertyGridInterface::ExpandAll( bool doExpand )
289 {
290 wxPropertyGridPageState* state = m_pState;
291
292 if ( !state->DoGetRoot()->GetChildCount() )
293 return true;
294
295 wxPropertyGrid* pg = state->GetGrid();
296
297 if ( GetSelection() && GetSelection() != state->DoGetRoot() &&
298 !doExpand )
299 {
300 pg->DoClearSelection();
301 }
302
303 wxPGVIterator it;
304
305 for ( it = GetVIterator( wxPG_ITERATE_ALL ); !it.AtEnd(); it.Next() )
306 {
307 wxPGProperty* p = (wxPGProperty*) it.GetProperty();
308 if ( p->GetChildCount() )
309 {
310 if ( doExpand )
311 {
312 if ( !p->IsExpanded() )
313 {
314 state->DoExpand(p);
315 }
316 }
317 else
318 {
319 if ( p->IsExpanded() )
320 {
321 state->DoCollapse(p);
322 }
323 }
324 }
325 }
326
327 pg->RecalculateVirtualSize();
328
329 RefreshGrid();
330
331 return true;
332 }
333
334 // -----------------------------------------------------------------------
335
336 void wxPropertyGridInterface::ClearModifiedStatus()
337 {
338 unsigned int pageIndex = 0;
339
340 for (;;)
341 {
342 wxPropertyGridPageState* page = GetPageState(pageIndex);
343 if ( !page ) break;
344
345 page->DoGetRoot()->SetFlagRecursively(wxPG_PROP_MODIFIED, false);
346 page->m_anyModified = false;
347
348 pageIndex++;
349 }
350
351 // Update active editor control, if any
352 GetPropertyGrid()->RefreshEditor();
353 }
354
355 bool wxPropertyGridInterface::SetColumnProportion( unsigned int column,
356 int proportion )
357 {
358 wxCHECK(m_pState, false);
359 wxPropertyGrid* pg = m_pState->GetGrid();
360 wxCHECK(pg, false);
361 wxCHECK(pg->HasFlag(wxPG_SPLITTER_AUTO_CENTER), false);
362 m_pState->DoSetColumnProportion(column, proportion);
363 return true;
364 }
365
366 // -----------------------------------------------------------------------
367 // wxPropertyGridInterface property value setting and getting
368 // -----------------------------------------------------------------------
369
370 void wxPGGetFailed( const wxPGProperty* p, const wxString& typestr )
371 {
372 wxPGTypeOperationFailed(p, typestr, wxS("Get"));
373 }
374
375 // -----------------------------------------------------------------------
376
377 void wxPGTypeOperationFailed( const wxPGProperty* p,
378 const wxString& typestr,
379 const wxString& op )
380 {
381 wxASSERT( p != NULL );
382 wxLogError( _("Type operation \"%s\" failed: Property labeled \"%s\" is of type \"%s\", NOT \"%s\"."),
383 op.c_str(), p->GetLabel().c_str(), p->GetValue().GetType().c_str(), typestr.c_str() );
384 }
385
386 // -----------------------------------------------------------------------
387
388 void wxPropertyGridInterface::SetPropVal( wxPGPropArg id, wxVariant& value )
389 {
390 wxPG_PROP_ARG_CALL_PROLOG()
391
392 if ( p )
393 p->SetValue(value);
394 }
395
396 // -----------------------------------------------------------------------
397
398 void wxPropertyGridInterface::SetPropertyValueString( wxPGPropArg id, const wxString& value )
399 {
400 wxPG_PROP_ARG_CALL_PROLOG()
401
402 if ( p )
403 m_pState->DoSetPropertyValueString(p, value);
404 }
405
406 // -----------------------------------------------------------------------
407
408 void wxPropertyGridInterface::SetValidationFailureBehavior( int vfbFlags )
409 {
410 GetPropertyGrid()->m_permanentValidationFailureBehavior = vfbFlags;
411 }
412
413 // -----------------------------------------------------------------------
414
415 wxPGProperty* wxPropertyGridInterface::GetPropertyByNameA( const wxString& name ) const
416 {
417 wxPGProperty* p = GetPropertyByName(name);
418 wxASSERT_MSG(p,wxString::Format(wxT("no property with name '%s'"),name.c_str()));
419 return p;
420 }
421
422 // ----------------------------------------------------------------------------
423
424 wxPGProperty* wxPropertyGridInterface::GetPropertyByLabel( const wxString& label ) const
425 {
426 wxPGVIterator it;
427
428 for ( it = GetVIterator( wxPG_ITERATE_PROPERTIES ); !it.AtEnd(); it.Next() )
429 {
430 if ( it.GetProperty()->GetLabel() == label )
431 return it.GetProperty();
432 }
433
434 return wxNullProperty;
435 }
436
437 // ----------------------------------------------------------------------------
438
439 void wxPropertyGridInterface::DoSetPropertyAttribute( wxPGPropArg id, const wxString& name,
440 wxVariant& value, long argFlags )
441 {
442 wxPG_PROP_ARG_CALL_PROLOG()
443
444 p->SetAttribute( name, value );
445
446 if ( argFlags & wxPG_RECURSE )
447 {
448 unsigned int i;
449 for ( i = 0; i < p->GetChildCount(); i++ )
450 DoSetPropertyAttribute(p->Item(i), name, value, argFlags);
451 }
452 }
453
454 // -----------------------------------------------------------------------
455
456 void wxPropertyGridInterface::SetPropertyAttributeAll( const wxString& attrName,
457 wxVariant value )
458 {
459 unsigned int pageIndex = 0;
460
461 for (;;)
462 {
463 wxPropertyGridPageState* page = GetPageState(pageIndex);
464 if ( !page ) break;
465
466 DoSetPropertyAttribute(page->DoGetRoot(), attrName, value, wxPG_RECURSE);
467
468 pageIndex++;
469 }
470 }
471
472 // -----------------------------------------------------------------------
473
474 void wxPropertyGridInterface::GetPropertiesWithFlag( wxArrayPGProperty* targetArr,
475 wxPGProperty::FlagType flags,
476 bool inverse,
477 int iterFlags ) const
478 {
479 wxASSERT( targetArr );
480 wxPGVIterator it = GetVIterator( iterFlags );
481
482 for ( ;
483 !it.AtEnd();
484 it.Next() )
485 {
486 const wxPGProperty* property = it.GetProperty();
487
488 if ( !inverse )
489 {
490 if ( (property->GetFlags() & flags) == flags )
491 targetArr->push_back((wxPGProperty*)property);
492 }
493 else
494 {
495 if ( (property->GetFlags() & flags) != flags )
496 targetArr->push_back((wxPGProperty*)property);
497 }
498 }
499 }
500
501 // -----------------------------------------------------------------------
502
503 void wxPropertyGridInterface::SetBoolChoices( const wxString& trueChoice,
504 const wxString& falseChoice )
505 {
506 wxPGGlobalVars->m_boolChoices[0] = falseChoice;
507 wxPGGlobalVars->m_boolChoices[1] = trueChoice;
508 }
509
510 // -----------------------------------------------------------------------
511
512 wxPGProperty* wxPropertyGridInterface::DoGetPropertyByName( const wxString& name ) const
513 {
514 return m_pState->BaseGetPropertyByName(name);
515 }
516
517 // -----------------------------------------------------------------------
518
519 wxPGProperty* wxPropertyGridInterface::GetPropertyByName( const wxString& name,
520 const wxString& subname ) const
521 {
522 wxPGProperty* p = DoGetPropertyByName(name);
523 if ( !p || !p->GetChildCount() )
524 return wxNullProperty;
525
526 return p->GetPropertyByName(subname);
527 }
528
529 // -----------------------------------------------------------------------
530
531 // Since GetPropertyByName is used *a lot*, this makes sense
532 // since non-virtual method can be called with less code.
533 wxPGProperty* wxPropertyGridInterface::GetPropertyByName( const wxString& name ) const
534 {
535 wxPGProperty* p = DoGetPropertyByName(name);
536 if ( p )
537 return p;
538
539 // Check if its "Property.SubProperty" format
540 int pos = name.Find(wxT('.'));
541 if ( pos <= 0 )
542 return NULL;
543
544 return GetPropertyByName(name.substr(0,pos),
545 name.substr(pos+1,name.length()-pos-1));
546 }
547
548 // -----------------------------------------------------------------------
549
550 bool wxPropertyGridInterface::HideProperty( wxPGPropArg id, bool hide, int flags )
551 {
552 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
553
554 wxPropertyGrid* pg = m_pState->GetGrid();
555
556 if ( pg == p->GetGrid() )
557 return pg->DoHideProperty(p, hide, flags);
558 else
559 m_pState->DoHideProperty(p, hide, flags);
560
561 return true;
562 }
563
564 // -----------------------------------------------------------------------
565
566 bool wxPropertyGridInterface::Collapse( wxPGPropArg id )
567 {
568 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
569 wxPropertyGrid* pg = p->GetGridIfDisplayed();
570 if ( pg )
571 return pg->DoCollapse(p);
572
573 return p->GetParentState()->DoCollapse(p);
574 }
575
576 // -----------------------------------------------------------------------
577
578 bool wxPropertyGridInterface::Expand( wxPGPropArg id )
579 {
580 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
581 wxPropertyGrid* pg = p->GetGridIfDisplayed();
582 if ( pg )
583 return pg->DoExpand(p);
584
585 return p->GetParentState()->DoExpand(p);
586 }
587
588 // -----------------------------------------------------------------------
589
590 void wxPropertyGridInterface::Sort( int flags )
591 {
592 wxPropertyGrid* pg = GetPropertyGrid();
593
594 unsigned int pageIndex = 0;
595
596 for (;;)
597 {
598 wxPropertyGridPageState* page = GetPageState(pageIndex);
599 if ( !page ) break;
600 page->DoSort(flags);
601 pageIndex++;
602 }
603
604 // Fix positions of any open editor controls
605 if ( pg )
606 pg->CorrectEditorWidgetPosY();
607 }
608
609 // -----------------------------------------------------------------------
610
611 void wxPropertyGridInterface::SetPropertyLabel( wxPGPropArg id, const wxString& newproplabel )
612 {
613 wxPG_PROP_ARG_CALL_PROLOG()
614
615 p->SetLabel( newproplabel );
616
617 wxPropertyGridPageState* state = p->GetParentState();
618 wxPropertyGrid* pg = state->GetGrid();
619
620 if ( pg->HasFlag(wxPG_AUTO_SORT) )
621 pg->SortChildren(p->GetParent());
622
623 if ( pg->GetState() == state )
624 {
625 if ( pg->HasFlag(wxPG_AUTO_SORT) )
626 pg->Refresh();
627 else
628 pg->DrawItem( p );
629 }
630 }
631
632 // -----------------------------------------------------------------------
633
634 bool wxPropertyGridInterface::SetPropertyMaxLength( wxPGPropArg id, int maxLen )
635 {
636 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
637
638 wxPropertyGrid* pg = m_pState->GetGrid();
639
640 p->m_maxLen = (short) maxLen;
641
642 // Adjust control if selected currently
643 if ( pg == p->GetGrid() && p == m_pState->GetSelection() )
644 {
645 wxWindow* wnd = pg->GetEditorControl();
646 wxTextCtrl* tc = wxDynamicCast(wnd,wxTextCtrl);
647 if ( tc )
648 tc->SetMaxLength( maxLen );
649 else
650 // Not a text ctrl
651 return false;
652 }
653
654 return true;
655 }
656
657 // -----------------------------------------------------------------------
658
659 void
660 wxPropertyGridInterface::SetPropertyBackgroundColour( wxPGPropArg id,
661 const wxColour& colour,
662 int flags )
663 {
664 wxPG_PROP_ARG_CALL_PROLOG()
665 p->SetBackgroundColour(colour, flags);
666 RefreshProperty(p);
667 }
668
669 // -----------------------------------------------------------------------
670
671 void wxPropertyGridInterface::SetPropertyTextColour( wxPGPropArg id,
672 const wxColour& colour,
673 int flags )
674 {
675 wxPG_PROP_ARG_CALL_PROLOG()
676 p->SetTextColour(colour, flags);
677 RefreshProperty(p);
678 }
679
680 // -----------------------------------------------------------------------
681
682 void wxPropertyGridInterface::SetPropertyColoursToDefault( wxPGPropArg id )
683 {
684 wxPG_PROP_ARG_CALL_PROLOG()
685
686 p->m_cells.clear();
687 }
688
689 // -----------------------------------------------------------------------
690
691 void wxPropertyGridInterface::SetPropertyCell( wxPGPropArg id,
692 int column,
693 const wxString& text,
694 const wxBitmap& bitmap,
695 const wxColour& fgCol,
696 const wxColour& bgCol )
697 {
698 wxPG_PROP_ARG_CALL_PROLOG()
699
700 wxPGCell& cell = p->GetCell(column);
701 if ( !text.empty() && text != wxPG_LABEL )
702 cell.SetText(text);
703 if ( bitmap.IsOk() )
704 cell.SetBitmap(bitmap);
705 if ( fgCol != wxNullColour )
706 cell.SetFgCol(fgCol);
707 if ( bgCol != wxNullColour )
708 cell.SetBgCol(bgCol);
709 }
710
711 // -----------------------------------------------------------------------
712 // GetPropertyValueAsXXX methods
713
714 #define IMPLEMENT_GET_VALUE(T,TRET,BIGNAME,DEFRETVAL) \
715 TRET wxPropertyGridInterface::GetPropertyValueAs##BIGNAME( wxPGPropArg id ) const \
716 { \
717 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFRETVAL) \
718 wxVariant value = p->GetValue(); \
719 if ( wxStrcmp(value.GetType(), wxPGTypeName_##T) != 0 ) \
720 { \
721 wxPGGetFailed(p,wxPGTypeName_##T); \
722 return (TRET)DEFRETVAL; \
723 } \
724 return (TRET)value.Get##BIGNAME(); \
725 }
726
727 // String is different than others.
728 wxString wxPropertyGridInterface::GetPropertyValueAsString( wxPGPropArg id ) const
729 {
730 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxEmptyString)
731 return p->GetValueAsString(wxPG_FULL_VALUE);
732 }
733
734 bool wxPropertyGridInterface::GetPropertyValueAsBool( wxPGPropArg id ) const
735 {
736 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
737 wxVariant value = p->GetValue();
738 if ( wxStrcmp(value.GetType(), wxPGTypeName_bool) == 0 )
739 {
740 return value.GetBool();
741 }
742 if ( wxStrcmp(value.GetType(), wxPGTypeName_long) == 0 )
743 {
744 return value.GetLong()?true:false;
745 }
746 wxPGGetFailed(p,wxPGTypeName_bool);
747 return false;
748 }
749
750 IMPLEMENT_GET_VALUE(long,long,Long,0)
751 IMPLEMENT_GET_VALUE(double,double,Double,0.0)
752
753 bool wxPropertyGridInterface::IsPropertyExpanded( wxPGPropArg id ) const
754 {
755 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
756 return p->IsExpanded();
757 }
758
759 // -----------------------------------------------------------------------
760 // wxPropertyGridInterface wrappers
761 // -----------------------------------------------------------------------
762
763 bool wxPropertyGridInterface::ChangePropertyValue( wxPGPropArg id, wxVariant newValue )
764 {
765 return GetPropertyGrid()->ChangePropertyValue(id, newValue);
766 }
767
768 // -----------------------------------------------------------------------
769
770 void wxPropertyGridInterface::BeginAddChildren( wxPGPropArg id )
771 {
772 wxPG_PROP_ARG_CALL_PROLOG()
773 wxCHECK_RET( p->HasFlag(wxPG_PROP_AGGREGATE), wxT("only call on properties with fixed children") );
774 p->ClearFlag(wxPG_PROP_AGGREGATE);
775 p->SetFlag(wxPG_PROP_MISC_PARENT);
776 }
777
778 // -----------------------------------------------------------------------
779
780 bool wxPropertyGridInterface::EditorValidate()
781 {
782 return GetPropertyGrid()->DoEditorValidate();
783 }
784
785 // -----------------------------------------------------------------------
786
787 void wxPropertyGridInterface::EndAddChildren( wxPGPropArg id )
788 {
789 wxPG_PROP_ARG_CALL_PROLOG()
790 wxCHECK_RET( p->HasFlag(wxPG_PROP_MISC_PARENT), wxT("only call on properties for which BeginAddChildren was called prior") );
791 p->ClearFlag(wxPG_PROP_MISC_PARENT);
792 p->SetFlag(wxPG_PROP_AGGREGATE);
793 }
794
795 // -----------------------------------------------------------------------
796 // wxPGVIterator_State
797 // -----------------------------------------------------------------------
798
799 // Default returned by wxPropertyGridInterface::GetVIterator().
800 class wxPGVIteratorBase_State : public wxPGVIteratorBase
801 {
802 public:
803 wxPGVIteratorBase_State( wxPropertyGridPageState* state, int flags )
804 {
805 m_it.Init( state, flags );
806 }
807 virtual ~wxPGVIteratorBase_State() { }
808 virtual void Next() { m_it.Next(); }
809 };
810
811 wxPGVIterator wxPropertyGridInterface::GetVIterator( int flags ) const
812 {
813 return wxPGVIterator( new wxPGVIteratorBase_State( m_pState, flags ) );
814 }
815
816 // -----------------------------------------------------------------------
817 // wxPGEditableState related functions
818 // -----------------------------------------------------------------------
819
820 // EscapeDelimiters() changes ";" into "\;" and "|" into "\|"
821 // in the input string. This is an internal functions which is
822 // used for saving states
823 // NB: Similar function exists in aui/framemanager.cpp
824 static wxString EscapeDelimiters(const wxString& s)
825 {
826 wxString result;
827 result.Alloc(s.length());
828 const wxChar* ch = s.c_str();
829 while (*ch)
830 {
831 if (*ch == wxT(';') || *ch == wxT('|') || *ch == wxT(','))
832 result += wxT('\\');
833 result += *ch;
834 ++ch;
835 }
836 return result;
837 }
838
839 wxString wxPropertyGridInterface::SaveEditableState( int includedStates ) const
840 {
841 wxString result;
842
843 //
844 // Save state on page basis
845 unsigned int pageIndex = 0;
846 wxArrayPtrVoid pageStates;
847
848 for (;;)
849 {
850 wxPropertyGridPageState* page = GetPageState(pageIndex);
851 if ( !page ) break;
852
853 pageStates.Add(page);
854
855 pageIndex++;
856 }
857
858 for ( pageIndex=0; pageIndex < pageStates.size(); pageIndex++ )
859 {
860 wxPropertyGridPageState* pageState = (wxPropertyGridPageState*) pageStates[pageIndex];
861
862 if ( includedStates & SelectionState )
863 {
864 wxString sel;
865 if ( pageState->GetSelection() )
866 sel = pageState->GetSelection()->GetName();
867 result += wxS("selection=");
868 result += EscapeDelimiters(sel);
869 result += wxS(";");
870 }
871 if ( includedStates & ExpandedState )
872 {
873 wxArrayPGProperty ptrs;
874 wxPropertyGridConstIterator it =
875 wxPropertyGridConstIterator( pageState,
876 wxPG_ITERATE_ALL_PARENTS_RECURSIVELY|wxPG_ITERATE_HIDDEN,
877 wxNullProperty );
878
879 result += wxS("expanded=");
880
881 for ( ;
882 !it.AtEnd();
883 it.Next() )
884 {
885 const wxPGProperty* p = it.GetProperty();
886
887 if ( !p->HasFlag(wxPG_PROP_COLLAPSED) )
888 result += EscapeDelimiters(p->GetName());
889 result += wxS(",");
890
891 }
892
893 if ( result.Last() == wxS(',') )
894 result.RemoveLast();
895
896 result += wxS(";");
897 }
898 if ( includedStates & ScrollPosState )
899 {
900 int x, y;
901 GetPropertyGrid()->GetViewStart(&x,&y);
902 result += wxString::Format(wxS("scrollpos=%i,%i;"), x, y);
903 }
904 if ( includedStates & SplitterPosState )
905 {
906 result += wxS("splitterpos=");
907
908 for ( size_t i=0; i<pageState->GetColumnCount(); i++ )
909 result += wxString::Format(wxS("%i,"), pageState->DoGetSplitterPosition(i));
910
911 result.RemoveLast(); // Remove last comma
912 result += wxS(";");
913 }
914 if ( includedStates & PageState )
915 {
916 result += wxS("ispageselected=");
917
918 if ( GetPageState(-1) == pageState )
919 result += wxS("1;");
920 else
921 result += wxS("0;");
922 }
923 if ( includedStates & DescBoxState )
924 {
925 wxVariant v = GetEditableStateItem(wxS("descboxheight"));
926 if ( !v.IsNull() )
927 result += wxString::Format(wxS("descboxheight=%i;"), (int)v.GetLong());
928 }
929 result.RemoveLast(); // Remove last semicolon
930 result += wxS("|");
931 }
932
933 // Remove last '|'
934 if ( !result.empty() )
935 result.RemoveLast();
936
937 return result;
938 }
939
940 bool wxPropertyGridInterface::RestoreEditableState( const wxString& src, int restoreStates )
941 {
942 wxPropertyGrid* pg = GetPropertyGrid();
943 wxPGProperty* newSelection = NULL;
944 size_t pageIndex;
945 long vx = -1;
946 long vy = -1;
947 long selectedPage = -1;
948 bool pgSelectionSet = false;
949 bool res = true;
950
951 pg->Freeze();
952 wxArrayString pageStrings = ::wxSplit(src, wxS('|'), wxS('\\'));
953
954 for ( pageIndex=0; pageIndex<pageStrings.size(); pageIndex++ )
955 {
956 wxPropertyGridPageState* pageState = GetPageState(pageIndex);
957 if ( !pageState )
958 break;
959
960 wxArrayString kvpairStrings = ::wxSplit(pageStrings[pageIndex], wxS(';'), wxS('\\'));
961
962 for ( size_t i=0; i<kvpairStrings.size(); i++ )
963 {
964 const wxString& kvs = kvpairStrings[i];
965 int eq_pos = kvs.Find(wxS('='));
966 if ( eq_pos != wxNOT_FOUND )
967 {
968 wxString key = kvs.substr(0, eq_pos);
969 wxString value = kvs.substr(eq_pos+1);
970
971 // Further split value by commas
972 wxArrayString values = ::wxSplit(value, wxS(','), wxS('\\'));
973
974 if ( key == wxS("expanded") )
975 {
976 if ( restoreStates & ExpandedState )
977 {
978 wxPropertyGridIterator it =
979 wxPropertyGridIterator( pageState,
980 wxPG_ITERATE_ALL,
981 wxNullProperty );
982
983 // First collapse all
984 for ( ; !it.AtEnd(); it.Next() )
985 {
986 wxPGProperty* p = it.GetProperty();
987 pageState->DoCollapse(p);
988 }
989
990 // Then expand those which names are in values
991 for ( size_t n=0; n<values.size(); n++ )
992 {
993 const wxString& name = values[n];
994 wxPGProperty* prop = GetPropertyByName(name);
995 if ( prop )
996 pageState->DoExpand(prop);
997 }
998 }
999 }
1000 else if ( key == wxS("scrollpos") )
1001 {
1002 if ( restoreStates & ScrollPosState )
1003 {
1004 if ( values.size() == 2 )
1005 {
1006 values[0].ToLong(&vx);
1007 values[1].ToLong(&vy);
1008 }
1009 else
1010 {
1011 res = false;
1012 }
1013 }
1014 }
1015 else if ( key == wxS("splitterpos") )
1016 {
1017 if ( restoreStates & SplitterPosState )
1018 {
1019 for ( size_t n=1; n<values.size(); n++ )
1020 {
1021 long pos = 0;
1022 values[n].ToLong(&pos);
1023 if ( pos > 0 )
1024 pageState->DoSetSplitterPosition(pos, n);
1025 }
1026 }
1027 }
1028 else if ( key == wxS("selection") )
1029 {
1030 if ( restoreStates & SelectionState )
1031 {
1032 if ( values.size() > 0 )
1033 {
1034 if ( pageState->IsDisplayed() )
1035 {
1036 if ( !values[0].empty() )
1037 newSelection = GetPropertyByName(value);
1038 pgSelectionSet = true;
1039 }
1040 else
1041 {
1042 if ( !values[0].empty() )
1043 pageState->DoSetSelection(GetPropertyByName(value));
1044 else
1045 pageState->DoClearSelection();
1046 }
1047 }
1048 }
1049 }
1050 else if ( key == wxS("ispageselected") )
1051 {
1052 if ( restoreStates & PageState )
1053 {
1054 long pageSelStatus;
1055 if ( values.size() == 1 && values[0].ToLong(&pageSelStatus) )
1056 {
1057 if ( pageSelStatus )
1058 selectedPage = pageIndex;
1059 }
1060 else
1061 {
1062 res = false;
1063 }
1064 }
1065 }
1066 else if ( key == wxS("descboxheight") )
1067 {
1068 if ( restoreStates & DescBoxState )
1069 {
1070 long descBoxHeight;
1071 if ( values.size() == 1 && values[0].ToLong(&descBoxHeight) )
1072 {
1073 SetEditableStateItem(wxS("descboxheight"), descBoxHeight);
1074 }
1075 else
1076 {
1077 res = false;
1078 }
1079 }
1080 }
1081 else
1082 {
1083 res = false;
1084 }
1085 }
1086 }
1087 }
1088
1089 //
1090 // Force recalculation of virtual heights of all pages
1091 // (may be needed on unclean source string).
1092 pageIndex = 0;
1093 wxPropertyGridPageState* pageState = GetPageState(pageIndex);
1094 while ( pageState )
1095 {
1096 pageState->VirtualHeightChanged();
1097 pageIndex += 1;
1098 pageState = GetPageState(pageIndex);
1099 }
1100
1101 pg->Thaw();
1102
1103 //
1104 // Selection of visible grid page must be set after Thaw() call
1105 if ( pgSelectionSet )
1106 {
1107 if ( newSelection )
1108 pg->DoSelectProperty(newSelection);
1109 else
1110 pg->DoClearSelection();
1111 }
1112
1113 if ( selectedPage != -1 )
1114 {
1115 DoSelectPage(selectedPage);
1116 }
1117
1118 if ( vx >= 0 )
1119 {
1120 pg->Scroll(vx, vy);
1121 }
1122
1123 return res;
1124 }
1125
1126 #endif // wxUSE_PROPGRID
1127