• Home
  • History
  • Annotate
  • Line#
  • Navigate
  • Raw
  • Download
  • only in /netgear-R7000-V1.0.7.12_1.2.5/ap/gpl/amule/wxWidgets-2.8.12/contrib/src/deprecated/
1/////////////////////////////////////////////////////////////////////////////
2// Name:        prop.cpp
3// Purpose:     Propert sheet classes implementation
4// Author:      Julian Smart
5// Modified by:
6// Created:     04/01/98
7// RCS-ID:      $Id: prop.cpp 38724 2006-04-14 19:56:03Z ABX $
8// Copyright:   (c) Julian Smart
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#include "wx/deprecated/setup.h"
20
21#if wxUSE_PROPSHEET
22
23#ifndef WX_PRECOMP
24#endif
25
26#include "wx/debug.h"
27#include "wx/deprecated/prop.h"
28
29#include <ctype.h>
30#include <stdlib.h>
31#include <math.h>
32#include <string.h>
33
34#if !WXWIN_COMPATIBILITY_2_4
35static inline wxChar* copystring(const wxChar* s)
36    { return wxStrcpy(new wxChar[wxStrlen(s) + 1], s); }
37#endif
38
39IMPLEMENT_DYNAMIC_CLASS(wxPropertyValue, wxObject)
40
41wxPropertyValue::wxPropertyValue(void)
42{
43  m_type = wxPropertyValueNull;
44  m_next = NULL;
45  m_last = NULL;
46  m_value.first = NULL;
47  m_clientData = NULL;
48  m_modifiedFlag = false;
49}
50
51wxPropertyValue::wxPropertyValue(const wxPropertyValue& copyFrom)
52    : wxObject()
53{
54  m_value.string = (wxChar*) NULL;
55  m_modifiedFlag = false;
56  Copy((wxPropertyValue& )copyFrom);
57}
58
59wxPropertyValue::wxPropertyValue(const wxChar *val)
60{
61  m_modifiedFlag = false;
62  m_type = wxPropertyValueString;
63
64  m_value.string = copystring(val);
65  m_clientData = NULL;
66  m_next = NULL;
67  m_last = NULL;
68}
69
70wxPropertyValue::wxPropertyValue(const wxString& val)
71{
72  m_modifiedFlag = false;
73  m_type = wxPropertyValueString;
74
75  m_value.string = copystring(val.c_str());
76  m_clientData = NULL;
77  m_next = NULL;
78  m_last = NULL;
79}
80
81wxPropertyValue::wxPropertyValue(long the_integer)
82{
83  m_modifiedFlag = false;
84  m_type = wxPropertyValueInteger;
85  m_value.integer = the_integer;
86  m_clientData = NULL;
87  m_next = NULL;
88}
89
90wxPropertyValue::wxPropertyValue(bool val)
91{
92  m_modifiedFlag = false;
93  m_type = wxPropertyValuebool;
94  m_value.integer = val;
95  m_clientData = NULL;
96  m_next = NULL;
97}
98
99wxPropertyValue::wxPropertyValue(float the_real)
100{
101  m_modifiedFlag = false;
102  m_type = wxPropertyValueReal;
103  m_value.real = the_real;
104  m_clientData = NULL;
105  m_next = NULL;
106}
107
108wxPropertyValue::wxPropertyValue(double the_real)
109{
110  m_modifiedFlag = false;
111  m_type = wxPropertyValueReal;
112  m_value.real = (float)the_real;
113  m_clientData = NULL;
114  m_next = NULL;
115}
116
117// Pointer versions: we have a pointer to the real C++ value.
118wxPropertyValue::wxPropertyValue(wxChar **val)
119{
120  m_modifiedFlag = false;
121  m_type = wxPropertyValueStringPtr;
122
123  m_value.stringPtr = val;
124  m_clientData = NULL;
125  m_next = NULL;
126  m_last = NULL;
127}
128
129wxPropertyValue::wxPropertyValue(long *val)
130{
131  m_modifiedFlag = false;
132  m_type = wxPropertyValueIntegerPtr;
133  m_value.integerPtr = val;
134  m_clientData = NULL;
135  m_next = NULL;
136}
137
138wxPropertyValue::wxPropertyValue(bool *val)
139{
140  m_modifiedFlag = false;
141  m_type = wxPropertyValueboolPtr;
142  m_value.boolPtr = val;
143  m_clientData = NULL;
144  m_next = NULL;
145}
146
147wxPropertyValue::wxPropertyValue(float *val)
148{
149  m_modifiedFlag = false;
150  m_type = wxPropertyValueRealPtr;
151  m_value.realPtr = val;
152  m_clientData = NULL;
153  m_next = NULL;
154}
155
156wxPropertyValue::wxPropertyValue(wxList *the_list)
157{
158  m_modifiedFlag = false;
159  m_type = wxPropertyValueList;
160  m_clientData = NULL;
161  m_last = NULL;
162  m_value.first = NULL;
163
164  wxObjectList::compatibility_iterator node = the_list->GetFirst();
165  while (node)
166  {
167    wxPropertyValue *expr = (wxPropertyValue *)node->GetData();
168    Append(expr);
169    node = node->GetNext();
170  }
171
172  delete the_list;
173}
174
175wxPropertyValue::wxPropertyValue(wxStringList *the_list)
176{
177  m_modifiedFlag = false;
178  m_type = wxPropertyValueList;
179  m_clientData = NULL;
180  m_last = NULL;
181  m_value.first = NULL;
182
183  wxStringList::compatibility_iterator node = the_list->GetFirst();
184  while (node)
185  {
186    wxString s = node->GetData();
187    Append(new wxPropertyValue(s));
188    node = node->GetNext();
189  }
190  delete the_list;
191}
192
193wxPropertyValue::~wxPropertyValue(void)
194{
195  switch (m_type)
196  {
197    case wxPropertyValueInteger:
198    case wxPropertyValuebool:
199    case wxPropertyValueReal:
200    {
201     break;
202    }
203   case wxPropertyValueString:
204   {
205     delete[] m_value.string;
206     break;
207   }
208   case wxPropertyValueList:
209   {
210     wxPropertyValue *expr = m_value.first;
211     while (expr)
212     {
213       wxPropertyValue *expr1 = expr->m_next;
214
215       delete expr;
216       expr = expr1;
217     }
218     break;
219   }
220   default:
221   case wxPropertyValueNull: break;
222  }
223}
224
225void wxPropertyValue::Append(wxPropertyValue *expr)
226{
227  m_modifiedFlag = true;
228  if (!m_value.first)
229    m_value.first = expr;
230
231  if (m_last)
232    m_last->m_next = expr;
233  m_last = expr;
234}
235
236void wxPropertyValue::Insert(wxPropertyValue *expr)
237{
238  m_modifiedFlag = true;
239  expr->m_next = m_value.first;
240  m_value.first = expr;
241
242  if (!m_last)
243    m_last = expr;
244}
245
246// Delete from list
247void wxPropertyValue::Delete(wxPropertyValue *node)
248{
249  wxPropertyValue *expr = GetFirst();
250
251  wxPropertyValue *previous = NULL;
252  while (expr && (expr != node))
253  {
254    previous = expr;
255    expr = expr->GetNext();
256  }
257
258  if (expr)
259  {
260    if (previous)
261      previous->m_next = expr->m_next;
262
263    // If node was the first in the list,
264    // make the list point to the NEXT one.
265    if (GetFirst() == expr)
266    {
267      m_value.first = expr->m_next;
268    }
269
270    // If node was the last in the list,
271    // make the list 'last' pointer point to the PREVIOUS one.
272    if (GetLast() == expr)
273    {
274      if (previous)
275        m_last = previous;
276      else
277        m_last = NULL;
278    }
279    m_modifiedFlag = true;
280    delete expr;
281  }
282
283}
284
285void wxPropertyValue::ClearList(void)
286{
287  wxPropertyValue *val = GetFirst();
288  if (val)
289    m_modifiedFlag = true;
290
291  while (val)
292  {
293    wxPropertyValue *next = val->GetNext();
294    delete val;
295    val = next;
296  }
297  m_value.first = NULL;
298  m_last = NULL;
299}
300
301wxPropertyValue *wxPropertyValue::NewCopy(void) const
302{
303  switch (m_type)
304  {
305    case wxPropertyValueInteger:
306      return new wxPropertyValue(m_value.integer);
307    case wxPropertyValuebool:
308      return new wxPropertyValue((bool) (m_value.integer != 0));
309    case wxPropertyValueReal:
310      return new wxPropertyValue(m_value.real);
311    case wxPropertyValueString:
312      return new wxPropertyValue(m_value.string);
313    case wxPropertyValueList:
314    {
315      wxPropertyValue *expr = m_value.first;
316      wxPropertyValue *new_list = new wxPropertyValue;
317      new_list->SetType(wxPropertyValueList);
318      while (expr)
319      {
320        wxPropertyValue *expr2 = expr->NewCopy();
321        new_list->Append(expr2);
322        expr = expr->m_next;
323      }
324      return new_list;
325    }
326   case wxPropertyValueIntegerPtr:
327     return new wxPropertyValue(m_value.integerPtr);
328   case wxPropertyValueRealPtr:
329     return new wxPropertyValue(m_value.realPtr);
330   case wxPropertyValueboolPtr:
331     return new wxPropertyValue(m_value.boolPtr);
332   case wxPropertyValueStringPtr:
333     return new wxPropertyValue(m_value.stringPtr);
334
335   case wxPropertyValueNull:
336    wxFAIL_MSG( wxT("Should never get here!\n" ) );
337    break;
338  }
339  return NULL;
340}
341
342void wxPropertyValue::Copy(wxPropertyValue& copyFrom)
343{
344  if (m_type == wxPropertyValueString)
345  {
346    delete[] m_value.string ;
347    m_value.string = NULL;
348  }
349  m_type = copyFrom.Type();
350
351  switch (m_type)
352  {
353    case wxPropertyValueInteger:
354      (*this) = copyFrom.IntegerValue();
355      return ;
356
357    case wxPropertyValueReal:
358      (*this) = copyFrom.RealValue();
359      return ;
360
361    case wxPropertyValueString:
362      (*this) = wxString(copyFrom.StringValue());
363      return ;
364
365    case wxPropertyValuebool:
366      (*this) = copyFrom.BoolValue();
367      return ;
368
369    // Pointers
370    case wxPropertyValueboolPtr:
371      (*this) = copyFrom.BoolValuePtr();
372      return ;
373    case wxPropertyValueRealPtr:
374      (*this) = copyFrom.RealValuePtr();
375      return ;
376    case wxPropertyValueIntegerPtr:
377      (*this) = copyFrom.IntegerValuePtr();
378      return ;
379    case wxPropertyValueStringPtr:
380    {
381      wxChar** s = copyFrom.StringValuePtr();
382
383#if 0
384      // what is this? are you trying to assign a bool or a string?  VA can't figure it out..
385#if defined(__VISAGECPP__) || defined( __VISUALC__ )
386      (*this) = s;
387#else
388      (*this) = s != 0;
389#endif
390#endif // if 0
391
392      (*this) = (bool)(s != 0);
393
394      return ;
395    }
396
397    case wxPropertyValueList:
398    {
399      m_value.first = NULL;
400      m_next = NULL;
401      m_last = NULL;
402      wxPropertyValue *expr = copyFrom.m_value.first;
403      while (expr)
404      {
405        wxPropertyValue *expr2 = expr->NewCopy();
406        Append(expr2);
407        expr = expr->m_next;
408      }
409      return;
410    }
411   case wxPropertyValueNull:
412    wxFAIL_MSG( wxT("Should never get here!\n" ) );
413    break;
414  }
415}
416
417// Return nth argument of a clause (starting from 1)
418wxPropertyValue *wxPropertyValue::Arg(wxPropertyValueType type, int arg) const
419{
420  wxPropertyValue *expr = m_value.first;
421  for (int i = 1; i < arg; i++)
422    if (expr)
423      expr = expr->m_next;
424
425  if (expr && (expr->m_type == type))
426    return expr;
427  else
428    return NULL;
429}
430
431// Return nth argument of a list expression (starting from zero)
432wxPropertyValue *wxPropertyValue::Nth(int arg) const
433{
434  if (m_type != wxPropertyValueList)
435    return NULL;
436
437  wxPropertyValue *expr = m_value.first;
438  for (int i = 0; i < arg; i++)
439    if (expr)
440      expr = expr->m_next;
441    else return NULL;
442
443  if (expr)
444    return expr;
445  else
446    return NULL;
447}
448
449  // Returns the number of elements in a list expression
450int wxPropertyValue::Number(void) const
451{
452  if (m_type != wxPropertyValueList)
453    return 0;
454
455  int i = 0;
456  wxPropertyValue *expr = m_value.first;
457  while (expr)
458  {
459    expr = expr->m_next;
460    i ++;
461  }
462  return i;
463}
464
465void wxPropertyValue::WritePropertyClause(wxString& stream)  // Write this expression as a top-level clause
466{
467  if (m_type != wxPropertyValueList)
468    return;
469
470  wxPropertyValue *node = m_value.first;
471  if (node)
472  {
473    node->WritePropertyType(stream);
474    stream.Append( wxT("(") );
475    node = node->m_next;
476    bool first = true;
477    while (node)
478    {
479      if (!first)
480        stream.Append( wxT("  ") );
481      node->WritePropertyType(stream);
482      node = node->m_next;
483      if (node)
484        stream.Append( wxT(",\n" ) );
485      first = false;
486    }
487    stream.Append( wxT(").\n\n") );
488  }
489}
490
491void wxPropertyValue::WritePropertyType(wxString& stream)    // Write as any other subexpression
492{
493  wxString tmp;
494  switch (m_type)
495  {
496    case wxPropertyValueInteger:
497    {
498      tmp.Printf( wxT("%ld"), m_value.integer );
499      stream.Append( tmp );
500      break;
501    }
502    case wxPropertyValueIntegerPtr:
503    {
504      tmp.Printf( wxT("%ld"), *m_value.integerPtr );
505      stream.Append( tmp );
506      break;
507    }
508    case wxPropertyValuebool:
509    {
510      if (m_value.integer)
511        stream.Append( wxT("True") );
512      else
513        stream.Append( wxT("False") );
514      break;
515    }
516    case wxPropertyValueboolPtr:
517    {
518      if (*m_value.integerPtr)
519        stream.Append( wxT("True") );
520      else
521        stream.Append( wxT("False") );
522      break;
523    }
524    case wxPropertyValueReal:
525    {
526      double d = m_value.real;
527      tmp.Printf( wxT("%.6g"), d );
528      stream.Append( tmp );
529      break;
530    }
531    case wxPropertyValueRealPtr:
532    {
533      double d = *m_value.realPtr;
534      tmp.Printf( wxT("%.6g"), d );
535      stream.Append( tmp );
536      break;
537    }
538    case wxPropertyValueString:
539    {
540      stream.Append( m_value.string );
541      break;
542    }
543    case wxPropertyValueStringPtr:
544    {
545      wxFAIL_MSG( wxT("wxPropertyValue::WritePropertyType( wxPropertyValueStringPtr ) not implemented") );
546      /*
547      int i;
548      int len = strlen(*(m_value.stringPtr));
549      for (i = 0; i < len; i++)
550      {
551        char ch = *(m_value.stringPtr)[i];
552
553      }
554      */
555      break;
556    }
557    case wxPropertyValueList:
558    {
559      if (!m_value.first)
560        stream.Append( wxT("[]") );
561      else
562      {
563        wxPropertyValue *expr = m_value.first;
564
565        stream.Append( wxT("[") );
566        while (expr)
567        {
568          expr->WritePropertyType(stream);
569          expr = expr->m_next;
570          if (expr)
571        stream.Append( wxT(", ") );
572        }
573        stream.Append( wxT("]") );
574      }
575      break;
576    }
577   case wxPropertyValueNull: break;
578  }
579}
580
581wxString wxPropertyValue::GetStringRepresentation(void)
582{
583  wxString str;
584  WritePropertyType(str);
585  return str;
586}
587
588void wxPropertyValue::operator=(const wxPropertyValue& val)
589{
590  m_modifiedFlag = true;
591  Copy((wxPropertyValue&)val);
592}
593
594// void wxPropertyValue::operator=(const char *val)
595void wxPropertyValue::operator=(const wxString& val1)
596{
597  const wxChar *val = (const wxChar *)val1;
598
599  m_modifiedFlag = true;
600
601  wxPropertyValueType oldType = m_type;
602  if (oldType == wxPropertyValueString)
603  {
604    delete[] m_value.string ;
605    m_value.string = NULL;
606  }
607
608  if (m_type == wxPropertyValueNull)
609    m_type = wxPropertyValueString;
610
611  if (m_type == wxPropertyValueString)
612  {
613    if (val)
614      m_value.string = copystring(val);
615    else
616      m_value.string = NULL;
617  }
618  else if (m_type == wxPropertyValueStringPtr)
619  {
620    wxFAIL_MSG( wxT("Shouldn't try to assign a wxString reference to a char* pointer.") );
621    if (val)
622      *m_value.stringPtr = copystring(val);
623    else
624      *m_value.stringPtr = NULL;
625  }
626
627  m_clientData = NULL;
628  m_next = NULL;
629  m_last = NULL;
630
631}
632
633void wxPropertyValue::operator=(const long val)
634{
635  wxPropertyValueType oldType = m_type;
636  if (oldType == wxPropertyValueString)
637  {
638    delete[] m_value.string ;
639    m_value.string = NULL;
640  }
641
642  m_modifiedFlag = true;
643  if (m_type == wxPropertyValueNull)
644    m_type = wxPropertyValueInteger;
645
646  if (m_type == wxPropertyValueInteger)
647    m_value.integer = val;
648  else if (m_type == wxPropertyValueIntegerPtr)
649    *m_value.integerPtr = val;
650  else if (m_type == wxPropertyValueReal)
651    m_value.real = (float)val;
652  else if (m_type == wxPropertyValueRealPtr)
653    *m_value.realPtr = (float)val;
654
655  m_clientData = NULL;
656  m_next = NULL;
657}
658
659void wxPropertyValue::operator=(const bool val)
660{
661  wxPropertyValueType oldType = m_type;
662  if (oldType == wxPropertyValueString)
663  {
664    delete[] m_value.string ;
665    m_value.string = NULL;
666  }
667
668  m_modifiedFlag = true;
669  if (m_type == wxPropertyValueNull)
670    m_type = wxPropertyValuebool;
671
672  if (m_type == wxPropertyValuebool)
673    m_value.integer = (long)val;
674  else if (m_type == wxPropertyValueboolPtr)
675    *m_value.boolPtr = val;
676
677  m_clientData = NULL;
678  m_next = NULL;
679}
680
681void wxPropertyValue::operator=(const float val)
682{
683  wxPropertyValueType oldType = m_type;
684  if (oldType == wxPropertyValueString)
685  {
686    delete[] m_value.string ;
687    m_value.string = NULL;
688  }
689
690  m_modifiedFlag = true;
691  if (m_type == wxPropertyValueNull)
692    m_type = wxPropertyValueReal;
693
694  if (m_type == wxPropertyValueInteger)
695    m_value.integer = (long)val;
696  else if (m_type == wxPropertyValueIntegerPtr)
697    *m_value.integerPtr = (long)val;
698  else if (m_type == wxPropertyValueReal)
699    m_value.real = val;
700  else if (m_type == wxPropertyValueRealPtr)
701    *m_value.realPtr = val;
702
703  m_clientData = NULL;
704  m_next = NULL;
705}
706
707void wxPropertyValue::operator=(const wxChar **val)
708{
709  wxPropertyValueType oldType = m_type;
710  if (oldType == wxPropertyValueString)
711  {
712    delete[] m_value.string ;
713    m_value.string = NULL;
714  }
715
716  m_modifiedFlag = true;
717  m_type = wxPropertyValueStringPtr;
718
719  if (val)
720    m_value.stringPtr = (wxChar **)val;
721  else
722    m_value.stringPtr = NULL;
723  m_clientData = NULL;
724  m_next = NULL;
725  m_last = NULL;
726
727}
728
729void wxPropertyValue::operator=(const long *val)
730{
731  m_modifiedFlag = true;
732  m_type = wxPropertyValueIntegerPtr;
733  m_value.integerPtr = (long *)val;
734  m_clientData = NULL;
735  m_next = NULL;
736}
737
738void wxPropertyValue::operator=(const bool *val)
739{
740  m_modifiedFlag = true;
741  m_type = wxPropertyValueboolPtr;
742  m_value.boolPtr = (bool *)val;
743  m_clientData = NULL;
744  m_next = NULL;
745}
746
747void wxPropertyValue::operator=(const float *val)
748{
749  m_modifiedFlag = true;
750  m_type = wxPropertyValueRealPtr;
751  m_value.realPtr = (float *)val;
752  m_clientData = NULL;
753  m_next = NULL;
754}
755
756long wxPropertyValue::IntegerValue(void) const
757  {
758    if (m_type == wxPropertyValueInteger)
759      return m_value.integer;
760    else if (m_type == wxPropertyValueReal)
761      return (long)m_value.real;
762    else if (m_type == wxPropertyValueIntegerPtr)
763      return *m_value.integerPtr;
764    else if (m_type == wxPropertyValueRealPtr)
765      return (long)(*m_value.realPtr);
766    else return 0;
767  }
768
769long *wxPropertyValue::IntegerValuePtr(void) const
770{
771  return m_value.integerPtr;
772}
773
774float wxPropertyValue::RealValue(void) const {
775    if (m_type == wxPropertyValueReal)
776      return m_value.real;
777    else if (m_type == wxPropertyValueRealPtr)
778      return *m_value.realPtr;
779    else if (m_type == wxPropertyValueInteger)
780      return (float)m_value.integer;
781    else if (m_type == wxPropertyValueIntegerPtr)
782      return (float)*(m_value.integerPtr);
783    else return 0.0;
784  }
785
786float *wxPropertyValue::RealValuePtr(void) const
787{
788  return m_value.realPtr;
789}
790
791bool wxPropertyValue::BoolValue(void) const {
792    if (m_type == wxPropertyValueReal)
793      return (m_value.real != 0.0);
794    if (m_type == wxPropertyValueRealPtr)
795      return (*(m_value.realPtr) != 0.0);
796    else if (m_type == wxPropertyValueInteger)
797      return (m_value.integer != 0);
798    else if (m_type == wxPropertyValueIntegerPtr)
799      return (*(m_value.integerPtr) != 0);
800    else if (m_type == wxPropertyValuebool)
801      return (m_value.integer != 0);
802    else if (m_type == wxPropertyValueboolPtr)
803      return (*(m_value.boolPtr) != 0);
804    else return false;
805  }
806
807bool *wxPropertyValue::BoolValuePtr(void) const
808{
809  return m_value.boolPtr;
810}
811
812wxChar *wxPropertyValue::StringValue(void) const {
813    if (m_type == wxPropertyValueString)
814      return m_value.string;
815    else if (m_type == wxPropertyValueStringPtr)
816      return *(m_value.stringPtr);
817    else return NULL;
818  }
819
820wxChar **wxPropertyValue::StringValuePtr(void) const
821{
822  return m_value.stringPtr;
823}
824
825/*
826 * A property (name plus value)
827 */
828
829IMPLEMENT_DYNAMIC_CLASS(wxProperty, wxObject)
830
831wxProperty::wxProperty(void)
832{
833  m_propertyRole = wxEmptyString;
834  m_propertyValidator = NULL;
835  m_propertyWindow = NULL;
836  m_enabled = true;
837}
838
839wxProperty::wxProperty(wxProperty& copyFrom)
840    : wxObject()
841{
842  m_value = copyFrom.GetValue();
843  m_name = copyFrom.GetName();
844  m_propertyRole = copyFrom.GetRole();
845  m_propertyValidator = copyFrom.GetValidator();
846  m_enabled = copyFrom.IsEnabled();
847  m_propertyWindow = NULL;
848}
849
850wxProperty::wxProperty(wxString nm, wxString role, wxPropertyValidator *ed):m_name(nm), m_propertyRole(role)
851{
852  m_propertyValidator = ed;
853  m_propertyWindow = NULL;
854  m_enabled = true;
855}
856
857wxProperty::wxProperty(wxString nm, const wxPropertyValue& val, wxString role, wxPropertyValidator *ed):
858  m_value(val), m_name(nm), m_propertyRole(role)
859{
860  m_propertyValidator = ed;
861  m_propertyWindow = NULL;
862  m_enabled = true;
863}
864
865wxProperty::~wxProperty(void)
866{
867  if (m_propertyValidator)
868    delete m_propertyValidator;
869}
870
871wxPropertyValue& wxProperty::GetValue(void) const
872{
873  return (wxPropertyValue&) m_value;
874}
875
876wxPropertyValidator *wxProperty::GetValidator(void) const
877{
878  return m_propertyValidator;
879}
880
881wxString& wxProperty::GetName(void) const
882{
883  return (wxString&) m_name;
884}
885
886wxString& wxProperty::GetRole(void) const
887{
888  return (wxString&) m_propertyRole;
889}
890
891void wxProperty::SetValue(const wxPropertyValue& val)
892{
893  m_value = val;
894}
895
896void wxProperty::SetValidator(wxPropertyValidator *ed)
897{
898  m_propertyValidator = ed;
899}
900
901void wxProperty::SetRole(wxString& role)
902{
903  m_propertyRole = role;
904}
905
906void wxProperty::SetName(wxString& nm)
907{
908  m_name = nm;
909}
910
911void wxProperty::operator=(const wxPropertyValue& val)
912{
913  m_value = val;
914}
915
916/*
917 * Base property view class
918 */
919
920IMPLEMENT_DYNAMIC_CLASS(wxPropertyView, wxEvtHandler)
921
922wxPropertyView::wxPropertyView(long flags)
923{
924  m_buttonFlags = flags;
925  m_propertySheet = NULL;
926  m_currentValidator = NULL;
927  m_currentProperty = NULL;
928}
929
930wxPropertyView::~wxPropertyView(void)
931{
932}
933
934void wxPropertyView::AddRegistry(wxPropertyValidatorRegistry *registry)
935{
936  m_validatorRegistryList.Append(registry);
937}
938
939wxPropertyValidator *wxPropertyView::FindPropertyValidator(wxProperty *property)
940{
941  if (property->GetValidator())
942    return property->GetValidator();
943
944  wxObjectList::compatibility_iterator node = m_validatorRegistryList.GetFirst();
945  while (node)
946  {
947    wxPropertyValidatorRegistry *registry = (wxPropertyValidatorRegistry *)node->GetData();
948    wxPropertyValidator *validator = registry->GetValidator(property->GetRole());
949    if (validator)
950      return validator;
951    node = node->GetNext();
952  }
953  return NULL;
954/*
955  if (!wxDefaultPropertyValidator)
956    wxDefaultPropertyValidator = new wxPropertyListValidator;
957  return wxDefaultPropertyValidator;
958*/
959}
960
961/*
962 * Property sheet
963 */
964
965IMPLEMENT_DYNAMIC_CLASS(wxPropertySheet, wxObject)
966
967wxPropertySheet::wxPropertySheet(const wxString& name)
968:m_properties(wxKEY_STRING),m_name(name)
969{
970}
971
972wxPropertySheet::~wxPropertySheet(void)
973{
974  Clear();
975}
976
977void wxPropertySheet::UpdateAllViews( wxPropertyView *WXUNUSED(thisView) )
978{
979}
980
981// Add a property
982void wxPropertySheet::AddProperty(wxProperty *property)
983{
984  m_properties.Append((const wxChar*) property->GetName(), property);
985}
986
987// Get property by name
988wxProperty *wxPropertySheet::GetProperty(const wxString& name) const
989{
990  wxObjectList::compatibility_iterator node = m_properties.Find((const wxChar*) name);
991  if (!node)
992    return NULL;
993  else
994    return (wxProperty *)node->GetData();
995}
996
997bool wxPropertySheet::SetProperty(const wxString& name, const wxPropertyValue& value)
998{
999  wxProperty* prop = GetProperty(name);
1000  if(prop){
1001    prop->SetValue(value);
1002    return true;
1003  }else{
1004    return false;
1005  }
1006}
1007
1008void wxPropertySheet::RemoveProperty(const wxString& name)
1009{
1010  wxObjectList::compatibility_iterator node = m_properties.Find(name);
1011  if(node)
1012  {
1013    wxProperty *prop = (wxProperty *)node->GetData();
1014     delete prop;
1015    m_properties.Erase(node);
1016  }
1017}
1018
1019bool wxPropertySheet::HasProperty(const wxString& name) const
1020{
1021    return (GetProperty(name)?true:false);
1022}
1023
1024// Clear all properties
1025void wxPropertySheet::Clear(void)
1026{
1027    wxObjectList::compatibility_iterator node = m_properties.GetFirst();
1028    while (node)
1029    {
1030        wxProperty *prop = (wxProperty *)node->GetData();
1031        delete prop;
1032        node = node->GetNext();
1033    }
1034    m_properties.Clear();
1035}
1036
1037// Sets/clears the modified flag for each property value
1038void wxPropertySheet::SetAllModified(bool flag)
1039{
1040  wxObjectList::compatibility_iterator node = m_properties.GetFirst();
1041  while (node)
1042  {
1043    wxProperty *prop = (wxProperty *)node->GetData();
1044    prop->GetValue().SetModified(flag);
1045    node = node->GetNext();
1046  }
1047}
1048
1049/*
1050 * Property validator registry
1051 *
1052 */
1053
1054IMPLEMENT_DYNAMIC_CLASS(wxPropertyValidatorRegistry, wxHashTable)
1055
1056wxPropertyValidatorRegistry::wxPropertyValidatorRegistry(void):wxHashTable(wxKEY_STRING)
1057{
1058}
1059
1060wxPropertyValidatorRegistry::~wxPropertyValidatorRegistry(void)
1061{
1062  ClearRegistry();
1063}
1064
1065void wxPropertyValidatorRegistry::RegisterValidator(const wxString& typeName, wxPropertyValidator *validator)
1066{
1067  Put((const wxChar*) typeName, validator);
1068}
1069
1070wxPropertyValidator *wxPropertyValidatorRegistry::GetValidator(const wxString& typeName)
1071{
1072  return (wxPropertyValidator *)Get((const wxChar*) typeName);
1073}
1074
1075void wxPropertyValidatorRegistry::ClearRegistry(void)
1076{
1077  BeginFind();
1078  wxHashTable::Node *node;
1079  while ((node = Next()) != NULL)
1080  {
1081    delete (wxPropertyValidator *)node->GetData();
1082  }
1083}
1084
1085 /*
1086  * Property validator
1087  */
1088
1089
1090IMPLEMENT_ABSTRACT_CLASS(wxPropertyValidator, wxEvtHandler)
1091
1092wxPropertyValidator::wxPropertyValidator(long flags)
1093{
1094  m_validatorFlags = flags;
1095  m_validatorProperty = NULL;
1096}
1097
1098wxPropertyValidator::~wxPropertyValidator(void)
1099{}
1100
1101bool wxPropertyValidator::StringToFloat (wxChar *s, float *number) {
1102    double num;
1103    bool ok = StringToDouble (s, &num);
1104    *number = (float) num;
1105    return ok;
1106}
1107
1108bool wxPropertyValidator::StringToDouble (wxChar *s, double *number) {
1109    bool ok = true;
1110    wxChar *value_ptr;
1111    *number = wxStrtod (s, &value_ptr);
1112    if (value_ptr) {
1113        int len = wxStrlen (value_ptr);
1114        for (int i = 0; i < len; i++) {
1115            ok = (wxIsspace (value_ptr[i]) != 0);
1116            if (!ok) return false;
1117        }
1118    }
1119    return ok;
1120}
1121
1122bool wxPropertyValidator::StringToInt (wxChar *s, int *number) {
1123    long num;
1124    bool ok = StringToLong (s, &num);
1125    *number = (int) num;
1126    return ok;
1127}
1128
1129bool wxPropertyValidator::StringToLong (wxChar *s, long *number) {
1130    bool ok = true;
1131    wxChar *value_ptr;
1132    *number = wxStrtol (s, &value_ptr, 10);
1133    if (value_ptr) {
1134        int len = wxStrlen (value_ptr);
1135        for (int i = 0; i < len; i++) {
1136            ok = (wxIsspace (value_ptr[i]) != 0);
1137            if (!ok) return false;
1138        }
1139    }
1140    return ok;
1141}
1142
1143wxChar *wxPropertyValidator::FloatToString (float number) {
1144    static wxChar buf[20];
1145    wxSnprintf (buf, 20, wxT("%.6g"), number);
1146    return buf;
1147}
1148
1149wxChar *wxPropertyValidator::DoubleToString (double number) {
1150    static wxChar buf[20];
1151    wxSnprintf (buf, 20, wxT("%.6g"), number);
1152    return buf;
1153}
1154
1155wxChar *wxPropertyValidator::IntToString (int number) {
1156    static wxChar buf[20];
1157
1158    wxSprintf (buf, wxT("%d"), number);
1159    return buf;
1160}
1161
1162wxChar *wxPropertyValidator::LongToString (long number) {
1163    static wxChar buf[20];
1164
1165    wxSprintf (buf, wxT("%ld"), number);
1166    return buf;
1167}
1168
1169#endif // wxUSE_PROPSHEET
1170