Use CmdDown in mouse events instead of ControlDown so Mac users can

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

diff --git a/include/wx/dynarray.h b/include/wx/dynarray.h
index 0f1751ade0be029db1b67029ea75b8ed2d09db9d..a70982e87c86b8e692df5ed5b9061ef81761f5ad 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


@@ -296,15 +291,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); }                                     \


@@ -342,18 +337,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); }                               \


@@ -400,13 +395,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                                        \


@@ -433,13 +428,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); }              \


@@ -518,22 +513,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); }                                \


@@ -575,17 +570,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); }                      \
                                                                          \


@@ -972,10 +967,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]);                                \

         }                                                                     \
     }
 
         }                                                                     \
     }
 


@@ -987,10 +982,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();                                                      \