]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/list.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Reorganize wxCollapsiblePane event and layout code under GTK+
[wxWidgets.git] / src / common / list.cpp
diff --git a/src/common/list.cpp b/src/common/list.cpp
index 80841b6ea68e270160ed0450dcd558f039a6942c..4bdefdba206de4c34ba73b947f251673b6eb7b47 100644 (file)
--- a/src/common/list.cpp
+++ b/src/common/list.cpp
@@ -1,405 +1,475 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        list.cpp
+////////////////////////////////////////////////////////////////////////////////
+// Name:        src/common/list.cpp
 // Purpose:     wxList implementation
 // Author:      Julian Smart
 // Purpose:     wxList implementation
 // Author:      Julian Smart
-// Modified by:
+// Modified by: VZ at 16/11/98: WX_DECLARE_LIST() and typesafe lists added
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Created:     04/01/98
 // RCS-ID:      $Id$
-// Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:    wxWindows license
-/////////////////////////////////////////////////////////////////////////////
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+////////////////////////////////////////////////////////////////////////////////
 
 
-#ifdef __GNUG__
-#pragma implementation "list.h"
-#endif
+// =============================================================================
+// declarations
+// =============================================================================
+
+// -----------------------------------------------------------------------------
+// headers
+// -----------------------------------------------------------------------------
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#ifndef WX_PRECOMP
-#include "wx/defs.h"
-#include "wx/list.h"
-#include "wx/utils.h"
-#include <wx/intl.h>
-#endif
-
-// Sun CC compatibility (interference with xview/pkg.h, apparently...)
-#if defined(SUN_CC) && defined(__XVIEW__)
-#undef va_start
-#undef va_end
-#undef va_arg
-#undef va_list
+    #pragma hdrstop
 #endif
 
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 
 #endif
 
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 
-#if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxNode, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxList, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxStringList, wxList)
+#ifndef WX_PRECOMP
+    #include "wx/list.h"
+    #include "wx/crt.h"
 #endif
 
 #endif
 
-wxNode::wxNode (wxList * the_list, wxNode * last_one, wxNode * next_one,
-       wxObject * object)
-{
-  data = object;
-  previous = last_one;
-  next = next_one;
-  list = the_list;
-  key.string = (char *) NULL;
-
-  if (previous)
-    previous->next = this;
-
-  if (next)
-    next->previous = this;
-}
-
-// Keyed constructor
-wxNode::wxNode (wxList * the_list, wxNode * last_one, wxNode * next_one,
-       wxObject * object, long the_key)
-{
-  data = object;
-  previous = last_one;
-  next = next_one;
-  list = the_list;
-  key.integer = the_key;
+#if !wxUSE_STL
 
 
-  if (previous)
-    previous->next = this;
+// =============================================================================
+// implementation
+// =============================================================================
 
 
-  if (next)
-    next->previous = this;
-}
+// -----------------------------------------------------------------------------
+// wxListKey
+// -----------------------------------------------------------------------------
+wxListKey wxDefaultListKey;
 
 
-wxNode::wxNode (wxList * the_list, wxNode * last_one, wxNode * next_one,
-       wxObject * object, const char *the_key)
+bool wxListKey::operator==(wxListKeyValue value) const
 {
 {
-  data = object;
-  previous = last_one;
-  next = next_one;
-  list = the_list;
-  key.string = copystring (the_key);
+    switch ( m_keyType )
+    {
+        default:
+            wxFAIL_MSG(wxT("bad key type."));
+            // let compiler optimize the line above away in release build
+            // by not putting return here...
 
 
-  if (previous)
-    previous->next = this;
+        case wxKEY_STRING:
+            return *m_key.string == *value.string;
 
 
-  if (next)
-    next->previous = this;
+        case wxKEY_INTEGER:
+            return m_key.integer == value.integer;
+    }
 }
 
 }
 
+// -----------------------------------------------------------------------------
+// wxNodeBase
+// -----------------------------------------------------------------------------
 
 
-wxNode::~wxNode (void)
+wxNodeBase::wxNodeBase(wxListBase *list,
+                       wxNodeBase *previous, wxNodeBase *next,
+                       void *data, const wxListKey& key)
 {
 {
-  if (list)
-    list->n--;
+    m_list = list;
+    m_data = data;
+    m_previous = previous;
+    m_next = next;
+
+    switch ( key.GetKeyType() )
+    {
+        case wxKEY_NONE:
+            break;
 
 
-  if (list && list->destroy_data)
-    delete data;
+        case wxKEY_INTEGER:
+            m_key.integer = key.GetNumber();
+            break;
 
 
-  if (list && list->key_type == wxKEY_STRING && key.string)
-    delete[]key.string;
+        case wxKEY_STRING:
+            // to be free()d later
+            m_key.string = new wxString(key.GetString());
+            break;
 
 
-  // Make next node point back to the previous node from here
-  if (next)
-    next->previous = previous;
-  else if (list)
-    // If there's a new end of list (deleting the last one)
-    // make sure the list knows about it.
-    list->last_node = previous;
+        default:
+            wxFAIL_MSG(wxT("invalid key type"));
+    }
 
 
-  // Make the previous node point to the next node from here
-  if (previous)
-    previous->next = next;
+    if ( previous )
+        previous->m_next = this;
 
 
-  // Or if no previous node (start of list), make sure list points at
-  // the next node which becomes the first!.
-  else if (list)
-    list->first_node = next;
+    if ( next )
+        next->m_previous = this;
 }
 
 }
 
-wxList::wxList (void)
+wxNodeBase::~wxNodeBase()
 {
 {
-  first_node = (wxNode *) NULL;
-  last_node = (wxNode *) NULL;
-  n = 0;
-  destroy_data = 0;
-  key_type = wxKEY_NONE;
+    // handle the case when we're being deleted from the list by the user (i.e.
+    // not by the list itself from DeleteNode) - we must do it for
+    // compatibility with old code
+    if ( m_list != NULL )
+    {
+        if ( m_list->m_keyType == wxKEY_STRING )
+        {
+            delete m_key.string;
+        }
+
+        m_list->DetachNode(this);
+    }
 }
 
 }
 
-wxList::wxList (int N, wxObject * Objects[])
+int wxNodeBase::IndexOf() const
 {
 {
-  wxNode *last = (wxNode *) NULL;
+    wxCHECK_MSG( m_list, wxNOT_FOUND, wxT("node doesn't belong to a list in IndexOf"));
+
+    // It would be more efficient to implement IndexOf() completely inside
+    // wxListBase (only traverse the list once), but this is probably a more
+    // reusable way of doing it. Can always be optimized at a later date (since
+    // IndexOf() resides in wxListBase as well) if efficiency is a problem.
+    int i;
+    wxNodeBase *prev = m_previous;
 
 
-  int i;
-  for (i = 0; i < N; i++)
+    for( i = 0; prev; i++ )
     {
     {
-      wxNode *next = new wxNode (this, last, (wxNode *) NULL, Objects[i]);
-      last = next;
-      if (i == 0)
-       first_node = next;
+        prev = prev->m_previous;
     }
     }
-  last_node = last;
-  n = N;
-  key_type = wxKEY_NONE;
+
+    return i;
 }
 
 }
 
-wxList::wxList (const unsigned int the_key_type)
+// -----------------------------------------------------------------------------
+// wxListBase
+// -----------------------------------------------------------------------------
+
+void wxListBase::Init(wxKeyType keyType)
 {
 {
-  n = 0;
-  destroy_data = 0;
-  first_node = (wxNode *) NULL;
-  last_node = (wxNode *) NULL;
-  key_type = the_key_type;
+  m_nodeFirst =
+  m_nodeLast = NULL;
+  m_count = 0;
+  m_destroy = false;
+  m_keyType = keyType;
 }
 
 }
 
-// Variable argument list, terminated by a zero
-wxList::wxList (wxObject * first_one...)
+wxListBase::wxListBase(size_t count, void *elements[])
 {
 {
-// #ifndef __SGI__
-  va_list ap;
+  Init();
+
+  for ( size_t n = 0; n < count; n++ )
+  {
+      Append(elements[n]);
+  }
+}
 
 
-  va_start (ap, first_one);
+void wxListBase::DoCopy(const wxListBase& list)
+{
+    wxASSERT_MSG( !list.m_destroy,
+                  wxT("copying list which owns it's elements is a bad idea") );
 
 
-  wxNode *last = new wxNode (this, (wxNode *) NULL, (wxNode *) NULL, first_one);
-  first_node = last;
-  n = 1;
+    m_destroy = list.m_destroy;
+    m_keyType = list.m_keyType;
+    m_nodeFirst =
+    m_nodeLast = NULL;
 
 
-  for (;;)
+    switch (m_keyType)
     {
     {
-      wxObject *object = va_arg (ap, wxObject *);
-//    if (object == NULL) // Doesn't work in Windows -- segment is non-zero for NULL!
-#ifdef __WXMSW__
-      if ((int) object == 0)
-#else
-      if ((long) object == 0)
-#endif
-       break;
-      else
-       {
-         wxNode *node = new wxNode (this, last, (wxNode *) NULL, object);
-         last = node;
-         n++;
-       }
+        case wxKEY_INTEGER:
+            {
+                long key;
+                for ( wxNodeBase *node = list.GetFirst(); node; node = node->GetNext() )
+                {
+                    key = node->GetKeyInteger();
+                    Append(key, node->GetData());
+                }
+                break;
+            }
+
+        case wxKEY_STRING:
+            {
+                const wxChar *key;
+                for ( wxNodeBase *node = list.GetFirst(); node; node = node->GetNext() )
+                {
+                    key = node->GetKeyString();
+                    Append(key, node->GetData());
+                }
+                break;
+            }
+
+        default:
+            {
+                for ( wxNodeBase *node = list.GetFirst(); node; node = node->GetNext() )
+                {
+                    Append(node->GetData());
+                }
+                break;
+            }
     }
     }
-  last_node = last;
-  va_end (ap);
 
 
-  destroy_data = 0;
-  key_type = wxKEY_NONE;
-/*
-#else
-  fprintf (stderr, "Error: cannot use variable-argument functions on SGI!\n");
-#endif
-*/
+    wxASSERT_MSG( m_count == list.m_count, _T("logic error in wxList::DoCopy") );
 }
 
 }
 
-wxList::~wxList (void)
+wxListBase::~wxListBase()
 {
 {
-  wxNode *each = first_node;
-  while (each)
-    {
-      wxNode *next = each->Next ();
-      delete each;
+  wxNodeBase *each = m_nodeFirst;
+  while ( each != NULL )
+  {
+      wxNodeBase *next = each->GetNext();
+      DoDeleteNode(each);
       each = next;
       each = next;
-    }
+  }
 }
 
 }
 
-wxNode *wxList::Append(wxObject *object)
+wxNodeBase *wxListBase::AppendCommon(wxNodeBase *node)
 {
 {
-    wxNode *node = new wxNode(this, last_node, (wxNode *) NULL, object);
-    if (!first_node)
-      first_node = node;
-    last_node = node;
-    n ++;
+    if ( !m_nodeFirst )
+    {
+        m_nodeFirst = node;
+        m_nodeLast = m_nodeFirst;
+    }
+    else
+    {
+        m_nodeLast->m_next = node;
+        m_nodeLast = node;
+    }
+
+    m_count++;
+
     return node;
 }
 
     return node;
 }
 
-wxNode *wxList::Nth (int i) const
+wxNodeBase *wxListBase::Append(void *object)
 {
 {
-  int j = 0;
-  for (wxNode * current = First (); current; current = current->Next ())
-    {
-      if (j++ == i)
-       return current;
-    }
-  return (wxNode *) NULL;                      // No such element
+    // all objects in a keyed list should have a key
+    wxCHECK_MSG( m_keyType == wxKEY_NONE, NULL,
+                 wxT("need a key for the object to append") );
+
+    // we use wxDefaultListKey even though it is the default parameter value
+    // because gcc under Mac OS X seems to miscompile this call otherwise
+    wxNodeBase *node = CreateNode(m_nodeLast, NULL, object,
+                                  wxDefaultListKey);
 
 
+    return AppendCommon(node);
 }
 
 }
 
-wxNode *wxList::Find (long key) const
+wxNodeBase *wxListBase::Append(long key, void *object)
 {
 {
-  wxNode *current = First();
-  while (current)
-  {
-    if (current->key.integer == key)
-      return current;
-    current = current->Next();
-  }
-    
-  return (wxNode *) NULL;                      // Not found!
+    wxCHECK_MSG( (m_keyType == wxKEY_INTEGER) ||
+                 (m_keyType == wxKEY_NONE && m_count == 0),
+                 NULL,
+                 wxT("can't append object with numeric key to this list") );
+
+    wxNodeBase *node = CreateNode(m_nodeLast, NULL, object, key);
+    return AppendCommon(node);
 }
 
 }
 
-wxNode *wxList::Find (const char *key) const
+wxNodeBase *wxListBase::Append (const wxString& key, void *object)
 {
 {
-  wxNode *current = First();
-  while (current)
-  {
-      if (!current->key.string)
-       {
-         wxFatalError (_("wxList: string key not present, probably did not Append correctly!"));
-         break;
-       }
-      if (strcmp (current->key.string, key) == 0)
-       return current;
-      current = current->Next();
-  }
-
-  return (wxNode *) NULL;                      // Not found!
+    wxCHECK_MSG( (m_keyType == wxKEY_STRING) ||
+                 (m_keyType == wxKEY_NONE && m_count == 0),
+                 NULL,
+                 wxT("can't append object with string key to this list") );
 
 
+    wxNodeBase *node = CreateNode(m_nodeLast, NULL, object, key);
+    return AppendCommon(node);
 }
 
 }
 
-wxNode *wxList::Member (wxObject * object) const
+wxNodeBase *wxListBase::Insert(wxNodeBase *position, void *object)
 {
 {
-  for (wxNode * current = First (); current; current = current->Next ())
+    // all objects in a keyed list should have a key
+    wxCHECK_MSG( m_keyType == wxKEY_NONE, NULL,
+                 wxT("need a key for the object to insert") );
+
+    wxCHECK_MSG( !position || position->m_list == this, NULL,
+                 wxT("can't insert before a node from another list") );
+
+    // previous and next node for the node being inserted
+    wxNodeBase *prev, *next;
+    if ( position )
+    {
+        prev = position->GetPrevious();
+        next = position;
+    }
+    else
+    {
+        // inserting in the beginning of the list
+        prev = NULL;
+        next = m_nodeFirst;
+    }
+
+    // wxDefaultListKey: see comment in Append() above
+    wxNodeBase *node = CreateNode(prev, next, object, wxDefaultListKey);
+    if ( !m_nodeFirst )
+    {
+        m_nodeLast = node;
+    }
+
+    if ( prev == NULL )
     {
     {
-      wxObject *each = current->Data ();
-      if (each == object)
-       return current;
+        m_nodeFirst = node;
     }
     }
-  return (wxNode *) NULL;
+
+    m_count++;
+
+    return node;
 }
 
 }
 
-bool wxList::DeleteNode (wxNode * node)
+wxNodeBase *wxListBase::Item(size_t n) const
 {
 {
-  if (node)
+    for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
     {
     {
-      delete node;
-      return TRUE;
+        if ( n-- == 0 )
+        {
+            return current;
+        }
     }
     }
-  return FALSE;
+
+    wxFAIL_MSG( wxT("invalid index in wxListBase::Item") );
+
+    return NULL;
 }
 
 }
 
-bool wxList::DeleteObject (wxObject * object)
+wxNodeBase *wxListBase::Find(const wxListKey& key) const
 {
 {
-  // Search list for object
-  for (wxNode * current = first_node; current; current = current->Next ())
+    wxASSERT_MSG( m_keyType == key.GetKeyType(),
+                  wxT("this list is not keyed on the type of this key") );
+
+    for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
     {
     {
-      if (current->Data () == object)
-       {
-         delete current;
-         return TRUE;
-       }
+        if ( key == current->m_key )
+        {
+            return current;
+        }
     }
     }
-  return FALSE;                        // Did not find the object
 
 
+    // not found
+    return NULL;
 }
 
 }
 
-
-// Insert new node at front of list
-wxNode *wxList::Insert (wxObject * object)
+wxNodeBase *wxListBase::Find(const void *object) const
 {
 {
-  wxNode *node = new wxNode (this, (wxNode *) NULL, First (), object);
-  first_node = node;
-
-  if (!(node->Next ()))
-    last_node = node;
+    for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
+    {
+        if ( current->GetData() == object )
+            return current;
+    }
 
 
-  n++;
-  return node;
+    // not found
+    return NULL;
 }
 
 }
 
+int wxListBase::IndexOf(void *object) const
+{
+    wxNodeBase *node = Find( object );
+
+    return node ? node->IndexOf() : wxNOT_FOUND;
+}
 
 
-// Insert new node before given node.
-wxNode *wxList::Insert (wxNode * position, wxObject * object)
+void wxListBase::DoDeleteNode(wxNodeBase *node)
 {
 {
-  wxNode *prev = (wxNode *) NULL;
-  if (position)
-    prev = position->Previous ();
+    // free node's data
+    if ( m_keyType == wxKEY_STRING )
+    {
+        free(node->m_key.string);
+    }
 
 
-  wxNode *node = new wxNode (this, prev, position, object);
-  if (!first_node)
+    if ( m_destroy )
     {
     {
-      first_node = node;
-      last_node = node;
+        node->DeleteData();
     }
     }
-  if (!prev)
-    first_node = node;
 
 
-  n++;
-  return node;
+    // so that the node knows that it's being deleted by the list
+    node->m_list = NULL;
+    delete node;
+}
+
+wxNodeBase *wxListBase::DetachNode(wxNodeBase *node)
+{
+    wxCHECK_MSG( node, NULL, wxT("detaching NULL wxNodeBase") );
+    wxCHECK_MSG( node->m_list == this, NULL,
+                 wxT("detaching node which is not from this list") );
+
+    // update the list
+    wxNodeBase **prevNext = node->GetPrevious() ? &node->GetPrevious()->m_next
+                                                : &m_nodeFirst;
+    wxNodeBase **nextPrev = node->GetNext() ? &node->GetNext()->m_previous
+                                            : &m_nodeLast;
+
+    *prevNext = node->GetNext();
+    *nextPrev = node->GetPrevious();
+
+    m_count--;
+
+    // mark the node as not belonging to this list any more
+    node->m_list = NULL;
+
+    return node;
 }
 
 }
 
-// Keyed append
-wxNode *wxList::Append (long key, wxObject * object)
+bool wxListBase::DeleteNode(wxNodeBase *node)
 {
 {
-  wxNode *node = new wxNode (this, last_node, (wxNode *) NULL, object, key);
-  if (!first_node)
-    first_node = node;
-  last_node = node;
-  n++;
-  return node;
+    if ( !DetachNode(node) )
+        return false;
+
+    DoDeleteNode(node);
+
+    return true;
 }
 
 }
 
-wxNode *wxList::Append (const char *key, wxObject * object)
+bool wxListBase::DeleteObject(void *object)
 {
 {
-  wxNode *node = new wxNode (this, last_node, (wxNode *) NULL, object, key);
-  if (!first_node)
-    first_node = node;
-  last_node = node;
-  n++;
-  return node;
+    for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
+    {
+        if ( current->GetData() == object )
+        {
+            DeleteNode(current);
+            return true;
+        }
+    }
+
+    // not found
+    return false;
 }
 
 }
 
-void wxList::Clear (void)
+void wxListBase::Clear()
 {
 {
-  wxNode *current = first_node;
-  while (current)
+    wxNodeBase *current = m_nodeFirst;
+    while ( current )
     {
     {
-      wxNode *next = current->Next ();
-      delete current;
-      current = next;
+        wxNodeBase *next = current->GetNext();
+        DoDeleteNode(current);
+        current = next;
     }
     }
-  first_node = (wxNode *) NULL;
-  last_node = (wxNode *) NULL;
-  n = 0;
+
+    m_nodeFirst =
+    m_nodeLast = NULL;
+
+    m_count = 0;
 }
 
 }
 
-//Executes function F with all items present in the list
-void wxList::ForEach(wxListIterateFunction F)
+void wxListBase::ForEach(wxListIterateFunction F)
 {
 {
-  wxNode *each = first_node;
-  while (each)
-    { (*F)( each->Data ());
-      each = each->Next();
+    for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
+    {
+        (*F)(current->GetData());
     }
 }
     }
 }
-// Returns a pointer to the item which returns TRUE with function F
-// or NULL if no such item found
-wxObject *wxList::FirstThat(wxListIterateFunction F)
+
+void *wxListBase::FirstThat(wxListIterateFunction F)
 {
 {
-  wxNode *each = first_node;
-  while (each)
-    { if ((*F)( each->Data ())) return each->Data();
-      each = each->Next();
+    for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
+    {
+        if ( (*F)(current->GetData()) )
+            return current->GetData();
     }
     }
-  return (wxNode *) NULL;
+
+    return NULL;
 }
 }
-// Like FirstThat, but proceeds from the end backward
-wxObject *wxList::LastThat(wxListIterateFunction F)
+
+void *wxListBase::LastThat(wxListIterateFunction F)
 {
 {
-  wxNode *each = last_node;
-  while (each)
-    { if ((*F)( each->Data ())) return each->Data();
-      each = each->Previous();
+    for ( wxNodeBase *current = GetLast(); current; current = current->GetPrevious() )
+    {
+        if ( (*F)(current->GetData()) )
+            return current->GetData();
     }
     }
-  return (wxNode *) NULL;
+
+    return NULL;
 }
 
 // (stefan.hammes@urz.uni-heidelberg.de)
 }
 
 // (stefan.hammes@urz.uni-heidelberg.de)
@@ -421,8 +491,8 @@ wxObject *wxList::LastThat(wxListIterateFunction F)
 //   }
 //
 //   void main()
 //   }
 //
 //   void main()
-//   { 
-//     wxList list;
+//   {
+//     wxListBase list;
 //
 //     list.Append(new wxString("DEF"));
 //     list.Append(new wxString("GHI"));
 //
 //     list.Append(new wxString("DEF"));
 //     list.Append(new wxString("GHI"));
@@ -430,210 +500,272 @@ wxObject *wxList::LastThat(wxListIterateFunction F)
 //     list.Sort(listcompare);
 //   }
 
 //     list.Sort(listcompare);
 //   }
 
-void wxList::Sort(const wxSortCompareFunction compfunc)
-{
-  // allocate an array for the wxObject pointers of the list
-  const size_t num = Number();
-  wxObject **objArray = new wxObject *[num];
-  wxObject **objPtr = objArray;
-  
-  // go through the list and put the pointers into the array
-  wxNode *node = First();
-  while(node!=NULL){
-    *objPtr++ = node->Data();
-    node = node->Next();
-  }
-  // sort the array
-  qsort((void *)objArray,num,sizeof(wxObject *),compfunc);
-  // put the sorted pointers back into the list  
-  objPtr = objArray;
-  node = First();
-  while(node!=NULL){
-    node->SetData(*objPtr++);
-    node = node->Next();
-  }
-  // free the array
-  delete[] objArray;
-}
+void wxListBase::Sort(const wxSortCompareFunction compfunc)
+{
+    // allocate an array for the wxObject pointers of the list
+    const size_t num = GetCount();
+    void **objArray = new void *[num];
+    void **objPtr = objArray;
 
 
-/*
- * String list
- *
- */
+    // go through the list and put the pointers into the array
+    wxNodeBase *node;
+    for ( node = GetFirst(); node; node = node->GetNext() )
+    {
+        *objPtr++ = node->GetData();
+    }
 
 
-wxStringList::wxStringList (void):
-wxList ()
-{
-}
+    // sort the array
+    qsort((void *)objArray,num,sizeof(wxObject *),
+#ifdef __WXWINCE__
+        (int (__cdecl *)(const void *,const void *))
+#endif
+        compfunc);
 
 
-wxStringList::wxStringList (const wxStringList& list)
-{
-    (*this) = list;
+    // put the sorted pointers back into the list
+    objPtr = objArray;
+    for ( node = GetFirst(); node; node = node->GetNext() )
+    {
+        node->SetData(*objPtr++);
+    }
+
+    // free the array
+    delete[] objArray;
 }
 
 }
 
-// Variable argument list, terminated by a zero
-// Makes new storage for the strings
-wxStringList::wxStringList (const char *first...)
+void wxListBase::Reverse()
 {
 {
-// #ifndef __SGI__
-  n = 0;
-  destroy_data = 0;
-  key_type = wxKEY_NONE;
-  first_node = (wxNode *) NULL;
-  last_node = (wxNode *) NULL;
+    wxNodeBase* node = m_nodeFirst;
+    wxNodeBase* tmp;
 
 
-  if (!first)
-    return;
+    while (node)
+    {
+        // swap prev and next pointers
+        tmp = node->m_next;
+        node->m_next = node->m_previous;
+        node->m_previous = tmp;
 
 
-  va_list ap;
+        // this is the node that was next before swapping
+        node = tmp;
+    }
 
 
-  va_start (ap, first);
+    // swap first and last node
+    tmp = m_nodeFirst; m_nodeFirst = m_nodeLast; m_nodeLast = tmp;
+}
 
 
-  wxNode *last = new wxNode (this, (wxNode *) NULL, (wxNode *) NULL, (wxObject *) copystring (first));
-  first_node = last;
-  n = 1;
+void wxListBase::DeleteNodes(wxNodeBase* first, wxNodeBase* last)
+{
+    wxNodeBase* node = first;
 
 
-  for (;;)
+    while (node != last)
     {
     {
-      char *s = va_arg (ap, char *);
-//    if (s == NULL)
-#ifdef __WXMSW__
-      if ((int) s == 0)
-#else
-      if ((long) s == 0)
-#endif
-       break;
-      else
-       {
-         wxNode *node = new wxNode (this, last, (wxNode *) NULL, (wxObject *) copystring (s));
-         last = node;
-         n++;
-       }
+        wxNodeBase* next = node->GetNext();
+        DeleteNode(node);
+        node = next;
     }
     }
-  last_node = last;
-  va_end (ap);
-/*
-#else
-  fprintf (stderr, "Error: cannot use variable-argument functions on SGI!\n");
-#endif
-*/
 }
 
 }
 
-wxStringList::~wxStringList (void)
+// ============================================================================
+// compatibility section from now on
+// ============================================================================
+
+#ifdef wxLIST_COMPATIBILITY
+
+// -----------------------------------------------------------------------------
+// wxList (a.k.a. wxObjectList)
+// -----------------------------------------------------------------------------
+
+wxList::wxList( int key_type )
+    : wxObjectList( (wxKeyType)key_type )
 {
 {
-    Clear();
 }
 
 }
 
-void wxStringList::Clear(void)
+void wxObjectListNode::DeleteData()
 {
 {
-  wxNode *each = First();
-  while (each)
-    {
-      char *s = (char *) each->Data ();
-      delete[]s;
-      wxNode *next = each->Next ();
-      delete each;
-      each = next;
-    }
-  wxList::Clear();
+    delete (wxObject *)GetData();
 }
 
 }
 
-wxNode *wxStringList::Add (const char *s)
+// ----------------------------------------------------------------------------
+// wxStringList
+// ----------------------------------------------------------------------------
+
+static inline wxChar* MYcopystring(const wxChar* s)
 {
 {
-  return Append ((wxObject *) (copystring (s)));
+    wxChar* copy = new wxChar[wxStrlen(s) + 1];
+    return wxStrcpy(copy, s);
 }
 
 }
 
-void wxStringList::Delete (const char *s)
+// instead of WX_DEFINE_LIST(wxStringListBase) we define this function
+// ourselves
+void wxStringListNode::DeleteData()
 {
 {
-  for (wxNode * node = First (); node; node = node->Next ())
-    {
-      char *string = (char *) node->Data ();
-      if (string == s || strcmp (string, s) == 0)
-       {
-         delete[]string;
-         delete node;
-         break;                // Done!
+    delete [] (char *)GetData();
+}
+
+bool wxStringList::Delete(const wxChar *s)
+{
+    wxStringListNode *current;
 
 
-       }
-    }                          // for
+    for ( current = GetFirst(); current; current = current->GetNext() )
+    {
+        if ( wxStrcmp(current->GetData(), s) == 0 )
+        {
+            DeleteNode(current);
+            return true;
+        }
+    }
 
 
+    // not found
+    return false;
 }
 
 }
 
-// Only makes new strings if arg is TRUE
-char **wxStringList::ListToArray (bool new_copies) const
+void wxStringList::DoCopy(const wxStringList& other)
 {
 {
-  char **string_array = new char *[Number ()];
-  wxNode *node = First ();
-  int i;
-  for (i = 0; i < n; i++)
+    wxASSERT( GetCount() == 0 );    // this list must be empty before copying!
+
+    size_t count = other.GetCount();
+    for ( size_t n = 0; n < count; n++ )
     {
     {
-      char *s = (char *) node->Data ();
-      if (new_copies)
-       string_array[i] = copystring (s);
-      else
-       string_array[i] = s;
-      node = node->Next ();
+        Add(other.Item(n)->GetData());
     }
     }
-  return string_array;
 }
 
 }
 
-static int 
-wx_comparestrings (const void *arg1, const void *arg2)
+wxStringList::wxStringList()
 {
 {
-  char **s1 = (char **) arg1;
-  char **s2 = (char **) arg2;
-
-  return strcmp (*s1, *s2);
+    DeleteContents(true);
 }
 
 }
 
-// Sort a list of strings - deallocates old nodes, allocates new
-void wxStringList::Sort (void)
+// Variable argument list, terminated by a zero
+// Makes new storage for the strings
+wxStringList::wxStringList (const wxChar *first, ...)
 {
 {
-  size_t N = n;
-  char **array = new char *[N];
+  DeleteContents(true);
+  if ( !first )
+    return;
+
+  va_list ap;
+  va_start(ap, first);
+
+  const wxChar *s = first;
+  for (;;)
+  {
+      Add(s);
+
+      // icc gives this warning in its own va_arg() macro, argh
+#ifdef __INTELC__
+    #pragma warning(push)
+    #pragma warning(disable: 1684)
+#endif
+
+      s = va_arg(ap, const wxChar *);
+
+#ifdef __INTELC__
+    #pragma warning(pop)
+#endif
 
 
-  size_t i = 0;
-  for (wxNode * node = First (); node; node = node->Next ())
-    array[i++] = (char *) node->Data ();
+      if ( !s )
+          break;
+  }
 
 
-  qsort (array, N, sizeof (char *), wx_comparestrings);
-  Clear ();
+  va_end(ap);
+}
 
 
-  for (i = 0; i < N; i++)
-    Append ((wxObject *) (array[i]));
+// Only makes new strings if arg is true
+wxChar **wxStringList::ListToArray(bool new_copies) const
+{
+    wxChar **string_array = new wxChar *[GetCount()];
+    wxStringListNode *node = GetFirst();
+    for (size_t i = 0; i < GetCount(); i++)
+    {
+        wxChar *s = node->GetData();
+        if ( new_copies )
+            string_array[i] = MYcopystring(s);
+        else
+            string_array[i] = s;
+        node = node->GetNext();
+    }
 
 
-  delete[]array;
+    return string_array;
 }
 
 // Checks whether s is a member of the list
 }
 
 // Checks whether s is a member of the list
-bool wxStringList::Member (const char *s) const
+bool wxStringList::Member(const wxChar *s) const
 {
 {
-  for (wxNode * node = First (); node; node = node->Next ())
+    for ( wxStringListNode *node = GetFirst(); node; node = node->GetNext() )
     {
     {
-      const char *s1 = (const char *) node->Data ();
-      if (s == s1 || strcmp (s, s1) == 0)
-       return TRUE;
+        const wxChar *s1 = node->GetData();
+        if (s == s1 || wxStrcmp (s, s1) == 0)
+            return true;
     }
     }
-  return FALSE;
+
+    return false;
 }
 
 }
 
-void wxStringList::operator= (const wxStringList& list)
+#ifdef __WXWINCE__
+extern "C"
 {
 {
-    Clear();
+static int __cdecl
+#else
+extern "C"
+{
+static int LINKAGEMODE
+#endif
 
 
-    wxNode *node = list.First();
-    while (node)
+wx_comparestrings(const void *arg1, const void *arg2)
+{
+  wxChar **s1 = (wxChar **) arg1;
+  wxChar **s2 = (wxChar **) arg2;
+
+  return wxStrcmp (*s1, *s2);
+}
+
+}   // end of extern "C" (required because of GCC Bug c++/33078
+
+// Sort a list of strings - deallocates old nodes, allocates new
+void wxStringList::Sort()
+{
+    size_t N = GetCount();
+    wxChar **array = new wxChar *[N];
+    wxStringListNode *node;
+
+    size_t i = 0;
+    for ( node = GetFirst(); node; node = node->GetNext() )
     {
     {
-        char *s = (char *) node->Data ();
-        Add(s);
-        node = node->Next();
+        array[i++] = node->GetData();
     }
     }
+
+    qsort (array, N, sizeof (wxChar *), wx_comparestrings);
+
+    i = 0;
+    for ( node = GetFirst(); node; node = node->GetNext() )
+        node->SetData( array[i++] );
+
+    delete [] array;
+}
+
+wxNode *wxStringList::Add(const wxChar *s)
+{
+    return (wxNode *)(wxStringListBase::Node *)
+            wxStringListBase::Append(MYcopystring(s));
 }
 
 }
 
-char* wxStringList::operator[] (int i) const
+wxNode *wxStringList::Prepend(const wxChar *s)
 {
 {
-    wxASSERT_MSG( (i < Number()), "Invalid index for wxStringList" );
+    return (wxNode *)(wxStringListBase::Node *)
+            wxStringListBase::Insert(MYcopystring(s));
+}
+
+#endif // wxLIST_COMPATIBILITY
+
+#else // wxUSE_STL = 1
 
 
-    return (char*) (Nth(i)->Data());
+    #include "wx/listimpl.cpp"
+    WX_DEFINE_LIST(wxObjectList)
+
+// with wxUSE_STL wxStringList contains wxString objects, not pointers
+void _WX_LIST_HELPER_wxStringListBase::DeleteFunction( wxString WXUNUSED(X) )
+{
 }
 
 }
 
+wxStringListBase::BaseListType wxStringListBase::EmptyList;
+
+#endif // !wxUSE_STL
wxWidgets (Impactor)