[ 1713933 ] docs for wxEditableListBox

[wxWidgets.git] / include / wx / listimpl.cpp

diff --git a/include/wx/listimpl.cpp b/include/wx/listimpl.cpp
index e3513099c889aff1b4f4d265fde3fa3d992cf1b9..c4c8e020d06e83b3ae6c4f53aff5c246b36ad015 100644 (file)
--- a/include/wx/listimpl.cpp
+++ b/include/wx/listimpl.cpp
@@ -1,111 +1,39 @@
-///////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////

 // Name:        listimpl.cpp
 // Name:        listimpl.cpp

-// Purpose:     helper file for implementation of dynamic lists
+// Purpose:     second-part of macro based implementation of template lists

 // Author:      Vadim Zeitlin
 // Author:      Vadim Zeitlin

-// Modified by: 
-// Created:     16.10.97
+// Modified by:
+// Created:     16/11/98

 // RCS-ID:      $Id$
 // RCS-ID:      $Id$

-// Copyright:   (c) 1997 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// Licence:     wxWindows license
-///////////////////////////////////////////////////////////////////////////////
+// Copyright:   (c) 1998 Vadim Zeitlin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////

 
 

-/*****************************************************************************
- * Purpose: implements methods of "template" class declared in DECLARE_LIST  *
- *          macro and which couldn't be implemented inline (because they     *
- *          need the full definition of type T in scope)                     *
- *                                                                           *
- * Usage:   1) #include dynarray.h                                           *
- *          2) WX_DECLARE_LIST                                               *
- *          3) #include listimpl.cpp                                         *
- *          4) WX_DEFINE_LIST                                                *
- *****************************************************************************/
+#if wxUSE_STL

 
 

-// macro implements remaining (not inline) methods of template list
-// (it's private to this file)
-#define _DEFINE_LIST(T, name)                                                 \
-name::~name()                                                                 \
-{                                                                             \
-  Empty();                                                                    \
-}                                                                             \
-                                                                              \
-void name::DoCopy(const name& src)                                            \
-{                                                                             \
-  for ( uint ui = 0; ui < src.Count(); ui++ )                                 \
-    Add(src[ui]);                                                             \
-}                                                                             \
-                                                                              \
-name& name::operator=(const name& src)                                        \
-{                                                                             \
-  Empty();                                                                    \
-  DoCopy(src);                                                                \
-                                                                              \
-  return *this;                                                               \
-}                                                                             \
-                                                                              \
-name::name(const name& src)                                                   \
-{                                                                             \
-  DoCopy(src);                                                                \
-}                                                                             \
-                                                                              \
-void name::Empty()                                                            \
-{                                                                             \
-  for ( uint ui = 0; ui < Count(); ui++ )                                     \
-    delete (T*)BaseArray::Item(ui);                                           \
-                                                                              \
-  BaseArray::Clear();                                                         \
-}                                                                             \
-                                                                              \
-void name::Remove(uint uiIndex)                                               \
-{                                                                             \
-  wxCHECK( uiIndex < Count() );                                               \
-                                                                              \
-  delete (T*)BaseArray::Item(uiIndex);                                        \
-                                                                              \
-  BaseArray::Remove(uiIndex);                                                 \
-}                                                                             \
-                                                                              \
-void name::Add(const T& item)                                                 \
-{                                                                             \
-  T* pItem = new T(item);                                                     \
-  if ( pItem != NULL )                                                        \
-    Add(pItem);                                                               \
-}                                                                             \
-                                                                              \
-void name::Insert(const T& item, uint uiIndex)                                \
-{                                                                             \
-  T* pItem = new T(item);                                                     \
-  if ( pItem != NULL )                                                        \
-    Insert(pItem, uiIndex);                                                   \
-}                                                                             \
-                                                                              \
-int name::Index(const T& Item, Bool bFromEnd) const                           \
-{                                                                             \
-  if ( bFromEnd ) {                                                           \
-    if ( Count() > 0 ) {                                                      \
-      uint ui = Count() - 1;                                                  \
-      do {                                                                    \
-        if ( (T*)BaseArray::Item(ui) == &Item )                               \
-          return ui;                                                          \
-        ui--;                                                                 \
-      }                                                                       \
-      while ( ui != 0 );                                                      \
-    }                                                                         \
-  }                                                                           \
-  else {                                                                      \
-    for( uint ui = 0; ui < Count(); ui++ ) {                                  \
-      if( (T*)BaseArray::Item(ui) == &Item )                                  \
-        return ui;                                                            \
+#undef  WX_DEFINE_LIST
+#define WX_DEFINE_LIST(name)                                                  \
+    void _WX_LIST_HELPER_##name::DeleteFunction( _WX_LIST_ITEM_TYPE_##name X )\
+    {                                                                         \
+        delete X;                                                             \

     }                                                                         \
     }                                                                         \

-  }                                                                           \
-                                                                              \
-  return NOT_FOUND;                                                           \
-}                                                                             
+    name::BaseListType name::EmptyList;

 
 

-// redefine the macro so that now it will generate the class implementation
-// old value would provoke a compile-time error if this file is not included
-#undef  WX_DEFINE_LIST
-#define WX_DEFINE_LIST(name) _DEFINE_LIST(_L##name, name)
+#else // !wxUSE_STL
+
+    #define _DEFINE_LIST(T, name)         \
+        void wx##name##Node::DeleteData() \
+        {                                 \
+            delete (T *)GetData();        \
+        }
+
+    // redefine the macro so that now it will generate the class implementation
+    // old value would provoke a compile-time error if this file is not included
+    #undef  WX_DEFINE_LIST
+    #define WX_DEFINE_LIST(name) _DEFINE_LIST(_WX_LIST_ITEM_TYPE_##name, name)
+
+    // don't pollute preprocessor's name space
+    //#undef  _DEFINE_LIST

 
 

-// don't pollute preprocessor's name space
-#undef  _DEFINE_LIST
+#endif // wxUSE_STL/!wxUSE_STL