Reworked the undef stuff a little

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

diff --git a/include/wx/list.h b/include/wx/list.h
index 8bd77c2d2f3f8b4864cdc0bf98d69633812e476c..01eddf8190c42140e75a4fbb582d68f4c9b78ccb 100644 (file)
--- a/include/wx/list.h
+++ b/include/wx/list.h
@@ -40,7 +40,7 @@
 
 // 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 char* copystring(const char *s);
+extern WXDLLEXPORT wxChar* copystring(const wxChar *s);

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


@@ -77,7 +77,7 @@ typedef int (*wxListIterateFunction)(void *current);
 union wxListKeyValue
 {
     long integer;
 union wxListKeyValue
 {
     long integer;

-    char *string;
+    wxChar *string;

 };
 
 // a struct which may contain both types of keys
 };
 
 // a struct which may contain both types of keys


@@ -94,14 +94,14 @@ public:
         { m_keyType = wxKEY_NONE; }
     wxListKey(long i)
         { m_keyType = wxKEY_INTEGER; m_key.integer = i; }
         { m_keyType = wxKEY_NONE; }
     wxListKey(long i)
         { m_keyType = wxKEY_INTEGER; m_key.integer = i; }

-    wxListKey(const char *s)
-        { m_keyType = wxKEY_STRING; m_key.string = strdup(s); }
+    wxListKey(const wxChar *s)
+        { m_keyType = wxKEY_STRING; m_key.string = wxStrdup(s); }

     wxListKey(const wxString& s)
     wxListKey(const wxString& s)

-        { m_keyType = wxKEY_STRING; m_key.string = strdup(s.c_str()); }
+        { 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; }

-    const char *GetString() const
+    const wxChar *GetString() const

         { wxASSERT( m_keyType == wxKEY_STRING ); return m_key.string; }
     long GetNumber() const
         { wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; }
         { wxASSERT( m_keyType == wxKEY_STRING ); return m_key.string; }
     long GetNumber() const
         { wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; }


@@ -142,12 +142,12 @@ public:
 
     virtual ~wxNodeBase();
 
 
     virtual ~wxNodeBase();
 

-    // @@ no check is done that the list is really keyed on strings
-    const char *GetKeyString() const { return m_key.string; }
+    // 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; }
 
     // Necessary for some existing code
     long GetKeyInteger() const { return m_key.integer; }
 
     // Necessary for some existing code

-    void SetKeyString(char* s) { m_key.string = s; }
+    void SetKeyString(wxChar* s) { m_key.string = s; }

     void SetKeyInteger(long i) { m_key.integer = i; }
 
 #ifdef wxLIST_COMPATIBILITY
     void SetKeyInteger(long i) { m_key.integer = i; }
 
 #ifdef wxLIST_COMPATIBILITY


@@ -272,7 +272,7 @@ protected:
 
         // keyed append
     wxNodeBase *Append(long key, void *object);
 
         // keyed append
     wxNodeBase *Append(long key, void *object);

-    wxNodeBase *Append(const char *key, void *object);
+    wxNodeBase *Append(const wxChar *key, void *object);

 
         // removes node from the list but doesn't delete it (returns pointer
         // to the node or NULL if it wasn't found in the list)
 
         // removes node from the list but doesn't delete it (returns pointer
         // to the node or NULL if it wasn't found in the list)


@@ -339,8 +339,16 @@ 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.
 //  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)                                \
+//
+//  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                          \
     typedef int (*wxSortFuncFor_##name)(const T *, const T *);              \
                                                                             \
     class WXDLLEXPORT nodetype : public wxNodeBase                          \


@@ -390,32 +398,32 @@ private:
             return node ? (T*)(node->GetData()) : (T*)NULL;                 \
         }                                                                   \
                                                                             \
             return node ? (T*)(node->GetData()) : (T*)NULL;                 \
         }                                                                   \
                                                                             \

-        nodetype *Append(T *object)                                         \
+        nodetype *Append(Tbase *object)                                     \

             { return (nodetype *)wxListBase::Append(object); }              \
             { return (nodetype *)wxListBase::Append(object); }              \

-        nodetype *Insert(T *object)                                         \
+        nodetype *Insert(Tbase *object)                                     \

             { return (nodetype *)Insert((nodetype*)NULL, object); }         \
             { return (nodetype *)Insert((nodetype*)NULL, object); }         \

-        nodetype *Insert(nodetype *prev, T *object)                         \
+        nodetype *Insert(nodetype *prev, Tbase *object)                     \

             { return (nodetype *)wxListBase::Insert(prev, object); }        \
                                                                             \
         nodetype *Append(long key, void *object)                            \
             { return (nodetype *)wxListBase::Append(key, object); }         \
             { return (nodetype *)wxListBase::Insert(prev, object); }        \
                                                                             \
         nodetype *Append(long key, void *object)                            \
             { return (nodetype *)wxListBase::Append(key, object); }         \

-        nodetype *Append(const char *key, void *object)                     \
+        nodetype *Append(const wxChar *key, void *object)                   \

             { return (nodetype *)wxListBase::Append(key, object); }         \
                                                                             \
         nodetype *DetachNode(nodetype *node)                                \
             { return (nodetype *)wxListBase::DetachNode(node); }            \
         bool DeleteNode(nodetype *node)                                     \
             { return wxListBase::DeleteNode(node); }                        \
             { return (nodetype *)wxListBase::Append(key, object); }         \
                                                                             \
         nodetype *DetachNode(nodetype *node)                                \
             { 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); }                    \
                                                                             \
             { 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); }                   \
                                                                             \
             { 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)                                \
             { return wxListBase::IndexOf(object); }                         \
                                                                             \
         void Sort(wxSortFuncFor_##name func)                                \


@@ -432,6 +440,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)
 #define WX_DECLARE_LIST(elementtype, listname)                              \
     typedef elementtype _WX_LIST_ITEM_TYPE_##listname;                      \
     WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node)


@@ -445,12 +456,9 @@ private:
 // =============================================================================
 
 // ----------------------------------------------------------------------------
 // =============================================================================
 
 // ----------------------------------------------------------------------------

-// commonly used string classes
+// commonly used list classes

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-class wxWindow;
-WX_DECLARE_LIST(wxWindow, wxWindowList);
-

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


@@ -474,7 +482,7 @@ public:
 // wxStringList class for compatibility with the old code
 // -----------------------------------------------------------------------------
 
 // wxStringList class for compatibility with the old code
 // -----------------------------------------------------------------------------
 

-WX_DECLARE_LIST_2(char, wxStringListBase, wxStringListNode);
+WX_DECLARE_LIST_2(wxChar, wxStringListBase, wxStringListNode);

 
 class WXDLLEXPORT wxStringList : public wxStringListBase
 {
 
 class WXDLLEXPORT wxStringList : public wxStringListBase
 {


@@ -482,7 +490,7 @@ public:
     // ctors and such
         // default
     wxStringList() { DeleteContents(TRUE); }
     // ctors and such
         // default
     wxStringList() { DeleteContents(TRUE); }

-    wxStringList(const char *first ...);
+    wxStringList(const wxChar *first ...);

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


@@ -492,13 +500,13 @@ public:
 
     // operations
         // makes a copy of the string
 
     // operations
         // makes a copy of the string

-    wxNode *Add(const char *s)
+    wxNode *Add(const wxChar *s)

         { return (wxNode *)wxStringListBase::Append(copystring(s)); }
 
         { return (wxNode *)wxStringListBase::Append(copystring(s)); }
 

-    bool Delete(const char *s);
+    bool Delete(const wxChar *s);

 
 

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

 
     // alphabetic sort
     void Sort();
 
     // alphabetic sort
     void Sort();