1. wxProcess changes to make capturing subprocess output easier (and more

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

diff --git a/include/wx/list.h b/include/wx/list.h
index dc28a480fe958376c33b80d0b043428cbc0ee15d..f42942f4420b4072ee0dcc6332833fd52ed76602 100644 (file)
--- a/include/wx/list.h
+++ b/include/wx/list.h
@@ -65,10 +65,10 @@ enum wxKeyType
 // type of compare function for list sort operation (as in 'qsort'): it should
 // return a negative value, 0 or positive value if the first element is less
 // than, equal or greater than the second
-typedef int (*wxSortCompareFunction)(const void *elem1, const void *elem2);
+typedef int (* LINKAGEMODE wxSortCompareFunction)(const void *elem1, const void *elem2);
 
 //
-typedef int (*wxListIterateFunction)(void *current);
+typedef int (* LINKAGEMODE wxListIterateFunction)(void *current);
 
 // -----------------------------------------------------------------------------
 // key stuff: a list may be optionally keyed on integer or string key
@@ -142,7 +142,7 @@ public:
 
     virtual ~wxNodeBase();
 
-    // @@ no check is done that the list is really keyed on strings
+    // FIXME no check is done that the list is really keyed on strings
     const wxChar *GetKeyString() const { return m_key.string; }
     long GetKeyInteger() const { return m_key.integer; }
 
@@ -186,7 +186,8 @@ private:
 // -----------------------------------------------------------------------------
 class WXDLLEXPORT wxListBase : public wxObject
 {
-friend class wxNodeBase; // should be able to call DetachNode()
+friend class wxNodeBase;        // should be able to call DetachNode()
+friend class wxHashTableBase;   // should be able to call untyped Find()
 public:
     // default ctor & dtor
     wxListBase(wxKeyType keyType = wxKEY_NONE) { Init(keyType); }
@@ -267,6 +268,10 @@ protected:
     wxNodeBase *Append(void *object);
         // insert a new item at the beginning of the list
     wxNodeBase *Insert(void *object) { return Insert( (wxNodeBase*)NULL, object); }
+        // insert a new item at the given position
+    wxNodeBase *Insert(size_t pos, void *object)
+        { return pos == GetCount() ? Append(object)
+                                   : Insert(Item(pos), object); }
         // insert before given node or at front of list if prev == NULL
     wxNodeBase *Insert(wxNodeBase *prev, void *object);
 
@@ -339,9 +344,17 @@ private:
 //  2. We redefine all non-type-safe wxList functions with type-safe versions
 //     which don't take any space (everything is inline), but bring compile
 //     time error checking.
-
-#define WX_DECLARE_LIST_2(T, name, nodetype)                                \
-    typedef int (*wxSortFuncFor_##name)(const T *, const T *);              \
+//
+//  3. The macro which is usually used (WX_DECLARE_LIST) is defined in terms of
+//     a more generic WX_DECLARE_LIST_2 macro which, in turn, uses the most
+//     generic WX_DECLARE_LIST_3 one. The last macro adds a sometimes
+//     interesting capability to store polymorphic objects in the list and is
+//     particularly useful with, for example, "wxWindow *" list where the
+//     wxWindowBase pointers are put into the list, but wxWindow pointers are
+//     retrieved from it.
+
+#define WX_DECLARE_LIST_3(T, Tbase, name, nodetype)                         \
+    typedef int (*wxSortFuncFor_##name)(const T **, const T **);            \
                                                                             \
     class WXDLLEXPORT nodetype : public wxNodeBase                          \
     {                                                                       \
@@ -390,11 +403,13 @@ private:
             return node ? (T*)(node->GetData()) : (T*)NULL;                 \
         }                                                                   \
                                                                             \
-        nodetype *Append(T *object)                                         \
+        nodetype *Append(Tbase *object)                                     \
             { return (nodetype *)wxListBase::Append(object); }              \
-        nodetype *Insert(T *object)                                         \
+        nodetype *Insert(Tbase *object)                                     \
             { return (nodetype *)Insert((nodetype*)NULL, object); }         \
-        nodetype *Insert(nodetype *prev, T *object)                         \
+        nodetype *Insert(size_t pos, Tbase *object)                         \
+            { return (nodetype *)wxListBase::Insert(pos, object); }         \
+        nodetype *Insert(nodetype *prev, Tbase *object)                     \
             { return (nodetype *)wxListBase::Insert(prev, object); }        \
                                                                             \
         nodetype *Append(long key, void *object)                            \
@@ -406,16 +421,16 @@ private:
             { return (nodetype *)wxListBase::DetachNode(node); }            \
         bool DeleteNode(nodetype *node)                                     \
             { return wxListBase::DeleteNode(node); }                        \
-        bool DeleteObject(T *object)                                        \
+        bool DeleteObject(Tbase *object)                                    \
             { return wxListBase::DeleteObject(object); }                    \
                                                                             \
-        nodetype *Find(T *object) const                                     \
+        nodetype *Find(Tbase *object) const                                 \
             { return (nodetype *)wxListBase::Find(object); }                \
                                                                             \
         virtual nodetype *Find(const wxListKey& key) const                  \
             { return (nodetype *)wxListBase::Find(key); }                   \
                                                                             \
-        int IndexOf( T *object ) const                                      \
+        int IndexOf(Tbase *object) const                                    \
             { return wxListBase::IndexOf(object); }                         \
                                                                             \
         void Sort(wxSortFuncFor_##name func)                                \
@@ -432,6 +447,9 @@ private:
             }                                                               \
     }
 
+#define WX_DECLARE_LIST_2(elementtype, listname, nodename)                  \
+    WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename)
+
 #define WX_DECLARE_LIST(elementtype, listname)                              \
     typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
     WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node)
@@ -445,12 +463,9 @@ private:
 // =============================================================================
 
 // ----------------------------------------------------------------------------
-// commonly used string classes
+// commonly used list classes
 // ----------------------------------------------------------------------------
 
-class wxWindow;
-WX_DECLARE_LIST(wxWindow, wxWindowList);
-
 #ifdef wxLIST_COMPATIBILITY
 
 // -----------------------------------------------------------------------------