src/common/variant.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        variant.cpp
   3 // Purpose:     wxVariant class, container for any type
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     10/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "variant.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx/wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #if wxUSE_IOSTREAMH
  24 #   include <fstream.h>
  25 #else
  26 #   include <fstream>
  27 #   ifdef _MSC_VER
  28         using namespace std;
  29 #   endif
  30 #endif
  31
  32 #include "wx/stream.h"
  33 #include "wx/string.h"
  34 #include "wx/variant.h"
  35
  36 IMPLEMENT_ABSTRACT_CLASS(wxVariantData, wxObject)
  37
  38 wxVariant wxNullVariant;
  39
  40 /*
  41  * wxVariantDataList
  42  */
  43
  44 class WXDLLEXPORT wxVariantDataList: public wxVariantData
  45 {
  46 DECLARE_DYNAMIC_CLASS(wxVariantDataList)
  47 public:
  48     wxVariantDataList() {}
  49     wxVariantDataList(const wxList& list);
  50     ~wxVariantDataList();
  51
  52     wxList& GetValue() const { return (wxList&) m_value; }
  53     void SetValue(const wxList& value) ;
  54
  55     virtual void Copy(wxVariantData& data);
  56     virtual bool Eq(wxVariantData& data) const;
  57     virtual bool Write(ostream& str) const;
  58     virtual bool Write(wxString& str) const;
  59     virtual bool Read(istream& str);
  60     virtual bool Read(wxString& str);
  61     virtual wxString GetType() const { return "list"; };
  62
  63     void Clear();
  64
  65 protected:
  66     wxList  m_value;
  67 };
  68
  69 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataList, wxVariantData)
  70
  71 wxVariantDataList::wxVariantDataList(const wxList& list)
  72 {
  73     SetValue(list);
  74 }
  75
  76 wxVariantDataList::~wxVariantDataList()
  77 {
  78     Clear();
  79 }
  80
  81 void wxVariantDataList::SetValue(const wxList& value)
  82 {
  83     Clear();
  84     wxNode* node = value.First();
  85     while (node)
  86     {
  87         wxVariant* var = (wxVariant*) node->Data();
  88         m_value.Append(new wxVariant(*var));
  89         node = node->Next();
  90     }
  91 }
  92
  93 void wxVariantDataList::Clear()
  94 {
  95     wxNode* node = m_value.First();
  96     while (node)
  97     {
  98         wxVariant* var = (wxVariant*) node->Data();
  99         delete var;
 100         node = node->Next();
 101     }
 102     m_value.Clear();
 103 }
 104
 105 void wxVariantDataList::Copy(wxVariantData& data)
 106 {
 107     wxASSERT_MSG( (data.GetType() == "list"), "wxVariantDataList::Copy: Can't copy to this type of data" );
 108
 109     wxVariantDataList& listData = (wxVariantDataList&) data;
 110
 111     listData.Clear();
 112     wxNode* node = m_value.First();
 113     while (node)
 114     {
 115         wxVariant* var = (wxVariant*) node->Data();
 116         listData.m_value.Append(new wxVariant(*var));
 117         node = node->Next();
 118     }
 119 }
 120
 121 bool wxVariantDataList::Eq(wxVariantData& data) const
 122 {
 123     wxASSERT_MSG( (data.GetType() == "list"), "wxVariantDataList::Eq: argument mismatch" );
 124
 125     wxVariantDataList& listData = (wxVariantDataList&) data;
 126     wxNode* node1 = m_value.First();
 127     wxNode* node2 = listData.GetValue().First();
 128     while (node1 && node2)
 129     {
 130         wxVariant* var1 = (wxVariant*) node1->Data();
 131         wxVariant* var2 = (wxVariant*) node2->Data();
 132         if ((*var1) != (*var2))
 133             return FALSE;
 134         node1 = node1->Next();
 135         node2 = node2->Next();
 136     }
 137     if (node1 || node2) return FALSE;
 138     return TRUE;
 139 }
 140
 141 bool wxVariantDataList::Write(ostream& str) const
 142 {
 143     wxString s;
 144     Write(s);
 145     str << (const char*) s;
 146     return TRUE;
 147 }
 148
 149 bool wxVariantDataList::Write(wxString& str) const
 150 {
 151     str = "";
 152     wxNode* node = m_value.First();
 153     while (node)
 154     {
 155         wxVariant* var = (wxVariant*) node->Data();
 156         if (node != m_value.First())
 157           str += " ";
 158         wxString str1;
 159         str += var->MakeString();
 160         node = node->Next();
 161     }
 162
 163     return TRUE;
 164 }
 165
 166 bool wxVariantDataList::Read(istream& WXUNUSED(str))
 167 {
 168     wxFAIL_MSG("Unimplemented");
 169     // TODO
 170     return FALSE;
 171 }
 172
 173 bool wxVariantDataList::Read(wxString& WXUNUSED(str))
 174 {
 175     wxFAIL_MSG("Unimplemented");
 176     // TODO
 177     return FALSE;
 178 }
 179
 180 /*
 181  * wxVariantDataStringList
 182  */
 183
 184 class WXDLLEXPORT wxVariantDataStringList: public wxVariantData
 185 {
 186 DECLARE_DYNAMIC_CLASS(wxVariantDataStringList)
 187 public:
 188     wxVariantDataStringList() {}
 189     wxVariantDataStringList(const wxStringList& list) { m_value = list; }
 190
 191     wxStringList& GetValue() const { return (wxStringList&) m_value; }
 192     void SetValue(const wxStringList& value);
 193
 194     virtual void Copy(wxVariantData& data);
 195     virtual bool Eq(wxVariantData& data) const;
 196     virtual bool Write(ostream& str) const;
 197     virtual bool Write(wxString& str) const;
 198     virtual bool Read(istream& str);
 199     virtual bool Read(wxString& str);
 200     virtual wxString GetType() const { return "stringlist"; };
 201
 202 protected:
 203     wxStringList  m_value;
 204 };
 205
 206 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataStringList, wxVariantData)
 207
 208 void wxVariantDataStringList::SetValue(const wxStringList& value)
 209 {
 210     m_value = value;
 211 }
 212
 213 void wxVariantDataStringList::Copy(wxVariantData& data)
 214 {
 215     wxASSERT_MSG( (data.GetType() == "stringlist"), "wxVariantDataStringList::Copy: Can't copy to this type of data" );
 216
 217     wxVariantDataStringList& listData = (wxVariantDataStringList&) data;
 218
 219     listData.m_value = m_value ;
 220 }
 221
 222 bool wxVariantDataStringList::Eq(wxVariantData& data) const
 223 {
 224     wxASSERT_MSG( (data.GetType() == "stringlist"), "wxVariantDataStringList::Eq: argument mismatch" );
 225
 226     wxVariantDataStringList& listData = (wxVariantDataStringList&) data;
 227     wxNode* node1 = m_value.First();
 228     wxNode* node2 = listData.GetValue().First();
 229     while (node1 && node2)
 230     {
 231         wxString str1 ((char*) node1->Data());
 232         wxString str2 ((char*) node2->Data());
 233         if (str1 != str2)
 234             return FALSE;
 235         node1 = node1->Next();
 236         node2 = node2->Next();
 237     }
 238     if (node1 || node2) return FALSE;
 239     return TRUE;
 240 }
 241
 242 bool wxVariantDataStringList::Write(ostream& str) const
 243 {
 244     wxString s;
 245     Write(s);
 246     str << (const char*) s;
 247     return TRUE;
 248 }
 249
 250 bool wxVariantDataStringList::Write(wxString& str) const
 251 {
 252     str = "";
 253     wxNode* node = m_value.First();
 254     while (node)
 255     {
 256         char* s = (char*) node->Data();
 257         if (node != m_value.First())
 258           str += " ";
 259         str += s;
 260         node = node->Next();
 261     }
 262
 263     return TRUE;
 264 }
 265
 266 bool wxVariantDataStringList::Read(istream& WXUNUSED(str))
 267 {
 268     wxFAIL_MSG("Unimplemented");
 269     // TODO
 270     return FALSE;
 271 }
 272
 273 bool wxVariantDataStringList::Read(wxString& WXUNUSED(str))
 274 {
 275     wxFAIL_MSG("Unimplemented");
 276     // TODO
 277     return FALSE;
 278 }
 279
 280 /*
 281  * wxVariantDataLong
 282  */
 283
 284 class WXDLLEXPORT wxVariantDataLong: public wxVariantData
 285 {
 286 DECLARE_DYNAMIC_CLASS(wxVariantDataLong)
 287 public:
 288     wxVariantDataLong() { m_value = 0; }
 289     wxVariantDataLong(long value) { m_value = value; }
 290
 291     inline long GetValue() const { return m_value; }
 292     inline void SetValue(long value) { m_value = value; }
 293
 294     virtual void Copy(wxVariantData& data);
 295     virtual bool Eq(wxVariantData& data) const;
 296     virtual bool Write(ostream& str) const;
 297     virtual bool Write(wxString& str) const;
 298     virtual bool Write(wxOutputStream &str) const;
 299     virtual bool Read(istream& str);
 300     virtual bool Read(wxInputStream& str);
 301     virtual bool Read(wxString& str);
 302     virtual wxString GetType() const { return "long"; };
 303
 304 protected:
 305     long m_value;
 306 };
 307
 308 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataLong, wxVariantData)
 309
 310 void wxVariantDataLong::Copy(wxVariantData& data)
 311 {
 312     wxASSERT_MSG( (data.GetType() == "long"), "wxVariantDataLong::Copy: Can't copy to this type of data" );
 313
 314     wxVariantDataLong& otherData = (wxVariantDataLong&) data;
 315
 316     otherData.m_value = m_value;
 317 }
 318
 319 bool wxVariantDataLong::Eq(wxVariantData& data) const
 320 {
 321     wxASSERT_MSG( (data.GetType() == "long"), "wxVariantDataLong::Eq: argument mismatch" );
 322
 323     wxVariantDataLong& otherData = (wxVariantDataLong&) data;
 324
 325     return (otherData.m_value == m_value);
 326 }
 327
 328 bool wxVariantDataLong::Write(ostream& str) const
 329 {
 330     wxString s;
 331     Write(s);
 332     str << (const char*) s;
 333     return TRUE;
 334 }
 335
 336 bool wxVariantDataLong::Write(wxOutputStream& str) const
 337 {
 338     str << m_value;
 339     return TRUE;
 340 }
 341
 342 bool wxVariantDataLong::Write(wxString& str) const
 343 {
 344     str.Printf("%ld", m_value);
 345     return TRUE;
 346 }
 347
 348 bool wxVariantDataLong::Read(istream& str)
 349 {
 350     str >> m_value;
 351     return TRUE;
 352 }
 353
 354 bool wxVariantDataLong::Read(wxInputStream& str)
 355 {
 356    str >> m_value;
 357    return TRUE;
 358 }
 359
 360 bool wxVariantDataLong::Read(wxString& str)
 361 {
 362     m_value = atol((const char*) str);
 363     return TRUE;
 364 }
 365
 366 /*
 367  * wxVariantDataReal
 368  */
 369
 370 class WXDLLEXPORT wxVariantDataReal: public wxVariantData
 371 {
 372 DECLARE_DYNAMIC_CLASS(wxVariantDataReal)
 373 public:
 374     wxVariantDataReal() { m_value = 0.0; }
 375     wxVariantDataReal(double value) { m_value = value; }
 376
 377     inline double GetValue() const { return m_value; }
 378     inline void SetValue(double value) { m_value = value; }
 379
 380     virtual void Copy(wxVariantData& data);
 381     virtual bool Eq(wxVariantData& data) const;
 382     virtual bool Write(ostream& str) const;
 383     virtual bool Write(wxString& str) const;
 384     virtual bool Write(wxOutputStream &str) const;
 385     virtual bool Read(istream& str);
 386     virtual bool Read(wxInputStream& str);
 387     virtual bool Read(wxString& str);
 388     virtual wxString GetType() const { return "double"; };
 389
 390 protected:
 391     double m_value;
 392 };
 393
 394 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataReal, wxVariantData)
 395
 396 void wxVariantDataReal::Copy(wxVariantData& data)
 397 {
 398     wxASSERT_MSG( (data.GetType() == "double"), "wxVariantDataReal::Copy: Can't copy to this type of data" );
 399
 400     wxVariantDataReal& otherData = (wxVariantDataReal&) data;
 401
 402     otherData.m_value = m_value;
 403 }
 404
 405 bool wxVariantDataReal::Eq(wxVariantData& data) const
 406 {
 407     wxASSERT_MSG( (data.GetType() == "double"), "wxVariantDataReal::Eq: argument mismatch" );
 408
 409     wxVariantDataReal& otherData = (wxVariantDataReal&) data;
 410
 411     return (otherData.m_value == m_value);
 412 }
 413
 414 bool wxVariantDataReal::Write(ostream& str) const
 415 {
 416     wxString s;
 417     Write(s);
 418     str << (const char*) s;
 419     return TRUE;
 420 }
 421
 422 bool wxVariantDataReal::Write(wxOutputStream& str) const
 423 {
 424     str << m_value;
 425     return TRUE;
 426 }
 427
 428 bool wxVariantDataReal::Write(wxString& str) const
 429 {
 430     str.Printf("%.4f", m_value);
 431     return TRUE;
 432 }
 433
 434 bool wxVariantDataReal::Read(istream& str)
 435 {
 436     str >> m_value;
 437     return TRUE;
 438 }
 439
 440 bool wxVariantDataReal::Read(wxInputStream& str)
 441 {
 442     str >> (float&)m_value;
 443     return TRUE;
 444 }
 445
 446 bool wxVariantDataReal::Read(wxString& str)
 447 {
 448     m_value = atof((const char*) str);
 449     return TRUE;
 450 }
 451
 452 /*
 453  * wxVariantDataBool
 454  */
 455
 456 class WXDLLEXPORT wxVariantDataBool: public wxVariantData
 457 {
 458 DECLARE_DYNAMIC_CLASS(wxVariantDataBool)
 459 public:
 460     wxVariantDataBool() { m_value = 0; }
 461     wxVariantDataBool(bool value) { m_value = value; }
 462
 463     inline bool GetValue() const { return m_value; }
 464     inline void SetValue(bool value) { m_value = value; }
 465
 466     virtual void Copy(wxVariantData& data);
 467     virtual bool Eq(wxVariantData& data) const;
 468     virtual bool Write(ostream& str) const;
 469     virtual bool Write(wxOutputStream& str) const;
 470     virtual bool Write(wxString& str) const;
 471     virtual bool Read(istream& str);
 472     virtual bool Read(wxInputStream& str);
 473     virtual bool Read(wxString& str);
 474     virtual wxString GetType() const { return "bool"; };
 475
 476 protected:
 477     bool m_value;
 478 };
 479
 480 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataBool, wxVariantData)
 481
 482 void wxVariantDataBool::Copy(wxVariantData& data)
 483 {
 484     wxASSERT_MSG( (data.GetType() == "bool"), "wxVariantDataBool::Copy: Can't copy to this type of data" );
 485
 486     wxVariantDataBool& otherData = (wxVariantDataBool&) data;
 487
 488     otherData.m_value = m_value;
 489 }
 490
 491 bool wxVariantDataBool::Eq(wxVariantData& data) const
 492 {
 493     wxASSERT_MSG( (data.GetType() == "bool"), "wxVariantDataBool::Eq: argument mismatch" );
 494
 495     wxVariantDataBool& otherData = (wxVariantDataBool&) data;
 496
 497     return (otherData.m_value == m_value);
 498 }
 499
 500 bool wxVariantDataBool::Write(ostream& str) const
 501 {
 502     wxString s;
 503     Write(s);
 504     str << (const char*) s;
 505     return TRUE;
 506 }
 507
 508 bool wxVariantDataBool::Write(wxOutputStream& str) const
 509 {
 510     str << (char)m_value;
 511     return TRUE;
 512 }
 513
 514 bool wxVariantDataBool::Write(wxString& str) const
 515 {
 516     str.Printf("%d", (int) m_value);
 517     return TRUE;
 518 }
 519
 520 bool wxVariantDataBool::Read(istream& WXUNUSED(str))
 521 {
 522     wxFAIL_MSG("Unimplemented");
 523 //    str >> (long) m_value;
 524     return FALSE;
 525 }
 526
 527 bool wxVariantDataBool::Read(wxInputStream& str)
 528 {
 529     str >> (char&)m_value;
 530     return TRUE;
 531 }
 532
 533 bool wxVariantDataBool::Read(wxString& str)
 534 {
 535     m_value = (atol((const char*) str) != 0);
 536     return TRUE;
 537 }
 538
 539 /*
 540  * wxVariantDataChar
 541  */
 542
 543 class WXDLLEXPORT wxVariantDataChar: public wxVariantData
 544 {
 545 DECLARE_DYNAMIC_CLASS(wxVariantDataChar)
 546 public:
 547     wxVariantDataChar() { m_value = 0; }
 548     wxVariantDataChar(char value) { m_value = value; }
 549
 550     inline char GetValue() const { return m_value; }
 551     inline void SetValue(char value) { m_value = value; }
 552
 553     virtual void Copy(wxVariantData& data);
 554     virtual bool Eq(wxVariantData& data) const;
 555     virtual bool Write(ostream& str) const;
 556     virtual bool Write(wxOutputStream& str) const;
 557     virtual bool Write(wxString& str) const;
 558     virtual bool Read(istream& str);
 559     virtual bool Read(wxInputStream& str);
 560     virtual bool Read(wxString& str);
 561     virtual wxString GetType() const { return "char"; };
 562
 563 protected:
 564     char m_value;
 565 };
 566
 567 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataChar, wxVariantData)
 568
 569 void wxVariantDataChar::Copy(wxVariantData& data)
 570 {
 571     wxASSERT_MSG( (data.GetType() == "char"), "wxVariantDataChar::Copy: Can't copy to this type of data" );
 572
 573     wxVariantDataChar& otherData = (wxVariantDataChar&) data;
 574
 575     otherData.m_value = m_value;
 576 }
 577
 578 bool wxVariantDataChar::Eq(wxVariantData& data) const
 579 {
 580     wxASSERT_MSG( (data.GetType() == "char"), "wxVariantDataChar::Eq: argument mismatch" );
 581
 582     wxVariantDataChar& otherData = (wxVariantDataChar&) data;
 583
 584     return (otherData.m_value == m_value);
 585 }
 586
 587 bool wxVariantDataChar::Write(ostream& str) const
 588 {
 589     wxString s;
 590     Write(s);
 591     str << (const char*) s;
 592     return TRUE;
 593 }
 594
 595 bool wxVariantDataChar::Write(wxOutputStream& str) const
 596 {
 597     str << m_value;
 598     return TRUE;
 599 }
 600
 601 bool wxVariantDataChar::Write(wxString& str) const
 602 {
 603     str.Printf("%c", m_value);
 604     return TRUE;
 605 }
 606
 607 bool wxVariantDataChar::Read(istream& WXUNUSED(str))
 608 {
 609     wxFAIL_MSG("Unimplemented");
 610 //    str >> m_value;
 611     return FALSE;
 612 }
 613
 614 bool wxVariantDataChar::Read(wxInputStream& str)
 615 {
 616     str >> m_value;
 617     return TRUE;
 618 }
 619
 620 bool wxVariantDataChar::Read(wxString& str)
 621 {
 622     m_value = str[(size_t)0];
 623     return TRUE;
 624 }
 625
 626 /*
 627  * wxVariantDataString
 628  */
 629
 630 class WXDLLEXPORT wxVariantDataString: public wxVariantData
 631 {
 632 DECLARE_DYNAMIC_CLASS(wxVariantDataString)
 633 public:
 634     wxVariantDataString() { }
 635     wxVariantDataString(const wxString& value) { m_value = value; }
 636
 637     inline wxString GetValue() const { return m_value; }
 638     inline void SetValue(const wxString& value) { m_value = value; }
 639
 640     virtual void Copy(wxVariantData& data);
 641     virtual bool Eq(wxVariantData& data) const;
 642     virtual bool Write(ostream& str) const;
 643     virtual bool Write(wxOutputStream& str) const;
 644     virtual bool Write(wxString& str) const;
 645     virtual bool Read(istream& str);
 646     virtual bool Read(wxInputStream& str);
 647     virtual bool Read(wxString& str);
 648     virtual wxString GetType() const { return "string"; };
 649
 650 protected:
 651     wxString m_value;
 652 };
 653
 654 void wxVariantDataString::Copy(wxVariantData& data)
 655 {
 656     wxASSERT_MSG( (data.GetType() == "string"), "wxVariantDataString::Copy: Can't copy to this type of data" );
 657
 658     wxVariantDataString& otherData = (wxVariantDataString&) data;
 659
 660     otherData.m_value = m_value;
 661 }
 662
 663 bool wxVariantDataString::Eq(wxVariantData& data) const
 664 {
 665     wxASSERT_MSG( (data.GetType() == "string"), "wxVariantDataString::Eq: argument mismatch" );
 666
 667     wxVariantDataString& otherData = (wxVariantDataString&) data;
 668
 669     return (otherData.m_value == m_value);
 670 }
 671
 672 bool wxVariantDataString::Write(ostream& str) const
 673 {
 674     str << (const char*) m_value;
 675     return TRUE;
 676 }
 677
 678 bool wxVariantDataString::Write(wxOutputStream& str) const
 679 {
 680     str << (const char*) m_value;
 681     return TRUE;
 682 }
 683
 684 bool wxVariantDataString::Write(wxString& str) const
 685 {
 686     str = m_value;
 687     return TRUE;
 688 }
 689
 690 bool wxVariantDataString::Read(istream& str)
 691 {
 692     str >> m_value;
 693     return TRUE;
 694 }
 695
 696 bool wxVariantDataString::Read(wxInputStream& str)
 697 {
 698     str >> m_value;
 699     return TRUE;
 700 }
 701
 702 bool wxVariantDataString::Read(wxString& str)
 703 {
 704     m_value = str;
 705     return TRUE;
 706 }
 707
 708 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataString, wxVariantData)
 709
 710 /*
 711  * wxVariantDataTime
 712  */
 713
 714 #if wxUSE_TIMEDATE
 715
 716 class wxVariantDataTime: public wxVariantData
 717 {
 718  DECLARE_DYNAMIC_CLASS(wxVariantDataTime)
 719 public:
 720     wxVariantDataTime() { }
 721     wxVariantDataTime(const wxTime& value) { m_value = value; }
 722
 723     inline wxTime GetValue() const { return m_value; }
 724     inline void SetValue(const wxTime& value) { m_value = value; }
 725
 726     virtual void Copy(wxVariantData& data);
 727     virtual bool Eq(wxVariantData& data) const;
 728     virtual bool Write(ostream& str) const;
 729     virtual bool Write(wxString& str) const;
 730     virtual bool Read(istream& str);
 731     virtual bool Read(wxString& str);
 732     virtual wxString GetType() const { return "time"; };
 733         virtual wxVariantData* Clone() { return new wxVariantDataTime; }
 734
 735 protected:
 736     wxTime m_value;
 737 };
 738
 739 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataTime, wxVariantData)
 740
 741 void wxVariantDataTime::Copy(wxVariantData& data)
 742 {
 743     wxASSERT_MSG( (data.GetType() == "time"), "wxVariantDataTime::Copy: Can't copy to this type of data" );
 744
 745     wxVariantDataTime& otherData = (wxVariantDataTime&) data;
 746
 747     otherData.m_value = m_value;
 748 }
 749
 750 bool wxVariantDataTime::Eq(wxVariantData& data) const
 751 {
 752     wxASSERT_MSG( (data.GetType() == "time"), "wxVariantDataTime::Eq: argument mismatch" );
 753
 754     wxVariantDataTime& otherData = (wxVariantDataTime&) data;
 755
 756     return (otherData.m_value == m_value);
 757 }
 758
 759 bool wxVariantDataTime::Write(ostream& str) const
 760 {
 761     wxString s;
 762     Write(s);
 763     str << (const char*) s;
 764     return TRUE;
 765 }
 766
 767 bool wxVariantDataTime::Write(wxString& str) const
 768 {
 769     char*s = m_value.FormatTime();
 770     str = s;
 771     return TRUE;
 772 }
 773
 774 bool wxVariantDataTime::Read(istream& str)
 775 {
 776     // Not implemented
 777     return FALSE;
 778 }
 779
 780 bool wxVariantDataTime::Read(wxString& str)
 781 {
 782     // Not implemented
 783     return FALSE;
 784 }
 785
 786 /*
 787  * wxVariantDataDate
 788  */
 789
 790 class wxVariantDataDate: public wxVariantData
 791 {
 792  DECLARE_DYNAMIC_CLASS(wxVariantDataDate)
 793 public:
 794     wxVariantDataDate() { }
 795     wxVariantDataDate(const wxDate& value) { m_value = value; }
 796
 797     inline wxDate GetValue() const { return m_value; }
 798     inline void SetValue(const wxDate& value) { m_value = value; }
 799
 800     virtual void Copy(wxVariantData& data);
 801     virtual bool Eq(wxVariantData& data) const;
 802     virtual bool Write(ostream& str) const;
 803     virtual bool Write(wxString& str) const;
 804     virtual bool Read(istream& str);
 805     virtual bool Read(wxString& str);
 806     virtual wxString GetType() const { return "date"; };
 807         virtual wxVariantData* Clone() { return new wxVariantDataDate; }
 808
 809 protected:
 810     wxDate m_value;
 811 };
 812
 813 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataDate, wxVariantData)
 814
 815 void wxVariantDataDate::Copy(wxVariantData& data)
 816 {
 817     wxASSERT_MSG( (data.GetType() == "date"), "wxVariantDataDate::Copy: Can't copy to this type of data" );
 818
 819     wxVariantDataDate& otherData = (wxVariantDataDate&) data;
 820
 821     otherData.m_value = m_value;
 822 }
 823
 824 bool wxVariantDataDate::Eq(wxVariantData& data) const
 825 {
 826     wxASSERT_MSG( (data.GetType() == "date"), "wxVariantDataDate::Eq: argument mismatch" );
 827
 828     wxVariantDataDate& otherData = (wxVariantDataDate&) data;
 829
 830     return (otherData.m_value == m_value);
 831 }
 832
 833 bool wxVariantDataDate::Write(ostream& str) const
 834 {
 835     wxString s;
 836     Write(s);
 837     str << (const char*) s;
 838     return TRUE;
 839 }
 840
 841 bool wxVariantDataDate::Write(wxString& str) const
 842 {
 843     str = m_value.FormatDate();
 844     return TRUE;
 845 }
 846
 847 bool wxVariantDataDate::Read(istream& str)
 848 {
 849     // Not implemented
 850     return FALSE;
 851 }
 852
 853 bool wxVariantDataDate::Read(wxString& str)
 854 {
 855     // Not implemented
 856     return FALSE;
 857 }
 858 #endif
 859   // wxUSE_TIMEDATE
 860
 861 /*
 862  * wxVariantDataVoidPtr
 863  */
 864
 865 class wxVariantDataVoidPtr: public wxVariantData
 866 {
 867 DECLARE_DYNAMIC_CLASS(wxVariantDataVoidPtr)
 868 public:
 869     wxVariantDataVoidPtr() { }
 870     wxVariantDataVoidPtr(void* value) { m_value = value; }
 871
 872     inline void* GetValue() const { return m_value; }
 873     inline void SetValue(void* value) { m_value = value; }
 874
 875     virtual void Copy(wxVariantData& data);
 876     virtual bool Eq(wxVariantData& data) const;
 877     virtual bool Write(ostream& str) const;
 878     virtual bool Write(wxString& str) const;
 879     virtual bool Read(istream& str);
 880     virtual bool Read(wxString& str);
 881     virtual wxString GetType() const { return "void*"; };
 882         virtual wxVariantData* Clone() { return new wxVariantDataVoidPtr; }
 883
 884 protected:
 885     void* m_value;
 886 };
 887
 888 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataVoidPtr, wxVariantData)
 889
 890 void wxVariantDataVoidPtr::Copy(wxVariantData& data)
 891 {
 892     wxASSERT_MSG( (data.GetType() == "void*"), "wxVariantDataVoidPtr::Copy: Can't copy to this type of data" );
 893
 894     wxVariantDataVoidPtr& otherData = (wxVariantDataVoidPtr&) data;
 895
 896     otherData.m_value = m_value;
 897 }
 898
 899 bool wxVariantDataVoidPtr::Eq(wxVariantData& data) const
 900 {
 901     wxASSERT_MSG( (data.GetType() == "void*"), "wxVariantDataVoidPtr::Eq: argument mismatch" );
 902
 903     wxVariantDataVoidPtr& otherData = (wxVariantDataVoidPtr&) data;
 904
 905     return (otherData.m_value == m_value);
 906 }
 907
 908 bool wxVariantDataVoidPtr::Write(ostream& str) const
 909 {
 910     wxString s;
 911     Write(s);
 912     str << (const char*) s;
 913     return TRUE;
 914 }
 915
 916 bool wxVariantDataVoidPtr::Write(wxString& str) const
 917 {
 918     char buf[80];
 919     sprintf(buf, "%ld", (long) m_value);
 920     str = buf;
 921     return TRUE;
 922 }
 923
 924 bool wxVariantDataVoidPtr::Read(istream& str)
 925 {
 926     // Not implemented
 927     return FALSE;
 928 }
 929
 930 bool wxVariantDataVoidPtr::Read(wxString& str)
 931 {
 932     // Not implemented
 933     return FALSE;
 934 }
 935
 936
 937 /*
 938  * wxVariant
 939  */
 940
 941 IMPLEMENT_DYNAMIC_CLASS(wxVariant, wxObject)
 942
 943 // Construction & destruction
 944 wxVariant::wxVariant()
 945 {
 946     m_data = (wxVariantData*) NULL;
 947     m_name = wxEmptyString;
 948 }
 949
 950 wxVariant::wxVariant(double val, const wxString& name)
 951 {
 952     m_data = new wxVariantDataReal(val);
 953     m_name = name;
 954 }
 955
 956 wxVariant::wxVariant(long val, const wxString& name)
 957 {
 958     m_data = new wxVariantDataLong(val);
 959     m_name = name;
 960 }
 961
 962 wxVariant::wxVariant(bool val, const wxString& name)
 963 {
 964     m_data = new wxVariantDataBool(val);
 965     m_name = name;
 966 }
 967
 968 wxVariant::wxVariant(char val, const wxString& name)
 969 {
 970     m_data = new wxVariantDataChar(val);
 971     m_name = name;
 972 }
 973
 974 wxVariant::wxVariant(const wxString& val, const wxString& name)
 975 {
 976     m_data = new wxVariantDataString(val);
 977     m_name = name;
 978 }
 979
 980 wxVariant::wxVariant(const char* val, const wxString& name)
 981 {
 982     m_data = new wxVariantDataString(wxString(val));
 983     m_name = name;
 984 }
 985
 986 wxVariant::wxVariant(const wxStringList& val, const wxString& name)
 987 {
 988     m_data = new wxVariantDataStringList(val);
 989     m_name = name;
 990 }
 991
 992 wxVariant::wxVariant(const wxList& val, const wxString& name) // List of variants
 993 {
 994     m_data = new wxVariantDataList(val);
 995     m_name = name;
 996 }
 997
 998 #if wxUSE_TIMEDATE
 999 wxVariant::wxVariant(const wxTime& val, const wxString& name) // Time
1000 {
1001     m_data = new wxVariantDataTime(val);
1002     m_name = name;
1003 }
1004
1005 wxVariant::wxVariant(const wxDate& val, const wxString& name) // Date
1006 {
1007     m_data = new wxVariantDataDate(val);
1008     m_name = name;
1009 }
1010 #endif
1011
1012 wxVariant::wxVariant(void* val, const wxString& name) // Void ptr
1013 {
1014     m_data = new wxVariantDataVoidPtr(val);
1015     m_name = name;
1016 }
1017
1018 wxVariant::wxVariant(const wxVariant& variant)
1019 {
1020     if (!variant.IsNull())
1021     {
1022         m_data = (wxVariantData*) variant.GetData()->GetClassInfo()->CreateObject();
1023         variant.m_data->Copy(*m_data);
1024     }
1025     else
1026         m_data = (wxVariantData*) NULL;
1027     m_name = variant.m_name;
1028 }
1029
1030 wxVariant::wxVariant(wxVariantData* data, const wxString& name) // User-defined data
1031 {
1032     m_data = data;
1033     m_name = name;
1034 }
1035
1036 wxVariant::~wxVariant()
1037 {
1038     delete m_data;
1039 }
1040
1041
1042 // Make NULL (i.e. delete the data)
1043 void wxVariant::MakeNull()
1044 {
1045     delete m_data;
1046     m_data = NULL;
1047 }
1048
1049 // Generic operators
1050 // Assignment
1051 void wxVariant::operator= (const wxVariant& variant)
1052 {
1053     if (variant.IsNull())
1054     {
1055         MakeNull();
1056         return;
1057     }
1058
1059     if (IsNull() || (GetType() != variant.GetType()))
1060     {
1061         if (m_data)
1062             delete m_data;
1063         m_data = (wxVariantData*) variant.GetData()->GetClassInfo()->CreateObject();
1064     }
1065 //    GetData()->Copy(* variant.GetData());
1066     variant.GetData()->Copy(* GetData());
1067 }
1068
1069 // Assignment using data, e.g.
1070 // myVariant = new wxStringVariantData("hello")
1071 void wxVariant::operator= (wxVariantData* variantData)
1072 {
1073     MakeNull();
1074     m_data = variantData;
1075 }
1076
1077 bool wxVariant::operator== (const wxVariant& variant) const
1078 {
1079     if (IsNull() || variant.IsNull())
1080         return (IsNull() == variant.IsNull());
1081
1082     return (GetData()->Eq(* variant.GetData()));
1083 }
1084
1085 bool wxVariant::operator!= (const wxVariant& variant) const
1086 {
1087     return (!(*this == variant));
1088 }
1089
1090
1091 // Specific operators
1092 bool wxVariant::operator== (double value) const
1093 {
1094     double thisValue;
1095     if (!Convert(&thisValue))
1096         return FALSE;
1097     else
1098         return (value == thisValue);
1099 }
1100
1101 bool wxVariant::operator!= (double value) const
1102 {
1103     return (!((*this) == value));
1104 }
1105
1106 void wxVariant::operator= (double value)
1107 {
1108     if (GetType() == "double")
1109     {
1110         ((wxVariantDataReal*)GetData())->SetValue(value);
1111     }
1112     else
1113     {
1114         if (m_data)
1115             delete m_data;
1116         m_data = new wxVariantDataReal(value);
1117     }
1118 }
1119
1120 bool wxVariant::operator== (long value) const
1121 {
1122     long thisValue;
1123     if (!Convert(&thisValue))
1124         return FALSE;
1125     else
1126         return (value == thisValue);
1127 }
1128
1129 bool wxVariant::operator!= (long value) const
1130 {
1131     return (!((*this) == value));
1132 }
1133
1134 void wxVariant::operator= (long value)
1135 {
1136     if (GetType() == "long")
1137     {
1138         ((wxVariantDataLong*)GetData())->SetValue(value);
1139     }
1140     else
1141     {
1142         if (m_data)
1143             delete m_data;
1144         m_data = new wxVariantDataLong(value);
1145     }
1146 }
1147
1148 bool wxVariant::operator== (char value) const
1149 {
1150     char thisValue;
1151     if (!Convert(&thisValue))
1152         return FALSE;
1153     else
1154         return (value == thisValue);
1155 }
1156
1157 bool wxVariant::operator!= (char value) const
1158 {
1159     return (!((*this) == value));
1160 }
1161
1162 void wxVariant::operator= (char value)
1163 {
1164     if (GetType() == "char")
1165     {
1166         ((wxVariantDataChar*)GetData())->SetValue(value);
1167     }
1168     else
1169     {
1170         if (m_data)
1171             delete m_data;
1172         m_data = new wxVariantDataChar(value);
1173     }
1174 }
1175
1176 bool wxVariant::operator== (bool value) const
1177 {
1178     bool thisValue;
1179     if (!Convert(&thisValue))
1180         return FALSE;
1181     else
1182         return (value == thisValue);
1183 }
1184
1185 bool wxVariant::operator!= (bool value) const
1186 {
1187     return (!((*this) == value));
1188 }
1189
1190 void wxVariant::operator= (bool value)
1191 {
1192     if (GetType() == "bool")
1193     {
1194         ((wxVariantDataBool*)GetData())->SetValue(value);
1195     }
1196     else
1197     {
1198         if (m_data)
1199             delete m_data;
1200         m_data = new wxVariantDataBool(value);
1201     }
1202 }
1203
1204 bool wxVariant::operator== (const wxString& value) const
1205 {
1206     wxString thisValue;
1207     if (!Convert(&thisValue))
1208         return FALSE;
1209     else
1210         return (value == thisValue);
1211 }
1212
1213 bool wxVariant::operator!= (const wxString& value) const
1214 {
1215     return (!((*this) == value));
1216 }
1217
1218 void wxVariant::operator= (const wxString& value)
1219 {
1220     if (GetType() == "string")
1221     {
1222         ((wxVariantDataString*)GetData())->SetValue(value);
1223     }
1224     else
1225     {
1226         if (m_data)
1227             delete m_data;
1228         m_data = new wxVariantDataString(value);
1229     }
1230 }
1231
1232 void wxVariant::operator= (const char* value)
1233 {
1234     if (GetType() == "string")
1235     {
1236         ((wxVariantDataString*)GetData())->SetValue(wxString(value));
1237     }
1238     else
1239     {
1240         if (m_data)
1241             delete m_data;
1242         m_data = new wxVariantDataString(wxString(value));
1243     }
1244 }
1245
1246 bool wxVariant::operator== (const wxStringList& value) const
1247 {
1248     wxASSERT_MSG( (GetType() == "stringlist"), "Invalid type for == operator" );
1249
1250     wxVariantDataStringList other(value);
1251     return (m_data->Eq(other));
1252 }
1253
1254 bool wxVariant::operator!= (const wxStringList& value) const
1255 {
1256     return (!((*this) == value));
1257 }
1258
1259 void wxVariant::operator= (const wxStringList& value)
1260 {
1261     if (GetType() == "stringlist")
1262     {
1263         ((wxVariantDataStringList*)GetData())->SetValue(value);
1264     }
1265     else
1266     {
1267         if (m_data)
1268             delete m_data;
1269         m_data = new wxVariantDataStringList(value);
1270     }
1271 }
1272
1273 bool wxVariant::operator== (const wxList& value) const
1274 {
1275     wxASSERT_MSG( (GetType() == "list"), "Invalid type for == operator" );
1276
1277     wxVariantDataList other(value);
1278     return (m_data->Eq(other));
1279 }
1280
1281 bool wxVariant::operator!= (const wxList& value) const
1282 {
1283     return (!((*this) == value));
1284 }
1285
1286 void wxVariant::operator= (const wxList& value)
1287 {
1288     if (GetType() == "list")
1289     {
1290         ((wxVariantDataList*)GetData())->SetValue(value);
1291     }
1292     else
1293     {
1294         if (m_data)
1295             delete m_data;
1296         m_data = new wxVariantDataList(value);
1297     }
1298 }
1299
1300 #if wxUSE_TIMEDATE
1301 bool wxVariant::operator== (const wxTime& value) const
1302 {
1303     wxTime thisValue;
1304     if (!Convert(&thisValue))
1305         return FALSE;
1306     else
1307         return (value == thisValue);
1308 }
1309
1310 bool wxVariant::operator!= (const wxTime& value) const
1311 {
1312     return (!((*this) == value));
1313 }
1314
1315 void wxVariant::operator= (const wxTime& value)
1316 {
1317     if (GetType() == "time")
1318     {
1319         ((wxVariantDataTime*)GetData())->SetValue(value);
1320     }
1321     else
1322     {
1323         if (m_data)
1324             delete m_data;
1325         m_data = new wxVariantDataTime(value);
1326     }
1327 }
1328
1329 bool wxVariant::operator== (const wxDate& value) const
1330 {
1331     wxDate thisValue;
1332     if (!Convert(&thisValue))
1333         return FALSE;
1334     else
1335         return (value == thisValue);
1336 }
1337
1338 bool wxVariant::operator!= (const wxDate& value) const
1339 {
1340     return (!((*this) == value));
1341 }
1342
1343 void wxVariant::operator= (const wxDate& value)
1344 {
1345     if (GetType() == "date")
1346     {
1347         ((wxVariantDataTime*)GetData())->SetValue(value);
1348     }
1349     else
1350     {
1351         if (m_data)
1352             delete m_data;
1353         m_data = new wxVariantDataDate(value);
1354     }
1355 }
1356 #endif
1357
1358 bool wxVariant::operator== (void* value) const
1359 {
1360     return (value == ((wxVariantDataVoidPtr*)GetData())->GetValue());
1361 }
1362
1363 bool wxVariant::operator!= (void* value) const
1364 {
1365     return (!((*this) == value));
1366 }
1367
1368 void wxVariant::operator= (void* value)
1369 {
1370     if (GetType() == "void*")
1371     {
1372         ((wxVariantDataVoidPtr*)GetData())->SetValue(value);
1373     }
1374     else
1375     {
1376         if (m_data)
1377             delete m_data;
1378         m_data = new wxVariantDataVoidPtr(value);
1379     }
1380 }
1381
1382 // Treat a list variant as an array
1383 wxVariant wxVariant::operator[] (size_t idx) const
1384 {
1385     wxASSERT_MSG( (GetType() == "list" || GetType() == "stringlist"), "Invalid type for array operator" );
1386
1387     if (GetType() == "list")
1388     {
1389         wxVariantDataList* data = (wxVariantDataList*) m_data;
1390         wxASSERT_MSG( (idx < (size_t) data->GetValue().Number()), "Invalid index for array" );
1391         return * (wxVariant*) (data->GetValue().Nth(idx)->Data());
1392     }
1393     else if (GetType() == "stringlist")
1394     {
1395         wxVariantDataStringList* data = (wxVariantDataStringList*) m_data;
1396         wxASSERT_MSG( (idx < (size_t) data->GetValue().Number()), "Invalid index for array" );
1397
1398         wxVariant variant( wxString( (char*) (data->GetValue().Nth(idx)->Data()) ));
1399         return variant;
1400     }
1401     return wxNullVariant;
1402 }
1403
1404 wxVariant& wxVariant::operator[] (size_t idx)
1405 {
1406     // We can't return a reference to a variant for a string list, since the string
1407     // is actually stored as a char*, not a variant.
1408
1409     wxASSERT_MSG( (GetType() == "list"), "Invalid type for array operator" );
1410
1411     wxVariantDataList* data = (wxVariantDataList*) m_data;
1412     wxASSERT_MSG( (idx < (size_t) data->GetValue().Number()), "Invalid index for array" );
1413
1414     return * (wxVariant*) (data->GetValue().Nth(idx)->Data());
1415 }
1416
1417 // Return the number of elements in a list
1418 int wxVariant::GetCount() const
1419 {
1420     wxASSERT_MSG( (GetType() == "list" || GetType() == "stringlist"), "Invalid type for GetCount()" );
1421
1422     if (GetType() == "list")
1423     {
1424         wxVariantDataList* data = (wxVariantDataList*) m_data;
1425         return data->GetValue().Number();
1426     }
1427     else if (GetType() == "stringlist")
1428     {
1429         wxVariantDataStringList* data = (wxVariantDataStringList*) m_data;
1430         return data->GetValue().Number();
1431     }
1432     return 0;
1433 }
1434
1435 wxString wxVariant::MakeString() const
1436 {
1437     if (!IsNull())
1438     {
1439         wxString str;
1440         if (GetData()->Write(str))
1441             return str;
1442     }
1443     return wxString("");
1444 }
1445
1446 // Accessors
1447
1448 void wxVariant::SetData(wxVariantData* data)
1449 {
1450     if (m_data) delete m_data;
1451     m_data = data;
1452 }
1453
1454
1455 // Returns a string representing the type of the variant,
1456 // e.g. "string", "bool", "stringlist", "list", "double", "long"
1457 wxString wxVariant::GetType() const
1458 {
1459     if (IsNull())
1460         return wxString("null");
1461     else
1462         return m_data->GetType();
1463 }
1464
1465
1466 bool wxVariant::IsType(const wxString& type) const
1467 {
1468     return (GetType() == type);
1469 }
1470
1471
1472 // Value accessors
1473 double wxVariant::GetReal() const
1474 {
1475     double value;
1476     if (Convert(& value))
1477         return value;
1478     else
1479     {
1480         wxFAIL_MSG("Could not convert to a real number");
1481         return 0.0;
1482     }
1483 }
1484
1485 long wxVariant::GetInteger() const
1486 {
1487     long value;
1488     if (Convert(& value))
1489         return value;
1490     else
1491     {
1492         wxFAIL_MSG("Could not convert to an integer");
1493         return 0;
1494     }
1495 }
1496
1497 char wxVariant::GetChar() const
1498 {
1499     char value;
1500     if (Convert(& value))
1501         return value;
1502     else
1503     {
1504         wxFAIL_MSG("Could not convert to a char");
1505         return 0;
1506     }
1507 }
1508
1509 bool wxVariant::GetBool() const
1510 {
1511     bool value;
1512     if (Convert(& value))
1513         return value;
1514     else
1515     {
1516         wxFAIL_MSG("Could not convert to a bool");
1517         return 0;
1518     }
1519 }
1520
1521 wxString wxVariant::GetString() const
1522 {
1523     wxString value;
1524     if (Convert(& value))
1525         return value;
1526     else
1527     {
1528         wxFAIL_MSG("Could not convert to a string");
1529         return wxString("");
1530     }
1531 }
1532
1533 #if wxUSE_TIMEDATE
1534 wxTime wxVariant::GetTime() const
1535 {
1536     wxTime value;
1537     if (Convert(& value))
1538         return value;
1539     else
1540     {
1541         wxFAIL_MSG("Could not convert to a time");
1542         return wxTime();
1543     }
1544 }
1545
1546 wxDate wxVariant::GetDate() const
1547 {
1548     wxDate value;
1549     if (Convert(& value))
1550         return value;
1551     else
1552     {
1553         wxFAIL_MSG("Could not convert to a date");
1554         return wxDate();
1555     }
1556 }
1557 #endif
1558
1559 void* wxVariant::GetVoidPtr() const
1560 {
1561     wxASSERT( (GetType() == "void*") );
1562
1563     return (void*) ((wxVariantDataVoidPtr*) m_data)->GetValue();
1564 }
1565
1566 wxList& wxVariant::GetList() const
1567 {
1568     wxASSERT( (GetType() == "list") );
1569
1570     return (wxList&) ((wxVariantDataList*) m_data)->GetValue();
1571 }
1572
1573 wxStringList& wxVariant::GetStringList() const
1574 {
1575     wxASSERT( (GetType() == "stringlist") );
1576
1577     return (wxStringList&) ((wxVariantDataStringList*) m_data)->GetValue();
1578 }
1579
1580 // Append to list
1581 void wxVariant::Append(const wxVariant& value)
1582 {
1583     wxList& list = GetList();
1584
1585     list.Append(new wxVariant(value));
1586 }
1587
1588 // Insert at front of list
1589 void wxVariant::Insert(const wxVariant& value)
1590 {
1591     wxList& list = GetList();
1592
1593     list.Insert(new wxVariant(value));
1594 }
1595
1596 // Returns TRUE if the variant is a member of the list
1597 bool wxVariant::Member(const wxVariant& value) const
1598 {
1599     wxList& list = GetList();
1600
1601     wxNode* node = list.First();
1602     while (node)
1603     {
1604         wxVariant* other = (wxVariant*) node->Data();
1605         if (value == *other)
1606             return TRUE;
1607         node = node->Next();
1608     }
1609     return FALSE;
1610 }
1611
1612 // Deletes the nth element of the list
1613 bool wxVariant::Delete(int item)
1614 {
1615     wxList& list = GetList();
1616
1617     wxASSERT_MSG( (item < list.Number()), "Invalid index to Delete" );
1618     wxNode* node = list.Nth(item);
1619     wxVariant* variant = (wxVariant*) node->Data();
1620     delete variant;
1621     delete node;
1622     return TRUE;
1623 }
1624
1625 // Clear list
1626 void wxVariant::ClearList()
1627 {
1628     if (!IsNull() && (GetType() == "list"))
1629     {
1630         ((wxVariantDataList*) m_data)->Clear();
1631     }
1632     else
1633     {
1634         if (GetType() != "list")
1635         {
1636             delete m_data;
1637             m_data = NULL;
1638         }
1639         m_data = new wxVariantDataList;
1640     }
1641 }
1642
1643 // Type conversion
1644 bool wxVariant::Convert(long* value) const
1645 {
1646     wxString type(GetType());
1647     if (type == "double")
1648         *value = (long) (((wxVariantDataReal*)GetData())->GetValue());
1649     else if (type == "long")
1650         *value = ((wxVariantDataLong*)GetData())->GetValue();
1651     else if (type == "bool")
1652         *value = (long) (((wxVariantDataBool*)GetData())->GetValue());
1653     else if (type == "string")
1654         *value = atol((const char*) ((wxVariantDataString*)GetData())->GetValue());
1655     else
1656         return FALSE;
1657
1658     return TRUE;
1659 }
1660
1661 bool wxVariant::Convert(bool* value) const
1662 {
1663     wxString type(GetType());
1664     if (type == "double")
1665         *value = ((int) (((wxVariantDataReal*)GetData())->GetValue()) != 0);
1666     else if (type == "long")
1667         *value = (((wxVariantDataLong*)GetData())->GetValue() != 0);
1668     else if (type == "bool")
1669         *value = ((wxVariantDataBool*)GetData())->GetValue();
1670     else if (type == "string")
1671     {
1672         wxString val(((wxVariantDataString*)GetData())->GetValue());
1673         val.MakeLower();
1674         if (val == "true" || val == "yes")
1675             *value = TRUE;
1676         else if (val == "false" || val == "no")
1677             *value = FALSE;
1678         else
1679             return FALSE;
1680     }
1681     else
1682         return FALSE;
1683
1684     return TRUE;
1685 }
1686
1687 bool wxVariant::Convert(double* value) const
1688 {
1689     wxString type(GetType());
1690     if (type == "double")
1691         *value = ((wxVariantDataReal*)GetData())->GetValue();
1692     else if (type == "long")
1693         *value = (double) (((wxVariantDataLong*)GetData())->GetValue());
1694     else if (type == "bool")
1695         *value = (double) (((wxVariantDataBool*)GetData())->GetValue());
1696     else if (type == "string")
1697         *value = (double) atof((const char*) ((wxVariantDataString*)GetData())->GetValue());
1698     else
1699         return FALSE;
1700
1701     return TRUE;
1702 }
1703
1704 bool wxVariant::Convert(char* value) const
1705 {
1706     wxString type(GetType());
1707     if (type == "char")
1708         *value = ((wxVariantDataChar*)GetData())->GetValue();
1709     else if (type == "long")
1710         *value = (char) (((wxVariantDataLong*)GetData())->GetValue());
1711     else if (type == "bool")
1712         *value = (char) (((wxVariantDataBool*)GetData())->GetValue());
1713     else
1714         return FALSE;
1715
1716     return TRUE;
1717 }
1718
1719 bool wxVariant::Convert(wxString* value) const
1720 {
1721     *value = MakeString();
1722     return TRUE;
1723 }
1724
1725 #if wxUSE_TIMEDATE
1726 bool wxVariant::Convert(wxTime* value) const
1727 {
1728     wxString type(GetType());
1729     if (type == "time")
1730         *value = ((wxVariantDataTime*)GetData())->GetValue();
1731     else if (type == "date")
1732         *value = wxTime(((wxVariantDataDate*)GetData())->GetValue());
1733     else
1734         return FALSE;
1735
1736     return TRUE;
1737 }
1738
1739 bool wxVariant::Convert(wxDate* value) const
1740 {
1741     wxString type(GetType());
1742     if (type == "date")
1743         *value = ((wxVariantDataDate*)GetData())->GetValue();
1744     else
1745         return FALSE;
1746
1747     return TRUE;
1748 }
1749 #endif
1750  // wxUSE_TIMEDATE