Provide NSAutoreleasePool instances during initialization

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

diff --git a/include/wx/list.h b/include/wx/list.h
index c7d31658c49aeebb16c9001e121ac62abc72e053..e3c8284fb63901bfffcea718848ce11b28a70a4e 100644 (file)
--- a/include/wx/list.h
+++ b/include/wx/list.h
@@ -6,7 +6,7 @@
 // Created:     29/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Julian Smart
 // Created:     29/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Julian Smart

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /*
 /////////////////////////////////////////////////////////////////////////////
 
 /*


@@ -25,7 +25,7 @@
 #ifndef _WX_LISTH__
 #define _WX_LISTH__
 
 #ifndef _WX_LISTH__
 #define _WX_LISTH__
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(__APPLE__)

 #pragma interface "list.h"
 #endif
 
 #pragma interface "list.h"
 #endif
 


@@ -34,15 +34,10 @@
 // -----------------------------------------------------------------------------
 
 #include "wx/defs.h"
 // -----------------------------------------------------------------------------
 
 #include "wx/defs.h"

-#include "wx/debug.h"

 #include "wx/object.h"
 #include "wx/string.h"
 
 #include "wx/object.h"
 #include "wx/string.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);
-
-class WXDLLEXPORT wxObjectListNode;
+class WXDLLIMPEXP_BASE wxObjectListNode;

 typedef wxObjectListNode wxNode;
 
 // undef it to get rid of old, deprecated functions
 typedef wxObjectListNode wxNode;
 
 // undef it to get rid of old, deprecated functions


@@ -65,10 +60,13 @@ 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
 // 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);
+extern "C"
+{
+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
 
 // -----------------------------------------------------------------------------
 // key stuff: a list may be optionally keyed on integer or string key


@@ -86,18 +84,18 @@ union wxListKeyValue
 // for any keyed operation instead of 2 almost equivalent. OTOH, it's needed to
 // resolve ambiguity which we would otherwise have with wxStringList::Find() and
 // wxList::Find(const char *).
 // for any keyed operation instead of 2 almost equivalent. OTOH, it's needed to
 // resolve ambiguity which we would otherwise have with wxStringList::Find() and
 // wxList::Find(const char *).

-class WXDLLEXPORT wxListKey
+class WXDLLIMPEXP_BASE wxListKey

 {
 public:
     // implicit ctors
 {
 public:
     // implicit ctors

-    wxListKey()
-        { m_keyType = wxKEY_NONE; }
-    wxListKey(long i)
-        { m_keyType = wxKEY_INTEGER; m_key.integer = i; }
-    wxListKey(const wxChar *s)
-        { m_keyType = wxKEY_STRING; m_key.string = wxStrdup(s); }
-    wxListKey(const wxString& s)
-        { m_keyType = wxKEY_STRING; m_key.string = wxStrdup(s.c_str()); }
+    wxListKey() : m_keyType(wxKEY_NONE)
+        { }
+    wxListKey(long i) : m_keyType(wxKEY_INTEGER)
+        { m_key.integer = i; }
+    wxListKey(const wxChar *s) : m_keyType(wxKEY_STRING)
+        { m_key.string = wxStrdup(s); }
+    wxListKey(const wxString& s) : m_keyType(wxKEY_STRING)
+        { m_key.string = wxStrdup(s.c_str()); }

 
     // accessors
     wxKeyType GetKeyType() const { return m_keyType; }
 
     // accessors
     wxKeyType GetKeyType() const { return m_keyType; }


@@ -127,9 +125,11 @@ private:
 // wxNodeBase class is a (base for) node in a double linked list
 // -----------------------------------------------------------------------------
 
 // wxNodeBase class is a (base for) node in a double linked list
 // -----------------------------------------------------------------------------
 

-WXDLLEXPORT_DATA(extern wxListKey) wxDefaultListKey;
+WXDLLIMPEXP_DATA_BASE(extern wxListKey) wxDefaultListKey;

 
 

-class WXDLLEXPORT wxNodeBase
+class WXDLLIMPEXP_BASE wxListBase;
+
+class WXDLLIMPEXP_BASE wxNodeBase

 {
 friend class wxListBase;
 public:
 {
 friend class wxListBase;
 public:


@@ -151,10 +151,10 @@ public:
     void SetKeyInteger(long i) { m_key.integer = i; }
 
 #ifdef wxLIST_COMPATIBILITY
     void SetKeyInteger(long i) { m_key.integer = i; }
 
 #ifdef wxLIST_COMPATIBILITY

-    // compatibility methods
-    wxNode *Next() const { return (wxNode *)GetNext(); }
-    wxNode *Previous() const { return (wxNode *)GetPrevious(); }
-    wxObject *Data() const { return (wxObject *)GetData(); }
+    // compatibility methods, use Get* instead.
+    wxDEPRECATED( wxNode *Next() const );
+    wxDEPRECATED( wxNode *Previous() const );
+    wxDEPRECATED( wxObject *Data() const );

 #endif // wxLIST_COMPATIBILITY
 
 protected:
 #endif // wxLIST_COMPATIBILITY
 
 protected:


@@ -179,23 +179,36 @@ private:
                 *m_previous;
 
     wxListBase  *m_list;        // list we belong to
                 *m_previous;
 
     wxListBase  *m_list;        // list we belong to

+
+    DECLARE_NO_COPY_CLASS(wxNodeBase)

 };
 
 // -----------------------------------------------------------------------------
 // a double-linked list class
 // -----------------------------------------------------------------------------
 };
 
 // -----------------------------------------------------------------------------
 // a double-linked list class
 // -----------------------------------------------------------------------------

-class WXDLLEXPORT wxListBase : public wxObject
+
+class wxList;
+
+class WXDLLIMPEXP_BASE wxListBase : public wxObject

 {
 {

-friend class wxNodeBase; // should be able to call DetachNode()
+friend class WXDLLIMPEXP_BASE wxNodeBase; // should be able to call DetachNode()
+friend class wxHashTableBase;   // should be able to call untyped Find()
+private:
+        // common part of all ctors
+    void Init(wxKeyType keyType = wxKEY_NONE); // Must be declared before it's used (for VC++ 1.5)

 public:
     // default ctor & dtor
 public:
     // default ctor & dtor

-    wxListBase(wxKeyType keyType = wxKEY_NONE) { Init(keyType); }
+    wxListBase(wxKeyType keyType = wxKEY_NONE)
+        { Init(keyType); }

     virtual ~wxListBase();
 
     // accessors
         // count of items in the list
     size_t GetCount() const { return m_count; }
 
     virtual ~wxListBase();
 
     // accessors
         // count of items in the list
     size_t GetCount() const { return m_count; }
 

+        // return TRUE if this list is empty
+    bool IsEmpty() const { return m_count == 0; }
+

     // operations
 
         // delete all nodes
     // operations
 
         // delete all nodes


@@ -217,10 +230,14 @@ public:
         { wxASSERT( m_count==0 ); m_keyType = keyType; }
 
 #ifdef wxLIST_COMPATIBILITY
         { wxASSERT( m_count==0 ); m_keyType = keyType; }
 
 #ifdef wxLIST_COMPATIBILITY

-    int Number() const { return GetCount(); }
-    wxNode *First() const { return (wxNode *)GetFirst(); }
-    wxNode *Last() const { return (wxNode *)GetLast(); }
-    wxNode *Nth(size_t index) const { return (wxNode *)Item(index); }
+    // compatibility methods from old wxList
+    wxDEPRECATED( int Number() const );             // use GetCount instead.
+    wxDEPRECATED( wxNode *First() const );          // use GetFirst
+    wxDEPRECATED( wxNode *Last() const );           // use GetLast
+    wxDEPRECATED( wxNode *Nth(size_t n) const );    // use Item
+
+    // kludge for typesafe list migration in core classes.
+    wxDEPRECATED( operator wxList&() const );

 #endif // wxLIST_COMPATIBILITY
 
 protected:
 #endif // wxLIST_COMPATIBILITY
 
 protected:


@@ -246,8 +263,8 @@ public:
 
 protected:
         // copy ctor and assignment operator
 
 protected:
         // copy ctor and assignment operator

-    wxListBase(const wxListBase& list)
-        { DoCopy(list); }
+    wxListBase(const wxListBase& list) : wxObject()
+        { Init(); DoCopy(list); }

     wxListBase& operator=(const wxListBase& list)
         { Clear(); DoCopy(list); return *this; }
 
     wxListBase& operator=(const wxListBase& list)
         { Clear(); DoCopy(list); return *this; }
 


@@ -259,14 +276,25 @@ protected:
     wxNodeBase *Item(size_t index) const;
 
         // get the list item's data
     wxNodeBase *Item(size_t index) const;
 
         // get the list item's data

-    void *operator[](size_t index) const
-        { wxNodeBase *node = Item(index); return node ? node->GetData() : (wxNodeBase*)NULL; }
+    void *operator[](size_t n) const
+    {
+        wxNodeBase *node = Item(n);
+
+        return node ? node->GetData() : (wxNodeBase *)NULL;
+    }

 
     // operations
         // append to end of list
 
     // operations
         // append to end of list

+    wxNodeBase *Prepend(void *object)
+        { return (wxNodeBase *)wxListBase::Insert(object); }
+        // append to beginning of list

     wxNodeBase *Append(void *object);
         // insert a new item at the beginning of the list
     wxNodeBase *Insert(void *object) { return Insert( (wxNodeBase*)NULL, object); }
     wxNodeBase *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);
 
         // insert before given node or at front of list if prev == NULL
     wxNodeBase *Insert(wxNodeBase *prev, void *object);
 


@@ -304,8 +332,6 @@ protected:
 
 private:
     // helpers
 
 private:
     // helpers

-        // common part of all ctors
-    void Init(wxKeyType keyType = wxKEY_NONE);

         // common part of copy ctor and assignment operator
     void DoCopy(const wxListBase& list);
         // common part of all Append()s
         // common part of copy ctor and assignment operator
     void DoCopy(const wxListBase& list);
         // common part of all Append()s


@@ -348,10 +374,10 @@ private:
 //     wxWindowBase pointers are put into the list, but wxWindow pointers are
 //     retrieved from it.
 
 //     wxWindowBase pointers are put into the list, but wxWindow pointers are
 //     retrieved from it.
 

-#define WX_DECLARE_LIST_3(T, Tbase, name, nodetype)                         \
+#define WX_DECLARE_LIST_3(T, Tbase, name, nodetype, classexp)               \

     typedef int (*wxSortFuncFor_##name)(const T **, const T **);            \
                                                                             \
     typedef int (*wxSortFuncFor_##name)(const T **, const T **);            \
                                                                             \

-    class WXDLLEXPORT nodetype : public wxNodeBase                          \
+    classexp nodetype : public wxNodeBase                                   \

     {                                                                       \
     public:                                                                 \
         nodetype(wxListBase *list = (wxListBase *)NULL,                     \
     {                                                                       \
     public:                                                                 \
         nodetype(wxListBase *list = (wxListBase *)NULL,                     \


@@ -374,7 +400,7 @@ private:
         virtual void DeleteData();                                          \
     };                                                                      \
                                                                             \
         virtual void DeleteData();                                          \
     };                                                                      \
                                                                             \

-    class WXDLLEXPORT name : public wxListBase                              \
+    classexp name : public wxListBase                                       \

     {                                                                       \
     public:                                                                 \
         typedef nodetype Node;                                              \
     {                                                                       \
     public:                                                                 \
         typedef nodetype Node;                                              \


@@ -384,6 +410,9 @@ private:
         name(size_t count, T *elements[])                                   \
             : wxListBase(count, (void **)elements) { }                      \
                                                                             \
         name(size_t count, T *elements[])                                   \
             : wxListBase(count, (void **)elements) { }                      \
                                                                             \

+        name& operator=(const name& list)                                   \
+            { (void) wxListBase::operator=(list); return *this; }           \
+                                                                            \

         nodetype *GetFirst() const                                          \
             { return (nodetype *)wxListBase::GetFirst(); }                  \
         nodetype *GetLast() const                                           \
         nodetype *GetFirst() const                                          \
             { return (nodetype *)wxListBase::GetFirst(); }                  \
         nodetype *GetLast() const                                           \


@@ -402,6 +431,8 @@ private:
             { return (nodetype *)wxListBase::Append(object); }              \
         nodetype *Insert(Tbase *object)                                     \
             { return (nodetype *)Insert((nodetype*)NULL, object); }         \
             { return (nodetype *)wxListBase::Append(object); }              \
         nodetype *Insert(Tbase *object)                                     \
             { return (nodetype *)Insert((nodetype*)NULL, 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 *Insert(nodetype *prev, Tbase *object)                     \
             { return (nodetype *)wxListBase::Insert(prev, object); }        \
                                                                             \


@@ -430,7 +461,7 @@ private:
             { wxListBase::Sort((wxSortCompareFunction)func); }              \
                                                                             \
     protected:                                                              \
             { wxListBase::Sort((wxSortCompareFunction)func); }              \
                                                                             \
     protected:                                                              \

-        wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,          \
+        virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,  \

                                void *data,                                  \
                                const wxListKey& key = wxDefaultListKey)     \
             {                                                               \
                                void *data,                                  \
                                const wxListKey& key = wxDefaultListKey)     \
             {                                                               \


@@ -440,17 +471,29 @@ private:
             }                                                               \
     }
 
             }                                                               \
     }
 

-#define WX_DECLARE_LIST_2(elementtype, listname, nodename)                  \
-    WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename)
+#define WX_DECLARE_LIST_2(elementtype, listname, nodename, classexp)        \
+    WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename, classexp)

 
 #define WX_DECLARE_LIST(elementtype, listname)                              \
     typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
 
 #define WX_DECLARE_LIST(elementtype, listname)                              \
     typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \

-    WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node)
+    WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class)
+
+#define WX_DECLARE_EXPORTED_LIST(elementtype, listname)                     \
+    typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
+    WX_DECLARE_LIST_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)

 
 // this macro must be inserted in your program after
 //      #include <wx/listimpl.cpp>
 #define WX_DEFINE_LIST(name)    "don't forget to include listimpl.cpp!"
 
 
 // this macro must be inserted in your program after
 //      #include <wx/listimpl.cpp>
 #define WX_DEFINE_LIST(name)    "don't forget to include listimpl.cpp!"
 

+#define WX_DEFINE_EXPORTED_LIST(name)      WX_DEFINE_LIST(name)
+#define WX_DEFINE_USER_EXPORTED_LIST(name) WX_DEFINE_LIST(name)
+
+

 // =============================================================================
 // now we can define classes 100% compatible with the old ones
 // =============================================================================
 // =============================================================================
 // now we can define classes 100% compatible with the old ones
 // =============================================================================


@@ -461,47 +504,70 @@ private:
 
 #ifdef wxLIST_COMPATIBILITY
 
 
 #ifdef wxLIST_COMPATIBILITY
 

+// 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);
+WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode, class WXDLLIMPEXP_BASE);

 
 

-class WXDLLEXPORT wxList : public wxObjectList
+class WXDLLIMPEXP_BASE wxList : public wxObjectList

 {
 public:
 {
 public:

-    wxList(int key_type = wxKEY_NONE) : wxObjectList((wxKeyType)key_type) { }
+#ifdef wxWARN_COMPAT_LIST_USE
+    wxDEPRECATED( wxList(int key_type = wxKEY_NONE) );
+#else
+    wxList(int key_type = wxKEY_NONE);
+#endif
+
+    // this destructor is required for Darwin
+   ~wxList() { }
+
+    wxList& operator=(const wxList& list)
+        { (void) wxListBase::operator=(list); return *this; }

 
     // compatibility methods
     void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }
 
     wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }
 
     // compatibility methods
     void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }
 
     wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }

+
+private:
+    DECLARE_DYNAMIC_CLASS(wxList)

 };
 
 // -----------------------------------------------------------------------------
 // wxStringList class for compatibility with the old code
 // -----------------------------------------------------------------------------
 
 };
 
 // -----------------------------------------------------------------------------
 // wxStringList class for compatibility with the old code
 // -----------------------------------------------------------------------------
 

-WX_DECLARE_LIST_2(wxChar, wxStringListBase, wxStringListNode);
+WX_DECLARE_LIST_2(wxChar, wxStringListBase, wxStringListNode, class WXDLLIMPEXP_BASE);

 
 

-class WXDLLEXPORT wxStringList : public wxStringListBase
+class WXDLLIMPEXP_BASE wxStringList : public wxStringListBase

 {
 public:
     // ctors and such
         // default
 {
 public:
     // ctors and such
         // default

-    wxStringList() { DeleteContents(TRUE); }
+#ifdef wxWARN_COMPAT_LIST_USE
+    wxDEPRECATED( wxStringList() );
+    wxDEPRECATED( wxStringList(const wxChar *first ...) );
+#else
+    wxStringList();

     wxStringList(const wxChar *first ...);
     wxStringList(const wxChar *first ...);

+#endif

 
         // copying the string list: the strings are copied, too (extremely
         // inefficient!)
 
         // copying the string list: the strings are copied, too (extremely
         // inefficient!)

-    wxStringList(const wxStringList& other) { DoCopy(other); }
+    wxStringList(const wxStringList& other) : wxStringListBase() { DeleteContents(TRUE); DoCopy(other); }

     wxStringList& operator=(const wxStringList& other)
         { Clear(); DoCopy(other); return *this; }
 
     // operations
         // makes a copy of the string
     wxStringList& operator=(const wxStringList& other)
         { Clear(); DoCopy(other); return *this; }
 
     // operations
         // makes a copy of the string

-    wxNode *Add(const wxChar *s)
-        { return (wxNode *)wxStringListBase::Append(copystring(s)); }
+    wxNode *Add(const wxChar *s);
+        
+        // Append to beginning of list
+    wxNode *Prepend(const wxChar *s);

 
     bool Delete(const wxChar *s);
 
 
     bool Delete(const wxChar *s);
 


@@ -513,6 +579,8 @@ public:
 
 private:
     void DoCopy(const wxStringList&); // common part of copy ctor and operator=
 
 private:
     void DoCopy(const wxStringList&); // common part of copy ctor and operator=

+
+    DECLARE_DYNAMIC_CLASS(wxStringList)

 };
 
 #endif // wxLIST_COMPATIBILITY
 };
 
 #endif // wxLIST_COMPATIBILITY