]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/dlist.h
in debug mode when clicking with the middle mouse button draw borders around all...
[wxWidgets.git] / include / wx / dlist.h
index dcb6e7d7ba09a27ce47223e813d9c1d23ad8b625..0389d830d412696b16150a8423956acf2f779129 100644 (file)
@@ -28,177 +28,190 @@ private:
     bool m_destroy;
     typedef std::list<T*> BaseListType;
     typedef wxDList<T> ListType;
-    
+
 public:
+    typedef typename BaseListType::iterator iterator;
+
+    class compatibility_iterator
+    {
+    private:
+        /* Workaround for broken VC6 nested class name resolution */
         typedef typename BaseListType::iterator iterator;
-        
-        class compatibility_iterator
+        friend class wxDList<T>;
+
+        iterator m_iter;
+        ListType *m_list;
+
+    public:
+        compatibility_iterator()
+            : m_iter(), m_list( NULL ) {}
+        compatibility_iterator( ListType* li, iterator i )
+            : m_iter( i ), m_list( li ) {}
+        compatibility_iterator( const ListType* li, iterator i )
+            : m_iter( i ), m_list( const_cast<ListType*>(li) ) {}
+
+        compatibility_iterator* operator->() { return this; }
+        const compatibility_iterator* operator->() const { return this; }
+
+        bool operator==(const compatibility_iterator& i) const
         {
-        private:
-            /* Workaround for broken VC6 nested class name resolution */
-            typedef typename BaseListType::iterator iterator;
-            friend class wxDList<T>;
-            
-            iterator m_iter;
-            ListType *m_list;
-            
-        public:
-            compatibility_iterator()
-                : m_iter(), m_list( NULL ) {}
-            compatibility_iterator( ListType* li, iterator i )
-                : m_iter( i ), m_list( li ) {}
-            compatibility_iterator( const ListType* li, iterator i )              
-                : m_iter( i ), m_list( const_cast<ListType*>(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,                            
-                              wxT("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                                            
-                { return m_list ? m_iter != m_list->end() : false; }         
-            bool operator !() const                                          
-                { return !( operator bool() ); }                             
-                                                                             
-            T* GetData() const                                              
-                { return *m_iter; }                                          
-            void SetData( T* e )                                            
-                { *m_iter = e; }                                             
-                                                                             
-            compatibility_iterator GetNext() const                           
-            {                                                                
-                iterator i = m_iter;                                         
-                return compatibility_iterator( m_list, ++i );                
-            }                                                                
-            compatibility_iterator GetPrevious() const                       
-            {                                                                
-                if ( m_iter == m_list->begin() )                             
-                    return compatibility_iterator();                         
-                                                                             
-                iterator i = m_iter;                                         
-                return compatibility_iterator( m_list, --i );                
-            }                                                                
-            int IndexOf() const                                              
-            {                                                                
-                return *this ? std::distance( m_list->begin(), m_iter )      
-                             : wxNOT_FOUND;                                  
-            }                                                                
-        };                                                                   
-    public:                                                                  
-        wxDList() : m_destroy( false ) {}
-                                                                             
-        ~wxDList() { Clear(); }
-        
-        compatibility_iterator Find( const T* e ) const                     
-        {                                                                    
-          return compatibility_iterator( this,                              
-                     std::find( const_cast<ListType*>(this)->begin(), const_cast<ListType*>(this)->end(), e ) );         
-        }                                                                    
-                                                                             
-        bool IsEmpty() const                                                 
-            { return this->empty(); }                                              
-        size_t GetCount() const                                              
-            { return this->size(); }                                               
-                                                                             
-        compatibility_iterator Item( size_t idx ) const                      
-        {                                                                    
-            iterator i = const_cast<ListType*>(this)->begin();                  
-            std::advance( i, idx );                                          
-            return compatibility_iterator( this, i );                        
-        }                                                                    
-        T* operator[](size_t idx) const                                     
-        {                                                                    
-            return Item(idx).GetData();                                      
-        }                                                                    
-                                                                             
-        compatibility_iterator GetFirst() const                              
-        {                                                                    
-            return compatibility_iterator( this, const_cast<ListType*>(this)->begin() );
-        }                                                                    
-        compatibility_iterator GetLast() const                               
-        {                                                                    
-            iterator i = const_cast<ListType*>(this)->end();
-            return compatibility_iterator( this, !(this->empty()) ? --i : i );       
-        }                                                                    
-        compatibility_iterator Member( T* e ) const                         
-            { return Find( e ); }                                            
-        compatibility_iterator Nth( int n ) const                            
-            { return Item( n ); }                                            
-        int IndexOf( T* e ) const                                           
-            { return Find( e ).IndexOf(); }                                  
-                                                                             
-        compatibility_iterator Append( T* e )                               
-        {                                                                    
-            this->push_back( e );                                                  
-            return GetLast();                                                
-        }                                                                    
-        compatibility_iterator Insert( T* e )                               
-        {                                                                    
-            this->push_front( e );                                                 
-            return compatibility_iterator( this, this->begin() );
-        }                                                                    
-        compatibility_iterator Insert( compatibility_iterator & i, T* e )   
-        {                                                                    
-            return compatibility_iterator( this, this->insert( i.m_iter, e ) );    
-        }                                                                    
-        compatibility_iterator Insert( size_t idx, T* e )                   
-        {                                                                    
-            return compatibility_iterator( this,                             
-                                           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 )
-                delete i->GetData();
-            this->erase( i.m_iter );                                               
-        }                                                                    
-        bool DeleteNode( const compatibility_iterator& i )                   
-        {                                                                    
-            if( i )                                                          
-            {                                                                
-                Erase( i );                                                  
-                return true;                                                 
-            }                                                                
-            return false;                                                    
-        }                                                                    
-        bool DeleteObject( T* e )                                           
-        {                                                                    
-            return DeleteNode( Find( e ) );                                  
-        }                                                                    
-        void Clear()                                                         
-        {                                                                    
-            if ( m_destroy )
-            {
-                iterator it, en;
-                for ( it = this->begin(), en = this->end(); it != en; ++it )
-                    delete *it;
-            }
-            this->clear();                                                         
-        }                                                                    
+            wxASSERT_MSG( m_list && i.m_list,
+                          "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
+            { return m_list ? m_iter != m_list->end() : false; }
+        bool operator !() const
+            { return !( operator bool() ); }
+
+        T* GetData() const { return *m_iter; }
+        void SetData( T* e ) { *m_iter = e; }
+
+        compatibility_iterator GetNext() const
+        {
+            iterator i = m_iter;
+            return compatibility_iterator( m_list, ++i );
+        }
+
+        compatibility_iterator GetPrevious() const
+        {
+            if ( m_iter == m_list->begin() )
+                return compatibility_iterator();
+
+            iterator i = m_iter;
+            return compatibility_iterator( m_list, --i );
+        }
+
+        int IndexOf() const
+        {
+            return *this ? std::distance( m_list->begin(), m_iter )
+                : wxNOT_FOUND;
+        }
+    };
+
+public:
+    wxDList() : m_destroy( false ) {}
+
+    ~wxDList() { Clear(); }
+
+    compatibility_iterator Find( const T* e ) const
+    {
+        return compatibility_iterator( this,
+                std::find( const_cast<ListType*>(this)->begin(),
+                           const_cast<ListType*>(this)->end(), e ) );
+    }
+
+    bool IsEmpty() const
+        { return this->empty(); }
+    size_t GetCount() const
+        { return this->size(); }
+
+    compatibility_iterator Item( size_t idx ) const
+    {
+        iterator i = const_cast<ListType*>(this)->begin();
+        std::advance( i, idx );
+        return compatibility_iterator( this, i );
+    }
+
+    T* operator[](size_t idx) const
+    {
+        return Item(idx).GetData();
+    }
+
+    compatibility_iterator GetFirst() const
+    {
+        return compatibility_iterator( this, const_cast<ListType*>(this)->begin() );
+    }
+    compatibility_iterator GetLast() const
+    {
+        iterator i = const_cast<ListType*>(this)->end();
+        return compatibility_iterator( this, !(this->empty()) ? --i : i );
+    }
+    compatibility_iterator Member( T* e ) const
+        { return Find( e ); }
+    compatibility_iterator Nth( int n ) const
+        { return Item( n ); }
+    int IndexOf( T* e ) const
+        { return Find( e ).IndexOf(); }
+
+    compatibility_iterator Append( T* e )
+    {
+        this->push_back( e );
+        return GetLast();
+    }
+
+    compatibility_iterator Insert( T* e )
+    {
+        this->push_front( e );
+        return compatibility_iterator( this, this->begin() );
+    }
+
+    compatibility_iterator Insert( compatibility_iterator & i, T* e )
+    {
+        return compatibility_iterator( this, this->insert( i.m_iter, e ) );
+    }
+
+    compatibility_iterator Insert( size_t idx, T* e )
+    {
+        return compatibility_iterator( this,
+                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 )
+            delete i->GetData();
+        this->erase( i.m_iter );
+    }
+
+    bool DeleteNode( const compatibility_iterator& i )
+    {
+        if( i )
+        {
+            Erase( i );
+            return true;
+        }
+        return false;
+    }
+
+    bool DeleteObject( T* e )
+    {
+        return DeleteNode( Find( e ) );
+    }
+
+    void Clear()
+    {
+        if ( m_destroy )
+        {
+            iterator it, en;
+            for ( it = this->begin(), en = this->end(); it != en; ++it )
+                delete *it;
+        }
+        this->clear();
+    }
 };
 
 #else  // STL
-                                                                            
-template<typename T>
+
+template <typename T>
 class wxDList
 {
-public:      
+public:
     class Node
     {
-    friend class wxDList<T>;
     public:
-        Node( wxDList<T> *list = NULL, Node *previous = NULL, Node *next = NULL, T *data = NULL )
+        Node(wxDList<T> *list = NULL,
+             Node *previous = NULL,
+             Node *next = NULL,
+             T *data = NULL)
         {
             m_list = list;
             m_previous = previous;
@@ -213,54 +226,57 @@ public:
         ~Node()
         {
             // handle the case when we're being deleted from the list by
-            // the user (i.e. not by the list itself from DeleteNode) - 
+            // the user (i.e. not by the list itself from DeleteNode) -
             // we must do it for compatibility with old code
             if (m_list != NULL)
                 m_list->DetachNode(this);
         }
-        
+
         void DeleteData()
         {
             delete m_data;
         }
-        
+
         Node *GetNext() const      { return m_next; }
         Node *GetPrevious() const  { return m_previous; }
         T *GetData() const         { return m_data; }
         T **GetDataPtr() const     { return &(wx_const_cast(nodetype*,this)->m_data); }
         void SetData( T *data )    { m_data = data; }
-        
+
         int IndexOf() const
         {
-            wxCHECK_MSG( m_list, wxNOT_FOUND, wxT("node doesn't belong to a list in IndexOf"));
-            
+            wxCHECK_MSG( m_list, wxNOT_FOUND,
+                         "node doesn't belong to a list in IndexOf" );
+
             int i;
             Node *prev = m_previous;
             for( i = 0; prev; i++ )
                 prev = prev->m_previous;
             return i;
         }
-        
+
     private:
         T           *m_data;        // user data
         Node        *m_next,        // next and previous nodes in the list
                     *m_previous;
         wxDList<T>   *m_list;         // list we belong to
+
+        friend class wxDList<T>;
     };
-    
+
     typedef Node nodetype;
-    
+
     class compatibility_iterator
     {
     public:
         compatibility_iterator(nodetype *ptr = NULL) : m_ptr(ptr) { }
         nodetype *operator->() const { return m_ptr; }
         operator nodetype *() const  { return m_ptr; }
+
     private:
         nodetype *m_ptr;
-    };                                                                  
-                
-    
+    };
+
 private:
     void Init()
     {
@@ -269,7 +285,7 @@ private:
         m_count = 0;
         m_destroy = false;
     }
-    
+
     void DoDeleteNode( nodetype *node )
     {
         if ( m_destroy )
@@ -283,20 +299,19 @@ private:
     bool m_destroy;             // destroy user data when deleting list items?
     nodetype *m_nodeFirst,      // pointers to the head and tail of the list
              *m_nodeLast;
-    
-    
-public:                                                            
+
+public:
     wxDList()
     {
         Init();
     }
-    
+
     wxDList( const wxDList<T>& list )
-    { 
+    {
         Init();
-        Assign(list); 
+        Assign(list);
     }
-     
+
     wxDList( size_t count, T *elements[] )
     {
         Init();
@@ -304,14 +319,14 @@ public:
         for (n = 0; n < count; n++)
             Append( elements[n] );
     }
-                                                                            
+
     wxDList& operator=( const wxDList<T>& list )
-    { 
-        if (&list != this) 
-            Assign(list); 
+    {
+        if (&list != this)
+            Assign(list);
         return *this;
     }
-    
+
     ~wxDList()
     {
         nodetype *each = m_nodeFirst;
@@ -322,11 +337,11 @@ public:
             each = next;
         }
     }
-    
+
     void Assign(const wxDList<T> &list)
     {
         wxASSERT_MSG( !list.m_destroy,
-                  wxT("copying list which owns it's elements is a bad idea") );
+                      "copying list which owns it's elements is a bad idea" );
         Clear();
         m_destroy = list.m_destroy;
         m_nodeFirst = NULL;
@@ -334,13 +349,13 @@ public:
         nodetype* node;
         for (node = list.GetFirst(); node; node = node->GetNext() )
             Append(node->GetData());
-        wxASSERT_MSG( m_count == list.m_count, wxT("logic error in Assign()") );
+        wxASSERT_MSG( m_count == list.m_count, "logic error in Assign()" );
     }
-    
+
     nodetype *Append( T *object )
     {
         nodetype *node = new nodetype( this, m_nodeLast, NULL, object );
-        
+
         if ( !m_nodeFirst )
         {
             m_nodeFirst = node;
@@ -354,11 +369,12 @@ public:
         m_count++;
         return node;
     }
-    
+
     nodetype *Insert( T* object )
-    { 
+    {
         return Insert( NULL, object );
     }
+
     nodetype *Insert( size_t pos, T* object )
     {
         if (pos == m_count)
@@ -366,11 +382,12 @@ public:
         else
             return Insert( Item(pos), object );
     }
+
     nodetype *Insert( nodetype *position, T* object )
     {
         wxCHECK_MSG( !position || position->m_list == this, NULL,
-                 wxT("can't insert before a node from another list") );
-                 
+                     "can't insert before a node from another list" );
+
         // previous and next node for the node being inserted
         nodetype *prev, *next;
         if ( position )
@@ -392,56 +409,37 @@ public:
         m_count++;
         return node;
     }
-   
-                                                                            
-    nodetype *GetFirst() const                                          
-    { 
-        return m_nodeFirst;
-    }
-    nodetype *GetLast() const
-    {
-        return m_nodeLast;
-    }
-    size_t GetCount() const
-    {
-        return m_count;
-    }
-    bool IsEmpty() const
-    {
-        return m_count == 0;
-    }
-    
-    void DeleteContents(bool destroy) 
-    { 
-        m_destroy = destroy;
-    }
-    bool GetDeleteContents() const
-    { 
-        return m_destroy;
-    }
-    
+
+    nodetype *GetFirst() const { return m_nodeFirst; }
+    nodetype *GetLast() const { return m_nodeLast; }
+    size_t GetCount() const { return m_count; }
+    bool IsEmpty() const { return m_count == 0; }
+
+    void DeleteContents(bool destroy) { m_destroy = destroy; }
+    bool GetDeleteContents() const { return m_destroy; }
+
     nodetype *Item(size_t index) const
-    { 
+    {
         for ( nodetype *current = GetFirst(); current; current = current->GetNext() )
         {
             if ( index-- == 0 )
                return current;
         }
-        wxFAIL_MSG( wxT("invalid index in Item()") );
+        wxFAIL_MSG( "invalid index in Item()" );
         return NULL;
     }
-                                                                            
-    T *operator[](size_t index) const                                   
-    {                                                                   
-        nodetype *node = Item(index);                                  
+
+    T *operator[](size_t index) const
+    {
+        nodetype *node = Item(index);
         return node ? node->GetData() : NULL;
     }
-                                                                            
+
     nodetype *DetachNode( nodetype *node )
     {
-        wxCHECK_MSG( node, NULL, wxT("detaching NULL wxNodeBase") );
+        wxCHECK_MSG( node, NULL, "detaching NULL wxNodeBase" );
         wxCHECK_MSG( node->m_list == this, NULL,
-                 wxT("detaching node which is not from this list") );
+                     "detaching node which is not from this list" );
         // update the list
         nodetype **prevNext = node->GetPrevious() ? &node->GetPrevious()->m_next
                                                   : &m_nodeFirst;
@@ -454,11 +452,12 @@ public:
         node->m_list = NULL;
         return node;
     }
-    
+
     void Erase( nodetype *node )
-    { 
+    {
          DeleteNode(node);
-    }                                             
+    }
+
     bool DeleteNode( nodetype *node )
     {
         if ( !DetachNode(node) )
@@ -466,7 +465,7 @@ public:
         DoDeleteNode(node);
         return true;
     }
-    
+
     bool DeleteObject( T *object )
     {
         for ( nodetype *current = GetFirst(); current; current = current->GetNext() )
@@ -480,7 +479,7 @@ public:
         // not found
         return false;
     }
-    
+
     nodetype *Find(const T *object) const
     {
         for ( nodetype *current = GetFirst(); current; current = current->GetNext() )
@@ -491,7 +490,7 @@ public:
         // not found
         return NULL;
     }
-                                                                            
+
     int IndexOf(const T *object) const
     {
         int n = 0;
@@ -503,7 +502,7 @@ public:
         }
         return wxNOT_FOUND;
     }
-    
+
     void Clear()
     {
         nodetype *current = m_nodeFirst;
@@ -534,9 +533,7 @@ public:
         // swap first and last node
         tmp = m_nodeFirst; m_nodeFirst = m_nodeLast; m_nodeLast = tmp;
     }
-    
-    
-    
+
     void DeleteNodes(nodetype* first, nodetype* last)
     {
         nodetype * node = first;
@@ -573,276 +570,281 @@ public:
         }
         return NULL;
     }
-    
-        /* STL interface */                                                 
-    public:                                                                 
-        typedef size_t size_type;                                           
-        typedef int difference_type;                                        
-        typedef T* value_type;                                              
-        typedef value_type& reference;                                      
-        typedef const value_type& const_reference;                          
-                                                                            
-        class iterator                                                   
-        {                                                                   
-        public:                                                             
-            typedef nodetype Node;                                          
-            typedef iterator itor;                                          
-            typedef T* value_type;                                          
-            typedef value_type* ptr_type;                                   
-            typedef value_type& reference;                                  
-                                                                            
-            Node* m_node;                                                   
-            Node* m_init;                                                   
-        public:                                                             
-            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 *m_node->GetDataPtr(); }             
-            // ptrop                                                           
-            itor& operator++() { m_node = m_node->GetNext(); return *this; }
-            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;                                               
-            }                                                               
-            const itor operator--(int)                                      
-            {                                                               
-                itor tmp = *this;                                           
-                m_node = m_node ? m_node->GetPrevious() : m_init;          
-                return tmp;                                                 
-            }                                                               
-            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                                             
-        {                                                                   
-        public:                                                             
-            typedef nodetype Node;                                          
-            typedef T* value_type;                                          
-            typedef const value_type& const_reference;                      
-            typedef const_iterator itor;                                    
-            typedef value_type* ptr_type;                                   
-                                                                            
-            Node* m_node;                                                   
-            Node* m_init;                                                   
-        public:                                                             
-            typedef const_reference reference_type;                         
-            typedef const ptr_type pointer_type;                            
-                                                                            
-            const_iterator(Node* node, Node* init)                          
-                : m_node(node), m_init(init) { }                            
-            const_iterator() : m_node(NULL), m_init(NULL) { }               
-            const_iterator(const iterator& it)                              
-                : m_node(it.m_node), m_init(it.m_init) { }                  
-            reference_type operator*() const                                
-                { return *m_node->GetDataPtr(); }             
-            // ptrop                                                           
-            itor& operator++() { m_node = m_node->GetNext(); return *this; }
-            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;                                               
-            }                                                               
-            const itor operator--(int)                                      
-            {                                                               
-                itor tmp = *this;                                           
-                m_node = m_node ? m_node->GetPrevious() : m_init;           
-                return tmp;                                                 
-            }                                                               
-            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                                           
-        {                                                                   
-        public:                                                             
-            typedef nodetype Node;                                          
-            typedef T* value_type;                                          
-            typedef reverse_iterator itor;                                 
-            typedef value_type* ptr_type;                                   
-            typedef value_type& reference;                                  
-                                                                            
-            Node* m_node;                                                   
-            Node* m_init;                                                   
-        public:                                                             
-            typedef reference reference_type;                              
-            typedef ptr_type pointer_type;                                  
-                                                                            
-            reverse_iterator(Node* node, Node* init)                        
-                : m_node(node), m_init(init) { }                            
-            reverse_iterator() : m_node(NULL), m_init(NULL) { }             
-            reference_type operator*() const                                
-                { return *m_node->GetDataPtr(); }             
-            // ptrop                                                           
-            itor& operator++()                                              
-                { m_node = m_node->GetPrevious(); return *this; }           
-            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; } 
-            const itor operator--(int)                                      
-            {                                                               
-                itor tmp = *this;                                           
-                m_node = m_node ? m_node->GetNext() : m_init;               
-                return tmp;                                                 
-            }                                                               
-            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                                     
-        {                                                                   
-        public:                                                             
-            typedef nodetype Node;                                          
-            typedef T* value_type;                                          
-            typedef const_reverse_iterator itor;                            
-            typedef value_type* ptr_type;                                   
-            typedef const value_type& const_reference;                      
-                                                                            
-            Node* m_node;                                                   
-            Node* m_init;                                                   
-        public:                                                             
-            typedef const_reference reference_type;                         
-            typedef const ptr_type pointer_type;                            
-                                                                            
-            const_reverse_iterator(Node* node, Node* init)                 
-                : m_node(node), m_init(init) { }                            
-            const_reverse_iterator() : m_node(NULL), m_init(NULL) { }       
-            const_reverse_iterator(const reverse_iterator& it)              
-                : m_node(it.m_node), m_init(it.m_init) { }                  
-            reference_type operator*() const                                
-                { return *m_node->GetDataPtr(); }             
-            // ptrop                                                           
-            itor& operator++()                                              
-                { m_node = m_node->GetPrevious(); return *this; }           
-            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;}
-            const itor operator--(int)                                      
-            {                                                              
-                itor tmp = *this;                                           
-                m_node = m_node ? m_node->GetNext() : m_init;               
-                return tmp;                                                 
-            }                                                               
-            bool operator!=(const itor& it) const                           
-                { return it.m_node != m_node; }                             
-            bool operator==(const itor& it) const                          
-                { return it.m_node == m_node; }                             
-        };                                                                  
-                                                                            
-        wxEXPLICIT wxDList(size_type n, const_reference v = value_type())      
-            { assign(n, v); }                                               
-        wxDList(const const_iterator& first, const const_iterator& last)       
-            { assign(first, last); }                                        
-        iterator begin() { return iterator(GetFirst(), GetLast()); }        
-        const_iterator begin() const                                        
-            { return const_iterator(GetFirst(), GetLast()); }               
-        iterator end() { return iterator(NULL, GetLast()); }                
-        const_iterator end() const { return const_iterator(NULL, GetLast()); }
-        reverse_iterator rbegin()                                           
-            { return reverse_iterator(GetLast(), GetFirst()); }             
-        const_reverse_iterator rbegin() const                               
-            { return const_reverse_iterator(GetLast(), GetFirst()); }       
-        reverse_iterator rend() { return reverse_iterator(NULL, GetFirst()); }
-        const_reverse_iterator rend() const                                 
-            { return const_reverse_iterator(NULL, GetFirst()); }            
-        void resize(size_type n, value_type v = value_type())               
-        {                                                                   
-            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(); }                  
-        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(), v); }               
-        void pop_front() { DeleteNode(GetFirst()); }                        
-        void push_back(const_reference v = value_type())                    
-            { Append( v ); }                            
-        void pop_back() { DeleteNode(GetLast()); }                          
-        void assign(const_iterator first, const const_iterator& last)       
-        {                                                                   
-            clear();                                                        
-            for(; first != last; ++first)                                   
-                Append(*first);                       
-        }                                                                   
-        void assign(size_type n, const_reference v = value_type())          
-        {                                                                   
-            clear();                                                        
-            for(size_type i = 0; i < n; ++i)                                
-                Append(v);                            
-        }                                                                   
-        iterator insert(const iterator& it, const_reference v = value_type())
-        {                                                                   
-            Insert(it.m_node,v);                     
-            iterator itprev(it);                                            
-            return itprev--;                                                
-        }                                                                   
-        void insert(const iterator& it, size_type n, const_reference v = value_type())
-        {                                                                   
-            for(size_type i = 0; i < n; ++i)                               
-                Insert(it.m_node, v);                 
-        }                                                                   
-        void insert(const iterator& it, const_iterator first, const const_iterator& last)
-        {                                                                   
-            for(; first != last; ++first)                                   
-                Insert(it.m_node, *first);            
-        }                                                                   
-        iterator erase(const iterator& it)                                  
-        {                                                                   
-            iterator next = iterator(it.m_node->GetNext(), GetLast());      
-            DeleteNode(it.m_node); return next;                             
-        }                                                                   
-        iterator erase(const iterator& first, const iterator& last)        
-        {                                                                   
-            iterator next = last; ++next;                                   
-            DeleteNodes(first.m_node, last.m_node);                         
-            return next;                                                    
-        }                                                                   
-        void clear() { Clear(); }                                           
-        void splice(const iterator& it, wxDList<T>& l, const iterator& first, const iterator& last)
-            { insert(it, first, last); l.erase(first, last); }              
-        void splice(const iterator& it, wxDList<T>& l)                            
-            { splice(it, l, l.begin(), l.end() ); }                         
-        void splice(const iterator& it, wxDList<T>& l, const iterator& first)     
-        {                                                                   
-            iterator tmp = first; ++tmp;                                    
-            if(it == first || it == tmp) return;                            
-            insert(it, *first);                                             
-            l.erase(first);                                                 
-        }                                                                  
-        void remove(const_reference v)                                      
-            { DeleteObject(v); }                      
-        void reverse()                                                      
-            { Reverse(); }                                                  
-     /* void swap(list<T>& l)                                                  
-        {                                                                  
-            { size_t t = m_count; m_count = l.m_count; l.m_count = t; }     
-            { bool t = m_destroy; m_destroy = l.m_destroy; l.m_destroy = t; }
-            { wxNodeBase* t = m_nodeFirst; m_nodeFirst = l.m_nodeFirst; l.m_nodeFirst = t; }
-            { wxNodeBase* t = m_nodeLast; m_nodeLast = l.m_nodeLast; l.m_nodeLast = t; }
-            { wxKeyType t = m_keyType; m_keyType = l.m_keyType; l.m_keyType = t; }
-        } */
+
+    /* STL interface */
+public:
+    typedef size_t size_type;
+    typedef int difference_type;
+    typedef T* value_type;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+
+    class iterator
+    {
+    public:
+        typedef nodetype Node;
+        typedef iterator itor;
+        typedef T* value_type;
+        typedef value_type* ptr_type;
+        typedef value_type& reference;
+
+        Node* m_node;
+        Node* m_init;
+    public:
+        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 *m_node->GetDataPtr(); }
+        // ptrop
+        itor& operator++() { m_node = m_node->GetNext(); return *this; }
+        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;
+        }
+        const itor operator--(int)
+        {
+            itor tmp = *this;
+            m_node = m_node ? m_node->GetPrevious() : m_init;
+            return tmp;
+        }
+        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
+    {
+    public:
+        typedef nodetype Node;
+        typedef T* value_type;
+        typedef const value_type& const_reference;
+        typedef const_iterator itor;
+        typedef value_type* ptr_type;
+
+        Node* m_node;
+        Node* m_init;
+    public:
+        typedef const_reference reference_type;
+        typedef const ptr_type pointer_type;
+
+        const_iterator(Node* node, Node* init)
+            : m_node(node), m_init(init) { }
+        const_iterator() : m_node(NULL), m_init(NULL) { }
+        const_iterator(const iterator& it)
+            : m_node(it.m_node), m_init(it.m_init) { }
+        reference_type operator*() const
+            { return *m_node->GetDataPtr(); }
+        // ptrop
+        itor& operator++() { m_node = m_node->GetNext(); return *this; }
+        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;
+        }
+        const itor operator--(int)
+        {
+            itor tmp = *this;
+            m_node = m_node ? m_node->GetPrevious() : m_init;
+            return tmp;
+        }
+        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
+    {
+    public:
+        typedef nodetype Node;
+        typedef T* value_type;
+        typedef reverse_iterator itor;
+        typedef value_type* ptr_type;
+        typedef value_type& reference;
+
+        Node* m_node;
+        Node* m_init;
+    public:
+        typedef reference reference_type;
+        typedef ptr_type pointer_type;
+
+        reverse_iterator(Node* node, Node* init)
+            : m_node(node), m_init(init) { }
+        reverse_iterator() : m_node(NULL), m_init(NULL) { }
+        reference_type operator*() const
+            { return *m_node->GetDataPtr(); }
+        // ptrop
+        itor& operator++()
+            { m_node = m_node->GetPrevious(); return *this; }
+        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; }
+        const itor operator--(int)
+        {
+            itor tmp = *this;
+            m_node = m_node ? m_node->GetNext() : m_init;
+            return tmp;
+        }
+        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
+    {
+    public:
+        typedef nodetype Node;
+        typedef T* value_type;
+        typedef const_reverse_iterator itor;
+        typedef value_type* ptr_type;
+        typedef const value_type& const_reference;
+
+        Node* m_node;
+        Node* m_init;
+    public:
+        typedef const_reference reference_type;
+        typedef const ptr_type pointer_type;
+
+        const_reverse_iterator(Node* node, Node* init)
+            : m_node(node), m_init(init) { }
+        const_reverse_iterator() : m_node(NULL), m_init(NULL) { }
+        const_reverse_iterator(const reverse_iterator& it)
+            : m_node(it.m_node), m_init(it.m_init) { }
+        reference_type operator*() const
+            { return *m_node->GetDataPtr(); }
+        // ptrop
+        itor& operator++()
+            { m_node = m_node->GetPrevious(); return *this; }
+        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;}
+        const itor operator--(int)
+        {
+            itor tmp = *this;
+            m_node = m_node ? m_node->GetNext() : m_init;
+            return tmp;
+        }
+        bool operator!=(const itor& it) const
+            { return it.m_node != m_node; }
+        bool operator==(const itor& it) const
+            { return it.m_node == m_node; }
+    };
+
+    wxEXPLICIT wxDList(size_type n, const_reference v = value_type())
+        { assign(n, v); }
+    wxDList(const const_iterator& first, const const_iterator& last)
+        { assign(first, last); }
+    iterator begin() { return iterator(GetFirst(), GetLast()); }
+    const_iterator begin() const
+        { return const_iterator(GetFirst(), GetLast()); }
+    iterator end() { return iterator(NULL, GetLast()); }
+    const_iterator end() const { return const_iterator(NULL, GetLast()); }
+    reverse_iterator rbegin()
+        { return reverse_iterator(GetLast(), GetFirst()); }
+    const_reverse_iterator rbegin() const
+        { return const_reverse_iterator(GetLast(), GetFirst()); }
+    reverse_iterator rend() { return reverse_iterator(NULL, GetFirst()); }
+    const_reverse_iterator rend() const
+        { return const_reverse_iterator(NULL, GetFirst()); }
+    void resize(size_type n, value_type v = value_type())
+    {
+        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(); }
+    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(), v); }
+    void pop_front() { DeleteNode(GetFirst()); }
+    void push_back(const_reference v = value_type())
+        { Append( v ); }
+    void pop_back() { DeleteNode(GetLast()); }
+    void assign(const_iterator first, const const_iterator& last)
+    {
+        clear();
+        for(; first != last; ++first)
+            Append(*first);
+    }
+    void assign(size_type n, const_reference v = value_type())
+    {
+        clear();
+        for(size_type i = 0; i < n; ++i)
+            Append(v);
+    }
+    iterator insert(const iterator& it, const_reference v)
+    {
+        if (it == end())
+            Append( v );
+        else
+            Insert(it.m_node,v);
+        iterator itprev(it);
+        return itprev--;
+    }
+    void insert(const iterator& it, size_type n, const_reference v)
+    {
+        for(size_type i = 0; i < n; ++i)
+            Insert(it.m_node, v);
+    }
+    void insert(const iterator& it, const_iterator first, const const_iterator& last)
+    {
+        for(; first != last; ++first)
+            Insert(it.m_node, *first);
+    }
+    iterator erase(const iterator& it)
+    {
+        iterator next = iterator(it.m_node->GetNext(), GetLast());
+        DeleteNode(it.m_node); return next;
+    }
+    iterator erase(const iterator& first, const iterator& last)
+    {
+        iterator next = last; ++next;
+        DeleteNodes(first.m_node, last.m_node);
+        return next;
+    }
+    void clear() { Clear(); }
+    void splice(const iterator& it, wxDList<T>& l, const iterator& first, const iterator& last)
+        { insert(it, first, last); l.erase(first, last); }
+    void splice(const iterator& it, wxDList<T>& l)
+        { splice(it, l, l.begin(), l.end() ); }
+    void splice(const iterator& it, wxDList<T>& l, const iterator& first)
+    {
+        iterator tmp = first; ++tmp;
+        if(it == first || it == tmp) return;
+        insert(it, *first);
+        l.erase(first);
+    }
+    void remove(const_reference v)
+        { DeleteObject(v); }
+    void reverse()
+        { Reverse(); }
+ /* void swap(list<T>& l)
+    {
+        { size_t t = m_count; m_count = l.m_count; l.m_count = t; }
+        { bool t = m_destroy; m_destroy = l.m_destroy; l.m_destroy = t; }
+        { wxNodeBase* t = m_nodeFirst; m_nodeFirst = l.m_nodeFirst; l.m_nodeFirst = t; }
+        { wxNodeBase* t = m_nodeLast; m_nodeLast = l.m_nodeLast; l.m_nodeLast = t; }
+        { wxKeyType t = m_keyType; m_keyType = l.m_keyType; l.m_keyType = t; }
+    } */
 };
 
-#endif
+#endif // wxUSE_STL/!wxUSE_STL
 
 #endif // _WX_DLIST_H_