]> git.saurik.com Git - wxWidgets.git/blob - samples/propgrid/sampleprops.cpp
supporting alignment in single line controls, see #14452
[wxWidgets.git] / samples / propgrid / sampleprops.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: samples/propgrid/sampleprops.cpp
3 // Purpose: wxPropertyGrid Sample Properties
4 // Author: Jaakko Salli
5 // Modified by:
6 // Created: 2006-03-05
7 // RCS-ID: $Id$
8 // Copyright: (c) Jaakko Salli
9 // Licence: wxWindows licence
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 // for all others, include the necessary headers (this file is usually all you
20 // need because it includes almost all "standard" wxWidgets headers)
21 #ifndef WX_PRECOMP
22 #include "wx/wx.h"
23 #endif
24
25 #include "wx/fontdlg.h"
26
27 // -----------------------------------------------------------------------
28
29
30 #include <wx/propgrid/propgrid.h>
31 #include <wx/propgrid/advprops.h>
32
33 #ifndef WX_PROPGRID_SAMPLEPROPS_H
34 #include "sampleprops.h"
35 #endif
36
37
38 // -----------------------------------------------------------------------
39 // wxFontDataProperty
40 // -----------------------------------------------------------------------
41
42 // Dummy comparison required by value type implementation.
43 bool operator == (const wxFontData&, const wxFontData&)
44 {
45 return FALSE;
46 }
47
48 // Custom version of wxFontProperty that also holds colour in the value.
49 // Original version by Vladimir Vainer.
50
51 IMPLEMENT_VARIANT_OBJECT_SHALLOWCMP(wxFontData)
52
53 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFontDataProperty,wxFontProperty,
54 wxFontData,const wxFontData&,TextCtrlAndButton)
55
56 wxFontDataProperty::wxFontDataProperty( const wxString& label, const wxString& name,
57 const wxFontData& value ) : wxFontProperty(label,name,value.GetInitialFont())
58 {
59 wxFontData fontData(value);
60
61 // Fix value.
62 fontData.SetChosenFont(value.GetInitialFont());
63 if ( !fontData.GetColour().IsOk() )
64 fontData.SetColour(*wxBLACK);
65
66 // Set initial value - should be done in a simpler way like this
67 // (instead of calling SetValue) in derived (wxObject) properties.
68 m_value_wxFontData << value;
69
70 // Add extra children.
71 AddPrivateChild( new wxColourProperty(_("Colour"), wxPG_LABEL,
72 fontData.GetColour() ) );
73 }
74
75 wxFontDataProperty::~wxFontDataProperty () { }
76
77 void wxFontDataProperty::OnSetValue()
78 {
79 if ( m_value.GetType() != "wxFontData" )
80 {
81 if ( m_value.GetType() == "wxFont" )
82 {
83 wxFont font;
84 font << m_value;
85 wxFontData fontData;
86 fontData.SetChosenFont(font);
87 if ( !m_value_wxFontData.IsNull() )
88 {
89 wxFontData oldFontData;
90 oldFontData << m_value_wxFontData;
91 fontData.SetColour(oldFontData.GetColour());
92 }
93 else
94 {
95 fontData.SetColour(*wxBLACK);
96 }
97 wxVariant variant;
98 variant << fontData;
99 m_value_wxFontData = variant;
100 }
101 else
102 {
103 wxFAIL_MSG(wxT("Value to wxFontDataProperty must be eithe wxFontData or wxFont"));
104 }
105 }
106 else
107 {
108 // Set m_value to wxFont so that wxFontProperty methods will work
109 // correctly.
110 m_value_wxFontData = m_value;
111
112 wxFontData fontData;
113 fontData << m_value_wxFontData;
114
115 wxFont font = fontData.GetChosenFont();
116 if ( !font.IsOk() )
117 font = wxFont(10,wxSWISS,wxNORMAL,wxNORMAL);
118
119 m_value = WXVARIANT(font);
120 }
121 }
122
123 wxVariant wxFontDataProperty::DoGetValue() const
124 {
125 return m_value_wxFontData;
126 }
127
128 // Must re-create font dialog displayer.
129 bool wxFontDataProperty::OnEvent( wxPropertyGrid* propgrid,
130 wxWindow* WXUNUSED(primary), wxEvent& event )
131 {
132 if ( propgrid->IsMainButtonEvent(event) )
133 {
134 wxVariant useValue = propgrid->GetUncommittedPropertyValue();
135
136 wxFontData fontData;
137 fontData << useValue;
138
139 fontData.SetInitialFont(fontData.GetChosenFont());
140
141 wxFontDialog dlg(propgrid, fontData);
142
143 if ( dlg.ShowModal() == wxID_OK )
144 {
145 wxVariant variant;
146 variant << dlg.GetFontData();
147 SetValueInEvent( variant );
148 return true;
149 }
150 }
151 return false;
152 }
153
154 void wxFontDataProperty::RefreshChildren()
155 {
156 wxFontProperty::RefreshChildren();
157 if ( GetChildCount() < 6 ) // Number is count of wxFontProperty's children + 1.
158 return;
159 wxFontData fontData; fontData << m_value_wxFontData;
160 wxVariant variant; variant << fontData.GetColour();
161 Item(6)->SetValue( variant );
162 }
163
164 wxVariant wxFontDataProperty::ChildChanged( wxVariant& thisValue,
165 int childIndex,
166 wxVariant& childValue ) const
167 {
168 wxFontData fontData;
169 fontData << thisValue;
170 wxColour col;
171 wxVariant variant;
172
173 switch ( childIndex )
174 {
175 case 6:
176 col << childValue;
177 fontData.SetColour( col );
178 break;
179 default:
180 // Transfer from subset to superset.
181 wxFont font = fontData.GetChosenFont();
182 variant = WXVARIANT(font);
183 wxFontProperty::ChildChanged( variant, childIndex, childValue );
184 font << variant;
185 fontData.SetChosenFont(font);
186 }
187
188 wxVariant newVariant;
189 newVariant << fontData;
190 return newVariant;
191 }
192
193 // -----------------------------------------------------------------------
194 // wxSizeProperty
195 // -----------------------------------------------------------------------
196
197 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxSizeProperty,wxPGProperty,
198 wxSize,const wxSize&,TextCtrl)
199
200 wxSizeProperty::wxSizeProperty( const wxString& label, const wxString& name,
201 const wxSize& value) : wxPGProperty(label,name)
202 {
203 SetValueI(value);
204 AddPrivateChild( new wxIntProperty(wxT("Width"),wxPG_LABEL,value.x) );
205 AddPrivateChild( new wxIntProperty(wxT("Height"),wxPG_LABEL,value.y) );
206 }
207
208 wxSizeProperty::~wxSizeProperty() { }
209
210 void wxSizeProperty::RefreshChildren()
211 {
212 if ( !GetChildCount() ) return;
213 const wxSize& size = wxSizeRefFromVariant(m_value);
214 Item(0)->SetValue( (long)size.x );
215 Item(1)->SetValue( (long)size.y );
216 }
217
218 wxVariant wxSizeProperty::ChildChanged( wxVariant& thisValue,
219 int childIndex,
220 wxVariant& childValue ) const
221 {
222 wxSize& size = wxSizeRefFromVariant(thisValue);
223 int val = childValue.GetLong();
224 switch ( childIndex )
225 {
226 case 0: size.x = val; break;
227 case 1: size.y = val; break;
228 }
229 wxVariant newVariant;
230 newVariant << size;
231 return newVariant;
232 }
233
234 // -----------------------------------------------------------------------
235 // wxPointProperty
236 // -----------------------------------------------------------------------
237
238 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxPointProperty,wxPGProperty,
239 wxPoint,const wxPoint&,TextCtrl)
240
241 wxPointProperty::wxPointProperty( const wxString& label, const wxString& name,
242 const wxPoint& value) : wxPGProperty(label,name)
243 {
244 SetValueI(value);
245 AddPrivateChild( new wxIntProperty(wxT("X"),wxPG_LABEL,value.x) );
246 AddPrivateChild( new wxIntProperty(wxT("Y"),wxPG_LABEL,value.y) );
247 }
248
249 wxPointProperty::~wxPointProperty() { }
250
251 void wxPointProperty::RefreshChildren()
252 {
253 if ( !GetChildCount() ) return;
254 const wxPoint& point = wxPointRefFromVariant(m_value);
255 Item(0)->SetValue( (long)point.x );
256 Item(1)->SetValue( (long)point.y );
257 }
258
259 wxVariant wxPointProperty::ChildChanged( wxVariant& thisValue,
260 int childIndex,
261 wxVariant& childValue ) const
262 {
263 wxPoint& point = wxPointRefFromVariant(thisValue);
264 int val = childValue.GetLong();
265 switch ( childIndex )
266 {
267 case 0: point.x = val; break;
268 case 1: point.y = val; break;
269 }
270 wxVariant newVariant;
271 newVariant << point;
272 return newVariant;
273 }
274
275
276 // -----------------------------------------------------------------------
277 // Dirs Property
278 // -----------------------------------------------------------------------
279
280 WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(wxDirsProperty, ',',
281 "Browse")
282
283 #if wxUSE_VALIDATORS
284
285 wxValidator* wxDirsProperty::DoGetValidator() const
286 {
287 return wxFileProperty::GetClassValidator();
288 }
289
290 #endif
291
292
293 bool wxDirsProperty::OnCustomStringEdit( wxWindow* parent, wxString& value )
294 {
295 wxDirDialog dlg(parent,
296 _("Select a directory to be added to the list:"),
297 value,
298 0);
299
300 if ( dlg.ShowModal() == wxID_OK )
301 {
302 value = dlg.GetPath();
303 return TRUE;
304 }
305 return FALSE;
306 }
307
308 // -----------------------------------------------------------------------
309 // wxArrayDoubleEditorDialog
310 // -----------------------------------------------------------------------
311
312
313 //
314 // You can *almost* convert wxArrayDoubleEditorDialog to wxArrayXXXEditorDialog
315 // by replacing each ArrayDouble with ArrayXXX.
316 //
317
318 class wxArrayDoubleEditorDialog : public wxPGArrayEditorDialog
319 {
320 public:
321 wxArrayDoubleEditorDialog();
322
323 void Init();
324
325 wxArrayDoubleEditorDialog(wxWindow *parent,
326 const wxString& message,
327 const wxString& caption,
328 wxArrayDouble& array,
329 long style = wxAEDIALOG_STYLE,
330 const wxPoint& pos = wxDefaultPosition,
331 const wxSize& sz = wxDefaultSize );
332
333 bool Create(wxWindow *parent,
334 const wxString& message,
335 const wxString& caption,
336 wxArrayDouble& array,
337 long style = wxAEDIALOG_STYLE,
338 const wxPoint& pos = wxDefaultPosition,
339 const wxSize& sz = wxDefaultSize );
340
341 const wxArrayDouble& GetArray() const { return m_array; }
342
343 // Extra method for this type of array
344 void SetPrecision ( int precision )
345 {
346 m_precision = precision;
347 m_dtoaTemplate.Empty();
348 }
349
350 protected:
351 // Mandatory array of type
352 wxArrayDouble m_array;
353
354 // Use this to avoid extra wxString creation+Printf
355 // on double-to-wxString conversion.
356 wxString m_dtoaTemplate;
357
358 int m_precision;
359
360 // Mandatory overridden methods
361 virtual wxString ArrayGet( size_t index );
362 virtual size_t ArrayGetCount();
363 virtual bool ArrayInsert( const wxString& str, int index );
364 virtual bool ArraySet( size_t index, const wxString& str );
365 virtual void ArrayRemoveAt( int index );
366 virtual void ArraySwap( size_t first, size_t second );
367
368 private:
369 DECLARE_DYNAMIC_CLASS_NO_COPY(wxArrayDoubleEditorDialog)
370 };
371
372 IMPLEMENT_DYNAMIC_CLASS(wxArrayDoubleEditorDialog, wxPGArrayEditorDialog)
373
374 //
375 // Array dialog array access and manipulation
376 //
377
378 wxString wxArrayDoubleEditorDialog::ArrayGet( size_t index )
379 {
380 wxString str;
381 wxPropertyGrid::DoubleToString(str,m_array[index],m_precision,true,&m_dtoaTemplate);
382 return str;
383 }
384
385 size_t wxArrayDoubleEditorDialog::ArrayGetCount()
386 {
387 return m_array.GetCount();
388 }
389
390 bool wxArrayDoubleEditorDialog::ArrayInsert( const wxString& str, int index )
391 {
392 double d;
393 if ( !str.ToDouble(&d) )
394 return FALSE;
395
396 if (index<0)
397 m_array.Add(d);
398 else
399 m_array.Insert(d,index);
400 return TRUE;
401 }
402
403 bool wxArrayDoubleEditorDialog::ArraySet( size_t index, const wxString& str )
404 {
405 double d;
406 if ( !str.ToDouble(&d) )
407 return FALSE;
408 m_array[index] = d;
409 return TRUE;
410 }
411
412 void wxArrayDoubleEditorDialog::ArrayRemoveAt( int index )
413 {
414 m_array.RemoveAt(index);
415 }
416
417 void wxArrayDoubleEditorDialog::ArraySwap( size_t first, size_t second )
418 {
419 double a = m_array[first];
420 double b = m_array[second];
421 m_array[first] = b;
422 m_array[second] = a;
423 }
424
425 //
426 // Array dialog construction etc.
427 //
428
429 wxArrayDoubleEditorDialog::wxArrayDoubleEditorDialog()
430 : wxPGArrayEditorDialog()
431 {
432 Init();
433 }
434
435 void wxArrayDoubleEditorDialog::Init()
436 {
437 wxPGArrayEditorDialog::Init();
438 SetPrecision(-1);
439 }
440
441 wxArrayDoubleEditorDialog::wxArrayDoubleEditorDialog(wxWindow *parent,
442 const wxString& message,
443 const wxString& caption,
444 wxArrayDouble& array,
445 long style,
446 const wxPoint& pos,
447 const wxSize& sz )
448 : wxPGArrayEditorDialog()
449 {
450 Init();
451 Create(parent,message,caption,array,style,pos,sz);
452 }
453
454 bool wxArrayDoubleEditorDialog::Create(wxWindow *parent,
455 const wxString& message,
456 const wxString& caption,
457 wxArrayDouble& array,
458 long style,
459 const wxPoint& pos,
460 const wxSize& sz )
461 {
462
463 m_array = array;
464
465 return wxPGArrayEditorDialog::Create (parent,message,caption,style,pos,sz);
466 }
467
468 // -----------------------------------------------------------------------
469 // wxArrayDoubleProperty
470 // -----------------------------------------------------------------------
471
472 #include <math.h> // for fabs
473
474 // Comparison required by value type implementation.
475 bool operator == (const wxArrayDouble& a, const wxArrayDouble& b)
476 {
477 if ( a.GetCount() != b.GetCount() )
478 return FALSE;
479
480 size_t i;
481
482 for ( i=0; i<a.GetCount(); i++ )
483 {
484 // Can't do direct equality comparison with floating point numbers.
485 if ( fabs(a[i] - b[i]) > 0.0000000001 )
486 {
487 //wxLogDebug(wxT("%f != %f"),a[i],b[i]);
488 return FALSE;
489 }
490 }
491 return TRUE;
492 }
493
494 WX_PG_IMPLEMENT_VARIANT_DATA_DUMMY_EQ(wxArrayDouble)
495
496 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxArrayDoubleProperty,
497 wxPGProperty,
498 wxArrayDouble,
499 const wxArrayDouble&,
500 TextCtrlAndButton)
501
502
503 wxArrayDoubleProperty::wxArrayDoubleProperty (const wxString& label,
504 const wxString& name,
505 const wxArrayDouble& array )
506 : wxPGProperty(label,name)
507 {
508 m_precision = -1;
509
510 //
511 // Need to figure out delimiter needed for this locale
512 // (ie. can't use comma when comma acts as decimal point in float).
513 wxChar use_delimiter = wxT(',');
514
515 if (wxString::Format(wxT("%.2f"),12.34).Find(use_delimiter) >= 0)
516 use_delimiter = wxT(';');
517
518 m_delimiter = use_delimiter;
519
520 SetValue( WXVARIANT(array) );
521 }
522
523 wxArrayDoubleProperty::~wxArrayDoubleProperty () { }
524
525 void wxArrayDoubleProperty::OnSetValue()
526 {
527 // Generate cached display string, to optimize grid drawing
528 GenerateValueAsString( m_display, m_precision, true );
529 }
530
531 wxString wxArrayDoubleProperty::ValueToString( wxVariant& value,
532 int argFlags ) const
533 {
534 wxString s;
535
536 if ( argFlags & wxPG_FULL_VALUE )
537 {
538 GenerateValueAsString(s,-1,false);
539 }
540 else
541 {
542 //
543 // Display cached string only if value truly matches m_value
544 if ( value.GetData() == m_value.GetData() )
545 return m_display;
546 else
547 GenerateValueAsString( s, m_precision, true );
548 }
549
550 return s;
551 }
552
553 void wxArrayDoubleProperty::GenerateValueAsString( wxString& target, int prec, bool removeZeroes ) const
554 {
555 wxString s;
556 wxString template_str;
557 wxChar between[3] = wxT(", ");
558 size_t i;
559
560 between[0] = m_delimiter;
561
562 target.Empty();
563
564 const wxArrayDouble& value = wxArrayDoubleRefFromVariant(m_value);
565
566 for ( i=0; i<value.GetCount(); i++ )
567 {
568
569 wxPropertyGrid::DoubleToString(s,value[i],prec,removeZeroes,&template_str);
570
571 target += s;
572
573 if ( i<(value.GetCount()-1) )
574 target += between;
575 }
576 }
577
578 bool wxArrayDoubleProperty::OnEvent( wxPropertyGrid* propgrid,
579 wxWindow* WXUNUSED(primary),
580 wxEvent& event)
581 {
582 if ( propgrid->IsMainButtonEvent(event) )
583 {
584 // Update the value in case of last minute changes
585 wxVariant useValue = propgrid->GetUncommittedPropertyValue();
586
587 wxArrayDouble& value = wxArrayDoubleRefFromVariant(useValue);
588
589 // Create editor dialog.
590 wxArrayDoubleEditorDialog dlg;
591 dlg.SetPrecision(m_precision);
592 dlg.Create( propgrid, wxEmptyString, m_label, value );
593 dlg.Move( propgrid->GetGoodEditorDialogPosition(this,dlg.GetSize()) );
594
595 // Execute editor dialog
596 int res = dlg.ShowModal();
597 if ( res == wxID_OK && dlg.IsModified() )
598 {
599 SetValueInEvent( WXVARIANT(dlg.GetArray()) );
600 return true;
601 }
602 return false;
603 }
604 return false;
605 }
606
607 bool wxArrayDoubleProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
608 {
609 double tval;
610 wxString tstr;
611 // Add values to a temporary array so that in case
612 // of error we can opt not to use them.
613 wxArrayDouble new_array;
614
615 bool ok = true;
616
617 wxChar delimiter = m_delimiter;
618
619 WX_PG_TOKENIZER1_BEGIN(text,delimiter)
620
621 if ( !token.empty() )
622 {
623
624 // If token was invalid, exit the loop now
625 if ( !token.ToDouble(&tval) )
626 {
627 tstr.Printf ( _("\"%s\" is not a floating-point number."), token.c_str() );
628 ok = false;
629 break;
630 }
631 // TODO: Put validator code here
632
633 new_array.Add(tval);
634
635 }
636
637 WX_PG_TOKENIZER1_END()
638
639 // When invalid token found, show error message and don't change anything
640 if ( !ok )
641 {
642 //ShowError( tstr );
643 return false;
644 }
645
646 if ( !(wxArrayDoubleRefFromVariant(m_value) == new_array) )
647 {
648 variant = WXVARIANT(new_array);
649 return true;
650 }
651
652 return false;
653 }
654
655 bool wxArrayDoubleProperty::DoSetAttribute( const wxString& name, wxVariant& value )
656 {
657 if ( name == wxPG_FLOAT_PRECISION )
658 {
659 m_precision = value.GetLong();
660 GenerateValueAsString( m_display, m_precision, true );
661 return true;
662 }
663 return false;
664 }
665