Insure suitable choices of path/drive separator on OS/2.

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

diff --git a/include/wx/list.h b/include/wx/list.h
index 247b602e34e72b1b4cfa3d6859c3b0e3b42cd8bc..2312ea49082a20e5a4faab5767639a0d8eeb0344 100644 (file)
--- a/include/wx/list.h
+++ b/include/wx/list.h
@@ -25,7 +25,7 @@
 #ifndef _WX_LISTH__
 #define _WX_LISTH__
 
 #ifndef _WX_LISTH__
 #define _WX_LISTH__
 

-#if defined(__GNUG__) && !defined(__APPLE__) && \
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && \

     !(defined(__MINGW32__) && __GNUC__ == 3 && __GNUC_MINOR__ == 2)
 #pragma interface "list.h"
 #endif
     !(defined(__MINGW32__) && __GNUC__ == 3 && __GNUC_MINOR__ == 2)
 #pragma interface "list.h"
 #endif


@@ -42,9 +42,6 @@
     #include "wx/beforestd.h"
     #include <list>
     #include "wx/afterstd.h"
     #include "wx/beforestd.h"
     #include <list>
     #include "wx/afterstd.h"

-    #if defined(__WXMSW__) && defined(__MINGW32__)
-        #include "wx/msw/winundef.h"
-    #endif

 #endif
 
 // ----------------------------------------------------------------------------
 #endif
 
 // ----------------------------------------------------------------------------


@@ -87,12 +84,16 @@ enum wxKeyType
 #define wxLIST_COMPATIBILITY
 
 #define WX_DECLARE_LIST_3(elT, dummy1, liT, dummy2, decl) \
 #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)
 
 #define WX_DECLARE_LIST_XO(elT, liT, decl) \
     WX_DECLARE_LIST_XO(elT*, liT, decl)
 
 #define WX_DECLARE_LIST_XO(elT, liT, decl) \


@@ -118,6 +119,10 @@ enum wxKeyType
             compatibility_iterator() : m_list( NULL ) { }                     \
             dummy* operator->() { return (dummy*)this; }                      \
             const dummy* operator->() const { return (const dummy*)this; }    \
             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;                          \
                                                                               \
         };                                                                    \
         typedef struct compatibility_iterator citer;                          \
                                                                               \


@@ -141,7 +146,7 @@ enum wxKeyType
             {                                                                 \
                 citer* i = (citer*)this;                                      \
                 it lit = i->m_iter;                                           \
             {                                                                 \
                 citer* i = (citer*)this;                                      \
                 it lit = i->m_iter;                                           \

-                return citer( i->m_list, ++lit );                             \
+                return citer( i->m_list, --lit );                             \

             }                                                                 \
             void SetData( elT e )                                             \
             {                                                                 \
             }                                                                 \
             void SetData( elT e )                                             \
             {                                                                 \


@@ -210,13 +215,19 @@ enum wxKeyType
     }
 
 #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 WXDLLEXPORT)
+#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
 //      #include <wx/listimpl.cpp>
 
 // this macro must be inserted in your program after
 //      #include <wx/listimpl.cpp>


@@ -229,7 +240,9 @@ enum wxKeyType
 
 // due to circular header dependencies this function has to be declared here
 // (normally it's found in utils.h which includes itself list.h...)
 
 // due to circular header dependencies this function has to be declared here
 // (normally it's found in utils.h which includes itself list.h...)

-extern WXDLLEXPORT wxChar* copystring(const wxChar *s);
+#if WXWIN_COMPATIBILITY_2_4
+extern WXDLLIMPEXP_BASE wxChar* copystring(const wxChar *s);
+#endif

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


@@ -548,8 +561,14 @@ 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                                   \
     typedef int (*wxSortFuncFor_##name)(const T **, const T **);            \
                                                                             \
     classexp nodetype : public wxNodeBase                                   \


@@ -573,6 +592,8 @@ private:
             { wxNodeBase::SetData(data); }                                  \
                                                                             \
         virtual void DeleteData();                                          \
             { wxNodeBase::SetData(data); }                                  \
                                                                             \
         virtual void DeleteData();                                          \

+                                                                            \
+        DECLARE_NO_COPY_CLASS(nodetype)                                     \

     };                                                                      \
                                                                             \
     classexp name : public wxListBase                                       \
     };                                                                      \
                                                                             \
     classexp name : public wxListBase                                       \


@@ -678,8 +699,7 @@ private:
             iterator() : m_node(NULL), m_init(NULL) { }                     \
             reference_type operator*() const                                \
                 { return *(pointer_type)m_node->GetDataPtr(); }             \
             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++(int)                                            \
                 { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
             itor& operator++() { m_node = m_node->GetNext(); return *this; }\
             itor operator++(int)                                            \
                 { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\


@@ -722,8 +742,7 @@ 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++(int)                                            \
                 { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
             itor& operator++() { m_node = m_node->GetNext(); return *this; }\
             itor operator++(int)                                            \
                 { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\


@@ -764,8 +783,7 @@ 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++(int)                                            \
             itor& operator++()                                              \
                 { m_node = m_node->GetPrevious(); return *this; }           \
             itor operator++(int)                                            \


@@ -806,8 +824,7 @@ 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++(int)                                            \
             itor& operator++()                                              \
                 { m_node = m_node->GetPrevious(); return *this; }           \
             itor operator++(int)                                            \


@@ -844,10 +861,10 @@ 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; }                      \
         }                                                                   \
         size_type size() const { return GetCount(); }                       \
         size_type max_size() const { return INT_MAX; }                      \


@@ -926,20 +943,45 @@ 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 WXDLLEXPORT)
+
+#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 WXDLLEXPORT)

 
 #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
 //      #include <wx/listimpl.cpp>
 
 // this macro must be inserted in your program after
 //      #include <wx/listimpl.cpp>


@@ -950,29 +992,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


@@ -1012,7 +1081,7 @@ public:
     // ctors and such
         // default
 #ifdef wxWARN_COMPAT_LIST_USE
     // ctors and such
         // default
 #ifdef wxWARN_COMPAT_LIST_USE

-    wxDEPRECATED( wxStringList() );
+    wxStringList();

     wxDEPRECATED( wxStringList(const wxChar *first ...) );
 #else
     wxStringList();
     wxDEPRECATED( wxStringList(const wxChar *first ...) );
 #else
     wxStringList();


@@ -1053,6 +1122,20 @@ WX_DECLARE_LIST_XO(wxString, wxStringListBase, class WXDLLEXPORT);
 class WXDLLEXPORT wxStringList : public wxStringListBase
 {
 public:
 class WXDLLEXPORT wxStringList : public wxStringListBase
 {
 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