Corrected memory.cpp checkpoint bug; added Tex2RTF

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

diff --git a/include/wx/list.h b/include/wx/list.h
index afda75ffce59f10db2fbe25b5ce3a26c24d709c7..6e8cda59400bc4c161bdeebdf3737db4d0854d73 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

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


@@ -106,23 +106,10 @@ public:
     long GetNumber() const
         { wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; }
 
     long GetNumber() const
         { wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; }
 

-    // comparaison
-    bool operator==(wxListKeyValue value) const
-    {
-        switch ( m_keyType )
-        {
-            default:
-                wxFAIL_MSG("bad key type.");
-                // let compiler optimize the line above away in release build
-                // by not putting return here...
-
-            case wxKEY_STRING:
-                return strcmp(m_key.string, value.string) == 0;
-
-            case wxKEY_INTEGER:
-                return m_key.integer == value.integer;
-        }
-    }
+    // comparison
+    // Note: implementation moved to list.cpp to prevent BC++ inline
+    // expansion warning.
+    bool operator==(wxListKeyValue value) const ;

 
     // dtor
     ~wxListKey()
 
     // dtor
     ~wxListKey()


@@ -155,6 +142,11 @@ public:
 
     // @@ no check is done that the list is really keyed on strings
     const char *GetKeyString() const { return m_key.string; }
 
     // @@ no check is done that the list is really keyed on strings
     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
 
 #ifdef wxLIST_COMPATIBILITY
     // compatibility methods


@@ -171,6 +163,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 NOT_FOUND
+    int IndexOf() const;
+

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


@@ -200,11 +195,25 @@ public:
     size_t GetCount() const { return m_count; }
 
     // operations
     size_t GetCount() const { return m_count; }
 
     // operations

+    

         // delete all nodes
         // delete all nodes

-    virtual void Clear();
+    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; }
+

 protected:
     // all methods here are "overloaded" in derived classes to provide compile
     // time type checking
 protected:
     // all methods here are "overloaded" in derived classes to provide compile
     // time type checking


@@ -235,13 +244,13 @@ protected:
 
         // get the list item's data
     void *operator[](size_t index) const
 
         // get the list item's data
     void *operator[](size_t index) const

-        { wxNodeBase *node = Item(index); return node ? node->GetData() : NULL; }
+        { wxNodeBase *node = Item(index); return node ? node->GetData() : (wxNodeBase*)NULL; }

 
     // operations
         // append to end of list
     wxNodeBase *Append(void *object);
         // insert a new item at the beginning of the list
 
     // operations
         // append to end of list
     wxNodeBase *Append(void *object);
         // insert a new item at the beginning of the list

-    wxNodeBase *Insert(void *object) { return Insert(NULL, object); }
+    wxNodeBase *Insert(void *object) { return Insert( (wxNodeBase*)NULL, 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);
 


@@ -256,7 +265,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


@@ -265,19 +274,22 @@ protected:
         // by key
     wxNodeBase *Find(const wxListKey& key) const;
 
         // by key
     wxNodeBase *Find(const wxListKey& key) const;
 

+    // get 0-based index of object or NOT_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.
     // 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(wxSortCompareFunction compfunc);
+    void Sort(const wxSortCompareFunction compfunc);

 
     // functions for iterating over the list
     void *FirstThat(wxListIterateFunction func);
     void ForEach(wxListIterateFunction func);
     void *LastThat(wxListIterateFunction func);
 
     // functions for iterating over the list
     void *FirstThat(wxListIterateFunction func);
     void ForEach(wxListIterateFunction func);
     void *LastThat(wxListIterateFunction func);

-
+    

 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


@@ -363,7 +375,7 @@ private:
         nodetype *Append(T *object)                                         \
             { return (nodetype *)wxListBase::Append(object); }              \
         nodetype *Insert(T *object)                                         \
         nodetype *Append(T *object)                                         \
             { return (nodetype *)wxListBase::Append(object); }              \
         nodetype *Insert(T *object)                                         \

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

         nodetype *Insert(nodetype *prev, T *object)                         \
             { return (nodetype *)wxListBase::Insert(prev, object); }        \
                                                                             \
         nodetype *Insert(nodetype *prev, T *object)                         \
             { return (nodetype *)wxListBase::Insert(prev, object); }        \
                                                                             \


@@ -385,6 +397,9 @@ 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); }              \
                                                                             \
         void Sort(wxSortFuncFor_##name func)                                \
             { wxListBase::Sort((wxSortCompareFunction)func); }              \
                                                                             \


@@ -438,7 +453,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);
 
 class WXDLLEXPORT wxStringList : public wxStringListBase
 WX_DECLARE_LIST_2(char, wxStringListBase, wxStringListNode);
 
 class WXDLLEXPORT wxStringList : public wxStringListBase


@@ -449,13 +464,18 @@ public:
     wxStringList() { DeleteContents(TRUE); }
     wxStringList(const char *first ...);
 
     wxStringList() { DeleteContents(TRUE); }
     wxStringList(const char *first ...);
 

+        // copying the string list: the strings are copied, too (extremely
+        // inefficient!)
+    wxStringList(const wxStringList& other) { DoCopy(other); }
+    wxStringList& operator=(const wxStringList& other)
+        { Clear(); DoCopy(other); return *this; }
+

     // operations
         // makes a copy of the string
     wxNode *Add(const char *s)
         { return (wxNode *)wxStringListBase::Append(copystring(s)); }
 
     // operations
         // makes a copy of the string
     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;


@@ -468,6 +488,9 @@ public:
     wxNode *First() const { return (wxNode *)GetFirst(); }
     wxNode *Last() const { return (wxNode *)GetLast(); }
     wxNode *Nth(size_t index) const { return (wxNode *)Item(index); }
     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=

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