]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/propgrid/property.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Add samples files missing from distribution.
[wxWidgets.git] / src / propgrid / property.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/propgrid/property.cpp
3// Purpose: wxPGProperty and related support classes
4// Author: Jaakko Salli
5// Modified by:
6// Created: 2008-08-23
7// RCS-ID: $Id$
8// Copyright: (c) Jaakko Salli
9// Licence: wxWindows license
10/////////////////////////////////////////////////////////////////////////////
11
12// For compilers that support precompilation, includes "wx/wx.h".
13#include "wx/wxprec.h"
14
15#ifdef __BORLANDC__
16 #pragma hdrstop
17#endif
18
19#if wxUSE_PROPGRID
20
21#ifndef WX_PRECOMP
22 #include "wx/defs.h"
23 #include "wx/object.h"
24 #include "wx/hash.h"
25 #include "wx/string.h"
26 #include "wx/log.h"
27 #include "wx/event.h"
28 #include "wx/window.h"
29 #include "wx/panel.h"
30 #include "wx/dc.h"
31 #include "wx/dcmemory.h"
32 #include "wx/pen.h"
33 #include "wx/brush.h"
34 #include "wx/settings.h"
35 #include "wx/intl.h"
36#endif
37
38#include "wx/propgrid/propgrid.h"
39
40
41#define PWC_CHILD_SUMMARY_LIMIT 16 // Maximum number of children summarized in a parent property's
42 // value field.
43
44#define PWC_CHILD_SUMMARY_CHAR_LIMIT 64 // Character limit of summary field when not editing
45
46#if wxPG_COMPATIBILITY_1_4
47
48// Used to establish backwards compatiblity
49const char* g_invalidStringContent = "@__TOTALLY_INVALID_STRING__@";
50
51#endif
52
53// -----------------------------------------------------------------------
54
55static void wxPGDrawFocusRect( wxDC& dc, const wxRect& rect )
56{
57#if defined(__WXMSW__) && !defined(__WXWINCE__)
58 // FIXME: Use DrawFocusRect code above (currently it draws solid line
59 // for caption focus but works ok for other stuff).
60 // Also, it seems that this code may not work in future wx versions.
61 dc.SetLogicalFunction(wxINVERT);
62
63 wxPen pen(*wxBLACK,1,wxDOT);
64 pen.SetCap(wxCAP_BUTT);
65 dc.SetPen(pen);
66 dc.SetBrush(*wxTRANSPARENT_BRUSH);
67
68 dc.DrawRectangle(rect);
69
70 dc.SetLogicalFunction(wxCOPY);
71#else
72 dc.SetLogicalFunction(wxINVERT);
73
74 dc.SetPen(wxPen(*wxBLACK,1,wxDOT));
75 dc.SetBrush(*wxTRANSPARENT_BRUSH);
76
77 dc.DrawRectangle(rect);
78
79 dc.SetLogicalFunction(wxCOPY);
80#endif
81}
82
83// -----------------------------------------------------------------------
84// wxPGCellRenderer
85// -----------------------------------------------------------------------
86
87wxSize wxPGCellRenderer::GetImageSize( const wxPGProperty* WXUNUSED(property),
88 int WXUNUSED(column),
89 int WXUNUSED(item) ) const
90{
91 return wxSize(0, 0);
92}
93
94void wxPGCellRenderer::DrawText( wxDC& dc, const wxRect& rect,
95 int xOffset, const wxString& text ) const
96{
97 dc.DrawText( text,
98 rect.x+xOffset+wxPG_XBEFORETEXT,
99 rect.y+((rect.height-dc.GetCharHeight())/2) );
100}
101
102void wxPGCellRenderer::DrawEditorValue( wxDC& dc, const wxRect& rect,
103 int xOffset, const wxString& text,
104 wxPGProperty* property,
105 const wxPGEditor* editor ) const
106{
107 int yOffset = ((rect.height-dc.GetCharHeight())/2);
108
109 if ( editor )
110 {
111 wxRect rect2(rect);
112 rect2.x += xOffset;
113 rect2.y += yOffset;
114 rect2.height -= yOffset;
115 editor->DrawValue( dc, rect2, property, text );
116 }
117 else
118 {
119 dc.DrawText( text,
120 rect.x+xOffset+wxPG_XBEFORETEXT,
121 rect.y+yOffset );
122 }
123}
124
125void wxPGCellRenderer::DrawCaptionSelectionRect( wxDC& dc, int x, int y, int w, int h ) const
126{
127 wxRect focusRect(x,y+((h-dc.GetCharHeight())/2),w,h);
128 wxPGDrawFocusRect(dc,focusRect);
129}
130
131int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell& cell, int flags ) const
132{
133 int imageWidth = 0;
134
135 // If possible, use cell colours
136 if ( !(flags & DontUseCellBgCol) )
137 {
138 dc.SetPen(cell.GetBgCol());
139 dc.SetBrush(cell.GetBgCol());
140 }
141
142 if ( !(flags & DontUseCellFgCol) )
143 {
144 dc.SetTextForeground(cell.GetFgCol());
145 }
146
147 // Draw Background, but only if not rendering in control
148 // (as control already has rendered correct background).
149 if ( !(flags & (Control|ChoicePopup)) )
150 dc.DrawRectangle(rect);
151
152 const wxBitmap& bmp = cell.GetBitmap();
153 if ( bmp.Ok() &&
154 // Do not draw oversized bitmap outside choice popup
155 ((flags & ChoicePopup) || bmp.GetHeight() < rect.height )
156 )
157 {
158 dc.DrawBitmap( bmp,
159 rect.x + wxPG_CONTROL_MARGIN + wxCC_CUSTOM_IMAGE_MARGIN1,
160 rect.y + wxPG_CUSTOM_IMAGE_SPACINGY,
161 true );
162 imageWidth = bmp.GetWidth();
163 }
164
165 return imageWidth;
166}
167
168// -----------------------------------------------------------------------
169// wxPGDefaultRenderer
170// -----------------------------------------------------------------------
171
172void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
173 const wxPropertyGrid* propertyGrid, wxPGProperty* property,
174 int column, int item, int flags ) const
175{
176 bool isUnspecified = property->IsValueUnspecified();
177
178 if ( column == 1 && item == -1 )
179 {
180 int cmnVal = property->GetCommonValue();
181 if ( cmnVal >= 0 )
182 {
183 // Common Value
184 if ( !isUnspecified )
185 DrawText( dc, rect, 0, propertyGrid->GetCommonValueLabel(cmnVal) );
186 return;
187 }
188 }
189
190 const wxPGEditor* editor = NULL;
191 const wxPGCell* cell = NULL;
192
193 wxString text;
194 int imageWidth = 0;
195 int preDrawFlags = flags;
196
197 property->GetDisplayInfo(column, item, flags, &text, &cell);
198
199 imageWidth = PreDrawCell( dc, rect, *cell, preDrawFlags );
200
201 if ( column == 1 )
202 {
203 if ( !isUnspecified )
204 {
205 editor = property->GetColumnEditor(column);
206
207 // Regular property value
208
209 wxSize imageSize = propertyGrid->GetImageSize(property, item);
210
211 wxPGPaintData paintdata;
212 paintdata.m_parent = propertyGrid;
213 paintdata.m_choiceItem = item;
214
215 if ( imageSize.x > 0 )
216 {
217 wxRect imageRect(rect.x + wxPG_CONTROL_MARGIN + wxCC_CUSTOM_IMAGE_MARGIN1,
218 rect.y+wxPG_CUSTOM_IMAGE_SPACINGY,
219 wxPG_CUSTOM_IMAGE_WIDTH,
220 rect.height-(wxPG_CUSTOM_IMAGE_SPACINGY*2));
221
222 dc.SetPen( wxPen(propertyGrid->GetCellTextColour(), 1, wxSOLID) );
223
224 paintdata.m_drawnWidth = imageSize.x;
225 paintdata.m_drawnHeight = imageSize.y;
226
227 property->OnCustomPaint( dc, imageRect, paintdata );
228
229 imageWidth = paintdata.m_drawnWidth;
230 }
231
232 text = property->GetValueAsString();
233
234 // Add units string?
235 if ( propertyGrid->GetColumnCount() <= 2 )
236 {
237 wxString unitsString = property->GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
238 if ( unitsString.length() )
239 text = wxString::Format(wxS("%s %s"), text.c_str(), unitsString.c_str() );
240 }
241 }
242
243 if ( text.length() == 0 )
244 {
245 // Try to show inline help if no text
246 wxVariant vInlineHelp = property->GetAttribute(wxPGGlobalVars->m_strInlineHelp);
247 if ( !vInlineHelp.IsNull() )
248 {
249 text = vInlineHelp.GetString();
250 dc.SetTextForeground(propertyGrid->GetCellDisabledTextColour());
251 }
252 }
253 }
254
255 int imageOffset = property->GetImageOffset(imageWidth);
256
257 DrawEditorValue( dc, rect, imageOffset, text, property, editor );
258
259 // active caption gets nice dotted rectangle
260 if ( property->IsCategory() /*&& column == 0*/ )
261 {
262 if ( flags & Selected )
263 {
264 if ( imageWidth > 0 )
265 {
266 imageOffset -= DEFAULT_IMAGE_OFFSET_INCREMENT;
267 imageWidth += wxCC_CUSTOM_IMAGE_MARGIN2 + 4;
268 }
269
270 DrawCaptionSelectionRect( dc,
271 rect.x+wxPG_XBEFORETEXT-wxPG_CAPRECTXMARGIN+imageOffset,
272 rect.y-wxPG_CAPRECTYMARGIN+1,
273 ((wxPropertyCategory*)property)->GetTextExtent(propertyGrid,
274 propertyGrid->GetCaptionFont())
275 +(wxPG_CAPRECTXMARGIN*2),
276 propertyGrid->GetFontHeight()+(wxPG_CAPRECTYMARGIN*2) );
277 }
278 }
279}
280
281wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
282 int column,
283 int item ) const
284{
285 if ( property && column == 1 )
286 {
287 if ( item == -1 )
288 {
289 wxBitmap* bmp = property->GetValueImage();
290
291 if ( bmp && bmp->Ok() )
292 return wxSize(bmp->GetWidth(),bmp->GetHeight());
293 }
294 }
295 return wxSize(0,0);
296}
297
298// -----------------------------------------------------------------------
299// wxPGCellData
300// -----------------------------------------------------------------------
301
302wxPGCellData::wxPGCellData()
303 : wxObjectRefData()
304{
305 m_hasValidText = false;
306}
307
308// -----------------------------------------------------------------------
309// wxPGCell
310// -----------------------------------------------------------------------
311
312wxPGCell::wxPGCell()
313 : wxObject()
314{
315}
316
317wxPGCell::wxPGCell( const wxString& text,
318 const wxBitmap& bitmap,
319 const wxColour& fgCol,
320 const wxColour& bgCol )
321 : wxObject()
322{
323 wxPGCellData* data = new wxPGCellData();
324 m_refData = data;
325 data->m_text = text;
326 data->m_bitmap = bitmap;
327 data->m_fgCol = fgCol;
328 data->m_bgCol = bgCol;
329 data->m_hasValidText = true;
330}
331
332wxObjectRefData *wxPGCell::CloneRefData( const wxObjectRefData *data ) const
333{
334 wxPGCellData* c = new wxPGCellData();
335 const wxPGCellData* o = (const wxPGCellData*) data;
336 c->m_text = o->m_text;
337 c->m_bitmap = o->m_bitmap;
338 c->m_fgCol = o->m_fgCol;
339 c->m_bgCol = o->m_bgCol;
340 c->m_hasValidText = o->m_hasValidText;
341 return c;
342}
343
344void wxPGCell::SetText( const wxString& text )
345{
346 AllocExclusive();
347
348 GetData()->SetText(text);
349}
350
351void wxPGCell::SetBitmap( const wxBitmap& bitmap )
352{
353 AllocExclusive();
354
355 GetData()->SetBitmap(bitmap);
356}
357
358void wxPGCell::SetFgCol( const wxColour& col )
359{
360 AllocExclusive();
361
362 GetData()->SetFgCol(col);
363}
364
365void wxPGCell::SetBgCol( const wxColour& col )
366{
367 AllocExclusive();
368
369 GetData()->SetBgCol(col);
370}
371
372void wxPGCell::MergeFrom( const wxPGCell& srcCell )
373{
374 AllocExclusive();
375
376 wxPGCellData* data = GetData();
377
378 if ( srcCell.HasText() )
379 data->SetText(srcCell.GetText());
380
381 if ( srcCell.GetFgCol().IsOk() )
382 data->SetFgCol(srcCell.GetFgCol());
383
384 if ( srcCell.GetBgCol().IsOk() )
385 data->SetBgCol(srcCell.GetBgCol());
386
387 if ( srcCell.GetBitmap().IsOk() )
388 data->SetBitmap(srcCell.GetBitmap());
389}
390
391// -----------------------------------------------------------------------
392// wxPGProperty
393// -----------------------------------------------------------------------
394
395IMPLEMENT_ABSTRACT_CLASS(wxPGProperty, wxObject)
396
397wxString* wxPGProperty::sm_wxPG_LABEL = NULL;
398
399void wxPGProperty::Init()
400{
401 m_commonValue = -1;
402 m_arrIndex = 0xFFFF;
403 m_parent = NULL;
404
405 m_parentState = NULL;
406
407 m_clientData = NULL;
408 m_clientObject = NULL;
409
410 m_customEditor = NULL;
411#if wxUSE_VALIDATORS
412 m_validator = NULL;
413#endif
414 m_valueBitmap = NULL;
415
416 m_maxLen = 0; // infinite maximum length
417
418 m_flags = wxPG_PROP_PROPERTY;
419
420 m_depth = 1;
421
422 SetExpanded(true);
423}
424
425
426void wxPGProperty::Init( const wxString& label, const wxString& name )
427{
428 // We really need to check if &label and &name are NULL pointers
429 // (this can if we are called before property grid has been initalized)
430
431 if ( (&label) != NULL && label != wxPG_LABEL )
432 m_label = label;
433
434 if ( (&name) != NULL && name != wxPG_LABEL )
435 DoSetName( name );
436 else
437 DoSetName( m_label );
438
439 Init();
440}
441
442void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState,
443 wxPropertyGrid* propgrid )
444{
445 //
446 // Called after property has been added to grid or page
447 // (so propgrid can be NULL, too).
448
449 wxPGProperty* parent = m_parent;
450 bool parentIsRoot = parent->IsKindOf(CLASSINFO(wxPGRootProperty));
451
452 m_parentState = pageState;
453
454#if wxPG_COMPATIBILITY_1_4
455 // Make sure deprecated virtual functions are not implemented
456 wxString s = GetValueAsString( 0xFFFF );
457 wxASSERT_MSG( s == g_invalidStringContent,
458 "Implement ValueToString() instead of GetValueAsString()" );
459#endif
460
461 if ( !parentIsRoot && !parent->IsCategory() )
462 {
463 m_cells = parent->m_cells;
464 }
465
466 // If in hideable adding mode, or if assigned parent is hideable, then
467 // make this one hideable.
468 if (
469 ( !parentIsRoot && parent->HasFlag(wxPG_PROP_HIDDEN) ) ||
470 ( propgrid && (propgrid->HasInternalFlag(wxPG_FL_ADDING_HIDEABLES)) )
471 )
472 SetFlag( wxPG_PROP_HIDDEN );
473
474 // Set custom image flag.
475 int custImgHeight = OnMeasureImage().y;
476 if ( custImgHeight < 0 )
477 {
478 SetFlag(wxPG_PROP_CUSTOMIMAGE);
479 }
480
481 if ( propgrid && (propgrid->HasFlag(wxPG_LIMITED_EDITING)) )
482 SetFlag(wxPG_PROP_NOEDITOR);
483
484 // Make sure parent has some parental flags
485 if ( !parent->HasFlag(wxPG_PROP_PARENTAL_FLAGS) )
486 parent->SetParentalType(wxPG_PROP_MISC_PARENT);
487
488 if ( !IsCategory() )
489 {
490 // This is not a category.
491
492 // Depth.
493 //
494 unsigned char depth = 1;
495 if ( !parentIsRoot )
496 {
497 depth = parent->m_depth;
498 if ( !parent->IsCategory() )
499 depth++;
500 }
501 m_depth = depth;
502 unsigned char greyDepth = depth;
503
504 if ( !parentIsRoot )
505 {
506 wxPropertyCategory* pc;
507
508 if ( parent->IsCategory() )
509 pc = (wxPropertyCategory* ) parent;
510 else
511 // This conditional compile is necessary to
512 // bypass some compiler bug.
513 pc = pageState->GetPropertyCategory(parent);
514
515 if ( pc )
516 greyDepth = pc->GetDepth();
517 else
518 greyDepth = parent->m_depthBgCol;
519 }
520
521 m_depthBgCol = greyDepth;
522 }
523 else
524 {
525 // This is a category.
526
527 // depth
528 unsigned char depth = 1;
529 if ( !parentIsRoot )
530 {
531 depth = parent->m_depth + 1;
532 }
533 m_depth = depth;
534 m_depthBgCol = depth;
535 }
536
537 //
538 // Has initial children
539 if ( GetChildCount() )
540 {
541 // Check parental flags
542 wxASSERT_MSG( ((m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
543 wxPG_PROP_AGGREGATE) ||
544 ((m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
545 wxPG_PROP_MISC_PARENT),
546 "wxPGProperty parental flags set incorrectly at "
547 "this time" );
548
549 if ( HasFlag(wxPG_PROP_AGGREGATE) )
550 {
551 // Properties with private children are not expanded by default.
552 SetExpanded(false);
553 }
554 else if ( propgrid && propgrid->HasFlag(wxPG_HIDE_MARGIN) )
555 {
556 // ...unless it cannot be expanded by user and therefore must
557 // remain visible at all times
558 SetExpanded(true);
559 }
560
561 //
562 // Prepare children recursively
563 for ( unsigned int i=0; i<GetChildCount(); i++ )
564 {
565 wxPGProperty* child = Item(i);
566 child->InitAfterAdded(pageState, pageState->GetGrid());
567 }
568
569 if ( propgrid && (propgrid->GetExtraStyle() & wxPG_EX_AUTO_UNSPECIFIED_VALUES) )
570 SetFlagRecursively(wxPG_PROP_AUTO_UNSPECIFIED, true);
571 }
572}
573
574wxPGProperty::wxPGProperty()
575 : wxObject()
576{
577 Init();
578}
579
580
581wxPGProperty::wxPGProperty( const wxString& label, const wxString& name )
582 : wxObject()
583{
584 Init( label, name );
585}
586
587
588wxPGProperty::~wxPGProperty()
589{
590 delete m_clientObject;
591
592 Empty(); // this deletes items
593
594 delete m_valueBitmap;
595#if wxUSE_VALIDATORS
596 delete m_validator;
597#endif
598
599 // This makes it easier for us to detect dangling pointers
600 m_parent = NULL;
601}
602
603
604bool wxPGProperty::IsSomeParent( wxPGProperty* candidate ) const
605{
606 wxPGProperty* parent = m_parent;
607 do
608 {
609 if ( parent == candidate )
610 return true;
611 parent = parent->m_parent;
612 } while ( parent );
613 return false;
614}
615
616
617wxString wxPGProperty::GetName() const
618{
619 wxPGProperty* parent = GetParent();
620
621 if ( !m_name.length() || !parent || parent->IsCategory() || parent->IsRoot() )
622 return m_name;
623
624 return m_parent->GetName() + wxS(".") + m_name;
625}
626
627wxPropertyGrid* wxPGProperty::GetGrid() const
628{
629 if ( !m_parentState )
630 return NULL;
631 return m_parentState->GetGrid();
632}
633
634int wxPGProperty::Index( const wxPGProperty* p ) const
635{
636 for ( unsigned int i = 0; i<m_children.size(); i++ )
637 {
638 if ( p == m_children[i] )
639 return i;
640 }
641 return wxNOT_FOUND;
642}
643
644bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const
645{
646 return true;
647}
648
649void wxPGProperty::OnSetValue()
650{
651}
652
653void wxPGProperty::RefreshChildren ()
654{
655}
656
657void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )
658{
659}
660
661void wxPGProperty::GetDisplayInfo( unsigned int column,
662 int choiceIndex,
663 int flags,
664 wxString* pString,
665 const wxPGCell** pCell )
666{
667 const wxPGCell* cell = NULL;
668
669 if ( !(flags & wxPGCellRenderer::ChoicePopup) )
670 {
671 // Not painting listi of choice popups, so get text from property
672 cell = &GetCell(column);
673 if ( cell->HasText() )
674 {
675 *pString = cell->GetText();
676 }
677 else
678 {
679 if ( column == 0 )
680 *pString = GetLabel();
681 else if ( column == 1 )
682 *pString = GetDisplayedString();
683 else if ( column == 2 )
684 *pString = GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
685 }
686 }
687 else
688 {
689 wxASSERT( column == 1 );
690
691 if ( choiceIndex != wxNOT_FOUND )
692 {
693 const wxPGChoiceEntry& entry = m_choices[choiceIndex];
694 if ( entry.GetBitmap().IsOk() ||
695 entry.GetFgCol().IsOk() ||
696 entry.GetBgCol().IsOk() )
697 cell = &entry;
698 *pString = m_choices.GetLabel(choiceIndex);
699 }
700 }
701
702 if ( !cell )
703 cell = &GetCell(column);
704
705 wxASSERT_MSG( cell->GetData(),
706 wxString::Format("Invalid cell for property %s",
707 GetName().c_str()) );
708
709 *pCell = cell;
710}
711
712/*
713wxString wxPGProperty::GetColumnText( unsigned int col, int choiceIndex ) const
714{
715
716 if ( col != 1 || choiceIndex == wxNOT_FOUND )
717 {
718 const wxPGCell& cell = GetCell(col);
719 if ( cell->HasText() )
720 {
721 return cell->GetText();
722 }
723 else
724 {
725 if ( col == 0 )
726 return GetLabel();
727 else if ( col == 1 )
728 return GetDisplayedString();
729 else if ( col == 2 )
730 return GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
731 }
732 }
733 else
734 {
735 // Use choice
736 return m_choices.GetLabel(choiceIndex);
737 }
738
739 return wxEmptyString;
740}
741*/
742
743void wxPGProperty::DoGenerateComposedValue( wxString& text,
744 int argFlags,
745 const wxVariantList* valueOverrides,
746 wxPGHashMapS2S* childResults ) const
747{
748 int i;
749 int iMax = m_children.size();
750
751 text.clear();
752 if ( iMax == 0 )
753 return;
754
755 if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
756 !(argFlags & wxPG_FULL_VALUE) )
757 iMax = PWC_CHILD_SUMMARY_LIMIT;
758
759 int iMaxMinusOne = iMax-1;
760
761 if ( !IsTextEditable() )
762 argFlags |= wxPG_UNEDITABLE_COMPOSITE_FRAGMENT;
763
764 wxPGProperty* curChild = m_children[0];
765
766 bool overridesLeft = false;
767 wxVariant overrideValue;
768 wxVariantList::const_iterator node;
769
770 if ( valueOverrides )
771 {
772 node = valueOverrides->begin();
773 if ( node != valueOverrides->end() )
774 {
775 overrideValue = *node;
776 overridesLeft = true;
777 }
778 }
779
780 for ( i = 0; i < iMax; i++ )
781 {
782 wxVariant childValue;
783
784 wxString childLabel = curChild->GetLabel();
785
786 // Check for value override
787 if ( overridesLeft && overrideValue.GetName() == childLabel )
788 {
789 if ( !overrideValue.IsNull() )
790 childValue = overrideValue;
791 else
792 childValue = curChild->GetValue();
793 ++node;
794 if ( node != valueOverrides->end() )
795 overrideValue = *node;
796 else
797 overridesLeft = false;
798 }
799 else
800 {
801 childValue = curChild->GetValue();
802 }
803
804 wxString s;
805 if ( !childValue.IsNull() )
806 {
807 if ( overridesLeft &&
808 curChild->HasFlag(wxPG_PROP_COMPOSED_VALUE) &&
809 childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
810 {
811 wxVariantList& childList = childValue.GetList();
812 DoGenerateComposedValue(s, argFlags|wxPG_COMPOSITE_FRAGMENT,
813 &childList, childResults);
814 }
815 else
816 {
817 s = curChild->ValueToString(childValue,
818 argFlags|wxPG_COMPOSITE_FRAGMENT);
819 }
820 }
821
822 if ( childResults && curChild->GetChildCount() )
823 (*childResults)[curChild->GetName()] = s;
824
825 bool skip = false;
826 if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && !s.length() )
827 skip = true;
828
829 if ( !curChild->GetChildCount() || skip )
830 text += s;
831 else
832 text += wxS("[") + s + wxS("]");
833
834 if ( i < iMaxMinusOne )
835 {
836 if ( text.length() > PWC_CHILD_SUMMARY_CHAR_LIMIT &&
837 !(argFlags & wxPG_EDITABLE_VALUE) &&
838 !(argFlags & wxPG_FULL_VALUE) )
839 break;
840
841 if ( !skip )
842 {
843 if ( !curChild->GetChildCount() )
844 text += wxS("; ");
845 else
846 text += wxS(" ");
847 }
848
849 curChild = m_children[i+1];
850 }
851 }
852
853 if ( (unsigned int)i < m_children.size() )
854 {
855 if ( !text.EndsWith(wxS("; ")) )
856 text += wxS("; ...");
857 else
858 text += wxS("...");
859 }
860}
861
862wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value),
863 int argFlags ) const
864{
865 wxCHECK_MSG( GetChildCount() > 0,
866 wxString(),
867 "If user property does not have any children, it must "
868 "override GetValueAsString" );
869
870 // FIXME: Currently code below only works if value is actually m_value
871 wxASSERT_MSG( argFlags & wxPG_VALUE_IS_CURRENT,
872 "Sorry, currently default wxPGProperty::ValueToString() "
873 "implementation only works if value is m_value." );
874
875 wxString text;
876 DoGenerateComposedValue(text, argFlags);
877 return text;
878}
879
880wxString wxPGProperty::GetValueAsString( int argFlags ) const
881{
882#if wxPG_COMPATIBILITY_1_4
883 // This is backwards compatibility test
884 // That is, to make sure this function is not overridden
885 // (instead, ValueToString() should be).
886 if ( argFlags == 0xFFFF )
887 {
888 // Do not override! (for backwards compliancy)
889 return g_invalidStringContent;
890 }
891#endif
892
893 if ( IsValueUnspecified() )
894 return wxEmptyString;
895
896 if ( m_commonValue == -1 )
897 {
898 wxVariant value(GetValue());
899 return ValueToString(value, argFlags|wxPG_VALUE_IS_CURRENT);
900 }
901
902 //
903 // Return common value's string representation
904 wxPropertyGrid* pg = GetGrid();
905 const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue);
906
907 if ( argFlags & wxPG_FULL_VALUE )
908 {
909 return cv->GetLabel();
910 }
911 else if ( argFlags & wxPG_EDITABLE_VALUE )
912 {
913 return cv->GetEditableText();
914 }
915 else
916 {
917 return cv->GetLabel();
918 }
919}
920
921wxString wxPGProperty::GetValueString( int argFlags ) const
922{
923 return GetValueAsString(argFlags);
924}
925
926bool wxPGProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
927{
928 variant = (long)number;
929 return true;
930}
931
932// Convert semicolon delimited tokens into child values.
933bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
934{
935 if ( !GetChildCount() )
936 return false;
937
938 unsigned int curChild = 0;
939
940 unsigned int iMax = m_children.size();
941
942 if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
943 !(argFlags & wxPG_FULL_VALUE) )
944 iMax = PWC_CHILD_SUMMARY_LIMIT;
945
946 bool changed = false;
947
948 wxString token;
949 size_t pos = 0;
950
951 // Its best only to add non-empty group items
952 bool addOnlyIfNotEmpty = false;
953 const wxChar delimeter = wxS(';');
954
955 size_t tokenStart = 0xFFFFFF;
956
957 wxVariantList temp_list;
958 wxVariant list(temp_list);
959
960 int propagatedFlags = argFlags & (wxPG_REPORT_ERROR|wxPG_PROGRAMMATIC_VALUE);
961
962 wxLogTrace("propgrid",
963 wxT(">> %s.StringToValue('%s')"), GetLabel(), text);
964
965 wxString::const_iterator it = text.begin();
966 wxUniChar a;
967
968 if ( it != text.end() )
969 a = *it;
970 else
971 a = 0;
972
973 for ( ;; )
974 {
975 // How many units we iterate string forward at the end of loop?
976 // We need to keep track of this or risk going to negative
977 // with it-- operation.
978 unsigned int strPosIncrement = 1;
979
980 if ( tokenStart != 0xFFFFFF )
981 {
982 // Token is running
983 if ( a == delimeter || a == 0 )
984 {
985 token = text.substr(tokenStart,pos-tokenStart);
986 token.Trim(true);
987 size_t len = token.length();
988
989 if ( !addOnlyIfNotEmpty || len > 0 )
990 {
991 const wxPGProperty* child = Item(curChild);
992 wxVariant variant(child->GetValue());
993 wxString childName = child->GetBaseName();
994
995 wxLogTrace("propgrid",
996 wxT("token = '%s', child = %s"),
997 token, childName);
998
999 // Add only if editable or setting programmatically
1000 if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
1001 !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
1002 {
1003 if ( len > 0 )
1004 {
1005 if ( child->StringToValue(variant, token,
1006 propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
1007 {
1008 // We really need to set the variant's name
1009 // *after* child->StringToValue() has been
1010 // called, since variant's value may be set by
1011 // assigning another variant into it, which
1012 // then usually causes name to be copied (ie.
1013 // usually cleared) as well. wxBoolProperty
1014 // being case in point with its use of
1015 // wxPGVariant_Bool macro as an optimization.
1016 variant.SetName(childName);
1017 list.Append(variant);
1018
1019 changed = true;
1020 }
1021 }
1022 else
1023 {
1024 // Empty, becomes unspecified
1025 variant.MakeNull();
1026 variant.SetName(childName);
1027 list.Append(variant);
1028 changed = true;
1029 }
1030 }
1031
1032 curChild++;
1033 if ( curChild >= iMax )
1034 break;
1035 }
1036
1037 tokenStart = 0xFFFFFF;
1038 }
1039 }
1040 else
1041 {
1042 // Token is not running
1043 if ( a != wxS(' ') )
1044 {
1045
1046 addOnlyIfNotEmpty = false;
1047
1048 // Is this a group of tokens?
1049 if ( a == wxS('[') )
1050 {
1051 int depth = 1;
1052
1053 if ( it != text.end() ) ++it;
1054 pos++;
1055 size_t startPos = pos;
1056
1057 // Group item - find end
1058 while ( it != text.end() && depth > 0 )
1059 {
1060 a = *it;
1061 ++it;
1062 pos++;
1063
1064 if ( a == wxS(']') )
1065 depth--;
1066 else if ( a == wxS('[') )
1067 depth++;
1068 }
1069
1070 token = text.substr(startPos,pos-startPos-1);
1071
1072 if ( !token.length() )
1073 break;
1074
1075 const wxPGProperty* child = Item(curChild);
1076
1077 wxVariant oldChildValue = child->GetValue();
1078 wxVariant variant(oldChildValue);
1079
1080 if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
1081 !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
1082 {
1083 wxString childName = child->GetBaseName();
1084
1085 bool stvRes = child->StringToValue( variant, token,
1086 propagatedFlags );
1087 if ( stvRes || (variant != oldChildValue) )
1088 {
1089 variant.SetName(childName);
1090 list.Append(variant);
1091
1092 changed = true;
1093 }
1094 else
1095 {
1096 // No changes...
1097 }
1098 }
1099
1100 curChild++;
1101 if ( curChild >= iMax )
1102 break;
1103
1104 addOnlyIfNotEmpty = true;
1105
1106 tokenStart = 0xFFFFFF;
1107 }
1108 else
1109 {
1110 tokenStart = pos;
1111
1112 if ( a == delimeter )
1113 strPosIncrement -= 1;
1114 }
1115 }
1116 }
1117
1118 if ( a == 0 )
1119 break;
1120
1121 it += strPosIncrement;
1122
1123 if ( it != text.end() )
1124 {
1125 a = *it;
1126 }
1127 else
1128 {
1129 a = 0;
1130 }
1131
1132 pos += strPosIncrement;
1133 }
1134
1135 if ( changed )
1136 variant = list;
1137
1138 return changed;
1139}
1140
1141bool wxPGProperty::SetValueFromString( const wxString& text, int argFlags )
1142{
1143 wxVariant variant(m_value);
1144 bool res = StringToValue(variant, text, argFlags);
1145 if ( res )
1146 SetValue(variant);
1147 return res;
1148}
1149
1150bool wxPGProperty::SetValueFromInt( long number, int argFlags )
1151{
1152 wxVariant variant(m_value);
1153 bool res = IntToValue(variant, number, argFlags);
1154 if ( res )
1155 SetValue(variant);
1156 return res;
1157}
1158
1159wxSize wxPGProperty::OnMeasureImage( int WXUNUSED(item) ) const
1160{
1161 if ( m_valueBitmap )
1162 return wxSize(m_valueBitmap->GetWidth(),-1);
1163
1164 return wxSize(0,0);
1165}
1166
1167int wxPGProperty::GetImageOffset( int imageWidth ) const
1168{
1169 int imageOffset = 0;
1170
1171 if ( imageWidth )
1172 {
1173 // Do not increment offset too much for wide images
1174 if ( imageWidth <= (wxPG_CUSTOM_IMAGE_WIDTH+5) )
1175 imageOffset = imageWidth + DEFAULT_IMAGE_OFFSET_INCREMENT;
1176 else
1177 imageOffset = imageWidth + 1;
1178 }
1179
1180 return imageOffset;
1181}
1182
1183wxPGCellRenderer* wxPGProperty::GetCellRenderer( int WXUNUSED(column) ) const
1184{
1185 return wxPGGlobalVars->m_defaultRenderer;
1186}
1187
1188void wxPGProperty::OnCustomPaint( wxDC& dc,
1189 const wxRect& rect,
1190 wxPGPaintData& )
1191{
1192 wxBitmap* bmp = m_valueBitmap;
1193
1194 wxCHECK_RET( bmp && bmp->Ok(), wxT("invalid bitmap") );
1195
1196 wxCHECK_RET( rect.x >= 0, wxT("unexpected measure call") );
1197
1198 dc.DrawBitmap(*bmp,rect.x,rect.y);
1199}
1200
1201const wxPGEditor* wxPGProperty::DoGetEditorClass() const
1202{
1203 return wxPGEditor_TextCtrl;
1204}
1205
1206// Default extra property event handling - that is, none at all.
1207bool wxPGProperty::OnEvent( wxPropertyGrid*, wxWindow*, wxEvent& )
1208{
1209 return false;
1210}
1211
1212
1213void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
1214{
1215 // If auto unspecified values are not wanted (via window or property style),
1216 // then get default value instead of wxNullVariant.
1217 if ( value.IsNull() && (flags & wxPG_SETVAL_BY_USER) &&
1218 !UsesAutoUnspecified() )
1219 {
1220 value = GetDefaultValue();
1221 }
1222
1223 if ( !value.IsNull() )
1224 {
1225 wxVariant tempListVariant;
1226
1227 SetCommonValue(-1);
1228 // List variants are reserved a special purpose
1229 // as intermediate containers for child values
1230 // of properties with children.
1231 if ( value.GetType() == wxPG_VARIANT_TYPE_LIST )
1232 {
1233 //
1234 // However, situation is different for composed string properties
1235 if ( HasFlag(wxPG_PROP_COMPOSED_VALUE) )
1236 {
1237 tempListVariant = value;
1238 pList = &tempListVariant;
1239 }
1240
1241 wxVariant newValue;
1242 AdaptListToValue(value, &newValue);
1243 value = newValue;
1244 //wxLogDebug(wxT(">> %s.SetValue() adapted list value to type '%s'"),GetName().c_str(),value.GetType().c_str());
1245 }
1246
1247 if ( HasFlag( wxPG_PROP_AGGREGATE) )
1248 flags |= wxPG_SETVAL_AGGREGATED;
1249
1250 if ( pList && !pList->IsNull() )
1251 {
1252 wxASSERT( pList->GetType() == wxPG_VARIANT_TYPE_LIST );
1253 wxASSERT( GetChildCount() );
1254 wxASSERT( !IsCategory() );
1255
1256 wxVariantList& list = pList->GetList();
1257 wxVariantList::iterator node;
1258 unsigned int i = 0;
1259
1260 //wxLogDebug(wxT(">> %s.SetValue() pList parsing"),GetName().c_str());
1261
1262 // Children in list can be in any order, but we will give hint to
1263 // GetPropertyByNameWH(). This optimizes for full list parsing.
1264 for ( node = list.begin(); node != list.end(); ++node )
1265 {
1266 wxVariant& childValue = *((wxVariant*)*node);
1267 wxPGProperty* child = GetPropertyByNameWH(childValue.GetName(), i);
1268 if ( child )
1269 {
1270 //wxLogDebug(wxT("%i: child = %s, childValue.GetType()=%s"),i,child->GetBaseName().c_str(),childValue.GetType().c_str());
1271 if ( childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
1272 {
1273 if ( child->HasFlag(wxPG_PROP_AGGREGATE) && !(flags & wxPG_SETVAL_AGGREGATED) )
1274 {
1275 wxVariant listRefCopy = childValue;
1276 child->SetValue(childValue, &listRefCopy, flags|wxPG_SETVAL_FROM_PARENT);
1277 }
1278 else
1279 {
1280 wxVariant oldVal = child->GetValue();
1281 child->SetValue(oldVal, &childValue, flags|wxPG_SETVAL_FROM_PARENT);
1282 }
1283 }
1284 else if ( child->GetValue() != childValue )
1285 {
1286 // For aggregate properties, we will trust RefreshChildren()
1287 // to update child values.
1288 if ( !HasFlag(wxPG_PROP_AGGREGATE) )
1289 child->SetValue(childValue, NULL, flags|wxPG_SETVAL_FROM_PARENT);
1290 if ( flags & wxPG_SETVAL_BY_USER )
1291 child->SetFlag(wxPG_PROP_MODIFIED);
1292 }
1293 }
1294 i++;
1295 }
1296 }
1297
1298 if ( !value.IsNull() )
1299 {
1300 m_value = value;
1301 OnSetValue();
1302 }
1303
1304 if ( flags & wxPG_SETVAL_BY_USER )
1305 SetFlag(wxPG_PROP_MODIFIED);
1306
1307 if ( HasFlag(wxPG_PROP_AGGREGATE) )
1308 RefreshChildren();
1309 }
1310 else
1311 {
1312 if ( m_commonValue != -1 )
1313 {
1314 wxPropertyGrid* pg = GetGrid();
1315 if ( !pg || m_commonValue != pg->GetUnspecifiedCommonValue() )
1316 SetCommonValue(-1);
1317 }
1318
1319 m_value = value;
1320
1321 // Set children to unspecified, but only if aggregate or
1322 // value is <composed>
1323 if ( AreChildrenComponents() )
1324 {
1325 unsigned int i;
1326 for ( i=0; i<GetChildCount(); i++ )
1327 Item(i)->SetValue(value, NULL, flags|wxPG_SETVAL_FROM_PARENT);
1328 }
1329 }
1330
1331 if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
1332 UpdateParentValues();
1333
1334 //
1335 // Update editor control
1336 //
1337
1338 // We need to check for these, otherwise GetGrid() may fail.
1339 if ( flags & wxPG_SETVAL_REFRESH_EDITOR )
1340 {
1341 RefreshEditor();
1342 wxPropertyGrid* pg = GetGridIfDisplayed();
1343 if ( pg )
1344 pg->DrawItemAndValueRelated(this);
1345 }
1346}
1347
1348
1349void wxPGProperty::SetValueInEvent( wxVariant value ) const
1350{
1351 GetGrid()->ValueChangeInEvent(value);
1352}
1353
1354void wxPGProperty::SetFlagRecursively( FlagType flag, bool set )
1355{
1356 ChangeFlag(flag, set);
1357
1358 unsigned int i;
1359 for ( i = 0; i < GetChildCount(); i++ )
1360 Item(i)->SetFlagRecursively(flag, set);
1361}
1362
1363void wxPGProperty::RefreshEditor()
1364{
1365 if ( !m_parent )
1366 return;
1367
1368 wxPropertyGrid* pg = GetGrid();
1369 if ( pg && pg->GetSelectedProperty() == this )
1370 pg->RefreshEditor();
1371}
1372
1373wxVariant wxPGProperty::GetDefaultValue() const
1374{
1375 wxVariant defVal = GetAttribute(wxPG_ATTR_DEFAULT_VALUE);
1376 if ( !defVal.IsNull() )
1377 return defVal;
1378
1379 wxVariant value = GetValue();
1380
1381 if ( !value.IsNull() )
1382 {
1383 wxString valueType(value.GetType());
1384
1385 if ( valueType == wxPG_VARIANT_TYPE_LONG )
1386 return wxPGVariant_Zero;
1387 if ( valueType == wxPG_VARIANT_TYPE_STRING )
1388 return wxPGVariant_EmptyString;
1389 if ( valueType == wxPG_VARIANT_TYPE_BOOL )
1390 return wxPGVariant_False;
1391 if ( valueType == wxPG_VARIANT_TYPE_DOUBLE )
1392 return wxVariant(0.0);
1393 if ( valueType == wxPG_VARIANT_TYPE_ARRSTRING )
1394 return wxVariant(wxArrayString());
1395 if ( valueType == wxS("wxLongLong") )
1396 return WXVARIANT(wxLongLong(0));
1397 if ( valueType == wxS("wxULongLong") )
1398 return WXVARIANT(wxULongLong(0));
1399 if ( valueType == wxS("wxColour") )
1400 return WXVARIANT(*wxBLACK);
1401#if wxUSE_DATETIME
1402 if ( valueType == wxPG_VARIANT_TYPE_DATETIME )
1403 return wxVariant(wxDateTime::Now());
1404#endif
1405 if ( valueType == wxS("wxFont") )
1406 return WXVARIANT(*wxNORMAL_FONT);
1407 if ( valueType == wxS("wxPoint") )
1408 return WXVARIANT(wxPoint(0, 0));
1409 if ( valueType == wxS("wxSize") )
1410 return WXVARIANT(wxSize(0, 0));
1411 }
1412
1413 return wxVariant();
1414}
1415
1416void wxPGProperty::EnsureCells( unsigned int column )
1417{
1418 if ( column >= m_cells.size() )
1419 {
1420 // Fill empty slots with default cells
1421 wxPropertyGrid* pg = GetGrid();
1422 wxPGCell defaultCell;
1423
1424 if ( !HasFlag(wxPG_PROP_CATEGORY) )
1425 defaultCell = pg->GetPropertyDefaultCell();
1426 else
1427 defaultCell = pg->GetCategoryDefaultCell();
1428
1429 // TODO: Replace with resize() call
1430 unsigned int cellCountMax = column+1;
1431
1432 for ( unsigned int i=m_cells.size(); i<cellCountMax; i++ )
1433 m_cells.push_back(defaultCell);
1434 }
1435}
1436
1437void wxPGProperty::SetCell( int column,
1438 const wxPGCell& cell )
1439{
1440 EnsureCells(column);
1441
1442 m_cells[column] = cell;
1443}
1444
1445void wxPGProperty::AdaptiveSetCell( unsigned int firstCol,
1446 unsigned int lastCol,
1447 const wxPGCell& cell,
1448 const wxPGCell& srcData,
1449 wxPGCellData* unmodCellData,
1450 FlagType ignoreWithFlags,
1451 bool recursively )
1452{
1453 //
1454 // Sets cell in memory optimizing fashion. That is, if
1455 // current cell data matches unmodCellData, we will
1456 // simply get reference to data from cell. Otherwise,
1457 // cell information from srcData is merged into current.
1458 //
1459
1460 if ( !(m_flags & ignoreWithFlags) && !IsRoot() )
1461 {
1462 EnsureCells(lastCol);
1463
1464 for ( unsigned int col=firstCol; col<=lastCol; col++ )
1465 {
1466 if ( m_cells[col].GetData() == unmodCellData )
1467 {
1468 // Data matches... use cell directly
1469 m_cells[col] = cell;
1470 }
1471 else
1472 {
1473 // Data did not match... merge valid information
1474 m_cells[col].MergeFrom(srcData);
1475 }
1476 }
1477 }
1478
1479 if ( recursively )
1480 {
1481 for ( unsigned int i=0; i<GetChildCount(); i++ )
1482 Item(i)->AdaptiveSetCell( firstCol,
1483 lastCol,
1484 cell,
1485 srcData,
1486 unmodCellData,
1487 ignoreWithFlags,
1488 recursively );
1489 }
1490}
1491
1492const wxPGCell& wxPGProperty::GetCell( unsigned int column ) const
1493{
1494 if ( m_cells.size() > column )
1495 return m_cells[column];
1496
1497 wxPropertyGrid* pg = GetGrid();
1498
1499 if ( IsCategory() )
1500 return pg->GetCategoryDefaultCell();
1501
1502 return pg->GetPropertyDefaultCell();
1503}
1504
1505wxPGCell& wxPGProperty::GetCell( unsigned int column )
1506{
1507 EnsureCells(column);
1508 return m_cells[column];
1509}
1510
1511void wxPGProperty::SetBackgroundColour( const wxColour& colour,
1512 bool recursively )
1513{
1514 wxPGProperty* firstProp = this;
1515
1516 //
1517 // If category is tried to set recursively, skip it and only
1518 // affect the children.
1519 if ( recursively )
1520 {
1521 while ( firstProp->IsCategory() )
1522 {
1523 if ( !firstProp->GetChildCount() )
1524 return;
1525 firstProp = firstProp->Item(0);
1526 }
1527 }
1528
1529 wxPGCell& firstCell = firstProp->GetCell(0);
1530 wxPGCellData* firstCellData = firstCell.GetData();
1531
1532 wxPGCell newCell(firstCell);
1533 newCell.SetBgCol(colour);
1534 wxPGCell srcCell;
1535 srcCell.SetBgCol(colour);
1536
1537 AdaptiveSetCell( 0,
1538 GetParentState()->GetColumnCount()-1,
1539 newCell,
1540 srcCell,
1541 firstCellData,
1542 recursively ? wxPG_PROP_CATEGORY : 0,
1543 recursively );
1544}
1545
1546void wxPGProperty::SetTextColour( const wxColour& colour,
1547 bool recursively )
1548{
1549 wxPGProperty* firstProp = this;
1550
1551 //
1552 // If category is tried to set recursively, skip it and only
1553 // affect the children.
1554 if ( recursively )
1555 {
1556 while ( firstProp->IsCategory() )
1557 {
1558 if ( !firstProp->GetChildCount() )
1559 return;
1560 firstProp = firstProp->Item(0);
1561 }
1562 }
1563
1564 wxPGCell& firstCell = firstProp->GetCell(0);
1565 wxPGCellData* firstCellData = firstCell.GetData();
1566
1567 wxPGCell newCell(firstCell);
1568 newCell.SetFgCol(colour);
1569 wxPGCell srcCell;
1570 srcCell.SetFgCol(colour);
1571
1572 AdaptiveSetCell( 0,
1573 GetParentState()->GetColumnCount()-1,
1574 newCell,
1575 srcCell,
1576 firstCellData,
1577 recursively ? wxPG_PROP_CATEGORY : 0,
1578 recursively );
1579}
1580
1581wxPGEditorDialogAdapter* wxPGProperty::GetEditorDialog() const
1582{
1583 return NULL;
1584}
1585
1586bool wxPGProperty::DoSetAttribute( const wxString& WXUNUSED(name), wxVariant& WXUNUSED(value) )
1587{
1588 return false;
1589}
1590
1591void wxPGProperty::SetAttribute( const wxString& name, wxVariant value )
1592{
1593 if ( DoSetAttribute( name, value ) )
1594 {
1595 // Support working without grid, when possible
1596 if ( wxPGGlobalVars->HasExtraStyle( wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES ) )
1597 return;
1598 }
1599
1600 m_attributes.Set( name, value );
1601}
1602
1603void wxPGProperty::SetAttributes( const wxPGAttributeStorage& attributes )
1604{
1605 wxPGAttributeStorage::const_iterator it = attributes.StartIteration();
1606 wxVariant variant;
1607
1608 while ( attributes.GetNext(it, variant) )
1609 SetAttribute( variant.GetName(), variant );
1610}
1611
1612wxVariant wxPGProperty::DoGetAttribute( const wxString& WXUNUSED(name) ) const
1613{
1614 return wxVariant();
1615}
1616
1617
1618wxVariant wxPGProperty::GetAttribute( const wxString& name ) const
1619{
1620 return m_attributes.FindValue(name);
1621}
1622
1623wxString wxPGProperty::GetAttribute( const wxString& name, const wxString& defVal ) const
1624{
1625 wxVariant variant = m_attributes.FindValue(name);
1626
1627 if ( !variant.IsNull() )
1628 return variant.GetString();
1629
1630 return defVal;
1631}
1632
1633long wxPGProperty::GetAttributeAsLong( const wxString& name, long defVal ) const
1634{
1635 wxVariant variant = m_attributes.FindValue(name);
1636
1637 if ( variant.IsNull() )
1638 return defVal;
1639
1640 return variant.GetLong();
1641}
1642
1643double wxPGProperty::GetAttributeAsDouble( const wxString& name, double defVal ) const
1644{
1645 wxVariant variant = m_attributes.FindValue(name);
1646
1647 if ( variant.IsNull() )
1648 return defVal;
1649
1650 return variant.GetDouble();
1651}
1652
1653wxVariant wxPGProperty::GetAttributesAsList() const
1654{
1655 wxVariantList tempList;
1656 wxVariant v( tempList, wxString::Format(wxS("@%s@attr"),m_name.c_str()) );
1657
1658 wxPGAttributeStorage::const_iterator it = m_attributes.StartIteration();
1659 wxVariant variant;
1660
1661 while ( m_attributes.GetNext(it, variant) )
1662 v.Append(variant);
1663
1664 return v;
1665}
1666
1667// Slots of utility flags are NULL
1668const unsigned int gs_propFlagToStringSize = 14;
1669
1670static const wxChar* gs_propFlagToString[gs_propFlagToStringSize] = {
1671 NULL,
1672 wxT("DISABLED"),
1673 wxT("HIDDEN"),
1674 NULL,
1675 wxT("NOEDITOR"),
1676 wxT("COLLAPSED"),
1677 NULL,
1678 NULL,
1679 NULL,
1680 NULL,
1681 NULL,
1682 NULL,
1683 NULL,
1684 NULL
1685};
1686
1687wxString wxPGProperty::GetFlagsAsString( FlagType flagsMask ) const
1688{
1689 wxString s;
1690 int relevantFlags = m_flags & flagsMask & wxPG_STRING_STORED_FLAGS;
1691 FlagType a = 1;
1692
1693 unsigned int i = 0;
1694 for ( i=0; i<gs_propFlagToStringSize; i++ )
1695 {
1696 if ( relevantFlags & a )
1697 {
1698 const wxChar* fs = gs_propFlagToString[i];
1699 wxASSERT(fs);
1700 if ( s.length() )
1701 s << wxS("|");
1702 s << fs;
1703 }
1704 a = a << 1;
1705 }
1706
1707 return s;
1708}
1709
1710void wxPGProperty::SetFlagsFromString( const wxString& str )
1711{
1712 FlagType flags = 0;
1713
1714 WX_PG_TOKENIZER1_BEGIN(str, wxS('|'))
1715 unsigned int i;
1716 for ( i=0; i<gs_propFlagToStringSize; i++ )
1717 {
1718 const wxChar* fs = gs_propFlagToString[i];
1719 if ( fs && str == fs )
1720 {
1721 flags |= (1<<i);
1722 break;
1723 }
1724 }
1725 WX_PG_TOKENIZER1_END()
1726
1727 m_flags = (m_flags & ~wxPG_STRING_STORED_FLAGS) | flags;
1728}
1729
1730wxValidator* wxPGProperty::DoGetValidator() const
1731{
1732 return NULL;
1733}
1734
1735int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
1736{
1737 wxPropertyGrid* pg = GetGrid();
1738 int sel = GetChoiceSelection();
1739
1740 int newSel = sel;
1741
1742 if ( index == wxNOT_FOUND )
1743 index = m_choices.GetCount();
1744
1745 if ( index <= sel )
1746 newSel++;
1747
1748 m_choices.Insert(label, index, value);
1749
1750 if ( sel != newSel )
1751 SetChoiceSelection(newSel);
1752
1753 if ( this == pg->GetSelection() )
1754 GetEditorClass()->InsertItem(pg->GetEditorControl(),label,index);
1755
1756 return index;
1757}
1758
1759
1760void wxPGProperty::DeleteChoice( int index )
1761{
1762 wxPropertyGrid* pg = GetGrid();
1763
1764 int sel = GetChoiceSelection();
1765 int newSel = sel;
1766
1767 // Adjust current value
1768 if ( sel == index )
1769 {
1770 SetValueToUnspecified();
1771 newSel = 0;
1772 }
1773 else if ( index < sel )
1774 {
1775 newSel--;
1776 }
1777
1778 m_choices.RemoveAt(index);
1779
1780 if ( sel != newSel )
1781 SetChoiceSelection(newSel);
1782
1783 if ( this == pg->GetSelection() )
1784 GetEditorClass()->DeleteItem(pg->GetEditorControl(), index);
1785}
1786
1787int wxPGProperty::GetChoiceSelection() const
1788{
1789 wxVariant value = GetValue();
1790 wxString valueType = value.GetType();
1791 int index = wxNOT_FOUND;
1792
1793 if ( IsValueUnspecified() || !m_choices.GetCount() )
1794 return wxNOT_FOUND;
1795
1796 if ( valueType == wxPG_VARIANT_TYPE_LONG )
1797 {
1798 index = value.GetLong();
1799 }
1800 else if ( valueType == wxPG_VARIANT_TYPE_STRING )
1801 {
1802 index = m_choices.Index(value.GetString());
1803 }
1804 else if ( valueType == wxPG_VARIANT_TYPE_BOOL )
1805 {
1806 index = value.GetBool()? 1 : 0;
1807 }
1808
1809 return index;
1810}
1811
1812void wxPGProperty::SetChoiceSelection( int newValue )
1813{
1814 // Changes value of a property with choices, but only
1815 // works if the value type is long or string.
1816 wxString valueType = GetValue().GetType();
1817
1818 wxCHECK_RET( m_choices.IsOk(), wxT("invalid choiceinfo") );
1819
1820 if ( valueType == wxPG_VARIANT_TYPE_STRING )
1821 {
1822 SetValue( m_choices.GetLabel(newValue) );
1823 }
1824 else // if ( valueType == wxPG_VARIANT_TYPE_LONG )
1825 {
1826 SetValue( (long) newValue );
1827 }
1828}
1829
1830bool wxPGProperty::SetChoices( wxPGChoices& choices )
1831{
1832 m_choices.Assign(choices);
1833
1834 {
1835 // This may be needed to trigger some initialization
1836 // (but don't do it if property is somewhat uninitialized)
1837 wxVariant defVal = GetDefaultValue();
1838 if ( defVal.IsNull() )
1839 return false;
1840
1841 SetValue(defVal);
1842 }
1843
1844 return true;
1845}
1846
1847
1848const wxPGEditor* wxPGProperty::GetEditorClass() const
1849{
1850 const wxPGEditor* editor;
1851
1852 if ( !m_customEditor )
1853 {
1854 editor = DoGetEditorClass();
1855 }
1856 else
1857 editor = m_customEditor;
1858
1859 //
1860 // Maybe override editor if common value specified
1861 if ( GetDisplayedCommonValueCount() )
1862 {
1863 // TextCtrlAndButton -> ComboBoxAndButton
1864 if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlAndButtonEditor)) )
1865 editor = wxPGEditor_ChoiceAndButton;
1866
1867 // TextCtrl -> ComboBox
1868 else if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlEditor)) )
1869 editor = wxPGEditor_ComboBox;
1870 }
1871
1872 return editor;
1873}
1874
1875bool wxPGProperty::HasVisibleChildren() const
1876{
1877 unsigned int i;
1878
1879 for ( i=0; i<GetChildCount(); i++ )
1880 {
1881 wxPGProperty* child = Item(i);
1882
1883 if ( !child->HasFlag(wxPG_PROP_HIDDEN) )
1884 return true;
1885 }
1886
1887 return false;
1888}
1889
1890bool wxPGProperty::RecreateEditor()
1891{
1892 wxPropertyGrid* pg = GetGrid();
1893 wxASSERT(pg);
1894
1895 wxPGProperty* selected = pg->GetSelection();
1896 if ( this == selected )
1897 {
1898 pg->DoSelectProperty(this, wxPG_SEL_FORCE);
1899 return true;
1900 }
1901 return false;
1902}
1903
1904
1905void wxPGProperty::SetValueImage( wxBitmap& bmp )
1906{
1907 delete m_valueBitmap;
1908
1909 if ( &bmp && bmp.Ok() )
1910 {
1911 // Resize the image
1912 wxSize maxSz = GetGrid()->GetImageSize();
1913 wxSize imSz(bmp.GetWidth(),bmp.GetHeight());
1914
1915 if ( imSz.y != maxSz.y )
1916 {
1917 // Create a memory DC
1918 wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth());
1919
1920 wxMemoryDC dc;
1921 dc.SelectObject(*bmpNew);
1922
1923 // Scale
1924 // FIXME: This is ugly - use image or wait for scaling patch.
1925 double scaleY = (double)maxSz.y / (double)imSz.y;
1926
1927 dc.SetUserScale(scaleY, scaleY);
1928
1929 dc.DrawBitmap(bmp, 0, 0);
1930
1931 m_valueBitmap = bmpNew;
1932 }
1933 else
1934 {
1935 m_valueBitmap = new wxBitmap(bmp);
1936 }
1937
1938 m_flags |= wxPG_PROP_CUSTOMIMAGE;
1939 }
1940 else
1941 {
1942 m_valueBitmap = NULL;
1943 m_flags &= ~(wxPG_PROP_CUSTOMIMAGE);
1944 }
1945}
1946
1947
1948wxPGProperty* wxPGProperty::GetMainParent() const
1949{
1950 const wxPGProperty* curChild = this;
1951 const wxPGProperty* curParent = m_parent;
1952
1953 while ( curParent && !curParent->IsCategory() )
1954 {
1955 curChild = curParent;
1956 curParent = curParent->m_parent;
1957 }
1958
1959 return (wxPGProperty*) curChild;
1960}
1961
1962
1963const wxPGProperty* wxPGProperty::GetLastVisibleSubItem() const
1964{
1965 //
1966 // Returns last visible sub-item, recursively.
1967 if ( !IsExpanded() || !GetChildCount() )
1968 return this;
1969
1970 return Last()->GetLastVisibleSubItem();
1971}
1972
1973
1974bool wxPGProperty::IsVisible() const
1975{
1976 const wxPGProperty* parent;
1977
1978 if ( HasFlag(wxPG_PROP_HIDDEN) )
1979 return false;
1980
1981 for ( parent = GetParent(); parent != NULL; parent = parent->GetParent() )
1982 {
1983 if ( !parent->IsExpanded() || parent->HasFlag(wxPG_PROP_HIDDEN) )
1984 return false;
1985 }
1986
1987 return true;
1988}
1989
1990wxPropertyGrid* wxPGProperty::GetGridIfDisplayed() const
1991{
1992 wxPropertyGridPageState* state = GetParentState();
1993 if ( !state )
1994 return NULL;
1995 wxPropertyGrid* propGrid = state->GetGrid();
1996 if ( state == propGrid->GetState() )
1997 return propGrid;
1998 return NULL;
1999}
2000
2001
2002int wxPGProperty::GetY2( int lh ) const
2003{
2004 const wxPGProperty* parent;
2005 const wxPGProperty* child = this;
2006
2007 int y = 0;
2008
2009 for ( parent = GetParent(); parent != NULL; parent = child->GetParent() )
2010 {
2011 if ( !parent->IsExpanded() )
2012 return -1;
2013 y += parent->GetChildrenHeight(lh, child->GetIndexInParent());
2014 y += lh;
2015 child = parent;
2016 }
2017
2018 y -= lh; // need to reduce one level
2019
2020 return y;
2021}
2022
2023
2024int wxPGProperty::GetY() const
2025{
2026 return GetY2(GetGrid()->GetRowHeight());
2027}
2028
2029// This is used by Insert etc.
2030void wxPGProperty::DoAddChild( wxPGProperty* prop, int index,
2031 bool correct_mode )
2032{
2033 if ( index < 0 || (size_t)index >= m_children.size() )
2034 {
2035 if ( correct_mode ) prop->m_arrIndex = m_children.size();
2036 m_children.push_back( prop );
2037 }
2038 else
2039 {
2040 m_children.insert( m_children.begin()+index, prop);
2041 if ( correct_mode ) FixIndicesOfChildren( index );
2042 }
2043
2044 prop->m_parent = this;
2045}
2046
2047void wxPGProperty::DoPreAddChild( int index, wxPGProperty* prop )
2048{
2049 wxASSERT_MSG( prop->GetBaseName().length(),
2050 "Property's children must have unique, non-empty "
2051 "names within their scope" );
2052
2053 prop->m_arrIndex = index;
2054 m_children.insert( m_children.begin()+index,
2055 prop );
2056
2057 int custImgHeight = prop->OnMeasureImage().y;
2058 if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
2059 prop->m_flags |= wxPG_PROP_CUSTOMIMAGE;
2060
2061 prop->m_parent = this;
2062}
2063
2064void wxPGProperty::AddPrivateChild( wxPGProperty* prop )
2065{
2066 if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
2067 SetParentalType(wxPG_PROP_AGGREGATE);
2068
2069 wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
2070 wxPG_PROP_AGGREGATE,
2071 "Do not mix up AddPrivateChild() calls with other "
2072 "property adders." );
2073
2074 DoPreAddChild( m_children.size(), prop );
2075}
2076
2077#if wxPG_COMPATIBILITY_1_4
2078void wxPGProperty::AddChild( wxPGProperty* prop )
2079{
2080 AddPrivateChild(prop);
2081}
2082#endif
2083
2084wxPGProperty* wxPGProperty::InsertChild( int index,
2085 wxPGProperty* childProperty )
2086{
2087 if ( index < 0 )
2088 index = m_children.size();
2089
2090 if ( m_parentState )
2091 {
2092 m_parentState->DoInsert(this, index, childProperty);
2093 }
2094 else
2095 {
2096 if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
2097 SetParentalType(wxPG_PROP_MISC_PARENT);
2098
2099 wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
2100 wxPG_PROP_MISC_PARENT,
2101 "Do not mix up AddPrivateChild() calls with other "
2102 "property adders." );
2103
2104 DoPreAddChild( index, childProperty );
2105 }
2106
2107 return childProperty;
2108}
2109
2110void wxPGProperty::RemoveChild( wxPGProperty* p )
2111{
2112 wxArrayPGProperty::iterator it;
2113 wxArrayPGProperty& children = m_children;
2114
2115 for ( it=children.begin(); it != children.end(); it++ )
2116 {
2117 if ( *it == p )
2118 {
2119 m_children.erase(it);
2120 break;
2121 }
2122 }
2123}
2124
2125void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
2126{
2127 wxASSERT( GetChildCount() );
2128 wxASSERT( !IsCategory() );
2129
2130 *value = GetValue();
2131
2132 if ( !list.GetCount() )
2133 return;
2134
2135 wxASSERT( GetChildCount() >= (unsigned int)list.GetCount() );
2136
2137 bool allChildrenSpecified;
2138
2139 // Don't fully update aggregate properties unless all children have
2140 // specified value
2141 if ( HasFlag(wxPG_PROP_AGGREGATE) )
2142 allChildrenSpecified = AreAllChildrenSpecified(&list);
2143 else
2144 allChildrenSpecified = true;
2145
2146 wxVariant childValue = list[0];
2147 unsigned int i;
2148 unsigned int n = 0;
2149
2150 //wxLogDebug(wxT(">> %s.AdaptListToValue()"),GetBaseName().c_str());
2151
2152 for ( i=0; i<GetChildCount(); i++ )
2153 {
2154 const wxPGProperty* child = Item(i);
2155
2156 if ( childValue.GetName() == child->GetBaseName() )
2157 {
2158 //wxLogDebug(wxT(" %s(n=%i), %s"),childValue.GetName().c_str(),n,childValue.GetType().c_str());
2159
2160 if ( childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
2161 {
2162 wxVariant cv2(child->GetValue());
2163 child->AdaptListToValue(childValue, &cv2);
2164 childValue = cv2;
2165 }
2166
2167 if ( allChildrenSpecified )
2168 {
2169 *value = ChildChanged(*value, i, childValue);
2170 }
2171
2172 n++;
2173 if ( n == (unsigned int)list.GetCount() )
2174 break;
2175 childValue = list[n];
2176 }
2177 }
2178}
2179
2180
2181void wxPGProperty::FixIndicesOfChildren( unsigned int starthere )
2182{
2183 size_t i;
2184 for ( i=starthere;i<GetChildCount();i++)
2185 Item(i)->m_arrIndex = i;
2186}
2187
2188
2189// Returns (direct) child property with given name (or NULL if not found)
2190wxPGProperty* wxPGProperty::GetPropertyByName( const wxString& name ) const
2191{
2192 size_t i;
2193
2194 for ( i=0; i<GetChildCount(); i++ )
2195 {
2196 wxPGProperty* p = Item(i);
2197 if ( p->m_name == name )
2198 return p;
2199 }
2200
2201 // Does it have point, then?
2202 int pos = name.Find(wxS('.'));
2203 if ( pos <= 0 )
2204 return NULL;
2205
2206 wxPGProperty* p = GetPropertyByName(name. substr(0,pos));
2207
2208 if ( !p || !p->GetChildCount() )
2209 return NULL;
2210
2211 return p->GetPropertyByName(name.substr(pos+1,name.length()-pos-1));
2212}
2213
2214wxPGProperty* wxPGProperty::GetPropertyByNameWH( const wxString& name, unsigned int hintIndex ) const
2215{
2216 unsigned int i = hintIndex;
2217
2218 if ( i >= GetChildCount() )
2219 i = 0;
2220
2221 unsigned int lastIndex = i - 1;
2222
2223 if ( lastIndex >= GetChildCount() )
2224 lastIndex = GetChildCount() - 1;
2225
2226 for (;;)
2227 {
2228 wxPGProperty* p = Item(i);
2229 if ( p->m_name == name )
2230 return p;
2231
2232 if ( i == lastIndex )
2233 break;
2234
2235 i++;
2236 if ( i == GetChildCount() )
2237 i = 0;
2238 };
2239
2240 return NULL;
2241}
2242
2243int wxPGProperty::GetChildrenHeight( int lh, int iMax_ ) const
2244{
2245 // Returns height of children, recursively, and
2246 // by taking expanded/collapsed status into account.
2247 //
2248 // iMax is used when finding property y-positions.
2249 //
2250 unsigned int i = 0;
2251 int h = 0;
2252
2253 if ( iMax_ == -1 )
2254 iMax_ = GetChildCount();
2255
2256 unsigned int iMax = iMax_;
2257
2258 wxASSERT( iMax <= GetChildCount() );
2259
2260 if ( !IsExpanded() && GetParent() )
2261 return 0;
2262
2263 while ( i < iMax )
2264 {
2265 wxPGProperty* pwc = (wxPGProperty*) Item(i);
2266
2267 if ( !pwc->HasFlag(wxPG_PROP_HIDDEN) )
2268 {
2269 if ( !pwc->IsExpanded() ||
2270 pwc->GetChildCount() == 0 )
2271 h += lh;
2272 else
2273 h += pwc->GetChildrenHeight(lh) + lh;
2274 }
2275
2276 i++;
2277 }
2278
2279 return h;
2280}
2281
2282wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y,
2283 unsigned int lh,
2284 unsigned int* nextItemY ) const
2285{
2286 wxASSERT( nextItemY );
2287
2288 // Linear search at the moment
2289 //
2290 // nextItemY = y of next visible property, final value will be written back.
2291 wxPGProperty* result = NULL;
2292 wxPGProperty* current = NULL;
2293 unsigned int iy = *nextItemY;
2294 unsigned int i = 0;
2295 unsigned int iMax = GetChildCount();
2296
2297 while ( i < iMax )
2298 {
2299 wxPGProperty* pwc = Item(i);
2300
2301 if ( !pwc->HasFlag(wxPG_PROP_HIDDEN) )
2302 {
2303 // Found?
2304 if ( y < iy )
2305 {
2306 result = current;
2307 break;
2308 }
2309
2310 iy += lh;
2311
2312 if ( pwc->IsExpanded() &&
2313 pwc->GetChildCount() > 0 )
2314 {
2315 result = (wxPGProperty*) pwc->GetItemAtY( y, lh, &iy );
2316 if ( result )
2317 break;
2318 }
2319
2320 current = pwc;
2321 }
2322
2323 i++;
2324 }
2325
2326 // Found?
2327 if ( !result && y < iy )
2328 result = current;
2329
2330 *nextItemY = iy;
2331
2332 /*
2333 if ( current )
2334 {
2335 wxLogDebug(wxT("%s::GetItemAtY(%i) -> %s"),this->GetLabel().c_str(),y,current->GetLabel().c_str());
2336 }
2337 else
2338 {
2339 wxLogDebug(wxT("%s::GetItemAtY(%i) -> NULL"),this->GetLabel().c_str(),y);
2340 }
2341 */
2342
2343 return (wxPGProperty*) result;
2344}
2345
2346void wxPGProperty::Empty()
2347{
2348 size_t i;
2349 if ( !HasFlag(wxPG_PROP_CHILDREN_ARE_COPIES) )
2350 {
2351 for ( i=0; i<GetChildCount(); i++ )
2352 {
2353 delete m_children[i];
2354 }
2355 }
2356
2357 m_children.clear();
2358}
2359
2360wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y ) const
2361{
2362 unsigned int nextItem;
2363 return GetItemAtY( y, GetGrid()->GetRowHeight(), &nextItem);
2364}
2365
2366void wxPGProperty::DeleteChildren()
2367{
2368 wxPropertyGridPageState* state = m_parentState;
2369
2370 while ( GetChildCount() )
2371 {
2372 wxPGProperty* child = Item(GetChildCount()-1);
2373 state->DoDelete(child, true);
2374 }
2375}
2376
2377wxVariant wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
2378 int WXUNUSED(childIndex),
2379 wxVariant& WXUNUSED(childValue) ) const
2380{
2381 return wxNullVariant;
2382}
2383
2384bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
2385{
2386 unsigned int i;
2387
2388 const wxVariantList* pList = NULL;
2389 wxVariantList::const_iterator node;
2390
2391 if ( pendingList )
2392 {
2393 pList = &pendingList->GetList();
2394 node = pList->begin();
2395 }
2396
2397 for ( i=0; i<GetChildCount(); i++ )
2398 {
2399 wxPGProperty* child = Item(i);
2400 const wxVariant* listValue = NULL;
2401 wxVariant value;
2402
2403 if ( pendingList )
2404 {
2405 const wxString& childName = child->GetBaseName();
2406
2407 for ( ; node != pList->end(); ++node )
2408 {
2409 const wxVariant& item = *((const wxVariant*)*node);
2410 if ( item.GetName() == childName )
2411 {
2412 listValue = &item;
2413 value = item;
2414 break;
2415 }
2416 }
2417 }
2418
2419 if ( !listValue )
2420 value = child->GetValue();
2421
2422 if ( value.IsNull() )
2423 return false;
2424
2425 // Check recursively
2426 if ( child->GetChildCount() )
2427 {
2428 const wxVariant* childList = NULL;
2429
2430 if ( listValue && listValue->GetType() == wxPG_VARIANT_TYPE_LIST )
2431 childList = listValue;
2432
2433 if ( !child->AreAllChildrenSpecified((wxVariant*)childList) )
2434 return false;
2435 }
2436 }
2437
2438 return true;
2439}
2440
2441wxPGProperty* wxPGProperty::UpdateParentValues()
2442{
2443 wxPGProperty* parent = m_parent;
2444 if ( parent && parent->HasFlag(wxPG_PROP_COMPOSED_VALUE) &&
2445 !parent->IsCategory() && !parent->IsRoot() )
2446 {
2447 wxString s;
2448 parent->DoGenerateComposedValue(s);
2449 parent->m_value = s;
2450 return parent->UpdateParentValues();
2451 }
2452 return this;
2453}
2454
2455bool wxPGProperty::IsTextEditable() const
2456{
2457 if ( HasFlag(wxPG_PROP_READONLY) )
2458 return false;
2459
2460 if ( HasFlag(wxPG_PROP_NOEDITOR) &&
2461 (GetChildCount() ||
2462 wxString(GetEditorClass()->GetClassInfo()->GetClassName()).EndsWith(wxS("Button")))
2463 )
2464 return false;
2465
2466 return true;
2467}
2468
2469// Call after fixed sub-properties added/removed after creation.
2470// if oldSelInd >= 0 and < new max items, then selection is
2471// moved to it. Note: oldSelInd -2 indicates that this property
2472// should be selected.
2473void wxPGProperty::SubPropsChanged( int oldSelInd )
2474{
2475 wxPropertyGridPageState* state = GetParentState();
2476 wxPropertyGrid* grid = state->GetGrid();
2477
2478 //
2479 // Re-repare children (recursively)
2480 for ( unsigned int i=0; i<GetChildCount(); i++ )
2481 {
2482 wxPGProperty* child = Item(i);
2483 child->InitAfterAdded(state, grid);
2484 }
2485
2486 wxPGProperty* sel = NULL;
2487 if ( oldSelInd >= (int)m_children.size() )
2488 oldSelInd = (int)m_children.size() - 1;
2489
2490 if ( oldSelInd >= 0 )
2491 sel = m_children[oldSelInd];
2492 else if ( oldSelInd == -2 )
2493 sel = this;
2494
2495 if ( sel )
2496 state->DoSelectProperty(sel);
2497
2498 if ( state == grid->GetState() )
2499 {
2500 grid->GetPanel()->Refresh();
2501 }
2502}
2503
2504// -----------------------------------------------------------------------
2505// wxPGRootProperty
2506// -----------------------------------------------------------------------
2507
2508WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPGRootProperty,none,TextCtrl)
2509IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
2510
2511
2512wxPGRootProperty::wxPGRootProperty( const wxString& name )
2513 : wxPGProperty()
2514{
2515 m_name = name;
2516 m_label = m_name;
2517 SetParentalType(0);
2518 m_depth = 0;
2519}
2520
2521
2522wxPGRootProperty::~wxPGRootProperty()
2523{
2524}
2525
2526
2527// -----------------------------------------------------------------------
2528// wxPropertyCategory
2529// -----------------------------------------------------------------------
2530
2531WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPropertyCategory,none,TextCtrl)
2532IMPLEMENT_DYNAMIC_CLASS(wxPropertyCategory, wxPGProperty)
2533
2534void wxPropertyCategory::Init()
2535{
2536 // don't set colour - prepareadditem method should do this
2537 SetParentalType(wxPG_PROP_CATEGORY);
2538 m_capFgColIndex = 1;
2539 m_textExtent = -1;
2540}
2541
2542wxPropertyCategory::wxPropertyCategory()
2543 : wxPGProperty()
2544{
2545 Init();
2546}
2547
2548
2549wxPropertyCategory::wxPropertyCategory( const wxString &label, const wxString& name )
2550 : wxPGProperty(label,name)
2551{
2552 Init();
2553}
2554
2555
2556wxPropertyCategory::~wxPropertyCategory()
2557{
2558}
2559
2560
2561wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
2562 int WXUNUSED(argFlags) ) const
2563{
2564 return wxEmptyString;
2565}
2566
2567int wxPropertyCategory::GetTextExtent( const wxWindow* wnd, const wxFont& font ) const
2568{
2569 if ( m_textExtent > 0 )
2570 return m_textExtent;
2571 int x = 0, y = 0;
2572 ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font );
2573 return x;
2574}
2575
2576void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font )
2577{
2578 int x = 0, y = 0;
2579 wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font );
2580 m_textExtent = x;
2581}
2582
2583// -----------------------------------------------------------------------
2584// wxPGChoices
2585// -----------------------------------------------------------------------
2586
2587wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, int value )
2588{
2589 AllocExclusive();
2590
2591 wxPGChoiceEntry entry(label, value);
2592 return m_data->Insert( -1, entry );
2593}
2594
2595// -----------------------------------------------------------------------
2596
2597wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, const wxBitmap& bitmap, int value )
2598{
2599 AllocExclusive();
2600
2601 wxPGChoiceEntry entry(label, value);
2602 entry.SetBitmap(bitmap);
2603 return m_data->Insert( -1, entry );
2604}
2605
2606// -----------------------------------------------------------------------
2607
2608wxPGChoiceEntry& wxPGChoices::Insert( const wxPGChoiceEntry& entry, int index )
2609{
2610 AllocExclusive();
2611
2612 return m_data->Insert( index, entry );
2613}
2614
2615// -----------------------------------------------------------------------
2616
2617wxPGChoiceEntry& wxPGChoices::Insert( const wxString& label, int index, int value )
2618{
2619 AllocExclusive();
2620
2621 wxPGChoiceEntry entry(label, value);
2622 return m_data->Insert( index, entry );
2623}
2624
2625// -----------------------------------------------------------------------
2626
2627wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value )
2628{
2629 AllocExclusive();
2630
2631 size_t index = 0;
2632
2633 while ( index < GetCount() )
2634 {
2635 int cmpRes = GetLabel(index).Cmp(label);
2636 if ( cmpRes > 0 )
2637 break;
2638 index++;
2639 }
2640
2641 wxPGChoiceEntry entry(label, value);
2642 return m_data->Insert( index, entry );
2643}
2644
2645// -----------------------------------------------------------------------
2646
2647void wxPGChoices::Add( const wxChar** labels, const ValArrItem* values )
2648{
2649 AllocExclusive();
2650
2651 unsigned int itemcount = 0;
2652 const wxChar** p = &labels[0];
2653 while ( *p ) { p++; itemcount++; }
2654
2655 unsigned int i;
2656 for ( i = 0; i < itemcount; i++ )
2657 {
2658 int value = i;
2659 if ( values )
2660 value = values[i];
2661 wxPGChoiceEntry entry(labels[i], value);
2662 m_data->Insert( i, entry );
2663 }
2664}
2665
2666// -----------------------------------------------------------------------
2667
2668void wxPGChoices::Add( const wxArrayString& arr, const wxArrayInt& arrint )
2669{
2670 AllocExclusive();
2671
2672 unsigned int i;
2673 unsigned int itemcount = arr.size();
2674
2675 for ( i = 0; i < itemcount; i++ )
2676 {
2677 int value = i;
2678 if ( &arrint && arrint.size() )
2679 value = arrint[i];
2680 wxPGChoiceEntry entry(arr[i], value);
2681 m_data->Insert( i, entry );
2682 }
2683}
2684
2685// -----------------------------------------------------------------------
2686
2687void wxPGChoices::RemoveAt(size_t nIndex, size_t count)
2688{
2689 AllocExclusive();
2690
2691 wxASSERT( m_data->GetRefCount() != -1 );
2692 m_data->m_items.erase(m_data->m_items.begin()+nIndex,
2693 m_data->m_items.begin()+nIndex+count);
2694}
2695
2696// -----------------------------------------------------------------------
2697
2698void wxPGChoices::Clear()
2699{
2700 if ( m_data != wxPGChoicesEmptyData )
2701 {
2702 AllocExclusive();
2703 m_data->Clear();
2704 }
2705}
2706
2707// -----------------------------------------------------------------------
2708
2709int wxPGChoices::Index( const wxString& str ) const
2710{
2711 if ( IsOk() )
2712 {
2713 unsigned int i;
2714 for ( i=0; i< m_data->GetCount(); i++ )
2715 {
2716 const wxPGChoiceEntry& entry = m_data->Item(i);
2717 if ( entry.HasText() && entry.GetText() == str )
2718 return i;
2719 }
2720 }
2721 return -1;
2722}
2723
2724// -----------------------------------------------------------------------
2725
2726int wxPGChoices::Index( int val ) const
2727{
2728 if ( IsOk() )
2729 {
2730 unsigned int i;
2731 for ( i=0; i< m_data->GetCount(); i++ )
2732 {
2733 const wxPGChoiceEntry& entry = m_data->Item(i);
2734 if ( entry.GetValue() == val )
2735 return i;
2736 }
2737 }
2738 return -1;
2739}
2740
2741// -----------------------------------------------------------------------
2742
2743wxArrayString wxPGChoices::GetLabels() const
2744{
2745 wxArrayString arr;
2746 unsigned int i;
2747
2748 if ( this && IsOk() )
2749 for ( i=0; i<GetCount(); i++ )
2750 arr.push_back(GetLabel(i));
2751
2752 return arr;
2753}
2754
2755// -----------------------------------------------------------------------
2756
2757wxArrayInt wxPGChoices::GetValuesForStrings( const wxArrayString& strings ) const
2758{
2759 wxArrayInt arr;
2760
2761 if ( IsOk() )
2762 {
2763 unsigned int i;
2764 for ( i=0; i< strings.size(); i++ )
2765 {
2766 int index = Index(strings[i]);
2767 if ( index >= 0 )
2768 arr.Add(GetValue(index));
2769 else
2770 arr.Add(wxPG_INVALID_VALUE);
2771 }
2772 }
2773
2774 return arr;
2775}
2776
2777// -----------------------------------------------------------------------
2778
2779wxArrayInt wxPGChoices::GetIndicesForStrings( const wxArrayString& strings,
2780 wxArrayString* unmatched ) const
2781{
2782 wxArrayInt arr;
2783
2784 if ( IsOk() )
2785 {
2786 unsigned int i;
2787 for ( i=0; i< strings.size(); i++ )
2788 {
2789 const wxString& str = strings[i];
2790 int index = Index(str);
2791 if ( index >= 0 )
2792 arr.Add(index);
2793 else if ( unmatched )
2794 unmatched->Add(str);
2795 }
2796 }
2797
2798 return arr;
2799}
2800
2801// -----------------------------------------------------------------------
2802
2803void wxPGChoices::AllocExclusive()
2804{
2805 EnsureData();
2806
2807 if ( m_data->GetRefCount() != 1 )
2808 {
2809 wxPGChoicesData* data = new wxPGChoicesData();
2810 data->CopyDataFrom(m_data);
2811 Free();
2812 m_data = data;
2813 }
2814}
2815
2816// -----------------------------------------------------------------------
2817
2818void wxPGChoices::AssignData( wxPGChoicesData* data )
2819{
2820 Free();
2821
2822 if ( data != wxPGChoicesEmptyData )
2823 {
2824 m_data = data;
2825 data->IncRef();
2826 }
2827}
2828
2829// -----------------------------------------------------------------------
2830
2831void wxPGChoices::Init()
2832{
2833 m_data = wxPGChoicesEmptyData;
2834}
2835
2836// -----------------------------------------------------------------------
2837
2838void wxPGChoices::Free()
2839{
2840 if ( m_data != wxPGChoicesEmptyData )
2841 {
2842 m_data->DecRef();
2843 m_data = wxPGChoicesEmptyData;
2844 }
2845}
2846
2847// -----------------------------------------------------------------------
2848// wxPGAttributeStorage
2849// -----------------------------------------------------------------------
2850
2851wxPGAttributeStorage::wxPGAttributeStorage()
2852{
2853}
2854
2855wxPGAttributeStorage::~wxPGAttributeStorage()
2856{
2857 wxPGHashMapS2P::iterator it;
2858
2859 for ( it = m_map.begin(); it != m_map.end(); ++it )
2860 {
2861 wxVariantData* data = (wxVariantData*) it->second;
2862 data->DecRef();
2863 }
2864}
2865
2866void wxPGAttributeStorage::Set( const wxString& name, const wxVariant& value )
2867{
2868 wxVariantData* data = value.GetData();
2869
2870 // Free old, if any
2871 wxPGHashMapS2P::iterator it = m_map.find(name);
2872 if ( it != m_map.end() )
2873 {
2874 ((wxVariantData*)it->second)->DecRef();
2875
2876 if ( !data )
2877 {
2878 // If Null variant, just remove from set
2879 m_map.erase(it);
2880 return;
2881 }
2882 }
2883
2884 if ( data )
2885 {
2886 data->IncRef();
2887
2888 m_map[name] = data;
2889 }
2890}
2891
2892#endif // wxUSE_PROPGRID
wxWidgets (Impactor)