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