Implement HasSelection for the OSX WebKit backend.

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

diff --git a/include/wx/arrimpl.cpp b/include/wx/arrimpl.cpp
index cee3933129b59cfe391899942a9e70306e90ec10..f2bc7ce73f96540eeb39e244210b5ef8512501e6 100644 (file)
--- a/include/wx/arrimpl.cpp
+++ b/include/wx/arrimpl.cpp
@@ -6,7 +6,7 @@
 // Created:     16.10.97
 // RCS-ID:      $Id$
 // Copyright:   (c) 1997 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     16.10.97
 // RCS-ID:      $Id$
 // Copyright:   (c) 1997 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

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


@@ -35,7 +35,7 @@ name::~name()                                                                 \
                                                                               \
 void name::DoCopy(const name& src)                                            \
 {                                                                             \
                                                                               \
 void name::DoCopy(const name& src)                                            \
 {                                                                             \

-  for ( size_t ui = 0; ui < src.Count(); ui++ )                               \
+  for ( size_t ui = 0; ui < src.size(); ui++ )                                \

     Add(src[ui]);                                                             \
 }                                                                             \
                                                                               \
     Add(src[ui]);                                                             \
 }                                                                             \
                                                                               \


@@ -54,18 +54,18 @@ name::name(const name& src) : wxArrayPtrVoid()                                \
                                                                               \
 void name::DoEmpty()                                                          \
 {                                                                             \
                                                                               \
 void name::DoEmpty()                                                          \
 {                                                                             \

-  for ( size_t ui = 0; ui < Count(); ui++ )                                   \
-    delete (T*)wxBaseArrayPtrVoid::Item(ui);                                  \
+  for ( size_t ui = 0; ui < size(); ui++ )                                    \
+    delete (T*)base_array::operator[](ui);                                    \

 }                                                                             \
                                                                               \
 void name::RemoveAt(size_t uiIndex, size_t nRemove)                           \
 {                                                                             \
 }                                                                             \
                                                                               \
 void name::RemoveAt(size_t uiIndex, size_t nRemove)                           \
 {                                                                             \

-  wxCHECK_RET( uiIndex < Count(), _WX_ERROR_REMOVE2(name) );                  \
+  wxCHECK_RET( uiIndex < size(), _WX_ERROR_REMOVE2(name) );                   \

                                                                               \
   for (size_t i = 0; i < nRemove; i++ )                                       \
                                                                               \
   for (size_t i = 0; i < nRemove; i++ )                                       \

-    delete (T*)wxBaseArrayPtrVoid::Item(uiIndex + i);                         \
+    delete (T*)base_array::operator[](uiIndex + i);                           \

                                                                               \
                                                                               \

-  wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove);                             \
+  base_array::erase(begin() + uiIndex, begin() + uiIndex + nRemove);          \

 }                                                                             \
                                                                               \
 void name::Add(const T& item, size_t nInsert)                                 \
 }                                                                             \
                                                                               \
 void name::Add(const T& item, size_t nInsert)                                 \


@@ -73,11 +73,11 @@ void name::Add(const T& item, size_t nInsert)                                 \
   if (nInsert == 0)                                                           \
     return;                                                                   \
   T* pItem = new T(item);                                                     \
   if (nInsert == 0)                                                           \
     return;                                                                   \
   T* pItem = new T(item);                                                     \

-  size_t nOldSize = GetCount();                                               \
+  size_t nOldSize = size();                                                   \

   if ( pItem != NULL )                                                        \
   if ( pItem != NULL )                                                        \

-    wxBaseArrayPtrVoid::Add(pItem, nInsert);                                  \
+    base_array::insert(end(), nInsert, pItem);                                \

   for (size_t i = 1; i < nInsert; i++)                                        \
   for (size_t i = 1; i < nInsert; i++)                                        \

-    wxBaseArrayPtrVoid::Item(nOldSize + i) = new T(item);                     \
+    base_array::operator[](nOldSize + i) = new T(item);                       \

 }                                                                             \
                                                                               \
 void name::Insert(const T& item, size_t uiIndex, size_t nInsert)              \
 }                                                                             \
                                                                               \
 void name::Insert(const T& item, size_t uiIndex, size_t nInsert)              \


@@ -86,28 +86,28 @@ void name::Insert(const T& item, size_t uiIndex, size_t nInsert)              \
     return;                                                                   \
   T* pItem = new T(item);                                                     \
   if ( pItem != NULL )                                                        \
     return;                                                                   \
   T* pItem = new T(item);                                                     \
   if ( pItem != NULL )                                                        \

-    wxBaseArrayPtrVoid::Insert(pItem, uiIndex, nInsert);                      \
+    base_array::insert(begin() + uiIndex, nInsert, pItem);                    \

   for (size_t i = 1; i < nInsert; i++)                                        \
   for (size_t i = 1; i < nInsert; i++)                                        \

-    wxBaseArrayPtrVoid::Item(uiIndex + i) = new T(item);                      \
+    base_array::operator[](uiIndex + i) = new T(item);                        \

 }                                                                             \
                                                                               \
 int name::Index(const T& Item, bool bFromEnd) const                           \
 {                                                                             \
   if ( bFromEnd ) {                                                           \
 }                                                                             \
                                                                               \
 int name::Index(const T& Item, bool bFromEnd) const                           \
 {                                                                             \
   if ( bFromEnd ) {                                                           \

-    if ( Count() > 0 ) {                                                      \
-      size_t ui = Count() - 1;                                                \
+    if ( size() > 0 ) {                                                       \
+      size_t ui = size() - 1;                                                 \

       do {                                                                    \
       do {                                                                    \

-        if ( (T*)wxBaseArrayPtrVoid::Item(ui) == &Item )                      \
-          return ui;                                                          \
+        if ( (T*)base_array::operator[](ui) == &Item )                        \
+          return static_cast<int>(ui);                                     \

         ui--;                                                                 \
       }                                                                       \
       while ( ui != 0 );                                                      \
     }                                                                         \
   }                                                                           \
   else {                                                                      \
         ui--;                                                                 \
       }                                                                       \
       while ( ui != 0 );                                                      \
     }                                                                         \
   }                                                                           \
   else {                                                                      \

-    for( size_t ui = 0; ui < Count(); ui++ ) {                                \
-      if( (T*)wxBaseArrayPtrVoid::Item(ui) == &Item )                         \
-        return ui;                                                            \
+    for( size_t ui = 0; ui < size(); ui++ ) {                                 \
+      if( (T*)base_array::operator[](ui) == &Item )                           \
+        return static_cast<int>(ui);                                       \

     }                                                                         \
   }                                                                           \
                                                                               \
     }                                                                         \
   }                                                                           \
                                                                               \