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 #if defined(__BORLANDC__) && defined(__WIN16__)
 631 // Change name because of truncation
 632 #define wxVariantDataString wxVariantStringData
 633 #endif
 634
 635 class WXDLLEXPORT wxVariantDataString: public wxVariantData
 636 {
 637 #if defined(__BORLANDC__) && defined(__WIN16__)
 638 DECLARE_DYNAMIC_CLASS(wxVariantStringData)
 639 #else
 640 DECLARE_DYNAMIC_CLASS(wxVariantDataString)
 641 #endif
 642 public:
 643     wxVariantDataString() { }
 644     wxVariantDataString(const wxString& value) { m_value = value; }
 645
 646     inline wxString GetValue() const { return m_value; }
 647     inline void SetValue(const wxString& value) { m_value = value; }
 648
 649     virtual void Copy(wxVariantData& data);
 650     virtual bool Eq(wxVariantData& data) const;
 651     virtual bool Write(ostream& str) const;
 652     virtual bool Write(wxOutputStream& str) const;
 653     virtual bool Write(wxString& str) const;
 654     virtual bool Read(istream& str);
 655     virtual bool Read(wxInputStream& str);
 656     virtual bool Read(wxString& str);
 657     virtual wxString GetType() const { return "string"; };
 658
 659 protected:
 660     wxString m_value;
 661 };
 662
 663 void wxVariantDataString::Copy(wxVariantData& data)
 664 {
 665     wxASSERT_MSG( (data.GetType() == "string"), "wxVariantDataString::Copy: Can't copy to this type of data" );
 666
 667     wxVariantDataString& otherData = (wxVariantDataString&) data;
 668
 669     otherData.m_value = m_value;
 670 }
 671
 672 bool wxVariantDataString::Eq(wxVariantData& data) const
 673 {
 674     wxASSERT_MSG( (data.GetType() == "string"), "wxVariantDataString::Eq: argument mismatch" );
 675
 676     wxVariantDataString& otherData = (wxVariantDataString&) data;
 677
 678     return (otherData.m_value == m_value);
 679 }
 680
 681 bool wxVariantDataString::Write(ostream& str) const
 682 {
 683     str << (const char*) m_value;
 684     return TRUE;
 685 }
 686
 687 bool wxVariantDataString::Write(wxOutputStream& str) const
 688 {
 689     str << (const char*) m_value;
 690     return TRUE;
 691 }
 692
 693 bool wxVariantDataString::Write(wxString& str) const
 694 {
 695     str = m_value;
 696     return TRUE;
 697 }
 698
 699 bool wxVariantDataString::Read(istream& str)
 700 {
 701     str >> m_value;
 702     return TRUE;
 703 }
 704
 705 bool wxVariantDataString::Read(wxInputStream& str)
 706 {
 707     str >> m_value;
 708     return TRUE;
 709 }
 710
 711 bool wxVariantDataString::Read(wxString& str)
 712 {
 713     m_value = str;
 714     return TRUE;
 715 }
 716
 717 #if defined(__BORLANDC__) && defined(__WIN16__)
 718 IMPLEMENT_DYNAMIC_CLASS(wxVariantStringData, wxVariantData)
 719 #else
 720 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataString, wxVariantData)
 721 #endif
 722
 723 /*
 724  * wxVariantDataTime
 725  */
 726
 727 #if wxUSE_TIMEDATE
 728
 729 class wxVariantDataTime: public wxVariantData
 730 {
 731  DECLARE_DYNAMIC_CLASS(wxVariantDataTime)
 732 public:
 733     wxVariantDataTime() { }
 734     wxVariantDataTime(const wxTime& value) { m_value = value; }
 735
 736     inline wxTime GetValue() const { return m_value; }
 737     inline void SetValue(const wxTime& value) { m_value = value; }
 738
 739     virtual void Copy(wxVariantData& data);
 740     virtual bool Eq(wxVariantData& data) const;
 741     virtual bool Write(ostream& str) const;
 742     virtual bool Write(wxString& str) const;
 743     virtual bool Read(istream& str);
 744     virtual bool Read(wxString& str);
 745     virtual wxString GetType() const { return "time"; };
 746         virtual wxVariantData* Clone() { return new wxVariantDataTime; }
 747
 748 protected:
 749     wxTime m_value;
 750 };
 751
 752 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataTime, wxVariantData)
 753
 754 void wxVariantDataTime::Copy(wxVariantData& data)
 755 {
 756     wxASSERT_MSG( (data.GetType() == "time"), "wxVariantDataTime::Copy: Can't copy to this type of data" );
 757
 758     wxVariantDataTime& otherData = (wxVariantDataTime&) data;
 759
 760     otherData.m_value = m_value;
 761 }
 762
 763 bool wxVariantDataTime::Eq(wxVariantData& data) const
 764 {
 765     wxASSERT_MSG( (data.GetType() == "time"), "wxVariantDataTime::Eq: argument mismatch" );
 766
 767     wxVariantDataTime& otherData = (wxVariantDataTime&) data;
 768
 769     return (otherData.m_value == m_value);
 770 }
 771
 772 bool wxVariantDataTime::Write(ostream& str) const
 773 {
 774     wxString s;
 775     Write(s);
 776     str << (const char*) s;
 777     return TRUE;
 778 }
 779
 780 bool wxVariantDataTime::Write(wxString& str) const
 781 {
 782     char*s = m_value.FormatTime();
 783     str = s;
 784     return TRUE;
 785 }
 786
 787 bool wxVariantDataTime::Read(istream& WXUNUSED(str))
 788 {
 789     // Not implemented
 790     return FALSE;
 791 }
 792
 793 bool wxVariantDataTime::Read(wxString& WXUNUSED(str))
 794 {
 795     // Not implemented
 796     return FALSE;
 797 }
 798
 799 /*
 800  * wxVariantDataDate
 801  */
 802
 803 class wxVariantDataDate: public wxVariantData
 804 {
 805  DECLARE_DYNAMIC_CLASS(wxVariantDataDate)
 806 public:
 807     wxVariantDataDate() { }
 808     wxVariantDataDate(const wxDate& value) { m_value = value; }
 809
 810     inline wxDate GetValue() const { return m_value; }
 811     inline void SetValue(const wxDate& value) { m_value = value; }
 812
 813     virtual void Copy(wxVariantData& data);
 814     virtual bool Eq(wxVariantData& data) const;
 815     virtual bool Write(ostream& str) const;
 816     virtual bool Write(wxString& str) const;
 817     virtual bool Read(istream& str);
 818     virtual bool Read(wxString& str);
 819     virtual wxString GetType() const { return "date"; };
 820         virtual wxVariantData* Clone() { return new wxVariantDataDate; }
 821
 822 protected:
 823     wxDate m_value;
 824 };
 825
 826 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataDate, wxVariantData)
 827
 828 void wxVariantDataDate::Copy(wxVariantData& data)
 829 {
 830     wxASSERT_MSG( (data.GetType() == "date"), "wxVariantDataDate::Copy: Can't copy to this type of data" );
 831
 832     wxVariantDataDate& otherData = (wxVariantDataDate&) data;
 833
 834     otherData.m_value = m_value;
 835 }
 836
 837 bool wxVariantDataDate::Eq(wxVariantData& data) const
 838 {
 839     wxASSERT_MSG( (data.GetType() == "date"), "wxVariantDataDate::Eq: argument mismatch" );
 840
 841     wxVariantDataDate& otherData = (wxVariantDataDate&) data;
 842
 843     return (otherData.m_value == m_value);
 844 }
 845
 846 bool wxVariantDataDate::Write(ostream& str) const
 847 {
 848     wxString s;
 849     Write(s);
 850     str << (const char*) s;
 851     return TRUE;
 852 }
 853
 854 bool wxVariantDataDate::Write(wxString& str) const
 855 {
 856     str = m_value.FormatDate();
 857     return TRUE;
 858 }
 859
 860 bool wxVariantDataDate::Read(istream& WXUNUSED(str))
 861 {
 862     // Not implemented
 863     return FALSE;
 864 }
 865
 866 bool wxVariantDataDate::Read(wxString& WXUNUSED(str))
 867 {
 868     // Not implemented
 869     return FALSE;
 870 }
 871 #endif
 872   // wxUSE_TIMEDATE
 873
 874 /*
 875  * wxVariantDataVoidPtr
 876  */
 877
 878 class wxVariantDataVoidPtr: public wxVariantData
 879 {
 880 DECLARE_DYNAMIC_CLASS(wxVariantDataVoidPtr)
 881 public:
 882     wxVariantDataVoidPtr() { }
 883     wxVariantDataVoidPtr(void* value) { m_value = value; }
 884
 885     inline void* GetValue() const { return m_value; }
 886     inline void SetValue(void* value) { m_value = value; }
 887
 888     virtual void Copy(wxVariantData& data);
 889     virtual bool Eq(wxVariantData& data) const;
 890     virtual bool Write(ostream& str) const;
 891     virtual bool Write(wxString& str) const;
 892     virtual bool Read(istream& str);
 893     virtual bool Read(wxString& str);
 894     virtual wxString GetType() const { return "void*"; };
 895         virtual wxVariantData* Clone() { return new wxVariantDataVoidPtr; }
 896
 897 protected:
 898     void* m_value;
 899 };
 900
 901 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataVoidPtr, wxVariantData)
 902
 903 void wxVariantDataVoidPtr::Copy(wxVariantData& data)
 904 {
 905     wxASSERT_MSG( (data.GetType() == "void*"), "wxVariantDataVoidPtr::Copy: Can't copy to this type of data" );
 906
 907     wxVariantDataVoidPtr& otherData = (wxVariantDataVoidPtr&) data;
 908
 909     otherData.m_value = m_value;
 910 }
 911
 912 bool wxVariantDataVoidPtr::Eq(wxVariantData& data) const
 913 {
 914     wxASSERT_MSG( (data.GetType() == "void*"), "wxVariantDataVoidPtr::Eq: argument mismatch" );
 915
 916     wxVariantDataVoidPtr& otherData = (wxVariantDataVoidPtr&) data;
 917
 918     return (otherData.m_value == m_value);
 919 }
 920
 921 bool wxVariantDataVoidPtr::Write(ostream& str) const
 922 {
 923     wxString s;
 924     Write(s);
 925     str << (const char*) s;
 926     return TRUE;
 927 }
 928
 929 bool wxVariantDataVoidPtr::Write(wxString& str) const
 930 {
 931     char buf[80];
 932     sprintf(buf, "%ld", (long) m_value);
 933     str = buf;
 934     return TRUE;
 935 }
 936
 937 bool wxVariantDataVoidPtr::Read(istream& WXUNUSED(str))
 938 {
 939     // Not implemented
 940     return FALSE;
 941 }
 942
 943 bool wxVariantDataVoidPtr::Read(wxString& WXUNUSED(str))
 944 {
 945     // Not implemented
 946     return FALSE;
 947 }
 948
 949
 950 /*
 951  * wxVariant
 952  */
 953
 954 IMPLEMENT_DYNAMIC_CLASS(wxVariant, wxObject)
 955
 956 // Construction & destruction
 957 wxVariant::wxVariant()
 958 {
 959     m_data = (wxVariantData*) NULL;
 960 }
 961
 962 wxVariant::wxVariant(double val, const wxString& name)
 963 {
 964     m_data = new wxVariantDataReal(val);
 965     m_name = name;
 966 }
 967
 968 wxVariant::wxVariant(long val, const wxString& name)
 969 {
 970     m_data = new wxVariantDataLong(val);
 971     m_name = name;
 972 }
 973
 974 wxVariant::wxVariant(bool val, const wxString& name)
 975 {
 976     m_data = new wxVariantDataBool(val);
 977     m_name = name;
 978 }
 979
 980 wxVariant::wxVariant(char val, const wxString& name)
 981 {
 982     m_data = new wxVariantDataChar(val);
 983     m_name = name;
 984 }
 985
 986 wxVariant::wxVariant(const wxString& val, const wxString& name)
 987 {
 988     m_data = new wxVariantDataString(val);
 989     m_name = name;
 990 }
 991
 992 wxVariant::wxVariant(const char* val, const wxString& name)
 993 {
 994     m_data = new wxVariantDataString(wxString(val));
 995     m_name = name;
 996 }
 997
 998 wxVariant::wxVariant(const wxStringList& val, const wxString& name)
 999 {
1000     m_data = new wxVariantDataStringList(val);
1001     m_name = name;
1002 }
1003
1004 wxVariant::wxVariant(const wxList& val, const wxString& name) // List of variants
1005 {
1006     m_data = new wxVariantDataList(val);
1007     m_name = name;
1008 }
1009
1010 #if wxUSE_TIMEDATE
1011 wxVariant::wxVariant(const wxTime& val, const wxString& name) // Time
1012 {
1013     m_data = new wxVariantDataTime(val);
1014     m_name = name;
1015 }
1016
1017 wxVariant::wxVariant(const wxDate& val, const wxString& name) // Date
1018 {
1019     m_data = new wxVariantDataDate(val);
1020     m_name = name;
1021 }
1022 #endif
1023
1024 wxVariant::wxVariant(void* val, const wxString& name) // Void ptr
1025 {
1026     m_data = new wxVariantDataVoidPtr(val);
1027     m_name = name;
1028 }
1029
1030 wxVariant::wxVariant(const wxVariant& variant)
1031 {
1032     if (!variant.IsNull())
1033     {
1034         m_data = (wxVariantData*) variant.GetData()->GetClassInfo()->CreateObject();
1035         variant.m_data->Copy(*m_data);
1036     }
1037     else
1038         m_data = (wxVariantData*) NULL;
1039     m_name = variant.m_name;
1040 }
1041
1042 wxVariant::wxVariant(wxVariantData* data, const wxString& name) // User-defined data
1043 {
1044     m_data = data;
1045     m_name = name;
1046 }
1047
1048 wxVariant::~wxVariant()
1049 {
1050     delete m_data;
1051 }
1052
1053
1054 // Make NULL (i.e. delete the data)
1055 void wxVariant::MakeNull()
1056 {
1057     delete m_data;
1058     m_data = NULL;
1059 }
1060
1061 // Generic operators
1062 // Assignment
1063 void wxVariant::operator= (const wxVariant& variant)
1064 {
1065     if (variant.IsNull())
1066     {
1067         MakeNull();
1068         return;
1069     }
1070
1071     if (IsNull() || (GetType() != variant.GetType()))
1072     {
1073         if (m_data)
1074             delete m_data;
1075         m_data = (wxVariantData*) variant.GetData()->GetClassInfo()->CreateObject();
1076     }
1077 //    GetData()->Copy(* variant.GetData());
1078     variant.GetData()->Copy(* GetData());
1079 }
1080
1081 // Assignment using data, e.g.
1082 // myVariant = new wxStringVariantData("hello")
1083 void wxVariant::operator= (wxVariantData* variantData)
1084 {
1085     MakeNull();
1086     m_data = variantData;
1087 }
1088
1089 bool wxVariant::operator== (const wxVariant& variant) const
1090 {
1091     if (IsNull() || variant.IsNull())
1092         return (IsNull() == variant.IsNull());
1093
1094     return (GetData()->Eq(* variant.GetData()));
1095 }
1096
1097 bool wxVariant::operator!= (const wxVariant& variant) const
1098 {
1099     return (!(*this == variant));
1100 }
1101
1102
1103 // Specific operators
1104 bool wxVariant::operator== (double value) const
1105 {
1106     double thisValue;
1107     if (!Convert(&thisValue))
1108         return FALSE;
1109     else
1110         return (value == thisValue);
1111 }
1112
1113 bool wxVariant::operator!= (double value) const
1114 {
1115     return (!((*this) == value));
1116 }
1117
1118 void wxVariant::operator= (double value)
1119 {
1120     if (GetType() == "double")
1121     {
1122         ((wxVariantDataReal*)GetData())->SetValue(value);
1123     }
1124     else
1125     {
1126         if (m_data)
1127             delete m_data;
1128         m_data = new wxVariantDataReal(value);
1129     }
1130 }
1131
1132 bool wxVariant::operator== (long value) const
1133 {
1134     long thisValue;
1135     if (!Convert(&thisValue))
1136         return FALSE;
1137     else
1138         return (value == thisValue);
1139 }
1140
1141 bool wxVariant::operator!= (long value) const
1142 {
1143     return (!((*this) == value));
1144 }
1145
1146 void wxVariant::operator= (long value)
1147 {
1148     if (GetType() == "long")
1149     {
1150         ((wxVariantDataLong*)GetData())->SetValue(value);
1151     }
1152     else
1153     {
1154         if (m_data)
1155             delete m_data;
1156         m_data = new wxVariantDataLong(value);
1157     }
1158 }
1159
1160 bool wxVariant::operator== (char value) const
1161 {
1162     char thisValue;
1163     if (!Convert(&thisValue))
1164         return FALSE;
1165     else
1166         return (value == thisValue);
1167 }
1168
1169 bool wxVariant::operator!= (char value) const
1170 {
1171     return (!((*this) == value));
1172 }
1173
1174 void wxVariant::operator= (char value)
1175 {
1176     if (GetType() == "char")
1177     {
1178         ((wxVariantDataChar*)GetData())->SetValue(value);
1179     }
1180     else
1181     {
1182         if (m_data)
1183             delete m_data;
1184         m_data = new wxVariantDataChar(value);
1185     }
1186 }
1187
1188 bool wxVariant::operator== (bool value) const
1189 {
1190     bool thisValue;
1191     if (!Convert(&thisValue))
1192         return FALSE;
1193     else
1194         return (value == thisValue);
1195 }
1196
1197 bool wxVariant::operator!= (bool value) const
1198 {
1199     return (!((*this) == value));
1200 }
1201
1202 void wxVariant::operator= (bool value)
1203 {
1204     if (GetType() == "bool")
1205     {
1206         ((wxVariantDataBool*)GetData())->SetValue(value);
1207     }
1208     else
1209     {
1210         if (m_data)
1211             delete m_data;
1212         m_data = new wxVariantDataBool(value);
1213     }
1214 }
1215
1216 bool wxVariant::operator== (const wxString& value) const
1217 {
1218     wxString thisValue;
1219     if (!Convert(&thisValue))
1220         return FALSE;
1221     else
1222         return (value == thisValue);
1223 }
1224
1225 bool wxVariant::operator!= (const wxString& value) const
1226 {
1227     return (!((*this) == value));
1228 }
1229
1230 void wxVariant::operator= (const wxString& value)
1231 {
1232     if (GetType() == "string")
1233     {
1234         ((wxVariantDataString*)GetData())->SetValue(value);
1235     }
1236     else
1237     {
1238         if (m_data)
1239             delete m_data;
1240         m_data = new wxVariantDataString(value);
1241     }
1242 }
1243
1244 void wxVariant::operator= (const char* value)
1245 {
1246     if (GetType() == "string")
1247     {
1248         ((wxVariantDataString*)GetData())->SetValue(wxString(value));
1249     }
1250     else
1251     {
1252         if (m_data)
1253             delete m_data;
1254         m_data = new wxVariantDataString(wxString(value));
1255     }
1256 }
1257
1258 bool wxVariant::operator== (const wxStringList& value) const
1259 {
1260     wxASSERT_MSG( (GetType() == "stringlist"), "Invalid type for == operator" );
1261
1262     wxVariantDataStringList other(value);
1263     return (m_data->Eq(other));
1264 }
1265
1266 bool wxVariant::operator!= (const wxStringList& value) const
1267 {
1268     return (!((*this) == value));
1269 }
1270
1271 void wxVariant::operator= (const wxStringList& value)
1272 {
1273     if (GetType() == "stringlist")
1274     {
1275         ((wxVariantDataStringList*)GetData())->SetValue(value);
1276     }
1277     else
1278     {
1279         if (m_data)
1280             delete m_data;
1281         m_data = new wxVariantDataStringList(value);
1282     }
1283 }
1284
1285 bool wxVariant::operator== (const wxList& value) const
1286 {
1287     wxASSERT_MSG( (GetType() == "list"), "Invalid type for == operator" );
1288
1289     wxVariantDataList other(value);
1290     return (m_data->Eq(other));
1291 }
1292
1293 bool wxVariant::operator!= (const wxList& value) const
1294 {
1295     return (!((*this) == value));
1296 }
1297
1298 void wxVariant::operator= (const wxList& value)
1299 {
1300     if (GetType() == "list")
1301     {
1302         ((wxVariantDataList*)GetData())->SetValue(value);
1303     }
1304     else
1305     {
1306         if (m_data)
1307             delete m_data;
1308         m_data = new wxVariantDataList(value);
1309     }
1310 }
1311
1312 #if wxUSE_TIMEDATE
1313 bool wxVariant::operator== (const wxTime& value) const
1314 {
1315     wxTime thisValue;
1316     if (!Convert(&thisValue))
1317         return FALSE;
1318     else
1319         return (value == thisValue);
1320 }
1321
1322 bool wxVariant::operator!= (const wxTime& value) const
1323 {
1324     return (!((*this) == value));
1325 }
1326
1327 void wxVariant::operator= (const wxTime& value)
1328 {
1329     if (GetType() == "time")
1330     {
1331         ((wxVariantDataTime*)GetData())->SetValue(value);
1332     }
1333     else
1334     {
1335         if (m_data)
1336             delete m_data;
1337         m_data = new wxVariantDataTime(value);
1338     }
1339 }
1340
1341 bool wxVariant::operator== (const wxDate& value) const
1342 {
1343     wxDate thisValue;
1344     if (!Convert(&thisValue))
1345         return FALSE;
1346     else
1347         return (value == thisValue);
1348 }
1349
1350 bool wxVariant::operator!= (const wxDate& value) const
1351 {
1352     return (!((*this) == value));
1353 }
1354
1355 void wxVariant::operator= (const wxDate& value)
1356 {
1357     if (GetType() == "date")
1358     {
1359         ((wxVariantDataTime*)GetData())->SetValue(value);
1360     }
1361     else
1362     {
1363         if (m_data)
1364             delete m_data;
1365         m_data = new wxVariantDataDate(value);
1366     }
1367 }
1368 #endif
1369
1370 bool wxVariant::operator== (void* value) const
1371 {
1372     return (value == ((wxVariantDataVoidPtr*)GetData())->GetValue());
1373 }
1374
1375 bool wxVariant::operator!= (void* value) const
1376 {
1377     return (!((*this) == value));
1378 }
1379
1380 void wxVariant::operator= (void* value)
1381 {
1382     if (GetType() == "void*")
1383     {
1384         ((wxVariantDataVoidPtr*)GetData())->SetValue(value);
1385     }
1386     else
1387     {
1388         if (m_data)
1389             delete m_data;
1390         m_data = new wxVariantDataVoidPtr(value);
1391     }
1392 }
1393
1394 // Treat a list variant as an array
1395 wxVariant wxVariant::operator[] (size_t idx) const
1396 {
1397     wxASSERT_MSG( (GetType() == "list" || GetType() == "stringlist"), "Invalid type for array operator" );
1398
1399     if (GetType() == "list")
1400     {
1401         wxVariantDataList* data = (wxVariantDataList*) m_data;
1402         wxASSERT_MSG( (idx < (size_t) data->GetValue().Number()), "Invalid index for array" );
1403         return * (wxVariant*) (data->GetValue().Nth(idx)->Data());
1404     }
1405     else if (GetType() == "stringlist")
1406     {
1407         wxVariantDataStringList* data = (wxVariantDataStringList*) m_data;
1408         wxASSERT_MSG( (idx < (size_t) data->GetValue().Number()), "Invalid index for array" );
1409
1410         wxVariant variant( wxString( (char*) (data->GetValue().Nth(idx)->Data()) ));
1411         return variant;
1412     }
1413     return wxNullVariant;
1414 }
1415
1416 wxVariant& wxVariant::operator[] (size_t idx)
1417 {
1418     // We can't return a reference to a variant for a string list, since the string
1419     // is actually stored as a char*, not a variant.
1420
1421     wxASSERT_MSG( (GetType() == "list"), "Invalid type for array operator" );
1422
1423     wxVariantDataList* data = (wxVariantDataList*) m_data;
1424     wxASSERT_MSG( (idx < (size_t) data->GetValue().Number()), "Invalid index for array" );
1425
1426     return * (wxVariant*) (data->GetValue().Nth(idx)->Data());
1427 }
1428
1429 // Return the number of elements in a list
1430 int wxVariant::GetCount() const
1431 {
1432     wxASSERT_MSG( (GetType() == "list" || GetType() == "stringlist"), "Invalid type for GetCount()" );
1433
1434     if (GetType() == "list")
1435     {
1436         wxVariantDataList* data = (wxVariantDataList*) m_data;
1437         return data->GetValue().Number();
1438     }
1439     else if (GetType() == "stringlist")
1440     {
1441         wxVariantDataStringList* data = (wxVariantDataStringList*) m_data;
1442         return data->GetValue().Number();
1443     }
1444     return 0;
1445 }
1446
1447 wxString wxVariant::MakeString() const
1448 {
1449     if (!IsNull())
1450     {
1451         wxString str;
1452         if (GetData()->Write(str))
1453             return str;
1454     }
1455     return wxString("");
1456 }
1457
1458 // Accessors
1459
1460 void wxVariant::SetData(wxVariantData* data)
1461 {
1462     if (m_data) delete m_data;
1463     m_data = data;
1464 }
1465
1466
1467 // Returns a string representing the type of the variant,
1468 // e.g. "string", "bool", "stringlist", "list", "double", "long"
1469 wxString wxVariant::GetType() const
1470 {
1471     if (IsNull())
1472         return wxString("null");
1473     else
1474         return m_data->GetType();
1475 }
1476
1477
1478 bool wxVariant::IsType(const wxString& type) const
1479 {
1480     return (GetType() == type);
1481 }
1482
1483
1484 // Value accessors
1485 double wxVariant::GetReal() const
1486 {
1487     double value;
1488     if (Convert(& value))
1489         return value;
1490     else
1491     {
1492         wxFAIL_MSG("Could not convert to a real number");
1493         return 0.0;
1494     }
1495 }
1496
1497 long wxVariant::GetInteger() const
1498 {
1499     long value;
1500     if (Convert(& value))
1501         return value;
1502     else
1503     {
1504         wxFAIL_MSG("Could not convert to an integer");
1505         return 0;
1506     }
1507 }
1508
1509 char wxVariant::GetChar() const
1510 {
1511     char value;
1512     if (Convert(& value))
1513         return value;
1514     else
1515     {
1516         wxFAIL_MSG("Could not convert to a char");
1517         return 0;
1518     }
1519 }
1520
1521 bool wxVariant::GetBool() const
1522 {
1523     bool value;
1524     if (Convert(& value))
1525         return value;
1526     else
1527     {
1528         wxFAIL_MSG("Could not convert to a bool");
1529         return 0;
1530     }
1531 }
1532
1533 wxString wxVariant::GetString() const
1534 {
1535     wxString value;
1536     if (Convert(& value))
1537         return value;
1538     else
1539     {
1540         wxFAIL_MSG("Could not convert to a string");
1541         return wxString("");
1542     }
1543 }
1544
1545 #if wxUSE_TIMEDATE
1546 wxTime wxVariant::GetTime() const
1547 {
1548     wxTime value;
1549     if (Convert(& value))
1550         return value;
1551     else
1552     {
1553         wxFAIL_MSG("Could not convert to a time");
1554         return wxTime();
1555     }
1556 }
1557
1558 wxDate wxVariant::GetDate() const
1559 {
1560     wxDate value;
1561     if (Convert(& value))
1562         return value;
1563     else
1564     {
1565         wxFAIL_MSG("Could not convert to a date");
1566         return wxDate();
1567     }
1568 }
1569 #endif
1570
1571 void* wxVariant::GetVoidPtr() const
1572 {
1573     wxASSERT( (GetType() == "void*") );
1574
1575     return (void*) ((wxVariantDataVoidPtr*) m_data)->GetValue();
1576 }
1577
1578 wxList& wxVariant::GetList() const
1579 {
1580     wxASSERT( (GetType() == "list") );
1581
1582     return (wxList&) ((wxVariantDataList*) m_data)->GetValue();
1583 }
1584
1585 wxStringList& wxVariant::GetStringList() const
1586 {
1587     wxASSERT( (GetType() == "stringlist") );
1588
1589     return (wxStringList&) ((wxVariantDataStringList*) m_data)->GetValue();
1590 }
1591
1592 // Append to list
1593 void wxVariant::Append(const wxVariant& value)
1594 {
1595     wxList& list = GetList();
1596
1597     list.Append(new wxVariant(value));
1598 }
1599
1600 // Insert at front of list
1601 void wxVariant::Insert(const wxVariant& value)
1602 {
1603     wxList& list = GetList();
1604
1605     list.Insert(new wxVariant(value));
1606 }
1607
1608 // Returns TRUE if the variant is a member of the list
1609 bool wxVariant::Member(const wxVariant& value) const
1610 {
1611     wxList& list = GetList();
1612
1613     wxNode* node = list.First();
1614     while (node)
1615     {
1616         wxVariant* other = (wxVariant*) node->Data();
1617         if (value == *other)
1618             return TRUE;
1619         node = node->Next();
1620     }
1621     return FALSE;
1622 }
1623
1624 // Deletes the nth element of the list
1625 bool wxVariant::Delete(int item)
1626 {
1627     wxList& list = GetList();
1628
1629     wxASSERT_MSG( (item < list.Number()), "Invalid index to Delete" );
1630     wxNode* node = list.Nth(item);
1631     wxVariant* variant = (wxVariant*) node->Data();
1632     delete variant;
1633     delete node;
1634     return TRUE;
1635 }
1636
1637 // Clear list
1638 void wxVariant::ClearList()
1639 {
1640     if (!IsNull() && (GetType() == "list"))
1641     {
1642         ((wxVariantDataList*) m_data)->Clear();
1643     }
1644     else
1645     {
1646         if (GetType() != "list")
1647         {
1648             delete m_data;
1649             m_data = NULL;
1650         }
1651         m_data = new wxVariantDataList;
1652     }
1653 }
1654
1655 // Type conversion
1656 bool wxVariant::Convert(long* value) const
1657 {
1658     wxString type(GetType());
1659     if (type == "double")
1660         *value = (long) (((wxVariantDataReal*)GetData())->GetValue());
1661     else if (type == "long")
1662         *value = ((wxVariantDataLong*)GetData())->GetValue();
1663     else if (type == "bool")
1664         *value = (long) (((wxVariantDataBool*)GetData())->GetValue());
1665     else if (type == "string")
1666         *value = atol((const char*) ((wxVariantDataString*)GetData())->GetValue());
1667     else
1668         return FALSE;
1669
1670     return TRUE;
1671 }
1672
1673 bool wxVariant::Convert(bool* value) const
1674 {
1675     wxString type(GetType());
1676     if (type == "double")
1677         *value = ((int) (((wxVariantDataReal*)GetData())->GetValue()) != 0);
1678     else if (type == "long")
1679         *value = (((wxVariantDataLong*)GetData())->GetValue() != 0);
1680     else if (type == "bool")
1681         *value = ((wxVariantDataBool*)GetData())->GetValue();
1682     else if (type == "string")
1683     {
1684         wxString val(((wxVariantDataString*)GetData())->GetValue());
1685         val.MakeLower();
1686         if (val == "true" || val == "yes")
1687             *value = TRUE;
1688         else if (val == "false" || val == "no")
1689             *value = FALSE;
1690         else
1691             return FALSE;
1692     }
1693     else
1694         return FALSE;
1695
1696     return TRUE;
1697 }
1698
1699 bool wxVariant::Convert(double* value) const
1700 {
1701     wxString type(GetType());
1702     if (type == "double")
1703         *value = ((wxVariantDataReal*)GetData())->GetValue();
1704     else if (type == "long")
1705         *value = (double) (((wxVariantDataLong*)GetData())->GetValue());
1706     else if (type == "bool")
1707         *value = (double) (((wxVariantDataBool*)GetData())->GetValue());
1708     else if (type == "string")
1709         *value = (double) atof((const char*) ((wxVariantDataString*)GetData())->GetValue());
1710     else
1711         return FALSE;
1712
1713     return TRUE;
1714 }
1715
1716 bool wxVariant::Convert(char* value) const
1717 {
1718     wxString type(GetType());
1719     if (type == "char")
1720         *value = ((wxVariantDataChar*)GetData())->GetValue();
1721     else if (type == "long")
1722         *value = (char) (((wxVariantDataLong*)GetData())->GetValue());
1723     else if (type == "bool")
1724         *value = (char) (((wxVariantDataBool*)GetData())->GetValue());
1725     else
1726         return FALSE;
1727
1728     return TRUE;
1729 }
1730
1731 bool wxVariant::Convert(wxString* value) const
1732 {
1733     *value = MakeString();
1734     return TRUE;
1735 }
1736
1737 #if wxUSE_TIMEDATE
1738 bool wxVariant::Convert(wxTime* value) const
1739 {
1740     wxString type(GetType());
1741     if (type == "time")
1742         *value = ((wxVariantDataTime*)GetData())->GetValue();
1743     else if (type == "date")
1744         *value = wxTime(((wxVariantDataDate*)GetData())->GetValue());
1745     else
1746         return FALSE;
1747
1748     return TRUE;
1749 }
1750
1751 bool wxVariant::Convert(wxDate* value) const
1752 {
1753     wxString type(GetType());
1754     if (type == "date")
1755         *value = ((wxVariantDataDate*)GetData())->GetValue();
1756     else
1757         return FALSE;
1758
1759     return TRUE;
1760 }
1761 #endif
1762  // wxUSE_TIMEDATE