X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/6c8a980fc412792e64256724e02e9d387ee38e21..43c42c18d36c703a88b1b7b697bac27fe5608eca:/include/wx/ctrlsub.h diff --git a/include/wx/ctrlsub.h b/include/wx/ctrlsub.h index b785bea964..a55e124148 100644 --- a/include/wx/ctrlsub.h +++ b/include/wx/ctrlsub.h @@ -5,94 +5,476 @@ // Modified by: // Created: 22.10.99 // RCS-ID: $Id$ -// Copyright: (c) wxWindows team -// Licence: wxWindows license +// Copyright: (c) wxWidgets team +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// #ifndef _WX_CTRLSUB_H_BASE_ #define _WX_CTRLSUB_H_BASE_ -#ifdef __GNUG__ - #pragma interface "controlwithitems.h" -#endif +#include "wx/defs.h" + +#if wxUSE_CONTROLS +#include "wx/arrstr.h" #include "wx/control.h" // base class // ---------------------------------------------------------------------------- -// wxControlWithItems defines an interface which is implemented by all controls +// wxItemContainer defines an interface which is implemented by all controls // which have string subitems each of which may be selected. // -// Examples: wxListBox, wxCheckListBox, wxChoice and wxComboBox +// It is decomposed in wxItemContainerImmutable which omits all methods +// adding/removing items and is used by wxRadioBox and wxItemContainer itself. +// +// Examples: wxListBox, wxCheckListBox, wxChoice and wxComboBox (which +// implements an extended interface deriving from this one) // ---------------------------------------------------------------------------- -class WXDLLEXPORT wxControlWithItems : public wxControl +class WXDLLIMPEXP_CORE wxItemContainerImmutable { public: - wxControlWithItems() { m_clientDataItemsType = ClientData_None; } + wxItemContainerImmutable() { } + virtual ~wxItemContainerImmutable(); - // adding items - // ------------ + // accessing strings + // ----------------- - void Append(const wxString& item) - { DoAppend(item); } - void Append(const wxString& item, void *clientData) - { int n = DoAppend(item); SetClientData(n, clientData); } - void Append(const wxString& item, wxClientData *clientData) - { int n = DoAppend(item); SetClientObject(n, clientData); } + virtual unsigned int GetCount() const = 0; + bool IsEmpty() const { return GetCount() == 0; } - // deleting items - // -------------- + virtual wxString GetString(unsigned int n) const = 0; + wxArrayString GetStrings() const; + virtual void SetString(unsigned int n, const wxString& s) = 0; - virtual void Clear() = 0; - virtual void Delete(int n) = 0; + // finding string natively is either case sensitive or insensitive + // but never both so fall back to this base version for not + // supported search type + virtual int FindString(const wxString& s, bool bCase = false) const + { + unsigned int count = GetCount(); - // accessing strings - // ----------------- + for ( unsigned int i = 0; i < count ; ++i ) + { + if (GetString(i).IsSameAs( s , bCase )) + return (int)i; + } + + return wxNOT_FOUND; + } - virtual int GetCount() const = 0; - virtual wxString GetString(int n) const = 0; - virtual void SetString(int n, const wxString& s) = 0; - virtual int FindString(const wxString& s) const = 0; // selection // --------- - virtual void Select(int n) = 0; + virtual void SetSelection(int n) = 0; virtual int GetSelection() const = 0; - wxString GetStringSelection() const; + // set selection to the specified string, return false if not found + bool SetStringSelection(const wxString& s); + + // return the selected string or empty string if none + virtual wxString GetStringSelection() const; + + // this is the same as SetSelection( for single-selection controls but + // reads better for multi-selection ones + void Select(int n) { SetSelection(n); } + + +protected: + // check that the index is valid + bool IsValid(unsigned int n) const { return n < GetCount(); } + bool IsValidInsert(unsigned int n) const { return n <= GetCount(); } +}; + +// ---------------------------------------------------------------------------- +// wxItemContainer extends wxItemContainerImmutable interface with methods +// for adding/removing items. +// +// Classes deriving from this one must override DoInsertItems() to implement +// adding items to the control. This can often be implemented more efficiently +// than simply looping over the elements and inserting them but if this is not +// the case, the generic DoInsertItemsInLoop can be used in implementation, but +// in this case DoInsertItem() needs to be overridden. +// ---------------------------------------------------------------------------- + +class WXDLLIMPEXP_CORE wxItemContainer : public wxItemContainerImmutable +{ +private: + // AppendItems() and InsertItems() helpers just call DoAppend/InsertItems() + // after doing some checks + // + // NB: they're defined here so that they're inlined when used in public part + int AppendItems(const wxArrayStringsAdapter& items, + void **clientData, + wxClientDataType type) + { + if ( items.IsEmpty() ) + return wxNOT_FOUND; + + return DoAppendItems(items, clientData, type); + } + + int AppendItems(const wxArrayStringsAdapter& items) + { + return AppendItems(items, NULL, wxClientData_None); + } + + int AppendItems(const wxArrayStringsAdapter& items, void **clientData) + { + wxASSERT_MSG( GetClientDataType() != wxClientData_Object, + wxT("can't mix different types of client data") ); + + return AppendItems(items, clientData, wxClientData_Void); + } + + int AppendItems(const wxArrayStringsAdapter& items, + wxClientData **clientData) + { + wxASSERT_MSG( GetClientDataType() != wxClientData_Void, + wxT("can't mix different types of client data") ); + + return AppendItems(items, reinterpret_cast(clientData), + wxClientData_Object); + } + + int InsertItems(const wxArrayStringsAdapter& items, + unsigned int pos, + void **clientData, + wxClientDataType type) + { + wxASSERT_MSG( !IsSorted(), wxT("can't insert items in sorted control") ); + + wxCHECK_MSG( pos <= GetCount(), wxNOT_FOUND, + wxT("position out of range") ); + + // not all derived classes handle empty arrays correctly in + // DoInsertItems() and besides it really doesn't make much sense to do + // this (for append it could correspond to creating an initially empty + // control but why would anybody need to insert 0 items?) + wxCHECK_MSG( !items.IsEmpty(), wxNOT_FOUND, + wxT("need something to insert") ); + + return DoInsertItems(items, pos, clientData, type); + } + + int InsertItems(const wxArrayStringsAdapter& items, unsigned int pos) + { + return InsertItems(items, pos, NULL, wxClientData_None); + } + + int InsertItems(const wxArrayStringsAdapter& items, + unsigned int pos, + void **clientData) + { + wxASSERT_MSG( GetClientDataType() != wxClientData_Object, + wxT("can't mix different types of client data") ); + + return InsertItems(items, pos, clientData, wxClientData_Void); + } + + int InsertItems(const wxArrayStringsAdapter& items, + unsigned int pos, + wxClientData **clientData) + { + wxASSERT_MSG( GetClientDataType() != wxClientData_Void, + wxT("can't mix different types of client data") ); + + return InsertItems(items, pos, + reinterpret_cast(clientData), + wxClientData_Object); + } + +public: + wxItemContainer() { m_clientDataItemsType = wxClientData_None; } + virtual ~wxItemContainer(); + + // adding items + // ------------ + + // append single item, return its position in the control (which can be + // different from the last one if the control is sorted) + int Append(const wxString& item) + { return AppendItems(item); } + int Append(const wxString& item, void *clientData) + { return AppendItems(item, &clientData); } + int Append(const wxString& item, wxClientData *clientData) + { return AppendItems(item, &clientData); } + + // append several items at once to the control, return the position of the + // last item appended + int Append(const wxArrayString& items) + { return AppendItems(items); } + int Append(const wxArrayString& items, void **clientData) + { return AppendItems(items, clientData); } + int Append(const wxArrayString& items, wxClientData **clientData) + { return AppendItems(items, clientData); } + int Append(unsigned int n, const wxString *items) + { return AppendItems(wxArrayStringsAdapter(n, items)); } + int Append(unsigned int n, const wxString *items, void **clientData) + { return AppendItems(wxArrayStringsAdapter(n, items), clientData); } + int Append(unsigned int n, + const wxString *items, + wxClientData **clientData) + { return AppendItems(wxArrayStringsAdapter(n, items), clientData); } + + // only for RTTI needs (separate name) + void AppendString(const wxString& item) + { Append(item); } + + + // inserting items: not for sorted controls! + // ----------------------------------------- + + // insert single item at the given position, return its effective position + int Insert(const wxString& item, unsigned int pos) + { return InsertItems(item, pos); } + int Insert(const wxString& item, unsigned int pos, void *clientData) + { return InsertItems(item, pos, &clientData); } + int Insert(const wxString& item, unsigned int pos, wxClientData *clientData) + { return InsertItems(item, pos, &clientData); } + + // insert several items at once into the control, return the index of the + // last item inserted + int Insert(const wxArrayString& items, unsigned int pos) + { return InsertItems(items, pos); } + int Insert(const wxArrayString& items, unsigned int pos, void **clientData) + { return InsertItems(items, pos, clientData); } + int Insert(const wxArrayString& items, + unsigned int pos, + wxClientData **clientData) + { return InsertItems(items, pos, clientData); } + int Insert(unsigned int n, const wxString *items, unsigned int pos) + { return InsertItems(wxArrayStringsAdapter(n, items), pos); } + int Insert(unsigned int n, + const wxString *items, + unsigned int pos, + void **clientData) + { return InsertItems(wxArrayStringsAdapter(n, items), pos, clientData); } + int Insert(unsigned int n, + const wxString *items, + unsigned int pos, + wxClientData **clientData) + { return InsertItems(wxArrayStringsAdapter(n, items), pos, clientData); } + + + // replacing items + // --------------- + + void Set(const wxArrayString& items) + { Clear(); Append(items); } + void Set(const wxArrayString& items, void **clientData) + { Clear(); Append(items, clientData); } + void Set(const wxArrayString& items, wxClientData **clientData) + { Clear(); Append(items, clientData); } + void Set(unsigned int n, const wxString *items) + { Clear(); Append(n, items); } + void Set(unsigned int n, const wxString *items, void **clientData) + { Clear(); Append(n, items, clientData); } + void Set(unsigned int n, const wxString *items, wxClientData **clientData) + { Clear(); Append(n, items, clientData); } + + // deleting items + // -------------- + + void Clear(); + void Delete(unsigned int pos); + + + // various accessors + // ----------------- + + // The control may maintain its items in a sorted order in which case + // items are automatically inserted at the right position when they are + // inserted or appended. Derived classes have to override this method if + // they implement sorting, typically by returning HasFlag(wxXX_SORT) + virtual bool IsSorted() const { return false; } - // misc - // ---- // client data stuff - void SetClientData(int n, void* clientData); - void* GetClientData(int n) const; + // ----------------- + + void SetClientData(unsigned int n, void* clientData); + void* GetClientData(unsigned int n) const; - void SetClientObject(int n, wxClientData* clientData); - wxClientData* GetClientObject(int n) const; + // SetClientObject() takes ownership of the pointer, GetClientObject() + // returns it but keeps the ownership while DetachClientObject() expects + // the caller to delete the pointer and also resets the internally stored + // one to NULL for this item + void SetClientObject(unsigned int n, wxClientData* clientData); + wxClientData* GetClientObject(unsigned int n) const; + wxClientData* DetachClientObject(unsigned int n); + // return the type of client data stored in this control: usually it just + // returns m_clientDataItemsType but must be overridden in the controls + // which delegate their client data storage to another one (e.g. wxChoice + // in wxUniv which stores data in wxListBox which it uses anyhow); don't + // forget to override SetClientDataType() if you override this one + // + // NB: for this to work no code should ever access m_clientDataItemsType + // directly but only via this function! + virtual wxClientDataType GetClientDataType() const + { return m_clientDataItemsType; } + + bool HasClientData() const + { return GetClientDataType() != wxClientData_None; } bool HasClientObjectData() const - { return m_clientDataItemsType == ClientData_Object; } + { return GetClientDataType() == wxClientData_Object; } bool HasClientUntypedData() const - { return m_clientDataItemsType == ClientData_Void; } - - // compatibility - these functions are deprecated, use the new ones - // instead - int Number() const { return GetCount(); } + { return GetClientDataType() == wxClientData_Void; } protected: - virtual int DoAppend(const wxString& item) = 0; + // there is usually no need to override this method but you can do it if it + // is more convenient to only do "real" insertions in DoInsertItems() and + // to implement items appending here (in which case DoInsertItems() should + // call this method if pos == GetCount() as it can still be called in this + // case if public Insert() is called with such position) + virtual int DoAppendItems(const wxArrayStringsAdapter& items, + void **clientData, + wxClientDataType type) + { + return DoInsertItems(items, GetCount(), clientData, type); + } + + // this method must be implemented to insert the items into the control at + // position pos which can be GetCount() meaning that the items should be + // appended; for the sorted controls the position can be ignored + // + // the derived classes typically use AssignNewItemClientData() to + // associate the data with the items as they're being inserted + // + // the method should return the index of the position the last item was + // inserted into or wxNOT_FOUND if an error occurred + virtual int DoInsertItems(const wxArrayStringsAdapter & items, + unsigned int pos, + void **clientData, + wxClientDataType type) = 0; + + // before the client data is set for the first time for the control which + // hadn't had it before, DoInitItemClientData() is called which gives the + // derived class the possibility to initialize its client data storage only + // when client data is really used + virtual void DoInitItemClientData() { } + virtual void DoSetItemClientData(unsigned int n, void *clientData) = 0; + virtual void *DoGetItemClientData(unsigned int n) const = 0; + + virtual void DoClear() = 0; + virtual void DoDeleteOneItem(unsigned int pos) = 0; + + + // methods useful for the derived classes which don't have any better way + // of adding multiple items to the control than doing it one by one: such + // classes should call DoInsertItemsInLoop() from their DoInsert() and + // override DoInsertOneItem() to perform the real insertion + virtual int DoInsertOneItem(const wxString& item, unsigned int pos); + int DoInsertItemsInLoop(const wxArrayStringsAdapter& items, + unsigned int pos, + void **clientData, + wxClientDataType type); + + + // helper for DoInsertItems(): n is the index into clientData, pos is the + // position of the item in the control + void AssignNewItemClientData(unsigned int pos, + void **clientData, + unsigned int n, + wxClientDataType type); - virtual void DoSetItemClientData(int n, void* clientData) = 0; - virtual void* DoGetItemClientData(int n) const = 0; - virtual void DoSetItemClientObject(int n, wxClientData* clientData) = 0; - virtual wxClientData* DoGetItemClientObject(int n) const = 0; + // free the client object associated with the item at given position and + // set it to NULL (must only be called if HasClientObjectData()) + void ResetItemClientObject(unsigned int n); + // set the type of the client data stored in this control: override this if + // you override GetClientDataType() + virtual void SetClientDataType(wxClientDataType clientDataItemsType) + { + m_clientDataItemsType = clientDataItemsType; + } + +private: // the type of the client data for the items wxClientDataType m_clientDataItemsType; }; -#endif // _WX_CTRLSUB_H_BASE_ +// Inheriting directly from a wxWindow-derived class and wxItemContainer +// unfortunately introduces an ambiguity for all GetClientXXX() methods as they +// are inherited twice: the "global" versions from wxWindow and the per-item +// versions taking the index from wxItemContainer. +// +// So we need to explicitly resolve them and this helper template class is +// provided to do it. To use it, simply inherit from wxWindowWithItems instead of Window and Container interface directly. +template +class wxWindowWithItems : public W, public C +{ +public: + typedef W BaseWindowClass; + typedef C BaseContainerInterface; + + wxWindowWithItems() { } + + void SetClientData(void *data) + { BaseWindowClass::SetClientData(data); } + void *GetClientData() const + { return BaseWindowClass::GetClientData(); } + void SetClientObject(wxClientData *data) + { BaseWindowClass::SetClientObject(data); } + wxClientData *GetClientObject() const + { return BaseWindowClass::GetClientObject(); } + + void SetClientData(unsigned int n, void* clientData) + { wxItemContainer::SetClientData(n, clientData); } + void* GetClientData(unsigned int n) const + { return wxItemContainer::GetClientData(n); } + void SetClientObject(unsigned int n, wxClientData* clientData) + { wxItemContainer::SetClientObject(n, clientData); } + wxClientData* GetClientObject(unsigned int n) const + { return wxItemContainer::GetClientObject(n); } +}; + +class WXDLLIMPEXP_CORE wxControlWithItemsBase : + public wxWindowWithItems +{ +public: + wxControlWithItemsBase() { } + // usually the controls like list/combo boxes have their own background + // colour + virtual bool ShouldInheritColours() const { return false; } + + // Implementation only from now on. + + // Generate an event of the given type for the selection change. + void SendSelectionChangedEvent(wxEventType eventType); + +protected: + // fill in the client object or data field of the event as appropriate + // + // calls InitCommandEvent() and, if n != wxNOT_FOUND, also sets the per + // item client data + void InitCommandEventWithItems(wxCommandEvent& event, int n); + +private: + wxDECLARE_NO_COPY_CLASS(wxControlWithItemsBase); +}; + +// define the platform-specific wxControlWithItems class +#if defined(__WXMSW__) + #include "wx/msw/ctrlsub.h" +#elif defined(__WXMOTIF__) + #include "wx/motif/ctrlsub.h" +#else + class WXDLLIMPEXP_CORE wxControlWithItems : public wxControlWithItemsBase + { + public: + wxControlWithItems() { } + + private: + DECLARE_ABSTRACT_CLASS(wxControlWithItems) + wxDECLARE_NO_COPY_CLASS(wxControlWithItems); + }; +#endif + +#endif // wxUSE_CONTROLS + +#endif // _WX_CTRLSUB_H_BASE_