]> git.saurik.com Git - wxWidgets.git/blame - include/wx/list.h
Wrappers for *ToText
[wxWidgets.git] / include / wx / list.h
CommitLineData
c801d85f
KB
1/////////////////////////////////////////////////////////////////////////////
2// Name: list.h
3// Purpose: wxList, wxStringList classes
4// Author: Julian Smart
fd3f686c 5// Modified by: VZ at 16/11/98: WX_DECLARE_LIST() and typesafe lists added
c801d85f
KB
6// Created: 29/01/98
7// RCS-ID: $Id$
8// Copyright: (c) 1998 Julian Smart
65571936 9// Licence: wxWindows licence
c801d85f
KB
10/////////////////////////////////////////////////////////////////////////////
11
fd3f686c
VZ
12/*
13 All this is quite ugly but serves two purposes:
14 1. Be almost 100% compatible with old, untyped, wxList class
15 2. Ensure compile-time type checking for the linked lists
16
17 The idea is to have one base class (wxListBase) working with "void *" data,
18 but to hide these untyped functions - i.e. make them protected, so they
19 can only be used from derived classes which have inline member functions
20 working with right types. This achieves the 2nd goal. As for the first one,
21 we provide a special derivation of wxListBase called wxList which looks just
22 like the old class.
23*/
24
34138703
JS
25#ifndef _WX_LISTH__
26#define _WX_LISTH__
c801d85f 27
12028905 28#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && \
df5168c4 29 !(defined(__MINGW32__) && __GNUC__ == 3 && __GNUC_MINOR__ == 2)
0d3820b3 30#pragma interface "list.h"
c801d85f
KB
31#endif
32
fd3f686c
VZ
33// -----------------------------------------------------------------------------
34// headers
35// -----------------------------------------------------------------------------
36
c801d85f
KB
37#include "wx/defs.h"
38#include "wx/object.h"
3bef6c4c 39#include "wx/string.h"
c801d85f 40
df5168c4
MB
41#if wxUSE_STL
42 #include "wx/beforestd.h"
43 #include <list>
44 #include "wx/afterstd.h"
df5168c4
MB
45#endif
46
47// ----------------------------------------------------------------------------
48// types
49// ----------------------------------------------------------------------------
50
51// type of compare function for list sort operation (as in 'qsort'): it should
52// return a negative value, 0 or positive value if the first element is less
53// than, equal or greater than the second
5e967044 54
df5168c4
MB
55extern "C"
56{
57typedef int (* LINKAGEMODE wxSortCompareFunction)(const void *elem1, const void *elem2);
58}
59
bddd7a8d 60class WXDLLIMPEXP_BASE wxObjectListNode;
fd3f686c
VZ
61typedef wxObjectListNode wxNode;
62
df5168c4
MB
63//
64typedef int (* LINKAGEMODE wxListIterateFunction)(void *current);
c801d85f 65
df5168c4 66// ----------------------------------------------------------------------------
fd3f686c 67// constants
df5168c4
MB
68// ----------------------------------------------------------------------------
69
70#if !defined(wxENUM_KEY_TYPE_DEFINED)
71#define wxENUM_KEY_TYPE_DEFINED
72
fd3f686c
VZ
73enum wxKeyType
74{
75 wxKEY_NONE,
76 wxKEY_INTEGER,
77 wxKEY_STRING
78};
79
df5168c4 80#endif
fd3f686c 81
df5168c4 82#if wxUSE_STL
fd3f686c 83
df5168c4
MB
84#define wxLIST_COMPATIBILITY
85
86#define WX_DECLARE_LIST_3(elT, dummy1, liT, dummy2, decl) \
f794be6a 87 WX_DECLARE_LIST_WITH_DECL(elT, liT, decl)
6de44038
VZ
88#define WX_DECLARE_LIST_PTR_3(elT, dummy1, liT, dummy2, decl) \
89 WX_DECLARE_LIST_3(elT, dummy1, liT, dummy2, decl)
df5168c4
MB
90
91#define WX_DECLARE_LIST_2(elT, liT, dummy, decl) \
f794be6a 92 WX_DECLARE_LIST_WITH_DECL(elT, liT, decl)
6de44038
VZ
93#define WX_DECLARE_LIST_PTR_2(elT, liT, dummy, decl) \
94 WX_DECLARE_LIST_2(elT, liT, dummy, decl) \
df5168c4 95
f794be6a 96#define WX_DECLARE_LIST_WITH_DECL(elT, liT, decl) \
df5168c4
MB
97 WX_DECLARE_LIST_XO(elT*, liT, decl)
98
99#define WX_DECLARE_LIST_XO(elT, liT, decl) \
100 decl liT : public std::list<elT> \
101 { \
102 public: \
103 class dummy; \
104 \
105 struct compatibility_iterator \
106 { \
107 typedef std::list<elT>::iterator iterator; \
108 iterator m_iter; \
109 liT * m_list; \
110 public: \
111 operator bool() const \
112 { return m_list && m_iter != m_list->end(); } \
113 bool operator !() const \
114 { return !m_list || m_iter == m_list->end(); } \
115 compatibility_iterator( const liT* li, iterator it ) \
116 : m_iter( it ), m_list( (liT*)li ) {} \
117 compatibility_iterator( liT* li, iterator it ) \
118 : m_iter( it ), m_list( li ) {} \
119 compatibility_iterator() : m_list( NULL ) { } \
120 dummy* operator->() { return (dummy*)this; } \
121 const dummy* operator->() const { return (const dummy*)this; } \
728c62b6
MB
122 bool operator==(const compatibility_iterator& it) \
123 { return m_list == it.m_list && m_iter == it.m_iter; } \
124 bool operator!=(const compatibility_iterator& it) \
125 { return m_list != it.m_list || m_iter != it.m_iter; } \
df5168c4
MB
126 }; \
127 typedef struct compatibility_iterator citer; \
128 \
129 class dummy \
130 { \
131 typedef std::list<elT>::iterator it; \
132 typedef compatibility_iterator citer; \
133 public: \
134 elT GetData() const \
135 { \
136 citer* i = (citer*)this; \
137 return *(i->m_iter); \
138 } \
139 citer GetNext() const \
140 { \
141 citer* i = (citer*)this; \
142 it lit = i->m_iter; \
143 return citer( i->m_list, ++lit ); \
144 } \
145 citer GetPrevious() const \
146 { \
147 citer* i = (citer*)this; \
148 it lit = i->m_iter; \
728c62b6 149 return citer( i->m_list, --lit ); \
df5168c4
MB
150 } \
151 void SetData( elT e ) \
152 { \
153 citer* i = (citer*)this; \
154 *(i->m_iter) = e; \
155 } \
156 private: \
157 dummy(); \
158 }; \
159 protected: \
22d080f3 160 iterator find( const elT e ) \
df5168c4
MB
161 { \
162 iterator it, en; \
163 for( it = begin(), en = end(); it != en; ++it ) \
164 if( *it == e ) \
165 return it; \
166 return it; \
167 } \
168 public: \
eeb9e3d0 169 liT() {} \
df5168c4
MB
170 \
171 citer Append( elT e ) { push_back( e ); return GetLast(); } \
172 void Clear() { clear(); } \
173 size_t GetCount() const { return size(); } \
174 citer GetFirst() const { return citer( this, ((liT*)this)->begin() ); } \
175 citer GetLast() const { return citer( this, --(((liT*)this)->end()) ); } \
176 bool IsEmpty() const { return empty(); } \
177 bool DeleteObject( elT e ) \
178 { \
179 iterator it = find( e ); \
180 if( it != end() ) \
181 { \
182 erase( it ); \
183 return true; \
184 } \
185 return false; \
186 } \
187 void Erase( const compatibility_iterator& it ) \
188 { \
189 erase( it.m_iter ); \
190 } \
22d080f3 191 citer Find( const elT e ) const { return citer( this, ((liT*)this)->find( e ) ); } \
df5168c4
MB
192 citer Member( elT e ) const { return Find( e ); } \
193 citer Insert( elT e ) \
194 { push_front( e ); return citer( this, begin() ); } \
195 citer Insert( size_t idx, elT e ) \
196 { return Insert( Item( idx ), e ); } \
197 citer Insert( citer idx, elT e ) \
198 { return citer( this, insert( idx.m_iter, e ) ); } \
199 citer Item( size_t idx ) const \
200 { \
201 iterator it; \
202 for( it = ((liT*)this)->begin(); idx; --idx ) \
203 ++it; \
204 return citer( this, it ); \
205 } \
206 int IndexOf( elT e ) const \
207 { \
208 const_iterator it, en; \
209 int idx; \
210 for( idx = 0, it = begin(), en = end(); it != en; ++it, ++idx ) \
211 if( *it == e ) \
212 return idx; \
213 return wxNOT_FOUND; \
214 } \
215 }
216
217#define WX_DECLARE_LIST(elementtype, listname) \
f794be6a 218 WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class)
6de44038
VZ
219#define WX_DECLARE_LIST_PTR(elementtype, listname) \
220 WX_DECLARE_LIST(elementtype, listname)
df5168c4
MB
221
222#define WX_DECLARE_EXPORTED_LIST(elementtype, listname) \
f794be6a 223 WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLEXPORT)
6de44038
VZ
224#define WX_DECLARE_EXPORTED_LIST_PTR(elementtype, listname) \
225 WX_DECLARE_EXPORTED_LIST(elementtype, listname)
df5168c4
MB
226
227#define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo) \
f794be6a 228 WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class usergoo)
6de44038
VZ
229#define WX_DECLARE_USER_EXPORTED_LIST_PTR(elementtype, listname, usergoo) \
230 WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo)
df5168c4
MB
231
232// this macro must be inserted in your program after
233// #include <wx/listimpl.cpp>
234#define WX_DEFINE_LIST(name) "don't forget to include listimpl.cpp!"
235
236#define WX_DEFINE_EXPORTED_LIST(name) WX_DEFINE_LIST(name)
237#define WX_DEFINE_USER_EXPORTED_LIST(name) WX_DEFINE_LIST(name)
238
239#else // if !wxUSE_STL
240
241// due to circular header dependencies this function has to be declared here
242// (normally it's found in utils.h which includes itself list.h...)
0bd4d463 243#if WXWIN_COMPATIBILITY_2_4
ff98bd68 244extern WXDLLIMPEXP_BASE wxChar* copystring(const wxChar *s);
0bd4d463 245#endif
df5168c4
MB
246
247class WXDLLEXPORT wxObjectListNode;
248typedef wxObjectListNode wxNode;
249
250// undef it to get rid of old, deprecated functions
251#define wxLIST_COMPATIBILITY
fd3f686c
VZ
252
253// -----------------------------------------------------------------------------
254// key stuff: a list may be optionally keyed on integer or string key
255// -----------------------------------------------------------------------------
256
257union wxListKeyValue
c801d85f 258{
c801d85f 259 long integer;
9d2f3c71 260 wxChar *string;
c801d85f
KB
261};
262
fd3f686c
VZ
263// a struct which may contain both types of keys
264//
265// implementation note: on one hand, this class allows to have only one function
266// for any keyed operation instead of 2 almost equivalent. OTOH, it's needed to
267// resolve ambiguity which we would otherwise have with wxStringList::Find() and
268// wxList::Find(const char *).
bddd7a8d 269class WXDLLIMPEXP_BASE wxListKey
fd3f686c
VZ
270{
271public:
272 // implicit ctors
f2af4afb
GD
273 wxListKey() : m_keyType(wxKEY_NONE)
274 { }
275 wxListKey(long i) : m_keyType(wxKEY_INTEGER)
276 { m_key.integer = i; }
277 wxListKey(const wxChar *s) : m_keyType(wxKEY_STRING)
278 { m_key.string = wxStrdup(s); }
279 wxListKey(const wxString& s) : m_keyType(wxKEY_STRING)
280 { m_key.string = wxStrdup(s.c_str()); }
fd3f686c
VZ
281
282 // accessors
283 wxKeyType GetKeyType() const { return m_keyType; }
9d2f3c71 284 const wxChar *GetString() const
fd3f686c
VZ
285 { wxASSERT( m_keyType == wxKEY_STRING ); return m_key.string; }
286 long GetNumber() const
287 { wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; }
288
6164d85e
JS
289 // comparison
290 // Note: implementation moved to list.cpp to prevent BC++ inline
291 // expansion warning.
292 bool operator==(wxListKeyValue value) const ;
fd3f686c
VZ
293
294 // dtor
295 ~wxListKey()
296 {
297 if ( m_keyType == wxKEY_STRING )
298 free(m_key.string);
299 }
300
301private:
302 wxKeyType m_keyType;
303 wxListKeyValue m_key;
304};
305
306// -----------------------------------------------------------------------------
307// wxNodeBase class is a (base for) node in a double linked list
308// -----------------------------------------------------------------------------
309
bddd7a8d 310WXDLLIMPEXP_DATA_BASE(extern wxListKey) wxDefaultListKey;
2432b92d 311
bddd7a8d 312class WXDLLIMPEXP_BASE wxListBase;
fbfb3fb3 313
bddd7a8d 314class WXDLLIMPEXP_BASE wxNodeBase
fd3f686c
VZ
315{
316friend class wxListBase;
317public:
318 // ctor
319 wxNodeBase(wxListBase *list = (wxListBase *)NULL,
320 wxNodeBase *previous = (wxNodeBase *)NULL,
321 wxNodeBase *next = (wxNodeBase *)NULL,
322 void *data = NULL,
2432b92d 323 const wxListKey& key = wxDefaultListKey);
fd3f686c
VZ
324
325 virtual ~wxNodeBase();
326
f03fc89f 327 // FIXME no check is done that the list is really keyed on strings
9d2f3c71 328 const wxChar *GetKeyString() const { return m_key.string; }
74e34480 329 long GetKeyInteger() const { return m_key.integer; }
fd3f686c 330
4fabb575 331 // Necessary for some existing code
9d2f3c71 332 void SetKeyString(wxChar* s) { m_key.string = s; }
4fabb575
JS
333 void SetKeyInteger(long i) { m_key.integer = i; }
334
fd3f686c 335#ifdef wxLIST_COMPATIBILITY
b1d4dd7a
RL
336 // compatibility methods, use Get* instead.
337 wxDEPRECATED( wxNode *Next() const );
338 wxDEPRECATED( wxNode *Previous() const );
339 wxDEPRECATED( wxObject *Data() const );
fd3f686c
VZ
340#endif // wxLIST_COMPATIBILITY
341
342protected:
343 // all these are going to be "overloaded" in the derived classes
344 wxNodeBase *GetNext() const { return m_next; }
345 wxNodeBase *GetPrevious() const { return m_previous; }
346
347 void *GetData() const { return m_data; }
348 void SetData(void *data) { m_data = data; }
349
3c67202d 350 // get 0-based index of this node within the list or wxNOT_FOUND
77c5eefb
VZ
351 int IndexOf() const;
352
fd3f686c 353 virtual void DeleteData() { }
df5168c4
MB
354public:
355 // for wxList::iterator
356 void** GetDataPtr() const { return &(((wxNodeBase*)this)->m_data); }
fd3f686c
VZ
357private:
358 // optional key stuff
359 wxListKeyValue m_key;
360
361 void *m_data; // user data
362 wxNodeBase *m_next, // next and previous nodes in the list
363 *m_previous;
364
365 wxListBase *m_list; // list we belong to
f2af4afb
GD
366
367 DECLARE_NO_COPY_CLASS(wxNodeBase)
fd3f686c
VZ
368};
369
370// -----------------------------------------------------------------------------
371// a double-linked list class
372// -----------------------------------------------------------------------------
f98bd52a 373
446e5259 374class WXDLLIMPEXP_BASE wxList;
b1d4dd7a 375
bddd7a8d 376class WXDLLIMPEXP_BASE wxListBase : public wxObject
fd3f686c 377{
bddd7a8d 378friend class WXDLLIMPEXP_BASE wxNodeBase; // should be able to call DetachNode()
bcaa23de 379friend class wxHashTableBase; // should be able to call untyped Find()
788722ac
JS
380private:
381 // common part of all ctors
382 void Init(wxKeyType keyType = wxKEY_NONE); // Must be declared before it's used (for VC++ 1.5)
fd3f686c
VZ
383public:
384 // default ctor & dtor
f2af4afb
GD
385 wxListBase(wxKeyType keyType = wxKEY_NONE)
386 { Init(keyType); }
fd3f686c
VZ
387 virtual ~wxListBase();
388
389 // accessors
390 // count of items in the list
391 size_t GetCount() const { return m_count; }
c801d85f 392
b79a8705
VZ
393 // return TRUE if this list is empty
394 bool IsEmpty() const { return m_count == 0; }
395
fd3f686c 396 // operations
e146b8c8 397
fd3f686c 398 // delete all nodes
db9504c5 399 void Clear();
e146b8c8 400
fd3f686c
VZ
401 // instruct it to destroy user data when deleting nodes
402 void DeleteContents(bool destroy) { m_destroy = destroy; }
403
907789a0
RR
404 // query if to delete
405 bool GetDeleteContents() const
406 { return m_destroy; }
e146b8c8 407
907789a0
RR
408 // get the keytype
409 wxKeyType GetKeyType() const
410 { return m_keyType; }
411
412 // set the keytype (required by the serial code)
413 void SetKeyType(wxKeyType keyType)
414 { wxASSERT( m_count==0 ); m_keyType = keyType; }
415
e146b8c8 416#ifdef wxLIST_COMPATIBILITY
b1d4dd7a
RL
417 // compatibility methods from old wxList
418 wxDEPRECATED( int Number() const ); // use GetCount instead.
419 wxDEPRECATED( wxNode *First() const ); // use GetFirst
420 wxDEPRECATED( wxNode *Last() const ); // use GetLast
421 wxDEPRECATED( wxNode *Nth(size_t n) const ); // use Item
422
423 // kludge for typesafe list migration in core classes.
424 wxDEPRECATED( operator wxList&() const );
e146b8c8
VZ
425#endif // wxLIST_COMPATIBILITY
426
fd3f686c 427protected:
a3ef5bf5 428
fd3f686c
VZ
429 // all methods here are "overloaded" in derived classes to provide compile
430 // time type checking
431
432 // create a node for the list of this type
433 virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,
434 void *data,
2432b92d 435 const wxListKey& key = wxDefaultListKey) = 0;
fd3f686c 436
a3ef5bf5
JS
437// Can't access these from derived classes otherwise (bug in Salford C++?)
438#ifdef __SALFORDC__
439public:
440#endif
441
fd3f686c
VZ
442 // ctors
443 // from an array
444 wxListBase(size_t count, void *elements[]);
445 // from a sequence of objects
446 wxListBase(void *object, ... /* terminate with NULL */);
447
a3ef5bf5 448protected:
fd3f686c 449 // copy ctor and assignment operator
6788ecb8 450 wxListBase(const wxListBase& list) : wxObject()
6108b321 451 { Init(); DoCopy(list); }
fd3f686c
VZ
452 wxListBase& operator=(const wxListBase& list)
453 { Clear(); DoCopy(list); return *this; }
454
455 // get list head/tail
456 wxNodeBase *GetFirst() const { return m_nodeFirst; }
457 wxNodeBase *GetLast() const { return m_nodeLast; }
458
459 // by (0-based) index
460 wxNodeBase *Item(size_t index) const;
461
462 // get the list item's data
2b5f62a0
VZ
463 void *operator[](size_t n) const
464 {
465 wxNodeBase *node = Item(n);
466
467 return node ? node->GetData() : (wxNodeBase *)NULL;
468 }
fd3f686c
VZ
469
470 // operations
471 // append to end of list
890f8a7c
RR
472 wxNodeBase *Prepend(void *object)
473 { return (wxNodeBase *)wxListBase::Insert(object); }
474 // append to beginning of list
fd3f686c
VZ
475 wxNodeBase *Append(void *object);
476 // insert a new item at the beginning of the list
a802c3a1 477 wxNodeBase *Insert(void *object) { return Insert( (wxNodeBase*)NULL, object); }
d8996187
VZ
478 // insert a new item at the given position
479 wxNodeBase *Insert(size_t pos, void *object)
480 { return pos == GetCount() ? Append(object)
481 : Insert(Item(pos), object); }
fd3f686c
VZ
482 // insert before given node or at front of list if prev == NULL
483 wxNodeBase *Insert(wxNodeBase *prev, void *object);
484
485 // keyed append
486 wxNodeBase *Append(long key, void *object);
9d2f3c71 487 wxNodeBase *Append(const wxChar *key, void *object);
fd3f686c
VZ
488
489 // removes node from the list but doesn't delete it (returns pointer
490 // to the node or NULL if it wasn't found in the list)
491 wxNodeBase *DetachNode(wxNodeBase *node);
492 // delete element from list, returns FALSE if node not found
493 bool DeleteNode(wxNodeBase *node);
494 // finds object pointer and deletes node (and object if DeleteContents
495 // is on), returns FALSE if object not found
77c5eefb 496 bool DeleteObject(void *object);
fd3f686c
VZ
497
498 // search (all return NULL if item not found)
499 // by data
22d080f3 500 wxNodeBase *Find(const void *object) const;
fd3f686c
VZ
501
502 // by key
503 wxNodeBase *Find(const wxListKey& key) const;
504
3c67202d 505 // get 0-based index of object or wxNOT_FOUND
77c5eefb
VZ
506 int IndexOf( void *object ) const;
507
fd3f686c
VZ
508 // this function allows the sorting of arbitrary lists by giving
509 // a function to compare two list elements. The list is sorted in place.
6164d85e 510 void Sort(const wxSortCompareFunction compfunc);
fd3f686c
VZ
511
512 // functions for iterating over the list
513 void *FirstThat(wxListIterateFunction func);
514 void ForEach(wxListIterateFunction func);
515 void *LastThat(wxListIterateFunction func);
e146b8c8 516
df5168c4
MB
517 // for STL interface, "last" points to one after the last node
518 // of the controlled sequence (NULL for the end of the list)
519 void Reverse();
520 void DeleteNodes(wxNodeBase* first, wxNodeBase* last);
fd3f686c
VZ
521private:
522 // helpers
fd3f686c
VZ
523 // common part of copy ctor and assignment operator
524 void DoCopy(const wxListBase& list);
525 // common part of all Append()s
526 wxNodeBase *AppendCommon(wxNodeBase *node);
527 // free node's data and node itself
528 void DoDeleteNode(wxNodeBase *node);
529
530 size_t m_count; // number of elements in the list
531 bool m_destroy; // destroy user data when deleting list items?
532 wxNodeBase *m_nodeFirst, // pointers to the head and tail of the list
533 *m_nodeLast;
534
535 wxKeyType m_keyType; // type of our keys (may be wxKEY_NONE)
536};
537
538// -----------------------------------------------------------------------------
539// macros for definition of "template" list type
540// -----------------------------------------------------------------------------
541
542// and now some heavy magic...
543
544// declare a list type named 'name' and containing elements of type 'T *'
545// (as a by product of macro expansion you also get wx##name##Node
ce3ed50d 546// wxNode-derived type)
fd3f686c
VZ
547//
548// implementation details:
ce3ed50d 549// 1. We define _WX_LIST_ITEM_TYPE_##name typedef to save in it the item type
fd3f686c
VZ
550// for the list of given type - this allows us to pass only the list name
551// to WX_DEFINE_LIST() even if it needs both the name and the type
552//
ce3ed50d
JS
553// 2. We redefine all non-type-safe wxList functions with type-safe versions
554// which don't take any space (everything is inline), but bring compile
fd3f686c 555// time error checking.
f03fc89f
VZ
556//
557// 3. The macro which is usually used (WX_DECLARE_LIST) is defined in terms of
558// a more generic WX_DECLARE_LIST_2 macro which, in turn, uses the most
559// generic WX_DECLARE_LIST_3 one. The last macro adds a sometimes
560// interesting capability to store polymorphic objects in the list and is
561// particularly useful with, for example, "wxWindow *" list where the
562// wxWindowBase pointers are put into the list, but wxWindow pointers are
563// retrieved from it.
6de44038
VZ
564//
565// 4. final hack is that WX_DECLARE_LIST_3 is defined in terms of
566// WX_DECLARE_LIST_4 to allow defining classes without operator->() as
567// it results in compiler warnings when this operator doesn't make sense
568// (i.e. stored elements are not pointers)
f03fc89f 569
6de44038
VZ
570// common part of WX_DECLARE_LIST_3 and WX_DECLARE_LIST_PTR_3
571#define WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, ptrop) \
ba059d80 572 typedef int (*wxSortFuncFor_##name)(const T **, const T **); \
fd3f686c 573 \
f6bcfd97 574 classexp nodetype : public wxNodeBase \
fd3f686c
VZ
575 { \
576 public: \
577 nodetype(wxListBase *list = (wxListBase *)NULL, \
578 nodetype *previous = (nodetype *)NULL, \
579 nodetype *next = (nodetype *)NULL, \
7f985bd3 580 T *data = (T *)NULL, \
e146b8c8 581 const wxListKey& key = wxDefaultListKey) \
fd3f686c
VZ
582 : wxNodeBase(list, previous, next, data, key) { } \
583 \
584 nodetype *GetNext() const \
585 { return (nodetype *)wxNodeBase::GetNext(); } \
586 nodetype *GetPrevious() const \
587 { return (nodetype *)wxNodeBase::GetPrevious(); } \
588 \
589 T *GetData() const \
590 { return (T *)wxNodeBase::GetData(); } \
591 void SetData(T *data) \
592 { wxNodeBase::SetData(data); } \
593 \
594 virtual void DeleteData(); \
cd989b24
VZ
595 \
596 DECLARE_NO_COPY_CLASS(nodetype) \
fd3f686c
VZ
597 }; \
598 \
f6bcfd97 599 classexp name : public wxListBase \
fd3f686c
VZ
600 { \
601 public: \
e2a3cc0c 602 typedef nodetype Node; \
df5168c4 603 typedef Node* compatibility_iterator; \
e2a3cc0c 604 \
fd3f686c
VZ
605 name(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType) \
606 { } \
607 name(size_t count, T *elements[]) \
608 : wxListBase(count, (void **)elements) { } \
609 \
f6bcfd97 610 name& operator=(const name& list) \
f2af4afb 611 { (void) wxListBase::operator=(list); return *this; } \
f6bcfd97 612 \
fd3f686c
VZ
613 nodetype *GetFirst() const \
614 { return (nodetype *)wxListBase::GetFirst(); } \
615 nodetype *GetLast() const \
616 { return (nodetype *)wxListBase::GetLast(); } \
617 \
618 nodetype *Item(size_t index) const \
619 { return (nodetype *)wxListBase::Item(index); } \
620 \
621 T *operator[](size_t index) const \
622 { \
623 nodetype *node = Item(index); \
7f985bd3 624 return node ? (T*)(node->GetData()) : (T*)NULL; \
fd3f686c
VZ
625 } \
626 \
f03fc89f 627 nodetype *Append(Tbase *object) \
fd3f686c 628 { return (nodetype *)wxListBase::Append(object); } \
f03fc89f 629 nodetype *Insert(Tbase *object) \
a802c3a1 630 { return (nodetype *)Insert((nodetype*)NULL, object); } \
d8996187
VZ
631 nodetype *Insert(size_t pos, Tbase *object) \
632 { return (nodetype *)wxListBase::Insert(pos, object); } \
f03fc89f 633 nodetype *Insert(nodetype *prev, Tbase *object) \
fd3f686c
VZ
634 { return (nodetype *)wxListBase::Insert(prev, object); } \
635 \
636 nodetype *Append(long key, void *object) \
637 { return (nodetype *)wxListBase::Append(key, object); } \
9d2f3c71 638 nodetype *Append(const wxChar *key, void *object) \
fd3f686c
VZ
639 { return (nodetype *)wxListBase::Append(key, object); } \
640 \
641 nodetype *DetachNode(nodetype *node) \
642 { return (nodetype *)wxListBase::DetachNode(node); } \
643 bool DeleteNode(nodetype *node) \
644 { return wxListBase::DeleteNode(node); } \
f03fc89f 645 bool DeleteObject(Tbase *object) \
fd3f686c 646 { return wxListBase::DeleteObject(object); } \
df5168c4
MB
647 void Erase(compatibility_iterator it) \
648 { DeleteNode(it); } \
fd3f686c 649 \
22d080f3 650 nodetype *Find(const Tbase *object) const \
fd3f686c
VZ
651 { return (nodetype *)wxListBase::Find(object); } \
652 \
653 virtual nodetype *Find(const wxListKey& key) const \
654 { return (nodetype *)wxListBase::Find(key); } \
655 \
f03fc89f 656 int IndexOf(Tbase *object) const \
77c5eefb
VZ
657 { return wxListBase::IndexOf(object); } \
658 \
fd3f686c
VZ
659 void Sort(wxSortFuncFor_##name func) \
660 { wxListBase::Sort((wxSortCompareFunction)func); } \
661 \
662 protected: \
ea48aff3 663 virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next, \
fd3f686c 664 void *data, \
e146b8c8 665 const wxListKey& key = wxDefaultListKey) \
fd3f686c
VZ
666 { \
667 return new nodetype(this, \
668 (nodetype *)prev, (nodetype *)next, \
669 (T *)data, key); \
670 } \
df5168c4
MB
671 /* STL interface */ \
672 public: \
673 typedef size_t size_type; \
674 typedef int difference_type; \
675 typedef T* value_type; \
676 typedef Tbase* base_value_type; \
677 typedef value_type& reference; \
678 typedef const value_type& const_reference; \
679 typedef base_value_type& base_reference; \
680 typedef const base_value_type& const_base_reference; \
681 \
682 class iterator \
683 { \
684 typedef name list; \
685 public: \
37589419 686 typedef nodetype Node; \
df5168c4 687 typedef iterator itor; \
37589419
MB
688 typedef T* value_type; \
689 typedef value_type* ptr_type; \
690 typedef value_type& reference; \
df5168c4
MB
691 \
692 Node* m_node; \
693 Node* m_init; \
694 public: \
37589419 695 typedef reference reference_type; \
df5168c4
MB
696 typedef ptr_type pointer_type; \
697 \
698 iterator(Node* node, Node* init) : m_node(node), m_init(init) {}\
699 iterator() : m_node(NULL), m_init(NULL) { } \
700 reference_type operator*() const \
701 { return *(pointer_type)m_node->GetDataPtr(); } \
6de44038 702 ptrop \
df5168c4
MB
703 itor& operator++() { m_node = m_node->GetNext(); return *this; }\
704 itor operator++(int) \
705 { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
706 itor& operator--() \
707 { \
708 m_node = m_node ? m_node->GetPrevious() : m_init; \
709 return *this; \
710 } \
711 itor operator--(int) \
712 { \
713 itor tmp = *this; \
714 m_node = m_node ? m_node->GetPrevious() : m_init; \
715 return tmp; \
716 } \
717 bool operator!=(const itor& it) const \
718 { return it.m_node != m_node; } \
719 bool operator==(const itor& it) const \
720 { return it.m_node == m_node; } \
721 }; \
722 class const_iterator \
723 { \
724 typedef name list; \
725 public: \
37589419
MB
726 typedef nodetype Node; \
727 typedef T* value_type; \
728 typedef const value_type& const_reference; \
df5168c4 729 typedef const_iterator itor; \
37589419 730 typedef value_type* ptr_type; \
df5168c4
MB
731 \
732 Node* m_node; \
733 Node* m_init; \
734 public: \
37589419 735 typedef const_reference reference_type; \
df5168c4
MB
736 typedef const ptr_type pointer_type; \
737 \
738 const_iterator(Node* node, Node* init) \
739 : m_node(node), m_init(init) { } \
740 const_iterator() : m_node(NULL), m_init(NULL) { } \
741 const_iterator(const iterator& it) \
742 : m_node(it.m_node), m_init(it.m_init) { } \
743 reference_type operator*() const \
744 { return *(pointer_type)m_node->GetDataPtr(); } \
6de44038 745 ptrop \
df5168c4
MB
746 itor& operator++() { m_node = m_node->GetNext(); return *this; }\
747 itor operator++(int) \
748 { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
749 itor& operator--() \
750 { \
751 m_node = m_node ? m_node->GetPrevious() : m_init; \
752 return *this; \
753 } \
754 itor operator--(int) \
755 { \
756 itor tmp = *this; \
757 m_node = m_node ? m_node->GetPrevious() : m_init; \
758 return tmp; \
759 } \
760 bool operator!=(const itor& it) const \
761 { return it.m_node != m_node; } \
762 bool operator==(const itor& it) const \
763 { return it.m_node == m_node; } \
764 }; \
765 class reverse_iterator \
766 { \
767 typedef name list; \
768 public: \
37589419
MB
769 typedef nodetype Node; \
770 typedef T* value_type; \
df5168c4 771 typedef reverse_iterator itor; \
37589419
MB
772 typedef value_type* ptr_type; \
773 typedef value_type& reference; \
df5168c4
MB
774 \
775 Node* m_node; \
776 Node* m_init; \
777 public: \
37589419 778 typedef reference reference_type; \
df5168c4
MB
779 typedef ptr_type pointer_type; \
780 \
781 reverse_iterator(Node* node, Node* init) \
782 : m_node(node), m_init(init) { } \
783 reverse_iterator() : m_node(NULL), m_init(NULL) { } \
784 reference_type operator*() const \
785 { return *(pointer_type)m_node->GetDataPtr(); } \
6de44038 786 ptrop \
df5168c4
MB
787 itor& operator++() \
788 { m_node = m_node->GetPrevious(); return *this; } \
789 itor operator++(int) \
790 { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }\
791 itor& operator--() \
792 { m_node = m_node ? m_node->GetNext() : m_init; return *this; } \
793 itor operator--(int) \
794 { \
795 itor tmp = *this; \
796 m_node = m_node ? m_node->GetNext() : m_init; \
797 return tmp; \
798 } \
799 bool operator!=(const itor& it) const \
800 { return it.m_node != m_node; } \
801 bool operator==(const itor& it) const \
802 { return it.m_node == m_node; } \
803 }; \
804 class const_reverse_iterator \
805 { \
806 typedef name list; \
807 public: \
37589419
MB
808 typedef nodetype Node; \
809 typedef T* value_type; \
df5168c4 810 typedef const_reverse_iterator itor; \
37589419
MB
811 typedef value_type* ptr_type; \
812 typedef const value_type& const_reference; \
df5168c4
MB
813 \
814 Node* m_node; \
815 Node* m_init; \
816 public: \
37589419 817 typedef const_reference reference_type; \
df5168c4
MB
818 typedef const ptr_type pointer_type; \
819 \
820 const_reverse_iterator(Node* node, Node* init) \
821 : m_node(node), m_init(init) { } \
822 const_reverse_iterator() : m_node(NULL), m_init(NULL) { } \
823 const_reverse_iterator(const reverse_iterator& it) \
824 : m_node(it.m_node), m_init(it.m_init) { } \
825 reference_type operator*() const \
826 { return *(pointer_type)m_node->GetDataPtr(); } \
6de44038 827 ptrop \
df5168c4
MB
828 itor& operator++() \
829 { m_node = m_node->GetPrevious(); return *this; } \
830 itor operator++(int) \
831 { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }\
832 itor& operator--() \
833 { m_node = m_node ? m_node->GetNext() : m_init; return *this;}\
834 itor operator--(int) \
835 { \
836 itor tmp = *this; \
837 m_node = m_node ? m_node->GetNext() : m_init; \
838 return tmp; \
839 } \
840 bool operator!=(const itor& it) const \
841 { return it.m_node != m_node; } \
842 bool operator==(const itor& it) const \
843 { return it.m_node == m_node; } \
844 }; \
845 \
846 wxEXPLICIT name(size_type n, const_reference v = value_type()) \
847 { assign(n, v); } \
848 name(const_iterator first, const_iterator last) \
849 { assign(first, last); } \
850 iterator begin() { return iterator(GetFirst(), GetLast()); } \
851 const_iterator begin() const \
852 { return const_iterator(GetFirst(), GetLast()); } \
853 iterator end() { return iterator(NULL, GetLast()); } \
854 const_iterator end() const { return const_iterator(NULL, GetLast()); }\
855 reverse_iterator rbegin() \
856 { return reverse_iterator(GetLast(), GetFirst()); } \
857 const_reverse_iterator rbegin() const \
858 { return const_reverse_iterator(GetLast(), GetFirst()); } \
859 reverse_iterator rend() { return reverse_iterator(NULL, GetFirst()); }\
860 const_reverse_iterator rend() const \
861 { return const_reverse_iterator(NULL, GetFirst()); } \
862 void resize(size_type n, value_type v = value_type()) \
863 { \
5751dd32
JS
864 while (n < size()) \
865 pop_back(); \
866 while (n > size()) \
d56cc7b1 867 push_back(v); \
df5168c4
MB
868 } \
869 size_type size() const { return GetCount(); } \
870 size_type max_size() const { return INT_MAX; } \
871 bool empty() const { return IsEmpty(); } \
872 reference front() { return *begin(); } \
873 const_reference front() const { return *begin(); } \
874 reference back() { return *--end(); } \
875 const_reference back() const { return *--end(); } \
876 void push_front(const_reference v = value_type()) \
877 { Insert(GetFirst(), (const_base_reference)v); } \
878 void pop_front() { DeleteNode(GetFirst()); } \
879 void push_back(const_reference v = value_type()) \
880 { Append((const_base_reference)v); } \
881 void pop_back() { DeleteNode(GetLast()); } \
882 void assign(const_iterator first, const_iterator last) \
883 { \
884 clear(); \
885 for(; first != last; ++first) \
886 Append((const_base_reference)*first); \
887 } \
888 void assign(size_type n, const_reference v = value_type()) \
889 { \
890 clear(); \
891 for(size_type i = 0; i < n; ++i) \
892 Append((const_base_reference)v); \
893 } \
894 iterator insert(iterator it, const_reference v = value_type()) \
895 { \
896 Insert(it.m_node, (const_base_reference)v); \
897 return iterator(it.m_node->GetPrevious(), GetLast()); \
898 } \
899 void insert(iterator it, size_type n, const_reference v = value_type())\
900 { \
901 for(size_type i = 0; i < n; ++i) \
902 Insert(it.m_node, (const_base_reference)v); \
903 } \
904 void insert(iterator it, const_iterator first, const_iterator last) \
905 { \
906 for(; first != last; ++first) \
907 Insert(it.m_node, (const_base_reference)*first); \
908 } \
909 iterator erase(iterator it) \
910 { \
911 iterator next = iterator(it.m_node->GetNext(), GetLast()); \
912 DeleteNode(it.m_node); return next; \
913 } \
914 iterator erase(iterator first, iterator last) \
915 { \
916 iterator next = last; ++next; \
917 DeleteNodes(first.m_node, last.m_node); \
918 return next; \
919 } \
920 void clear() { Clear(); } \
921 void splice(iterator it, name& l, iterator first, iterator last) \
922 { insert(it, first, last); l.erase(first, last); } \
923 void splice(iterator it, name& l) \
924 { splice(it, l, l.begin(), l.end() ); } \
925 void splice(iterator it, name& l, iterator first) \
926 { \
927 iterator tmp = first; ++tmp; \
928 if(it == first || it == tmp) return; \
929 insert(it, *first); \
930 l.erase(first); \
931 } \
932 void remove(const_reference v) \
933 { DeleteObject((const_base_reference)v); } \
934 void reverse() \
935 { Reverse(); } \
936 /* void swap(name& l) \
937 { \
938 { size_t t = m_count; m_count = l.m_count; l.m_count = t; } \
939 { bool t = m_destroy; m_destroy = l.m_destroy; l.m_destroy = t; }\
940 { wxNodeBase* t = m_nodeFirst; m_nodeFirst = l.m_nodeFirst; l.m_nodeFirst = t; }\
941 { wxNodeBase* t = m_nodeLast; m_nodeLast = l.m_nodeLast; l.m_nodeLast = t; }\
942 { wxKeyType t = m_keyType; m_keyType = l.m_keyType; l.m_keyType = t; }\
943 } */ \
385bcb35 944 }
fd3f686c 945
6de44038
VZ
946#define WX_LIST_PTROP \
947 pointer_type operator->() const \
948 { return (pointer_type)m_node->GetDataPtr(); }
949#define WX_LIST_PTROP_NONE
950
951#define WX_DECLARE_LIST_3(T, Tbase, name, nodetype, classexp) \
952 WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, WX_LIST_PTROP_NONE)
953#define WX_DECLARE_LIST_PTR_3(T, Tbase, name, nodetype, classexp) \
954 WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, WX_LIST_PTROP)
955
f6bcfd97
BP
956#define WX_DECLARE_LIST_2(elementtype, listname, nodename, classexp) \
957 WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename, classexp)
6de44038
VZ
958#define WX_DECLARE_LIST_PTR_2(elementtype, listname, nodename, classexp) \
959 WX_DECLARE_LIST_PTR_3(elementtype, elementtype, listname, nodename, classexp)
f03fc89f 960
fd3f686c
VZ
961#define WX_DECLARE_LIST(elementtype, listname) \
962 typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
f6bcfd97 963 WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class)
6de44038
VZ
964#define WX_DECLARE_LIST_PTR(elementtype, listname) \
965 typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
966 WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class)
f6bcfd97 967
45c1de35 968#define WX_DECLARE_LIST_WITH_DECL(elementtype, listname, decl) \
f6bcfd97 969 typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
45c1de35
VS
970 WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, decl)
971
972#define WX_DECLARE_EXPORTED_LIST(elementtype, listname) \
973 WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLEXPORT)
974
6de44038
VZ
975#define WX_DECLARE_EXPORTED_LIST_PTR(elementtype, listname) \
976 typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
977 WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class WXDLLEXPORT)
fd3f686c 978
0b9ab0bd
RL
979#define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo) \
980 typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
981 WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class usergoo)
6de44038
VZ
982#define WX_DECLARE_USER_EXPORTED_LIST_PTR(elementtype, listname, usergoo) \
983 typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
984 WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class usergoo)
0b9ab0bd 985
fd3f686c
VZ
986// this macro must be inserted in your program after
987// #include <wx/listimpl.cpp>
988#define WX_DEFINE_LIST(name) "don't forget to include listimpl.cpp!"
989
0b9ab0bd
RL
990#define WX_DEFINE_EXPORTED_LIST(name) WX_DEFINE_LIST(name)
991#define WX_DEFINE_USER_EXPORTED_LIST(name) WX_DEFINE_LIST(name)
992
df5168c4 993#endif // !wxUSE_STL
0b9ab0bd 994
69b9f4cc 995// ============================================================================
fd3f686c 996// now we can define classes 100% compatible with the old ones
69b9f4cc 997// ============================================================================
fd3f686c 998
e146b8c8 999// ----------------------------------------------------------------------------
f03fc89f 1000// commonly used list classes
e146b8c8
VZ
1001// ----------------------------------------------------------------------------
1002
69b9f4cc 1003#if defined(wxLIST_COMPATIBILITY)
fd3f686c 1004
137b7303
VZ
1005// inline compatibility functions
1006
69b9f4cc
MB
1007#if !wxUSE_STL
1008
1009// ----------------------------------------------------------------------------
137b7303 1010// wxNodeBase deprecated methods
69b9f4cc 1011// ----------------------------------------------------------------------------
137b7303
VZ
1012
1013inline wxNode *wxNodeBase::Next() const { return (wxNode *)GetNext(); }
1014inline wxNode *wxNodeBase::Previous() const { return (wxNode *)GetPrevious(); }
1015inline wxObject *wxNodeBase::Data() const { return (wxObject *)GetData(); }
1016
69b9f4cc 1017// ----------------------------------------------------------------------------
137b7303 1018// wxListBase deprecated methods
69b9f4cc 1019// ----------------------------------------------------------------------------
137b7303
VZ
1020
1021inline int wxListBase::Number() const { return (int)GetCount(); }
1022inline wxNode *wxListBase::First() const { return (wxNode *)GetFirst(); }
1023inline wxNode *wxListBase::Last() const { return (wxNode *)GetLast(); }
1024inline wxNode *wxListBase::Nth(size_t n) const { return (wxNode *)Item(n); }
1025inline wxListBase::operator wxList&() const { return *(wxList*)this; }
1026
69b9f4cc 1027#endif
137b7303 1028
b1d4dd7a
RL
1029// define this to make a lot of noise about use of the old wxList classes.
1030//#define wxWARN_COMPAT_LIST_USE
1031
69b9f4cc 1032// ----------------------------------------------------------------------------
fd3f686c 1033// wxList compatibility class: in fact, it's a list of wxObjects
69b9f4cc 1034// ----------------------------------------------------------------------------
6de44038
VZ
1035
1036WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode,
1037 class WXDLLIMPEXP_BASE);
fd3f686c 1038
bddd7a8d 1039class WXDLLIMPEXP_BASE wxList : public wxObjectList
c801d85f 1040{
fd3f686c 1041public:
df5168c4 1042#if defined(wxWARN_COMPAT_LIST_USE) && !wxUSE_STL
728c62b6
MB
1043 wxList() { };
1044 wxDEPRECATED( wxList(int key_type) );
df5168c4 1045#elif !wxUSE_STL
b1d4dd7a
RL
1046 wxList(int key_type = wxKEY_NONE);
1047#endif
1048
799ea011 1049 // this destructor is required for Darwin
f11bdd03 1050 ~wxList() { }
fd3f686c 1051
df5168c4 1052#if !wxUSE_STL
f6bcfd97 1053 wxList& operator=(const wxList& list)
f2af4afb 1054 { (void) wxListBase::operator=(list); return *this; }
f6bcfd97 1055
fd3f686c 1056 // compatibility methods
3bef6c4c 1057 void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }
df5168c4 1058#endif
3bef6c4c 1059
df5168c4
MB
1060#if wxUSE_STL
1061#else
fd3f686c 1062 wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }
df5168c4 1063#endif
f98bd52a
VZ
1064
1065private:
df5168c4 1066#if !wxUSE_STL
f98bd52a 1067 DECLARE_DYNAMIC_CLASS(wxList)
df5168c4 1068#endif
c801d85f
KB
1069};
1070
df5168c4
MB
1071#if !wxUSE_STL
1072
fd3f686c
VZ
1073// -----------------------------------------------------------------------------
1074// wxStringList class for compatibility with the old code
1075// -----------------------------------------------------------------------------
bddd7a8d 1076WX_DECLARE_LIST_2(wxChar, wxStringListBase, wxStringListNode, class WXDLLIMPEXP_BASE);
fd3f686c 1077
bddd7a8d 1078class WXDLLIMPEXP_BASE wxStringList : public wxStringListBase
c801d85f 1079{
fd3f686c
VZ
1080public:
1081 // ctors and such
1082 // default
b1d4dd7a 1083#ifdef wxWARN_COMPAT_LIST_USE
728c62b6 1084 wxStringList();
b1d4dd7a
RL
1085 wxDEPRECATED( wxStringList(const wxChar *first ...) );
1086#else
1087 wxStringList();
9d2f3c71 1088 wxStringList(const wxChar *first ...);
b1d4dd7a 1089#endif
fd3f686c 1090
db9504c5
VZ
1091 // copying the string list: the strings are copied, too (extremely
1092 // inefficient!)
6788ecb8 1093 wxStringList(const wxStringList& other) : wxStringListBase() { DeleteContents(TRUE); DoCopy(other); }
db9504c5
VZ
1094 wxStringList& operator=(const wxStringList& other)
1095 { Clear(); DoCopy(other); return *this; }
1096
fd3f686c
VZ
1097 // operations
1098 // makes a copy of the string
f526f752 1099 wxNode *Add(const wxChar *s);
890f8a7c
RR
1100
1101 // Append to beginning of list
f526f752 1102 wxNode *Prepend(const wxChar *s);
fd3f686c 1103
9d2f3c71 1104 bool Delete(const wxChar *s);
fd3f686c 1105
9d2f3c71
OK
1106 wxChar **ListToArray(bool new_copies = FALSE) const;
1107 bool Member(const wxChar *s) const;
fd3f686c
VZ
1108
1109 // alphabetic sort
1110 void Sort();
1111
db9504c5
VZ
1112private:
1113 void DoCopy(const wxStringList&); // common part of copy ctor and operator=
f98bd52a
VZ
1114
1115 DECLARE_DYNAMIC_CLASS(wxStringList)
c801d85f
KB
1116};
1117
df5168c4
MB
1118#else // if wxUSE_STL
1119
1120WX_DECLARE_LIST_XO(wxString, wxStringListBase, class WXDLLEXPORT);
1121
1122class WXDLLEXPORT wxStringList : public wxStringListBase
1123{
1124public:
fd82f4e6
MB
1125 compatibility_iterator Append(wxChar* s)
1126 { wxString tmp = s; delete[] s; return wxStringListBase::Append(tmp); }
1127 compatibility_iterator Insert(wxChar* s)
1128 { wxString tmp = s; delete[] s; return wxStringListBase::Insert(tmp); }
1129 compatibility_iterator Insert(size_t pos, wxChar* s)
1130 {
1131 wxString tmp = s;
1132 delete[] s;
1133 return wxStringListBase::Insert(pos, tmp);
1134 }
1135 compatibility_iterator Add(const wxChar* s)
1136 { push_back(s); return GetLast(); }
1137 compatibility_iterator Prepend(const wxChar* s)
1138 { push_front(s); return GetFirst(); }
df5168c4
MB
1139};
1140
1141#endif // wxUSE_STL
1142
fd3f686c
VZ
1143#endif // wxLIST_COMPATIBILITY
1144
df5168c4
MB
1145// delete all list elements
1146//
1147// NB: the class declaration of the list elements must be visible from the
1148// place where you use this macro, otherwise the proper destructor may not
1149// be called (a decent compiler should give a warning about it, but don't
1150// count on it)!
1151#define WX_CLEAR_LIST(type, list) \
1152 { \
1153 type::iterator it, en; \
1154 for( it = (list).begin(), en = (list).end(); it != en; ++it ) \
1155 delete *it; \
1156 (list).clear(); \
1157 }
1158
c801d85f 1159#endif
34138703 1160 // _WX_LISTH__