X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/335991afa513fee73e1def9824fa2d547686f659..e2eafeff03e55e8af173168ec4d4378f5c9d4630:/include/wx/dynarray.h?ds=inline diff --git a/include/wx/dynarray.h b/include/wx/dynarray.h index b836cffb72..0f1751ade0 100644 --- a/include/wx/dynarray.h +++ b/include/wx/dynarray.h @@ -12,7 +12,7 @@ #ifndef _DYNARRAY_H #define _DYNARRAY_H -#if defined(__GNUG__) && !defined(__APPLE__) && \ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && \ !(defined(__MINGW32__) && __GNUC__ == 3 && __GNUC_MINOR__ == 2) #pragma interface "dynarray.h" #endif @@ -86,9 +86,44 @@ typedef int (wxCMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2); #if wxUSE_STL +template +class WXDLLIMPEXP_BASE wxArray_SortFunction +{ +public: + typedef int (wxCMPFUNC_CONV *CMPFUNC)(T* pItem1, T* pItem2); + + wxArray_SortFunction(CMPFUNC f) : m_f(f) { } + bool operator()(const T& i1, const T& i2) + { return m_f((T*)&i1, (T*)&i2) < 0; } +private: + CMPFUNC m_f; +}; + +template +class WXDLLIMPEXP_BASE wxSortedArray_SortFunction +{ +public: + typedef F CMPFUNC; + + wxSortedArray_SortFunction(CMPFUNC f) : m_f(f) { } + bool operator()(const T& i1, const T& i2) + { return m_f(i1, i2) < 0; } +private: + CMPFUNC m_f; +}; + #define _WX_DECLARE_BASEARRAY(T, name, classexp) \ + typedef int (wxCMPFUNC_CONV *CMPFUN##name)(T pItem1, T pItem2); \ + typedef wxSortedArray_SortFunction name##_Predicate; \ + _WX_DECLARE_BASEARRAY_2(T, name, name##_Predicate, classexp) + +#define _WX_DECLARE_BASEARRAY_2(T, name, predicate, classexp) \ classexp name : public std::vector \ { \ + typedef predicate Predicate; \ + typedef predicate::CMPFUNC SCMPFUNC; \ +public: \ + typedef wxArray_SortFunction::CMPFUNC CMPFUNC; \ public: \ void Empty() { clear(); } \ void Clear() { clear(); } \ @@ -106,7 +141,7 @@ protected: \ T& Item(size_t uiIndex) const \ { wxASSERT( uiIndex < size() ); return (T&)operator[](uiIndex); } \ \ - int Index(T e, bool bFromEnd = FALSE) const; \ + int Index(T e, bool bFromEnd = false) const; \ int Index(T lItem, CMPFUNC fnCompare) const; \ size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const; \ void Add(T lItem, size_t nInsert = 1) \ @@ -120,19 +155,9 @@ protected: \ \ void Sort(CMPFUNC fCmp) \ { \ - Predicate p(fCmp); \ + wxArray_SortFunction p(fCmp); \ std::sort(begin(), end(), p); \ } \ -private: \ - class Predicate \ - { \ - typedef CMPFUNC fnc; \ - fnc m_f; \ - public: \ - Predicate(fnc f) : m_f(f) { } \ - bool operator()(const T& i1, const T& i2) \ - { return m_f((T*)&i1, (T*)&i2) < 0; /* const cast */ } \ - }; \ } #else // if !wxUSE_STL @@ -140,6 +165,7 @@ private: \ #define _WX_DECLARE_BASEARRAY(T, name, classexp) \ classexp name \ { \ + typedef CMPFUNC SCMPFUNC; /* for compatibility wuth wxUSE_STL */ \ public: \ name(); \ name(const name& array); \ @@ -152,7 +178,7 @@ public: \ void Shrink(); \ \ size_t GetCount() const { return m_nCount; } \ - void SetCount(size_t n, T defval = T(0)); \ + void SetCount(size_t n, T defval = T()); \ bool IsEmpty() const { return m_nCount == 0; } \ size_t Count() const { return m_nCount; } \ \ @@ -163,7 +189,7 @@ protected: \ { wxASSERT( uiIndex < m_nCount ); return m_pItems[uiIndex]; } \ T& operator[](size_t uiIndex) const { return Item(uiIndex); } \ \ - int Index(T lItem, bool bFromEnd = FALSE) const; \ + int Index(T lItem, bool bFromEnd = false) const; \ int Index(T lItem, CMPFUNC fnCompare) const; \ size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const; \ void Add(T lItem, size_t nInsert = 1); \ @@ -186,8 +212,6 @@ protected: \ void assign(const_iterator first, const_iterator last); \ void assign(size_type n, const_reference v); \ size_type capacity() const { return m_nSize; } \ - void clear() { Clear(); } \ - bool empty() const { return IsEmpty(); } \ iterator erase(iterator first, iterator last) \ { \ size_type idx = first - begin(); \ @@ -204,17 +228,24 @@ protected: \ return begin() + idx; \ } \ void insert(iterator it, const_iterator first, const_iterator last);\ - size_type max_size() const { return INT_MAX; } \ 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()); \ - size_type size() const { return GetCount(); } \ \ iterator begin() { return m_pItems; } \ iterator end() { return m_pItems + m_nCount; } \ const_iterator begin() const { return m_pItems; } \ const_iterator end() const { return m_pItems + m_nCount; } \ + \ + /* the following functions may be made directly public because */ \ + /* they don't use the type of the elements at all */ \ +public: \ + void clear() { Clear(); } \ + bool empty() const { return IsEmpty(); } \ + size_type max_size() const { return INT_MAX; } \ + size_type size() const { return GetCount(); } \ + \ private: \ void Grow(size_t nIncrement = 0); \ bool Realloc(size_t nSize); \ @@ -262,7 +293,7 @@ public: \ T& Last() const \ { return Item(Count() - 1); } \ \ - int Index(T e, bool bFromEnd = FALSE) const \ + int Index(T e, bool bFromEnd = false) const \ { return base::Index(e, bFromEnd); } \ \ void Add(T Item, size_t nInsert = 1) \ @@ -281,9 +312,14 @@ public: \ void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC)fCmp); } \ } +#define _WX_DEFINE_TYPEARRAY_PTR(T, name, base, classexp) \ + _WX_DEFINE_TYPEARRAY(T, name, base, classexp) + #else // if !wxUSE_STL -#define _WX_DEFINE_TYPEARRAY(T, name, base, classexp) \ +// 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_ASSERT2(sizeof(T) <= sizeof(base::base_type), \ TypeTooBigToBeStoredIn##base, \ name); \ @@ -306,7 +342,7 @@ public: \ T& Last() const \ { return (T&)(base::operator[](Count() - 1)); } \ \ - int Index(T Item, bool bFromEnd = FALSE) const \ + int Index(T Item, bool bFromEnd = false) const \ { return base::Index((base_type)Item, bFromEnd); } \ \ void Add(T Item, size_t nInsert = 1) \ @@ -363,7 +399,7 @@ public: \ reverse_iterator(pointer ptr) : m_ptr(ptr) { } \ reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } \ reference operator*() const { return *m_ptr; } \ - pointer operator->() const { return m_ptr; } \ + ptrop \ itor operator++() { --m_ptr; return *this; } \ itor operator++(int) \ { reverse_iterator tmp = *this; --m_ptr; return tmp; } \ @@ -396,7 +432,7 @@ public: \ const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } \ const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }\ reference operator*() const { return *m_ptr; } \ - pointer operator->() const { return m_ptr; } \ + ptrop \ itor operator++() { --m_ptr; return *this; } \ itor operator++(int) \ { itor tmp = *this; --m_ptr; return tmp; } \ @@ -406,6 +442,9 @@ public: \ bool operator !=(const itor& it) { return m_ptr != it.m_ptr; } \ }; \ \ + name(size_type n, const_reference v) { assign(n, v); } \ + name(const_iterator first, const_iterator last) \ + { assign(first, last); } \ void assign(const_iterator first, const_iterator last) \ { base::assign((bconst_iterator)first, (bconst_iterator)last); } \ void assign(size_type n, const_reference v) \ @@ -415,8 +454,6 @@ public: \ iterator begin() { return (iterator)base::begin(); } \ const_iterator begin() const { return (const_iterator)base::begin(); }\ size_type capacity() const { return base::capacity(); } \ - void clear() { base::clear(); } \ - bool empty() const { return base::empty(); } \ iterator end() { return (iterator)base::end(); } \ const_iterator end() const { return (const_iterator)base::end(); } \ iterator erase(iterator first, iterator last) \ @@ -432,7 +469,6 @@ public: \ void insert(iterator it, const_iterator first, const_iterator last) \ { base::insert((biterator)it, (bconst_iterator)first, \ (bconst_iterator)last); } \ - size_type max_size() const { return base::max_size(); } \ void pop_back() { base::pop_back(); } \ void push_back(const_reference v) \ { base::push_back((bconst_reference)v); } \ @@ -442,9 +478,15 @@ public: \ const_reverse_iterator rend() const; \ void reserve(size_type n) { base::reserve(n); }; \ void resize(size_type n, value_type v = value_type()); \ - size_type size() const { return base::size(); } \ } +#define _WX_PTROP pointer operator->() const { return m_ptr; } +#define _WX_PTROP_NONE + +#define _WX_DEFINE_TYPEARRAY(T, name, base, classexp) \ + _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, _WX_PTROP) +#define _WX_DEFINE_TYPEARRAY_PTR(T, name, base, classexp) \ + _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, _WX_PTROP_NONE) #endif // !wxUSE_STL @@ -459,6 +501,7 @@ wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type), \ name); \ classexp name : public base \ { \ + typedef comptype SCMPFUNC; \ public: \ name(comptype fn defcomp) { m_fnCompare = fn; } \ \ @@ -521,6 +564,7 @@ public: \ size_t GetCount() const { return base_array::size(); } \ size_t size() const { return base_array::size(); } \ bool IsEmpty() const { return base_array::empty(); } \ + bool empty() const { return base_array::empty(); } \ size_t Count() const { return base_array::size(); } \ void Shrink() { base::Shrink(); } \ \ @@ -531,7 +575,7 @@ public: \ T& Last() const \ { return *(T*)(base::operator[](size() - 1)); } \ \ - int Index(const T& Item, bool bFromEnd = FALSE) const; \ + int Index(const T& Item, bool bFromEnd = false) const; \ \ void Add(const T& Item, size_t nInsert = 1); \ void Add(const T* pItem) \ @@ -569,7 +613,7 @@ private: \ // same except that they use an additional __declspec(dllexport) or equivalent // under Windows if needed. // -// The first (just EXPORTED) macros do it if wxWindows was compiled as a DLL +// The first (just EXPORTED) macros do it if wxWidgets was compiled as a DLL // and so must be used used inside the library. The second kind (USER_EXPORTED) // allow the user code to do it when it wants. This is needed if you have a dll // that wants to export a wxArray daubed with your own import/export goo. @@ -604,16 +648,29 @@ private: \ #define WX_DEFINE_TYPEARRAY(T, name, base) \ WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class wxARRAY_DEFAULT_EXPORT) +#define WX_DEFINE_TYPEARRAY_PTR(T, name, base) \ + WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class wxARRAY_DEFAULT_EXPORT) + #define WX_DEFINE_EXPORTED_TYPEARRAY(T, name, base) \ WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class WXDLLEXPORT) +#define WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, base) \ + WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class WXDLLEXPORT) + #define WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, expdecl) \ WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class expdecl) +#define WX_DEFINE_USER_EXPORTED_TYPEARRAY_PTR(T, name, base, expdecl) \ + WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class expdecl) + #define WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, classdecl) \ typedef T _wxArray##name; \ _WX_DEFINE_TYPEARRAY(_wxArray##name, name, base, classdecl) +#define WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, classdecl) \ + typedef T _wxArray##name; \ + _WX_DEFINE_TYPEARRAY_PTR(_wxArray##name, name, base, classdecl) + // ---------------------------------------------------------------------------- // WX_DEFINE_SORTED_TYPEARRAY: this is the same as the previous macro, but it // defines a sorted array. @@ -729,9 +786,12 @@ private: \ #define WX_DECLARE_EXPORTED_OBJARRAY(T, name) \ WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, WXDLLEXPORT) -#define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \ +#define WX_DECLARE_OBJARRAY_WITH_DECL(T, name, decl) \ typedef T _wxObjArray##name; \ - _WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, class expmode) + _WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, decl) + +#define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \ + WX_DECLARE_OBJARRAY_WITH_DECL(T, name, class expmode) // WX_DEFINE_OBJARRAY is going to be redefined when arrimpl.cpp is included, // try to provoke a human-understandable error if it used incorrectly. @@ -748,14 +808,11 @@ private: \ WX_DECLARE_USER_EXPORTED_BASEARRAY(const void *, wxBaseArrayPtrVoid, WXDLLIMPEXP_BASE); -WX_DECLARE_USER_EXPORTED_BASEARRAY(short, wxBaseArrayShort, - WXDLLIMPEXP_BASE); -WX_DECLARE_USER_EXPORTED_BASEARRAY(int, wxBaseArrayInt, - WXDLLIMPEXP_BASE); -WX_DECLARE_USER_EXPORTED_BASEARRAY(long, wxBaseArrayLong, - WXDLLIMPEXP_BASE); -WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble, - WXDLLIMPEXP_BASE); +WX_DECLARE_USER_EXPORTED_BASEARRAY(short, wxBaseArrayShort, WXDLLIMPEXP_BASE); +WX_DECLARE_USER_EXPORTED_BASEARRAY(int, wxBaseArrayInt, WXDLLIMPEXP_BASE); +WX_DECLARE_USER_EXPORTED_BASEARRAY(long, wxBaseArrayLong, WXDLLIMPEXP_BASE); +WX_DECLARE_USER_EXPORTED_BASEARRAY(size_t, wxBaseArraySizeT, WXDLLIMPEXP_BASE); +WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble, WXDLLIMPEXP_BASE); // ---------------------------------------------------------------------------- // Convenience macros to define arrays from base arrays @@ -763,38 +820,53 @@ WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble, #define WX_DEFINE_ARRAY(T, name) \ WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayPtrVoid) +#define WX_DEFINE_ARRAY_PTR(T, name) \ + WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayPtrVoid) #define WX_DEFINE_EXPORTED_ARRAY(T, name) \ WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid) +#define WX_DEFINE_EXPORTED_ARRAY_PTR(T, name) \ + WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayPtrVoid) +#define WX_DEFINE_ARRAY_WITH_DECL_PTR(T, name, decl) \ + WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayPtrVoid, decl) #define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode) \ WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayPtrVoid, expmode) +#define WX_DEFINE_USER_EXPORTED_ARRAY_PTR(T, name, expmode) \ + WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayPtrVoid, expmode) #define WX_DEFINE_ARRAY_SHORT(T, name) \ - WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayShort) + WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayShort) #define WX_DEFINE_EXPORTED_ARRAY_SHORT(T, name) \ - WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort) + WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayShort) #define WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(T, name, expmode) \ - WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayShort, expmode) + WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayShort, expmode) #define WX_DEFINE_ARRAY_INT(T, name) \ - WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayInt) + WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayInt) #define WX_DEFINE_EXPORTED_ARRAY_INT(T, name) \ - WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt) + WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayInt) #define WX_DEFINE_USER_EXPORTED_ARRAY_INT(T, name, expmode) \ - WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayInt, expmode) + WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayInt, expmode) #define WX_DEFINE_ARRAY_LONG(T, name) \ - WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayLong) + WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayLong) #define WX_DEFINE_EXPORTED_ARRAY_LONG(T, name) \ - WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong) + WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayLong) #define WX_DEFINE_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \ - WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayLong, expmode) + WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayLong, expmode) + +#define WX_DEFINE_ARRAY_SIZE_T(T, name) \ + WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArraySizeT) +#define WX_DEFINE_EXPORTED_ARRAY_SIZE_T(T, name) \ + WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArraySizeT) +#define WX_DEFINE_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode) \ + WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArraySizeT, expmode) #define WX_DEFINE_ARRAY_DOUBLE(T, name) \ - WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayDouble) + WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayDouble) #define WX_DEFINE_EXPORTED_ARRAY_DOUBLE(T, name) \ - WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayDouble) + WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayDouble) #define WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(T, name, expmode) \ - WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayDouble, expmode) + WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayDouble, expmode) // ---------------------------------------------------------------------------- // Convenience macros to define sorted arrays from base arrays @@ -828,6 +900,13 @@ WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble, #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \ WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode) +#define WX_DEFINE_SORTED_ARRAY_SIZE_T(T, name) \ + WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArraySizeT) +#define WX_DEFINE_SORTED_EXPORTED_ARRAY_SIZE_T(T, name) \ + WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT) +#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode) \ + WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT, expmode) + // ---------------------------------------------------------------------------- // Convenience macros to define sorted arrays from base arrays // ---------------------------------------------------------------------------- @@ -868,14 +947,23 @@ WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble, WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \ wxBaseArrayLong, expmode) +#define WX_DEFINE_SORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name) \ + WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT) +#define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name) \ + WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT) +#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, \ + name, expmode) \ + WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \ + wxBaseArraySizeT, expmode) + // ---------------------------------------------------------------------------- // Some commonly used predefined arrays // ---------------------------------------------------------------------------- -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_LONG (long, wxArrayLong, class WXDLLIMPEXP_BASE); -WX_DEFINE_USER_EXPORTED_ARRAY (void *, wxArrayPtrVoid, 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_LONG(long, wxArrayLong, class WXDLLIMPEXP_BASE); +WX_DEFINE_USER_EXPORTED_ARRAY_PTR(void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE); // ----------------------------------------------------------------------------- // convenience macros