]>
Commit | Line | Data |
---|---|---|
23324ae1 FM |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: variant.h | |
e54c96f1 | 3 | // Purpose: interface of wxVariant |
23324ae1 FM |
4 | // Author: wxWidgets team |
5 | // RCS-ID: $Id$ | |
6 | // Licence: wxWindows license | |
7 | ///////////////////////////////////////////////////////////////////////////// | |
8 | ||
9 | /** | |
10 | @class wxVariant | |
7c913512 | 11 | |
09ad05fa | 12 | The wxVariant class represents a container for any type. A variant's value |
c1996262 | 13 | can be changed at run time, possibly to a different type of value. |
7c913512 | 14 | |
23324ae1 | 15 | As standard, wxVariant can store values of type bool, wxChar, double, long, |
09ad05fa BP |
16 | string, string list, time, date, void pointer, list of strings, and list of |
17 | variants. However, an application can extend wxVariant's capabilities by | |
18 | deriving from the class wxVariantData and using the wxVariantData form of | |
19 | the wxVariant constructor or assignment operator to assign this data to a | |
20 | variant. Actual values for user-defined types will need to be accessed via | |
21 | the wxVariantData object, unlike the case for basic data types where | |
22 | convenience functions such as GetLong() can be used. | |
23 | ||
24 | Pointers to any wxObject derived class can also easily be stored in a | |
25 | wxVariant. wxVariant will then use wxWidgets' built-in RTTI system to set | |
26 | the type name (returned by GetType()) and to perform type-safety checks at | |
27 | runtime. | |
28 | ||
29 | This class is useful for reducing the programming for certain tasks, such | |
30 | as an editor for different data types, or a remote procedure call protocol. | |
7c913512 | 31 | |
c1996262 | 32 | An optional name member is associated with a wxVariant. This might be used, |
09ad05fa BP |
33 | for example, in CORBA or OLE automation classes, where named parameters are |
34 | required. | |
7c913512 | 35 | |
09ad05fa BP |
36 | Note that as of wxWidgets 2.7.1, wxVariant is |
37 | @ref overview_refcount "reference counted". Additionally, the convenience | |
38 | macros DECLARE_VARIANT_OBJECT() and IMPLEMENT_VARIANT_OBJECT() were added | |
39 | so that adding (limited) support for conversion to and from wxVariant can | |
40 | be very easily implemented without modifying either wxVariant or the class | |
41 | to be stored by wxVariant. Since assignment operators cannot be declared | |
42 | outside the class, the shift left operators are used like this: | |
7c913512 | 43 | |
23324ae1 FM |
44 | @code |
45 | // in the header file | |
c1996262 | 46 | DECLARE_VARIANT_OBJECT(MyClass) |
7c913512 | 47 | |
c1996262 RR |
48 | // in the implementation file |
49 | IMPLEMENT_VARIANT_OBJECT(MyClass) | |
7c913512 | 50 | |
c1996262 RR |
51 | // in the user code |
52 | wxVariant variant; | |
53 | MyClass value; | |
54 | variant << value; | |
7c913512 | 55 | |
c1996262 RR |
56 | // or |
57 | value << variant; | |
23324ae1 | 58 | @endcode |
7c913512 | 59 | |
09ad05fa BP |
60 | For this to work, MyClass must derive from wxObject, implement the |
61 | @ref overview_rtti "wxWidgets RTTI system" and support the assignment | |
62 | operator and equality operator for itself. Ideally, it should also be | |
63 | reference counted to make copying operations cheap and fast. This can be | |
64 | most easily implemented using the reference counting support offered by | |
65 | wxObject itself. By default, wxWidgets already implements the shift | |
66 | operator conversion for a few of its drawing related classes: | |
7c913512 | 67 | |
23324ae1 FM |
68 | @code |
69 | IMPLEMENT_VARIANT_OBJECT(wxColour) | |
70 | IMPLEMENT_VARIANT_OBJECT(wxImage) | |
71 | IMPLEMENT_VARIANT_OBJECT(wxIcon) | |
72 | IMPLEMENT_VARIANT_OBJECT(wxBitmap) | |
73 | @endcode | |
7c913512 | 74 | |
09ad05fa BP |
75 | Note that as of wxWidgets 2.9.0, wxVariantData no longer inherits from |
76 | wxObject and wxVariant no longer uses the type-unsafe wxList class for list | |
23324ae1 | 77 | operations but the type-safe wxVariantList class. Also, wxVariantData now |
09ad05fa BP |
78 | supports the wxVariantData::Clone() function for implementing the Unshare() |
79 | function. wxVariantData::Clone() is implemented automatically by | |
80 | IMPLEMENT_VARIANT_OBJECT(). | |
7c913512 | 81 | |
09ad05fa BP |
82 | Since wxVariantData no longer derives from wxObject, any code that tests |
83 | the type of the data using wxDynamicCast() will require adjustment. You can | |
84 | use the macro wxDynamicCastVariantData() with the same arguments as | |
85 | wxDynamicCast(), to use C++ RTTI type information instead of wxWidgets | |
86 | RTTI. | |
7c913512 | 87 | |
23324ae1 FM |
88 | @library{wxbase} |
89 | @category{data} | |
7c913512 | 90 | |
e54c96f1 | 91 | @see wxVariantData |
23324ae1 FM |
92 | */ |
93 | class wxVariant : public wxObject | |
94 | { | |
95 | public: | |
23324ae1 | 96 | /** |
c1996262 | 97 | Default constructor. |
23324ae1 FM |
98 | */ |
99 | wxVariant(); | |
da1ed74c | 100 | |
c1996262 | 101 | /** |
09ad05fa BP |
102 | Constructs a variant directly with a wxVariantData object. wxVariant |
103 | will take ownership of the wxVariantData and will not increase its | |
104 | reference count. | |
c1996262 | 105 | */ |
da1ed74c FM |
106 | wxVariant(wxVariantData* data, const wxString& name = wxEmptyString); |
107 | ||
c1996262 | 108 | /** |
09ad05fa BP |
109 | Constructs a variant from another variant by increasing the reference |
110 | count. | |
c1996262 | 111 | */ |
7c913512 | 112 | wxVariant(const wxVariant& variant); |
da1ed74c | 113 | |
c1996262 RR |
114 | /** |
115 | Constructs a variant from a wide string literal. | |
116 | */ | |
da1ed74c FM |
117 | wxVariant(const wxChar* value, const wxString& name = wxEmptyString); |
118 | ||
c1996262 RR |
119 | /** |
120 | Constructs a variant from a string. | |
121 | */ | |
da1ed74c FM |
122 | wxVariant(const wxString& value, const wxString& name = wxEmptyString); |
123 | ||
c1996262 RR |
124 | /** |
125 | Constructs a variant from a wide char. | |
126 | */ | |
da1ed74c FM |
127 | wxVariant(wxChar value, const wxString& name = wxEmptyString); |
128 | ||
c1996262 RR |
129 | /** |
130 | Constructs a variant from a long. | |
131 | */ | |
da1ed74c FM |
132 | wxVariant(long value, const wxString& name = wxEmptyString); |
133 | ||
c1996262 RR |
134 | /** |
135 | Constructs a variant from a bool. | |
136 | */ | |
da1ed74c FM |
137 | wxVariant(bool value, const wxString& name = wxEmptyString); |
138 | ||
c1996262 RR |
139 | /** |
140 | Constructs a variant from a double. | |
141 | */ | |
da1ed74c FM |
142 | wxVariant(double value, const wxString& name = wxEmptyString); |
143 | ||
c1996262 RR |
144 | /** |
145 | Constructs a variant from a list of variants | |
146 | */ | |
da1ed74c FM |
147 | wxVariant(const wxVariantList& value, const wxString& name = wxEmptyString); |
148 | ||
c1996262 RR |
149 | /** |
150 | Constructs a variant from a void pointer. | |
151 | */ | |
da1ed74c FM |
152 | wxVariant(void* value, const wxString& name = wxEmptyString); |
153 | ||
c1996262 RR |
154 | /** |
155 | Constructs a variant from a pointer to an wxObject | |
156 | derived class. | |
157 | */ | |
da1ed74c FM |
158 | wxVariant(wxObject* value, const wxString& name = wxEmptyString); |
159 | ||
c1996262 RR |
160 | /** |
161 | Constructs a variant from a wxDateTime. | |
162 | */ | |
da1ed74c FM |
163 | wxVariant(wxDateTime& val, const wxString& name = wxEmptyString); |
164 | ||
c1996262 RR |
165 | /** |
166 | Constructs a variant from a wxArrayString. | |
167 | */ | |
da1ed74c | 168 | wxVariant(wxArrayString& val, const wxString& name = wxEmptyString); |
23324ae1 FM |
169 | |
170 | /** | |
171 | Destructor. | |
09ad05fa BP |
172 | |
173 | @note wxVariantData's destructor is protected, so wxVariantData cannot | |
174 | usually be deleted. Instead, wxVariantData::DecRef() should be | |
175 | called. See @ref overview_refcount_destruct | |
176 | "reference-counted object destruction" for more info. | |
23324ae1 | 177 | */ |
adaaa686 | 178 | virtual ~wxVariant(); |
23324ae1 | 179 | |
09ad05fa | 180 | |
c1996262 | 181 | /** |
09ad05fa | 182 | @name List Functionality |
c1996262 RR |
183 | */ |
184 | //@{ | |
09ad05fa | 185 | |
c1996262 RR |
186 | /** |
187 | Returns the value at @a idx (zero-based). | |
188 | */ | |
09ad05fa | 189 | wxVariant operator [](size_t idx) const; |
c1996262 | 190 | /** |
09ad05fa BP |
191 | Returns a reference to the value at @a idx (zero-based). This can be |
192 | used to change the value at this index. | |
c1996262 | 193 | */ |
09ad05fa BP |
194 | wxVariant& operator [](size_t idx); |
195 | ||
23324ae1 FM |
196 | /** |
197 | Appends a value to the list. | |
198 | */ | |
199 | void Append(const wxVariant& value); | |
09ad05fa BP |
200 | |
201 | /** | |
202 | Makes the variant null by deleting the internal data and set the name | |
203 | to wxEmptyString. | |
204 | */ | |
205 | void Clear(); | |
206 | ||
c1996262 RR |
207 | /** |
208 | Deletes the contents of the list. | |
209 | */ | |
210 | void ClearList(); | |
09ad05fa | 211 | |
c1996262 RR |
212 | /** |
213 | Deletes the zero-based @a item from the list. | |
214 | */ | |
215 | bool Delete(size_t item); | |
09ad05fa | 216 | |
c1996262 RR |
217 | /** |
218 | Returns the number of elements in the list. | |
219 | */ | |
220 | size_t GetCount() const; | |
09ad05fa | 221 | |
c1996262 | 222 | /** |
09ad05fa BP |
223 | Returns a reference to the wxVariantList class used by wxVariant if |
224 | this wxVariant is currently a list of variants. | |
c1996262 RR |
225 | */ |
226 | wxVariantList& GetList() const; | |
09ad05fa | 227 | |
23324ae1 | 228 | /** |
c1996262 | 229 | Inserts a value at the front of the list. |
23324ae1 | 230 | */ |
c1996262 | 231 | void Insert(const wxVariant& value); |
09ad05fa | 232 | |
c1996262 | 233 | /** |
09ad05fa BP |
234 | Makes an empty list. This differs from a null variant which has no |
235 | data; a null list is of type list, but the number of elements in the | |
236 | list is zero. | |
c1996262 RR |
237 | */ |
238 | void NullList(); | |
09ad05fa | 239 | |
c1996262 | 240 | //@} |
23324ae1 | 241 | |
09ad05fa | 242 | |
23324ae1 FM |
243 | //@{ |
244 | /** | |
09ad05fa BP |
245 | Retrieves and converts the value of this variant to the type that |
246 | @a value is. | |
23324ae1 | 247 | */ |
328f5751 | 248 | bool Convert(long* value) const; |
09ad05fa BP |
249 | bool Convert(bool* value) const; |
250 | bool Convert(double* value) const; | |
251 | bool Convert(wxString* value) const; | |
252 | bool Convert(wxChar* value) const; | |
253 | bool Convert(wxDateTime* value) const; | |
23324ae1 FM |
254 | //@} |
255 | ||
23324ae1 FM |
256 | /** |
257 | Returns the string array value. | |
258 | */ | |
328f5751 | 259 | wxArrayString GetArrayString() const; |
23324ae1 FM |
260 | |
261 | /** | |
262 | Returns the boolean value. | |
263 | */ | |
328f5751 | 264 | bool GetBool() const; |
23324ae1 FM |
265 | |
266 | /** | |
267 | Returns the character value. | |
268 | */ | |
328f5751 | 269 | wxChar GetChar() const; |
23324ae1 | 270 | |
23324ae1 | 271 | /** |
09ad05fa BP |
272 | Returns a pointer to the internal variant data. To take ownership of |
273 | this data, you must call its wxVariantData::IncRef() method. When you | |
274 | stop using it, wxVariantData::DecRef() must be called as well. | |
23324ae1 | 275 | */ |
328f5751 | 276 | wxVariantData* GetData() const; |
23324ae1 FM |
277 | |
278 | /** | |
279 | Returns the date value. | |
280 | */ | |
328f5751 | 281 | wxDateTime GetDateTime() const; |
23324ae1 FM |
282 | |
283 | /** | |
284 | Returns the floating point value. | |
285 | */ | |
328f5751 | 286 | double GetDouble() const; |
23324ae1 | 287 | |
23324ae1 FM |
288 | /** |
289 | Returns the integer value. | |
290 | */ | |
328f5751 | 291 | long GetLong() const; |
23324ae1 FM |
292 | |
293 | /** | |
294 | Returns a constant reference to the variant name. | |
295 | */ | |
328f5751 | 296 | const wxString GetName() const; |
23324ae1 FM |
297 | |
298 | /** | |
299 | Gets the string value. | |
300 | */ | |
328f5751 | 301 | wxString GetString() const; |
23324ae1 FM |
302 | |
303 | /** | |
09ad05fa BP |
304 | Returns the value type as a string. |
305 | ||
306 | The built-in types are: | |
307 | - "bool" | |
308 | - "char" | |
309 | - "datetime" | |
310 | - "double" | |
311 | - "list" | |
312 | - "long" | |
313 | - "string" | |
314 | - "arrstring" | |
315 | - "void*" | |
316 | ||
317 | If the variant is null, the value type returned is the string "null" | |
318 | (not the empty string). | |
23324ae1 | 319 | */ |
328f5751 | 320 | wxString GetType() const; |
23324ae1 FM |
321 | |
322 | /** | |
323 | Gets the void pointer value. | |
324 | */ | |
328f5751 | 325 | void* GetVoidPtr() const; |
23324ae1 FM |
326 | |
327 | /** | |
328 | Gets the wxObject pointer value. | |
329 | */ | |
328f5751 | 330 | wxObject* GetWxObjectPtr() const; |
23324ae1 | 331 | |
23324ae1 | 332 | /** |
09ad05fa BP |
333 | Returns @true if there is no data associated with this variant, @false |
334 | if there is data. | |
23324ae1 | 335 | */ |
328f5751 | 336 | bool IsNull() const; |
23324ae1 FM |
337 | |
338 | /** | |
09ad05fa BP |
339 | Returns @true if @a type matches the type of the variant, @false |
340 | otherwise. | |
23324ae1 | 341 | */ |
328f5751 | 342 | bool IsType(const wxString& type) const; |
23324ae1 FM |
343 | |
344 | /** | |
09ad05fa BP |
345 | Returns @true if the data is derived from the class described by |
346 | @a type, @false otherwise. | |
23324ae1 | 347 | */ |
09ad05fa | 348 | bool IsValueKindOf(const wxClassInfo* type) const; |
23324ae1 FM |
349 | |
350 | /** | |
351 | Makes the variant null by deleting the internal data. | |
352 | */ | |
353 | void MakeNull(); | |
354 | ||
355 | /** | |
356 | Makes a string representation of the variant value (for any type). | |
357 | */ | |
328f5751 | 358 | wxString MakeString() const; |
23324ae1 FM |
359 | |
360 | /** | |
4cc4bfaf | 361 | Returns @true if @a value matches an element in the list. |
23324ae1 | 362 | */ |
328f5751 | 363 | bool Member(const wxVariant& value) const; |
23324ae1 | 364 | |
23324ae1 | 365 | /** |
09ad05fa BP |
366 | Sets the internal variant data, deleting the existing data if there is |
367 | any. | |
23324ae1 FM |
368 | */ |
369 | void SetData(wxVariantData* data); | |
370 | ||
371 | /** | |
09ad05fa BP |
372 | Makes sure that any data associated with this variant is not shared |
373 | with other variants. For this to work, wxVariantData::Clone() must be | |
374 | implemented for the data types you are working with. | |
375 | wxVariantData::Clone() is implemented for all the default data types. | |
23324ae1 FM |
376 | */ |
377 | bool Unshare(); | |
378 | ||
379 | //@{ | |
380 | /** | |
09ad05fa | 381 | Inequality test operator. |
23324ae1 | 382 | */ |
328f5751 | 383 | bool operator !=(const wxVariant& value) const; |
09ad05fa BP |
384 | bool operator !=(const wxString& value) const; |
385 | bool operator !=(const wxChar* value) const; | |
386 | bool operator !=(wxChar value) const; | |
387 | bool operator !=(const long value) const; | |
388 | bool operator !=(const bool value) const; | |
389 | bool operator !=(const double value) const; | |
390 | bool operator !=(void* value) const; | |
391 | bool operator !=(wxObject* value) const; | |
392 | bool operator !=(const wxVariantList& value) const; | |
393 | bool operator !=(const wxArrayString& value) const; | |
394 | bool operator !=(const wxDateTime& value) const; | |
23324ae1 FM |
395 | //@} |
396 | ||
397 | //@{ | |
398 | /** | |
09ad05fa BP |
399 | Assignment operator, using @ref overview_refcount "reference counting" |
400 | if possible. | |
23324ae1 FM |
401 | */ |
402 | void operator =(const wxVariant& value); | |
7c913512 FM |
403 | void operator =(wxVariantData* value); |
404 | void operator =(const wxString& value); | |
405 | void operator =(const wxChar* value); | |
406 | void operator =(wxChar value); | |
407 | void operator =(const long value); | |
408 | void operator =(const bool value); | |
409 | void operator =(const double value); | |
410 | void operator =(void* value); | |
411 | void operator =(wxObject* value); | |
412 | void operator =(const wxVariantList& value); | |
413 | void operator =(const wxDateTime& value); | |
414 | void operator =(const wxArrayString& value); | |
23324ae1 FM |
415 | //@} |
416 | ||
417 | //@{ | |
418 | /** | |
09ad05fa | 419 | Equality test operator. |
23324ae1 | 420 | */ |
328f5751 | 421 | bool operator ==(const wxVariant& value) const; |
09ad05fa BP |
422 | bool operator ==(const wxString& value) const; |
423 | bool operator ==(const wxChar* value) const; | |
424 | bool operator ==(wxChar value) const; | |
425 | bool operator ==(const long value) const; | |
426 | bool operator ==(const bool value) const; | |
427 | bool operator ==(const double value) const; | |
428 | bool operator ==(void* value) const; | |
429 | bool operator ==(wxObject* value) const; | |
430 | bool operator ==(const wxVariantList& value) const; | |
431 | bool operator ==(const wxArrayString& value) const; | |
432 | bool operator ==(const wxDateTime& value) const; | |
23324ae1 FM |
433 | //@} |
434 | ||
23324ae1 FM |
435 | //@{ |
436 | /** | |
437 | Operator for implicit conversion to a long, using GetLong(). | |
438 | */ | |
328f5751 | 439 | double operator double() const; |
09ad05fa | 440 | long operator long() const; |
23324ae1 FM |
441 | //@} |
442 | ||
443 | /** | |
09ad05fa BP |
444 | Operator for implicit conversion to a pointer to a void, using |
445 | GetVoidPtr(). | |
23324ae1 | 446 | */ |
328f5751 | 447 | void* operator void*() const; |
23324ae1 FM |
448 | |
449 | /** | |
450 | Operator for implicit conversion to a wxChar, using GetChar(). | |
451 | */ | |
328f5751 | 452 | char operator wxChar() const; |
23324ae1 FM |
453 | |
454 | /** | |
455 | Operator for implicit conversion to a pointer to a wxDateTime, using | |
456 | GetDateTime(). | |
457 | */ | |
328f5751 | 458 | void* operator wxDateTime() const; |
23324ae1 FM |
459 | |
460 | /** | |
461 | Operator for implicit conversion to a string, using MakeString(). | |
462 | */ | |
328f5751 | 463 | wxString operator wxString() const; |
23324ae1 FM |
464 | }; |
465 | ||
466 | ||
e54c96f1 | 467 | |
23324ae1 FM |
468 | /** |
469 | @class wxVariantData | |
7c913512 | 470 | |
09ad05fa | 471 | The wxVariantData class is used to implement a new type for wxVariant. |
23324ae1 | 472 | Derive from wxVariantData, and override the pure virtual functions. |
7c913512 | 473 | |
23324ae1 | 474 | wxVariantData is @ref overview_refcount "reference counted", but you don't |
09ad05fa BP |
475 | normally have to care about this, as wxVariant manages the count |
476 | automatically. However, in case your application needs to take ownership of | |
477 | wxVariantData, be aware that the object is created with a reference count | |
478 | of 1, and passing it to wxVariant will not increase this. In other words, | |
479 | IncRef() needs to be called only if you both take ownership of | |
480 | wxVariantData and pass it to a wxVariant. Also note that the destructor is | |
481 | protected, so you can never explicitly delete a wxVariantData instance. | |
482 | Instead, DecRef() will delete the object automatically when the reference | |
483 | count reaches zero. | |
7c913512 | 484 | |
23324ae1 | 485 | @library{wxbase} |
09ad05fa | 486 | @category{data} |
7c913512 | 487 | |
09ad05fa | 488 | @see wxVariant, wxGetVariantCast() |
23324ae1 | 489 | */ |
7c913512 | 490 | class wxVariantData |
23324ae1 FM |
491 | { |
492 | public: | |
493 | /** | |
494 | Default constructor. | |
495 | */ | |
496 | wxVariantData(); | |
497 | ||
498 | /** | |
09ad05fa BP |
499 | This function can be overridden to clone the data. You must implement |
500 | this function in order for wxVariant::Unshare() to work for your data. | |
501 | This function is implemented for all built-in data types. | |
23324ae1 | 502 | */ |
adaaa686 | 503 | virtual wxVariantData* Clone() const; |
23324ae1 FM |
504 | |
505 | /** | |
506 | Decreases reference count. If the count reaches zero, the object is | |
507 | automatically deleted. | |
09ad05fa BP |
508 | |
509 | @note The destructor of wxVariantData is protected, so delete cannot be | |
510 | used as normal. Instead, DecRef() should be called. | |
23324ae1 FM |
511 | */ |
512 | void DecRef(); | |
513 | ||
514 | /** | |
09ad05fa | 515 | Returns @true if this object is equal to @a data. |
23324ae1 | 516 | */ |
da1ed74c | 517 | virtual bool Eq(wxVariantData& data) const = 0; |
23324ae1 FM |
518 | |
519 | /** | |
520 | Returns the string type of the data. | |
521 | */ | |
da1ed74c | 522 | virtual wxString GetType() const = 0; |
23324ae1 FM |
523 | |
524 | /** | |
525 | If the data is a wxObject returns a pointer to the objects wxClassInfo | |
09ad05fa | 526 | structure, if the data isn't a wxObject the method returns @NULL. |
23324ae1 | 527 | */ |
adaaa686 | 528 | virtual wxClassInfo* GetValueClassInfo(); |
23324ae1 FM |
529 | |
530 | /** | |
09ad05fa BP |
531 | Increases reference count. Note that initially wxVariantData has |
532 | reference count of 1. | |
23324ae1 FM |
533 | */ |
534 | void IncRef(); | |
535 | ||
23324ae1 | 536 | /** |
09ad05fa | 537 | Reads the data from @a stream. |
23324ae1 FM |
538 | */ |
539 | bool Read(ostream& stream); | |
09ad05fa BP |
540 | /** |
541 | Reads the data from @a string. | |
542 | */ | |
adaaa686 | 543 | virtual bool Read(wxString& string); |
23324ae1 | 544 | |
23324ae1 | 545 | /** |
09ad05fa | 546 | Writes the data to @a stream. |
23324ae1 | 547 | */ |
adaaa686 | 548 | virtual bool Write(ostream& stream) const; |
23324ae1 | 549 | /** |
09ad05fa | 550 | Writes the data to @a string. |
23324ae1 | 551 | */ |
adaaa686 | 552 | virtual bool Write(wxString& string) const; |
23324ae1 | 553 | }; |
e54c96f1 | 554 | |
09ad05fa BP |
555 | |
556 | ||
557 | // ============================================================================ | |
558 | // Global functions/macros | |
559 | // ============================================================================ | |
560 | ||
561 | /** @ingroup group_funcmacro_rtti */ | |
562 | //@{ | |
563 | ||
564 | /** | |
565 | This macro returns a pointer to the data stored in @a var (wxVariant) cast | |
566 | to the type @a classname if the data is of this type (the check is done | |
567 | during the run-time) or @NULL otherwise. | |
568 | ||
569 | @header{wx/variant.h} | |
570 | ||
571 | @see @ref overview_rtti, wxDynamicCast() | |
572 | */ | |
573 | #define wxGetVariantCast(var, classname) | |
574 | ||
575 | //@} | |
576 |