added template wxScopedArray<> too

[wxWidgets.git] / include / wx / list.h
diff --git a/include/wx/list.h b/include/wx/list.h

index 56c3a674302781a3de8e4297bfb96264241107d7..950156d4f821667159acf276271e95d89d3699e3 100644 (file)
--- a/include/wx/list.h
+++ b/include/wx/list.h
@@ -1,5 +1,5 @@
  /////////////////////////////////////////////////////////////////////////////
  /////////////////////////////////////////////////////////////////////////////
-// Name:        list.h
+// Name:        wx/list.h
  // Purpose:     wxList, wxStringList classes
  // Author:      Julian Smart
  // Modified by: VZ at 16/11/98: WX_DECLARE_LIST() and typesafe lists added
  // Purpose:     wxList, wxStringList classes
  // Author:      Julian Smart
  // Modified by: VZ at 16/11/98: WX_DECLARE_LIST() and typesafe lists added
@@ -22,13 +22,8 @@
    like the old class.
  */
  
    like the old class.
  */
  
-#ifndef _WX_LISTH__
-#define _WX_LISTH__
-
-#if defined(__GNUG__) && !defined(__APPLE__) && \
-    !(defined(__MINGW32__) && __GNUC__ == 3 && __GNUC_MINOR__ == 2)
-#pragma interface "list.h"
-#endif
+#ifndef _WX_LIST_H_
+#define _WX_LIST_H_
  
  // -----------------------------------------------------------------------------
  // headers
  
  // -----------------------------------------------------------------------------
  // headers
@@ -40,185 +35,312 @@
  
  #if wxUSE_STL
      #include "wx/beforestd.h"
  
  #if wxUSE_STL
      #include "wx/beforestd.h"
+    #include <algorithm>
+    #include <iterator>
      #include <list>
      #include "wx/afterstd.h"
      #include <list>
      #include "wx/afterstd.h"
-    #if defined(__WXMSW__) && defined(__MINGW32__)
-        #include "wx/msw/winundef.h"
-    #endif
  #endif
  
  // ----------------------------------------------------------------------------
  // types
  // ----------------------------------------------------------------------------
  
  #endif
  
  // ----------------------------------------------------------------------------
  // types
  // ----------------------------------------------------------------------------
  
-// 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
-extern "C"
-{
-typedef int (* LINKAGEMODE wxSortCompareFunction)(const void *elem1, const void *elem2);
-}
-
-class WXDLLIMPEXP_BASE wxObjectListNode;
+class WXDLLIMPEXP_FWD_BASE wxObjectListNode;
  typedef wxObjectListNode wxNode;
  
  typedef wxObjectListNode wxNode;
  
-//
-typedef int (* LINKAGEMODE wxListIterateFunction)(void *current);
-
-// ----------------------------------------------------------------------------
-// constants
-// ----------------------------------------------------------------------------
-
-#if !defined(wxENUM_KEY_TYPE_DEFINED)
-#define wxENUM_KEY_TYPE_DEFINED
-
-enum wxKeyType
-{
-    wxKEY_NONE,
-    wxKEY_INTEGER,
-    wxKEY_STRING
-};
-
-#endif
-
  #if wxUSE_STL
  
  #define wxLIST_COMPATIBILITY
  
  #define WX_DECLARE_LIST_3(elT, dummy1, liT, dummy2, decl) \
  #if wxUSE_STL
  
  #define wxLIST_COMPATIBILITY
  
  #define WX_DECLARE_LIST_3(elT, dummy1, liT, dummy2, decl) \
-    WX_DECLARE_LIST_X(elT, liT, decl)
+    WX_DECLARE_LIST_WITH_DECL(elT, liT, decl)
+#define WX_DECLARE_LIST_PTR_3(elT, dummy1, liT, dummy2, decl) \
+    WX_DECLARE_LIST_3(elT, dummy1, liT, dummy2, decl)
  
  #define WX_DECLARE_LIST_2(elT, liT, dummy, decl) \
  
  #define WX_DECLARE_LIST_2(elT, liT, dummy, decl) \
-    WX_DECLARE_LIST_X(elT, liT, decl)
+    WX_DECLARE_LIST_WITH_DECL(elT, liT, decl)
+#define WX_DECLARE_LIST_PTR_2(elT, liT, dummy, decl) \
+    WX_DECLARE_LIST_2(elT, liT, dummy, decl) \
  
  
-#define WX_DECLARE_LIST_X(elT, liT, decl) \
+#define WX_DECLARE_LIST_WITH_DECL(elT, liT, decl) \
      WX_DECLARE_LIST_XO(elT*, liT, decl)
  
      WX_DECLARE_LIST_XO(elT*, liT, decl)
  
-#define WX_DECLARE_LIST_XO(elT, liT, decl) \
-    decl liT : public std::list<elT>                                          \
+#if !defined(__VISUALC__) || __VISUALC__ >= 1300 // == !VC6
+
+template<class T>
+class wxList_SortFunction
+{
+public:
+    wxList_SortFunction(wxSortCompareFunction f) : m_f(f) { }
+    bool operator()(const T& i1, const T& i2)
+      { return m_f((T*)&i1, (T*)&i2) < 0; }
+private:
+    wxSortCompareFunction m_f;
+};
+
+#define WX_LIST_SORTFUNCTION( elT, f ) wxList_SortFunction<elT>(f)
+#define WX_LIST_VC6_WORKAROUND(elT, liT, decl)
+
+#else // if defined( __VISUALC__ ) && __VISUALC__ < 1300 // == VC6
+
+#define WX_LIST_SORTFUNCTION( elT, f ) std::greater<elT>( f )
+#define WX_LIST_VC6_WORKAROUND(elT, liT, decl)                                \
+    decl liT;                                                                 \
+                                                                              \
+    /* Workaround for broken VC6 STL incorrectly requires a std::greater<> */ \
+    /* to be passed into std::list::sort() */                                 \
+    template <>                                                               \
+    struct std::greater<elT>                                                  \
      {                                                                         \
      {                                                                         \
+        private:                                                              \
+            wxSortCompareFunction m_CompFunc;                                 \
+        public:                                                               \
+            greater( wxSortCompareFunction compfunc = NULL )                  \
+                : m_CompFunc( compfunc ) {}                                   \
+            bool operator()(const elT X, const elT Y) const                   \
+                {                                                             \
+                    return m_CompFunc ?                                       \
+                        ( m_CompFunc( wxListCastElementToVoidPtr(X),          \
+                                      wxListCastElementToVoidPtr(Y) ) < 0 ) : \
+                        ( X > Y );                                            \
+                }                                                             \
+    };
+
+// helper for std::greater<elT> above:
+template<typename T>
+inline const void *wxListCastElementToVoidPtr(const T* ptr) { return ptr; }
+inline const void *wxListCastElementToVoidPtr(const wxString& str)
+    { return (const char*)str; }
+
+#endif // VC6/!VC6
+
+/*
+    Note 1: the outer helper class _WX_LIST_HELPER_##liT below is a workaround
+    for mingw 3.2.3 compiler bug that prevents a static function of liT class
+    from being exported into dll. A minimal code snippet reproducing the bug:
+
+         struct WXDLLIMPEXP_CORE Foo
+         {
+            static void Bar();
+            struct SomeInnerClass
+            {
+              friend class Foo; // comment this out to make it link
+            };
+            ~Foo()
+            {
+                Bar();
+            }
+         };
+
+    The program does not link under mingw_gcc 3.2.3 producing undefined
+    reference to Foo::Bar() function
+
+
+    Note 2: the EmptyList is needed to allow having a NULL pointer-like
+    invalid iterator. We used to use just an uninitialized iterator object
+    instead but this fails with some debug/checked versions of STL, notably the
+    glibc version activated with _GLIBCXX_DEBUG, so we need to have a separate
+    invalid iterator.
+ */
+
+// the real wxList-class declaration
+#define WX_DECLARE_LIST_XO(elT, liT, decl)                                    \
+    decl _WX_LIST_HELPER_##liT                                                \
+    {                                                                         \
+        typedef elT _WX_LIST_ITEM_TYPE_##liT;                                 \
      public:                                                                   \
      public:                                                                   \
-        class dummy;                                                          \
+        static void DeleteFunction( _WX_LIST_ITEM_TYPE_##liT X );             \
+    };                                                                        \
+                                                                              \
+    WX_LIST_VC6_WORKAROUND(elT, liT, decl)                                    \
+    decl liT : public std::list<elT>                                          \
+    {                                                                         \
+    private:                                                                  \
+        typedef std::list<elT> BaseListType;                                  \
+        static BaseListType EmptyList;                                        \
+                                                                              \
+        bool m_destroy;                                                       \
                                                                                \
                                                                                \
-        struct compatibility_iterator                                         \
+    public:                                                                   \
+        decl compatibility_iterator                                           \
          {                                                                     \
          {                                                                     \
+        private:                                                              \
+            /* Workaround for broken VC6 nested class name resolution */      \
              typedef std::list<elT>::iterator iterator;                        \
              typedef std::list<elT>::iterator iterator;                        \
+            friend class liT;                                                 \
+                                                                              \
              iterator m_iter;                                                  \
              liT * m_list;                                                     \
              iterator m_iter;                                                  \
              liT * m_list;                                                     \
+                                                                              \
          public:                                                               \
          public:                                                               \
+            compatibility_iterator()                                          \
+                : m_iter(EmptyList.end()), m_list( NULL ) {}                  \
+            compatibility_iterator( liT* li, iterator i )                     \
+                : m_iter( i ), m_list( li ) {}                                \
+            compatibility_iterator( const liT* li, iterator i )               \
+                : m_iter( i ), m_list( const_cast< liT* >( li ) ) {}          \
+                                                                              \
+            compatibility_iterator* operator->() { return this; }             \
+            const compatibility_iterator* operator->() const { return this; } \
+                                                                              \
+            bool operator==(const compatibility_iterator& i) const            \
+            {                                                                 \
+                wxASSERT_MSG( m_list && i.m_list,                             \
+                              _T("comparing invalid iterators is illegal") ); \
+                return (m_list == i.m_list) && (m_iter == i.m_iter);          \
+            }                                                                 \
+            bool operator!=(const compatibility_iterator& i) const            \
+                { return !( operator==( i ) ); }                              \
              operator bool() const                                             \
              operator bool() const                                             \
-                { return m_list && m_iter != m_list->end(); }                 \
+                { return m_list ? m_iter != m_list->end() : false; }          \
              bool operator !() const                                           \
              bool operator !() const                                           \
-                { return !m_list || m_iter == m_list->end(); }                \
-            compatibility_iterator( const liT* li, iterator it )              \
-                : m_iter( it ), m_list( (liT*)li ) {}                         \
-            compatibility_iterator( liT* li, iterator it )                    \
-                : m_iter( it ), m_list( li ) {}                               \
-            compatibility_iterator() : m_list( NULL ) { }                     \
-            dummy* operator->() { return (dummy*)this; }                      \
-            const dummy* operator->() const { return (const dummy*)this; }    \
-        };                                                                    \
-        typedef struct compatibility_iterator citer;                          \
+                { return !( operator bool() ); }                              \
                                                                                \
                                                                                \
-        class dummy                                                           \
-        {                                                                     \
-            typedef std::list<elT>::iterator it;                              \
-            typedef compatibility_iterator citer;                             \
-        public:                                                               \
              elT GetData() const                                               \
              elT GetData() const                                               \
+                { return *m_iter; }                                           \
+            void SetData( elT e )                                             \
+                { *m_iter = e; }                                              \
+                                                                              \
+            compatibility_iterator GetNext() const                            \
              {                                                                 \
              {                                                                 \
-                citer* i = (citer*)this;                                      \
-                return *(i->m_iter);                                          \
-            }                                                                 \
-            citer GetNext() const                                             \
-            {                                                                 \
-                citer* i = (citer*)this;                                      \
-                it lit = i->m_iter;                                           \
-                return citer( i->m_list, ++lit );                             \
+                iterator i = m_iter;                                          \
+                return compatibility_iterator( m_list, ++i );                 \
              }                                                                 \
              }                                                                 \
-            citer GetPrevious() const                                         \
+            compatibility_iterator GetPrevious() const                        \
              {                                                                 \
              {                                                                 \
-                citer* i = (citer*)this;                                      \
-                it lit = i->m_iter;                                           \
-                return citer( i->m_list, ++lit );                             \
+                if ( m_iter == m_list->begin() )                              \
+                    return compatibility_iterator();                          \
+                                                                              \
+                iterator i = m_iter;                                          \
+                return compatibility_iterator( m_list, --i );                 \
              }                                                                 \
              }                                                                 \
-            void SetData( elT e )                                             \
+            int IndexOf() const                                               \
              {                                                                 \
              {                                                                 \
-                citer* i = (citer*)this;                                      \
-                *(i->m_iter) = e;                                             \
+                return *this ? std::distance( m_list->begin(), m_iter )       \
+                             : wxNOT_FOUND;                                   \
              }                                                                 \
              }                                                                 \
-        private:                                                              \
-            dummy();                                                          \
          };                                                                    \
          };                                                                    \
-    protected:                                                                \
-        iterator find( elT e )                                                \
+    public:                                                                   \
+        liT() : m_destroy( false ) {}                                         \
+                                                                              \
+        compatibility_iterator Find( const elT e ) const                      \
          {                                                                     \
          {                                                                     \
-            iterator it, en;                                                  \
-            for( it = begin(), en = end(); it != en; ++it )                   \
-                if( *it == e )                                                \
-                    return it;                                                \
-            return it;                                                        \
+          liT* _this = const_cast< liT* >( this );                            \
+          return compatibility_iterator( _this,                               \
+                     std::find( _this->begin(), _this->end(), e ) );          \
          }                                                                     \
          }                                                                     \
-    public:                                                                   \
-        liT() {};                                                             \
                                                                                \
                                                                                \
-        citer Append( elT e ) { push_back( e ); return GetLast(); }           \
-        void Clear() { clear(); }                                             \
-        size_t GetCount() const { return size(); }                            \
-        citer GetFirst() const { return citer( this, ((liT*)this)->begin() ); } \
-        citer GetLast() const { return citer( this, --(((liT*)this)->end()) ); } \
-        bool IsEmpty() const { return empty(); }                              \
-        bool DeleteObject( elT e )                                            \
+        bool IsEmpty() const                                                  \
+            { return empty(); }                                               \
+        size_t GetCount() const                                               \
+            { return size(); }                                                \
+        int Number() const                                                    \
+            { return static_cast< int >( GetCount() ); }                      \
+                                                                              \
+        compatibility_iterator Item( size_t idx ) const                       \
+        {                                                                     \
+            iterator i = const_cast< liT* >(this)->begin();                   \
+            std::advance( i, idx );                                           \
+            return compatibility_iterator( this, i );                         \
+        }                                                                     \
+        elT operator[](size_t idx) const                                      \
+        {                                                                     \
+            return Item(idx).GetData();                                       \
+        }                                                                     \
+                                                                              \
+        compatibility_iterator GetFirst() const                               \
+        {                                                                     \
+            return compatibility_iterator( this,                              \
+                const_cast< liT* >(this)->begin() );                          \
+        }                                                                     \
+        compatibility_iterator GetLast() const                                \
+        {                                                                     \
+            iterator i = const_cast< liT* >(this)->end();                     \
+            return compatibility_iterator( this, !empty() ? --i : i );        \
+        }                                                                     \
+        compatibility_iterator Member( elT e ) const                          \
+            { return Find( e ); }                                             \
+        compatibility_iterator Nth( int n ) const                             \
+            { return Item( n ); }                                             \
+        int IndexOf( elT e ) const                                            \
+            { return Find( e ).IndexOf(); }                                   \
+                                                                              \
+        compatibility_iterator Append( elT e )                                \
+        {                                                                     \
+            push_back( e );                                                   \
+            return GetLast();                                                 \
+        }                                                                     \
+        compatibility_iterator Insert( elT e )                                \
+        {                                                                     \
+            push_front( e );                                                  \
+            return compatibility_iterator( this, begin() );                   \
+        }                                                                     \
+        compatibility_iterator Insert(const compatibility_iterator & i, elT e)\
+        {                                                                     \
+            return compatibility_iterator( this, insert( i.m_iter, e ) );     \
+        }                                                                     \
+        compatibility_iterator Insert( size_t idx, elT e )                    \
+        {                                                                     \
+            return compatibility_iterator( this,                              \
+                                           insert( Item( idx ).m_iter, e ) ); \
+        }                                                                     \
+                                                                              \
+        void DeleteContents( bool destroy )                                   \
+            { m_destroy = destroy; }                                          \
+        bool GetDeleteContents() const                                        \
+            { return m_destroy; }                                             \
+        void Erase( const compatibility_iterator& i )                         \
          {                                                                     \
          {                                                                     \
-            iterator it = find( e );                                          \
-            if( it != end() )                                                 \
+            if ( m_destroy )                                                  \
+                _WX_LIST_HELPER_##liT::DeleteFunction( i->GetData() );        \
+            erase( i.m_iter );                                                \
+        }                                                                     \
+        bool DeleteNode( const compatibility_iterator& i )                    \
+        {                                                                     \
+            if( i )                                                           \
              {                                                                 \
              {                                                                 \
-                erase( it );                                                  \
+                Erase( i );                                                   \
                  return true;                                                  \
              }                                                                 \
              return false;                                                     \
          }                                                                     \
                  return true;                                                  \
              }                                                                 \
              return false;                                                     \
          }                                                                     \
-        void Erase( const compatibility_iterator& it )                        \
-        {                                                                     \
-            erase( it.m_iter );                                               \
-        }                                                                     \
-        citer Find( elT e ) const { return citer( this, ((liT*)this)->find( e ) ); } \
-        citer Member( elT e ) const { return Find( e ); }                     \
-        citer Insert( elT e )                                                 \
-            { push_front( e ); return citer( this, begin() ); }               \
-        citer Insert( size_t idx, elT e )                                     \
-            { return Insert( Item( idx ), e ); }                              \
-        citer Insert( citer idx, elT e )                                      \
-            { return citer( this, insert( idx.m_iter, e ) ); }                \
-        citer Item( size_t idx ) const                                        \
+        bool DeleteObject( elT e )                                            \
          {                                                                     \
          {                                                                     \
-            iterator it;                                                      \
-            for( it = ((liT*)this)->begin(); idx; --idx )                     \
-                ++it;                                                         \
-            return citer( this, it );                                         \
+            return DeleteNode( Find( e ) );                                   \
          }                                                                     \
          }                                                                     \
-        int IndexOf( elT e ) const                                            \
+        void Clear()                                                          \
          {                                                                     \
          {                                                                     \
-            const_iterator it, en;                                            \
-            int idx;                                                          \
-            for( idx = 0, it = begin(), en = end(); it != en; ++it, ++idx )   \
-                if( *it == e )                                                \
-                    return idx;                                               \
-            return wxNOT_FOUND;                                               \
+            if ( m_destroy )                                                  \
+                std::for_each( begin(), end(),                                \
+                               _WX_LIST_HELPER_##liT::DeleteFunction );       \
+            clear();                                                          \
          }                                                                     \
          }                                                                     \
+        /* Workaround for broken VC6 std::list::sort() see above */           \
+        void Sort( wxSortCompareFunction compfunc )                           \
+            { sort( WX_LIST_SORTFUNCTION( elT, compfunc ) ); }                \
+        ~liT() { Clear(); }                                                   \
+                                                                              \
+        /* It needs access to our EmptyList */                                \
+        friend class compatibility_iterator;                                  \
      }
  
  #define WX_DECLARE_LIST(elementtype, listname)                              \
      }
  
  #define WX_DECLARE_LIST(elementtype, listname)                              \
-    WX_DECLARE_LIST_X(elementtype, listname, class)
+    WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class)
+#define WX_DECLARE_LIST_PTR(elementtype, listname)                          \
+    WX_DECLARE_LIST(elementtype, listname)
  
  #define WX_DECLARE_EXPORTED_LIST(elementtype, listname)                     \
  
  #define WX_DECLARE_EXPORTED_LIST(elementtype, listname)                     \
-    WX_DECLARE_LIST_X(elementtype, listname, class WXDLLEXPORT)
+    WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLIMPEXP_CORE)
+#define WX_DECLARE_EXPORTED_LIST_PTR(elementtype, listname)                 \
+    WX_DECLARE_EXPORTED_LIST(elementtype, listname)
  
  #define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo)       \
  
  #define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo)       \
-    WX_DECLARE_LIST_X(elementtype, listname, class usergoo)
+    WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class usergoo)
+#define WX_DECLARE_USER_EXPORTED_LIST_PTR(elementtype, listname, usergoo)   \
+    WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo)
  
  // this macro must be inserted in your program after
  
  // this macro must be inserted in your program after
-//      #include <wx/listimpl.cpp>
+//      #include "wx/listimpl.cpp"
  #define WX_DEFINE_LIST(name)    "don't forget to include listimpl.cpp!"
  
  #define WX_DEFINE_EXPORTED_LIST(name)      WX_DEFINE_LIST(name)
  #define WX_DEFINE_LIST(name)    "don't forget to include listimpl.cpp!"
  
  #define WX_DEFINE_EXPORTED_LIST(name)      WX_DEFINE_LIST(name)
@@ -226,12 +348,6 @@ enum wxKeyType
  
  #else // if !wxUSE_STL
  
  
  #else // if !wxUSE_STL
  
-// 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 wxChar* copystring(const wxChar *s);
-
-class WXDLLEXPORT wxObjectListNode;
-typedef wxObjectListNode wxNode;
  
  // undef it to get rid of old, deprecated functions
  #define wxLIST_COMPATIBILITY
  
  // undef it to get rid of old, deprecated functions
  #define wxLIST_COMPATIBILITY
@@ -243,7 +359,7 @@ typedef wxObjectListNode wxNode;
  union wxListKeyValue
  {
      long integer;
  union wxListKeyValue
  {
      long integer;
-    wxChar *string;
+    wxString *string;
  };
  
  // a struct which may contain both types of keys
  };
  
  // a struct which may contain both types of keys
@@ -260,15 +376,17 @@ public:
          { }
      wxListKey(long i) : m_keyType(wxKEY_INTEGER)
          { m_key.integer = i; }
          { }
      wxListKey(long i) : m_keyType(wxKEY_INTEGER)
          { m_key.integer = i; }
-    wxListKey(const wxChar *s) : m_keyType(wxKEY_STRING)
-        { m_key.string = wxStrdup(s); }
      wxListKey(const wxString& s) : m_keyType(wxKEY_STRING)
      wxListKey(const wxString& s) : m_keyType(wxKEY_STRING)
-        { m_key.string = wxStrdup(s.c_str()); }
+        { m_key.string = new wxString(s); }
+    wxListKey(const char *s) : m_keyType(wxKEY_STRING)
+        { m_key.string = new wxString(s); }
+    wxListKey(const wchar_t *s) : m_keyType(wxKEY_STRING)
+        { m_key.string = new wxString(s); }
  
      // accessors
      wxKeyType GetKeyType() const { return m_keyType; }
  
      // accessors
      wxKeyType GetKeyType() const { return m_keyType; }
-    const wxChar *GetString() const
-        { wxASSERT( m_keyType == wxKEY_STRING ); return m_key.string; }
+    const wxString GetString() const
+        { wxASSERT( m_keyType == wxKEY_STRING ); return *m_key.string; }
      long GetNumber() const
          { wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; }
  
      long GetNumber() const
          { wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; }
  
@@ -281,7 +399,7 @@ public:
      ~wxListKey()
      {
          if ( m_keyType == wxKEY_STRING )
      ~wxListKey()
      {
          if ( m_keyType == wxKEY_STRING )
-            free(m_key.string);
+            delete m_key.string;
      }
  
  private:
      }
  
  private:
@@ -293,29 +411,29 @@ 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
  // -----------------------------------------------------------------------------
  
-WXDLLIMPEXP_DATA_BASE(extern wxListKey) wxDefaultListKey;
+extern WXDLLIMPEXP_DATA_BASE(wxListKey) wxDefaultListKey;
  
  
-class WXDLLIMPEXP_BASE wxListBase;
+class WXDLLIMPEXP_FWD_BASE wxListBase;
  
  class WXDLLIMPEXP_BASE wxNodeBase
  {
  friend class wxListBase;
  public:
      // ctor
  
  class WXDLLIMPEXP_BASE wxNodeBase
  {
  friend class wxListBase;
  public:
      // ctor
-    wxNodeBase(wxListBase *list = (wxListBase *)NULL,
-               wxNodeBase *previous = (wxNodeBase *)NULL,
-               wxNodeBase *next = (wxNodeBase *)NULL,
+    wxNodeBase(wxListBase *list = NULL,
+               wxNodeBase *previous = NULL,
+               wxNodeBase *next = NULL,
                 void *data = NULL,
                 const wxListKey& key = wxDefaultListKey);
  
      virtual ~wxNodeBase();
  
      // FIXME no check is done that the list is really keyed on strings
                 void *data = NULL,
                 const wxListKey& key = wxDefaultListKey);
  
      virtual ~wxNodeBase();
  
      // FIXME no check is done that the list is really keyed on strings
-    const wxChar *GetKeyString() const { return m_key.string; }
+    wxString 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(wxChar* s) { m_key.string = s; }
+    void SetKeyString(const wxString& s) { m_key.string = new wxString(s); }
      void SetKeyInteger(long i) { m_key.integer = i; }
  
  #ifdef wxLIST_COMPATIBILITY
      void SetKeyInteger(long i) { m_key.integer = i; }
  
  #ifdef wxLIST_COMPATIBILITY
@@ -339,7 +457,7 @@ protected:
      virtual void DeleteData() { }
  public:
      // for wxList::iterator
      virtual void DeleteData() { }
  public:
      // for wxList::iterator
-    void** GetDataPtr() const { return &(((wxNodeBase*)this)->m_data); }
+    void** GetDataPtr() const { return &(const_cast<wxNodeBase*>(this)->m_data); }
  private:
      // optional key stuff
      wxListKeyValue m_key;
  private:
      // optional key stuff
      wxListKeyValue m_key;
@@ -357,15 +475,13 @@ private:
  // a double-linked list class
  // -----------------------------------------------------------------------------
  
  // a double-linked list class
  // -----------------------------------------------------------------------------
  
-class wxList;
+class WXDLLIMPEXP_FWD_BASE wxList;
  
  
-class WXDLLIMPEXP_BASE wxListBase : public wxObject
+class WXDLLIMPEXP_BASE wxListBase
  {
  {
-friend class WXDLLIMPEXP_BASE 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()
  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)
  public:
      // default ctor & dtor
      wxListBase(wxKeyType keyType = wxKEY_NONE)
@@ -376,7 +492,7 @@ public:
          // count of items in the list
      size_t GetCount() const { return m_count; }
  
          // count of items in the list
      size_t GetCount() const { return m_count; }
  
-        // return TRUE if this list is empty
+        // return true if this list is empty
      bool IsEmpty() const { return m_count == 0; }
  
      // operations
      bool IsEmpty() const { return m_count == 0; }
  
      // operations
@@ -420,10 +536,6 @@ protected:
                                     void *data,
                                     const wxListKey& key = wxDefaultListKey) = 0;
  
                                     void *data,
                                     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
@@ -432,11 +544,8 @@ public:
      wxListBase(void *object, ... /* terminate with NULL */);
  
  protected:
      wxListBase(void *object, ... /* terminate with NULL */);
  
  protected:
-        // copy ctor and assignment operator
-    wxListBase(const wxListBase& list) : wxObject()
-        { Init(); DoCopy(list); }
-    wxListBase& operator=(const wxListBase& list)
-        { Clear(); DoCopy(list); return *this; }
+    void Assign(const wxListBase& list)
+        { Clear(); DoCopy(list); }
  
          // get list head/tail
      wxNodeBase *GetFirst() const { return m_nodeFirst; }
  
          // get list head/tail
      wxNodeBase *GetFirst() const { return m_nodeFirst; }
@@ -450,7 +559,7 @@ protected:
      {
          wxNodeBase *node = Item(n);
  
      {
          wxNodeBase *node = Item(n);
  
-        return node ? node->GetData() : (wxNodeBase *)NULL;
+        return node ? node->GetData() : NULL;
      }
  
      // operations
      }
  
      // operations
@@ -460,7 +569,8 @@ protected:
          // append to beginning of list
      wxNodeBase *Append(void *object);
          // insert a new item at the beginning of the list
          // append to beginning of list
      wxNodeBase *Append(void *object);
          // insert a new item at the beginning of the list
-    wxNodeBase *Insert(void *object) { return Insert( (wxNodeBase*)NULL, object); }
+    wxNodeBase *Insert(void *object)
+        { return Insert(static_cast<wxNodeBase *>(NULL), object); }
          // insert a new item at the given position
      wxNodeBase *Insert(size_t pos, void *object)
          { return pos == GetCount() ? Append(object)
          // insert a new item at the given position
      wxNodeBase *Insert(size_t pos, void *object)
          { return pos == GetCount() ? Append(object)
@@ -470,20 +580,20 @@ protected:
  
          // keyed append
      wxNodeBase *Append(long key, void *object);
  
          // keyed append
      wxNodeBase *Append(long key, void *object);
-    wxNodeBase *Append(const wxChar *key, void *object);
+    wxNodeBase *Append(const wxString& 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)
      wxNodeBase *DetachNode(wxNodeBase *node);
  
          // 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)
      wxNodeBase *DetachNode(wxNodeBase *node);
-        // delete element from list, returns FALSE if node not found
+        // delete element from list, returns false if node not found
      bool DeleteNode(wxNodeBase *node);
          // finds object pointer and deletes node (and object if DeleteContents
      bool DeleteNode(wxNodeBase *node);
          // finds object pointer and deletes node (and object if DeleteContents
-        // is on), returns FALSE if object not found
+        // is on), returns false if object not found
      bool DeleteObject(void *object);
  
      // search (all return NULL if item not found)
          // by data
      bool DeleteObject(void *object);
  
      // search (all return NULL if item not found)
          // by data
-    wxNodeBase *Find(void *object) const;
+    wxNodeBase *Find(const void *object) const;
  
          // by key
      wxNodeBase *Find(const wxListKey& key) const;
  
          // by key
      wxNodeBase *Find(const wxListKey& key) const;
@@ -505,6 +615,10 @@ protected:
      void Reverse();
      void DeleteNodes(wxNodeBase* first, wxNodeBase* last);
  private:
      void Reverse();
      void DeleteNodes(wxNodeBase* first, wxNodeBase* last);
  private:
+
+        // common part of all ctors
+    void Init(wxKeyType keyType = wxKEY_NONE);
+
      // helpers
          // common part of copy ctor and assignment operator
      void DoCopy(const wxListBase& list);
      // helpers
          // common part of copy ctor and assignment operator
      void DoCopy(const wxListBase& list);
@@ -547,17 +661,23 @@ private:
  //     particularly useful with, for example, "wxWindow *" list where the
  //     wxWindowBase pointers are put into the list, but wxWindow pointers are
  //     retrieved from it.
  //     particularly useful with, for example, "wxWindow *" list where the
  //     wxWindowBase pointers are put into the list, but wxWindow pointers are
  //     retrieved from it.
+//
+//  4. final hack is that WX_DECLARE_LIST_3 is defined in terms of
+//     WX_DECLARE_LIST_4 to allow defining classes without operator->() as
+//     it results in compiler warnings when this operator doesn't make sense
+//     (i.e. stored elements are not pointers)
  
  
-#define WX_DECLARE_LIST_3(T, Tbase, name, nodetype, classexp)               \
+// common part of WX_DECLARE_LIST_3 and WX_DECLARE_LIST_PTR_3
+#define WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, ptrop)        \
      typedef int (*wxSortFuncFor_##name)(const T **, const T **);            \
                                                                              \
      classexp nodetype : public wxNodeBase                                   \
      {                                                                       \
      public:                                                                 \
      typedef int (*wxSortFuncFor_##name)(const T **, const T **);            \
                                                                              \
      classexp nodetype : public wxNodeBase                                   \
      {                                                                       \
      public:                                                                 \
-        nodetype(wxListBase *list = (wxListBase *)NULL,                     \
-                 nodetype *previous = (nodetype *)NULL,                     \
-                 nodetype *next = (nodetype *)NULL,                         \
-                 T *data = (T *)NULL,                                       \
+        nodetype(wxListBase *list = NULL,                                   \
+                 nodetype *previous = NULL,                                 \
+                 nodetype *next = NULL,                                     \
+                 T *data = NULL,                                            \
                   const wxListKey& key = wxDefaultListKey)                   \
              : wxNodeBase(list, previous, next, data, key) { }               \
                                                                              \
                   const wxListKey& key = wxDefaultListKey)                   \
              : wxNodeBase(list, previous, next, data, key) { }               \
                                                                              \
@@ -571,22 +691,37 @@ private:
          void SetData(T *data)                                               \
              { wxNodeBase::SetData(data); }                                  \
                                                                              \
          void SetData(T *data)                                               \
              { wxNodeBase::SetData(data); }                                  \
                                                                              \
+    protected:                                                              \
          virtual void DeleteData();                                          \
          virtual void DeleteData();                                          \
+                                                                            \
+        DECLARE_NO_COPY_CLASS(nodetype)                                     \
      };                                                                      \
                                                                              \
      classexp name : public wxListBase                                       \
      {                                                                       \
      public:                                                                 \
          typedef nodetype Node;                                              \
      };                                                                      \
                                                                              \
      classexp name : public wxListBase                                       \
      {                                                                       \
      public:                                                                 \
          typedef nodetype Node;                                              \
-        typedef Node* compatibility_iterator;                               \
+        classexp compatibility_iterator                                     \
+        {                                                                   \
+        public:                                                             \
+            compatibility_iterator(Node *ptr = NULL) : m_ptr(ptr) { }       \
+                                                                            \
+            Node *operator->() const { return m_ptr; }                      \
+            operator Node *() const { return m_ptr; }                       \
+                                                                            \
+        private:                                                            \
+            Node *m_ptr;                                                    \
+        };                                                                  \
                                                                              \
          name(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType)          \
              { }                                                             \
                                                                              \
          name(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType)          \
              { }                                                             \
+        name(const name& list) : wxListBase(list.GetKeyType())              \
+            { Assign(list); }                                               \
          name(size_t count, T *elements[])                                   \
              : wxListBase(count, (void **)elements) { }                      \
                                                                              \
          name& operator=(const name& list)                                   \
          name(size_t count, T *elements[])                                   \
              : wxListBase(count, (void **)elements) { }                      \
                                                                              \
          name& operator=(const name& list)                                   \
-            { (void) wxListBase::operator=(list); return *this; }           \
+            { if (&list != this) Assign(list); return *this; }              \
                                                                              \
          nodetype *GetFirst() const                                          \
              { return (nodetype *)wxListBase::GetFirst(); }                  \
                                                                              \
          nodetype *GetFirst() const                                          \
              { return (nodetype *)wxListBase::GetFirst(); }                  \
@@ -599,13 +734,14 @@ private:
          T *operator[](size_t index) const                                   \
          {                                                                   \
              nodetype *node = Item(index);                                   \
          T *operator[](size_t index) const                                   \
          {                                                                   \
              nodetype *node = Item(index);                                   \
-            return node ? (T*)(node->GetData()) : (T*)NULL;                 \
+            return node ? (T*)(node->GetData()) : NULL;                     \
          }                                                                   \
                                                                              \
          nodetype *Append(Tbase *object)                                     \
              { return (nodetype *)wxListBase::Append(object); }              \
          nodetype *Insert(Tbase *object)                                     \
          }                                                                   \
                                                                              \
          nodetype *Append(Tbase *object)                                     \
              { return (nodetype *)wxListBase::Append(object); }              \
          nodetype *Insert(Tbase *object)                                     \
-            { return (nodetype *)Insert((nodetype*)NULL, object); }         \
+            { return (nodetype *)Insert(static_cast<nodetype *>(NULL),      \
+                                        object); }                          \
          nodetype *Insert(size_t pos, Tbase *object)                         \
              { return (nodetype *)wxListBase::Insert(pos, object); }         \
          nodetype *Insert(nodetype *prev, Tbase *object)                     \
          nodetype *Insert(size_t pos, Tbase *object)                         \
              { return (nodetype *)wxListBase::Insert(pos, object); }         \
          nodetype *Insert(nodetype *prev, Tbase *object)                     \
@@ -622,10 +758,10 @@ private:
              { return wxListBase::DeleteNode(node); }                        \
          bool DeleteObject(Tbase *object)                                    \
              { return wxListBase::DeleteObject(object); }                    \
              { return wxListBase::DeleteNode(node); }                        \
          bool DeleteObject(Tbase *object)                                    \
              { return wxListBase::DeleteObject(object); }                    \
-        void Erase(compatibility_iterator it)                               \
+        void Erase(nodetype *it)                                            \
              { DeleteNode(it); }                                             \
                                                                              \
              { DeleteNode(it); }                                             \
                                                                              \
-        nodetype *Find(Tbase *object) const                                 \
+        nodetype *Find(const Tbase *object) const                           \
              { return (nodetype *)wxListBase::Find(object); }                \
                                                                              \
          virtual nodetype *Find(const wxListKey& key) const                  \
              { return (nodetype *)wxListBase::Find(object); }                \
                                                                              \
          virtual nodetype *Find(const wxListKey& key) const                  \
@@ -634,8 +770,10 @@ private:
          int IndexOf(Tbase *object) const                                    \
              { return wxListBase::IndexOf(object); }                         \
                                                                              \
          int IndexOf(Tbase *object) const                                    \
              { return wxListBase::IndexOf(object); }                         \
                                                                              \
+        void Sort(wxSortCompareFunction func)                               \
+            { wxListBase::Sort(func); }                                     \
          void Sort(wxSortFuncFor_##name func)                                \
          void Sort(wxSortFuncFor_##name func)                                \
-            { wxListBase::Sort((wxSortCompareFunction)func); }              \
+            { Sort((wxSortCompareFunction)func); }                          \
                                                                              \
      protected:                                                              \
          virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,  \
                                                                              \
      protected:                                                              \
          virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,  \
@@ -657,35 +795,36 @@ private:
          typedef base_value_type& base_reference;                            \
          typedef const base_value_type& const_base_reference;                \
                                                                              \
          typedef base_value_type& base_reference;                            \
          typedef const base_value_type& const_base_reference;                \
                                                                              \
-        class iterator                                                      \
+        classexp iterator                                                   \
          {                                                                   \
              typedef name list;                                              \
          public:                                                             \
          {                                                                   \
              typedef name list;                                              \
          public:                                                             \
-            typedef list::Node Node;                                        \
+            typedef nodetype Node;                                          \
              typedef iterator itor;                                          \
              typedef iterator itor;                                          \
-            typedef list::value_type* ptr_type;                             \
+            typedef T* value_type;                                          \
+            typedef value_type* ptr_type;                                   \
+            typedef value_type& reference;                                  \
                                                                              \
              Node* m_node;                                                   \
              Node* m_init;                                                   \
          public:                                                             \
                                                                              \
              Node* m_node;                                                   \
              Node* m_init;                                                   \
          public:                                                             \
-            typedef list::reference reference_type;                         \
+            typedef reference reference_type;                               \
              typedef ptr_type pointer_type;                                  \
                                                                              \
              iterator(Node* node, Node* init) : m_node(node), m_init(init) {}\
              iterator() : m_node(NULL), m_init(NULL) { }                     \
              reference_type operator*() const                                \
                  { return *(pointer_type)m_node->GetDataPtr(); }             \
              typedef ptr_type pointer_type;                                  \
                                                                              \
              iterator(Node* node, Node* init) : m_node(node), m_init(init) {}\
              iterator() : m_node(NULL), m_init(NULL) { }                     \
              reference_type operator*() const                                \
                  { return *(pointer_type)m_node->GetDataPtr(); }             \
-            pointer_type operator->() const                                 \
-                { return (pointer_type)m_node->GetDataPtr(); }              \
+            ptrop                                                           \
              itor& operator++() { m_node = m_node->GetNext(); return *this; }\
              itor& operator++() { m_node = m_node->GetNext(); return *this; }\
-            itor operator++(int)                                            \
+            const itor operator++(int)                                      \
                  { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
              itor& operator--()                                              \
              {                                                               \
                  m_node = m_node ? m_node->GetPrevious() : m_init;           \
                  return *this;                                               \
              }                                                               \
                  { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
              itor& operator--()                                              \
              {                                                               \
                  m_node = m_node ? m_node->GetPrevious() : m_init;           \
                  return *this;                                               \
              }                                                               \
-            itor operator--(int)                                            \
+            const itor operator--(int)                                      \
              {                                                               \
                  itor tmp = *this;                                           \
                  m_node = m_node ? m_node->GetPrevious() : m_init;           \
              {                                                               \
                  itor tmp = *this;                                           \
                  m_node = m_node ? m_node->GetPrevious() : m_init;           \
@@ -696,18 +835,20 @@ private:
              bool operator==(const itor& it) const                           \
                  { return it.m_node == m_node; }                             \
          };                                                                  \
              bool operator==(const itor& it) const                           \
                  { return it.m_node == m_node; }                             \
          };                                                                  \
-        class const_iterator                                                \
+        classexp const_iterator                                             \
          {                                                                   \
              typedef name list;                                              \
          public:                                                             \
          {                                                                   \
              typedef name list;                                              \
          public:                                                             \
-            typedef list::Node Node;                                        \
+            typedef nodetype Node;                                          \
+            typedef T* value_type;                                          \
+            typedef const value_type& const_reference;                      \
              typedef const_iterator itor;                                    \
              typedef const_iterator itor;                                    \
-            typedef list::value_type* ptr_type;                             \
+            typedef value_type* ptr_type;                                   \
                                                                              \
              Node* m_node;                                                   \
              Node* m_init;                                                   \
          public:                                                             \
                                                                              \
              Node* m_node;                                                   \
              Node* m_init;                                                   \
          public:                                                             \
-            typedef list::const_reference reference_type;                   \
+            typedef const_reference reference_type;                         \
              typedef const ptr_type pointer_type;                            \
                                                                              \
              const_iterator(Node* node, Node* init)                          \
              typedef const ptr_type pointer_type;                            \
                                                                              \
              const_iterator(Node* node, Node* init)                          \
@@ -717,17 +858,16 @@ private:
                  : m_node(it.m_node), m_init(it.m_init) { }                  \
              reference_type operator*() const                                \
                  { return *(pointer_type)m_node->GetDataPtr(); }             \
                  : m_node(it.m_node), m_init(it.m_init) { }                  \
              reference_type operator*() const                                \
                  { return *(pointer_type)m_node->GetDataPtr(); }             \
-            pointer_type operator->() const                                 \
-                { return (pointer_type)m_node->GetDataPtr(); }              \
+            ptrop                                                           \
              itor& operator++() { m_node = m_node->GetNext(); return *this; }\
              itor& operator++() { m_node = m_node->GetNext(); return *this; }\
-            itor operator++(int)                                            \
+            const itor operator++(int)                                      \
                  { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
              itor& operator--()                                              \
              {                                                               \
                  m_node = m_node ? m_node->GetPrevious() : m_init;           \
                  return *this;                                               \
              }                                                               \
                  { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
              itor& operator--()                                              \
              {                                                               \
                  m_node = m_node ? m_node->GetPrevious() : m_init;           \
                  return *this;                                               \
              }                                                               \
-            itor operator--(int)                                            \
+            const itor operator--(int)                                      \
              {                                                               \
                  itor tmp = *this;                                           \
                  m_node = m_node ? m_node->GetPrevious() : m_init;           \
              {                                                               \
                  itor tmp = *this;                                           \
                  m_node = m_node ? m_node->GetPrevious() : m_init;           \
@@ -738,18 +878,20 @@ private:
              bool operator==(const itor& it) const                           \
                  { return it.m_node == m_node; }                             \
          };                                                                  \
              bool operator==(const itor& it) const                           \
                  { return it.m_node == m_node; }                             \
          };                                                                  \
-        class reverse_iterator                                              \
+        classexp reverse_iterator                                           \
          {                                                                   \
              typedef name list;                                              \
          public:                                                             \
          {                                                                   \
              typedef name list;                                              \
          public:                                                             \
-            typedef list::Node Node;                                        \
+            typedef nodetype Node;                                          \
+            typedef T* value_type;                                          \
              typedef reverse_iterator itor;                                  \
              typedef reverse_iterator itor;                                  \
-            typedef list::value_type* ptr_type;                             \
+            typedef value_type* ptr_type;                                   \
+            typedef value_type& reference;                                  \
                                                                              \
              Node* m_node;                                                   \
              Node* m_init;                                                   \
          public:                                                             \
                                                                              \
              Node* m_node;                                                   \
              Node* m_init;                                                   \
          public:                                                             \
-            typedef list::reference reference_type;                         \
+            typedef reference reference_type;                               \
              typedef ptr_type pointer_type;                                  \
                                                                              \
              reverse_iterator(Node* node, Node* init)                        \
              typedef ptr_type pointer_type;                                  \
                                                                              \
              reverse_iterator(Node* node, Node* init)                        \
@@ -757,15 +899,14 @@ private:
              reverse_iterator() : m_node(NULL), m_init(NULL) { }             \
              reference_type operator*() const                                \
                  { return *(pointer_type)m_node->GetDataPtr(); }             \
              reverse_iterator() : m_node(NULL), m_init(NULL) { }             \
              reference_type operator*() const                                \
                  { return *(pointer_type)m_node->GetDataPtr(); }             \
-            pointer_type operator->() const                                 \
-                { return (pointer_type)m_node->GetDataPtr(); }              \
+            ptrop                                                           \
              itor& operator++()                                              \
                  { m_node = m_node->GetPrevious(); return *this; }           \
              itor& operator++()                                              \
                  { m_node = m_node->GetPrevious(); return *this; }           \
-            itor operator++(int)                                            \
+            const itor operator++(int)                                      \
              { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }\
              itor& operator--()                                              \
              { m_node = m_node ? m_node->GetNext() : m_init; return *this; } \
              { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }\
              itor& operator--()                                              \
              { m_node = m_node ? m_node->GetNext() : m_init; return *this; } \
-            itor operator--(int)                                            \
+            const itor operator--(int)                                      \
              {                                                               \
                  itor tmp = *this;                                           \
                  m_node = m_node ? m_node->GetNext() : m_init;               \
              {                                                               \
                  itor tmp = *this;                                           \
                  m_node = m_node ? m_node->GetNext() : m_init;               \
@@ -776,18 +917,20 @@ private:
              bool operator==(const itor& it) const                           \
                  { return it.m_node == m_node; }                             \
          };                                                                  \
              bool operator==(const itor& it) const                           \
                  { return it.m_node == m_node; }                             \
          };                                                                  \
-        class const_reverse_iterator                                        \
+        classexp const_reverse_iterator                                     \
          {                                                                   \
              typedef name list;                                              \
          public:                                                             \
          {                                                                   \
              typedef name list;                                              \
          public:                                                             \
-            typedef list::Node Node;                                        \
+            typedef nodetype Node;                                          \
+            typedef T* value_type;                                          \
              typedef const_reverse_iterator itor;                            \
              typedef const_reverse_iterator itor;                            \
-            typedef list::value_type* ptr_type;                             \
+            typedef value_type* ptr_type;                                   \
+            typedef const value_type& const_reference;                      \
                                                                              \
              Node* m_node;                                                   \
              Node* m_init;                                                   \
          public:                                                             \
                                                                              \
              Node* m_node;                                                   \
              Node* m_init;                                                   \
          public:                                                             \
-            typedef list::const_reference reference_type;                   \
+            typedef const_reference reference_type;                         \
              typedef const ptr_type pointer_type;                            \
                                                                              \
              const_reverse_iterator(Node* node, Node* init)                  \
              typedef const ptr_type pointer_type;                            \
                                                                              \
              const_reverse_iterator(Node* node, Node* init)                  \
@@ -797,15 +940,14 @@ private:
                  : m_node(it.m_node), m_init(it.m_init) { }                  \
              reference_type operator*() const                                \
                  { return *(pointer_type)m_node->GetDataPtr(); }             \
                  : m_node(it.m_node), m_init(it.m_init) { }                  \
              reference_type operator*() const                                \
                  { return *(pointer_type)m_node->GetDataPtr(); }             \
-            pointer_type operator->() const                                 \
-                { return (pointer_type)m_node->GetDataPtr(); }              \
+            ptrop                                                           \
              itor& operator++()                                              \
                  { m_node = m_node->GetPrevious(); return *this; }           \
              itor& operator++()                                              \
                  { m_node = m_node->GetPrevious(); return *this; }           \
-            itor operator++(int)                                            \
+            const itor operator++(int)                                      \
              { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }\
              itor& operator--()                                              \
                  { m_node = m_node ? m_node->GetNext() : m_init; return *this;}\
              { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }\
              itor& operator--()                                              \
                  { m_node = m_node ? m_node->GetNext() : m_init; return *this;}\
-            itor operator--(int)                                            \
+            const itor operator--(int)                                      \
              {                                                               \
                  itor tmp = *this;                                           \
                  m_node = m_node ? m_node->GetNext() : m_init;               \
              {                                                               \
                  itor tmp = *this;                                           \
                  m_node = m_node ? m_node->GetNext() : m_init;               \
@@ -819,7 +961,7 @@ private:
                                                                              \
          wxEXPLICIT name(size_type n, const_reference v = value_type())      \
              { assign(n, v); }                                               \
                                                                              \
          wxEXPLICIT name(size_type n, const_reference v = value_type())      \
              { assign(n, v); }                                               \
-        name(const_iterator first, const_iterator last)                     \
+        name(const const_iterator& first, const const_iterator& last)       \
              { assign(first, last); }                                        \
          iterator begin() { return iterator(GetFirst(), GetLast()); }        \
          const_iterator begin() const                                        \
              { assign(first, last); }                                        \
          iterator begin() { return iterator(GetFirst(), GetLast()); }        \
          const_iterator begin() const                                        \
@@ -835,25 +977,25 @@ private:
              { return const_reverse_iterator(NULL, GetFirst()); }            \
          void resize(size_type n, value_type v = value_type())               \
          {                                                                   \
              { return const_reverse_iterator(NULL, GetFirst()); }            \
          void resize(size_type n, value_type v = value_type())               \
          {                                                                   \
-            if(n < size())                                                  \
-                for(; n < size(); pop_back());                              \
-            else if(n > size())                                             \
-                for(; n > size(); push_back(v));                            \
+            while (n < size())                                              \
+                pop_back();                                                 \
+            while (n > size())                                              \
+                push_back(v);                                                \
          }                                                                   \
          size_type size() const { return GetCount(); }                       \
          size_type max_size() const { return INT_MAX; }                      \
          bool empty() const { return IsEmpty(); }                            \
          reference front() { return *begin(); }                              \
          const_reference front() const { return *begin(); }                  \
          }                                                                   \
          size_type size() const { return GetCount(); }                       \
          size_type max_size() const { return INT_MAX; }                      \
          bool empty() const { return IsEmpty(); }                            \
          reference front() { return *begin(); }                              \
          const_reference front() const { return *begin(); }                  \
-        reference back() { return *--end(); }                               \
-        const_reference back() const { return *--end(); }                   \
+        reference back() { iterator tmp = end(); return *--tmp; }           \
+        const_reference back() const { const_iterator tmp = end(); return *--tmp; }\
          void push_front(const_reference v = value_type())                   \
              { Insert(GetFirst(), (const_base_reference)v); }                \
          void pop_front() { DeleteNode(GetFirst()); }                        \
          void push_back(const_reference v = value_type())                    \
              { Append((const_base_reference)v); }                            \
          void pop_back() { DeleteNode(GetLast()); }                          \
          void push_front(const_reference v = value_type())                   \
              { Insert(GetFirst(), (const_base_reference)v); }                \
          void pop_front() { DeleteNode(GetFirst()); }                        \
          void push_back(const_reference v = value_type())                    \
              { Append((const_base_reference)v); }                            \
          void pop_back() { DeleteNode(GetLast()); }                          \
-        void assign(const_iterator first, const_iterator last)              \
+        void assign(const_iterator first, const const_iterator& last)       \
          {                                                                   \
              clear();                                                        \
              for(; first != last; ++first)                                   \
          {                                                                   \
              clear();                                                        \
              for(; first != last; ++first)                                   \
@@ -865,38 +1007,43 @@ private:
              for(size_type i = 0; i < n; ++i)                                \
                  Append((const_base_reference)v);                            \
          }                                                                   \
              for(size_type i = 0; i < n; ++i)                                \
                  Append((const_base_reference)v);                            \
          }                                                                   \
-        iterator insert(iterator it, const_reference v = value_type())      \
+        iterator insert(const iterator& it, const_reference v)              \
          {                                                                   \
          {                                                                   \
-            Insert(it.m_node, (const_base_reference)v);                     \
-            return iterator(it.m_node->GetPrevious(), GetLast());           \
+            if ( it == end() )                                              \
+                Append((const_base_reference)v);                            \
+            else                                                            \
+                Insert(it.m_node, (const_base_reference)v);                 \
+            iterator itprev(it);                                            \
+            return itprev--;                                                \
          }                                                                   \
          }                                                                   \
-        void insert(iterator it, size_type n, const_reference v = value_type())\
+        void insert(const iterator& it, size_type n, const_reference v)     \
          {                                                                   \
              for(size_type i = 0; i < n; ++i)                                \
                  Insert(it.m_node, (const_base_reference)v);                 \
          }                                                                   \
          {                                                                   \
              for(size_type i = 0; i < n; ++i)                                \
                  Insert(it.m_node, (const_base_reference)v);                 \
          }                                                                   \
-        void insert(iterator it, const_iterator first, const_iterator last) \
+        void insert(const iterator& it,                                     \
+                    const_iterator first, const const_iterator& last)       \
          {                                                                   \
              for(; first != last; ++first)                                   \
                  Insert(it.m_node, (const_base_reference)*first);            \
          }                                                                   \
          {                                                                   \
              for(; first != last; ++first)                                   \
                  Insert(it.m_node, (const_base_reference)*first);            \
          }                                                                   \
-        iterator erase(iterator it)                                         \
+        iterator erase(const iterator& it)                                  \
          {                                                                   \
              iterator next = iterator(it.m_node->GetNext(), GetLast());      \
              DeleteNode(it.m_node); return next;                             \
          }                                                                   \
          {                                                                   \
              iterator next = iterator(it.m_node->GetNext(), GetLast());      \
              DeleteNode(it.m_node); return next;                             \
          }                                                                   \
-        iterator erase(iterator first, iterator last)                       \
+        iterator erase(const iterator& first, const iterator& last)         \
          {                                                                   \
              iterator next = last; ++next;                                   \
              DeleteNodes(first.m_node, last.m_node);                         \
              return next;                                                    \
          }                                                                   \
          void clear() { Clear(); }                                           \
          {                                                                   \
              iterator next = last; ++next;                                   \
              DeleteNodes(first.m_node, last.m_node);                         \
              return next;                                                    \
          }                                                                   \
          void clear() { Clear(); }                                           \
-        void splice(iterator it, name& l, iterator first, iterator last)    \
+        void splice(const iterator& it, name& l, const iterator& first, const iterator& last)\
              { insert(it, first, last); l.erase(first, last); }              \
              { insert(it, first, last); l.erase(first, last); }              \
-        void splice(iterator it, name& l)                                   \
+        void splice(const iterator& it, name& l)                            \
              { splice(it, l, l.begin(), l.end() ); }                         \
              { splice(it, l, l.begin(), l.end() ); }                         \
-        void splice(iterator it, name& l, iterator first)                   \
+        void splice(const iterator& it, name& l, const iterator& first)     \
          {                                                                   \
              iterator tmp = first; ++tmp;                                    \
              if(it == first || it == tmp) return;                            \
          {                                                                   \
              iterator tmp = first; ++tmp;                                    \
              if(it == first || it == tmp) return;                            \
@@ -917,23 +1064,48 @@ private:
          } */                                                                \
      }
  
          } */                                                                \
      }
  
+#define WX_LIST_PTROP                                                       \
+            pointer_type operator->() const                                 \
+                { return (pointer_type)m_node->GetDataPtr(); }
+#define WX_LIST_PTROP_NONE
+
+#define WX_DECLARE_LIST_3(T, Tbase, name, nodetype, classexp)               \
+    WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, WX_LIST_PTROP_NONE)
+#define WX_DECLARE_LIST_PTR_3(T, Tbase, name, nodetype, classexp)        \
+    WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, WX_LIST_PTROP)
+
  #define WX_DECLARE_LIST_2(elementtype, listname, nodename, classexp)        \
      WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename, classexp)
  #define WX_DECLARE_LIST_2(elementtype, listname, nodename, classexp)        \
      WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename, classexp)
+#define WX_DECLARE_LIST_PTR_2(elementtype, listname, nodename, classexp)        \
+    WX_DECLARE_LIST_PTR_3(elementtype, elementtype, listname, nodename, classexp)
  
  #define WX_DECLARE_LIST(elementtype, listname)                              \
      typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
      WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class)
  
  #define WX_DECLARE_LIST(elementtype, listname)                              \
      typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
      WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class)
+#define WX_DECLARE_LIST_PTR(elementtype, listname)                              \
+    typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
+    WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class)
+
+#define WX_DECLARE_LIST_WITH_DECL(elementtype, listname, decl) \
+    typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
+    WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, decl)
  
  #define WX_DECLARE_EXPORTED_LIST(elementtype, listname)                     \
  
  #define WX_DECLARE_EXPORTED_LIST(elementtype, listname)                     \
+    WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLIMPEXP_CORE)
+
+#define WX_DECLARE_EXPORTED_LIST_PTR(elementtype, listname)                     \
      typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
      typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
-    WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class WXDLLEXPORT)
+    WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class WXDLLIMPEXP_CORE)
  
  #define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo)       \
      typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
      WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class usergoo)
  
  #define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo)       \
      typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
      WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class usergoo)
+#define WX_DECLARE_USER_EXPORTED_LIST_PTR(elementtype, listname, usergoo)       \
+    typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
+    WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class usergoo)
  
  // this macro must be inserted in your program after
  
  // this macro must be inserted in your program after
-//      #include <wx/listimpl.cpp>
+//      #include "wx/listimpl.cpp"
  #define WX_DEFINE_LIST(name)    "don't forget to include listimpl.cpp!"
  
  #define WX_DEFINE_EXPORTED_LIST(name)      WX_DEFINE_LIST(name)
  #define WX_DEFINE_LIST(name)    "don't forget to include listimpl.cpp!"
  
  #define WX_DEFINE_EXPORTED_LIST(name)      WX_DEFINE_LIST(name)
@@ -941,29 +1113,56 @@ private:
  
  #endif // !wxUSE_STL
  
  
  #endif // !wxUSE_STL
  
-// =============================================================================
+// ============================================================================
  // 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
  // ----------------------------------------------------------------------------
  
  
  // ----------------------------------------------------------------------------
  // commonly used list classes
  // ----------------------------------------------------------------------------
  
-#ifdef wxLIST_COMPATIBILITY
+#if defined(wxLIST_COMPATIBILITY)
+
+// inline compatibility functions
+
+#if !wxUSE_STL
+
+// ----------------------------------------------------------------------------
+// wxNodeBase deprecated methods
+// ----------------------------------------------------------------------------
+
+inline wxNode *wxNodeBase::Next() const { return (wxNode *)GetNext(); }
+inline wxNode *wxNodeBase::Previous() const { return (wxNode *)GetPrevious(); }
+inline wxObject *wxNodeBase::Data() const { return (wxObject *)GetData(); }
+
+// ----------------------------------------------------------------------------
+// wxListBase deprecated methods
+// ----------------------------------------------------------------------------
+
+inline int wxListBase::Number() const { return (int)GetCount(); }
+inline wxNode *wxListBase::First() const { return (wxNode *)GetFirst(); }
+inline wxNode *wxListBase::Last() const { return (wxNode *)GetLast(); }
+inline wxNode *wxListBase::Nth(size_t n) const { return (wxNode *)Item(n); }
+inline wxListBase::operator wxList&() const { return *(wxList*)this; }
+
+#endif
  
  // define this to make a lot of noise about use of the old wxList classes.
  //#define wxWARN_COMPAT_LIST_USE
  
  
  // define this to make a lot of noise about use of the old wxList classes.
  //#define wxWARN_COMPAT_LIST_USE
  
-// -----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
  // wxList compatibility class: in fact, it's a list of wxObjects
  // wxList compatibility class: in fact, it's a list of wxObjects
-// -----------------------------------------------------------------------------
-WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode, class WXDLLIMPEXP_BASE);
+// ----------------------------------------------------------------------------
+
+WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode,
+                        class WXDLLIMPEXP_BASE);
  
  class WXDLLIMPEXP_BASE wxList : public wxObjectList
  {
  public:
  #if defined(wxWARN_COMPAT_LIST_USE) && !wxUSE_STL
  
  class WXDLLIMPEXP_BASE wxList : public wxObjectList
  {
  public:
  #if defined(wxWARN_COMPAT_LIST_USE) && !wxUSE_STL
-    wxDEPRECATED( wxList(int key_type = wxKEY_NONE) );
+    wxList() { };
+    wxDEPRECATED( wxList(int key_type) );
  #elif !wxUSE_STL
      wxList(int key_type = wxKEY_NONE);
  #endif
  #elif !wxUSE_STL
      wxList(int key_type = wxKEY_NONE);
  #endif
@@ -973,7 +1172,7 @@ public:
  
  #if !wxUSE_STL
      wxList& operator=(const wxList& list)
  
  #if !wxUSE_STL
      wxList& operator=(const wxList& list)
-        { (void) wxListBase::operator=(list); return *this; }
+        { if (&list != this) Assign(list); return *this; }
  
      // compatibility methods
      void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }
  
      // compatibility methods
      void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }
@@ -983,11 +1182,6 @@ public:
  #else
      wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }
  #endif
  #else
      wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }
  #endif
-
-private:
-#if !wxUSE_STL
-    DECLARE_DYNAMIC_CLASS(wxList)
-#endif
  };
  
  #if !wxUSE_STL
  };
  
  #if !wxUSE_STL
@@ -1003,29 +1197,36 @@ public:
      // ctors and such
          // default
  #ifdef wxWARN_COMPAT_LIST_USE
      // ctors and such
          // default
  #ifdef wxWARN_COMPAT_LIST_USE
-    wxDEPRECATED( wxStringList() );
-    wxDEPRECATED( wxStringList(const wxChar *first ...) );
+    wxStringList();
+    wxDEPRECATED( wxStringList(const wxChar *first ...) ); // FIXME-UTF8
  #else
      wxStringList();
  #else
      wxStringList();
-    wxStringList(const wxChar *first ...);
+    wxStringList(const wxChar *first ...); // FIXME-UTF8
  #endif
  
          // copying the string list: the strings are copied, too (extremely
          // inefficient!)
  #endif
  
          // copying the string list: the strings are copied, too (extremely
          // inefficient!)
-    wxStringList(const wxStringList& other) : wxStringListBase() { DeleteContents(TRUE); DoCopy(other); }
+    wxStringList(const wxStringList& other) : wxStringListBase() { DeleteContents(true); DoCopy(other); }
      wxStringList& operator=(const wxStringList& other)
      wxStringList& operator=(const wxStringList& other)
-        { Clear(); DoCopy(other); return *this; }
+    {
+        if (&other != this)
+        {
+            Clear();
+            DoCopy(other);
+        }
+        return *this;
+    }
  
      // operations
          // makes a copy of the string
      wxNode *Add(const wxChar *s);
  
      // operations
          // makes a copy of the string
      wxNode *Add(const wxChar *s);
-        
+
          // Append to beginning of list
      wxNode *Prepend(const wxChar *s);
  
      bool Delete(const wxChar *s);
  
          // Append to beginning of list
      wxNode *Prepend(const wxChar *s);
  
      bool Delete(const wxChar *s);
  
-    wxChar **ListToArray(bool new_copies = FALSE) const;
+    wxChar **ListToArray(bool new_copies = false) const;
      bool Member(const wxChar *s) const;
  
      // alphabetic sort
      bool Member(const wxChar *s) const;
  
      // alphabetic sort
@@ -1033,17 +1234,29 @@ public:
  
  private:
      void DoCopy(const wxStringList&); // common part of copy ctor and operator=
  
  private:
      void DoCopy(const wxStringList&); // common part of copy ctor and operator=
-
-    DECLARE_DYNAMIC_CLASS(wxStringList)
  };
  
  #else // if wxUSE_STL
  
  };
  
  #else // if wxUSE_STL
  
-WX_DECLARE_LIST_XO(wxString, wxStringListBase, class WXDLLEXPORT);
+WX_DECLARE_LIST_XO(wxString, wxStringListBase, class WXDLLIMPEXP_BASE);
  
  
-class WXDLLEXPORT wxStringList : public wxStringListBase
+class WXDLLIMPEXP_BASE wxStringList : public wxStringListBase
  {
  public:
  {
  public:
+    compatibility_iterator Append(wxChar* s)
+        { wxString tmp = s; delete[] s; return wxStringListBase::Append(tmp); }
+    compatibility_iterator Insert(wxChar* s)
+        { wxString tmp = s; delete[] s; return wxStringListBase::Insert(tmp); }
+    compatibility_iterator Insert(size_t pos, wxChar* s)
+    {
+        wxString tmp = s;
+        delete[] s;
+        return wxStringListBase::Insert(pos, tmp);
+    }
+    compatibility_iterator Add(const wxChar* s)
+        { push_back(s); return GetLast(); }
+    compatibility_iterator Prepend(const wxChar* s)
+        { push_front(s); return GetFirst(); }
  };
  
  #endif // wxUSE_STL
  };
  
  #endif // wxUSE_STL
@@ -1064,5 +1277,4 @@ public:
          (list).clear();                                                      \
      }
  
          (list).clear();                                                      \
      }
  
-#endif
-    // _WX_LISTH__
+#endif // _WX_LISTH__