oops, missing semi colon added

[wxWidgets.git] / include / wx / list.h

diff --git a/include/wx/list.h b/include/wx/list.h
index a65bb8d4856224fa2764a264521d1648303fdc71..283c4586be01b985fb50862a8f0a61f06c56bb15 100644 (file)
--- a/include/wx/list.h
+++ b/include/wx/list.h
@@ -6,7 +6,7 @@
 // Created:     29/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Julian Smart
 // Created:     29/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Julian Smart

-// Licence:       wxWindows license
+// Licence:     wxWindows license

 /////////////////////////////////////////////////////////////////////////////
 
 /*
 /////////////////////////////////////////////////////////////////////////////
 
 /*


@@ -34,13 +34,12 @@
 // -----------------------------------------------------------------------------
 
 #include "wx/defs.h"
 // -----------------------------------------------------------------------------
 
 #include "wx/defs.h"

-#include "wx/debug.h"

 #include "wx/object.h"
 #include "wx/string.h"
 
 // due to circular header dependencies this function has to be declared here
 // (normally it's found in utils.h which includes itself list.h...)
 #include "wx/object.h"
 #include "wx/string.h"
 
 // due to circular header dependencies this function has to be declared here
 // (normally it's found in utils.h which includes itself list.h...)

-extern WXDLLEXPORT char* copystring(const char *s);
+extern WXDLLEXPORT wxChar* copystring(const wxChar *s);

 
 class WXDLLEXPORT wxObjectListNode;
 typedef wxObjectListNode wxNode;
 
 class WXDLLEXPORT wxObjectListNode;
 typedef wxObjectListNode wxNode;


@@ -65,10 +64,10 @@ enum wxKeyType
 // type of compare function for list sort operation (as in 'qsort'): it should
 // return a negative value, 0 or positive value if the first element is less
 // than, equal or greater than the second
 // type of compare function for list sort operation (as in 'qsort'): it should
 // return a negative value, 0 or positive value if the first element is less
 // than, equal or greater than the second

-typedef int (*wxSortCompareFunction)(const void *elem1, const void *elem2);
+typedef int (* LINKAGEMODE wxSortCompareFunction)(const void *elem1, const void *elem2);

 
 //
 
 //

-typedef int (*wxListIterateFunction)(void *current);
+typedef int (* LINKAGEMODE wxListIterateFunction)(void *current);

 
 // -----------------------------------------------------------------------------
 // key stuff: a list may be optionally keyed on integer or string key
 
 // -----------------------------------------------------------------------------
 // key stuff: a list may be optionally keyed on integer or string key


@@ -77,7 +76,7 @@ typedef int (*wxListIterateFunction)(void *current);
 union wxListKeyValue
 {
     long integer;
 union wxListKeyValue
 {
     long integer;

-    char *string;
+    wxChar *string;

 };
 
 // a struct which may contain both types of keys
 };
 
 // a struct which may contain both types of keys


@@ -94,14 +93,14 @@ public:
         { m_keyType = wxKEY_NONE; }
     wxListKey(long i)
         { m_keyType = wxKEY_INTEGER; m_key.integer = i; }
         { m_keyType = wxKEY_NONE; }
     wxListKey(long i)
         { m_keyType = wxKEY_INTEGER; m_key.integer = i; }

-    wxListKey(const char *s)
-        { m_keyType = wxKEY_STRING; m_key.string = strdup(s); }
+    wxListKey(const wxChar *s)
+        { m_keyType = wxKEY_STRING; m_key.string = wxStrdup(s); }

     wxListKey(const wxString& s)
     wxListKey(const wxString& s)

-        { m_keyType = wxKEY_STRING; m_key.string = strdup(s.c_str()); }
+        { m_keyType = wxKEY_STRING; m_key.string = wxStrdup(s.c_str()); }

 
     // accessors
     wxKeyType GetKeyType() const { return m_keyType; }
 
     // accessors
     wxKeyType GetKeyType() const { return m_keyType; }

-    const char *GetString() const
+    const wxChar *GetString() const

         { wxASSERT( m_keyType == wxKEY_STRING ); return m_key.string; }
     long GetNumber() const
         { wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; }
         { wxASSERT( m_keyType == wxKEY_STRING ); return m_key.string; }
     long GetNumber() const
         { wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; }


@@ -127,6 +126,8 @@ private:
 // wxNodeBase class is a (base for) node in a double linked list
 // -----------------------------------------------------------------------------
 
 // wxNodeBase class is a (base for) node in a double linked list
 // -----------------------------------------------------------------------------
 

+WXDLLEXPORT_DATA(extern wxListKey) wxDefaultListKey;
+

 class WXDLLEXPORT wxNodeBase
 {
 friend class wxListBase;
 class WXDLLEXPORT wxNodeBase
 {
 friend class wxListBase;


@@ -136,16 +137,16 @@ public:
                wxNodeBase *previous = (wxNodeBase *)NULL,
                wxNodeBase *next = (wxNodeBase *)NULL,
                void *data = NULL,
                wxNodeBase *previous = (wxNodeBase *)NULL,
                wxNodeBase *next = (wxNodeBase *)NULL,
                void *data = NULL,

-               const wxListKey& key = wxListKey());
+               const wxListKey& key = wxDefaultListKey);

 
     virtual ~wxNodeBase();
 
 
     virtual ~wxNodeBase();
 

-    // @@ no check is done that the list is really keyed on strings
-    const char *GetKeyString() const { return m_key.string; }
+    // FIXME no check is done that the list is really keyed on strings
+    const wxChar *GetKeyString() const { return m_key.string; }

     long GetKeyInteger() const { return m_key.integer; }
 
     // Necessary for some existing code
     long GetKeyInteger() const { return m_key.integer; }
 
     // Necessary for some existing code

-    void SetKeyString(char* s) { m_key.string = s; }
+    void SetKeyString(wxChar* s) { m_key.string = s; }

     void SetKeyInteger(long i) { m_key.integer = i; }
 
 #ifdef wxLIST_COMPATIBILITY
     void SetKeyInteger(long i) { m_key.integer = i; }
 
 #ifdef wxLIST_COMPATIBILITY


@@ -163,7 +164,7 @@ protected:
     void *GetData() const { return m_data; }
     void SetData(void *data) { m_data = data; }
 
     void *GetData() const { return m_data; }
     void SetData(void *data) { m_data = data; }
 

-    // get 0-based index of this node within the list or NOT_FOUND
+    // get 0-based index of this node within the list or wxNOT_FOUND

     int IndexOf() const;
 
     virtual void DeleteData() { }
     int IndexOf() const;
 
     virtual void DeleteData() { }


@@ -184,7 +185,11 @@ private:
 // -----------------------------------------------------------------------------
 class WXDLLEXPORT wxListBase : public wxObject
 {
 // -----------------------------------------------------------------------------
 class WXDLLEXPORT wxListBase : public wxObject
 {

-friend class wxNodeBase; // should be able to call DetachNode()
+friend class wxNodeBase;        // should be able to call DetachNode()
+friend class wxHashTableBase;   // should be able to call untyped Find()
+private:
+        // common part of all ctors
+    void Init(wxKeyType keyType = wxKEY_NONE); // Must be declared before it's used (for VC++ 1.5)

 public:
     // default ctor & dtor
     wxListBase(wxKeyType keyType = wxKEY_NONE) { Init(keyType); }
 public:
     // default ctor & dtor
     wxListBase(wxKeyType keyType = wxKEY_NONE) { Init(keyType); }


@@ -195,17 +200,17 @@ public:
     size_t GetCount() const { return m_count; }
 
     // operations
     size_t GetCount() const { return m_count; }
 
     // operations

-    
+

         // delete all nodes
     void Clear();
         // delete all nodes
     void Clear();

-    
+

         // instruct it to destroy user data when deleting nodes
     void DeleteContents(bool destroy) { m_destroy = destroy; }
 
        // query if to delete
     bool GetDeleteContents() const
         { return m_destroy; }
         // instruct it to destroy user data when deleting nodes
     void DeleteContents(bool destroy) { m_destroy = destroy; }
 
        // query if to delete
     bool GetDeleteContents() const
         { return m_destroy; }

-    
+

       // get the keytype
     wxKeyType GetKeyType() const
         { return m_keyType; }
       // get the keytype
     wxKeyType GetKeyType() const
         { return m_keyType; }


@@ -214,14 +219,27 @@ public:
     void SetKeyType(wxKeyType keyType)
         { wxASSERT( m_count==0 ); m_keyType = keyType; }
 
     void SetKeyType(wxKeyType keyType)
         { wxASSERT( m_count==0 ); m_keyType = keyType; }
 

+#ifdef wxLIST_COMPATIBILITY
+    int Number() const { return GetCount(); }
+    wxNode *First() const { return (wxNode *)GetFirst(); }
+    wxNode *Last() const { return (wxNode *)GetLast(); }
+    wxNode *Nth(size_t index) const { return (wxNode *)Item(index); }
+#endif // wxLIST_COMPATIBILITY
+

 protected:
 protected:

+

     // all methods here are "overloaded" in derived classes to provide compile
     // time type checking
 
     // create a node for the list of this type
     virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,
                                    void *data,
     // all methods here are "overloaded" in derived classes to provide compile
     // time type checking
 
     // create a node for the list of this type
     virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,
                                    void *data,

-                                   const wxListKey& key = wxListKey()) = 0;
+                                   const wxListKey& key = wxDefaultListKey) = 0;
+
+// Can't access these from derived classes otherwise (bug in Salford C++?)
+#ifdef __SALFORDC__
+public:
+#endif

 
     // ctors
         // from an array
 
     // ctors
         // from an array


@@ -229,9 +247,10 @@ protected:
         // from a sequence of objects
     wxListBase(void *object, ... /* terminate with NULL */);
 
         // from a sequence of objects
     wxListBase(void *object, ... /* terminate with NULL */);
 

+protected:

         // copy ctor and assignment operator
     wxListBase(const wxListBase& list)
         // copy ctor and assignment operator
     wxListBase(const wxListBase& list)

-        { DoCopy(list); }
+        { Init(); DoCopy(list); }

     wxListBase& operator=(const wxListBase& list)
         { Clear(); DoCopy(list); return *this; }
 
     wxListBase& operator=(const wxListBase& list)
         { Clear(); DoCopy(list); return *this; }
 


@@ -251,12 +270,16 @@ protected:
     wxNodeBase *Append(void *object);
         // insert a new item at the beginning of the list
     wxNodeBase *Insert(void *object) { return Insert( (wxNodeBase*)NULL, object); }
     wxNodeBase *Append(void *object);
         // insert a new item at the beginning of the list
     wxNodeBase *Insert(void *object) { return Insert( (wxNodeBase*)NULL, object); }

+        // insert a new item at the given position
+    wxNodeBase *Insert(size_t pos, void *object)
+        { return pos == GetCount() ? Append(object)
+                                   : Insert(Item(pos), object); }

         // insert before given node or at front of list if prev == NULL
     wxNodeBase *Insert(wxNodeBase *prev, void *object);
 
         // keyed append
     wxNodeBase *Append(long key, void *object);
         // insert before given node or at front of list if prev == NULL
     wxNodeBase *Insert(wxNodeBase *prev, void *object);
 
         // keyed append
     wxNodeBase *Append(long key, void *object);

-    wxNodeBase *Append(const char *key, void *object);
+    wxNodeBase *Append(const wxChar *key, void *object);

 
         // removes node from the list but doesn't delete it (returns pointer
         // to the node or NULL if it wasn't found in the list)
 
         // removes node from the list but doesn't delete it (returns pointer
         // to the node or NULL if it wasn't found in the list)


@@ -274,7 +297,7 @@ protected:
         // by key
     wxNodeBase *Find(const wxListKey& key) const;
 
         // by key
     wxNodeBase *Find(const wxListKey& key) const;
 

-    // get 0-based index of object or NOT_FOUND
+    // get 0-based index of object or wxNOT_FOUND

     int IndexOf( void *object ) const;
 
     // this function allows the sorting of arbitrary lists by giving
     int IndexOf( void *object ) const;
 
     // this function allows the sorting of arbitrary lists by giving


@@ -285,11 +308,9 @@ protected:
     void *FirstThat(wxListIterateFunction func);
     void ForEach(wxListIterateFunction func);
     void *LastThat(wxListIterateFunction func);
     void *FirstThat(wxListIterateFunction func);
     void ForEach(wxListIterateFunction func);
     void *LastThat(wxListIterateFunction func);

-    
+

 private:
     // helpers
 private:
     // helpers

-        // common part of all ctors
-    void Init(wxKeyType keyType);

         // common part of copy ctor and assignment operator
     void DoCopy(const wxListBase& list);
         // common part of all Append()s
         // common part of copy ctor and assignment operator
     void DoCopy(const wxListBase& list);
         // common part of all Append()s


@@ -313,28 +334,36 @@ private:
 
 // declare a list type named 'name' and containing elements of type 'T *'
 // (as a by product of macro expansion you also get wx##name##Node
 
 // declare a list type named 'name' and containing elements of type 'T *'
 // (as a by product of macro expansion you also get wx##name##Node

-// wxNode-dervied type)
+// wxNode-derived type)

 //
 // implementation details:
 //
 // implementation details:

-//  1. we define _WX_LIST_ITEM_TYPE_##name typedef to save in it the item type
+//  1. We define _WX_LIST_ITEM_TYPE_##name typedef to save in it the item type

 //     for the list of given type - this allows us to pass only the list name
 //     to WX_DEFINE_LIST() even if it needs both the name and the type
 //
 //     for the list of given type - this allows us to pass only the list name
 //     to WX_DEFINE_LIST() even if it needs both the name and the type
 //

-//  2. We redefine all not type-safe wxList functions withtype-safe versions
-//     which don't take any place (everything is inline), but bring compile
+//  2. We redefine all non-type-safe wxList functions with type-safe versions
+//     which don't take any space (everything is inline), but bring compile

 //     time error checking.
 //     time error checking.

-
-#define WX_DECLARE_LIST_2(T, name, nodetype)                                \
-    typedef int (*wxSortFuncFor_##name)(const T *, const T *);              \
+//
+//  3. The macro which is usually used (WX_DECLARE_LIST) is defined in terms of
+//     a more generic WX_DECLARE_LIST_2 macro which, in turn, uses the most
+//     generic WX_DECLARE_LIST_3 one. The last macro adds a sometimes
+//     interesting capability to store polymorphic objects in the list and is
+//     particularly useful with, for example, "wxWindow *" list where the
+//     wxWindowBase pointers are put into the list, but wxWindow pointers are
+//     retrieved from it.
+
+#define WX_DECLARE_LIST_3(T, Tbase, name, nodetype, classexp)               \
+    typedef int (*wxSortFuncFor_##name)(const T **, const T **);            \

                                                                             \
                                                                             \

-    class WXDLLEXPORT nodetype : public wxNodeBase                          \
+    classexp nodetype : public wxNodeBase                                   \

     {                                                                       \
     public:                                                                 \
         nodetype(wxListBase *list = (wxListBase *)NULL,                     \
                  nodetype *previous = (nodetype *)NULL,                     \
                  nodetype *next = (nodetype *)NULL,                         \
                  T *data = (T *)NULL,                                       \
     {                                                                       \
     public:                                                                 \
         nodetype(wxListBase *list = (wxListBase *)NULL,                     \
                  nodetype *previous = (nodetype *)NULL,                     \
                  nodetype *next = (nodetype *)NULL,                         \
                  T *data = (T *)NULL,                                       \

-                 const wxListKey& key = wxListKey())                        \
+                 const wxListKey& key = wxDefaultListKey)                   \

             : wxNodeBase(list, previous, next, data, key) { }               \
                                                                             \
         nodetype *GetNext() const                                           \
             : wxNodeBase(list, previous, next, data, key) { }               \
                                                                             \
         nodetype *GetNext() const                                           \


@@ -350,14 +379,19 @@ private:
         virtual void DeleteData();                                          \
     };                                                                      \
                                                                             \
         virtual void DeleteData();                                          \
     };                                                                      \
                                                                             \

-    class WXDLLEXPORT name : public wxListBase                                          \
+    classexp name : public wxListBase                                       \

     {                                                                       \
     public:                                                                 \
     {                                                                       \
     public:                                                                 \

+        typedef nodetype Node;                                              \
+                                                                            \

         name(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType)          \
             { }                                                             \
         name(size_t count, T *elements[])                                   \
             : wxListBase(count, (void **)elements) { }                      \
                                                                             \
         name(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType)          \
             { }                                                             \
         name(size_t count, T *elements[])                                   \
             : wxListBase(count, (void **)elements) { }                      \
                                                                             \

+        name& operator=(const name& list)                                   \
+            { return (name&)wxListBase::operator=(list); }                  \
+                                                                            \

         nodetype *GetFirst() const                                          \
             { return (nodetype *)wxListBase::GetFirst(); }                  \
         nodetype *GetLast() const                                           \
         nodetype *GetFirst() const                                          \
             { return (nodetype *)wxListBase::GetFirst(); }                  \
         nodetype *GetLast() const                                           \


@@ -372,32 +406,34 @@ private:
             return node ? (T*)(node->GetData()) : (T*)NULL;                 \
         }                                                                   \
                                                                             \
             return node ? (T*)(node->GetData()) : (T*)NULL;                 \
         }                                                                   \
                                                                             \

-        nodetype *Append(T *object)                                         \
+        nodetype *Append(Tbase *object)                                     \

             { return (nodetype *)wxListBase::Append(object); }              \
             { return (nodetype *)wxListBase::Append(object); }              \

-        nodetype *Insert(T *object)                                         \
+        nodetype *Insert(Tbase *object)                                     \

             { return (nodetype *)Insert((nodetype*)NULL, object); }         \
             { return (nodetype *)Insert((nodetype*)NULL, object); }         \

-        nodetype *Insert(nodetype *prev, T *object)                         \
+        nodetype *Insert(size_t pos, Tbase *object)                         \
+            { return (nodetype *)wxListBase::Insert(pos, object); }         \
+        nodetype *Insert(nodetype *prev, Tbase *object)                     \

             { return (nodetype *)wxListBase::Insert(prev, object); }        \
                                                                             \
         nodetype *Append(long key, void *object)                            \
             { return (nodetype *)wxListBase::Append(key, object); }         \
             { return (nodetype *)wxListBase::Insert(prev, object); }        \
                                                                             \
         nodetype *Append(long key, void *object)                            \
             { return (nodetype *)wxListBase::Append(key, object); }         \

-        nodetype *Append(const char *key, void *object)                     \
+        nodetype *Append(const wxChar *key, void *object)                   \

             { return (nodetype *)wxListBase::Append(key, object); }         \
                                                                             \
         nodetype *DetachNode(nodetype *node)                                \
             { return (nodetype *)wxListBase::DetachNode(node); }            \
         bool DeleteNode(nodetype *node)                                     \
             { return wxListBase::DeleteNode(node); }                        \
             { return (nodetype *)wxListBase::Append(key, object); }         \
                                                                             \
         nodetype *DetachNode(nodetype *node)                                \
             { return (nodetype *)wxListBase::DetachNode(node); }            \
         bool DeleteNode(nodetype *node)                                     \
             { return wxListBase::DeleteNode(node); }                        \

-        bool DeleteObject(T *object)                                        \
+        bool DeleteObject(Tbase *object)                                    \

             { return wxListBase::DeleteObject(object); }                    \
                                                                             \
             { return wxListBase::DeleteObject(object); }                    \
                                                                             \

-        nodetype *Find(T *object) const                                     \
+        nodetype *Find(Tbase *object) const                                 \

             { return (nodetype *)wxListBase::Find(object); }                \
                                                                             \
         virtual nodetype *Find(const wxListKey& key) const                  \
             { return (nodetype *)wxListBase::Find(key); }                   \
                                                                             \
             { return (nodetype *)wxListBase::Find(object); }                \
                                                                             \
         virtual nodetype *Find(const wxListKey& key) const                  \
             { return (nodetype *)wxListBase::Find(key); }                   \
                                                                             \

-        int IndexOf( T *object ) const                                      \
+        int IndexOf(Tbase *object) const                                    \

             { return wxListBase::IndexOf(object); }                         \
                                                                             \
         void Sort(wxSortFuncFor_##name func)                                \
             { return wxListBase::IndexOf(object); }                         \
                                                                             \
         void Sort(wxSortFuncFor_##name func)                                \


@@ -406,7 +442,7 @@ private:
     protected:                                                              \
         wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,          \
                                void *data,                                  \
     protected:                                                              \
         wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,          \
                                void *data,                                  \

-                               const wxListKey& key = wxListKey())          \
+                               const wxListKey& key = wxDefaultListKey)     \

             {                                                               \
                 return new nodetype(this,                                   \
                                     (nodetype *)prev, (nodetype *)next,     \
             {                                                               \
                 return new nodetype(this,                                   \
                                     (nodetype *)prev, (nodetype *)next,     \


@@ -414,39 +450,51 @@ private:
             }                                                               \
     }
 
             }                                                               \
     }
 

+#define WX_DECLARE_LIST_2(elementtype, listname, nodename, classexp)        \
+    WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename, classexp)
+

 #define WX_DECLARE_LIST(elementtype, listname)                              \
     typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
 #define WX_DECLARE_LIST(elementtype, listname)                              \
     typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \

-    WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node)
+    WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class)
+
+#define WX_DECLARE_EXPORTED_LIST(elementtype, listname)                     \
+    typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
+    WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class WXDLLEXPORT)

 
 // this macro must be inserted in your program after
 //      #include <wx/listimpl.cpp>
 #define WX_DEFINE_LIST(name)    "don't forget to include listimpl.cpp!"
 
 
 // this macro must be inserted in your program after
 //      #include <wx/listimpl.cpp>
 #define WX_DEFINE_LIST(name)    "don't forget to include listimpl.cpp!"
 

-

 // =============================================================================
 // now we can define classes 100% compatible with the old ones
 // =============================================================================
 
 // =============================================================================
 // now we can define classes 100% compatible with the old ones
 // =============================================================================
 

+// ----------------------------------------------------------------------------
+// commonly used list classes
+// ----------------------------------------------------------------------------
+

 #ifdef wxLIST_COMPATIBILITY
 
 // -----------------------------------------------------------------------------
 // wxList compatibility class: in fact, it's a list of wxObjects
 // -----------------------------------------------------------------------------
 
 #ifdef wxLIST_COMPATIBILITY
 
 // -----------------------------------------------------------------------------
 // wxList compatibility class: in fact, it's a list of wxObjects
 // -----------------------------------------------------------------------------
 

-WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode);
+WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode, class WXDLLEXPORT);

 
 class WXDLLEXPORT wxList : public wxObjectList
 {
 public:
     wxList(int key_type = wxKEY_NONE) : wxObjectList((wxKeyType)key_type) { }
 
 class WXDLLEXPORT wxList : public wxObjectList
 {
 public:
     wxList(int key_type = wxKEY_NONE) : wxObjectList((wxKeyType)key_type) { }

+#ifdef __WXMAC_X__
+   ~wxList() {}   // Added min for Mac X
+#endif
+
+    wxList& operator=(const wxList& list)
+        { return (wxList&)wxListBase::operator=(list); }

 
     // compatibility methods
     void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }
 
 
     // compatibility methods
     void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }
 

-    int Number() const { return GetCount(); }
-    wxNode *First() const { return (wxNode *)GetFirst(); }
-    wxNode *Last() const { return (wxNode *)GetLast(); }
-    wxNode *Nth(size_t index) const { return (wxNode *)Item(index); }

     wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }
 };
 
     wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }
 };
 


@@ -454,7 +502,7 @@ public:
 // wxStringList class for compatibility with the old code
 // -----------------------------------------------------------------------------
 
 // wxStringList class for compatibility with the old code
 // -----------------------------------------------------------------------------
 

-WX_DECLARE_LIST_2(char, wxStringListBase, wxStringListNode);
+WX_DECLARE_LIST_2(wxChar, wxStringListBase, wxStringListNode, class WXDLLEXPORT);

 
 class WXDLLEXPORT wxStringList : public wxStringListBase
 {
 
 class WXDLLEXPORT wxStringList : public wxStringListBase
 {


@@ -462,34 +510,27 @@ public:
     // ctors and such
         // default
     wxStringList() { DeleteContents(TRUE); }
     // ctors and such
         // default
     wxStringList() { DeleteContents(TRUE); }

-    wxStringList(const char *first ...);
+    wxStringList(const wxChar *first ...);

 
         // copying the string list: the strings are copied, too (extremely
         // inefficient!)
 
         // copying the string list: the strings are copied, too (extremely
         // inefficient!)

-    wxStringList(const wxStringList& other) { DoCopy(other); }
+    wxStringList(const wxStringList& other) { DeleteContents(TRUE); DoCopy(other); }

     wxStringList& operator=(const wxStringList& other)
         { Clear(); DoCopy(other); return *this; }
 
     // operations
         // makes a copy of the string
     wxStringList& operator=(const wxStringList& other)
         { Clear(); DoCopy(other); return *this; }
 
     // operations
         // makes a copy of the string

-    wxNode *Add(const char *s)
+    wxNode *Add(const wxChar *s)

         { return (wxNode *)wxStringListBase::Append(copystring(s)); }
 
         { return (wxNode *)wxStringListBase::Append(copystring(s)); }
 

-    void Delete(const char *s)
-        { wxStringListBase::DeleteObject((char *)s); }
+    bool Delete(const wxChar *s);

 
 

-    char **ListToArray(bool new_copies = FALSE) const;
-    bool Member(const char *s) const;
+    wxChar **ListToArray(bool new_copies = FALSE) const;
+    bool Member(const wxChar *s) const;

 
     // alphabetic sort
     void Sort();
 
 
     // alphabetic sort
     void Sort();
 

-    // compatibility methods
-    int Number() const { return GetCount(); }
-    wxNode *First() const { return (wxNode *)GetFirst(); }
-    wxNode *Last() const { return (wxNode *)GetLast(); }
-    wxNode *Nth(size_t index) const { return (wxNode *)Item(index); }
-

 private:
     void DoCopy(const wxStringList&); // common part of copy ctor and operator=
 };
 private:
     void DoCopy(const wxStringList&); // common part of copy ctor and operator=
 };