Unicode definitions for glibc, etc.

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

diff --git a/include/wx/list.h b/include/wx/list.h
index 696162ab4400a75e5048d57fdc2e3ecea54cff17..8bd77c2d2f3f8b4864cdc0bf98d69633812e476c 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 license

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


@@ -127,6 +127,8 @@ 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;
+

 class WXDLLEXPORT wxNodeBase
 {
 friend class wxListBase;
 class WXDLLEXPORT wxNodeBase
 {
 friend class wxListBase;


@@ -136,7 +138,7 @@ public:
                wxNodeBase *previous = (wxNodeBase *)NULL,
                wxNodeBase *next = (wxNodeBase *)NULL,
                void *data = NULL,
                wxNodeBase *previous = (wxNodeBase *)NULL,
                wxNodeBase *next = (wxNodeBase *)NULL,
                void *data = NULL,

-               const wxListKey& key = wxListKey());
+               const wxListKey& key = wxDefaultListKey);

 
     virtual ~wxNodeBase();
 
 
     virtual ~wxNodeBase();
 


@@ -144,6 +146,10 @@ public:
     const char *GetKeyString() const { return m_key.string; }
     long GetKeyInteger() const { return m_key.integer; }
 
     const char *GetKeyString() const { return m_key.string; }
     long GetKeyInteger() const { return m_key.integer; }
 

+    // Necessary for some existing code
+    void SetKeyString(char* s) { m_key.string = s; }
+    void SetKeyInteger(long i) { m_key.integer = i; }
+

 #ifdef wxLIST_COMPATIBILITY
     // compatibility methods
     wxNode *Next() const { return (wxNode *)GetNext(); }
 #ifdef wxLIST_COMPATIBILITY
     // compatibility methods
     wxNode *Next() const { return (wxNode *)GetNext(); }


@@ -159,6 +165,9 @@ protected:
     void *GetData() const { return m_data; }
     void SetData(void *data) { m_data = data; }
 
     void *GetData() const { return m_data; }
     void SetData(void *data) { m_data = data; }
 

+    // get 0-based index of this node within the list or wxNOT_FOUND
+    int IndexOf() const;
+

     virtual void DeleteData() { }
 
 private:
     virtual void DeleteData() { }
 
 private:


@@ -188,19 +197,46 @@ public:
     size_t GetCount() const { return m_count; }
 
     // operations
     size_t GetCount() const { return m_count; }
 
     // operations

+

         // delete all nodes
     void Clear();
         // delete all nodes
     void Clear();

+

         // instruct it to destroy user data when deleting nodes
     void DeleteContents(bool destroy) { m_destroy = destroy; }
 
         // instruct it to destroy user data when deleting nodes
     void DeleteContents(bool destroy) { m_destroy = destroy; }
 

+       // query if to delete
+    bool GetDeleteContents() const
+        { return m_destroy; }
+
+      // get the keytype
+    wxKeyType GetKeyType() const
+        { return m_keyType; }
+
+      // set the keytype (required by the serial code)
+    void SetKeyType(wxKeyType keyType)
+        { 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); }
+#endif // wxLIST_COMPATIBILITY
+

 protected:
 protected:

+

     // all methods here are "overloaded" in derived classes to provide compile
     // time type checking
 
     // create a node for the list of this type
     virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,
                                    void *data,
     // all methods here are "overloaded" in derived classes to provide compile
     // time type checking
 
     // create a node for the list of this type
     virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,
                                    void *data,

-                                   const wxListKey& key = wxListKey()) = 0;
+                                   const wxListKey& key = wxDefaultListKey) = 0;
+
+// Can't access these from derived classes otherwise (bug in Salford C++?)
+#ifdef __SALFORDC__
+public:
+#endif

 
     // ctors
         // from an array
 
     // ctors
         // from an array


@@ -208,6 +244,7 @@ protected:
         // from a sequence of objects
     wxListBase(void *object, ... /* terminate with NULL */);
 
         // from a sequence of objects
     wxListBase(void *object, ... /* terminate with NULL */);
 

+protected:

         // copy ctor and assignment operator
     wxListBase(const wxListBase& list)
         { DoCopy(list); }
         // copy ctor and assignment operator
     wxListBase(const wxListBase& list)
         { DoCopy(list); }


@@ -244,7 +281,7 @@ protected:
     bool DeleteNode(wxNodeBase *node);
         // finds object pointer and deletes node (and object if DeleteContents
         // is on), returns FALSE if object not found
     bool DeleteNode(wxNodeBase *node);
         // finds object pointer and deletes node (and object if DeleteContents
         // is on), returns FALSE if object not found

-    bool DeleteObject(void *object);  
+    bool DeleteObject(void *object);

 
     // search (all return NULL if item not found)
         // by data
 
     // search (all return NULL if item not found)
         // by data


@@ -253,6 +290,9 @@ protected:
         // by key
     wxNodeBase *Find(const wxListKey& key) const;
 
         // by key
     wxNodeBase *Find(const wxListKey& key) const;
 

+    // get 0-based index of object or wxNOT_FOUND
+    int IndexOf( void *object ) const;
+

     // this function allows the sorting of arbitrary lists by giving
     // a function to compare two list elements. The list is sorted in place.
     void Sort(const wxSortCompareFunction compfunc);
     // this function allows the sorting of arbitrary lists by giving
     // a function to compare two list elements. The list is sorted in place.
     void Sort(const wxSortCompareFunction compfunc);


@@ -265,7 +305,7 @@ protected:
 private:
     // helpers
         // common part of all ctors
 private:
     // helpers
         // common part of all ctors

-    void Init(wxKeyType keyType);
+    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


@@ -289,15 +329,15 @@ private:
 
 // declare a list type named 'name' and containing elements of type 'T *'
 // (as a by product of macro expansion you also get wx##name##Node
 
 // declare a list type named 'name' and containing elements of type 'T *'
 // (as a by product of macro expansion you also get wx##name##Node

-// wxNode-dervied type)
+// wxNode-derived type)

 //
 // implementation details:
 //
 // implementation details:

-//  1. we define _WX_LIST_ITEM_TYPE_##name typedef to save in it the item type
+//  1. We define _WX_LIST_ITEM_TYPE_##name typedef to save in it the item type

 //     for the list of given type - this allows us to pass only the list name
 //     to WX_DEFINE_LIST() even if it needs both the name and the type
 //
 //     for the list of given type - this allows us to pass only the list name
 //     to WX_DEFINE_LIST() even if it needs both the name and the type
 //

-//  2. We redefine all not type-safe wxList functions withtype-safe versions
-//     which don't take any place (everything is inline), but bring compile
+//  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)                                \
 //     time error checking.
 
 #define WX_DECLARE_LIST_2(T, name, nodetype)                                \


@@ -310,7 +350,7 @@ private:
                  nodetype *previous = (nodetype *)NULL,                     \
                  nodetype *next = (nodetype *)NULL,                         \
                  T *data = (T *)NULL,                                       \
                  nodetype *previous = (nodetype *)NULL,                     \
                  nodetype *next = (nodetype *)NULL,                         \
                  T *data = (T *)NULL,                                       \

-                 const wxListKey& key = wxListKey())                        \
+                 const wxListKey& key = wxDefaultListKey)                   \

             : wxNodeBase(list, previous, next, data, key) { }               \
                                                                             \
         nodetype *GetNext() const                                           \
             : wxNodeBase(list, previous, next, data, key) { }               \
                                                                             \
         nodetype *GetNext() const                                           \


@@ -326,9 +366,11 @@ private:
         virtual void DeleteData();                                          \
     };                                                                      \
                                                                             \
         virtual void DeleteData();                                          \
     };                                                                      \
                                                                             \

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

     {                                                                       \
     public:                                                                 \
     {                                                                       \
     public:                                                                 \

+        typedef nodetype Node;                                              \
+                                                                            \

         name(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType)          \
             { }                                                             \
         name(size_t count, T *elements[])                                   \
         name(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType)          \
             { }                                                             \
         name(size_t count, T *elements[])                                   \


@@ -373,13 +415,16 @@ private:
         virtual nodetype *Find(const wxListKey& key) const                  \
             { return (nodetype *)wxListBase::Find(key); }                   \
                                                                             \
         virtual nodetype *Find(const wxListKey& key) const                  \
             { return (nodetype *)wxListBase::Find(key); }                   \
                                                                             \

+        int IndexOf( T *object ) const                                      \
+            { return wxListBase::IndexOf(object); }                         \
+                                                                            \

         void Sort(wxSortFuncFor_##name func)                                \
             { wxListBase::Sort((wxSortCompareFunction)func); }              \
                                                                             \
     protected:                                                              \
         wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,          \
                                void *data,                                  \
         void Sort(wxSortFuncFor_##name func)                                \
             { wxListBase::Sort((wxSortCompareFunction)func); }              \
                                                                             \
     protected:                                                              \
         wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,          \
                                void *data,                                  \

-                               const wxListKey& key = wxListKey())          \
+                               const wxListKey& key = wxDefaultListKey)     \

             {                                                               \
                 return new nodetype(this,                                   \
                                     (nodetype *)prev, (nodetype *)next,     \
             {                                                               \
                 return new nodetype(this,                                   \
                                     (nodetype *)prev, (nodetype *)next,     \


@@ -395,11 +440,17 @@ private:
 //      #include <wx/listimpl.cpp>
 #define WX_DEFINE_LIST(name)    "don't forget to include listimpl.cpp!"
 
 //      #include <wx/listimpl.cpp>
 #define WX_DEFINE_LIST(name)    "don't forget to include listimpl.cpp!"
 

-

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

+// ----------------------------------------------------------------------------
+// commonly used string classes
+// ----------------------------------------------------------------------------
+
+class wxWindow;
+WX_DECLARE_LIST(wxWindow, wxWindowList);
+

 #ifdef wxLIST_COMPATIBILITY
 
 // -----------------------------------------------------------------------------
 #ifdef wxLIST_COMPATIBILITY
 
 // -----------------------------------------------------------------------------


@@ -416,17 +467,13 @@ public:
     // compatibility methods
     void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }
 
     // compatibility methods
     void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }
 

-    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); }

     wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }
 };
 
 // -----------------------------------------------------------------------------
 // wxStringList class for compatibility with the old code
 // -----------------------------------------------------------------------------
     wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }
 };
 
 // -----------------------------------------------------------------------------
 // wxStringList class for compatibility with the old code
 // -----------------------------------------------------------------------------

-    
+

 WX_DECLARE_LIST_2(char, wxStringListBase, wxStringListNode);
 
 class WXDLLEXPORT wxStringList : public wxStringListBase
 WX_DECLARE_LIST_2(char, wxStringListBase, wxStringListNode);
 
 class WXDLLEXPORT wxStringList : public wxStringListBase


@@ -448,8 +495,7 @@ public:
     wxNode *Add(const char *s)
         { return (wxNode *)wxStringListBase::Append(copystring(s)); }
 
     wxNode *Add(const char *s)
         { return (wxNode *)wxStringListBase::Append(copystring(s)); }
 

-    void Delete(const char *s)
-        { wxStringListBase::DeleteObject((char *)s); }
+    bool Delete(const char *s);

 
     char **ListToArray(bool new_copies = FALSE) const;
     bool Member(const char *s) const;
 
     char **ListToArray(bool new_copies = FALSE) const;
     bool Member(const char *s) const;


@@ -457,12 +503,6 @@ public:
     // alphabetic sort
     void Sort();
 
     // alphabetic sort
     void Sort();
 

-    // compatibility methods
-    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); }
-

 private:
     void DoCopy(const wxStringList&); // common part of copy ctor and operator=
 };
 private:
     void DoCopy(const wxStringList&); // common part of copy ctor and operator=
 };