]> git.saurik.com Git - wxWidgets.git/blame - src/propgrid/property.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
better native types for carbon
[wxWidgets.git] / src / propgrid / property.cpp
CommitLineData
1c4293cb
VZ		 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
ea5af9c5 7// RCS-ID: $Id$
1c4293cb
VZ		 8// Copyright: (c) Jaakko Salli
9// Licence: wxWindows license
10/////////////////////////////////////////////////////////////////////////////
11
12// For compilers that support precompilation, includes "wx/wx.h".
13#include "wx/wxprec.h"
14
15#ifdef __BORLANDC__
16 #pragma hdrstop
17#endif
18
f4bc1aa2
JS		 19#if wxUSE_PROPGRID
20
1c4293cb
VZ		 21#ifndef WX_PRECOMP
22 #include "wx/defs.h"
23 #include "wx/object.h"
24 #include "wx/hash.h"
25 #include "wx/string.h"
26 #include "wx/log.h"
27 #include "wx/event.h"
28 #include "wx/window.h"
29 #include "wx/panel.h"
30 #include "wx/dc.h"
31 #include "wx/dcmemory.h"
1c4293cb
VZ		 32 #include "wx/pen.h"
33 #include "wx/brush.h"
1c4293cb 34 #include "wx/settings.h"
1c4293cb 35 #include "wx/intl.h"
1c4293cb
VZ		 36#endif
37
3b211af1 38#include "wx/propgrid/propgrid.h"
1c4293cb
VZ		 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
1425eca5
JS		 46#if wxPG_COMPATIBILITY_1_4
47
48// Used to establish backwards compatiblity
49const char* g_invalidStringContent = "@__TOTALLY_INVALID_STRING__@";
50
51#endif
1c4293cb
VZ		 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{
1c4293cb
VZ		 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{
1c4293cb
VZ		 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{
4aee8334 133 int imageWidth = 0;
1c4293cb 134
d7e2b522
JS		 135 // If possible, use cell colours
136 if ( !(flags & DontUseCellBgCol) )
1c4293cb 137 {
d7e2b522
JS		 138 dc.SetPen(cell.GetBgCol());
139 dc.SetBrush(cell.GetBgCol());
140 }
1c4293cb 141
d7e2b522
JS		 142 if ( !(flags & DontUseCellFgCol) )
143 {
144 dc.SetTextForeground(cell.GetFgCol());
1c4293cb
VZ		 145 }
146
a2851207
JS		 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);
d7e2b522 151
1c4293cb
VZ		 152 const wxBitmap& bmp = cell.GetBitmap();
153 if ( bmp.Ok() &&
d7e2b522
JS		 154 // Do not draw oversized bitmap outside choice popup
155 ((flags & ChoicePopup) || bmp.GetHeight() < rect.height )
1c4293cb
VZ		 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 );
4aee8334 162 imageWidth = bmp.GetWidth();
1c4293cb
VZ		 163 }
164
4aee8334 165 return imageWidth;
1c4293cb
VZ		 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;
d7e2b522 191 const wxPGCell* cell = NULL;
1c4293cb
VZ		 192
193 wxString text;
4aee8334 194 int imageWidth = 0;
d7e2b522 195 int preDrawFlags = flags;
1c4293cb 196
d7e2b522 197 property->GetDisplayInfo(column, item, flags, &text, &cell);
1c4293cb 198
4aee8334 199 imageWidth = PreDrawCell( dc, rect, *cell, preDrawFlags );
1c4293cb 200
d7e2b522 201 if ( column == 1 )
1c4293cb
VZ		 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
1c4293cb
VZ		 222 dc.SetPen( wxPen(propertyGrid->GetCellTextColour(), 1, wxSOLID) );
223
224 paintdata.m_drawnWidth = imageSize.x;
225 paintdata.m_drawnHeight = imageSize.y;
226
b7bc9d80 227 property->OnCustomPaint( dc, imageRect, paintdata );
1c4293cb 228
4aee8334 229 imageWidth = paintdata.m_drawnWidth;
1c4293cb
VZ		 230 }
231
1425eca5 232 text = property->GetValueAsString();
1c4293cb
VZ		 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 }
1c4293cb 254
4aee8334
JS		 255 int imageOffset = property->GetImageOffset(imageWidth);
256
1c4293cb
VZ		 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 {
4aee8334
JS		 264 if ( imageWidth > 0 )
265 {
266 imageOffset -= DEFAULT_IMAGE_OFFSET_INCREMENT;
267 imageWidth += wxCC_CUSTOM_IMAGE_MARGIN2 + 4;
268 }
1c4293cb
VZ		 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
d7e2b522
JS		 298// -----------------------------------------------------------------------
299// wxPGCellData
300// -----------------------------------------------------------------------
301
302wxPGCellData::wxPGCellData()
303 : wxObjectRefData()
304{
305 m_hasValidText = false;
306}
307
1c4293cb
VZ		 308// -----------------------------------------------------------------------
309// wxPGCell
310// -----------------------------------------------------------------------
311
312wxPGCell::wxPGCell()
d7e2b522 313 : wxObject()
1c4293cb
VZ		 314{
315}
316
317wxPGCell::wxPGCell( const wxString& text,
318 const wxBitmap& bitmap,
319 const wxColour& fgCol,
320 const wxColour& bgCol )
d7e2b522
JS		 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 )
1c4293cb 352{
d7e2b522
JS		 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());
1c4293cb
VZ		 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
d3b9f782 405 m_parentState = NULL;
1c4293cb
VZ		 406
407 m_clientData = NULL;
408 m_clientObject = NULL;
409
d3b9f782 410 m_customEditor = NULL;
1c4293cb 411#if wxUSE_VALIDATORS
d3b9f782 412 m_validator = NULL;
1c4293cb 413#endif
d3b9f782 414 m_valueBitmap = NULL;
1c4293cb
VZ		 415
416 m_maxLen = 0; // infinite maximum length
417
418 m_flags = wxPG_PROP_PROPERTY;
419
420 m_depth = 1;
1c4293cb
VZ		 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
2fd4a524
JS		 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
1425eca5
JS		 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
d7e2b522 461 if ( !parentIsRoot && !parent->IsCategory() )
2fd4a524 462 {
d7e2b522 463 m_cells = parent->m_cells;
2fd4a524
JS		 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 {
2fd4a524 541 // Check parental flags
48a32cf6
JS		 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" );
2fd4a524
JS		 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
1c4293cb
VZ		 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
1c4293cb
VZ		 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
f7a094e1
JS		 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}
1c4293cb 643
1c4293cb
VZ		 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
d8812c6e
JS		 657void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )
658{
659}
660
d7e2b522
JS		 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
1c4293cb 714{
d7e2b522
JS		 715
716 if ( col != 1 || choiceIndex == wxNOT_FOUND )
1c4293cb 717 {
d7e2b522
JS		 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 }
1c4293cb
VZ		 732 }
733 else
734 {
d7e2b522
JS		 735 // Use choice
736 return m_choices.GetLabel(choiceIndex);
1c4293cb
VZ		 737 }
738
739 return wxEmptyString;
740}
d7e2b522 741*/
1c4293cb 742
c82a80e8
JS		 743void wxPGProperty::DoGenerateComposedValue( wxString& text,
744 int argFlags,
745 const wxVariantList* valueOverrides,
746 wxPGHashMapS2S* childResults ) const
1c4293cb
VZ		 747{
748 int i;
f7a094e1 749 int iMax = m_children.size();
1c4293cb
VZ		 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
f7a094e1 764 wxPGProperty* curChild = m_children[0];
1c4293cb 765
1425eca5
JS		 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
1c4293cb
VZ		 780 for ( i = 0; i < iMax; i++ )
781 {
1425eca5
JS		 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();
b7bc9d80 793 ++node;
1425eca5
JS		 794 if ( node != valueOverrides->end() )
795 overrideValue = *node;
796 else
797 overridesLeft = false;
798 }
799 else
800 {
801 childValue = curChild->GetValue();
802 }
803
1c4293cb 804 wxString s;
1425eca5
JS		 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();
c82a80e8
JS		 812 DoGenerateComposedValue(s, argFlags|wxPG_COMPOSITE_FRAGMENT,
813 &childList, childResults);
1425eca5
JS		 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;
1c4293cb
VZ		 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
f7a094e1 849 curChild = m_children[i+1];
1c4293cb
VZ		 850 }
851 }
852
f7a094e1 853 if ( (unsigned int)i < m_children.size() )
7036fd20
JS		 854 {
855 if ( !text.EndsWith(wxS("; ")) )
856 text += wxS("; ...");
857 else
858 text += wxS("...");
859 }
1c4293cb
VZ		 860}
861
1425eca5
JS		 862wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value),
863 int argFlags ) const
1c4293cb
VZ		 864{
865 wxCHECK_MSG( GetChildCount() > 0,
866 wxString(),
1425eca5
JS		 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." );
1c4293cb
VZ		 874
875 wxString text;
c82a80e8 876 DoGenerateComposedValue(text, argFlags);
1c4293cb
VZ		 877 return text;
878}
879
1425eca5 880wxString wxPGProperty::GetValueAsString( int argFlags ) const
1c4293cb 881{
1425eca5
JS		 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
1c4293cb
VZ		 893 if ( IsValueUnspecified() )
894 return wxEmptyString;
895
896 if ( m_commonValue == -1 )
1425eca5
JS		 897 {
898 wxVariant value(GetValue());
899 return ValueToString(value, argFlags|wxPG_VALUE_IS_CURRENT);
900 }
1c4293cb
VZ		 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
1425eca5
JS		 921wxString wxPGProperty::GetValueString( int argFlags ) const
922{
923 return GetValueAsString(argFlags);
924}
925
1c4293cb
VZ		 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
f7a094e1 940 unsigned int iMax = m_children.size();
1c4293cb
VZ		 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
f275b5db 960 int propagatedFlags = argFlags & (wxPG_REPORT_ERROR|wxPG_PROGRAMMATIC_VALUE);
1c4293cb 961
4b6a582b
VZ		 962 wxLogTrace("propgrid",
963 wxT(">> %s.StringToValue('%s')"), GetLabel(), text);
1c4293cb
VZ		 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 {
a64a1bf7
JS		 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
1c4293cb
VZ		 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);
f275b5db 992 wxVariant variant(child->GetValue());
ae82388e 993 wxString childName = child->GetBaseName();
f275b5db 994
4b6a582b
VZ		 995 wxLogTrace("propgrid",
996 wxT("token = '%s', child = %s"),
997 token, childName);
1c4293cb 998
f275b5db
JS		 999 // Add only if editable or setting programmatically
1000 if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
1001 !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
1c4293cb 1002 {
f275b5db 1003 if ( len > 0 )
1c4293cb 1004 {
ae82388e
JS		 1005 if ( child->StringToValue(variant, token,
1006 propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
1c4293cb 1007 {
ae82388e
JS		 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);
f275b5db 1017 list.Append(variant);
1c4293cb 1018
f275b5db
JS		 1019 changed = true;
1020 }
1021 }
1022 else
1023 {
1024 // Empty, becomes unspecified
1025 variant.MakeNull();
ae82388e 1026 variant.SetName(childName);
f275b5db 1027 list.Append(variant);
1c4293cb
VZ		 1028 changed = true;
1029 }
1030 }
1c4293cb
VZ		 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
b7bc9d80 1053 if ( it != text.end() ) ++it;
1c4293cb
VZ		 1054 pos++;
1055 size_t startPos = pos;
1056
1057 // Group item - find end
1058 while ( it != text.end() && depth > 0 )
1059 {
1060 a = *it;
b7bc9d80 1061 ++it;
1c4293cb
VZ		 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
2bbd3749
JS		 1077 wxVariant oldChildValue = child->GetValue();
1078 wxVariant variant(oldChildValue);
f275b5db
JS		 1079
1080 if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
1081 !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
1c4293cb 1082 {
a64a1bf7
JS		 1083 wxString childName = child->GetBaseName();
1084
1085 bool stvRes = child->StringToValue( variant, token,
1086 propagatedFlags );
f275b5db
JS		 1087 if ( stvRes || (variant != oldChildValue) )
1088 {
a64a1bf7
JS		 1089 variant.SetName(childName);
1090 list.Append(variant);
1091
1092 changed = true;
f275b5db
JS		 1093 }
1094 else
1095 {
a64a1bf7 1096 // No changes...
f275b5db 1097 }
1c4293cb
VZ		 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 )
a64a1bf7 1113 strPosIncrement -= 1;
1c4293cb
VZ		 1114 }
1115 }
1116 }
1117
1118 if ( a == 0 )
1119 break;
1120
a64a1bf7
JS		 1121 it += strPosIncrement;
1122
1c4293cb
VZ		 1123 if ( it != text.end() )
1124 {
1125 a = *it;
1126 }
1127 else
1128 {
1129 a = 0;
1130 }
a64a1bf7
JS		 1131
1132 pos += strPosIncrement;
1c4293cb
VZ		 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
4aee8334
JS		 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
1c4293cb
VZ		 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{
c26873c8 1203 return wxPGEditor_TextCtrl;
1c4293cb
VZ		 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{
104837f2
JS		 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
1c4293cb
VZ		 1223 if ( !value.IsNull() )
1224 {
8f18b252
JS		 1225 wxVariant tempListVariant;
1226
1c4293cb
VZ		 1227 SetCommonValue(-1);
1228 // List variants are reserved a special purpose
1229 // as intermediate containers for child values
1230 // of properties with children.
0372d42e 1231 if ( value.GetType() == wxPG_VARIANT_TYPE_LIST )
1c4293cb 1232 {
8f18b252
JS		 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
1c4293cb
VZ		 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 {
0372d42e 1252 wxASSERT( pList->GetType() == wxPG_VARIANT_TYPE_LIST );
1c4293cb
VZ		 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
d665918b 1263 // GetPropertyByNameWH(). This optimizes for full list parsing.
b7bc9d80 1264 for ( node = list.begin(); node != list.end(); ++node )
1c4293cb
VZ		 1265 {
1266 wxVariant& childValue = *((wxVariant*)*node);
d665918b 1267 wxPGProperty* child = GetPropertyByNameWH(childValue.GetName(), i);
1c4293cb
VZ		 1268 if ( child )
1269 {
d665918b 1270 //wxLogDebug(wxT("%i: child = %s, childValue.GetType()=%s"),i,child->GetBaseName().c_str(),childValue.GetType().c_str());
0372d42e 1271 if ( childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
1c4293cb
VZ		 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 }
0372d42e 1284 else if ( child->GetValue() != childValue )
1c4293cb
VZ		 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);
8f18b252
JS		 1290 if ( flags & wxPG_SETVAL_BY_USER )
1291 child->SetFlag(wxPG_PROP_MODIFIED);
1c4293cb
VZ		 1292 }
1293 }
1294 i++;
1295 }
1296 }
1297
1298 if ( !value.IsNull() )
1299 {
0372d42e 1300 m_value = value;
1c4293cb 1301 OnSetValue();
1c4293cb
VZ		 1302 }
1303
8f18b252 1304 if ( flags & wxPG_SETVAL_BY_USER )
1c4293cb
VZ		 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
daeb4e4d
JS		 1331 if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
1332 UpdateParentValues();
1333
1c4293cb
VZ		 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 )
e777bd14 1340 {
1c4293cb 1341 RefreshEditor();
e777bd14
JS		 1342 wxPropertyGrid* pg = GetGridIfDisplayed();
1343 if ( pg )
1344 pg->DrawItemAndValueRelated(this);
1345 }
1c4293cb
VZ		 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 if ( set )
1357 SetFlag(flag);
1358 else
1359 ClearFlag(flag);
1360
1361 unsigned int i;
1362 for ( i = 0; i < GetChildCount(); i++ )
1363 Item(i)->SetFlagRecursively(flag, set);
1364}
1365
1366void wxPGProperty::RefreshEditor()
1367{
f521bae6
JS		 1368 if ( !m_parent )
1369 return;
1c4293cb 1370
f521bae6
JS		 1371 wxPropertyGrid* pg = GetGrid();
1372 if ( pg && pg->GetSelectedProperty() == this )
a6353fe8 1373 pg->RefreshEditor();
f521bae6 1374}
1c4293cb
VZ		 1375
1376wxVariant wxPGProperty::GetDefaultValue() const
1377{
1378 wxVariant defVal = GetAttribute(wxS("DefaultValue"));
1379 if ( !defVal.IsNull() )
1380 return defVal;
1381
1382 wxVariant value = GetValue();
1383
1384 if ( !value.IsNull() )
1385 {
0372d42e
JS		 1386 wxString valueType(value.GetType());
1387
1388 if ( valueType == wxPG_VARIANT_TYPE_LONG )
1c4293cb 1389 return wxPGVariant_Zero;
0372d42e 1390 if ( valueType == wxPG_VARIANT_TYPE_STRING )
1c4293cb 1391 return wxPGVariant_EmptyString;
0372d42e 1392 if ( valueType == wxPG_VARIANT_TYPE_BOOL )
1c4293cb 1393 return wxPGVariant_False;
0372d42e 1394 if ( valueType == wxPG_VARIANT_TYPE_DOUBLE )
1c4293cb 1395 return wxVariant(0.0);
0372d42e 1396 if ( valueType == wxPG_VARIANT_TYPE_ARRSTRING )
1c4293cb 1397 return wxVariant(wxArrayString());
0372d42e
JS		 1398 if ( valueType == wxS("wxLongLong") )
1399 return WXVARIANT(wxLongLong(0));
1400 if ( valueType == wxS("wxULongLong") )
1401 return WXVARIANT(wxULongLong(0));
1402 if ( valueType == wxS("wxColour") )
1403 return WXVARIANT(*wxBLACK);
1c4293cb 1404#if wxUSE_DATETIME
0372d42e 1405 if ( valueType == wxPG_VARIANT_TYPE_DATETIME )
1c4293cb
VZ		 1406 return wxVariant(wxDateTime::Now());
1407#endif
0372d42e
JS		 1408 if ( valueType == wxS("wxFont") )
1409 return WXVARIANT(*wxNORMAL_FONT);
1410 if ( valueType == wxS("wxPoint") )
1411 return WXVARIANT(wxPoint(0, 0));
1412 if ( valueType == wxS("wxSize") )
1413 return WXVARIANT(wxSize(0, 0));
1c4293cb
VZ		 1414 }
1415
1416 return wxVariant();
1417}
1418
d7e2b522
JS		 1419void wxPGProperty::EnsureCells( unsigned int column )
1420{
1421 if ( column >= m_cells.size() )
1422 {
1423 // Fill empty slots with default cells
1424 wxPropertyGrid* pg = GetGrid();
1425 wxPGCell defaultCell;
1426
1427 if ( !HasFlag(wxPG_PROP_CATEGORY) )
1428 defaultCell = pg->GetPropertyDefaultCell();
1429 else
1430 defaultCell = pg->GetCategoryDefaultCell();
1431
1432 // TODO: Replace with resize() call
1433 unsigned int cellCountMax = column+1;
1434
1435 for ( unsigned int i=m_cells.size(); i<cellCountMax; i++ )
1436 m_cells.push_back(defaultCell);
1437 }
1438}
1439
1440void wxPGProperty::SetCell( int column,
1441 const wxPGCell& cell )
1442{
1443 EnsureCells(column);
1444
1445 m_cells[column] = cell;
1446}
1447
1448void wxPGProperty::AdaptiveSetCell( unsigned int firstCol,
1449 unsigned int lastCol,
1450 const wxPGCell& cell,
1451 const wxPGCell& srcData,
1452 wxPGCellData* unmodCellData,
1453 FlagType ignoreWithFlags,
1454 bool recursively )
1455{
1456 //
1457 // Sets cell in memory optimizing fashion. That is, if
1458 // current cell data matches unmodCellData, we will
1459 // simply get reference to data from cell. Otherwise,
1460 // cell information from srcData is merged into current.
1461 //
1462
1463 if ( !(m_flags & ignoreWithFlags) && !IsRoot() )
1464 {
1465 EnsureCells(lastCol);
1466
1467 for ( unsigned int col=firstCol; col<=lastCol; col++ )
1468 {
1469 if ( m_cells[col].GetData() == unmodCellData )
1470 {
1471 // Data matches... use cell directly
1472 m_cells[col] = cell;
1473 }
1474 else
1475 {
1476 // Data did not match... merge valid information
1477 m_cells[col].MergeFrom(srcData);
1478 }
1479 }
1480 }
1481
1482 if ( recursively )
1483 {
1484 for ( unsigned int i=0; i<GetChildCount(); i++ )
1485 Item(i)->AdaptiveSetCell( firstCol,
1486 lastCol,
1487 cell,
1488 srcData,
1489 unmodCellData,
1490 ignoreWithFlags,
1491 recursively );
1492 }
1493}
1494
1495const wxPGCell& wxPGProperty::GetCell( unsigned int column ) const
1c4293cb 1496{
d7e2b522
JS		 1497 if ( m_cells.size() > column )
1498 return m_cells[column];
1499
1500 wxPropertyGrid* pg = GetGrid();
1501
1502 if ( IsCategory() )
1503 return pg->GetCategoryDefaultCell();
1504
1505 return pg->GetPropertyDefaultCell();
1506}
1507
1508wxPGCell& wxPGProperty::GetCell( unsigned int column )
1509{
1510 EnsureCells(column);
1511 return m_cells[column];
1512}
1513
1514void wxPGProperty::SetBackgroundColour( const wxColour& colour,
1515 bool recursively )
1516{
1517 wxPGProperty* firstProp = this;
1518
1519 //
1520 // If category is tried to set recursively, skip it and only
1521 // affect the children.
1522 if ( recursively )
1523 {
1524 while ( firstProp->IsCategory() )
1525 {
1526 if ( !firstProp->GetChildCount() )
1527 return;
1528 firstProp = firstProp->Item(0);
1529 }
1530 }
1531
1532 wxPGCell& firstCell = firstProp->GetCell(0);
1533 wxPGCellData* firstCellData = firstCell.GetData();
1534
1535 wxPGCell newCell(firstCell);
1536 newCell.SetBgCol(colour);
1537 wxPGCell srcCell;
1538 srcCell.SetBgCol(colour);
1539
1540 AdaptiveSetCell( 0,
1541 GetParentState()->GetColumnCount()-1,
1542 newCell,
1543 srcCell,
1544 firstCellData,
1545 recursively ? wxPG_PROP_CATEGORY : 0,
1546 recursively );
1547}
1548
1549void wxPGProperty::SetTextColour( const wxColour& colour,
1550 bool recursively )
1551{
1552 wxPGProperty* firstProp = this;
1553
1554 //
1555 // If category is tried to set recursively, skip it and only
1556 // affect the children.
1557 if ( recursively )
1558 {
1559 while ( firstProp->IsCategory() )
1560 {
1561 if ( !firstProp->GetChildCount() )
1562 return;
1563 firstProp = firstProp->Item(0);
1564 }
1565 }
1c4293cb 1566
d7e2b522
JS		 1567 wxPGCell& firstCell = firstProp->GetCell(0);
1568 wxPGCellData* firstCellData = firstCell.GetData();
1569
1570 wxPGCell newCell(firstCell);
1571 newCell.SetFgCol(colour);
1572 wxPGCell srcCell;
1573 srcCell.SetFgCol(colour);
1574
1575 AdaptiveSetCell( 0,
1576 GetParentState()->GetColumnCount()-1,
1577 newCell,
1578 srcCell,
1579 firstCellData,
1580 recursively ? wxPG_PROP_CATEGORY : 0,
1581 recursively );
1c4293cb
VZ		 1582}
1583
1c4293cb
VZ		 1584wxPGEditorDialogAdapter* wxPGProperty::GetEditorDialog() const
1585{
1586 return NULL;
1587}
1588
1589bool wxPGProperty::DoSetAttribute( const wxString& WXUNUSED(name), wxVariant& WXUNUSED(value) )
1590{
1591 return false;
1592}
1593
1594void wxPGProperty::SetAttribute( const wxString& name, wxVariant value )
1595{
1596 if ( DoSetAttribute( name, value ) )
1597 {
1598 // Support working without grid, when possible
1599 if ( wxPGGlobalVars->HasExtraStyle( wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES ) )
1600 return;
1601 }
1602
1603 m_attributes.Set( name, value );
1604}
1605
1606void wxPGProperty::SetAttributes( const wxPGAttributeStorage& attributes )
1607{
1608 wxPGAttributeStorage::const_iterator it = attributes.StartIteration();
1609 wxVariant variant;
1610
1611 while ( attributes.GetNext(it, variant) )
1612 SetAttribute( variant.GetName(), variant );
1613}
1614
1615wxVariant wxPGProperty::DoGetAttribute( const wxString& WXUNUSED(name) ) const
1616{
1617 return wxVariant();
1618}
1619
1620
1621wxVariant wxPGProperty::GetAttribute( const wxString& name ) const
1622{
1623 return m_attributes.FindValue(name);
1624}
1625
1626wxString wxPGProperty::GetAttribute( const wxString& name, const wxString& defVal ) const
1627{
1628 wxVariant variant = m_attributes.FindValue(name);
1629
1630 if ( !variant.IsNull() )
1631 return variant.GetString();
1632
1633 return defVal;
1634}
1635
1636long wxPGProperty::GetAttributeAsLong( const wxString& name, long defVal ) const
1637{
1638 wxVariant variant = m_attributes.FindValue(name);
1639
1640 return wxPGVariantToInt(variant, defVal);
1641}
1642
1643double wxPGProperty::GetAttributeAsDouble( const wxString& name, double defVal ) const
1644{
1645 double retVal;
1646 wxVariant variant = m_attributes.FindValue(name);
1647
1648 if ( wxPGVariantToDouble(variant, &retVal) )
1649 return retVal;
1650
1651 return defVal;
1652}
1653
1654wxVariant wxPGProperty::GetAttributesAsList() const
1655{
1656 wxVariantList tempList;
1657 wxVariant v( tempList, wxString::Format(wxS("@%s@attr"),m_name.c_str()) );
1658
1659 wxPGAttributeStorage::const_iterator it = m_attributes.StartIteration();
1660 wxVariant variant;
1661
1662 while ( m_attributes.GetNext(it, variant) )
1663 v.Append(variant);
1664
1665 return v;
1666}
1667
1668// Slots of utility flags are NULL
1669const unsigned int gs_propFlagToStringSize = 14;
1670
1671static const wxChar* gs_propFlagToString[gs_propFlagToStringSize] = {
1672 NULL,
1673 wxT("DISABLED"),
1674 wxT("HIDDEN"),
1675 NULL,
1676 wxT("NOEDITOR"),
1677 wxT("COLLAPSED"),
1678 NULL,
1679 NULL,
1680 NULL,
1681 NULL,
1682 NULL,
1683 NULL,
1684 NULL,
1685 NULL
1686};
1687
1688wxString wxPGProperty::GetFlagsAsString( FlagType flagsMask ) const
1689{
1690 wxString s;
1691 int relevantFlags = m_flags & flagsMask & wxPG_STRING_STORED_FLAGS;
1692 FlagType a = 1;
1693
1694 unsigned int i = 0;
1695 for ( i=0; i<gs_propFlagToStringSize; i++ )
1696 {
1697 if ( relevantFlags & a )
1698 {
1699 const wxChar* fs = gs_propFlagToString[i];
1700 wxASSERT(fs);
1701 if ( s.length() )
1702 s << wxS("|");
1703 s << fs;
1704 }
1705 a = a << 1;
1706 }
1707
1708 return s;
1709}
1710
1711void wxPGProperty::SetFlagsFromString( const wxString& str )
1712{
1713 FlagType flags = 0;
1714
1715 WX_PG_TOKENIZER1_BEGIN(str, wxS('|'))
1716 unsigned int i;
1717 for ( i=0; i<gs_propFlagToStringSize; i++ )
1718 {
1719 const wxChar* fs = gs_propFlagToString[i];
1720 if ( fs && str == fs )
1721 {
1722 flags |= (1<<i);
1723 break;
1724 }
1725 }
1726 WX_PG_TOKENIZER1_END()
1727
1728 m_flags = (m_flags & ~wxPG_STRING_STORED_FLAGS) | flags;
1729}
1730
1731wxValidator* wxPGProperty::DoGetValidator() const
1732{
d3b9f782 1733 return NULL;
1c4293cb
VZ		 1734}
1735
939d9364 1736int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
1c4293cb 1737{
939d9364
JS		 1738 wxPropertyGrid* pg = GetGrid();
1739 int sel = GetChoiceSelection();
1740
1741 int newSel = sel;
1742
1743 if ( index == wxNOT_FOUND )
1744 index = m_choices.GetCount();
1745
1746 if ( index <= sel )
1747 newSel++;
1748
1749 m_choices.Insert(label, index, value);
1750
1751 if ( sel != newSel )
1752 SetChoiceSelection(newSel);
1753
1754 if ( this == pg->GetSelection() )
1755 GetEditorClass()->InsertItem(pg->GetEditorControl(),label,index);
1756
1757 return index;
1c4293cb
VZ		 1758}
1759
939d9364
JS		 1760
1761void wxPGProperty::DeleteChoice( int index )
1c4293cb 1762{
939d9364
JS		 1763 wxPropertyGrid* pg = GetGrid();
1764
1765 int sel = GetChoiceSelection();
1766 int newSel = sel;
1767
1768 // Adjust current value
1769 if ( sel == index )
1770 {
1771 SetValueToUnspecified();
1772 newSel = 0;
1773 }
1774 else if ( index < sel )
1775 {
1776 newSel--;
1777 }
1778
1779 m_choices.RemoveAt(index);
1780
1781 if ( sel != newSel )
1782 SetChoiceSelection(newSel);
1783
1784 if ( this == pg->GetSelection() )
1785 GetEditorClass()->DeleteItem(pg->GetEditorControl(), index);
1c4293cb
VZ		 1786}
1787
939d9364 1788int wxPGProperty::GetChoiceSelection() const
1c4293cb 1789{
939d9364
JS		 1790 wxVariant value = GetValue();
1791 wxString valueType = value.GetType();
1792 int index = wxNOT_FOUND;
1793
1794 if ( IsValueUnspecified() || !m_choices.GetCount() )
1795 return wxNOT_FOUND;
1796
1797 if ( valueType == wxPG_VARIANT_TYPE_LONG )
1798 {
1799 index = value.GetLong();
1800 }
1801 else if ( valueType == wxPG_VARIANT_TYPE_STRING )
1802 {
1803 index = m_choices.Index(value.GetString());
1804 }
1805 else if ( valueType == wxPG_VARIANT_TYPE_BOOL )
1806 {
1807 index = value.GetBool()? 1 : 0;
1808 }
1809
1810 return index;
1c4293cb
VZ		 1811}
1812
939d9364 1813void wxPGProperty::SetChoiceSelection( int newValue )
1c4293cb 1814{
939d9364
JS		 1815 // Changes value of a property with choices, but only
1816 // works if the value type is long or string.
1817 wxString valueType = GetValue().GetType();
1818
1819 wxCHECK_RET( m_choices.IsOk(), wxT("invalid choiceinfo") );
1c4293cb 1820
939d9364
JS		 1821 if ( valueType == wxPG_VARIANT_TYPE_STRING )
1822 {
1823 SetValue( m_choices.GetLabel(newValue) );
1824 }
1825 else // if ( valueType == wxPG_VARIANT_TYPE_LONG )
1826 {
1827 SetValue( (long) newValue );
1828 }
1c4293cb
VZ		 1829}
1830
1831bool wxPGProperty::SetChoices( wxPGChoices& choices )
1832{
939d9364 1833 m_choices.Assign(choices);
1c4293cb 1834
1c4293cb 1835 {
939d9364
JS		 1836 // This may be needed to trigger some initialization
1837 // (but don't do it if property is somewhat uninitialized)
1838 wxVariant defVal = GetDefaultValue();
1839 if ( defVal.IsNull() )
1840 return false;
1c4293cb 1841
939d9364 1842 SetValue(defVal);
1c4293cb 1843 }
939d9364
JS		 1844
1845 return true;
1c4293cb
VZ		 1846}
1847
1848
1849const wxPGEditor* wxPGProperty::GetEditorClass() const
1850{
1851 const wxPGEditor* editor;
1852
1853 if ( !m_customEditor )
1854 {
1855 editor = DoGetEditorClass();
1856 }
1857 else
1858 editor = m_customEditor;
1859
1860 //
1861 // Maybe override editor if common value specified
1862 if ( GetDisplayedCommonValueCount() )
1863 {
1864 // TextCtrlAndButton -> ComboBoxAndButton
1865 if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlAndButtonEditor)) )
c26873c8 1866 editor = wxPGEditor_ChoiceAndButton;
1c4293cb
VZ		 1867
1868 // TextCtrl -> ComboBox
1869 else if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlEditor)) )
c26873c8 1870 editor = wxPGEditor_ComboBox;
1c4293cb
VZ		 1871 }
1872
1873 return editor;
1874}
1875
1c4293cb
VZ		 1876bool wxPGProperty::HasVisibleChildren() const
1877{
1878 unsigned int i;
1879
1880 for ( i=0; i<GetChildCount(); i++ )
1881 {
1882 wxPGProperty* child = Item(i);
1883
1884 if ( !child->HasFlag(wxPG_PROP_HIDDEN) )
1885 return true;
1886 }
1887
1888 return false;
1889}
1890
1c4293cb
VZ		 1891bool wxPGProperty::RecreateEditor()
1892{
1893 wxPropertyGrid* pg = GetGrid();
1894 wxASSERT(pg);
1895
1896 wxPGProperty* selected = pg->GetSelection();
1897 if ( this == selected )
1898 {
1899 pg->DoSelectProperty(this, wxPG_SEL_FORCE);
1900 return true;
1901 }
1902 return false;
1903}
1904
1905
1906void wxPGProperty::SetValueImage( wxBitmap& bmp )
1907{
1908 delete m_valueBitmap;
1909
1910 if ( &bmp && bmp.Ok() )
1911 {
1912 // Resize the image
1913 wxSize maxSz = GetGrid()->GetImageSize();
1914 wxSize imSz(bmp.GetWidth(),bmp.GetHeight());
1915
4aee8334 1916 if ( imSz.y != maxSz.y )
1c4293cb
VZ		 1917 {
1918 // Create a memory DC
1919 wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth());
1920
1921 wxMemoryDC dc;
1922 dc.SelectObject(*bmpNew);
1923
1924 // Scale
1925 // FIXME: This is ugly - use image or wait for scaling patch.
1c4293cb
VZ		 1926 double scaleY = (double)maxSz.y / (double)imSz.y;
1927
4aee8334 1928 dc.SetUserScale(scaleY, scaleY);
1c4293cb 1929
4aee8334 1930 dc.DrawBitmap(bmp, 0, 0);
1c4293cb
VZ		 1931
1932 m_valueBitmap = bmpNew;
1933 }
1934 else
1935 {
1936 m_valueBitmap = new wxBitmap(bmp);
1937 }
1938
1939 m_flags |= wxPG_PROP_CUSTOMIMAGE;
1940 }
1941 else
1942 {
1943 m_valueBitmap = NULL;
1944 m_flags &= ~(wxPG_PROP_CUSTOMIMAGE);
1945 }
1946}
1947
1948
1949wxPGProperty* wxPGProperty::GetMainParent() const
1950{
1951 const wxPGProperty* curChild = this;
1952 const wxPGProperty* curParent = m_parent;
1953
1954 while ( curParent && !curParent->IsCategory() )
1955 {
1956 curChild = curParent;
1957 curParent = curParent->m_parent;
1958 }
1959
1960 return (wxPGProperty*) curChild;
1961}
1962
1963
1964const wxPGProperty* wxPGProperty::GetLastVisibleSubItem() const
1965{
1966 //
1967 // Returns last visible sub-item, recursively.
1968 if ( !IsExpanded() || !GetChildCount() )
1969 return this;
1970
1971 return Last()->GetLastVisibleSubItem();
1972}
1973
1974
1975bool wxPGProperty::IsVisible() const
1976{
1977 const wxPGProperty* parent;
1978
1979 if ( HasFlag(wxPG_PROP_HIDDEN) )
1980 return false;
1981
1982 for ( parent = GetParent(); parent != NULL; parent = parent->GetParent() )
1983 {
1984 if ( !parent->IsExpanded() || parent->HasFlag(wxPG_PROP_HIDDEN) )
1985 return false;
1986 }
1987
1988 return true;
1989}
1990
1991wxPropertyGrid* wxPGProperty::GetGridIfDisplayed() const
1992{
1993 wxPropertyGridPageState* state = GetParentState();
e777bd14
JS		 1994 if ( !state )
1995 return NULL;
1c4293cb
VZ		 1996 wxPropertyGrid* propGrid = state->GetGrid();
1997 if ( state == propGrid->GetState() )
1998 return propGrid;
1999 return NULL;
2000}
2001
2002
2003int wxPGProperty::GetY2( int lh ) const
2004{
2005 const wxPGProperty* parent;
2006 const wxPGProperty* child = this;
2007
2008 int y = 0;
2009
2010 for ( parent = GetParent(); parent != NULL; parent = child->GetParent() )
2011 {
2012 if ( !parent->IsExpanded() )
2013 return -1;
2014 y += parent->GetChildrenHeight(lh, child->GetIndexInParent());
2015 y += lh;
2016 child = parent;
2017 }
2018
2019 y -= lh; // need to reduce one level
2020
2021 return y;
2022}
2023
2024
2025int wxPGProperty::GetY() const
2026{
2027 return GetY2(GetGrid()->GetRowHeight());
2028}
2029
1c4293cb 2030// This is used by Insert etc.
48a32cf6
JS		 2031void wxPGProperty::DoAddChild( wxPGProperty* prop, int index,
2032 bool correct_mode )
1c4293cb 2033{
f7a094e1 2034 if ( index < 0 || (size_t)index >= m_children.size() )
1c4293cb 2035 {
f7a094e1
JS		 2036 if ( correct_mode ) prop->m_arrIndex = m_children.size();
2037 m_children.push_back( prop );
1c4293cb
VZ		 2038 }
2039 else
2040 {
f7a094e1 2041 m_children.insert( m_children.begin()+index, prop);
1b895132 2042 if ( correct_mode ) FixIndicesOfChildren( index );
1c4293cb
VZ		 2043 }
2044
2045 prop->m_parent = this;
2046}
2047
48a32cf6 2048void wxPGProperty::DoPreAddChild( int index, wxPGProperty* prop )
1c4293cb 2049{
d665918b 2050 wxASSERT_MSG( prop->GetBaseName().length(),
48a32cf6
JS		 2051 "Property's children must have unique, non-empty "
2052 "names within their scope" );
d665918b 2053
48a32cf6
JS		 2054 prop->m_arrIndex = index;
2055 m_children.insert( m_children.begin()+index,
2056 prop );
1c4293cb
VZ		 2057
2058 int custImgHeight = prop->OnMeasureImage().y;
2059 if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
2060 prop->m_flags |= wxPG_PROP_CUSTOMIMAGE;
2061
2062 prop->m_parent = this;
2063}
2064
48a32cf6
JS		 2065void wxPGProperty::AddPrivateChild( wxPGProperty* prop )
2066{
2067 if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
2068 SetParentalType(wxPG_PROP_AGGREGATE);
2069
2070 wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
2071 wxPG_PROP_AGGREGATE,
2072 "Do not mix up AddPrivateChild() calls with other "
2073 "property adders." );
2074
2075 DoPreAddChild( m_children.size(), prop );
2076}
2077
2078#if wxPG_COMPATIBILITY_1_4
2079void wxPGProperty::AddChild( wxPGProperty* prop )
2080{
2081 AddPrivateChild(prop);
2082}
2083#endif
2084
2085wxPGProperty* wxPGProperty::InsertChild( int index,
2086 wxPGProperty* childProperty )
2087{
2088 if ( index < 0 )
2089 index = m_children.size();
2090
2091 if ( m_parentState )
2092 {
2093 m_parentState->DoInsert(this, index, childProperty);
2094 }
2095 else
2096 {
2097 if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) )
2098 SetParentalType(wxPG_PROP_MISC_PARENT);
2099
2100 wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) ==
2101 wxPG_PROP_MISC_PARENT,
2102 "Do not mix up AddPrivateChild() calls with other "
2103 "property adders." );
2104
2105 DoPreAddChild( index, childProperty );
2106 }
2107
2108 return childProperty;
2109}
2110
d8c74d04
JS		 2111void wxPGProperty::RemoveChild( wxPGProperty* p )
2112{
2113 wxArrayPGProperty::iterator it;
2114 wxArrayPGProperty& children = m_children;
2115
2116 for ( it=children.begin(); it != children.end(); it++ )
2117 {
2118 if ( *it == p )
2119 {
2120 m_children.erase(it);
2121 break;
2122 }
2123 }
2124}
1c4293cb
VZ		 2125
2126void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const
2127{
2128 wxASSERT( GetChildCount() );
2129 wxASSERT( !IsCategory() );
2130
2131 *value = GetValue();
2132
2133 if ( !list.GetCount() )
2134 return;
2135
2136 wxASSERT( GetChildCount() >= (unsigned int)list.GetCount() );
2137
2138 bool allChildrenSpecified;
2139
2140 // Don't fully update aggregate properties unless all children have
2141 // specified value
2142 if ( HasFlag(wxPG_PROP_AGGREGATE) )
2143 allChildrenSpecified = AreAllChildrenSpecified(&list);
2144 else
2145 allChildrenSpecified = true;
2146
2147 wxVariant childValue = list[0];
2148 unsigned int i;
2149 unsigned int n = 0;
2150
d665918b 2151 //wxLogDebug(wxT(">> %s.AdaptListToValue()"),GetBaseName().c_str());
1c4293cb
VZ		 2152
2153 for ( i=0; i<GetChildCount(); i++ )
2154 {
2155 const wxPGProperty* child = Item(i);
2156
d665918b 2157 if ( childValue.GetName() == child->GetBaseName() )
1c4293cb
VZ		 2158 {
2159 //wxLogDebug(wxT(" %s(n=%i), %s"),childValue.GetName().c_str(),n,childValue.GetType().c_str());
2160
0372d42e 2161 if ( childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
1c4293cb
VZ		 2162 {
2163 wxVariant cv2(child->GetValue());
2164 child->AdaptListToValue(childValue, &cv2);
2165 childValue = cv2;
2166 }
2167
2168 if ( allChildrenSpecified )
2169 ChildChanged(*value, i, childValue);
2170 n++;
2171 if ( n == (unsigned int)list.GetCount() )
2172 break;
2173 childValue = list[n];
2174 }
2175 }
2176}
2177
2178
1b895132 2179void wxPGProperty::FixIndicesOfChildren( unsigned int starthere )
1c4293cb
VZ		 2180{
2181 size_t i;
2182 for ( i=starthere;i<GetChildCount();i++)
2183 Item(i)->m_arrIndex = i;
2184}
2185
2186
2187// Returns (direct) child property with given name (or NULL if not found)
2188wxPGProperty* wxPGProperty::GetPropertyByName( const wxString& name ) const
2189{
2190 size_t i;
2191
2192 for ( i=0; i<GetChildCount(); i++ )
2193 {
2194 wxPGProperty* p = Item(i);
2195 if ( p->m_name == name )
2196 return p;
2197 }
2198
2199 // Does it have point, then?
2200 int pos = name.Find(wxS('.'));
2201 if ( pos <= 0 )
d3b9f782 2202 return NULL;
1c4293cb
VZ		 2203
2204 wxPGProperty* p = GetPropertyByName(name. substr(0,pos));
2205
2206 if ( !p || !p->GetChildCount() )
2207 return NULL;
2208
2209 return p->GetPropertyByName(name.substr(pos+1,name.length()-pos-1));
2210}
2211
d665918b 2212wxPGProperty* wxPGProperty::GetPropertyByNameWH( const wxString& name, unsigned int hintIndex ) const
1c4293cb
VZ		 2213{
2214 unsigned int i = hintIndex;
2215
2216 if ( i >= GetChildCount() )
2217 i = 0;
2218
2219 unsigned int lastIndex = i - 1;
2220
2221 if ( lastIndex >= GetChildCount() )
2222 lastIndex = GetChildCount() - 1;
2223
2224 for (;;)
2225 {
2226 wxPGProperty* p = Item(i);
d665918b 2227 if ( p->m_name == name )
1c4293cb
VZ		 2228 return p;
2229
2230 if ( i == lastIndex )
2231 break;
2232
2233 i++;
2234 if ( i == GetChildCount() )
2235 i = 0;
2236 };
2237
2238 return NULL;
2239}
2240
2241int wxPGProperty::GetChildrenHeight( int lh, int iMax_ ) const
2242{
2243 // Returns height of children, recursively, and
2244 // by taking expanded/collapsed status into account.
2245 //
2246 // iMax is used when finding property y-positions.
2247 //
2248 unsigned int i = 0;
2249 int h = 0;
2250
2251 if ( iMax_ == -1 )
2252 iMax_ = GetChildCount();
2253
2254 unsigned int iMax = iMax_;
2255
2256 wxASSERT( iMax <= GetChildCount() );
2257
2258 if ( !IsExpanded() && GetParent() )
2259 return 0;
2260
2261 while ( i < iMax )
2262 {
2263 wxPGProperty* pwc = (wxPGProperty*) Item(i);
2264
2265 if ( !pwc->HasFlag(wxPG_PROP_HIDDEN) )
2266 {
2267 if ( !pwc->IsExpanded() ||
2268 pwc->GetChildCount() == 0 )
2269 h += lh;
2270 else
2271 h += pwc->GetChildrenHeight(lh) + lh;
2272 }
2273
2274 i++;
2275 }
2276
2277 return h;
2278}
2279
2280wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y, unsigned int lh, unsigned int* nextItemY ) const
2281{
2282 wxASSERT( nextItemY );
2283
2284 // Linear search at the moment
2285 //
2286 // nextItemY = y of next visible property, final value will be written back.
2287 wxPGProperty* result = NULL;
2288 wxPGProperty* current = NULL;
2289 unsigned int iy = *nextItemY;
2290 unsigned int i = 0;
2291 unsigned int iMax = GetChildCount();
2292
2293 while ( i < iMax )
2294 {
2295 wxPGProperty* pwc = Item(i);
2296
2297 if ( !pwc->HasFlag(wxPG_PROP_HIDDEN) )
2298 {
2299 // Found?
2300 if ( y < iy )
2301 {
2302 result = current;
2303 break;
2304 }
2305
2306 iy += lh;
2307
2308 if ( pwc->IsExpanded() &&
2309 pwc->GetChildCount() > 0 )
2310 {
2311 result = (wxPGProperty*) pwc->GetItemAtY( y, lh, &iy );
2312 if ( result )
2313 break;
2314 }
2315
2316 current = pwc;
2317 }
2318
2319 i++;
2320 }
2321
2322 // Found?
2323 if ( !result && y < iy )
2324 result = current;
2325
2326 *nextItemY = iy;
2327
2328 /*
2329 if ( current )
2330 wxLogDebug(wxT("%s::GetItemAtY(%i) -> %s"),this->GetLabel().c_str(),y,current->GetLabel().c_str());
2331 else
2332 wxLogDebug(wxT("%s::GetItemAtY(%i) -> NULL"),this->GetLabel().c_str(),y);
2333 */
2334
2335 return (wxPGProperty*) result;
2336}
2337
2338void wxPGProperty::Empty()
2339{
2340 size_t i;
2341 if ( !HasFlag(wxPG_PROP_CHILDREN_ARE_COPIES) )
2342 {
2343 for ( i=0; i<GetChildCount(); i++ )
2344 {
f7a094e1 2345 delete m_children[i];
1c4293cb
VZ		 2346 }
2347 }
2348
f7a094e1 2349 m_children.clear();
1c4293cb
VZ		 2350}
2351
91c818f8
JS		 2352void wxPGProperty::DeleteChildren()
2353{
2354 wxPropertyGridPageState* state = m_parentState;
2355
2356 while ( GetChildCount() )
2357 {
2358 wxPGProperty* child = Item(GetChildCount()-1);
2359 state->DoDelete(child, true);
2360 }
2361}
2362
1c4293cb
VZ		 2363void wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
2364 int WXUNUSED(childIndex),
2365 wxVariant& WXUNUSED(childValue) ) const
2366{
2367}
2368
2369bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const
2370{
2371 unsigned int i;
2372
2373 const wxVariantList* pList = NULL;
2374 wxVariantList::const_iterator node;
2375
2376 if ( pendingList )
2377 {
2378 pList = &pendingList->GetList();
2379 node = pList->begin();
2380 }
2381
1c4293cb
VZ		 2382 for ( i=0; i<GetChildCount(); i++ )
2383 {
2384 wxPGProperty* child = Item(i);
2385 const wxVariant* listValue = NULL;
2386 wxVariant value;
2387
2388 if ( pendingList )
2389 {
d665918b 2390 const wxString& childName = child->GetBaseName();
1c4293cb 2391
b7bc9d80 2392 for ( ; node != pList->end(); ++node )
1c4293cb
VZ		 2393 {
2394 const wxVariant& item = *((const wxVariant*)*node);
d665918b 2395 if ( item.GetName() == childName )
1c4293cb
VZ		 2396 {
2397 listValue = &item;
2398 value = item;
2399 break;
2400 }
2401 }
2402 }
2403
2404 if ( !listValue )
2405 value = child->GetValue();
2406
2407 if ( value.IsNull() )
2408 return false;
2409
2410 // Check recursively
2411 if ( child->GetChildCount() )
2412 {
2413 const wxVariant* childList = NULL;
2414
0372d42e 2415 if ( listValue && listValue->GetType() == wxPG_VARIANT_TYPE_LIST )
1c4293cb
VZ		 2416 childList = listValue;
2417
2418 if ( !child->AreAllChildrenSpecified((wxVariant*)childList) )
2419 return false;
2420 }
2421 }
2422
2423 return true;
2424}
2425
2426wxPGProperty* wxPGProperty::UpdateParentValues()
2427{
2428 wxPGProperty* parent = m_parent;
2429 if ( parent && parent->HasFlag(wxPG_PROP_COMPOSED_VALUE) &&
2430 !parent->IsCategory() && !parent->IsRoot() )
2431 {
2432 wxString s;
c82a80e8 2433 parent->DoGenerateComposedValue(s);
1c4293cb
VZ		 2434 parent->m_value = s;
2435 return parent->UpdateParentValues();
2436 }
2437 return this;
2438}
2439
2440bool wxPGProperty::IsTextEditable() const
2441{
2442 if ( HasFlag(wxPG_PROP_READONLY) )
2443 return false;
2444
2445 if ( HasFlag(wxPG_PROP_NOEDITOR) &&
2446 (GetChildCount() ||
2447 wxString(GetEditorClass()->GetClassInfo()->GetClassName()).EndsWith(wxS("Button")))
2448 )
2449 return false;
2450
2451 return true;
2452}
2453
1c4293cb
VZ		 2454// Call after fixed sub-properties added/removed after creation.
2455// if oldSelInd >= 0 and < new max items, then selection is
2456// moved to it. Note: oldSelInd -2 indicates that this property
2457// should be selected.
2458void wxPGProperty::SubPropsChanged( int oldSelInd )
2459{
2460 wxPropertyGridPageState* state = GetParentState();
2461 wxPropertyGrid* grid = state->GetGrid();
2462
2fd4a524
JS		 2463 //
2464 // Re-repare children (recursively)
2465 for ( unsigned int i=0; i<GetChildCount(); i++ )
2466 {
2467 wxPGProperty* child = Item(i);
2468 child->InitAfterAdded(state, grid);
2469 }
1c4293cb 2470
d3b9f782 2471 wxPGProperty* sel = NULL;
f7a094e1
JS		 2472 if ( oldSelInd >= (int)m_children.size() )
2473 oldSelInd = (int)m_children.size() - 1;
1c4293cb
VZ		 2474
2475 if ( oldSelInd >= 0 )
f7a094e1 2476 sel = m_children[oldSelInd];
1c4293cb
VZ		 2477 else if ( oldSelInd == -2 )
2478 sel = this;
2479
2480 if ( sel )
2481 state->DoSelectProperty(sel);
2482
2483 if ( state == grid->GetState() )
2484 {
2485 grid->GetPanel()->Refresh();
2486 }
2487}
2488
2489// -----------------------------------------------------------------------
2490// wxPGRootProperty
2491// -----------------------------------------------------------------------
2492
2493WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPGRootProperty,none,TextCtrl)
2494IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
2495
2496
94b8ecf1 2497wxPGRootProperty::wxPGRootProperty( const wxString& name )
1c4293cb
VZ		 2498 : wxPGProperty()
2499{
94b8ecf1
JS		 2500 m_name = name;
2501 m_label = m_name;
1c4293cb
VZ		 2502 SetParentalType(0);
2503 m_depth = 0;
2504}
2505
2506
2507wxPGRootProperty::~wxPGRootProperty()
2508{
2509}
2510
2511
2512// -----------------------------------------------------------------------
2513// wxPropertyCategory
2514// -----------------------------------------------------------------------
2515
2516WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPropertyCategory,none,TextCtrl)
2517IMPLEMENT_DYNAMIC_CLASS(wxPropertyCategory, wxPGProperty)
2518
2519void wxPropertyCategory::Init()
2520{
2521 // don't set colour - prepareadditem method should do this
2522 SetParentalType(wxPG_PROP_CATEGORY);
2523 m_capFgColIndex = 1;
2524 m_textExtent = -1;
2525}
2526
2527wxPropertyCategory::wxPropertyCategory()
2528 : wxPGProperty()
2529{
2530 Init();
2531}
2532
2533
2534wxPropertyCategory::wxPropertyCategory( const wxString &label, const wxString& name )
2535 : wxPGProperty(label,name)
2536{
2537 Init();
2538}
2539
2540
2541wxPropertyCategory::~wxPropertyCategory()
2542{
2543}
2544
2545
1425eca5
JS		 2546wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
2547 int WXUNUSED(argFlags) ) const
1c4293cb
VZ		 2548{
2549 return wxEmptyString;
2550}
2551
2552int wxPropertyCategory::GetTextExtent( const wxWindow* wnd, const wxFont& font ) const
2553{
2554 if ( m_textExtent > 0 )
2555 return m_textExtent;
2556 int x = 0, y = 0;
2557 ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font );
2558 return x;
2559}
2560
2561void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font )
2562{
2563 int x = 0, y = 0;
2564 wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font );
2565 m_textExtent = x;
2566}
2567
2728c3bf
JS		 2568// -----------------------------------------------------------------------
2569// wxPGChoices
2570// -----------------------------------------------------------------------
2571
2572wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, int value )
2573{
2574 AllocExclusive();
2575
2576 wxPGChoiceEntry entry(label, value);
2577 return m_data->Insert( -1, entry );
2578}
2579
2580// -----------------------------------------------------------------------
2581
2582wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, const wxBitmap& bitmap, int value )
2583{
2584 AllocExclusive();
2585
2586 wxPGChoiceEntry entry(label, value);
2587 entry.SetBitmap(bitmap);
2588 return m_data->Insert( -1, entry );
2589}
2590
2591// -----------------------------------------------------------------------
2592
2593wxPGChoiceEntry& wxPGChoices::Insert( const wxPGChoiceEntry& entry, int index )
2594{
2595 AllocExclusive();
2596
2597 return m_data->Insert( index, entry );
2598}
2599
2600// -----------------------------------------------------------------------
2601
2602wxPGChoiceEntry& wxPGChoices::Insert( const wxString& label, int index, int value )
2603{
2604 AllocExclusive();
2605
2606 wxPGChoiceEntry entry(label, value);
2607 return m_data->Insert( index, entry );
2608}
2609
2610// -----------------------------------------------------------------------
2611
2612wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value )
2613{
2614 AllocExclusive();
2615
2616 size_t index = 0;
2617
2618 while ( index < GetCount() )
2619 {
2620 int cmpRes = GetLabel(index).Cmp(label);
2621 if ( cmpRes > 0 )
2622 break;
2623 index++;
2624 }
2625
2626 wxPGChoiceEntry entry(label, value);
2627 return m_data->Insert( index, entry );
2628}
2629
2630// -----------------------------------------------------------------------
2631
2632void wxPGChoices::Add( const wxChar** labels, const ValArrItem* values )
2633{
2634 AllocExclusive();
2635
2636 unsigned int itemcount = 0;
2637 const wxChar** p = &labels[0];
2638 while ( *p ) { p++; itemcount++; }
2639
2640 unsigned int i;
2641 for ( i = 0; i < itemcount; i++ )
2642 {
2643 int value = i;
2644 if ( values )
2645 value = values[i];
2646 wxPGChoiceEntry entry(labels[i], value);
2647 m_data->Insert( i, entry );
2648 }
2649}
2650
2651// -----------------------------------------------------------------------
2652
2653void wxPGChoices::Add( const wxArrayString& arr, const wxArrayInt& arrint )
2654{
2655 AllocExclusive();
2656
2657 unsigned int i;
2658 unsigned int itemcount = arr.size();
2659
2660 for ( i = 0; i < itemcount; i++ )
2661 {
2662 int value = i;
2663 if ( &arrint && arrint.size() )
2664 value = arrint[i];
2665 wxPGChoiceEntry entry(arr[i], value);
2666 m_data->Insert( i, entry );
2667 }
2668}
2669
2670// -----------------------------------------------------------------------
2671
2672void wxPGChoices::RemoveAt(size_t nIndex, size_t count)
2673{
2674 AllocExclusive();
2675
2676 wxASSERT( m_data->m_refCount != 0xFFFFFFF );
2677 m_data->m_items.erase(m_data->m_items.begin()+nIndex,
2678 m_data->m_items.begin()+nIndex+count);
2679}
2680
2681// -----------------------------------------------------------------------
2682
2683void wxPGChoices::Clear()
2684{
2685 if ( m_data != wxPGChoicesEmptyData )
2686 {
2687 AllocExclusive();
2688 m_data->Clear();
2689 }
2690}
2691
2692// -----------------------------------------------------------------------
2693
2694int wxPGChoices::Index( const wxString& str ) const
2695{
2696 if ( IsOk() )
2697 {
2698 unsigned int i;
2699 for ( i=0; i< m_data->GetCount(); i++ )
2700 {
2701 const wxPGChoiceEntry& entry = m_data->Item(i);
2702 if ( entry.HasText() && entry.GetText() == str )
2703 return i;
2704 }
2705 }
2706 return -1;
2707}
2708
2709// -----------------------------------------------------------------------
2710
2711int wxPGChoices::Index( int val ) const
2712{
2713 if ( IsOk() )
2714 {
2715 unsigned int i;
2716 for ( i=0; i< m_data->GetCount(); i++ )
2717 {
2718 const wxPGChoiceEntry& entry = m_data->Item(i);
2719 if ( entry.GetValue() == val )
2720 return i;
2721 }
2722 }
2723 return -1;
2724}
2725
2726// -----------------------------------------------------------------------
2727
2728wxArrayString wxPGChoices::GetLabels() const
2729{
2730 wxArrayString arr;
2731 unsigned int i;
2732
2733 if ( this && IsOk() )
2734 for ( i=0; i<GetCount(); i++ )
2735 arr.push_back(GetLabel(i));
2736
2737 return arr;
2738}
2739
2740// -----------------------------------------------------------------------
2741
2742wxArrayInt wxPGChoices::GetValuesForStrings( const wxArrayString& strings ) const
2743{
2744 wxArrayInt arr;
2745
2746 if ( IsOk() )
2747 {
2748 unsigned int i;
2749 for ( i=0; i< strings.size(); i++ )
2750 {
2751 int index = Index(strings[i]);
2752 if ( index >= 0 )
2753 arr.Add(GetValue(index));
2754 else
2755 arr.Add(wxPG_INVALID_VALUE);
2756 }
2757 }
2758
2759 return arr;
2760}
2761
2762// -----------------------------------------------------------------------
2763
2764wxArrayInt wxPGChoices::GetIndicesForStrings( const wxArrayString& strings,
2765 wxArrayString* unmatched ) const
2766{
2767 wxArrayInt arr;
2768
2769 if ( IsOk() )
2770 {
2771 unsigned int i;
2772 for ( i=0; i< strings.size(); i++ )
2773 {
2774 const wxString& str = strings[i];
2775 int index = Index(str);
2776 if ( index >= 0 )
2777 arr.Add(index);
2778 else if ( unmatched )
2779 unmatched->Add(str);
2780 }
2781 }
2782
2783 return arr;
2784}
2785
2786// -----------------------------------------------------------------------
2787
2788void wxPGChoices::AllocExclusive()
2789{
2790 EnsureData();
2791
2792 if ( m_data->m_refCount != 1 )
2793 {
2794 wxPGChoicesData* data = new wxPGChoicesData();
2795 data->CopyDataFrom(m_data);
2796 Free();
2797 m_data = data;
2798 }
2799}
2800
2801// -----------------------------------------------------------------------
2802
2803void wxPGChoices::AssignData( wxPGChoicesData* data )
2804{
2805 Free();
2806
2807 if ( data != wxPGChoicesEmptyData )
2808 {
2809 m_data = data;
2810 data->m_refCount++;
2811 }
2812}
2813
2814// -----------------------------------------------------------------------
2815
2816void wxPGChoices::Init()
2817{
2818 m_data = wxPGChoicesEmptyData;
2819}
2820
2821// -----------------------------------------------------------------------
2822
2823void wxPGChoices::Free()
2824{
2825 if ( m_data != wxPGChoicesEmptyData )
2826 {
2827 m_data->DecRef();
2828 m_data = wxPGChoicesEmptyData;
2829 }
2830}
2831
1c4293cb
VZ		 2832// -----------------------------------------------------------------------
2833// wxPGAttributeStorage
2834// -----------------------------------------------------------------------
2835
2836wxPGAttributeStorage::wxPGAttributeStorage()
2837{
2838}
2839
2840wxPGAttributeStorage::~wxPGAttributeStorage()
2841{
2842 wxPGHashMapS2P::iterator it;
2843
b7bc9d80 2844 for ( it = m_map.begin(); it != m_map.end(); ++it )
1c4293cb
VZ		 2845 {
2846 wxVariantData* data = (wxVariantData*) it->second;
2847 data->DecRef();
2848 }
2849}
2850
2851void wxPGAttributeStorage::Set( const wxString& name, const wxVariant& value )
2852{
2853 wxVariantData* data = value.GetData();
2854
2855 // Free old, if any
2856 wxPGHashMapS2P::iterator it = m_map.find(name);
2857 if ( it != m_map.end() )
1802a91d 2858 {
1c4293cb
VZ		 2859 ((wxVariantData*)it->second)->DecRef();
2860
1802a91d
JS		 2861 if ( !data )
2862 {
2863 // If Null variant, just remove from set
2864 m_map.erase(it);
2865 return;
2866 }
2867 }
2868
1c4293cb 2869 if ( data )
1802a91d 2870 {
1c4293cb
VZ		 2871 data->IncRef();
2872
1802a91d
JS		 2873 m_map[name] = data;
2874 }
1c4293cb
VZ		 2875}
2876
f4bc1aa2 2877#endif // wxUSE_PROPGRID
wxWidgets (Impactor)