implemented fallback for AlphaBlend() for the systems not supporting it

[wxWidgets.git] / src / common / dynarray.cpp

diff --git a/src/common/dynarray.cpp b/src/common/dynarray.cpp
index e8efb32ecb06ed51d7bbcbf83ad490038ddad004..012c6077a324155f5b7b24b1009c4659e3dc4098 100644 (file)
--- a/src/common/dynarray.cpp
+++ b/src/common/dynarray.cpp
@@ -6,7 +6,7 @@
 // Created:     12.09.97
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     12.09.97
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

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

 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -33,6 +33,11 @@
   #define max(a, b)   (((a) > (b)) ? (a) : (b))
 #endif
 
   #define max(a, b)   (((a) > (b)) ? (a) : (b))
 #endif
 

+// we cast the value to long from which we cast it to void * in IndexForInsert:
+// this can't work if the pointers are not big enough
+wxCOMPILE_TIME_ASSERT( sizeof(long) <= sizeof(void *),
+                       wxArraySizeOfPtrLessSizeOfLong ); // < 32 symbols
+

 // ============================================================================
 // constants
 // ============================================================================
 // ============================================================================
 // constants
 // ============================================================================


@@ -48,7 +53,7 @@
 // wxBaseArray - dynamic array of 'T's
 // ----------------------------------------------------------------------------
 
 // wxBaseArray - dynamic array of 'T's
 // ----------------------------------------------------------------------------
 

-#define _DECLARE_BASEARRAY(T, name)                                         \
+#define _WX_DEFINE_BASEARRAY(T, name)                                       \

 /* ctor */                                                                  \
 name::name()                                                                \
 {                                                                           \
 /* ctor */                                                                  \
 name::name()                                                                \
 {                                                                           \


@@ -101,39 +106,76 @@ name& name::operator=(const name& src)                                      \
   return *this;                                                             \
 }                                                                           \
                                                                             \
   return *this;                                                             \
 }                                                                           \
                                                                             \

+/* allocate new buffer of the given size and move our data to it */         \
+bool name::Realloc(size_t nSize)                                            \
+{                                                                           \
+  T *pNew = new T[nSize];                                                   \
+  /* only grow if allocation succeeded */                                   \
+  if ( !pNew )                                                              \
+      return false;                                                         \
+                                                                            \
+  m_nSize = nSize;                                                          \
+  /* copy data to new location */                                           \
+  memcpy(pNew, m_pItems, m_nCount*sizeof(T));                               \
+  delete [] m_pItems;                                                       \
+  m_pItems = pNew;                                                          \
+                                                                            \
+  return true;                                                              \
+}                                                                           \
+                                                                            \

 /* grow the array */                                                        \
 /* grow the array */                                                        \

-void name::Grow()                                                           \
+void name::Grow(size_t nIncrement)                                          \

 {                                                                           \
   /* only do it if no more place */                                         \
 {                                                                           \
   /* only do it if no more place */                                         \

-  if( m_nCount == m_nSize ) {                                               \
+  if( (m_nCount == m_nSize) || ((m_nSize - m_nCount) < nIncrement) ) {      \

     if( m_nSize == 0 ) {                                                    \
     if( m_nSize == 0 ) {                                                    \

-        /* was empty, alloc some memory */                                  \
-      m_pItems = new T[WX_ARRAY_DEFAULT_INITIAL_SIZE];                      \
+      /* was empty, determine initial size */                               \
+      size_t size = WX_ARRAY_DEFAULT_INITIAL_SIZE;                          \
+      if (size < nIncrement) size = nIncrement;                             \
+      /* allocate some memory */                                            \
+      m_pItems = new T[size];                                               \

       /* only grow if allocation succeeded */                               \
       if ( m_pItems ) {                                                     \
       /* only grow if allocation succeeded */                               \
       if ( m_pItems ) {                                                     \

-          m_nSize = WX_ARRAY_DEFAULT_INITIAL_SIZE;                          \
+          m_nSize = size;                                                   \

       }                                                                     \
     }                                                                       \
     else                                                                    \
     {                                                                       \
       }                                                                     \
     }                                                                       \
     else                                                                    \
     {                                                                       \

-      /* add 50% but not too much */                                        \
-      size_t nIncrement = m_nSize < WX_ARRAY_DEFAULT_INITIAL_SIZE           \
-                         ? WX_ARRAY_DEFAULT_INITIAL_SIZE : m_nSize >> 1;    \
-      if ( nIncrement > ARRAY_MAXSIZE_INCREMENT )                           \
-        nIncrement = ARRAY_MAXSIZE_INCREMENT;                               \
-      T *pNew = new T[m_nSize + nIncrement];                                \
-      /* only grow if allocation succeeded */                               \
-      if ( pNew ) {                                                         \
-          m_nSize += nIncrement;                                            \
-          /* copy data to new location */                                   \
-          memcpy(pNew, m_pItems, m_nCount*sizeof(T));                       \
-          delete [] m_pItems;                                               \
-          m_pItems = pNew;                                                  \
-      }                                                                     \
+      /* add at least 50% but not too much */                               \
+      size_t ndefIncrement = m_nSize < WX_ARRAY_DEFAULT_INITIAL_SIZE        \
+                            ? WX_ARRAY_DEFAULT_INITIAL_SIZE : m_nSize >> 1; \
+      if ( ndefIncrement > ARRAY_MAXSIZE_INCREMENT )                        \
+        ndefIncrement = ARRAY_MAXSIZE_INCREMENT;                            \
+      if ( nIncrement < ndefIncrement )                                     \
+        nIncrement = ndefIncrement;                                         \
+      Realloc(m_nSize + nIncrement);                                        \

     }                                                                       \
   }                                                                         \
 }                                                                           \
                                                                             \
     }                                                                       \
   }                                                                         \
 }                                                                           \
                                                                             \

+/* make sure that the array has at least count elements */                  \
+void name::SetCount(size_t count, T defval)                                 \
+{                                                                           \
+    if ( m_nSize < count )                                                  \
+    {                                                                       \
+        /* need to realloc memory: don't overallocate it here as if */      \
+        /* SetCount() is called, it probably means that the caller  */      \
+        /* knows in advance how many elements there will be in the  */      \
+        /* array and so it won't be necessary to realloc it later   */      \
+        if ( !Realloc(count) )                                              \
+        {                                                                   \
+            /* out of memory -- what can we do? */                          \
+            return;                                                         \
+        }                                                                   \
+    }                                                                       \
+                                                                            \
+    /* add new elements if we extend the array */                           \
+    while ( m_nCount < count )                                              \
+    {                                                                       \
+        m_pItems[m_nCount++] = defval;                                      \
+    }                                                                       \
+}                                                                           \
+                                                                            \

 /* dtor */                                                                  \
 name::~name()                                                               \
 {                                                                           \
 /* dtor */                                                                  \
 name::~name()                                                               \
 {                                                                           \


@@ -179,7 +221,11 @@ void name::Shrink()                                                         \
         memcpy(pNew, m_pItems, m_nCount*sizeof(T));                         \
         delete [] m_pItems;                                                 \
         m_pItems = pNew;                                                    \
         memcpy(pNew, m_pItems, m_nCount*sizeof(T));                         \
         delete [] m_pItems;                                                 \
         m_pItems = pNew;                                                    \

+                                                                            \
+        /* update the size of the new block */                              \
+        m_nSize = m_nCount;                                                 \

     }                                                                       \
     }                                                                       \

+    /* else: don't do anything, better keep old memory block! */            \

   }                                                                         \
 }                                                                           \
                                                                             \
   }                                                                         \
 }                                                                           \
                                                                             \


@@ -217,7 +263,8 @@ size_t name::IndexForInsert(T lItem, CMPFUNC fnCompare) const               \
   while ( lo < hi ) {                                                       \
     i = (lo + hi)/2;                                                        \
                                                                             \
   while ( lo < hi ) {                                                       \
     i = (lo + hi)/2;                                                        \
                                                                             \

-    res = (*fnCompare)((const void *)&lItem, (const void *)&(m_pItems[i])); \
+    res = (*fnCompare)((const void *)(long)lItem,                           \
+                       (const void *)(long)(m_pItems[i]));                  \

     if ( res < 0 )                                                          \
       hi = i;                                                               \
     else if ( res > 0 )                                                     \
     if ( res < 0 )                                                          \
       hi = i;                                                               \
     else if ( res > 0 )                                                     \


@@ -236,14 +283,20 @@ int name::Index(T lItem, CMPFUNC fnCompare) const                           \
 {                                                                           \
     size_t n = IndexForInsert(lItem, fnCompare);                            \
                                                                             \
 {                                                                           \
     size_t n = IndexForInsert(lItem, fnCompare);                            \
                                                                             \

-    return n < m_nCount && m_pItems[n] == lItem ? (int)n : wxNOT_FOUND;     \
+    return n < m_nCount &&                                                  \
+           (*fnCompare)((const void *)(long)lItem,                          \
+                        ((const void *)(long)m_pItems[n])) ? (int)n         \
+                                                           : wxNOT_FOUND;   \

 }                                                                           \
                                                                             \
 /* add item at the end */                                                   \
 }                                                                           \
                                                                             \
 /* add item at the end */                                                   \

-void name::Add(T lItem)                                                     \
+void name::Add(T lItem, size_t nInsert)                                     \

 {                                                                           \
 {                                                                           \

-  Grow();                                                                   \
-  m_pItems[m_nCount++] = lItem;                                             \
+  if (nInsert == 0)                                                         \
+      return;                                                               \
+  Grow(nInsert);                                                            \
+  for (size_t i = 0; i < nInsert; i++)                                      \
+      m_pItems[m_nCount++] = lItem;                                         \

 }                                                                           \
                                                                             \
 /* add item assuming the array is sorted with fnCompare function */         \
 }                                                                           \
                                                                             \
 /* add item assuming the array is sorted with fnCompare function */         \


@@ -253,26 +306,33 @@ void name::Add(T lItem, CMPFUNC fnCompare)                                  \
 }                                                                           \
                                                                             \
 /* add item at the given position */                                        \
 }                                                                           \
                                                                             \
 /* add item at the given position */                                        \

-void name::Insert(T lItem, size_t nIndex)                                   \
+void name::Insert(T lItem, size_t nIndex, size_t nInsert)                   \

 {                                                                           \
   wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArray::Insert") );   \
 {                                                                           \
   wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArray::Insert") );   \

+  wxCHECK_RET( m_nCount <= m_nCount + nInsert,                              \
+               wxT("array size overflow in wxArray::Insert") );             \

                                                                             \
                                                                             \

-  Grow();                                                                   \
+  if (nInsert == 0)                                                         \
+      return;                                                               \
+  Grow(nInsert);                                                            \

                                                                             \
                                                                             \

-  memmove(&m_pItems[nIndex + 1], &m_pItems[nIndex],                         \
+  memmove(&m_pItems[nIndex + nInsert], &m_pItems[nIndex],                   \

           (m_nCount - nIndex)*sizeof(T));                                   \
           (m_nCount - nIndex)*sizeof(T));                                   \

-  m_pItems[nIndex] = lItem;                                                 \
-  m_nCount++;                                                               \
+  for (size_t i = 0; i < nInsert; i++)                                      \
+      m_pItems[nIndex + i] = lItem;                                         \
+  m_nCount += nInsert;                                                      \

 }                                                                           \
                                                                             \
 /* removes item from array (by index) */                                    \
 }                                                                           \
                                                                             \
 /* removes item from array (by index) */                                    \

-void name::RemoveAt(size_t nIndex)                                          \
+void name::RemoveAt(size_t nIndex, size_t nRemove)                          \

 {                                                                           \
 {                                                                           \

-  wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArray::RemoveAt") ); \
+  wxCHECK_RET( nIndex < m_nCount, wxT("bad index in wxArray::RemoveAt") );  \
+  wxCHECK_RET( nIndex + nRemove <= m_nCount,                                \
+               wxT("removing too many elements in wxArray::RemoveAt") );    \

                                                                             \
                                                                             \

-  memmove(&m_pItems[nIndex], &m_pItems[nIndex + 1],                         \
-          (m_nCount - nIndex - 1)*sizeof(T));                               \
-  m_nCount--;                                                               \
+  memmove(&m_pItems[nIndex], &m_pItems[nIndex + nRemove],                   \
+          (m_nCount - nIndex - nRemove)*sizeof(T));                         \
+  m_nCount -= nRemove;                                                      \

 }                                                                           \
                                                                             \
 /* removes item from array (by value) */                                    \
 }                                                                           \
                                                                             \
 /* removes item from array (by value) */                                    \


@@ -292,9 +352,9 @@ void name::Sort(CMPFUNC fCmp)                                               \
   qsort(m_pItems, m_nCount, sizeof(T), fCmp);                               \
 }
 
   qsort(m_pItems, m_nCount, sizeof(T), fCmp);                               \
 }
 

-_DECLARE_BASEARRAY(void *, wxBaseArrayPtrVoid)
-_DECLARE_BASEARRAY(short,  wxBaseArrayShort)
-_DECLARE_BASEARRAY(int,    wxBaseArrayInt)
-_DECLARE_BASEARRAY(long,   wxBaseArrayLong)
-_DECLARE_BASEARRAY(double, wxBaseArrayDouble)
+_WX_DEFINE_BASEARRAY(const void *, wxBaseArrayPtrVoid)
+_WX_DEFINE_BASEARRAY(short,        wxBaseArrayShort)
+_WX_DEFINE_BASEARRAY(int,          wxBaseArrayInt)
+_WX_DEFINE_BASEARRAY(long,         wxBaseArrayLong)
+//_WX_DEFINE_BASEARRAY(double,       wxBaseArrayDouble)