]> 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
fixing gdiplus implementation, see #11282
[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
616void wxPGProperty::SetName( const wxString& newName )
617{
618 wxPropertyGrid* pg = GetGrid();
619
620 if ( pg )
621 pg->SetPropertyName(this, newName);
622 else
623 DoSetName(newName);
624}
625
626wxString wxPGProperty::GetName() const
627{
628 wxPGProperty* parent = GetParent();
629
630 if ( !m_name.length() || !parent || parent->IsCategory() || parent->IsRoot() )
631 return m_name;
632
633 return m_parent->GetName() + wxS(".") + m_name;
634}
635
636wxPropertyGrid* wxPGProperty::GetGrid() const
637{
638 if ( !m_parentState )
639 return NULL;
640 return m_parentState->GetGrid();
641}
642
643int wxPGProperty::Index( const wxPGProperty* p ) const
644{
645 for ( unsigned int i = 0; i<m_children.size(); i++ )
646 {
647 if ( p == m_children[i] )
648 return i;
649 }
650 return wxNOT_FOUND;
651}
652
653bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const
654{
655 return true;
656}
657
658void wxPGProperty::OnSetValue()
659{
660}
661
662void wxPGProperty::RefreshChildren ()
663{
664}
665
666void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )
667{
668}
669
670void wxPGProperty::GetDisplayInfo( unsigned int column,
671 int choiceIndex,
672 int flags,
673 wxString* pString,
674 const wxPGCell** pCell )
675{
676 const wxPGCell* cell = NULL;
677
678 if ( !(flags & wxPGCellRenderer::ChoicePopup) )
679 {
680 // Not painting listi of choice popups, so get text from property
681 cell = &GetCell(column);
682 if ( cell->HasText() )
683 {
684 *pString = cell->GetText();
685 }
686 else
687 {
688 if ( column == 0 )
689 *pString = GetLabel();
690 else if ( column == 1 )
691 *pString = GetDisplayedString();
692 else if ( column == 2 )
693 *pString = GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
694 }
695 }
696 else
697 {
698 wxASSERT( column == 1 );
699
700 if ( choiceIndex != wxNOT_FOUND )
701 {
702 const wxPGChoiceEntry& entry = m_choices[choiceIndex];
703 if ( entry.GetBitmap().IsOk() ||
704 entry.GetFgCol().IsOk() ||
705 entry.GetBgCol().IsOk() )
706 cell = &entry;
707 *pString = m_choices.GetLabel(choiceIndex);
708 }
709 }
710
711 if ( !cell )
712 cell = &GetCell(column);
713
714 wxASSERT_MSG( cell->GetData(),
715 wxString::Format("Invalid cell for property %s",
716 GetName().c_str()) );
717
718 *pCell = cell;
719}
720
721/*
722wxString wxPGProperty::GetColumnText( unsigned int col, int choiceIndex ) const
723{
724
725 if ( col != 1 || choiceIndex == wxNOT_FOUND )
726 {
727 const wxPGCell& cell = GetCell(col);
728 if ( cell->HasText() )
729 {
730 return cell->GetText();
731 }
732 else
733 {
734 if ( col == 0 )
735 return GetLabel();
736 else if ( col == 1 )
737 return GetDisplayedString();
738 else if ( col == 2 )
739 return GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
740 }
741 }
742 else
743 {
744 // Use choice
745 return m_choices.GetLabel(choiceIndex);
746 }
747
748 return wxEmptyString;
749}
750*/
751
752void wxPGProperty::DoGenerateComposedValue( wxString& text,
753 int argFlags,
754 const wxVariantList* valueOverrides,
755 wxPGHashMapS2S* childResults ) const
756{
757 int i;
758 int iMax = m_children.size();
759
760 text.clear();
761 if ( iMax == 0 )
762 return;
763
764 if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
765 !(argFlags & wxPG_FULL_VALUE) )
766 iMax = PWC_CHILD_SUMMARY_LIMIT;
767
768 int iMaxMinusOne = iMax-1;
769
770 if ( !IsTextEditable() )
771 argFlags |= wxPG_UNEDITABLE_COMPOSITE_FRAGMENT;
772
773 wxPGProperty* curChild = m_children[0];
774
775 bool overridesLeft = false;
776 wxVariant overrideValue;
777 wxVariantList::const_iterator node;
778
779 if ( valueOverrides )
780 {
781 node = valueOverrides->begin();
782 if ( node != valueOverrides->end() )
783 {
784 overrideValue = *node;
785 overridesLeft = true;
786 }
787 }
788
789 for ( i = 0; i < iMax; i++ )
790 {
791 wxVariant childValue;
792
793 wxString childLabel = curChild->GetLabel();
794
795 // Check for value override
796 if ( overridesLeft && overrideValue.GetName() == childLabel )
797 {
798 if ( !overrideValue.IsNull() )
799 childValue = overrideValue;
800 else
801 childValue = curChild->GetValue();
802 ++node;
803 if ( node != valueOverrides->end() )
804 overrideValue = *node;
805 else
806 overridesLeft = false;
807 }
808 else
809 {
810 childValue = curChild->GetValue();
811 }
812
813 wxString s;
814 if ( !childValue.IsNull() )
815 {
816 if ( overridesLeft &&
817 curChild->HasFlag(wxPG_PROP_COMPOSED_VALUE) &&
818 childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
819 {
820 wxVariantList& childList = childValue.GetList();
821 DoGenerateComposedValue(s, argFlags|wxPG_COMPOSITE_FRAGMENT,
822 &childList, childResults);
823 }
824 else
825 {
826 s = curChild->ValueToString(childValue,
827 argFlags|wxPG_COMPOSITE_FRAGMENT);
828 }
829 }
830
831 if ( childResults && curChild->GetChildCount() )
832 (*childResults)[curChild->GetName()] = s;
833
834 bool skip = false;
835 if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && !s.length() )
836 skip = true;
837
838 if ( !curChild->GetChildCount() || skip )
839 text += s;
840 else
841 text += wxS("[") + s + wxS("]");
842
843 if ( i < iMaxMinusOne )
844 {
845 if ( text.length() > PWC_CHILD_SUMMARY_CHAR_LIMIT &&
846 !(argFlags & wxPG_EDITABLE_VALUE) &&
847 !(argFlags & wxPG_FULL_VALUE) )
848 break;
849
850 if ( !skip )
851 {
852 if ( !curChild->GetChildCount() )
853 text += wxS("; ");
854 else
855 text += wxS(" ");
856 }
857
858 curChild = m_children[i+1];
859 }
860 }
861
862 if ( (unsigned int)i < m_children.size() )
863 {
864 if ( !text.EndsWith(wxS("; ")) )
865 text += wxS("; ...");
866 else
867 text += wxS("...");
868 }
869}
870
871wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value),
872 int argFlags ) const
873{
874 wxCHECK_MSG( GetChildCount() > 0,
875 wxString(),
876 "If user property does not have any children, it must "
877 "override GetValueAsString" );
878
879 // FIXME: Currently code below only works if value is actually m_value
880 wxASSERT_MSG( argFlags & wxPG_VALUE_IS_CURRENT,
881 "Sorry, currently default wxPGProperty::ValueToString() "
882 "implementation only works if value is m_value." );
883
884 wxString text;
885 DoGenerateComposedValue(text, argFlags);
886 return text;
887}
888
889wxString wxPGProperty::GetValueAsString( int argFlags ) const
890{
891#if wxPG_COMPATIBILITY_1_4
892 // This is backwards compatibility test
893 // That is, to make sure this function is not overridden
894 // (instead, ValueToString() should be).
895 if ( argFlags == 0xFFFF )
896 {
897 // Do not override! (for backwards compliancy)
898 return g_invalidStringContent;
899 }
900#endif
901
902 if ( IsValueUnspecified() )
903 return wxEmptyString;
904
905 if ( m_commonValue == -1 )
906 {
907 wxVariant value(GetValue());
908 return ValueToString(value, argFlags|wxPG_VALUE_IS_CURRENT);
909 }
910
911 //
912 // Return common value's string representation
913 wxPropertyGrid* pg = GetGrid();
914 const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue);
915
916 if ( argFlags & wxPG_FULL_VALUE )
917 {
918 return cv->GetLabel();
919 }
920 else if ( argFlags & wxPG_EDITABLE_VALUE )
921 {
922 return cv->GetEditableText();
923 }
924 else
925 {
926 return cv->GetLabel();
927 }
928}
929
930wxString wxPGProperty::GetValueString( int argFlags ) const
931{
932 return GetValueAsString(argFlags);
933}
934
935bool wxPGProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
936{
937 variant = (long)number;
938 return true;
939}
940
941// Convert semicolon delimited tokens into child values.
942bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
943{
944 if ( !GetChildCount() )
945 return false;
946
947 unsigned int curChild = 0;
948
949 unsigned int iMax = m_children.size();
950
951 if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
952 !(argFlags & wxPG_FULL_VALUE) )
953 iMax = PWC_CHILD_SUMMARY_LIMIT;
954
955 bool changed = false;
956
957 wxString token;
958 size_t pos = 0;
959
960 // Its best only to add non-empty group items
961 bool addOnlyIfNotEmpty = false;
962 const wxChar delimeter = wxS(';');
963
964 size_t tokenStart = 0xFFFFFF;
965
966 wxVariantList temp_list;
967 wxVariant list(temp_list);
968
969 int propagatedFlags = argFlags & (wxPG_REPORT_ERROR|wxPG_PROGRAMMATIC_VALUE);
970
971 wxLogTrace("propgrid",
972 wxT(">> %s.StringToValue('%s')"), GetLabel(), text);
973
974 wxString::const_iterator it = text.begin();
975 wxUniChar a;
976
977 if ( it != text.end() )
978 a = *it;
979 else
980 a = 0;
981
982 for ( ;; )
983 {
984 // How many units we iterate string forward at the end of loop?
985 // We need to keep track of this or risk going to negative
986 // with it-- operation.
987 unsigned int strPosIncrement = 1;
988
989 if ( tokenStart != 0xFFFFFF )
990 {
991 // Token is running
992 if ( a == delimeter || a == 0 )
993 {
994 token = text.substr(tokenStart,pos-tokenStart);
995 token.Trim(true);
996 size_t len = token.length();
997
998 if ( !addOnlyIfNotEmpty || len > 0 )
999 {
1000 const wxPGProperty* child = Item(curChild);
1001 wxVariant variant(child->GetValue());
1002 wxString childName = child->GetBaseName();
1003
1004 wxLogTrace("propgrid",
1005 wxT("token = '%s', child = %s"),
1006 token, childName);
1007
1008 // Add only if editable or setting programmatically
1009 if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
1010 !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
1011 {
1012 if ( len > 0 )
1013 {
1014 if ( child->StringToValue(variant, token,
1015 propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
1016 {
1017 // We really need to set the variant's name
1018 // *after* child->StringToValue() has been
1019 // called, since variant's value may be set by
1020 // assigning another variant into it, which
1021 // then usually causes name to be copied (ie.
1022 // usually cleared) as well. wxBoolProperty
1023 // being case in point with its use of
1024 // wxPGVariant_Bool macro as an optimization.
1025 variant.SetName(childName);
1026 list.Append(variant);
1027
1028 changed = true;
1029 }
1030 }
1031 else
1032 {
1033 // Empty, becomes unspecified
1034 variant.MakeNull();
1035 variant.SetName(childName);
1036 list.Append(variant);
1037 changed = true;
1038 }
1039 }
1040
1041 curChild++;
1042 if ( curChild >= iMax )
1043 break;
1044 }
1045
1046 tokenStart = 0xFFFFFF;
1047 }
1048 }
1049 else
1050 {
1051 // Token is not running
1052 if ( a != wxS(' ') )
1053 {
1054
1055 addOnlyIfNotEmpty = false;
1056
1057 // Is this a group of tokens?
1058 if ( a == wxS('[') )
1059 {
1060 int depth = 1;
1061
1062 if ( it != text.end() ) ++it;
1063 pos++;
1064 size_t startPos = pos;
1065
1066 // Group item - find end
1067 while ( it != text.end() && depth > 0 )
1068 {
1069 a = *it;
1070 ++it;
1071 pos++;
1072
1073 if ( a == wxS(']') )
1074 depth--;
1075 else if ( a == wxS('[') )
1076 depth++;
1077 }
1078
1079 token = text.substr(startPos,pos-startPos-1);
1080
1081 if ( !token.length() )
1082 break;
1083
1084 const wxPGProperty* child = Item(curChild);
1085
1086 wxVariant oldChildValue = child->GetValue();
1087 wxVariant variant(oldChildValue);
1088
1089 if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
1090 !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
1091 {
1092 wxString childName = child->GetBaseName();
1093
1094 bool stvRes = child->StringToValue( variant, token,
1095 propagatedFlags );
1096 if ( stvRes || (variant != oldChildValue) )
1097 {
1098 variant.SetName(childName);
1099 list.Append(variant);
1100
1101 changed = true;
1102 }
1103 else
1104 {
1105 // No changes...
1106 }
1107 }
1108
1109 curChild++;
1110 if ( curChild >= iMax )
1111 break;
1112
1113 addOnlyIfNotEmpty = true;
1114
1115 tokenStart = 0xFFFFFF;
1116 }
1117 else
1118 {
1119 tokenStart = pos;
1120
1121 if ( a == delimeter )
1122 strPosIncrement -= 1;
1123 }
1124 }
1125 }
1126
1127 if ( a == 0 )
1128 break;
1129
1130 it += strPosIncrement;
1131
1132 if ( it != text.end() )
1133 {
1134 a = *it;
1135 }
1136 else
1137 {
1138 a = 0;
1139 }
1140
1141 pos += strPosIncrement;
1142 }
1143
1144 if ( changed )
1145 variant = list;
1146
1147 return changed;
1148}
1149
1150bool wxPGProperty::SetValueFromString( const wxString& text, int argFlags )
1151{
1152 wxVariant variant(m_value);
1153 bool res = StringToValue(variant, text, argFlags);
1154 if ( res )
1155 SetValue(variant);
1156 return res;
1157}
1158
1159bool wxPGProperty::SetValueFromInt( long number, int argFlags )
1160{
1161 wxVariant variant(m_value);
1162 bool res = IntToValue(variant, number, argFlags);
1163 if ( res )
1164 SetValue(variant);
1165 return res;
1166}
1167
1168wxSize wxPGProperty::OnMeasureImage( int WXUNUSED(item) ) const
1169{
1170 if ( m_valueBitmap )
1171 return wxSize(m_valueBitmap->GetWidth(),-1);
1172
1173 return wxSize(0,0);
1174}
1175
1176int wxPGProperty::GetImageOffset( int imageWidth ) const
1177{
1178 int imageOffset = 0;
1179
1180 if ( imageWidth )
1181 {
1182 // Do not increment offset too much for wide images
1183 if ( imageWidth <= (wxPG_CUSTOM_IMAGE_WIDTH+5) )
1184 imageOffset = imageWidth + DEFAULT_IMAGE_OFFSET_INCREMENT;
1185 else
1186 imageOffset = imageWidth + 1;
1187 }
1188
1189 return imageOffset;
1190}
1191
1192wxPGCellRenderer* wxPGProperty::GetCellRenderer( int WXUNUSED(column) ) const
1193{
1194 return wxPGGlobalVars->m_defaultRenderer;
1195}
1196
1197void wxPGProperty::OnCustomPaint( wxDC& dc,
1198 const wxRect& rect,
1199 wxPGPaintData& )
1200{
1201 wxBitmap* bmp = m_valueBitmap;
1202
1203 wxCHECK_RET( bmp && bmp->Ok(), wxT("invalid bitmap") );
1204
1205 wxCHECK_RET( rect.x >= 0, wxT("unexpected measure call") );
1206
1207 dc.DrawBitmap(*bmp,rect.x,rect.y);
1208}
1209
1210const wxPGEditor* wxPGProperty::DoGetEditorClass() const
1211{
1212 return wxPGEditor_TextCtrl;
1213}
1214
1215// Default extra property event handling - that is, none at all.
1216bool wxPGProperty::OnEvent( wxPropertyGrid*, wxWindow*, wxEvent& )
1217{
1218 return false;
1219}
1220
1221
1222void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
1223{
1224 // If auto unspecified values are not wanted (via window or property style),
1225 // then get default value instead of wxNullVariant.
1226 if ( value.IsNull() && (flags & wxPG_SETVAL_BY_USER) &&
1227 !UsesAutoUnspecified() )
1228 {
1229 value = GetDefaultValue();
1230 }
1231
1232 if ( !value.IsNull() )
1233 {
1234 wxVariant tempListVariant;
1235
1236 SetCommonValue(-1);
1237 // List variants are reserved a special purpose
1238 // as intermediate containers for child values
1239 // of properties with children.
1240 if ( value.GetType() == wxPG_VARIANT_TYPE_LIST )
1241 {
1242 //
1243 // However, situation is different for composed string properties
1244 if ( HasFlag(wxPG_PROP_COMPOSED_VALUE) )
1245 {
1246 tempListVariant = value;
1247 pList = &tempListVariant;
1248 }
1249
1250 wxVariant newValue;
1251 AdaptListToValue(value, &newValue);
1252 value = newValue;
1253 //wxLogDebug(wxT(">> %s.SetValue() adapted list value to type '%s'"),GetName().c_str(),value.GetType().c_str());
1254 }
1255
1256 if ( HasFlag( wxPG_PROP_AGGREGATE) )
1257 flags |= wxPG_SETVAL_AGGREGATED;
1258
1259 if ( pList && !pList->IsNull() )
1260 {
1261 wxASSERT( pList->GetType() == wxPG_VARIANT_TYPE_LIST );
1262 wxASSERT( GetChildCount() );
1263 wxASSERT( !IsCategory() );
1264
1265 wxVariantList& list = pList->GetList();
1266 wxVariantList::iterator node;
1267 unsigned int i = 0;
1268
1269 //wxLogDebug(wxT(">> %s.SetValue() pList parsing"),GetName().c_str());
1270
1271 // Children in list can be in any order, but we will give hint to
1272 // GetPropertyByNameWH(). This optimizes for full list parsing.
1273 for ( node = list.begin(); node != list.end(); ++node )
1274 {
1275 wxVariant& childValue = *((wxVariant*)*node);
1276 wxPGProperty* child = GetPropertyByNameWH(childValue.GetName(), i);
1277 if ( child )
1278 {
1279 //wxLogDebug(wxT("%i: child = %s, childValue.GetType()=%s"),i,child->GetBaseName().c_str(),childValue.GetType().c_str());
1280 if ( childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
1281 {
1282 if ( child->HasFlag(wxPG_PROP_AGGREGATE) && !(flags & wxPG_SETVAL_AGGREGATED) )
1283 {
1284 wxVariant listRefCopy = childValue;
1285 child->SetValue(childValue, &listRefCopy, flags|wxPG_SETVAL_FROM_PARENT);
1286 }
1287 else
1288 {
1289 wxVariant oldVal = child->GetValue();
1290 child->SetValue(oldVal, &childValue, flags|wxPG_SETVAL_FROM_PARENT);
1291 }
1292 }
1293 else if ( child->GetValue() != childValue )
1294 {
1295 // For aggregate properties, we will trust RefreshChildren()
1296 // to update child values.
1297 if ( !HasFlag(wxPG_PROP_AGGREGATE) )
1298 child->SetValue(childValue, NULL, flags|wxPG_SETVAL_FROM_PARENT);
1299 if ( flags & wxPG_SETVAL_BY_USER )
1300 child->SetFlag(wxPG_PROP_MODIFIED);
1301 }
1302 }
1303 i++;
1304 }
1305 }
1306
1307 if ( !value.IsNull() )
1308 {
1309 m_value = value;
1310 OnSetValue();
1311 }
1312
1313 if ( flags & wxPG_SETVAL_BY_USER )
1314 SetFlag(wxPG_PROP_MODIFIED);
1315
1316 if ( HasFlag(wxPG_PROP_AGGREGATE) )
1317 RefreshChildren();
1318 }
1319 else
1320 {
1321 if ( m_commonValue != -1 )
1322 {
1323 wxPropertyGrid* pg = GetGrid();
1324 if ( !pg || m_commonValue != pg->GetUnspecifiedCommonValue() )
1325 SetCommonValue(-1);
1326 }
1327
1328 m_value = value;
1329
1330 // Set children to unspecified, but only if aggregate or
1331 // value is <composed>
1332 if ( AreChildrenComponents() )
1333 {
1334 unsigned int i;
1335 for ( i=0; i<GetChildCount(); i++ )
1336 Item(i)->SetValue(value, NULL, flags|wxPG_SETVAL_FROM_PARENT);
1337 }
1338 }
1339
1340 if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
1341 UpdateParentValues();
1342
1343 //
1344 // Update editor control
1345 //
1346
1347 // We need to check for these, otherwise GetGrid() may fail.
1348 if ( flags & wxPG_SETVAL_REFRESH_EDITOR )
1349 {
1350 RefreshEditor();
1351 wxPropertyGrid* pg = GetGridIfDisplayed();
1352 if ( pg )
1353 pg->DrawItemAndValueRelated(this);
1354 }
1355}
1356
1357
1358void wxPGProperty::SetValueInEvent( wxVariant value ) const
1359{
1360 GetGrid()->ValueChangeInEvent(value);
1361}
1362
1363void wxPGProperty::SetFlagRecursively( FlagType flag, bool set )
1364{
1365 ChangeFlag(flag, set);
1366
1367 unsigned int i;
1368 for ( i = 0; i < GetChildCount(); i++ )
1369 Item(i)->SetFlagRecursively(flag, set);
1370}
1371
1372void wxPGProperty::RefreshEditor()
1373{
1374 if ( !m_parent )
1375 return;
1376
1377 wxPropertyGrid* pg = GetGrid();
1378 if ( pg && pg->GetSelectedProperty() == this )
1379 pg->RefreshEditor();
1380}
1381
1382wxVariant wxPGProperty::GetDefaultValue() const
1383{
1384 wxVariant defVal = GetAttribute(wxPG_ATTR_DEFAULT_VALUE);
1385 if ( !defVal.IsNull() )
1386 return defVal;
1387
1388 wxVariant value = GetValue();
1389
1390 if ( !value.IsNull() )
1391 {
1392 wxString valueType(value.GetType());
1393
1394 if ( valueType == wxPG_VARIANT_TYPE_LONG )
1395 return wxPGVariant_Zero;
1396 if ( valueType == wxPG_VARIANT_TYPE_STRING )
1397 return wxPGVariant_EmptyString;
1398 if ( valueType == wxPG_VARIANT_TYPE_BOOL )
1399 return wxPGVariant_False;
1400 if ( valueType == wxPG_VARIANT_TYPE_DOUBLE )
1401 return wxVariant(0.0);
1402 if ( valueType == wxPG_VARIANT_TYPE_ARRSTRING )
1403 return wxVariant(wxArrayString());
1404 if ( valueType == wxS("wxLongLong") )
1405 return WXVARIANT(wxLongLong(0));
1406 if ( valueType == wxS("wxULongLong") )
1407 return WXVARIANT(wxULongLong(0));
1408 if ( valueType == wxS("wxColour") )
1409 return WXVARIANT(*wxBLACK);
1410#if wxUSE_DATETIME
1411 if ( valueType == wxPG_VARIANT_TYPE_DATETIME )
1412 return wxVariant(wxDateTime::Now());
1413#endif
1414 if ( valueType == wxS("wxFont") )
1415 return WXVARIANT(*wxNORMAL_FONT);
1416 if ( valueType == wxS("wxPoint") )
1417 return WXVARIANT(wxPoint(0, 0));
1418 if ( valueType == wxS("wxSize") )
1419 return WXVARIANT(wxSize(0, 0));
1420 }
1421
1422 return wxVariant();
1423}
1424
1425void wxPGProperty::EnsureCells( unsigned int column )
1426{
1427 if ( column >= m_cells.size() )
1428 {
1429 // Fill empty slots with default cells
1430 wxPropertyGrid* pg = GetGrid();
1431 wxPGCell defaultCell;
1432
1433 // Work around possible VC6 bug by using intermediate variables
1434 const wxPGCell& propDefCell = pg->GetPropertyDefaultCell();
1435 const wxPGCell& catDefCell = pg->GetCategoryDefaultCell();
1436
1437 if ( !HasFlag(wxPG_PROP_CATEGORY) )
1438 defaultCell = propDefCell;
1439 else
1440 defaultCell = catDefCell;
1441
1442 // TODO: Replace with resize() call
1443 unsigned int cellCountMax = column+1;
1444
1445 for ( unsigned int i=m_cells.size(); i<cellCountMax; i++ )
1446 m_cells.push_back(defaultCell);
1447 }
1448}
1449
1450void wxPGProperty::SetCell( int column,
1451 const wxPGCell& cell )
1452{
1453 EnsureCells(column);
1454
1455 m_cells[column] = cell;
1456}
1457
1458void wxPGProperty::AdaptiveSetCell( unsigned int firstCol,
1459 unsigned int lastCol,
1460 const wxPGCell& cell,
1461 const wxPGCell& srcData,
1462 wxPGCellData* unmodCellData,
1463 FlagType ignoreWithFlags,
1464 bool recursively )
1465{
1466 //
1467 // Sets cell in memory optimizing fashion. That is, if
1468 // current cell data matches unmodCellData, we will
1469 // simply get reference to data from cell. Otherwise,
1470 // cell information from srcData is merged into current.
1471 //
1472
1473 if ( !(m_flags & ignoreWithFlags) && !IsRoot() )
1474 {
1475 EnsureCells(lastCol);
1476
1477 for ( unsigned int col=firstCol; col<=lastCol; col++ )
1478 {
1479 if ( m_cells[col].GetData() == unmodCellData )
1480 {
1481 // Data matches... use cell directly
1482 m_cells[col] = cell;
1483 }
1484 else
1485 {
1486 // Data did not match... merge valid information
1487 m_cells[col].MergeFrom(srcData);
1488 }
1489 }
1490 }
1491
1492 if ( recursively )
1493 {
1494 for ( unsigned int i=0; i<GetChildCount(); i++ )
1495 Item(i)->AdaptiveSetCell( firstCol,
1496 lastCol,
1497 cell,
1498 srcData,
1499 unmodCellData,
1500 ignoreWithFlags,
1501 recursively );
1502 }
1503}
1504
1505const wxPGCell& wxPGProperty::GetCell( unsigned int column ) const
1506{
1507 if ( m_cells.size() > column )
1508 return m_cells[column];
1509
1510 wxPropertyGrid* pg = GetGrid();
1511
1512 if ( IsCategory() )
1513 return pg->GetCategoryDefaultCell();
1514
1515 return pg->GetPropertyDefaultCell();
1516}
1517
1518wxPGCell& wxPGProperty::GetOrCreateCell( unsigned int column )
1519{
1520 EnsureCells(column);
1521 return m_cells[column];
1522}
1523
1524void wxPGProperty::SetBackgroundColour( const wxColour& colour,
1525 bool recursively )
1526{
1527 wxPGProperty* firstProp = this;
1528
1529 //
1530 // If category is tried to set recursively, skip it and only
1531 // affect the children.
1532 if ( recursively )
1533 {
1534 while ( firstProp->IsCategory() )
1535 {
1536 if ( !firstProp->GetChildCount() )
1537 return;
1538 firstProp = firstProp->Item(0);
1539 }
1540 }
1541
1542 wxPGCell& firstCell = firstProp->GetCell(0);
1543 wxPGCellData* firstCellData = firstCell.GetData();
1544
1545 wxPGCell newCell(firstCell);
1546 newCell.SetBgCol(colour);
1547 wxPGCell srcCell;
1548 srcCell.SetBgCol(colour);
1549
1550 AdaptiveSetCell( 0,
1551 GetParentState()->GetColumnCount()-1,
1552 newCell,
1553 srcCell,
1554 firstCellData,
1555 recursively ? wxPG_PROP_CATEGORY : 0,
1556 recursively );
1557}
1558
1559void wxPGProperty::SetTextColour( const wxColour& colour,
1560 bool recursively )
1561{
1562 wxPGProperty* firstProp = this;
1563
1564 //
1565 // If category is tried to set recursively, skip it and only
1566 // affect the children.
1567 if ( recursively )
1568 {
1569 while ( firstProp->IsCategory() )
1570 {
1571 if ( !firstProp->GetChildCount() )
1572 return;
1573 firstProp = firstProp->Item(0);
1574 }
1575 }
1576
1577 wxPGCell& firstCell = firstProp->GetCell(0);
1578 wxPGCellData* firstCellData = firstCell.GetData();
1579
1580 wxPGCell newCell(firstCell);
1581 newCell.SetFgCol(colour);
1582 wxPGCell srcCell;
1583 srcCell.SetFgCol(colour);
1584
1585 AdaptiveSetCell( 0,
1586 GetParentState()->GetColumnCount()-1,
1587 newCell,
1588 srcCell,
1589 firstCellData,
1590 recursively ? wxPG_PROP_CATEGORY : 0,
1591 recursively );
1592}
1593
1594wxPGEditorDialogAdapter* wxPGProperty::GetEditorDialog() const
1595{
1596 return NULL;
1597}
1598
1599bool wxPGProperty::DoSetAttribute( const wxString& WXUNUSED(name), wxVariant& WXUNUSED(value) )
1600{
1601 return false;
1602}
1603
1604void wxPGProperty::SetAttribute( const wxString& name, wxVariant value )
1605{
1606 if ( DoSetAttribute( name, value ) )
1607 {
1608 // Support working without grid, when possible
1609 if ( wxPGGlobalVars->HasExtraStyle( wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES ) )
1610 return;
1611 }
1612
1613 m_attributes.Set( name, value );
1614}
1615
1616void wxPGProperty::SetAttributes( const wxPGAttributeStorage& attributes )
1617{
1618 wxPGAttributeStorage::const_iterator it = attributes.StartIteration();
1619 wxVariant variant;
1620
1621 while ( attributes.GetNext(it, variant) )
1622 SetAttribute( variant.GetName(), variant );
1623}
1624
1625wxVariant wxPGProperty::DoGetAttribute( const wxString& WXUNUSED(name) ) const
1626{
1627 return wxVariant();
1628}
1629
1630
1631wxVariant wxPGProperty::GetAttribute( const wxString& name ) const
1632{
1633 return m_attributes.FindValue(name);
1634}
1635
1636wxString wxPGProperty::GetAttribute( const wxString& name, const wxString& defVal ) const
1637{
1638 wxVariant variant = m_attributes.FindValue(name);
1639
1640 if ( !variant.IsNull() )
1641 return variant.GetString();
1642
1643 return defVal;
1644}
1645
1646long wxPGProperty::GetAttributeAsLong( const wxString& name, long defVal ) const
1647{
1648 wxVariant variant = m_attributes.FindValue(name);
1649
1650 if ( variant.IsNull() )
1651 return defVal;
1652
1653 return variant.GetLong();
1654}
1655
1656double wxPGProperty::GetAttributeAsDouble( const wxString& name, double defVal ) const
1657{
1658 wxVariant variant = m_attributes.FindValue(name);
1659
1660 if ( variant.IsNull() )
1661 return defVal;
1662
1663 return variant.GetDouble();
1664}
1665
1666wxVariant wxPGProperty::GetAttributesAsList() const
1667{
1668 wxVariantList tempList;
1669 wxVariant v( tempList, wxString::Format(wxS("@%s@attr"),m_name.c_str()) );
1670
1671 wxPGAttributeStorage::const_iterator it = m_attributes.StartIteration();
1672 wxVariant variant;
1673
1674 while ( m_attributes.GetNext(it, variant) )
1675 v.Append(variant);
1676
1677 return v;
1678}
1679
1680// Slots of utility flags are NULL
1681const unsigned int gs_propFlagToStringSize = 14;
1682
1683static const wxChar* gs_propFlagToString[gs_propFlagToStringSize] = {
1684 NULL,
1685 wxT("DISABLED"),
1686 wxT("HIDDEN"),
1687 NULL,
1688 wxT("NOEDITOR"),
1689 wxT("COLLAPSED"),
1690 NULL,
1691 NULL,
1692 NULL,
1693 NULL,
1694 NULL,
1695 NULL,
1696 NULL,
1697 NULL
1698};
1699
1700wxString wxPGProperty::GetFlagsAsString( FlagType flagsMask ) const
1701{
1702 wxString s;
1703 int relevantFlags = m_flags & flagsMask & wxPG_STRING_STORED_FLAGS;
1704 FlagType a = 1;
1705
1706 unsigned int i = 0;
1707 for ( i=0; i<gs_propFlagToStringSize; i++ )
1708 {
1709 if ( relevantFlags & a )
1710 {
1711 const wxChar* fs = gs_propFlagToString[i];
1712 wxASSERT(fs);
1713 if ( s.length() )
1714 s << wxS("|");
1715 s << fs;
1716 }
1717 a = a << 1;
1718 }
1719
1720 return s;
1721}
1722
1723void wxPGProperty::SetFlagsFromString( const wxString& str )
1724{
1725 FlagType flags = 0;
1726
1727 WX_PG_TOKENIZER1_BEGIN(str, wxS('|'))
1728 unsigned int i;
1729 for ( i=0; i<gs_propFlagToStringSize; i++ )
1730 {
1731 const wxChar* fs = gs_propFlagToString[i];
1732 if ( fs && str == fs )
1733 {
1734 flags |= (1<<i);
1735 break;
1736 }
1737 }
1738 WX_PG_TOKENIZER1_END()
1739
1740 m_flags = (m_flags & ~wxPG_STRING_STORED_FLAGS) | flags;
1741}
1742
1743wxValidator* wxPGProperty::DoGetValidator() const
1744{
1745 return NULL;
1746}
1747
1748int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
1749{
1750 wxPropertyGrid* pg = GetGrid();
1751 int sel = GetChoiceSelection();
1752
1753 int newSel = sel;
1754
1755 if ( index == wxNOT_FOUND )
1756 index = m_choices.GetCount();
1757
1758 if ( index <= sel )
1759 newSel++;
1760
1761 m_choices.Insert(label, index, value);
1762
1763 if ( sel != newSel )
1764 SetChoiceSelection(newSel);
1765
1766 if ( this == pg->GetSelection() )
1767 GetEditorClass()->InsertItem(pg->GetEditorControl(),label,index);
1768
1769 return index;
1770}
1771
1772
1773void wxPGProperty::DeleteChoice( int index )
1774{
1775 wxPropertyGrid* pg = GetGrid();
1776
1777 int sel = GetChoiceSelection();
1778 int newSel = sel;
1779
1780 // Adjust current value
1781 if ( sel == index )
1782 {
1783 SetValueToUnspecified();
1784 newSel = 0;
1785 }
1786 else if ( index < sel )
1787 {
1788 newSel--;
1789 }
1790
1791 m_choices.RemoveAt(index);
1792
1793 if ( sel != newSel )
1794 SetChoiceSelection(newSel);
1795
1796 if ( this == pg->GetSelection() )
1797 GetEditorClass()->DeleteItem(pg->GetEditorControl(), index);
1798}
1799
1800int wxPGProperty::GetChoiceSelection() const
1801{
1802 wxVariant value = GetValue();
1803 wxString valueType = value.GetType();
1804 int index = wxNOT_FOUND;
1805
1806 if ( IsValueUnspecified() || !m_choices.GetCount() )
1807 return wxNOT_FOUND;
1808
1809 if ( valueType == wxPG_VARIANT_TYPE_LONG )
1810 {
1811 index = value.GetLong();
1812 }
1813 else if ( valueType == wxPG_VARIANT_TYPE_STRING )
1814 {
1815 index = m_choices.Index(value.GetString());
1816 }
1817 else if ( valueType == wxPG_VARIANT_TYPE_BOOL )
1818 {
1819 index = value.GetBool()? 1 : 0;
1820 }
1821
1822 return index;
1823}
1824
1825void wxPGProperty::SetChoiceSelection( int newValue )
1826{
1827 // Changes value of a property with choices, but only
1828 // works if the value type is long or string.
1829 wxString valueType = GetValue().GetType();
1830
1831 wxCHECK_RET( m_choices.IsOk(), wxT("invalid choiceinfo") );
1832
1833 if ( valueType == wxPG_VARIANT_TYPE_STRING )
1834 {
1835 SetValue( m_choices.GetLabel(newValue) );
1836 }
1837 else // if ( valueType == wxPG_VARIANT_TYPE_LONG )
1838 {
1839 SetValue( (long) newValue );
1840 }
1841}
1842
1843bool wxPGProperty::SetChoices( wxPGChoices& choices )
1844{
1845 m_choices.Assign(choices);
1846
1847 {
1848 // This may be needed to trigger some initialization
1849 // (but don't do it if property is somewhat uninitialized)
1850 wxVariant defVal = GetDefaultValue();
1851 if ( defVal.IsNull() )
1852 return false;
1853
1854 SetValue(defVal);
1855 }
1856
1857 return true;
1858}
1859
1860
1861const wxPGEditor* wxPGProperty::GetEditorClass() const
1862{
1863 const wxPGEditor* editor;
1864
1865 if ( !m_customEditor )
1866 {
1867 editor = DoGetEditorClass();
1868 }
1869 else
1870 editor = m_customEditor;
1871
1872 //
1873 // Maybe override editor if common value specified
1874 if ( GetDisplayedCommonValueCount() )
1875 {
1876 // TextCtrlAndButton -> ComboBoxAndButton
1877 if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlAndButtonEditor)) )
1878 editor = wxPGEditor_ChoiceAndButton;
1879
1880 // TextCtrl -> ComboBox
1881 else if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlEditor)) )
1882 editor = wxPGEditor_ComboBox;
1883 }
1884
1885 return editor;
1886}
1887
1888bool wxPGProperty::HasVisibleChildren() const
1889{
1890 unsigned int i;
1891
1892 for ( i=0; i<GetChildCount(); i++ )
1893 {
1894 wxPGProperty* child = Item(i);
1895
1896 if ( !child->HasFlag(wxPG_PROP_HIDDEN) )
1897 return true;
1898 }
1899
1900 return false;
1901}
1902
1903bool wxPGProperty::RecreateEditor()
1904{
1905 wxPropertyGrid* pg = GetGrid();
1906 wxASSERT(pg);
1907
1908 wxPGProperty* selected = pg->GetSelection();
1909 if ( this == selected )
1910 {
1911 pg->DoSelectProperty(this, wxPG_SEL_FORCE);
1912 return true;
1913 }
1914 return false;
1915}
1916
1917
1918void wxPGProperty::SetValueImage( wxBitmap& bmp )
1919{
1920 delete m_valueBitmap;
1921
1922 if ( &bmp && bmp.Ok() )
1923 {
1924 // Resize the image
1925 wxSize maxSz = GetGrid()->GetImageSize();
1926 wxSize imSz(bmp.GetWidth(),bmp.GetHeight());
1927
1928 if ( imSz.y != maxSz.y )
1929 {
1930 // Create a memory DC
1931 wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth());
1932
1933 wxMemoryDC dc;
1934 dc.SelectObject(*bmpNew);
1935
1936 // Scale
1937 // FIXME: This is ugly - use image or wait for scaling patch.
1938 double scaleY = (double)maxSz.y / (double)imSz.y;
1939
1940 dc.SetUserScale(scaleY, scaleY);
1941
1942 dc.DrawBitmap(bmp, 0, 0);
1943
1944 m_valueBitmap = bmpNew;
1945 }
1946 else
1947 {
1948 m_valueBitmap = new wxBitmap(bmp);
1949 }
1950
1951 m_flags |= wxPG_PROP_CUSTOMIMAGE;
1952 }
1953 else
1954 {
1955 m_valueBitmap = NULL;
1956 m_flags &= ~(wxPG_PROP_CUSTOMIMAGE);
1957 }
1958}
1959
1960
1961wxPGProperty* wxPGProperty::GetMainParent() const
1962{
1963 const wxPGProperty* curChild = this;
1964 const wxPGProperty* curParent = m_parent;
1965
1966 while ( curParent && !curParent->IsCategory() )
1967 {
1968 curChild = curParent;
1969 curParent = curParent->m_parent;
1970 }
1971
1972 return (wxPGProperty*) curChild;
1973}
1974
1975
1976const wxPGProperty* wxPGProperty::GetLastVisibleSubItem() const
1977{
1978 //
1979 // Returns last visible sub-item, recursively.
1980 if ( !IsExpanded() || !GetChildCount() )
1981 return this;
1982
1983 return Last()->GetLastVisibleSubItem();
1984}
1985
1986
1987bool wxPGProperty::IsVisible() const
1988{
1989 const wxPGProperty* parent;
1990
1991 if ( HasFlag(wxPG_PROP_HIDDEN) )
1992 return false;
1993
1994 for ( parent = GetParent(); parent != NULL; parent = parent->GetParent() )
1995 {
1996 if ( !parent->IsExpanded() || parent->HasFlag(wxPG_PROP_HIDDEN) )
1997 return false;
1998 }
1999
2000 return true;
2001}
2002
2003wxPropertyGrid* wxPGProperty::GetGridIfDisplayed() const
2004{
2005 wxPropertyGridPageState* state = GetParentState();
2006 if ( !state )
2007 return NULL;
2008 wxPropertyGrid* propGrid = state->GetGrid();
2009 if ( state == propGrid->GetState() )
2010 return propGrid;
2011 return NULL;
2012}
2013
2014
2015int wxPGProperty::GetY2( int lh ) const
2016{
2017 const wxPGProperty* parent;
2018 const wxPGProperty* child = this;
2019
2020 int y = 0;
2021
2022 for ( parent = GetParent(); parent != NULL; parent = child->GetParent() )
2023 {
2024 if ( !parent->IsExpanded() )
2025 return -1;
2026 y += parent->GetChildrenHeight(lh, child->GetIndexInParent());
2027 y += lh;
2028 child = parent;
2029 }
2030
2031 y -= lh; // need to reduce one level
2032
2033 return y;
2034}
2035
2036
2037int wxPGProperty::GetY() const
2038{
2039 return GetY2(GetGrid()->GetRowHeight());
2040}
2041
2042// This is used by Insert etc.
2043void wxPGProperty::DoAddChild( wxPGProperty* prop, int index,
2044 bool correct_mode )
2045{
2046 if ( index < 0 || (size_t)index >= m_children.size() )
2047 {
2048 if ( correct_mode ) prop->m_arrIndex = m_children.size();
2049 m_children.push_back( prop );
2050 }
2051 else
2052 {
2053 m_children.insert( m_children.begin()+index, prop);
2054 if ( correct_mode ) FixIndicesOfChildren( index );
2055 }
2056
2057 prop->m_parent = this;
2058}
2059
2060void wxPGProperty::DoPreAddChild( int index, wxPGProperty* prop )
2061{
2062 wxASSERT_MSG( prop->GetBaseName().length(),
2063 "Property's children must have unique, non-empty "
2064 "names within their scope" );
2065
2066 prop->m_arrIndex = index;
2067 m_children.insert( m_children.begin()+index,
2068 prop );
2069
2070 int custImgHeight = prop->OnMeasureImage().y;
2071 if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
2072 prop->m_flags |= wxPG_PROP_CUSTOMIMAGE;
2073
2074 prop->m_parent = this;
2075}
2076
2077void wxPGProperty::AddPrivateChild( wxPGProperty* prop )
2078{
2079 if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
2080 SetParentalType(wxPG_PROP_AGGREGATE);
2081
2082 wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
2083 wxPG_PROP_AGGREGATE,
2084 "Do not mix up AddPrivateChild() calls with other "
2085 "property adders." );
2086
2087 DoPreAddChild( m_children.size(), prop );
2088}
2089
2090#if wxPG_COMPATIBILITY_1_4
2091void wxPGProperty::AddChild( wxPGProperty* prop )
2092{
2093 AddPrivateChild(prop);
2094}
2095#endif
2096
2097wxPGProperty* wxPGProperty::InsertChild( int index,
2098 wxPGProperty* childProperty )
2099{
2100 if ( index < 0 )
2101 index = m_children.size();
2102
2103 if ( m_parentState )
2104 {
2105 m_parentState->DoInsert(this, index, childProperty);
2106 }
2107 else
2108 {
2109 if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
2110 SetParentalType(wxPG_PROP_MISC_PARENT);
2111
2112 wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
2113 wxPG_PROP_MISC_PARENT,
2114 "Do not mix up AddPrivateChild() calls with other "
2115 "property adders." );
2116
2117 DoPreAddChild( index, childProperty );
2118 }
2119
2120 return childProperty;
2121}
2122
2123void wxPGProperty::RemoveChild( wxPGProperty* p )
2124{
2125 wxArrayPGProperty::iterator it;
2126 wxArrayPGProperty& children = m_children;
2127
2128 for ( it=children.begin(); it != children.end(); it++ )
2129 {
2130 if ( *it == p )
2131 {
2132 children.erase(it);
2133 break;
2134 }
2135 }
2136}
2137
2138void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
2139{
2140 wxASSERT( GetChildCount() );
2141 wxASSERT( !IsCategory() );
2142
2143 *value = GetValue();
2144
2145 if ( !list.GetCount() )
2146 return;
2147
2148 wxASSERT( GetChildCount() >= (unsigned int)list.GetCount() );
2149
2150 bool allChildrenSpecified;
2151
2152 // Don't fully update aggregate properties unless all children have
2153 // specified value
2154 if ( HasFlag(wxPG_PROP_AGGREGATE) )
2155 allChildrenSpecified = AreAllChildrenSpecified(&list);
2156 else
2157 allChildrenSpecified = true;
2158
2159 wxVariant childValue = list[0];
2160 unsigned int i;
2161 unsigned int n = 0;
2162
2163 //wxLogDebug(wxT(">> %s.AdaptListToValue()"),GetBaseName().c_str());
2164
2165 for ( i=0; i<GetChildCount(); i++ )
2166 {
2167 const wxPGProperty* child = Item(i);
2168
2169 if ( childValue.GetName() == child->GetBaseName() )
2170 {
2171 //wxLogDebug(wxT(" %s(n=%i), %s"),childValue.GetName().c_str(),n,childValue.GetType().c_str());
2172
2173 if ( childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
2174 {
2175 wxVariant cv2(child->GetValue());
2176 child->AdaptListToValue(childValue, &cv2);
2177 childValue = cv2;
2178 }
2179
2180 if ( allChildrenSpecified )
2181 {
2182 *value = ChildChanged(*value, i, childValue);
2183 }
2184
2185 n++;
2186 if ( n == (unsigned int)list.GetCount() )
2187 break;
2188 childValue = list[n];
2189 }
2190 }
2191}
2192
2193
2194void wxPGProperty::FixIndicesOfChildren( unsigned int starthere )
2195{
2196 size_t i;
2197 for ( i=starthere;i<GetChildCount();i++)
2198 Item(i)->m_arrIndex = i;
2199}
2200
2201
2202// Returns (direct) child property with given name (or NULL if not found)
2203wxPGProperty* wxPGProperty::GetPropertyByName( const wxString& name ) const
2204{
2205 size_t i;
2206
2207 for ( i=0; i<GetChildCount(); i++ )
2208 {
2209 wxPGProperty* p = Item(i);
2210 if ( p->m_name == name )
2211 return p;
2212 }
2213
2214 // Does it have point, then?
2215 int pos = name.Find(wxS('.'));
2216 if ( pos <= 0 )
2217 return NULL;
2218
2219 wxPGProperty* p = GetPropertyByName(name. substr(0,pos));
2220
2221 if ( !p || !p->GetChildCount() )
2222 return NULL;
2223
2224 return p->GetPropertyByName(name.substr(pos+1,name.length()-pos-1));
2225}
2226
2227wxPGProperty* wxPGProperty::GetPropertyByNameWH( const wxString& name, unsigned int hintIndex ) const
2228{
2229 unsigned int i = hintIndex;
2230
2231 if ( i >= GetChildCount() )
2232 i = 0;
2233
2234 unsigned int lastIndex = i - 1;
2235
2236 if ( lastIndex >= GetChildCount() )
2237 lastIndex = GetChildCount() - 1;
2238
2239 for (;;)
2240 {
2241 wxPGProperty* p = Item(i);
2242 if ( p->m_name == name )
2243 return p;
2244
2245 if ( i == lastIndex )
2246 break;
2247
2248 i++;
2249 if ( i == GetChildCount() )
2250 i = 0;
2251 };
2252
2253 return NULL;
2254}
2255
2256int wxPGProperty::GetChildrenHeight( int lh, int iMax_ ) const
2257{
2258 // Returns height of children, recursively, and
2259 // by taking expanded/collapsed status into account.
2260 //
2261 // iMax is used when finding property y-positions.
2262 //
2263 unsigned int i = 0;
2264 int h = 0;
2265
2266 if ( iMax_ == -1 )
2267 iMax_ = GetChildCount();
2268
2269 unsigned int iMax = iMax_;
2270
2271 wxASSERT( iMax <= GetChildCount() );
2272
2273 if ( !IsExpanded() && GetParent() )
2274 return 0;
2275
2276 while ( i < iMax )
2277 {
2278 wxPGProperty* pwc = (wxPGProperty*) Item(i);
2279
2280 if ( !pwc->HasFlag(wxPG_PROP_HIDDEN) )
2281 {
2282 if ( !pwc->IsExpanded() ||
2283 pwc->GetChildCount() == 0 )
2284 h += lh;
2285 else
2286 h += pwc->GetChildrenHeight(lh) + lh;
2287 }
2288
2289 i++;
2290 }
2291
2292 return h;
2293}
2294
2295wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y,
2296 unsigned int lh,
2297 unsigned int* nextItemY ) const
2298{
2299 wxASSERT( nextItemY );
2300
2301 // Linear search at the moment
2302 //
2303 // nextItemY = y of next visible property, final value will be written back.
2304 wxPGProperty* result = NULL;
2305 wxPGProperty* current = NULL;
2306 unsigned int iy = *nextItemY;
2307 unsigned int i = 0;
2308 unsigned int iMax = GetChildCount();
2309
2310 while ( i < iMax )
2311 {
2312 wxPGProperty* pwc = Item(i);
2313
2314 if ( !pwc->HasFlag(wxPG_PROP_HIDDEN) )
2315 {
2316 // Found?
2317 if ( y < iy )
2318 {
2319 result = current;
2320 break;
2321 }
2322
2323 iy += lh;
2324
2325 if ( pwc->IsExpanded() &&
2326 pwc->GetChildCount() > 0 )
2327 {
2328 result = (wxPGProperty*) pwc->GetItemAtY( y, lh, &iy );
2329 if ( result )
2330 break;
2331 }
2332
2333 current = pwc;
2334 }
2335
2336 i++;
2337 }
2338
2339 // Found?
2340 if ( !result && y < iy )
2341 result = current;
2342
2343 *nextItemY = iy;
2344
2345 /*
2346 if ( current )
2347 {
2348 wxLogDebug(wxT("%s::GetItemAtY(%i) -> %s"),this->GetLabel().c_str(),y,current->GetLabel().c_str());
2349 }
2350 else
2351 {
2352 wxLogDebug(wxT("%s::GetItemAtY(%i) -> NULL"),this->GetLabel().c_str(),y);
2353 }
2354 */
2355
2356 return (wxPGProperty*) result;
2357}
2358
2359void wxPGProperty::Empty()
2360{
2361 size_t i;
2362 if ( !HasFlag(wxPG_PROP_CHILDREN_ARE_COPIES) )
2363 {
2364 for ( i=0; i<GetChildCount(); i++ )
2365 {
2366 delete m_children[i];
2367 }
2368 }
2369
2370 m_children.clear();
2371}
2372
2373wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y ) const
2374{
2375 unsigned int nextItem;
2376 return GetItemAtY( y, GetGrid()->GetRowHeight(), &nextItem);
2377}
2378
2379void wxPGProperty::DeleteChildren()
2380{
2381 wxPropertyGridPageState* state = m_parentState;
2382
2383 while ( GetChildCount() )
2384 {
2385 wxPGProperty* child = Item(GetChildCount()-1);
2386 state->DoDelete(child, true);
2387 }
2388}
2389
2390wxVariant wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
2391 int WXUNUSED(childIndex),
2392 wxVariant& WXUNUSED(childValue) ) const
2393{
2394 return wxNullVariant;
2395}
2396
2397bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
2398{
2399 unsigned int i;
2400
2401 const wxVariantList* pList = NULL;
2402 wxVariantList::const_iterator node;
2403
2404 if ( pendingList )
2405 {
2406 pList = &pendingList->GetList();
2407 node = pList->begin();
2408 }
2409
2410 for ( i=0; i<GetChildCount(); i++ )
2411 {
2412 wxPGProperty* child = Item(i);
2413 const wxVariant* listValue = NULL;
2414 wxVariant value;
2415
2416 if ( pendingList )
2417 {
2418 const wxString& childName = child->GetBaseName();
2419
2420 for ( ; node != pList->end(); ++node )
2421 {
2422 const wxVariant& item = *((const wxVariant*)*node);
2423 if ( item.GetName() == childName )
2424 {
2425 listValue = &item;
2426 value = item;
2427 break;
2428 }
2429 }
2430 }
2431
2432 if ( !listValue )
2433 value = child->GetValue();
2434
2435 if ( value.IsNull() )
2436 return false;
2437
2438 // Check recursively
2439 if ( child->GetChildCount() )
2440 {
2441 const wxVariant* childList = NULL;
2442
2443 if ( listValue && listValue->GetType() == wxPG_VARIANT_TYPE_LIST )
2444 childList = listValue;
2445
2446 if ( !child->AreAllChildrenSpecified((wxVariant*)childList) )
2447 return false;
2448 }
2449 }
2450
2451 return true;
2452}
2453
2454wxPGProperty* wxPGProperty::UpdateParentValues()
2455{
2456 wxPGProperty* parent = m_parent;
2457 if ( parent && parent->HasFlag(wxPG_PROP_COMPOSED_VALUE) &&
2458 !parent->IsCategory() && !parent->IsRoot() )
2459 {
2460 wxString s;
2461 parent->DoGenerateComposedValue(s);
2462 parent->m_value = s;
2463 return parent->UpdateParentValues();
2464 }
2465 return this;
2466}
2467
2468bool wxPGProperty::IsTextEditable() const
2469{
2470 if ( HasFlag(wxPG_PROP_READONLY) )
2471 return false;
2472
2473 if ( HasFlag(wxPG_PROP_NOEDITOR) &&
2474 (GetChildCount() ||
2475 wxString(GetEditorClass()->GetClassInfo()->GetClassName()).EndsWith(wxS("Button")))
2476 )
2477 return false;
2478
2479 return true;
2480}
2481
2482// Call after fixed sub-properties added/removed after creation.
2483// if oldSelInd >= 0 and < new max items, then selection is
2484// moved to it. Note: oldSelInd -2 indicates that this property
2485// should be selected.
2486void wxPGProperty::SubPropsChanged( int oldSelInd )
2487{
2488 wxPropertyGridPageState* state = GetParentState();
2489 wxPropertyGrid* grid = state->GetGrid();
2490
2491 //
2492 // Re-repare children (recursively)
2493 for ( unsigned int i=0; i<GetChildCount(); i++ )
2494 {
2495 wxPGProperty* child = Item(i);
2496 child->InitAfterAdded(state, grid);
2497 }
2498
2499 wxPGProperty* sel = NULL;
2500 if ( oldSelInd >= (int)m_children.size() )
2501 oldSelInd = (int)m_children.size() - 1;
2502
2503 if ( oldSelInd >= 0 )
2504 sel = m_children[oldSelInd];
2505 else if ( oldSelInd == -2 )
2506 sel = this;
2507
2508 if ( sel )
2509 state->DoSelectProperty(sel);
2510
2511 if ( state == grid->GetState() )
2512 {
2513 grid->GetPanel()->Refresh();
2514 }
2515}
2516
2517// -----------------------------------------------------------------------
2518// wxPGRootProperty
2519// -----------------------------------------------------------------------
2520
2521WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPGRootProperty,none,TextCtrl)
2522IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
2523
2524
2525wxPGRootProperty::wxPGRootProperty( const wxString& name )
2526 : wxPGProperty()
2527{
2528 m_name = name;
2529 m_label = m_name;
2530 SetParentalType(0);
2531 m_depth = 0;
2532}
2533
2534
2535wxPGRootProperty::~wxPGRootProperty()
2536{
2537}
2538
2539
2540// -----------------------------------------------------------------------
2541// wxPropertyCategory
2542// -----------------------------------------------------------------------
2543
2544WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPropertyCategory,none,TextCtrl)
2545IMPLEMENT_DYNAMIC_CLASS(wxPropertyCategory, wxPGProperty)
2546
2547void wxPropertyCategory::Init()
2548{
2549 // don't set colour - prepareadditem method should do this
2550 SetParentalType(wxPG_PROP_CATEGORY);
2551 m_capFgColIndex = 1;
2552 m_textExtent = -1;
2553}
2554
2555wxPropertyCategory::wxPropertyCategory()
2556 : wxPGProperty()
2557{
2558 Init();
2559}
2560
2561
2562wxPropertyCategory::wxPropertyCategory( const wxString &label, const wxString& name )
2563 : wxPGProperty(label,name)
2564{
2565 Init();
2566}
2567
2568
2569wxPropertyCategory::~wxPropertyCategory()
2570{
2571}
2572
2573
2574wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
2575 int WXUNUSED(argFlags) ) const
2576{
2577 return wxEmptyString;
2578}
2579
2580int wxPropertyCategory::GetTextExtent( const wxWindow* wnd, const wxFont& font ) const
2581{
2582 if ( m_textExtent > 0 )
2583 return m_textExtent;
2584 int x = 0, y = 0;
2585 ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font );
2586 return x;
2587}
2588
2589void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font )
2590{
2591 int x = 0, y = 0;
2592 wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font );
2593 m_textExtent = x;
2594}
2595
2596// -----------------------------------------------------------------------
2597// wxPGChoices
2598// -----------------------------------------------------------------------
2599
2600wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, int value )
2601{
2602 AllocExclusive();
2603
2604 wxPGChoiceEntry entry(label, value);
2605 return m_data->Insert( -1, entry );
2606}
2607
2608// -----------------------------------------------------------------------
2609
2610wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, const wxBitmap& bitmap, int value )
2611{
2612 AllocExclusive();
2613
2614 wxPGChoiceEntry entry(label, value);
2615 entry.SetBitmap(bitmap);
2616 return m_data->Insert( -1, entry );
2617}
2618
2619// -----------------------------------------------------------------------
2620
2621wxPGChoiceEntry& wxPGChoices::Insert( const wxPGChoiceEntry& entry, int index )
2622{
2623 AllocExclusive();
2624
2625 return m_data->Insert( index, entry );
2626}
2627
2628// -----------------------------------------------------------------------
2629
2630wxPGChoiceEntry& wxPGChoices::Insert( const wxString& label, int index, int value )
2631{
2632 AllocExclusive();
2633
2634 wxPGChoiceEntry entry(label, value);
2635 return m_data->Insert( index, entry );
2636}
2637
2638// -----------------------------------------------------------------------
2639
2640wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value )
2641{
2642 AllocExclusive();
2643
2644 size_t index = 0;
2645
2646 while ( index < GetCount() )
2647 {
2648 int cmpRes = GetLabel(index).Cmp(label);
2649 if ( cmpRes > 0 )
2650 break;
2651 index++;
2652 }
2653
2654 wxPGChoiceEntry entry(label, value);
2655 return m_data->Insert( index, entry );
2656}
2657
2658// -----------------------------------------------------------------------
2659
2660void wxPGChoices::Add( const wxChar** labels, const ValArrItem* values )
2661{
2662 AllocExclusive();
2663
2664 unsigned int itemcount = 0;
2665 const wxChar** p = &labels[0];
2666 while ( *p ) { p++; itemcount++; }
2667
2668 unsigned int i;
2669 for ( i = 0; i < itemcount; i++ )
2670 {
2671 int value = i;
2672 if ( values )
2673 value = values[i];
2674 wxPGChoiceEntry entry(labels[i], value);
2675 m_data->Insert( i, entry );
2676 }
2677}
2678
2679// -----------------------------------------------------------------------
2680
2681void wxPGChoices::Add( const wxArrayString& arr, const wxArrayInt& arrint )
2682{
2683 AllocExclusive();
2684
2685 unsigned int i;
2686 unsigned int itemcount = arr.size();
2687
2688 for ( i = 0; i < itemcount; i++ )
2689 {
2690 int value = i;
2691 if ( &arrint && arrint.size() )
2692 value = arrint[i];
2693 wxPGChoiceEntry entry(arr[i], value);
2694 m_data->Insert( i, entry );
2695 }
2696}
2697
2698// -----------------------------------------------------------------------
2699
2700void wxPGChoices::RemoveAt(size_t nIndex, size_t count)
2701{
2702 AllocExclusive();
2703
2704 wxASSERT( m_data->GetRefCount() != -1 );
2705 m_data->m_items.erase(m_data->m_items.begin()+nIndex,
2706 m_data->m_items.begin()+nIndex+count);
2707}
2708
2709// -----------------------------------------------------------------------
2710
2711void wxPGChoices::Clear()
2712{
2713 if ( m_data != wxPGChoicesEmptyData )
2714 {
2715 AllocExclusive();
2716 m_data->Clear();
2717 }
2718}
2719
2720// -----------------------------------------------------------------------
2721
2722int wxPGChoices::Index( const wxString& str ) const
2723{
2724 if ( IsOk() )
2725 {
2726 unsigned int i;
2727 for ( i=0; i< m_data->GetCount(); i++ )
2728 {
2729 const wxPGChoiceEntry& entry = m_data->Item(i);
2730 if ( entry.HasText() && entry.GetText() == str )
2731 return i;
2732 }
2733 }
2734 return -1;
2735}
2736
2737// -----------------------------------------------------------------------
2738
2739int wxPGChoices::Index( int val ) const
2740{
2741 if ( IsOk() )
2742 {
2743 unsigned int i;
2744 for ( i=0; i< m_data->GetCount(); i++ )
2745 {
2746 const wxPGChoiceEntry& entry = m_data->Item(i);
2747 if ( entry.GetValue() == val )
2748 return i;
2749 }
2750 }
2751 return -1;
2752}
2753
2754// -----------------------------------------------------------------------
2755
2756wxArrayString wxPGChoices::GetLabels() const
2757{
2758 wxArrayString arr;
2759 unsigned int i;
2760
2761 if ( this && IsOk() )
2762 for ( i=0; i<GetCount(); i++ )
2763 arr.push_back(GetLabel(i));
2764
2765 return arr;
2766}
2767
2768// -----------------------------------------------------------------------
2769
2770wxArrayInt wxPGChoices::GetValuesForStrings( const wxArrayString& strings ) const
2771{
2772 wxArrayInt arr;
2773
2774 if ( IsOk() )
2775 {
2776 unsigned int i;
2777 for ( i=0; i< strings.size(); i++ )
2778 {
2779 int index = Index(strings[i]);
2780 if ( index >= 0 )
2781 arr.Add(GetValue(index));
2782 else
2783 arr.Add(wxPG_INVALID_VALUE);
2784 }
2785 }
2786
2787 return arr;
2788}
2789
2790// -----------------------------------------------------------------------
2791
2792wxArrayInt wxPGChoices::GetIndicesForStrings( const wxArrayString& strings,
2793 wxArrayString* unmatched ) const
2794{
2795 wxArrayInt arr;
2796
2797 if ( IsOk() )
2798 {
2799 unsigned int i;
2800 for ( i=0; i< strings.size(); i++ )
2801 {
2802 const wxString& str = strings[i];
2803 int index = Index(str);
2804 if ( index >= 0 )
2805 arr.Add(index);
2806 else if ( unmatched )
2807 unmatched->Add(str);
2808 }
2809 }
2810
2811 return arr;
2812}
2813
2814// -----------------------------------------------------------------------
2815
2816void wxPGChoices::AllocExclusive()
2817{
2818 EnsureData();
2819
2820 if ( m_data->GetRefCount() != 1 )
2821 {
2822 wxPGChoicesData* data = new wxPGChoicesData();
2823 data->CopyDataFrom(m_data);
2824 Free();
2825 m_data = data;
2826 }
2827}
2828
2829// -----------------------------------------------------------------------
2830
2831void wxPGChoices::AssignData( wxPGChoicesData* data )
2832{
2833 Free();
2834
2835 if ( data != wxPGChoicesEmptyData )
2836 {
2837 m_data = data;
2838 data->IncRef();
2839 }
2840}
2841
2842// -----------------------------------------------------------------------
2843
2844void wxPGChoices::Init()
2845{
2846 m_data = wxPGChoicesEmptyData;
2847}
2848
2849// -----------------------------------------------------------------------
2850
2851void wxPGChoices::Free()
2852{
2853 if ( m_data != wxPGChoicesEmptyData )
2854 {
2855 m_data->DecRef();
2856 m_data = wxPGChoicesEmptyData;
2857 }
2858}
2859
2860// -----------------------------------------------------------------------
2861// wxPGAttributeStorage
2862// -----------------------------------------------------------------------
2863
2864wxPGAttributeStorage::wxPGAttributeStorage()
2865{
2866}
2867
2868wxPGAttributeStorage::~wxPGAttributeStorage()
2869{
2870 wxPGHashMapS2P::iterator it;
2871
2872 for ( it = m_map.begin(); it != m_map.end(); ++it )
2873 {
2874 wxVariantData* data = (wxVariantData*) it->second;
2875 data->DecRef();
2876 }
2877}
2878
2879void wxPGAttributeStorage::Set( const wxString& name, const wxVariant& value )
2880{
2881 wxVariantData* data = value.GetData();
2882
2883 // Free old, if any
2884 wxPGHashMapS2P::iterator it = m_map.find(name);
2885 if ( it != m_map.end() )
2886 {
2887 ((wxVariantData*)it->second)->DecRef();
2888
2889 if ( !data )
2890 {
2891 // If Null variant, just remove from set
2892 m_map.erase(it);
2893 return;
2894 }
2895 }
2896
2897 if ( data )
2898 {
2899 data->IncRef();
2900
2901 m_map[name] = data;
2902 }
2903}
2904
2905#endif // wxUSE_PROPGRID
wxWidgets (Impactor)