moving rounded rect and ellipse to path class

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

diff --git a/include/wx/dynarray.h b/include/wx/dynarray.h
index b24d807b9c74607c4bfc75df5b5cf69edf187591..81c12e84b5fba0ea4e2c8586ba7c23d4bf3c95ec 100644 (file)
--- a/include/wx/dynarray.h
+++ b/include/wx/dynarray.h
@@ -12,11 +12,6 @@
 #ifndef   _DYNARRAY_H
 #define   _DYNARRAY_H
 
 #ifndef   _DYNARRAY_H
 #define   _DYNARRAY_H
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && \
-    !(defined(__MINGW32__) && __GNUC__ == 3 && __GNUC_MINOR__ == 2)
-#pragma interface "dynarray.h"
-#endif
-

 #include "wx/defs.h"
 
 #if wxUSE_STL
 #include "wx/defs.h"
 
 #if wxUSE_STL


@@ -231,7 +226,8 @@ protected:                                                          \
   void pop_back() { RemoveAt(size() - 1); }                         \
   void push_back(const value_type& v) { Add(v); }                   \
   void reserve(size_type n) { if(n > m_nSize) Realloc(n); }         \
   void pop_back() { RemoveAt(size() - 1); }                         \
   void push_back(const value_type& v) { Add(v); }                   \
   void reserve(size_type n) { if(n > m_nSize) Realloc(n); }         \

-  void resize(size_type n, value_type v = value_type());            \
+  void resize(size_type n, value_type v = value_type())             \
+    { SetCount(n, v); }                                             \

                                                                     \
   iterator begin() { return m_pItems; }                             \
   iterator end() { return m_pItems + m_nCount; }                    \
                                                                     \
   iterator begin() { return m_pItems; }                             \
   iterator end() { return m_pItems + m_nCount; }                    \


@@ -296,15 +292,15 @@ public:                                                               \
   int Index(T e, bool bFromEnd = false) const                         \
     { return base::Index(e, bFromEnd); }                              \
                                                                       \
   int Index(T e, bool bFromEnd = false) const                         \
     { return base::Index(e, bFromEnd); }                              \
                                                                       \

-  void Add(T Item, size_t nInsert = 1)                                \
-    { insert(end(), nInsert, Item); }                                 \
-  void Insert(T Item, size_t uiIndex, size_t nInsert = 1)             \
-    { insert(begin() + uiIndex, nInsert, Item); }                     \
+  void Add(T lItem, size_t nInsert = 1)                               \
+    { insert(end(), nInsert, lItem); }                                \
+  void Insert(T lItem, size_t uiIndex, size_t nInsert = 1)            \
+    { insert(begin() + uiIndex, nInsert, lItem); }                    \

                                                                       \
   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
     { base::RemoveAt(uiIndex, nRemove); }                             \
                                                                       \
   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
     { base::RemoveAt(uiIndex, nRemove); }                             \

-  void Remove(T Item)                                                 \
-    { int iIndex = Index(Item);                                       \
+  void Remove(T lItem)                                                \
+    { int iIndex = Index(lItem);                                      \

       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
          _WX_ERROR_REMOVE);                                           \
       RemoveAt((size_t)iIndex); }                                     \
       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
          _WX_ERROR_REMOVE);                                           \
       RemoveAt((size_t)iIndex); }                                     \


@@ -320,8 +316,9 @@ public:                                                               \
 // common declaration used by both _WX_DEFINE_TYPEARRAY and
 // _WX_DEFINE_TYPEARRAY_PTR
 #define  _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, ptrop)  \
 // common declaration used by both _WX_DEFINE_TYPEARRAY and
 // _WX_DEFINE_TYPEARRAY_PTR
 #define  _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, ptrop)  \

-wxCOMPILE_TIME_ASSERT(sizeof(T) <= sizeof(base::base_type),           \
-                       TypeTooBigToBeStoredIn##base);                 \
+wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type),          \
+                       TypeTooBigToBeStoredIn##base,                  \
+                       name);                                         \

 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2);         \
 classexp name : public base                                           \
 {                                                                     \
 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2);         \
 classexp name : public base                                           \
 {                                                                     \


@@ -341,18 +338,18 @@ public:                                                               \
   T& Last() const                                                     \
     { return (T&)(base::operator[](Count() - 1)); }                   \
                                                                       \
   T& Last() const                                                     \
     { return (T&)(base::operator[](Count() - 1)); }                   \
                                                                       \

-  int Index(T Item, bool bFromEnd = false) const                      \
-    { return base::Index((base_type)Item, bFromEnd); }                \
+  int Index(T lItem, bool bFromEnd = false) const                     \
+    { return base::Index((base_type)lItem, bFromEnd); }               \

                                                                       \
                                                                       \

-  void Add(T Item, size_t nInsert = 1)                                \
-    { base::Add((base_type)Item, nInsert); }                          \
-  void Insert(T Item, size_t uiIndex, size_t nInsert = 1)             \
-    { base::Insert((base_type)Item, uiIndex, nInsert) ; }             \
+  void Add(T lItem, size_t nInsert = 1)                               \
+    { base::Add((base_type)lItem, nInsert); }                         \
+  void Insert(T lItem, size_t uiIndex, size_t nInsert = 1)            \
+    { base::Insert((base_type)lItem, uiIndex, nInsert) ; }            \

                                                                       \
   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
     { base::RemoveAt(uiIndex, nRemove); }                             \
                                                                       \
   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
     { base::RemoveAt(uiIndex, nRemove); }                             \

-  void Remove(T Item)                                                 \
-    { int iIndex = Index(Item);                                       \
+  void Remove(T lItem)                                                \
+    { int iIndex = Index(lItem);                                      \

       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
          _WX_ERROR_REMOVE);                                           \
       base::RemoveAt((size_t)iIndex); }                               \
       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
          _WX_ERROR_REMOVE);                                           \
       base::RemoveAt((size_t)iIndex); }                               \


@@ -399,13 +396,13 @@ public:                                                               \
     reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }            \
     reference operator*() const { return *m_ptr; }                    \
     ptrop                                                             \
     reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }            \
     reference operator*() const { return *m_ptr; }                    \
     ptrop                                                             \

-    itor operator++() { --m_ptr; return *this; }                      \
-    itor operator++(int)                                              \
+    itor& operator++() { --m_ptr; return *this; }                     \
+    const itor operator++(int)                                        \

       { reverse_iterator tmp = *this; --m_ptr; return tmp; }          \
       { reverse_iterator tmp = *this; --m_ptr; return tmp; }          \

-    itor operator--() { ++m_ptr; return *this; }                      \
-    itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }   \
-    bool operator ==(const itor& it) { return m_ptr == it.m_ptr; }    \
-    bool operator !=(const itor& it) { return m_ptr != it.m_ptr; }    \
+    itor& operator--() { ++m_ptr; return *this; }                     \
+    const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }\
+    bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; }\
+    bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; }\

   };                                                                  \
                                                                       \
   class const_reverse_iterator                                        \
   };                                                                  \
                                                                       \
   class const_reverse_iterator                                        \


@@ -432,13 +429,13 @@ public:                                                               \
     const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }\
     reference operator*() const { return *m_ptr; }                    \
     ptrop                                                             \
     const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }\
     reference operator*() const { return *m_ptr; }                    \
     ptrop                                                             \

-    itor operator++() { --m_ptr; return *this; }                      \
-    itor operator++(int)                                              \
+    itor& operator++() { --m_ptr; return *this; }                     \
+    const itor operator++(int)                                        \

       { itor tmp = *this; --m_ptr; return tmp; }                      \
       { itor tmp = *this; --m_ptr; return tmp; }                      \

-    itor operator--() { ++m_ptr; return *this; }                      \
-    itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }   \
-    bool operator ==(const itor& it) { return m_ptr == it.m_ptr; }    \
-    bool operator !=(const itor& it) { return m_ptr != it.m_ptr; }    \
+    itor& operator--() { ++m_ptr; return *this; }                     \
+    const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }\
+    bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; }\
+    bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; }\

   };                                                                  \
                                                                       \
   name(size_type n, const_reference v) { assign(n, v); }              \
   };                                                                  \
                                                                       \
   name(size_type n, const_reference v) { assign(n, v); }              \


@@ -476,7 +473,8 @@ public:                                                               \
   reverse_iterator rend() { return reverse_iterator(begin() - 1); }   \
   const_reverse_iterator rend() const;                                \
   void reserve(size_type n) { base::reserve(n); };                    \
   reverse_iterator rend() { return reverse_iterator(begin() - 1); }   \
   const_reverse_iterator rend() const;                                \
   void reserve(size_type n) { base::reserve(n); };                    \

-  void resize(size_type n, value_type v = value_type());              \
+  void resize(size_type n, value_type v = value_type())               \
+    { base::resize(n, v); }                                           \

 }
 
 #define _WX_PTROP pointer operator->() const { return m_ptr; }
 }
 
 #define _WX_PTROP pointer operator->() const { return m_ptr; }


@@ -495,8 +493,9 @@ public:                                                               \
 // ----------------------------------------------------------------------------
 
 #define _WX_DEFINE_SORTED_TYPEARRAY_2(T, name, base, defcomp, classexp, comptype)\
 // ----------------------------------------------------------------------------
 
 #define _WX_DEFINE_SORTED_TYPEARRAY_2(T, name, base, defcomp, classexp, comptype)\

-wxCOMPILE_TIME_ASSERT(sizeof(T) <= sizeof(base::base_type),           \
-                      TypeTooBigToBeStoredInSorted##base);            \
+wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type),          \
+                       TypeTooBigToBeStoredInSorted##base,            \
+                       name);                                         \

 classexp name : public base                                           \
 {                                                                     \
   typedef comptype SCMPFUNC;                                          \
 classexp name : public base                                           \
 {                                                                     \
   typedef comptype SCMPFUNC;                                          \


@@ -516,22 +515,22 @@ public:                                                               \
   T& Last() const                                                     \
     { return (T&)(base::operator[](size() - 1)); }                    \
                                                                       \
   T& Last() const                                                     \
     { return (T&)(base::operator[](size() - 1)); }                    \
                                                                       \

-  int Index(T Item) const                                             \
-    { return base::Index(Item, (CMPFUNC)m_fnCompare); }               \
+  int Index(T lItem) const                                            \
+    { return base::Index(lItem, (CMPFUNC)m_fnCompare); }              \

                                                                       \
                                                                       \

-  size_t IndexForInsert(T Item) const                                 \
-    { return base::IndexForInsert(Item, (CMPFUNC)m_fnCompare); }      \
+  size_t IndexForInsert(T lItem) const                                \
+    { return base::IndexForInsert(lItem, (CMPFUNC)m_fnCompare); }     \

                                                                       \
   void AddAt(T item, size_t index)                                    \
     { base::insert(begin() + index, item); }                          \
                                                                       \
                                                                       \
   void AddAt(T item, size_t index)                                    \
     { base::insert(begin() + index, item); }                          \
                                                                       \

-  size_t Add(T Item)                                                  \
-    { return base::Add(Item, (CMPFUNC)m_fnCompare); }                 \
+  size_t Add(T lItem)                                                 \
+    { return base::Add(lItem, (CMPFUNC)m_fnCompare); }                \

                                                                       \
   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
     { base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); }  \
                                                                       \
   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
     { base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); }  \

-  void Remove(T Item)                                                 \
-    { int iIndex = Index(Item);                                       \
+  void Remove(T lItem)                                                \
+    { int iIndex = Index(lItem);                                      \

       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
         _WX_ERROR_REMOVE );                                           \
       base::erase(begin() + iIndex); }                                \
       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
         _WX_ERROR_REMOVE );                                           \
       base::erase(begin() + iIndex); }                                \


@@ -573,17 +572,17 @@ public:                                                                  \
   T& Last() const                                                        \
     { return *(T*)(base::operator[](size() - 1)); }                      \
                                                                          \
   T& Last() const                                                        \
     { return *(T*)(base::operator[](size() - 1)); }                      \
                                                                          \

-  int Index(const T& Item, bool bFromEnd = false) const;                 \
+  int Index(const T& lItem, bool bFromEnd = false) const;                \

                                                                          \
                                                                          \

-  void Add(const T& Item, size_t nInsert = 1);                           \
+  void Add(const T& lItem, size_t nInsert = 1);                          \

   void Add(const T* pItem)                                               \
     { base::push_back((T*)pItem); }                                      \
   void push_back(const T* pItem)                                         \
     { base::push_back((T*)pItem); }                                      \
   void Add(const T* pItem)                                               \
     { base::push_back((T*)pItem); }                                      \
   void push_back(const T* pItem)                                         \
     { base::push_back((T*)pItem); }                                      \

-  void push_back(const T& Item)                                          \
-    { Add(Item); }                                                       \
+  void push_back(const T& lItem)                                         \
+    { Add(lItem); }                                                      \

                                                                          \
                                                                          \

-  void Insert(const T& Item,  size_t uiIndex, size_t nInsert = 1);       \
+  void Insert(const T& lItem,  size_t uiIndex, size_t nInsert = 1);      \

   void Insert(const T* pItem, size_t uiIndex)                            \
     { base::insert(begin() + uiIndex, (T*)pItem); }                      \
                                                                          \
   void Insert(const T* pItem, size_t uiIndex)                            \
     { base::insert(begin() + uiIndex, (T*)pItem); }                      \
                                                                          \


@@ -960,6 +959,7 @@ WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble, WXDLLIMPEXP_BASE);
 
 WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(short, wxArrayShort, class WXDLLIMPEXP_BASE);
 WX_DEFINE_USER_EXPORTED_ARRAY_INT(int, wxArrayInt, class WXDLLIMPEXP_BASE);
 
 WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(short, wxArrayShort, class WXDLLIMPEXP_BASE);
 WX_DEFINE_USER_EXPORTED_ARRAY_INT(int, wxArrayInt, class WXDLLIMPEXP_BASE);

+WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(double, wxArrayDouble, class WXDLLIMPEXP_BASE);

 WX_DEFINE_USER_EXPORTED_ARRAY_LONG(long, wxArrayLong, class WXDLLIMPEXP_BASE);
 WX_DEFINE_USER_EXPORTED_ARRAY_PTR(void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE);
 
 WX_DEFINE_USER_EXPORTED_ARRAY_LONG(long, wxArrayLong, class WXDLLIMPEXP_BASE);
 WX_DEFINE_USER_EXPORTED_ARRAY_PTR(void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE);
 


@@ -970,10 +970,10 @@ WX_DEFINE_USER_EXPORTED_ARRAY_PTR(void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE
 // append all element of one array to another one
 #define WX_APPEND_ARRAY(array, other)                                         \
     {                                                                         \
 // append all element of one array to another one
 #define WX_APPEND_ARRAY(array, other)                                         \
     {                                                                         \

-        size_t count = (other).size();                                        \
-        for ( size_t n = 0; n < count; n++ )                                  \
+        size_t wxAAcnt = (other).size();                                      \
+        for ( size_t wxAAn = 0; wxAAn < wxAAcnt; wxAAn++ )                    \

         {                                                                     \
         {                                                                     \

-            (array).push_back((other)[n]);                                    \
+            (array).push_back((other)[wxAAn]);                                \

         }                                                                     \
     }
 
         }                                                                     \
     }
 


@@ -985,10 +985,10 @@ WX_DEFINE_USER_EXPORTED_ARRAY_PTR(void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE
 //     count on it)!
 #define WX_CLEAR_ARRAY(array)                                                 \
     {                                                                         \
 //     count on it)!
 #define WX_CLEAR_ARRAY(array)                                                 \
     {                                                                         \

-        size_t count = (array).size();                                        \
-        for ( size_t n = 0; n < count; n++ )                                  \
+        size_t wxAAcnt = (array).size();                                      \
+        for ( size_t wxAAn = 0; wxAAn < wxAAcnt; wxAAn++ )                    \

         {                                                                     \
         {                                                                     \

-            delete (array)[n];                                                \
+            delete (array)[wxAAn];                                            \

         }                                                                     \
                                                                               \
         (array).clear();                                                      \
         }                                                                     \
                                                                               \
         (array).clear();                                                      \