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