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