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