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