home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / src / common / variant.cpp < prev    next >
C/C++ Source or Header  |  2002-08-01  |  54KB  |  2,255 lines
  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: variant.cpp,v 1.38 2002/08/01 20:00:55 JS Exp $
  8. // Copyright:   (c)
  9. // Licence:     wxWindows licence
  10. /////////////////////////////////////////////////////////////////////////////
  11.  
  12. #ifdef __GNUG__
  13. #pragma implementation "variant.h"
  14. #pragma implementation "time.h"
  15. #pragma implementation "date.h"
  16. #endif
  17.  
  18. // For compilers that support precompilation, includes "wx/wx.h".
  19. #include "wx/wxprec.h"
  20.  
  21. #ifdef __BORLANDC__
  22.     #pragma hdrstop
  23. #endif
  24.  
  25. #if wxUSE_STD_IOSTREAM
  26.     #if wxUSE_IOSTREAMH
  27.         #include <fstream.h>
  28.     #else
  29.         #include <fstream>
  30.     #endif
  31. #endif
  32.  
  33. #if wxUSE_STREAMS
  34. #include "wx/stream.h"
  35. #include "wx/txtstrm.h"
  36. #endif
  37.  
  38. #include "wx/string.h"
  39. #include "wx/tokenzr.h"
  40.  
  41. #include "wx/variant.h"
  42.  
  43. #if wxUSE_TIMEDATE
  44. IMPLEMENT_DYNAMIC_CLASS(wxDate, wxObject)
  45. IMPLEMENT_DYNAMIC_CLASS(wxTime, wxObject)
  46.  
  47. wxTime::tFormat    wxTime::ms_Format    = wxTime::wx12h;
  48. wxTime::tPrecision wxTime::ms_Precision  = wxTime::wxStdMinSec;
  49. wxChar             wxTime::ms_bufTime[128];
  50. #endif
  51.  
  52. IMPLEMENT_ABSTRACT_CLASS(wxVariantData, wxObject)
  53.  
  54. wxVariant WXDLLEXPORT wxNullVariant;
  55.  
  56. /*
  57.  * wxVariantDataList
  58.  */
  59.  
  60. class WXDLLEXPORT wxVariantDataList: public wxVariantData
  61. {
  62. DECLARE_DYNAMIC_CLASS(wxVariantDataList)
  63. public:
  64.     wxVariantDataList() {}
  65.     wxVariantDataList(const wxList& list);
  66.     ~wxVariantDataList();
  67.  
  68.     wxList& GetValue() const { return (wxList&) m_value; }
  69.     void SetValue(const wxList& value) ;
  70.  
  71.     virtual void Copy(wxVariantData& data);
  72.     virtual bool Eq(wxVariantData& data) const;
  73. #if wxUSE_STD_IOSTREAM
  74.     virtual bool Write(wxSTD ostream& str) const;
  75. #endif
  76.     virtual bool Write(wxString& str) const;
  77. #if wxUSE_STD_IOSTREAM
  78.     virtual bool Read(wxSTD istream& str);
  79. #endif
  80.     virtual bool Read(wxString& str);
  81.     virtual wxString GetType() const { return wxT("list"); };
  82.  
  83.     void Clear();
  84.  
  85. protected:
  86.     wxList  m_value;
  87. };
  88.  
  89. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataList, wxVariantData)
  90.  
  91. wxVariantDataList::wxVariantDataList(const wxList& list)
  92. {
  93.     SetValue(list);
  94. }
  95.  
  96. wxVariantDataList::~wxVariantDataList()
  97. {
  98.     Clear();
  99. }
  100.  
  101. void wxVariantDataList::SetValue(const wxList& value)
  102. {
  103.     Clear();
  104.     wxNode* node = value.First();
  105.     while (node)
  106.     {
  107.         wxVariant* var = (wxVariant*) node->Data();
  108.         m_value.Append(new wxVariant(*var));
  109.         node = node->Next();
  110.     }
  111. }
  112.  
  113. void wxVariantDataList::Clear()
  114. {
  115.     wxNode* node = m_value.First();
  116.     while (node)
  117.     {
  118.         wxVariant* var = (wxVariant*) node->Data();
  119.         delete var;
  120.         node = node->Next();
  121.     }
  122.     m_value.Clear();
  123. }
  124.  
  125. void wxVariantDataList::Copy(wxVariantData& data)
  126. {
  127.     wxASSERT_MSG( (data.GetType() == wxT("list")), wxT("wxVariantDataList::Copy: Can't copy to this type of data") );
  128.  
  129.     wxVariantDataList& listData = (wxVariantDataList&) data;
  130.  
  131.     listData.Clear();
  132.     wxNode* node = m_value.First();
  133.     while (node)
  134.     {
  135.         wxVariant* var = (wxVariant*) node->Data();
  136.         listData.m_value.Append(new wxVariant(*var));
  137.         node = node->Next();
  138.     }
  139. }
  140.  
  141. bool wxVariantDataList::Eq(wxVariantData& data) const
  142. {
  143.     wxASSERT_MSG( (data.GetType() == wxT("list")), wxT("wxVariantDataList::Eq: argument mismatch") );
  144.  
  145.     wxVariantDataList& listData = (wxVariantDataList&) data;
  146.     wxNode* node1 = m_value.First();
  147.     wxNode* node2 = listData.GetValue().First();
  148.     while (node1 && node2)
  149.     {
  150.         wxVariant* var1 = (wxVariant*) node1->Data();
  151.         wxVariant* var2 = (wxVariant*) node2->Data();
  152.         if ((*var1) != (*var2))
  153.             return FALSE;
  154.         node1 = node1->Next();
  155.         node2 = node2->Next();
  156.     }
  157.     if (node1 || node2) return FALSE;
  158.     return TRUE;
  159. }
  160.  
  161. #if wxUSE_STD_IOSTREAM
  162. bool wxVariantDataList::Write(wxSTD ostream& str) const
  163. {
  164.     wxString s;
  165.     Write(s);
  166.     str << (const char*) s.mb_str();
  167.     return TRUE;
  168. }
  169. #endif
  170.  
  171. bool wxVariantDataList::Write(wxString& str) const
  172. {
  173.     str = wxT("");
  174.     wxNode* node = m_value.First();
  175.     while (node)
  176.     {
  177.         wxVariant* var = (wxVariant*) node->Data();
  178.         if (node != m_value.First())
  179.           str += wxT(" ");
  180.         wxString str1;
  181.         str += var->MakeString();
  182.         node = node->Next();
  183.     }
  184.  
  185.     return TRUE;
  186. }
  187.  
  188. #if wxUSE_STD_IOSTREAM
  189. bool wxVariantDataList::Read(wxSTD istream& WXUNUSED(str))
  190. {
  191.     wxFAIL_MSG(wxT("Unimplemented"));
  192.     // TODO
  193.     return FALSE;
  194. }
  195. #endif
  196.  
  197. bool wxVariantDataList::Read(wxString& WXUNUSED(str))
  198. {
  199.     wxFAIL_MSG(wxT("Unimplemented"));
  200.     // TODO
  201.     return FALSE;
  202. }
  203.  
  204. /*
  205.  * wxVariantDataStringList
  206.  */
  207.  
  208. class WXDLLEXPORT wxVariantDataStringList: public wxVariantData
  209. {
  210. DECLARE_DYNAMIC_CLASS(wxVariantDataStringList)
  211. public:
  212.     wxVariantDataStringList() {}
  213.     wxVariantDataStringList(const wxStringList& list) { m_value = list; }
  214.  
  215.     wxStringList& GetValue() const { return (wxStringList&) m_value; }
  216.     void SetValue(const wxStringList& value);
  217.  
  218.     virtual void Copy(wxVariantData& data);
  219.     virtual bool Eq(wxVariantData& data) const;
  220. #if wxUSE_STD_IOSTREAM
  221.     virtual bool Write(wxSTD ostream& str) const;
  222. #endif
  223.     virtual bool Write(wxString& str) const;
  224. #if wxUSE_STD_IOSTREAM
  225.     virtual bool Read(wxSTD istream& str);
  226. #endif
  227.     virtual bool Read(wxString& str);
  228.     virtual wxString GetType() const { return wxT("stringlist"); };
  229.  
  230. protected:
  231.     wxStringList  m_value;
  232. };
  233.  
  234. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataStringList, wxVariantData)
  235.  
  236. void wxVariantDataStringList::SetValue(const wxStringList& value)
  237. {
  238.     m_value = value;
  239. }
  240.  
  241. void wxVariantDataStringList::Copy(wxVariantData& data)
  242. {
  243.     wxASSERT_MSG( (data.GetType() == wxT("stringlist")), wxT("wxVariantDataStringList::Copy: Can't copy to this type of data") );
  244.  
  245.     wxVariantDataStringList& listData = (wxVariantDataStringList&) data;
  246.  
  247.     listData.m_value = m_value ;
  248. }
  249.  
  250. bool wxVariantDataStringList::Eq(wxVariantData& data) const
  251. {
  252.     wxASSERT_MSG( (data.GetType() == wxT("stringlist")), wxT("wxVariantDataStringList::Eq: argument mismatch") );
  253.  
  254.     wxVariantDataStringList& listData = (wxVariantDataStringList&) data;
  255.     wxNode* node1 = m_value.First();
  256.     wxNode* node2 = listData.GetValue().First();
  257.     while (node1 && node2)
  258.     {
  259.         wxString str1 ((wxChar*) node1->Data());
  260.         wxString str2 ((wxChar*) node2->Data());
  261.         if (str1 != str2)
  262.             return FALSE;
  263.         node1 = node1->Next();
  264.         node2 = node2->Next();
  265.     }
  266.     if (node1 || node2) return FALSE;
  267.     return TRUE;
  268. }
  269.  
  270. #if wxUSE_STD_IOSTREAM
  271. bool wxVariantDataStringList::Write(wxSTD ostream& str) const
  272. {
  273.     wxString s;
  274.     Write(s);
  275.     str << (const char*) s.mb_str();
  276.     return TRUE;
  277. }
  278. #endif
  279.  
  280. bool wxVariantDataStringList::Write(wxString& str) const
  281. {
  282.     str = wxT("");
  283.     wxNode* node = m_value.First();
  284.     while (node)
  285.     {
  286.         wxChar* s = (wxChar*) node->Data();
  287.         if (node != m_value.First())
  288.           str += wxT(" ");
  289.         str += s;
  290.         node = node->Next();
  291.     }
  292.  
  293.     return TRUE;
  294. }
  295.  
  296. #if wxUSE_STD_IOSTREAM
  297. bool wxVariantDataStringList::Read(wxSTD istream& WXUNUSED(str))
  298. {
  299.     wxFAIL_MSG(wxT("Unimplemented"));
  300.     // TODO
  301.     return FALSE;
  302. }
  303. #endif
  304.  
  305. bool wxVariantDataStringList::Read(wxString& WXUNUSED(str))
  306. {
  307.     wxFAIL_MSG(wxT("Unimplemented"));
  308.     // TODO
  309.     return FALSE;
  310. }
  311.  
  312. /*
  313.  * wxVariantDataLong
  314.  */
  315.  
  316. class WXDLLEXPORT wxVariantDataLong: public wxVariantData
  317. {
  318. DECLARE_DYNAMIC_CLASS(wxVariantDataLong)
  319. public:
  320.     wxVariantDataLong() { m_value = 0; }
  321.     wxVariantDataLong(long value) { m_value = value; }
  322.  
  323.     inline long GetValue() const { return m_value; }
  324.     inline void SetValue(long value) { m_value = value; }
  325.  
  326.     virtual void Copy(wxVariantData& data);
  327.     virtual bool Eq(wxVariantData& data) const;
  328.  
  329.     virtual bool Read(wxString& str);
  330.     virtual bool Write(wxString& str) const;
  331. #if wxUSE_STD_IOSTREAM
  332.     virtual bool Read(wxSTD istream& str);
  333.     virtual bool Write(wxSTD ostream& str) const;
  334. #endif
  335. #if wxUSE_STREAMS
  336.     virtual bool Read(wxInputStream& str);
  337.     virtual bool Write(wxOutputStream &str) const;
  338. #endif // wxUSE_STREAMS
  339.  
  340.     virtual wxString GetType() const { return wxT("long"); };
  341.  
  342. protected:
  343.     long m_value;
  344. };
  345.  
  346. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataLong, wxVariantData)
  347.  
  348. void wxVariantDataLong::Copy(wxVariantData& data)
  349. {
  350.     wxASSERT_MSG( (data.GetType() == wxT("long")), wxT("wxVariantDataLong::Copy: Can't copy to this type of data") );
  351.  
  352.     wxVariantDataLong& otherData = (wxVariantDataLong&) data;
  353.  
  354.     otherData.m_value = m_value;
  355. }
  356.  
  357. bool wxVariantDataLong::Eq(wxVariantData& data) const
  358. {
  359.     wxASSERT_MSG( (data.GetType() == wxT("long")), wxT("wxVariantDataLong::Eq: argument mismatch") );
  360.  
  361.     wxVariantDataLong& otherData = (wxVariantDataLong&) data;
  362.  
  363.     return (otherData.m_value == m_value);
  364. }
  365.  
  366. #if wxUSE_STD_IOSTREAM
  367. bool wxVariantDataLong::Write(wxSTD ostream& str) const
  368. {
  369.     wxString s;
  370.     Write(s);
  371.     str << (const char*) s.mb_str();
  372.     return TRUE;
  373. }
  374. #endif
  375.  
  376. bool wxVariantDataLong::Write(wxString& str) const
  377. {
  378.     str.Printf(wxT("%ld"), m_value);
  379.     return TRUE;
  380. }
  381.  
  382. #if wxUSE_STD_IOSTREAM
  383. bool wxVariantDataLong::Read(wxSTD istream& str)
  384. {
  385.     str >> m_value;
  386.     return TRUE;
  387. }
  388. #endif
  389.  
  390. #if wxUSE_STREAMS
  391. bool wxVariantDataLong::Write(wxOutputStream& str) const
  392. {
  393.     wxTextOutputStream s(str);
  394.  
  395.     s.Write32((size_t)m_value);
  396.     return TRUE;
  397. }
  398.  
  399. bool wxVariantDataLong::Read(wxInputStream& str)
  400. {
  401.    wxTextInputStream s(str);
  402.    m_value = s.Read32();
  403.    return TRUE;
  404. }
  405. #endif // wxUSE_STREAMS
  406.  
  407. bool wxVariantDataLong::Read(wxString& str)
  408. {
  409.     m_value = wxAtol((const wxChar*) str);
  410.     return TRUE;
  411. }
  412.  
  413. /*
  414.  * wxVariantDataReal
  415.  */
  416.  
  417. class WXDLLEXPORT wxVariantDataReal: public wxVariantData
  418. {
  419. DECLARE_DYNAMIC_CLASS(wxVariantDataReal)
  420. public:
  421.     wxVariantDataReal() { m_value = 0.0; }
  422.     wxVariantDataReal(double value) { m_value = value; }
  423.  
  424.     inline double GetValue() const { return m_value; }
  425.     inline void SetValue(double value) { m_value = value; }
  426.  
  427.     virtual void Copy(wxVariantData& data);
  428.     virtual bool Eq(wxVariantData& data) const;
  429.     virtual bool Read(wxString& str);
  430. #if wxUSE_STD_IOSTREAM
  431.     virtual bool Write(wxSTD ostream& str) const;
  432. #endif
  433.     virtual bool Write(wxString& str) const;
  434. #if wxUSE_STD_IOSTREAM
  435.     virtual bool Read(wxSTD istream& str);
  436. #endif
  437. #if wxUSE_STREAMS
  438.     virtual bool Read(wxInputStream& str);
  439.     virtual bool Write(wxOutputStream &str) const;
  440. #endif // wxUSE_STREAMS
  441.     virtual wxString GetType() const { return wxT("double"); };
  442.  
  443. protected:
  444.     double m_value;
  445. };
  446.  
  447. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataReal, wxVariantData)
  448.  
  449. void wxVariantDataReal::Copy(wxVariantData& data)
  450. {
  451.     wxASSERT_MSG( (data.GetType() == wxT("double")), wxT("wxVariantDataReal::Copy: Can't copy to this type of data") );
  452.  
  453.     wxVariantDataReal& otherData = (wxVariantDataReal&) data;
  454.  
  455.     otherData.m_value = m_value;
  456. }
  457.  
  458. bool wxVariantDataReal::Eq(wxVariantData& data) const
  459. {
  460.     wxASSERT_MSG( (data.GetType() == wxT("double")), wxT("wxVariantDataReal::Eq: argument mismatch") );
  461.  
  462.     wxVariantDataReal& otherData = (wxVariantDataReal&) data;
  463.  
  464.     return (otherData.m_value == m_value);
  465. }
  466.  
  467. #if wxUSE_STD_IOSTREAM
  468. bool wxVariantDataReal::Write(wxSTD ostream& str) const
  469. {
  470.     wxString s;
  471.     Write(s);
  472.     str << (const char*) s.mb_str();
  473.     return TRUE;
  474. }
  475. #endif
  476.  
  477. bool wxVariantDataReal::Write(wxString& str) const
  478. {
  479.     str.Printf(wxT("%.4f"), m_value);
  480.     return TRUE;
  481. }
  482.  
  483. #if wxUSE_STD_IOSTREAM
  484. bool wxVariantDataReal::Read(wxSTD istream& str)
  485. {
  486.     str >> m_value;
  487.     return TRUE;
  488. }
  489. #endif
  490.  
  491. #if wxUSE_STREAMS
  492. bool wxVariantDataReal::Write(wxOutputStream& str) const
  493. {
  494.     wxTextOutputStream s(str);
  495.     s.WriteDouble((double)m_value);
  496.     return TRUE;
  497. }
  498.  
  499. bool wxVariantDataReal::Read(wxInputStream& str)
  500. {
  501.     wxTextInputStream s(str);
  502.     m_value = (float)s.ReadDouble();
  503.     return TRUE;
  504. }
  505. #endif // wxUSE_STREAMS
  506.  
  507. bool wxVariantDataReal::Read(wxString& str)
  508. {
  509.     m_value = wxAtof((const wxChar*) str);
  510.     return TRUE;
  511. }
  512.  
  513. #ifdef HAVE_BOOL
  514. /*
  515.  * wxVariantDataBool
  516.  */
  517.  
  518. class WXDLLEXPORT wxVariantDataBool: public wxVariantData
  519. {
  520. DECLARE_DYNAMIC_CLASS(wxVariantDataBool)
  521. public:
  522.     wxVariantDataBool() { m_value = 0; }
  523.     wxVariantDataBool(bool value) { m_value = value; }
  524.  
  525.     inline bool GetValue() const { return m_value; }
  526.     inline void SetValue(bool value) { m_value = value; }
  527.  
  528.     virtual void Copy(wxVariantData& data);
  529.     virtual bool Eq(wxVariantData& data) const;
  530. #if wxUSE_STD_IOSTREAM
  531.     virtual bool Write(wxSTD ostream& str) const;
  532. #endif
  533.     virtual bool Write(wxString& str) const;
  534.     virtual bool Read(wxString& str);
  535. #if wxUSE_STD_IOSTREAM
  536.     virtual bool Read(wxSTD istream& str);
  537. #endif
  538. #if wxUSE_STREAMS
  539.     virtual bool Read(wxInputStream& str);
  540.     virtual bool Write(wxOutputStream& str) const;
  541. #endif // wxUSE_STREAMS
  542.     virtual wxString GetType() const { return wxT("bool"); };
  543.  
  544. protected:
  545.     bool m_value;
  546. };
  547.  
  548. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataBool, wxVariantData)
  549.  
  550. void wxVariantDataBool::Copy(wxVariantData& data)
  551. {
  552.     wxASSERT_MSG( (data.GetType() == wxT("bool")), wxT("wxVariantDataBool::Copy: Can't copy to this type of data") );
  553.  
  554.     wxVariantDataBool& otherData = (wxVariantDataBool&) data;
  555.  
  556.     otherData.m_value = m_value;
  557. }
  558.  
  559. bool wxVariantDataBool::Eq(wxVariantData& data) const
  560. {
  561.     wxASSERT_MSG( (data.GetType() == wxT("bool")), wxT("wxVariantDataBool::Eq: argument mismatch") );
  562.  
  563.     wxVariantDataBool& otherData = (wxVariantDataBool&) data;
  564.  
  565.     return (otherData.m_value == m_value);
  566. }
  567.  
  568. #if wxUSE_STD_IOSTREAM
  569. bool wxVariantDataBool::Write(wxSTD ostream& str) const
  570. {
  571.     wxString s;
  572.     Write(s);
  573.     str << (const char*) s.mb_str();
  574.     return TRUE;
  575. }
  576. #endif
  577.  
  578. bool wxVariantDataBool::Write(wxString& str) const
  579. {
  580.     str.Printf(wxT("%d"), (int) m_value);
  581.     return TRUE;
  582. }
  583.  
  584. #if wxUSE_STD_IOSTREAM
  585. bool wxVariantDataBool::Read(wxSTD istream& WXUNUSED(str))
  586. {
  587.     wxFAIL_MSG(wxT("Unimplemented"));
  588. //    str >> (long) m_value;
  589.     return FALSE;
  590. }
  591. #endif
  592.  
  593. #if wxUSE_STREAMS
  594. bool wxVariantDataBool::Write(wxOutputStream& str) const
  595. {
  596.     wxTextOutputStream s(str);
  597.  
  598.     s.Write8(m_value);
  599.     return TRUE;
  600. }
  601.  
  602. bool wxVariantDataBool::Read(wxInputStream& str)
  603. {
  604.     wxTextInputStream s(str);
  605.  
  606.     m_value = s.Read8() != 0;
  607.     return TRUE;
  608. }
  609. #endif // wxUSE_STREAMS
  610.  
  611. bool wxVariantDataBool::Read(wxString& str)
  612. {
  613.     m_value = (wxAtol((const wxChar*) str) != 0);
  614.     return TRUE;
  615. }
  616. #endif // HAVE_BOOL
  617.  
  618. /*
  619.  * wxVariantDataChar
  620.  */
  621.  
  622. class WXDLLEXPORT wxVariantDataChar: public wxVariantData
  623. {
  624. DECLARE_DYNAMIC_CLASS(wxVariantDataChar)
  625. public:
  626.     wxVariantDataChar() { m_value = 0; }
  627.     wxVariantDataChar(char value) { m_value = value; }
  628.  
  629.     inline char GetValue() const { return m_value; }
  630.     inline void SetValue(char value) { m_value = value; }
  631.  
  632.     virtual void Copy(wxVariantData& data);
  633.     virtual bool Eq(wxVariantData& data) const;
  634. #if wxUSE_STD_IOSTREAM
  635.     virtual bool Read(wxSTD istream& str);
  636.     virtual bool Write(wxSTD ostream& str) const;
  637. #endif
  638.     virtual bool Read(wxString& str);
  639.     virtual bool Write(wxString& str) const;
  640. #if wxUSE_STREAMS
  641.     virtual bool Read(wxInputStream& str);
  642.     virtual bool Write(wxOutputStream& str) const;
  643. #endif // wxUSE_STREAMS
  644.     virtual wxString GetType() const { return wxT("char"); };
  645.  
  646. protected:
  647.     char m_value;
  648. };
  649.  
  650. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataChar, wxVariantData)
  651.  
  652. void wxVariantDataChar::Copy(wxVariantData& data)
  653. {
  654.     wxASSERT_MSG( (data.GetType() == wxT("char")), wxT("wxVariantDataChar::Copy: Can't copy to this type of data") );
  655.  
  656.     wxVariantDataChar& otherData = (wxVariantDataChar&) data;
  657.  
  658.     otherData.m_value = m_value;
  659. }
  660.  
  661. bool wxVariantDataChar::Eq(wxVariantData& data) const
  662. {
  663.     wxASSERT_MSG( (data.GetType() == wxT("char")), wxT("wxVariantDataChar::Eq: argument mismatch") );
  664.  
  665.     wxVariantDataChar& otherData = (wxVariantDataChar&) data;
  666.  
  667.     return (otherData.m_value == m_value);
  668. }
  669.  
  670. #if wxUSE_STD_IOSTREAM
  671. bool wxVariantDataChar::Write(wxSTD ostream& str) const
  672. {
  673.     wxString s;
  674.     Write(s);
  675.     str << (const char*) s.mb_str();
  676.     return TRUE;
  677. }
  678. #endif
  679.  
  680. bool wxVariantDataChar::Write(wxString& str) const
  681. {
  682.     str.Printf(wxT("%c"), m_value);
  683.     return TRUE;
  684. }
  685.  
  686. #if wxUSE_STD_IOSTREAM
  687. bool wxVariantDataChar::Read(wxSTD istream& WXUNUSED(str))
  688. {
  689.     wxFAIL_MSG(wxT("Unimplemented"));
  690. //    str >> m_value;
  691.     return FALSE;
  692. }
  693. #endif
  694.  
  695. #if wxUSE_STREAMS
  696. bool wxVariantDataChar::Write(wxOutputStream& str) const
  697. {
  698.     wxTextOutputStream s(str);
  699.  
  700.     s.Write8(m_value);
  701.     return TRUE;
  702. }
  703.  
  704. bool wxVariantDataChar::Read(wxInputStream& str)
  705. {
  706.     wxTextInputStream s(str);
  707.  
  708.     m_value = s.Read8();
  709.     return TRUE;
  710. }
  711. #endif // wxUSE_STREAMS
  712.  
  713. bool wxVariantDataChar::Read(wxString& str)
  714. {
  715.     m_value = str[(size_t)0];
  716.     return TRUE;
  717. }
  718.  
  719. /*
  720.  * wxVariantDataString
  721.  */
  722.  
  723. #if defined(__BORLANDC__) && defined(__WIN16__)
  724. // Change name because of truncation
  725. #define wxVariantDataString wxVariantStringData
  726. #endif
  727.  
  728. class WXDLLEXPORT wxVariantDataString: public wxVariantData
  729. {
  730. #if defined(__BORLANDC__) && defined(__WIN16__)
  731. DECLARE_DYNAMIC_CLASS(wxVariantStringData)
  732. #else
  733. DECLARE_DYNAMIC_CLASS(wxVariantDataString)
  734. #endif
  735. public:
  736.     wxVariantDataString() { }
  737.     wxVariantDataString(const wxString& value) { m_value = value; }
  738.  
  739.     inline wxString GetValue() const { return m_value; }
  740.     inline void SetValue(const wxString& value) { m_value = value; }
  741.  
  742.     virtual void Copy(wxVariantData& data);
  743.     virtual bool Eq(wxVariantData& data) const;
  744. #if wxUSE_STD_IOSTREAM
  745.     virtual bool Write(wxSTD ostream& str) const;
  746. #endif
  747.     virtual bool Read(wxString& str);
  748.     virtual bool Write(wxString& str) const;
  749. #if wxUSE_STD_IOSTREAM
  750.     virtual bool Read(wxSTD istream& str);
  751. #endif
  752. #if wxUSE_STREAMS
  753.     virtual bool Read(wxInputStream& str);
  754.     virtual bool Write(wxOutputStream& str) const;
  755. #endif // wxUSE_STREAMS
  756.     virtual wxString GetType() const { return wxT("string"); };
  757.  
  758. protected:
  759.     wxString m_value;
  760. };
  761.  
  762. void wxVariantDataString::Copy(wxVariantData& data)
  763. {
  764.     wxASSERT_MSG( (data.GetType() == wxT("string")), wxT("wxVariantDataString::Copy: Can't copy to this type of data") );
  765.  
  766.     wxVariantDataString& otherData = (wxVariantDataString&) data;
  767.  
  768.     otherData.m_value = m_value;
  769. }
  770.  
  771. bool wxVariantDataString::Eq(wxVariantData& data) const
  772. {
  773.     wxASSERT_MSG( (data.GetType() == wxT("string")), wxT("wxVariantDataString::Eq: argument mismatch") );
  774.  
  775.     wxVariantDataString& otherData = (wxVariantDataString&) data;
  776.  
  777.     return (otherData.m_value == m_value);
  778. }
  779.  
  780. #if wxUSE_STD_IOSTREAM
  781. bool wxVariantDataString::Write(wxSTD ostream& str) const
  782. {
  783.     str << (const char*) m_value.mb_str();
  784.     return TRUE;
  785. }
  786. #endif
  787.  
  788. bool wxVariantDataString::Write(wxString& str) const
  789. {
  790.     str = m_value;
  791.     return TRUE;
  792. }
  793.  
  794. #if wxUSE_STD_IOSTREAM
  795. bool wxVariantDataString::Read(wxSTD istream& str)
  796. {
  797.     str >> m_value;
  798.     return TRUE;
  799. }
  800. #endif
  801.  
  802. #if wxUSE_STREAMS
  803. bool wxVariantDataString::Write(wxOutputStream& str) const
  804. {
  805.   // why doesn't wxOutputStream::operator<< take "const wxString&"
  806.     wxTextOutputStream s(str);
  807.     s.WriteString(m_value);
  808.     return TRUE;
  809. }
  810.  
  811. bool wxVariantDataString::Read(wxInputStream& str)
  812. {
  813.     wxTextInputStream s(str);
  814.  
  815.     m_value = s.ReadString();
  816.     return TRUE;
  817. }
  818. #endif // wxUSE_STREAMS
  819.  
  820. bool wxVariantDataString::Read(wxString& str)
  821. {
  822.     m_value = str;
  823.     return TRUE;
  824. }
  825.  
  826. #if defined(__BORLANDC__) && defined(__WIN16__)
  827. IMPLEMENT_DYNAMIC_CLASS(wxVariantStringData, wxVariantData)
  828. #else
  829. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataString, wxVariantData)
  830. #endif
  831.  
  832. /*
  833.  * wxVariantDataTime
  834.  */
  835.  
  836. // For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
  837. #if wxUSE_TIMEDATE && !defined(__WATCOMC__)
  838.  
  839. class wxVariantDataTime: public wxVariantData
  840. {
  841.  DECLARE_DYNAMIC_CLASS(wxVariantDataTime)
  842. public:
  843.     wxVariantDataTime() { }
  844.     wxVariantDataTime(const wxTime& value) { m_value = value; }
  845.  
  846.     inline wxTime GetValue() const { return m_value; }
  847.     inline void SetValue(const wxTime& value) { m_value = value; }
  848.  
  849.     virtual void Copy(wxVariantData& data);
  850.     virtual bool Eq(wxVariantData& data) const;
  851. #if wxUSE_STD_IOSTREAM
  852.     virtual bool Write(wxSTD ostream& str) const;
  853. #endif
  854.     virtual bool Write(wxString& str) const;
  855. #if wxUSE_STD_IOSTREAM
  856.     virtual bool Read(wxSTD istream& str);
  857. #endif
  858.     virtual bool Read(wxString& str);
  859.     virtual wxString GetType() const { return wxT("time"); };
  860.     virtual wxVariantData* Clone() { return new wxVariantDataTime; }
  861.  
  862. protected:
  863.     wxTime m_value;
  864. };
  865.  
  866. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataTime, wxVariantData)
  867.  
  868. void wxVariantDataTime::Copy(wxVariantData& data)
  869. {
  870.     wxASSERT_MSG( (data.GetType() == wxT("time")), wxT("wxVariantDataTime::Copy: Can't copy to this type of data") );
  871.  
  872.     wxVariantDataTime& otherData = (wxVariantDataTime&) data;
  873.  
  874.     otherData.m_value = m_value;
  875. }
  876.  
  877. bool wxVariantDataTime::Eq(wxVariantData& data) const
  878. {
  879.     wxASSERT_MSG( (data.GetType() == wxT("time")), wxT("wxVariantDataTime::Eq: argument mismatch") );
  880.  
  881.     wxVariantDataTime& otherData = (wxVariantDataTime&) data;
  882.  
  883.     return (otherData.m_value == m_value);
  884. }
  885.  
  886. #if wxUSE_STD_IOSTREAM
  887. bool wxVariantDataTime::Write(wxSTD ostream& str) const
  888. {
  889.     wxString s;
  890.     Write(s);
  891.     str << (const char*) s.mb_str();
  892.     return TRUE;
  893. }
  894. #endif
  895.  
  896. bool wxVariantDataTime::Write(wxString& str) const
  897. {
  898.     wxChar*s = m_value.FormatTime();
  899.     str = s;
  900.     return TRUE;
  901. }
  902.  
  903. #if wxUSE_STD_IOSTREAM
  904. bool wxVariantDataTime::Read(wxSTD istream& WXUNUSED(str))
  905. {
  906.     // Not implemented
  907.     return FALSE;
  908. }
  909. #endif
  910.  
  911. bool wxVariantDataTime::Read(wxString& WXUNUSED(str))
  912. {
  913.     // Not implemented
  914.     return FALSE;
  915. }
  916.  
  917. /*
  918.  * wxVariantDataDate
  919.  */
  920.  
  921. class wxVariantDataDate: public wxVariantData
  922. {
  923.  DECLARE_DYNAMIC_CLASS(wxVariantDataDate)
  924. public:
  925.     wxVariantDataDate() { }
  926.     wxVariantDataDate(const wxDate& value) { m_value = value; }
  927.  
  928.     inline wxDate GetValue() const { return m_value; }
  929.     inline void SetValue(const wxDate& value) { m_value = value; }
  930.  
  931.     virtual void Copy(wxVariantData& data);
  932.     virtual bool Eq(wxVariantData& data) const;
  933. #if wxUSE_STD_IOSTREAM
  934.     virtual bool Write(wxSTD ostream& str) const;
  935. #endif
  936.     virtual bool Write(wxString& str) const;
  937. #if wxUSE_STD_IOSTREAM
  938.     virtual bool Read(wxSTD istream& str);
  939. #endif
  940.     virtual bool Read(wxString& str);
  941.     virtual wxString GetType() const { return wxT("date"); };
  942.     virtual wxVariantData* Clone() { return new wxVariantDataDate; }
  943.  
  944. protected:
  945.     wxDate m_value;
  946. };
  947.  
  948. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataDate, wxVariantData)
  949.  
  950. void wxVariantDataDate::Copy(wxVariantData& data)
  951. {
  952.     wxASSERT_MSG( (data.GetType() == wxT("date")), wxT("wxVariantDataDate::Copy: Can't copy to this type of data") );
  953.  
  954.     wxVariantDataDate& otherData = (wxVariantDataDate&) data;
  955.  
  956.     otherData.m_value = m_value;
  957. }
  958.  
  959. bool wxVariantDataDate::Eq(wxVariantData& data) const
  960. {
  961.     wxASSERT_MSG( (data.GetType() == wxT("date")), wxT("wxVariantDataDate::Eq: argument mismatch") );
  962.  
  963.     wxVariantDataDate& otherData = (wxVariantDataDate&) data;
  964.  
  965.     return (otherData.m_value == m_value);
  966. }
  967.  
  968. #if wxUSE_STD_IOSTREAM
  969. bool wxVariantDataDate::Write(wxSTD ostream& str) const
  970. {
  971.     wxString s;
  972.     Write(s);
  973.     str << (const char*) s.mb_str();
  974.     return TRUE;
  975. }
  976. #endif
  977.  
  978. bool wxVariantDataDate::Write(wxString& str) const
  979. {
  980.     str = m_value.FormatDate();
  981.     return TRUE;
  982. }
  983.  
  984. #if wxUSE_STD_IOSTREAM
  985. bool wxVariantDataDate::Read(wxSTD istream& WXUNUSED(str))
  986. {
  987.     // Not implemented
  988.     return FALSE;
  989. }
  990. #endif
  991.  
  992. bool wxVariantDataDate::Read(wxString& WXUNUSED(str))
  993. {
  994.     // Not implemented
  995.     return FALSE;
  996. }
  997. #endif
  998.   // wxUSE_TIMEDATE
  999.  
  1000. /*
  1001.  * wxVariantDataVoidPtr
  1002.  */
  1003.  
  1004. class wxVariantDataVoidPtr: public wxVariantData
  1005. {
  1006. DECLARE_DYNAMIC_CLASS(wxVariantDataVoidPtr)
  1007. public:
  1008.     wxVariantDataVoidPtr() { }
  1009.     wxVariantDataVoidPtr(void* value) { m_value = value; }
  1010.  
  1011.     inline void* GetValue() const { return m_value; }
  1012.     inline void SetValue(void* value) { m_value = value; }
  1013.  
  1014.     virtual void Copy(wxVariantData& data);
  1015.     virtual bool Eq(wxVariantData& data) const;
  1016. #if wxUSE_STD_IOSTREAM
  1017.     virtual bool Write(wxSTD ostream& str) const;
  1018. #endif
  1019.     virtual bool Write(wxString& str) const;
  1020. #if wxUSE_STD_IOSTREAM
  1021.     virtual bool Read(wxSTD istream& str);
  1022. #endif
  1023.     virtual bool Read(wxString& str);
  1024.     virtual wxString GetType() const { return wxT("void*"); };
  1025.     virtual wxVariantData* Clone() { return new wxVariantDataVoidPtr; }
  1026.  
  1027. protected:
  1028.     void* m_value;
  1029. };
  1030.  
  1031. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataVoidPtr, wxVariantData)
  1032.  
  1033. void wxVariantDataVoidPtr::Copy(wxVariantData& data)
  1034. {
  1035.     wxASSERT_MSG( (data.GetType() == wxT("void*")), wxT("wxVariantDataVoidPtr::Copy: Can't copy to this type of data") );
  1036.  
  1037.     wxVariantDataVoidPtr& otherData = (wxVariantDataVoidPtr&) data;
  1038.  
  1039.     otherData.m_value = m_value;
  1040. }
  1041.  
  1042. bool wxVariantDataVoidPtr::Eq(wxVariantData& data) const
  1043. {
  1044.     wxASSERT_MSG( (data.GetType() == wxT("void*")), wxT("wxVariantDataVoidPtr::Eq: argument mismatch") );
  1045.  
  1046.     wxVariantDataVoidPtr& otherData = (wxVariantDataVoidPtr&) data;
  1047.  
  1048.     return (otherData.m_value == m_value);
  1049. }
  1050.  
  1051. #if wxUSE_STD_IOSTREAM
  1052. bool wxVariantDataVoidPtr::Write(wxSTD ostream& str) const
  1053. {
  1054.     wxString s;
  1055.     Write(s);
  1056.     str << (const char*) s.mb_str();
  1057.     return TRUE;
  1058. }
  1059. #endif
  1060.  
  1061. bool wxVariantDataVoidPtr::Write(wxString& str) const
  1062. {
  1063.     str.Printf(wxT("%ld"), (long) m_value);
  1064.     return TRUE;
  1065. }
  1066.  
  1067. #if wxUSE_STD_IOSTREAM
  1068. bool wxVariantDataVoidPtr::Read(wxSTD istream& WXUNUSED(str))
  1069. {
  1070.     // Not implemented
  1071.     return FALSE;
  1072. }
  1073. #endif
  1074.  
  1075. bool wxVariantDataVoidPtr::Read(wxString& WXUNUSED(str))
  1076. {
  1077.     // Not implemented
  1078.     return FALSE;
  1079. }
  1080.  
  1081. /*
  1082.  * wxVariantDataDateTime
  1083.  */
  1084.  
  1085. class wxVariantDataDateTime: public wxVariantData
  1086. {
  1087.     DECLARE_DYNAMIC_CLASS(wxVariantDataDateTime)
  1088.  
  1089. public:
  1090.     wxVariantDataDateTime() { }
  1091.     wxVariantDataDateTime(const wxDateTime& value) { m_value = value; }
  1092. #if wxUSE_ODBC
  1093.     wxVariantDataDateTime(const TIME_STRUCT* valptr)
  1094.         { m_value = wxDateTime(valptr->hour, valptr->minute, valptr->second); }
  1095.     wxVariantDataDateTime(const DATE_STRUCT* valptr)
  1096.         { m_value = wxDateTime(valptr->day, (wxDateTime::Month) (valptr->month - 1),valptr->year); }
  1097.     wxVariantDataDateTime(const TIMESTAMP_STRUCT* valptr)
  1098.         { m_value = wxDateTime(valptr->day, (wxDateTime::Month) (valptr->month - 1), valptr->year,
  1099.                         valptr->hour, valptr->minute, valptr->second, valptr->fraction ); }
  1100. #endif //ODBC
  1101.  
  1102.     inline wxDateTime GetValue() const { return m_value; }
  1103.     inline void SetValue(const wxDateTime& value) { m_value = value; }
  1104.  
  1105.     virtual void Copy(wxVariantData& data);
  1106.     virtual bool Eq(wxVariantData& data) const;
  1107. #if wxUSE_STD_IOSTREAM
  1108.     virtual bool Write(wxSTD ostream& str) const;
  1109. #endif
  1110.     virtual bool Write(wxString& str) const;
  1111. #if wxUSE_STD_IOSTREAM
  1112.     virtual bool Read(wxSTD istream& str);
  1113. #endif
  1114.     virtual bool Read(wxString& str);
  1115.     virtual wxString GetType() const { return wxT("datetime"); };
  1116.     virtual wxVariantData* Clone() { return new wxVariantDataDateTime; }
  1117.  
  1118. protected:
  1119.     wxDateTime m_value;
  1120. };
  1121.  
  1122.  
  1123. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataDateTime, wxVariantData)
  1124.  
  1125. void wxVariantDataDateTime::Copy(wxVariantData& data)
  1126. {
  1127.     wxASSERT_MSG( (data.GetType() == wxT("datetime")), wxT("wxVariantDataDateTime::Copy: Can't copy to this type of data") );
  1128.  
  1129.     wxVariantDataDateTime& otherData = (wxVariantDataDateTime&) data;
  1130.  
  1131.     otherData.m_value = m_value;
  1132. }
  1133.  
  1134.  
  1135. bool wxVariantDataDateTime::Eq(wxVariantData& data) const
  1136. {
  1137.     wxASSERT_MSG( (data.GetType() == wxT("datetime")), wxT("wxVariantDataDateTime::Eq: argument mismatch") );
  1138.  
  1139.     wxVariantDataDateTime& otherData = (wxVariantDataDateTime&) data;
  1140.  
  1141.     return (otherData.m_value == m_value);
  1142. }
  1143.  
  1144.  
  1145. #if wxUSE_STD_IOSTREAM
  1146. bool wxVariantDataDateTime::Write(wxSTD ostream& str) const
  1147. {
  1148.     // Not implemented
  1149.     return FALSE;
  1150. }
  1151. #endif
  1152.  
  1153.  
  1154. bool wxVariantDataDateTime::Write(wxString& str) const
  1155. {
  1156.     str = m_value.Format();
  1157.     return TRUE;
  1158. }
  1159.  
  1160.  
  1161. #if wxUSE_STD_IOSTREAM
  1162. bool wxVariantDataDateTime::Read(wxSTD istream& WXUNUSED(str))
  1163. {
  1164.     // Not implemented
  1165.     return FALSE;
  1166. }
  1167. #endif
  1168.  
  1169.  
  1170. bool wxVariantDataDateTime::Read(wxString& str)
  1171. {
  1172.     if(! m_value.ParseDateTime(str))
  1173.         return FALSE;
  1174.     return TRUE;
  1175. }
  1176.  
  1177. // ----------------------------------------------------------------------------
  1178. // wxVariantDataArrayString
  1179. // ----------------------------------------------------------------------------
  1180.  
  1181. class wxVariantDataArrayString: public wxVariantData
  1182. {
  1183. public:
  1184.     wxVariantDataArrayString() { }
  1185.     wxVariantDataArrayString(const wxArrayString& value) { m_value = value; }
  1186.  
  1187.     wxArrayString GetValue() const { return m_value; }
  1188.     void SetValue(const wxArrayString& value) { m_value = value; }
  1189.  
  1190.     virtual void Copy(wxVariantData& data);
  1191.     virtual bool Eq(wxVariantData& data) const;
  1192. #if wxUSE_STD_IOSTREAM
  1193.     virtual bool Write(wxSTD ostream& str) const;
  1194. #endif
  1195.     virtual bool Write(wxString& str) const;
  1196. #if wxUSE_STD_IOSTREAM
  1197.     virtual bool Read(wxSTD istream& str);
  1198. #endif
  1199.     virtual bool Read(wxString& str);
  1200.     virtual wxString GetType() const { return wxT("arrstring"); };
  1201.     virtual wxVariantData* Clone() { return new wxVariantDataArrayString; }
  1202.  
  1203. protected:
  1204.     wxArrayString m_value;
  1205.  
  1206.     DECLARE_DYNAMIC_CLASS(wxVariantDataArrayString)
  1207. };
  1208.  
  1209. IMPLEMENT_DYNAMIC_CLASS(wxVariantDataArrayString, wxVariantData)
  1210.  
  1211. void wxVariantDataArrayString::Copy(wxVariantData& data)
  1212. {
  1213.     wxASSERT_MSG( data.GetType() == GetType(), wxT("wxVariantDataArrayString::Copy: Can't copy to this type of data") );
  1214.  
  1215.     wxVariantDataArrayString& otherData = (wxVariantDataArrayString&) data;
  1216.  
  1217.     otherData.m_value = m_value;
  1218. }
  1219.  
  1220.  
  1221. bool wxVariantDataArrayString::Eq(wxVariantData& data) const
  1222. {
  1223.     wxASSERT_MSG( data.GetType() == GetType(), wxT("wxVariantDataArrayString::Eq: argument mismatch") );
  1224.  
  1225.     wxVariantDataArrayString& otherData = (wxVariantDataArrayString&) data;
  1226.  
  1227.     return otherData.m_value == m_value;
  1228. }
  1229.  
  1230.  
  1231. #if wxUSE_STD_IOSTREAM
  1232. bool wxVariantDataArrayString::Write(wxSTD ostream& str) const
  1233. {
  1234.     // Not implemented
  1235.     return FALSE;
  1236. }
  1237. #endif
  1238.  
  1239.  
  1240. bool wxVariantDataArrayString::Write(wxString& str) const
  1241. {
  1242.     size_t count = m_value.GetCount();
  1243.     for ( size_t n = 0; n < count; n++ )
  1244.     {
  1245.         if ( n )
  1246.             str += _T(';');
  1247.  
  1248.         str += m_value[n];
  1249.     }
  1250.  
  1251.     return TRUE;
  1252. }
  1253.  
  1254.  
  1255. #if wxUSE_STD_IOSTREAM
  1256. bool wxVariantDataArrayString::Read(wxSTD istream& WXUNUSED(str))
  1257. {
  1258.     // Not implemented
  1259.     return FALSE;
  1260. }
  1261. #endif
  1262.  
  1263.  
  1264. bool wxVariantDataArrayString::Read(wxString& str)
  1265. {
  1266.     wxStringTokenizer tk(str, _T(";"));
  1267.     while ( tk.HasMoreTokens() )
  1268.     {
  1269.         m_value.Add(tk.GetNextToken());
  1270.     }
  1271.  
  1272.     return TRUE;
  1273. }
  1274.  
  1275.  
  1276.  
  1277. /*
  1278.  * wxVariant
  1279.  */
  1280.  
  1281. IMPLEMENT_DYNAMIC_CLASS(wxVariant, wxObject)
  1282.  
  1283. // Construction & destruction
  1284. wxVariant::wxVariant()
  1285. {
  1286.     m_data = (wxVariantData*) NULL;
  1287. }
  1288.  
  1289. wxVariant::wxVariant(double val, const wxString& name)
  1290. {
  1291.     m_data = new wxVariantDataReal(val);
  1292.     m_name = name;
  1293. }
  1294.  
  1295. wxVariant::wxVariant(long val, const wxString& name)
  1296. {
  1297.     m_data = new wxVariantDataLong(val);
  1298.     m_name = name;
  1299. }
  1300.  
  1301. #ifdef HAVE_BOOL
  1302. wxVariant::wxVariant(bool val, const wxString& name)
  1303. {
  1304.     m_data = new wxVariantDataBool(val);
  1305.     m_name = name;
  1306. }
  1307. #endif
  1308.  
  1309. wxVariant::wxVariant(char val, const wxString& name)
  1310. {
  1311.     m_data = new wxVariantDataChar(val);
  1312.     m_name = name;
  1313. }
  1314.  
  1315. wxVariant::wxVariant(const wxString& val, const wxString& name)
  1316. {
  1317.     m_data = new wxVariantDataString(val);
  1318.     m_name = name;
  1319. }
  1320.  
  1321. wxVariant::wxVariant(const wxChar* val, const wxString& name)
  1322. {
  1323.     m_data = new wxVariantDataString(wxString(val));
  1324.     m_name = name;
  1325. }
  1326.  
  1327. wxVariant::wxVariant(const wxStringList& val, const wxString& name)
  1328. {
  1329.     m_data = new wxVariantDataStringList(val);
  1330.     m_name = name;
  1331. }
  1332.  
  1333. wxVariant::wxVariant(const wxList& val, const wxString& name) // List of variants
  1334. {
  1335.     m_data = new wxVariantDataList(val);
  1336.     m_name = name;
  1337. }
  1338.  
  1339. // For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
  1340. #if wxUSE_TIMEDATE && !defined(__WATCOMC__)
  1341. wxVariant::wxVariant(const wxTime& val, const wxString& name) // Time
  1342. {
  1343.     m_data = new wxVariantDataTime(val);
  1344.     m_name = name;
  1345. }
  1346.  
  1347. wxVariant::wxVariant(const wxDate& val, const wxString& name) // Date
  1348. {
  1349.     m_data = new wxVariantDataDate(val);
  1350.     m_name = name;
  1351. }
  1352. #endif
  1353.  
  1354. wxVariant::wxVariant(void* val, const wxString& name) // Void ptr
  1355. {
  1356.     m_data = new wxVariantDataVoidPtr(val);
  1357.     m_name = name;
  1358. }
  1359.  
  1360. wxVariant::wxVariant(const wxDateTime& val, const wxString& name) // Date
  1361. {
  1362.     m_data = new wxVariantDataDateTime(val);
  1363.     m_name = name;
  1364. }
  1365.  
  1366. #if wxUSE_ODBC
  1367. wxVariant::wxVariant(const TIME_STRUCT* valptr, const wxString& name) // Date
  1368. {
  1369.     m_data = new wxVariantDataDateTime(valptr);
  1370.     m_name = name;
  1371. }
  1372.  
  1373. wxVariant::wxVariant(const TIMESTAMP_STRUCT* valptr, const wxString& name) // Date
  1374. {
  1375.     m_data = new wxVariantDataDateTime(valptr);
  1376.     m_name = name;
  1377. }
  1378.  
  1379. wxVariant::wxVariant(const DATE_STRUCT* valptr, const wxString& name) // Date
  1380. {
  1381.     m_data = new wxVariantDataDateTime(valptr);
  1382.     m_name = name;
  1383. }
  1384. #endif // wxUSE_ODBC
  1385.  
  1386. wxVariant::wxVariant(const wxArrayString& val, const wxString& name) // Strings
  1387. {
  1388.     m_data = new wxVariantDataArrayString(val);
  1389.     m_name = name;
  1390. }
  1391.  
  1392. wxVariant::wxVariant(const wxVariant& variant)
  1393.     : wxObject()
  1394. {
  1395.     if (!variant.IsNull())
  1396.     {
  1397.         m_data = (wxVariantData*) variant.GetData()->GetClassInfo()->CreateObject();
  1398.         variant.m_data->Copy(*m_data);
  1399.     }
  1400.     else
  1401.         m_data = (wxVariantData*) NULL;
  1402.     m_name = variant.m_name;
  1403. }
  1404.  
  1405. wxVariant::wxVariant(wxVariantData* data, const wxString& name) // User-defined data
  1406. {
  1407.     m_data = data;
  1408.     m_name = name;
  1409. }
  1410.  
  1411. wxVariant::~wxVariant()
  1412. {
  1413.     delete m_data;
  1414. }
  1415.  
  1416.  
  1417. // Make NULL (i.e. delete the data)
  1418. void wxVariant::MakeNull()
  1419. {
  1420.     delete m_data;
  1421.     m_data = NULL;
  1422. }
  1423.  
  1424. // Generic operators
  1425. // Assignment
  1426. void wxVariant::operator= (const wxVariant& variant)
  1427. {
  1428.     if (variant.IsNull())
  1429.     {
  1430.         MakeNull();
  1431.         return;
  1432.     }
  1433.  
  1434.     if (IsNull() || (GetType() != variant.GetType()))
  1435.     {
  1436.         if (m_data)
  1437.             delete m_data;
  1438.         m_data = (wxVariantData*) variant.GetData()->GetClassInfo()->CreateObject();
  1439.     }
  1440.  
  1441.     variant.GetData()->Copy(* GetData());
  1442.  
  1443.     m_name = variant.m_name;
  1444. }
  1445.  
  1446. // Assignment using data, e.g.
  1447. // myVariant = new wxStringVariantData("hello")
  1448. void wxVariant::operator= (wxVariantData* variantData)
  1449. {
  1450.     MakeNull();
  1451.     m_data = variantData;
  1452. }
  1453.  
  1454. bool wxVariant::operator== (const wxVariant& variant) const
  1455. {
  1456.     if (IsNull() || variant.IsNull())
  1457.         return (IsNull() == variant.IsNull());
  1458.  
  1459.     return (GetData()->Eq(* variant.GetData()));
  1460. }
  1461.  
  1462. bool wxVariant::operator!= (const wxVariant& variant) const
  1463. {
  1464.     return (!(*this == variant));
  1465. }
  1466.  
  1467.  
  1468. // Specific operators
  1469. bool wxVariant::operator== (double value) const
  1470. {
  1471.     double thisValue;
  1472.     if (!Convert(&thisValue))
  1473.         return FALSE;
  1474.     else
  1475.         return (value == thisValue);
  1476. }
  1477.  
  1478. bool wxVariant::operator!= (double value) const
  1479. {
  1480.     return (!((*this) == value));
  1481. }
  1482.  
  1483. void wxVariant::operator= (double value)
  1484. {
  1485.     if (GetType() == wxT("double"))
  1486.     {
  1487.         ((wxVariantDataReal*)GetData())->SetValue(value);
  1488.     }
  1489.     else
  1490.     {
  1491.         if (m_data)
  1492.             delete m_data;
  1493.         m_data = new wxVariantDataReal(value);
  1494.     }
  1495. }
  1496.  
  1497. bool wxVariant::operator== (long value) const
  1498. {
  1499.     long thisValue;
  1500.     if (!Convert(&thisValue))
  1501.         return FALSE;
  1502.     else
  1503.         return (value == thisValue);
  1504. }
  1505.  
  1506. bool wxVariant::operator!= (long value) const
  1507. {
  1508.     return (!((*this) == value));
  1509. }
  1510.  
  1511. void wxVariant::operator= (long value)
  1512. {
  1513.     if (GetType() == wxT("long"))
  1514.     {
  1515.         ((wxVariantDataLong*)GetData())->SetValue(value);
  1516.     }
  1517.     else
  1518.     {
  1519.         if (m_data)
  1520.             delete m_data;
  1521.         m_data = new wxVariantDataLong(value);
  1522.     }
  1523. }
  1524.  
  1525. bool wxVariant::operator== (char value) const
  1526. {
  1527.     char thisValue;
  1528.     if (!Convert(&thisValue))
  1529.         return FALSE;
  1530.     else
  1531.         return (value == thisValue);
  1532. }
  1533.  
  1534. bool wxVariant::operator!= (char value) const
  1535. {
  1536.     return (!((*this) == value));
  1537. }
  1538.  
  1539. void wxVariant::operator= (char value)
  1540. {
  1541.     if (GetType() == wxT("char"))
  1542.     {
  1543.         ((wxVariantDataChar*)GetData())->SetValue(value);
  1544.     }
  1545.     else
  1546.     {
  1547.         if (m_data)
  1548.             delete m_data;
  1549.         m_data = new wxVariantDataChar(value);
  1550.     }
  1551. }
  1552.  
  1553. #ifdef HAVE_BOOL
  1554. bool wxVariant::operator== (bool value) const
  1555. {
  1556.     bool thisValue;
  1557.     if (!Convert(&thisValue))
  1558.         return FALSE;
  1559.     else
  1560.         return (value == thisValue);
  1561. }
  1562.  
  1563. bool wxVariant::operator!= (bool value) const
  1564. {
  1565.     return (!((*this) == value));
  1566. }
  1567.  
  1568. void wxVariant::operator= (bool value)
  1569. {
  1570.     if (GetType() == wxT("bool"))
  1571.     {
  1572.         ((wxVariantDataBool*)GetData())->SetValue(value);
  1573.     }
  1574.     else
  1575.     {
  1576.         if (m_data)
  1577.             delete m_data;
  1578.         m_data = new wxVariantDataBool(value);
  1579.     }
  1580. }
  1581. #endif // HAVE_BOOL
  1582.  
  1583. bool wxVariant::operator== (const wxString& value) const
  1584. {
  1585.     wxString thisValue;
  1586.     if (!Convert(&thisValue))
  1587.         return FALSE;
  1588.  
  1589.     return value == thisValue;
  1590. }
  1591.  
  1592. bool wxVariant::operator!= (const wxString& value) const
  1593. {
  1594.     return (!((*this) == value));
  1595. }
  1596.  
  1597. void wxVariant::operator= (const wxString& value)
  1598. {
  1599.     if (GetType() == wxT("string"))
  1600.     {
  1601.         ((wxVariantDataString*)GetData())->SetValue(value);
  1602.     }
  1603.     else
  1604.     {
  1605.         if (m_data)
  1606.             delete m_data;
  1607.         m_data = new wxVariantDataString(value);
  1608.     }
  1609. }
  1610.  
  1611. void wxVariant::operator= (const wxChar* value)
  1612. {
  1613.     if (GetType() == wxT("string"))
  1614.     {
  1615.         ((wxVariantDataString*)GetData())->SetValue(wxString(value));
  1616.     }
  1617.     else
  1618.     {
  1619.         if (m_data)
  1620.             delete m_data;
  1621.         m_data = new wxVariantDataString(wxString(value));
  1622.     }
  1623. }
  1624.  
  1625. bool wxVariant::operator== (const wxStringList& value) const
  1626. {
  1627.     wxASSERT_MSG( (GetType() == wxT("stringlist")), wxT("Invalid type for == operator") );
  1628.  
  1629.     wxVariantDataStringList other(value);
  1630.     return (m_data->Eq(other));
  1631. }
  1632.  
  1633. bool wxVariant::operator!= (const wxStringList& value) const
  1634. {
  1635.     return (!((*this) == value));
  1636. }
  1637.  
  1638. void wxVariant::operator= (const wxStringList& value)
  1639. {
  1640.     if (GetType() == wxT("stringlist"))
  1641.     {
  1642.         ((wxVariantDataStringList*)GetData())->SetValue(value);
  1643.     }
  1644.     else
  1645.     {
  1646.         if (m_data)
  1647.             delete m_data;
  1648.         m_data = new wxVariantDataStringList(value);
  1649.     }
  1650. }
  1651.  
  1652. bool wxVariant::operator== (const wxList& value) const
  1653. {
  1654.     wxASSERT_MSG( (GetType() == wxT("list")), wxT("Invalid type for == operator") );
  1655.  
  1656.     wxVariantDataList other(value);
  1657.     return (m_data->Eq(other));
  1658. }
  1659.  
  1660. bool wxVariant::operator!= (const wxList& value) const
  1661. {
  1662.     return (!((*this) == value));
  1663. }
  1664.  
  1665. void wxVariant::operator= (const wxList& value)
  1666. {
  1667.     if (GetType() == wxT("list"))
  1668.     {
  1669.         ((wxVariantDataList*)GetData())->SetValue(value);
  1670.     }
  1671.     else
  1672.     {
  1673.         if (m_data)
  1674.             delete m_data;
  1675.         m_data = new wxVariantDataList(value);
  1676.     }
  1677. }
  1678.  
  1679. // For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
  1680. #if wxUSE_TIMEDATE && !defined(__WATCOMC__)
  1681. bool wxVariant::operator== (const wxTime& value) const
  1682. {
  1683.     wxTime thisValue;
  1684.     if (!Convert(&thisValue))
  1685.         return FALSE;
  1686.  
  1687.     return value == thisValue;
  1688. }
  1689.  
  1690. bool wxVariant::operator!= (const wxTime& value) const
  1691. {
  1692.     return (!((*this) == value));
  1693. }
  1694.  
  1695. void wxVariant::operator= (const wxTime& value)
  1696. {
  1697.     if (GetType() == wxT("time"))
  1698.     {
  1699.         ((wxVariantDataTime*)GetData())->SetValue(value);
  1700.     }
  1701.     else
  1702.     {
  1703.         if (m_data)
  1704.             delete m_data;
  1705.         m_data = new wxVariantDataTime(value);
  1706.     }
  1707. }
  1708.  
  1709. bool wxVariant::operator== (const wxDate& value) const
  1710. {
  1711.     wxDate thisValue;
  1712.     if (!Convert(&thisValue))
  1713.         return FALSE;
  1714.  
  1715.     return (value == thisValue);
  1716. }
  1717.  
  1718. bool wxVariant::operator!= (const wxDate& value) const
  1719. {
  1720.     return (!((*this) == value));
  1721. }
  1722.  
  1723. void wxVariant::operator= (const wxDate& value)
  1724. {
  1725.     if (GetType() == wxT("date"))
  1726.     {
  1727.         ((wxVariantDataTime*)GetData())->SetValue(value);
  1728.     }
  1729.     else
  1730.     {
  1731.         if (m_data)
  1732.             delete m_data;
  1733.         m_data = new wxVariantDataDate(value);
  1734.     }
  1735. }
  1736. #endif
  1737.  
  1738. bool wxVariant::operator== (void* value) const
  1739. {
  1740.     return (value == ((wxVariantDataVoidPtr*)GetData())->GetValue());
  1741. }
  1742.  
  1743. bool wxVariant::operator!= (void* value) const
  1744. {
  1745.     return (!((*this) == (void*) value));
  1746. }
  1747.  
  1748. void wxVariant::operator= (void* value)
  1749. {
  1750.     if (GetType() == wxT("void*"))
  1751.     {
  1752.         ((wxVariantDataVoidPtr*)GetData())->SetValue(value);
  1753.     }
  1754.     else
  1755.     {
  1756.         if (m_data)
  1757.             delete m_data;
  1758.         m_data = new wxVariantDataVoidPtr(value);
  1759.     }
  1760. }
  1761.  
  1762. bool wxVariant::operator== (const wxDateTime& value) const
  1763. {
  1764.     wxDateTime thisValue;
  1765.     if (!Convert(&thisValue))
  1766.         return FALSE;
  1767.  
  1768.     return value.IsEqualTo(thisValue);
  1769. }
  1770.  
  1771. bool wxVariant::operator!= (const wxDateTime& value) const
  1772. {
  1773.     return (!((*this) == value));
  1774. }
  1775.  
  1776. void wxVariant::operator= (const wxDateTime& value)
  1777. {
  1778.     if (GetType() == wxT("datetime"))
  1779.     {
  1780.         ((wxVariantDataDateTime*)GetData())->SetValue(value);
  1781.     }
  1782.     else
  1783.     {
  1784.         if (m_data)
  1785.             delete m_data;
  1786.         m_data = new wxVariantDataDateTime(value);
  1787.     }
  1788. }
  1789.  
  1790. #if wxUSE_ODBC
  1791. void wxVariant::operator= (const DATE_STRUCT* value)
  1792. {
  1793.     if (m_data)
  1794.         delete m_data;
  1795.     m_data = new wxVariantDataDateTime(value);
  1796. }
  1797.  
  1798.  
  1799. void wxVariant::operator= (const TIME_STRUCT* value)
  1800. {
  1801.     if (m_data)
  1802.         delete m_data;
  1803.     m_data = new wxVariantDataDateTime(value);
  1804. }
  1805.  
  1806.  
  1807. void wxVariant::operator= (const TIMESTAMP_STRUCT* value)
  1808. {
  1809.     if (m_data)
  1810.         delete m_data;
  1811.     m_data = new wxVariantDataDateTime(value);
  1812. }
  1813.  
  1814. #endif // wxUSE_ODBC
  1815.  
  1816. bool wxVariant::operator==(const wxArrayString& WXUNUSED(value)) const
  1817. {
  1818.     wxFAIL_MSG( _T("TODO") );
  1819.  
  1820.     return FALSE;
  1821. }
  1822.  
  1823. bool wxVariant::operator!=(const wxArrayString& value) const
  1824. {
  1825.     return !(*this == value);
  1826. }
  1827.  
  1828. void wxVariant::operator=(const wxArrayString& value)
  1829. {
  1830.     if (GetType() == wxT("arrstring"))
  1831.     {
  1832.         ((wxVariantDataArrayString *)GetData())->SetValue(value);
  1833.     }
  1834.     else
  1835.     {
  1836.         delete m_data;
  1837.         m_data = new wxVariantDataArrayString(value);
  1838.     }
  1839. }
  1840.  
  1841. wxArrayString wxVariant::GetArrayString() const
  1842. {
  1843.     if ( GetType() == wxT("arrstring") )
  1844.         return ((wxVariantDataArrayString *)GetData())->GetValue();
  1845.  
  1846.     return wxArrayString();
  1847. }
  1848.  
  1849.  
  1850. // Treat a list variant as an array
  1851. wxVariant wxVariant::operator[] (size_t idx) const
  1852. {
  1853.     wxASSERT_MSG( (GetType() == wxT("list") || GetType() == wxT("stringlist")), wxT("Invalid type for array operator") );
  1854.  
  1855.     if (GetType() == wxT("list"))
  1856.     {
  1857.         wxVariantDataList* data = (wxVariantDataList*) m_data;
  1858.         wxASSERT_MSG( (idx < (size_t) data->GetValue().Number()), wxT("Invalid index for array") );
  1859.         return * (wxVariant*) (data->GetValue().Nth(idx)->Data());
  1860.     }
  1861.     else if (GetType() == wxT("stringlist"))
  1862.     {
  1863.         wxVariantDataStringList* data = (wxVariantDataStringList*) m_data;
  1864.         wxASSERT_MSG( (idx < (size_t) data->GetValue().Number()), wxT("Invalid index for array") );
  1865.  
  1866.         wxVariant variant( wxString( (wxChar*) (data->GetValue().Nth(idx)->Data()) ));
  1867.         return variant;
  1868.     }
  1869.     return wxNullVariant;
  1870. }
  1871.  
  1872. wxVariant& wxVariant::operator[] (size_t idx)
  1873. {
  1874.     // We can't return a reference to a variant for a string list, since the string
  1875.     // is actually stored as a char*, not a variant.
  1876.  
  1877.     wxASSERT_MSG( (GetType() == wxT("list")), wxT("Invalid type for array operator") );
  1878.  
  1879.     wxVariantDataList* data = (wxVariantDataList*) m_data;
  1880.     wxASSERT_MSG( (idx < (size_t) data->GetValue().Number()), wxT("Invalid index for array") );
  1881.  
  1882.     return * (wxVariant*) (data->GetValue().Nth(idx)->Data());
  1883. }
  1884.  
  1885. // Return the number of elements in a list
  1886. int wxVariant::GetCount() const
  1887. {
  1888.     wxASSERT_MSG( (GetType() == wxT("list") || GetType() == wxT("stringlist")), wxT("Invalid type for GetCount()") );
  1889.  
  1890.     if (GetType() == wxT("list"))
  1891.     {
  1892.         wxVariantDataList* data = (wxVariantDataList*) m_data;
  1893.         return data->GetValue().Number();
  1894.     }
  1895.     else if (GetType() == wxT("stringlist"))
  1896.     {
  1897.         wxVariantDataStringList* data = (wxVariantDataStringList*) m_data;
  1898.         return data->GetValue().Number();
  1899.     }
  1900.     return 0;
  1901. }
  1902.  
  1903. wxString wxVariant::MakeString() const
  1904. {
  1905.     if (!IsNull())
  1906.     {
  1907.         wxString str;
  1908.         if (GetData()->Write(str))
  1909.             return str;
  1910.     }
  1911.     return wxString(wxT(""));
  1912. }
  1913.  
  1914. // Accessors
  1915.  
  1916. void wxVariant::SetData(wxVariantData* data)
  1917. {
  1918.     if (m_data) delete m_data;
  1919.     m_data = data;
  1920. }
  1921.  
  1922.  
  1923. // Returns a string representing the type of the variant,
  1924. // e.g. "string", "bool", "stringlist", "list", "double", "long"
  1925. wxString wxVariant::GetType() const
  1926. {
  1927.     if (IsNull())
  1928.         return wxString(wxT("null"));
  1929.     else
  1930.         return m_data->GetType();
  1931. }
  1932.  
  1933.  
  1934. bool wxVariant::IsType(const wxString& type) const
  1935. {
  1936.     return (GetType() == type);
  1937. }
  1938.  
  1939.  
  1940. // Value accessors
  1941. double wxVariant::GetReal() const
  1942. {
  1943.     double value;
  1944.     if (Convert(& value))
  1945.         return value;
  1946.     else
  1947.     {
  1948.         wxFAIL_MSG(wxT("Could not convert to a real number"));
  1949.         return 0.0;
  1950.     }
  1951. }
  1952.  
  1953. long wxVariant::GetInteger() const
  1954. {
  1955.     long value;
  1956.     if (Convert(& value))
  1957.         return value;
  1958.     else
  1959.     {
  1960.         wxFAIL_MSG(wxT("Could not convert to an integer"));
  1961.         return 0;
  1962.     }
  1963. }
  1964.  
  1965. char wxVariant::GetChar() const
  1966. {
  1967.     char value;
  1968.     if (Convert(& value))
  1969.         return value;
  1970.     else
  1971.     {
  1972.         wxFAIL_MSG(wxT("Could not convert to a char"));
  1973.         return 0;
  1974.     }
  1975. }
  1976.  
  1977. bool wxVariant::GetBool() const
  1978. {
  1979.     bool value;
  1980.     if (Convert(& value))
  1981.         return value;
  1982.     else
  1983.     {
  1984.         wxFAIL_MSG(wxT("Could not convert to a bool"));
  1985.         return 0;
  1986.     }
  1987. }
  1988.  
  1989. wxString wxVariant::GetString() const
  1990. {
  1991.     wxString value;
  1992.     if (!Convert(& value))
  1993.     {
  1994.         wxFAIL_MSG(wxT("Could not convert to a string"));
  1995.     }
  1996.  
  1997.     return value;
  1998. }
  1999.  
  2000. // For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
  2001. #if wxUSE_TIMEDATE && !defined(__WATCOMC__)
  2002. wxTime wxVariant::GetTime() const
  2003. {
  2004.     wxTime value;
  2005.     if (!Convert(& value))
  2006.     {
  2007.         wxFAIL_MSG(wxT("Could not convert to a time"));
  2008.     }
  2009.  
  2010.     return value;
  2011. }
  2012.  
  2013. wxDate wxVariant::GetDate() const
  2014. {
  2015.     wxDate value;
  2016.     if (!Convert(& value))
  2017.     {
  2018.         wxFAIL_MSG(wxT("Could not convert to a date"));
  2019.     }
  2020.  
  2021.     return value;
  2022. }
  2023. #endif // wxUSE_TIMEDATE
  2024.  
  2025. void* wxVariant::GetVoidPtr() const
  2026. {
  2027.     wxASSERT( (GetType() == wxT("void*")) );
  2028.  
  2029.     return (void*) ((wxVariantDataVoidPtr*) m_data)->GetValue();
  2030. }
  2031.  
  2032. wxDateTime wxVariant::GetDateTime() const
  2033. {
  2034.     wxDateTime value;
  2035.     if (!Convert(& value))
  2036.     {
  2037.         wxFAIL_MSG(wxT("Could not convert to a datetime"));
  2038.     }
  2039.  
  2040.     return value;
  2041. }
  2042.  
  2043. wxList& wxVariant::GetList() const
  2044. {
  2045.     wxASSERT( (GetType() == wxT("list")) );
  2046.  
  2047.     return (wxList&) ((wxVariantDataList*) m_data)->GetValue();
  2048. }
  2049.  
  2050. wxStringList& wxVariant::GetStringList() const
  2051. {
  2052.     wxASSERT( (GetType() == wxT("stringlist")) );
  2053.  
  2054.     return (wxStringList&) ((wxVariantDataStringList*) m_data)->GetValue();
  2055. }
  2056.  
  2057. // Make empty list
  2058. void wxVariant::NullList()
  2059. {
  2060.     SetData(new wxVariantDataList());
  2061. };
  2062.  
  2063. // Append to list
  2064. void wxVariant::Append(const wxVariant& value)
  2065. {
  2066.     wxList& list = GetList();
  2067.  
  2068.     list.Append(new wxVariant(value));
  2069. }
  2070.  
  2071. // Insert at front of list
  2072. void wxVariant::Insert(const wxVariant& value)
  2073. {
  2074.     wxList& list = GetList();
  2075.  
  2076.     list.Insert(new wxVariant(value));
  2077. }
  2078.  
  2079. // Returns TRUE if the variant is a member of the list
  2080. bool wxVariant::Member(const wxVariant& value) const
  2081. {
  2082.     wxList& list = GetList();
  2083.  
  2084.     wxNode* node = list.First();
  2085.     while (node)
  2086.     {
  2087.         wxVariant* other = (wxVariant*) node->Data();
  2088.         if (value == *other)
  2089.             return TRUE;
  2090.         node = node->Next();
  2091.     }
  2092.     return FALSE;
  2093. }
  2094.  
  2095. // Deletes the nth element of the list
  2096. bool wxVariant::Delete(int item)
  2097. {
  2098.     wxList& list = GetList();
  2099.  
  2100.     wxASSERT_MSG( (item < list.Number()), wxT("Invalid index to Delete") );
  2101.     wxNode* node = list.Nth(item);
  2102.     wxVariant* variant = (wxVariant*) node->Data();
  2103.     delete variant;
  2104.     delete node;
  2105.     return TRUE;
  2106. }
  2107.  
  2108. // Clear list
  2109. void wxVariant::ClearList()
  2110. {
  2111.     if (!IsNull() && (GetType() == wxT("list")))
  2112.     {
  2113.         ((wxVariantDataList*) m_data)->Clear();
  2114.     }
  2115.     else
  2116.     {
  2117.         if (GetType() != wxT("list"))
  2118.         {
  2119.             delete m_data;
  2120.             m_data = NULL;
  2121.         }
  2122.         m_data = new wxVariantDataList;
  2123.     }
  2124. }
  2125.  
  2126. // Type conversion
  2127. bool wxVariant::Convert(long* value) const
  2128. {
  2129.     wxString type(GetType());
  2130.     if (type == wxT("double"))
  2131.         *value = (long) (((wxVariantDataReal*)GetData())->GetValue());
  2132.     else if (type == wxT("long"))
  2133.         *value = ((wxVariantDataLong*)GetData())->GetValue();
  2134. #ifdef HAVE_BOOL
  2135.     else if (type == wxT("bool"))
  2136.         *value = (long) (((wxVariantDataBool*)GetData())->GetValue());
  2137. #endif
  2138.     else if (type == wxT("string"))
  2139.         *value = wxAtol((const wxChar*) ((wxVariantDataString*)GetData())->GetValue());
  2140.     else
  2141.         return FALSE;
  2142.  
  2143.     return TRUE;
  2144. }
  2145.  
  2146. bool wxVariant::Convert(bool* value) const
  2147. {
  2148.     wxString type(GetType());
  2149.     if (type == wxT("double"))
  2150.         *value = ((int) (((wxVariantDataReal*)GetData())->GetValue()) != 0);
  2151.     else if (type == wxT("long"))
  2152.         *value = (((wxVariantDataLong*)GetData())->GetValue() != 0);
  2153. #ifdef HAVE_BOOL
  2154.     else if (type == wxT("bool"))
  2155.         *value = ((wxVariantDataBool*)GetData())->GetValue();
  2156. #endif
  2157.     else if (type == wxT("string"))
  2158.     {
  2159.         wxString val(((wxVariantDataString*)GetData())->GetValue());
  2160.         val.MakeLower();
  2161.         if (val == wxT("true") || val == wxT("yes"))
  2162.             *value = TRUE;
  2163.         else if (val == wxT("false") || val == wxT("no"))
  2164.             *value = FALSE;
  2165.         else
  2166.             return FALSE;
  2167.     }
  2168.     else
  2169.         return FALSE;
  2170.  
  2171.     return TRUE;
  2172. }
  2173.  
  2174. bool wxVariant::Convert(double* value) const
  2175. {
  2176.     wxString type(GetType());
  2177.     if (type == wxT("double"))
  2178.         *value = ((wxVariantDataReal*)GetData())->GetValue();
  2179.     else if (type == wxT("long"))
  2180.         *value = (double) (((wxVariantDataLong*)GetData())->GetValue());
  2181. #ifdef HAVE_BOOL
  2182.     else if (type == wxT("bool"))
  2183.         *value = (double) (((wxVariantDataBool*)GetData())->GetValue());
  2184. #endif
  2185.     else if (type == wxT("string"))
  2186.         *value = (double) wxAtof((const wxChar*) ((wxVariantDataString*)GetData())->GetValue());
  2187.     else
  2188.         return FALSE;
  2189.  
  2190.     return TRUE;
  2191. }
  2192.  
  2193. bool wxVariant::Convert(char* value) const
  2194. {
  2195.     wxString type(GetType());
  2196.     if (type == wxT("char"))
  2197.         *value = ((wxVariantDataChar*)GetData())->GetValue();
  2198.     else if (type == wxT("long"))
  2199.         *value = (char) (((wxVariantDataLong*)GetData())->GetValue());
  2200. #ifdef HAVE_BOOL
  2201.     else if (type == wxT("bool"))
  2202.         *value = (char) (((wxVariantDataBool*)GetData())->GetValue());
  2203. #endif
  2204.     else
  2205.         return FALSE;
  2206.  
  2207.     return TRUE;
  2208. }
  2209.  
  2210. bool wxVariant::Convert(wxString* value) const
  2211. {
  2212.     *value = MakeString();
  2213.     return TRUE;
  2214. }
  2215.  
  2216. // For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
  2217. #if wxUSE_TIMEDATE && !defined(__WATCOMC__)
  2218. bool wxVariant::Convert(wxTime* value) const
  2219. {
  2220.     wxString type(GetType());
  2221.     if (type == wxT("time"))
  2222.         *value = ((wxVariantDataTime*)GetData())->GetValue();
  2223.     else if (type == wxT("date"))
  2224.         *value = wxTime(((wxVariantDataDate*)GetData())->GetValue());
  2225.     else
  2226.         return FALSE;
  2227.  
  2228.     return TRUE;
  2229. }
  2230.  
  2231. bool wxVariant::Convert(wxDate* value) const
  2232. {
  2233.     wxString type(GetType());
  2234.     if (type == wxT("date"))
  2235.         *value = ((wxVariantDataDate*)GetData())->GetValue();
  2236.     else
  2237.         return FALSE;
  2238.  
  2239.     return TRUE;
  2240. }
  2241. #endif // wxUSE_TIMEDATE
  2242.  
  2243. bool wxVariant::Convert(wxDateTime* value) const
  2244. {
  2245.     wxString type(GetType());
  2246.     if (type == wxT("datetime"))
  2247.     {
  2248.         *value = ((wxVariantDataDateTime*)GetData())->GetValue();
  2249.         return TRUE;
  2250.     } 
  2251.     // Fallback to string conversion
  2252.     wxString val;
  2253.     return Convert(&val) && (value->ParseDate(val));
  2254. }
  2255.