← Back to branch summary

~brian-sidebotham/wxwidgets-cmake/wxpython-2.9.4

« back to all changes in this revision

Viewing changes to samples/propgrid/sampleprops.cpp

  • Committer: Brian Sidebotham
  • Date: 2013-08-03 14:30:08 UTC
  • Revision ID: brian.sidebotham@gmail.com-20130803143008-c7806tkych1tp6fc
Initial import into Bazaar

Show diffs side-by-side

added added

removed removed

Lines of Context:
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: sampleprops.cpp 67681 2011-05-03 16:29:04Z DS $
 
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