better compatibility with old wxList in wxUSE_STL==1 mode (patch 1075432)

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@32418 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/include/wx/list.h b/include/wx/list.h
index 3b857ef2718931c4caa910f30ee6c53e66339d9a..62d6c44aa0eb913ad2c46a7d4c1dcb714ff59a70 100644 (file)
--- a/include/wx/list.h
+++ b/include/wx/list.h
@@ -40,6 +40,8 @@
 
 #if wxUSE_STL
     #include "wx/beforestd.h"
+    #include <algorithm>
+    #include <iterator>
     #include <list>
     #include "wx/afterstd.h"
 #endif
@@ -96,122 +98,172 @@ enum wxKeyType
 #define WX_DECLARE_LIST_WITH_DECL(elT, liT, decl) \
     WX_DECLARE_LIST_XO(elT*, liT, decl)
 
-#define WX_DECLARE_LIST_XO(elT, liT, decl) \
+#define WX_DECLARE_LIST_XO(elT, liT, decl)                                    \
     decl liT : public std::list<elT>                                          \
     {                                                                         \
-    public:                                                                   \
-        class dummy;                                                          \
+    private:                                                                  \
+        bool m_destroy;                                                       \
+    private:                                                                  \
+        class SortCompareFunction                                             \
+        {                                                                     \
+        private:                                                              \
+            wxSortCompareFunction m_CompFunc;                                 \
+        public:                                                               \
+            SortCompareFunction( wxSortCompareFunction compfunc )             \
+                : m_CompFunc( compfunc ) {}                                   \
+            bool operator()( const elT X, const elT Y ) const                 \
+                { return ( m_CompFunc( X, Y ) < 0 ); }                        \
+        };                                                                    \
                                                                               \
-        struct compatibility_iterator                                         \
+        typedef elT _WX_LIST_ITEM_TYPE_##liT;                                 \
+        static void DeleteFunction( const _WX_LIST_ITEM_TYPE_##liT X );       \
+    public:                                                                   \
+        class compatibility_iterator                                          \
         {                                                                     \
-            typedef std::list<elT>::iterator iterator;                        \
+        private:                                                              \
+            typedef liT::iterator iterator;                                   \
+            friend class liT;                                                 \
+        private:                                                              \
             iterator m_iter;                                                  \
             liT * m_list;                                                     \
         public:                                                               \
+            compatibility_iterator()                                          \
+                : m_iter(), 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)                  \
+                { return (m_list == i.m_list) && (m_iter == i.m_iter); }      \
+            bool operator!=(const compatibility_iterator& i)                  \
+                { return !( operator==( i ) ); }                              \
             operator bool() const                                             \
-                { return m_list && m_iter != m_list->end(); }                 \
+                { return m_list ? m_iter != m_list->end() : false; }          \
             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; }    \
-            bool operator==(const compatibility_iterator& it)                 \
-                { return m_list == it.m_list && m_iter == it.m_iter; }        \
-            bool operator!=(const compatibility_iterator& it)                 \
-                { return m_list != it.m_list || m_iter != it.m_iter; }        \
-        };                                                                    \
-        typedef struct compatibility_iterator citer;                          \
+                { return !( operator bool() ); }                              \
                                                                               \
-        class dummy                                                           \
-        {                                                                     \
-            typedef std::list<elT>::iterator it;                              \
-            typedef compatibility_iterator citer;                             \
-        public:                                                               \
             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 );                             \
+                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 m_list ?                                               \
+                    m_iter != m_list->end() ?                                 \
+                        std::distance( m_list->begin(), m_iter ) :            \
+                            wxNOT_FOUND :                                     \
+                        wxNOT_FOUND;                                          \
             }                                                                 \
-        private:                                                              \
-            dummy();                                                          \
         };                                                                    \
-    protected:                                                                \
-        iterator find( const 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 it = find( e );                                          \
-            if( it != end() )                                                 \
+            iterator i = const_cast< liT* >(this)->begin();                   \
+            std::advance( i, idx );                                           \
+            return compatibility_iterator( this, i );                         \
+        }                                                                     \
+        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( 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 )                         \
+        {                                                                     \
+            if ( m_destroy )                                                  \
+                DeleteFunction( i->GetData() );                               \
+            erase( i.m_iter );                                                \
+        }                                                                     \
+        bool DeleteNode( const compatibility_iterator& i )                    \
+        {                                                                     \
+            if( i )                                                           \
             {                                                                 \
-                erase( it );                                                  \
+                Erase( i );                                                   \
                 return true;                                                  \
             }                                                                 \
             return false;                                                     \
         }                                                                     \
-        void Erase( const compatibility_iterator& it )                        \
-        {                                                                     \
-            erase( it.m_iter );                                               \
-        }                                                                     \
-        citer Find( const 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(), DeleteFunction );              \
+            clear();                                                          \
         }                                                                     \
+                                                                              \
+        void Sort( wxSortCompareFunction compfunc )                           \
+            { sort( SortCompareFunction( compfunc ) ); }                      \
+                                                                              \
+        ~liT() { Clear(); }                                                   \
     }
 
 #define WX_DECLARE_LIST(elementtype, listname)                              \
@@ -655,8 +707,10 @@ private:
         int IndexOf(Tbase *object) const                                    \
             { return wxListBase::IndexOf(object); }                         \
                                                                             \
+        void Sort(wxSortCompareFunction func)                               \
+            { wxListBase::Sort(func); }                                     \
         void Sort(wxSortFuncFor_##name func)                                \
-            { wxListBase::Sort((wxSortCompareFunction)func); }              \
+            { Sort((wxSortCompareFunction)func); }                          \
                                                                             \
     protected:                                                              \
         virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,  \

diff --git a/include/wx/listimpl.cpp b/include/wx/listimpl.cpp
index 1f1dba3a81278908640920af926c29ca53fee67b..11d0196a4e99f9cc09161b3f11f084a4143b76f7 100644 (file)
--- a/include/wx/listimpl.cpp
+++ b/include/wx/listimpl.cpp
@@ -11,23 +11,28 @@
 
 #if wxUSE_STL
 
-#undef WX_DEFINE_LIST
-#define WX_DEFINE_LIST(name)
+    #undef  WX_DEFINE_LIST
+    #define WX_DEFINE_LIST(name)                                        \
+        void name::DeleteFunction( const _WX_LIST_ITEM_TYPE_##name X )  \
+        {                                                               \
+            delete X;                                                   \
+        }
 
 #else // if !wxUSE_STL
 
-#define _DEFINE_LIST(T, name)                   \
-    void wx##name##Node::DeleteData()    \
-    {                                           \
-        delete (T *)GetData();                  \
-    }
+    #define _DEFINE_LIST(T, name)         \
+        void wx##name##Node::DeleteData() \
+        {                                 \
+            delete (T *)GetData();        \
+        }
 
-// redefine the macro so that now it will generate the class implementation
-// old value would provoke a compile-time error if this file is not included
-#undef  WX_DEFINE_LIST
-#define WX_DEFINE_LIST(name) _DEFINE_LIST(_WX_LIST_ITEM_TYPE_##name, name)
+    // redefine the macro so that now it will generate the class implementation
+    // old value would provoke a compile-time error if this file is not included
+    #undef  WX_DEFINE_LIST
+    #define WX_DEFINE_LIST(name) _DEFINE_LIST(_WX_LIST_ITEM_TYPE_##name, name)
 
-// don't pollute preprocessor's name space
-//#undef  _DEFINE_LIST
+    // don't pollute preprocessor's name space
+    //#undef  _DEFINE_LIST
 
 #endif
+

diff --git a/src/common/list.cpp b/src/common/list.cpp
index ed3c4a69d67259d8a9e72b758e46456599973030..337a8db96306d668058e5659c6dfa72e2ccb3df2 100644 (file)
--- a/src/common/list.cpp
+++ b/src/common/list.cpp
@@ -756,4 +756,11 @@ wxNode *wxStringList::Prepend(const wxChar *s)
 
 #endif // wxLIST_COMPATIBILITY
 
+#else // wxUSE_STL = 1
+
+    #include <wx/listimpl.cpp>
+    WX_DEFINE_LIST(wxObjectList);
+    WX_DEFINE_LIST(wxStringListBase);
+
 #endif // !wxUSE_STL
+

diff --git a/src/common/wincmn.cpp b/src/common/wincmn.cpp
index c76662163620a9d7e66c5bdaa1b4eebc7c27f5dc..d1e6488437a658ebd7452325d0794acfebf11d70 100644 (file)
--- a/src/common/wincmn.cpp
+++ b/src/common/wincmn.cpp
@@ -2288,15 +2288,22 @@ wxAccessible* wxWindowBase::CreateAccessible()
 
 #endif
 
-#if !wxUSE_STL
 // ----------------------------------------------------------------------------
 // list classes implementation
 // ----------------------------------------------------------------------------
 
+#if wxUSE_STL
+
+#include <wx/listimpl.cpp>
+WX_DEFINE_LIST(wxWindowList);
+
+#else
+
 void wxWindowListNode::DeleteData()
 {
     delete (wxWindow *)GetData();
 }
+
 #endif
 
 // ----------------------------------------------------------------------------