/////////////////////////////////////////////////////////////////////////////
-// Name: univ/listbox.cpp
+// Name: src/univ/listbox.cpp
// Purpose: wxListBox implementation
// Author: Vadim Zeitlin
// Modified by:
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "univlistbox.h"
-#endif
-
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#include "wx/univ/inphand.h"
#include "wx/univ/theme.h"
+// ----------------------------------------------------------------------------
+// wxStdListboxInputHandler: handles mouse and kbd in a single or multi
+// selection listbox
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxStdListboxInputHandler : public wxStdInputHandler
+{
+public:
+ // if pressing the mouse button in a multiselection listbox should toggle
+ // the item under mouse immediately, then specify true as the second
+ // parameter (this is the standard behaviour, under GTK the item is toggled
+ // only when the mouse is released in the multi selection listbox)
+ wxStdListboxInputHandler(wxInputHandler *inphand,
+ bool toggleOnPressAlways = true);
+
+ // base class methods
+ virtual bool HandleKey(wxInputConsumer *consumer,
+ const wxKeyEvent& event,
+ bool pressed);
+ virtual bool HandleMouse(wxInputConsumer *consumer,
+ const wxMouseEvent& event);
+ virtual bool HandleMouseMove(wxInputConsumer *consumer,
+ const wxMouseEvent& event);
+
+protected:
+ // return the item under mouse, 0 if the mouse is above the listbox or
+ // GetCount() if it is below it
+ int HitTest(const wxListBox *listbox, const wxMouseEvent& event);
+
+ // parts of HitTest(): first finds the pseudo (because not in range) index
+ // of the item and the second one adjusts it if necessary - that is if the
+ // third one returns false
+ int HitTestUnsafe(const wxListBox *listbox, const wxMouseEvent& event);
+ int FixItemIndex(const wxListBox *listbox, int item);
+ bool IsValidIndex(const wxListBox *listbox, int item);
+
+ // init m_btnCapture and m_actionMouse
+ wxControlAction SetupCapture(wxListBox *lbox,
+ const wxMouseEvent& event,
+ int item);
+
+ wxRenderer *m_renderer;
+
+ // the button which initiated the mouse capture (currently 0 or 1)
+ int m_btnCapture;
+
+ // the action to perform when the mouse moves while we capture it
+ wxControlAction m_actionMouse;
+
+ // the ctor parameter toggleOnPressAlways (see comments near it)
+ bool m_toggleOnPressAlways;
+
+ // do we track the mouse outside the window when it is captured?
+ bool m_trackMouseOutside;
+};
+
// ============================================================================
// implementation of wxListBox
// ============================================================================
-IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
+IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControlWithItems)
BEGIN_EVENT_TABLE(wxListBox, wxListBoxBase)
EVT_SIZE(wxListBox::OnSize)
-
- EVT_IDLE(wxListBox::OnIdle)
END_EVENT_TABLE()
// ----------------------------------------------------------------------------
m_maxWidth = 0;
m_scrollRangeY = 0;
m_maxWidthItem = -1;
+ m_strings.unsorted = NULL;
// no items hence no current item
m_current = -1;
m_selAnchor = -1;
- m_currentChanged = FALSE;
+ m_currentChanged = false;
// no need to update anything initially
m_updateCount = 0;
m_updateScrollbarX =
m_showScrollbarX =
m_updateScrollbarY =
- m_showScrollbarY = FALSE;
+ m_showScrollbarY = false;
+}
+
+wxListBox::wxListBox(wxWindow *parent,
+ wxWindowID id,
+ const wxPoint &pos,
+ const wxSize &size,
+ const wxArrayString& choices,
+ long style,
+ const wxValidator& validator,
+ const wxString &name)
+ :wxScrollHelper(this)
+{
+ Init();
+
+ Create(parent, id, pos, size, choices, style, validator, name);
+}
+
+bool wxListBox::Create(wxWindow *parent,
+ wxWindowID id,
+ const wxPoint &pos,
+ const wxSize &size,
+ const wxArrayString& choices,
+ long style,
+ const wxValidator& validator,
+ const wxString &name)
+{
+ wxCArrayString chs(choices);
+
+ return Create(parent, id, pos, size, chs.GetCount(), chs.GetStrings(),
+ style, validator, name);
}
bool wxListBox::Create(wxWindow *parent,
style |= wxBORDER_SUNKEN;
#endif
- if ( !wxControl::Create(parent, id, pos, size, style,
- wxDefaultValidator, name) )
- return FALSE;
-
- SetWindow(this);
+ if ( !wxControl::Create(parent, id, pos, size, style,
+ validator, name) )
+ return false;
- if ( style & wxLB_SORT )
- m_strings = wxArrayString(TRUE /* auto sort */);
+ if ( IsSorted() )
+ m_strings.sorted = new wxSortedArrayString;
+ else
+ m_strings.unsorted = new wxArrayString;
Set(n, choices);
- SetBestSize(size);
+ SetInitialSize(size);
CreateInputHandler(wxINP_HANDLER_LISTBOX);
- return TRUE;
+ return true;
}
wxListBox::~wxListBox()
{
+ // call this just to free the client data -- and avoid leaking memory
+ DoClear();
+
+ if ( IsSorted() )
+ delete m_strings.sorted;
+ else
+ delete m_strings.unsorted;
+
+ m_strings.sorted = NULL;
}
// ----------------------------------------------------------------------------
-// adding/inserting strings
+// accessing strings
// ----------------------------------------------------------------------------
-int wxListBox::DoAppend(const wxString& item)
+unsigned int wxListBox::GetCount() const
{
- size_t index = m_strings.Add(item);
- m_itemsClientData.Insert(NULL, index);
-
- m_updateScrollbarY = TRUE;
-
- if ( HasHorzScrollbar() )
- {
- // has the max width increased?
- wxCoord width;
- GetTextExtent(item, &width, NULL);
- if ( width > m_maxWidth )
- {
- m_maxWidth = width;
- m_maxWidthItem = index;
- m_updateScrollbarX = TRUE;
- }
- }
+ return IsSorted() ? m_strings.sorted->size()
+ : m_strings.unsorted->size();
+}
- RefreshFromItemToEnd(index);
+wxString wxListBox::GetString(unsigned int n) const
+{
+ return IsSorted() ? m_strings.sorted->Item(n)
+ : m_strings.unsorted->Item(n);
+}
- return index;
+int wxListBox::FindString(const wxString& s, bool bCase) const
+{
+ return IsSorted() ? m_strings.sorted->Index(s, bCase)
+ : m_strings.unsorted->Index(s, bCase);
}
-void wxListBox::DoInsertItems(const wxArrayString& items, int pos)
+// ----------------------------------------------------------------------------
+// adding/inserting strings
+// ----------------------------------------------------------------------------
+
+int wxListBox::DoInsertItems(const wxArrayStringsAdapter& items,
+ unsigned int pos,
+ void **clientData,
+ wxClientDataType type)
{
- // the position of the item being added to a sorted listbox can't be
- // specified
- wxCHECK_RET( !IsSorted(), _T("can't insert items into sorted listbox") );
+ int idx = wxNOT_FOUND;
- size_t count = items.GetCount();
- for ( size_t n = 0; n < count; n++ )
+ const unsigned int numItems = items.GetCount();
+ for ( unsigned int i = 0; i < numItems; ++i )
{
- m_strings.Insert(items[n], pos + n);
- m_itemsClientData.Insert(NULL, pos + n);
+ const wxString& item = items[i];
+ idx = IsSorted() ? m_strings.sorted->Add(item)
+ : (m_strings.unsorted->Insert(item, pos), pos++);
+
+ m_itemsClientData.Insert(NULL, idx);
+ AssignNewItemClientData(idx, clientData, i, type);
+
+ // call the wxCheckListBox hook
+ OnItemInserted(idx);
}
// the number of items has changed so we might have to show the scrollbar
- m_updateScrollbarY = TRUE;
+ m_updateScrollbarY = true;
// the max width also might have changed - just recalculate it instead of
// keeping track of it here, this is probably more efficient for a typical
// note that we have to refresh all the items after the ones we inserted,
// not just these items
RefreshFromItemToEnd(pos);
+
+ return idx;
}
-void wxListBox::DoSetItems(const wxArrayString& items, void **clientData)
+void wxListBox::SetString(unsigned int n, const wxString& s)
{
- DoClear();
-
- size_t count = items.GetCount();
- if ( !count )
- return;
-
- m_strings.Alloc(count);
- m_itemsClientData.Alloc(count);
- for ( size_t n = 0; n < count; n++ )
- {
- size_t index = m_strings.Add(items[n]);
- m_itemsClientData.Insert(clientData ? clientData[n] : NULL, index);
- }
+ wxCHECK_RET( !IsSorted(), wxT("can't set string in sorted listbox") );
- m_updateScrollbarY = TRUE;
-
- RefreshAll();
-}
+ if ( IsSorted() )
+ (*m_strings.sorted)[n] = s;
+ else
+ (*m_strings.unsorted)[n] = s;
-void wxListBox::SetString(int n, const wxString& s)
-{
if ( HasHorzScrollbar() )
{
// we need to update m_maxWidth as changing the string may cause the
// horz scrollbar [dis]appear
wxCoord width;
- m_strings[n] = s;
+
GetTextExtent(s, &width, NULL);
// it might have increased if the new string is long
{
m_maxWidth = width;
m_maxWidthItem = n;
- m_updateScrollbarX = TRUE;
+ m_updateScrollbarX = true;
}
// or also decreased if the old string was the longest one
- else if ( n == m_maxWidthItem )
+ else if ( n == (unsigned int)m_maxWidthItem )
{
RefreshHorzScrollbar();
}
}
- else // no horz scrollbar
- {
- m_strings[n] = s;
- }
RefreshItem(n);
}
void wxListBox::DoClear()
{
- m_strings.Clear();
-
- if ( HasClientObjectData() )
- {
- size_t count = m_itemsClientData.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- delete (wxClientData *) m_itemsClientData[n];
- }
- }
+ if ( IsSorted() )
+ m_strings.sorted->Clear();
+ else
+ m_strings.unsorted->Clear();
m_itemsClientData.Clear();
m_selections.Clear();
m_current = -1;
-}
-
-void wxListBox::Clear()
-{
- DoClear();
- m_updateScrollbarY = TRUE;
+ m_updateScrollbarY = true;
RefreshHorzScrollbar();
RefreshAll();
}
-void wxListBox::Delete(int n)
+void wxListBox::DoDeleteOneItem(unsigned int n)
{
- wxCHECK_RET( n < GetCount(), _T("invalid index in wxListBox::Delete") );
+ wxCHECK_RET( IsValid(n),
+ wxT("invalid index in wxListBox::Delete") );
// do it before removing the index as otherwise the last item will not be
// refreshed (as GetCount() will be decremented)
RefreshFromItemToEnd(n);
- m_strings.RemoveAt(n);
-
- if ( HasClientObjectData() )
- {
- delete (wxClientData *)m_itemsClientData[n];
- }
+ if ( IsSorted() )
+ m_strings.sorted->RemoveAt(n);
+ else
+ m_strings.unsorted->RemoveAt(n);
m_itemsClientData.RemoveAt(n);
// when the item disappears we must not keep using its index
- if ( n == m_current )
+ if ( (int)n == m_current )
{
m_current = -1;
}
- else if ( n < m_current )
+ else if ( (int)n < m_current )
{
m_current--;
}
// update the selections array: the indices of all seletected items after
// the one being deleted must change and the item itselfm ust be removed
int index = wxNOT_FOUND;
- size_t count = m_selections.GetCount();
- for ( size_t item = 0; item < count; item++ )
+ unsigned int count = m_selections.GetCount();
+ for ( unsigned int item = 0; item < count; item++ )
{
- if ( m_selections[item] == n )
+ if ( m_selections[item] == (int)n )
{
// remember to delete it later
index = item;
}
- else if ( m_selections[item] > n )
+ else if ( m_selections[item] > (int)n )
{
// to account for the index shift
m_selections[item]--;
}
// the number of items has changed, hence the scrollbar may disappear
- m_updateScrollbarY = TRUE;
+ m_updateScrollbarY = true;
// finally, if the longest item was deleted the scrollbar may disappear
- if ( n == m_maxWidthItem )
+ if ( (int)n == m_maxWidthItem )
{
RefreshHorzScrollbar();
}
// client data handling
// ----------------------------------------------------------------------------
-void wxListBox::DoSetItemClientData(int n, void* clientData)
+void wxListBox::DoSetItemClientData(unsigned int n, void* clientData)
{
m_itemsClientData[n] = clientData;
}
-void *wxListBox::DoGetItemClientData(int n) const
+void *wxListBox::DoGetItemClientData(unsigned int n) const
{
return m_itemsClientData[n];
}
-void wxListBox::DoSetItemClientObject(int n, wxClientData* clientData)
-{
- m_itemsClientData[n] = clientData;
-}
-
-wxClientData* wxListBox::DoGetItemClientObject(int n) const
-{
- return (wxClientData *)m_itemsClientData[n];
-}
-
// ----------------------------------------------------------------------------
// selection
// ----------------------------------------------------------------------------
-void wxListBox::SetSelection(int n, bool select)
+void wxListBox::DoSetSelection(int n, bool select)
{
if ( select )
{
- if ( m_selections.Index(n) == wxNOT_FOUND )
+ if ( n == wxNOT_FOUND )
+ {
+ if ( !HasMultipleSelection() )
+ {
+ // selecting wxNOT_FOUND is documented to deselect all items
+ DeselectAll();
+ return;
+ }
+ }
+ else if ( m_selections.Index(n) == wxNOT_FOUND )
{
if ( !HasMultipleSelection() )
{
// sanity check: a single selection listbox can't have more than one item
// selected
wxASSERT_MSG( HasMultipleSelection() || (m_selections.GetCount() < 2),
- _T("multiple selected items in single selection lbox?") );
+ wxT("multiple selected items in single selection lbox?") );
if ( select )
{
int wxListBox::GetSelection() const
{
- wxCHECK_MSG( !HasMultipleSelection(), -1,
- _T("use wxListBox::GetSelections for ths listbox") );
+ wxCHECK_MSG( !HasMultipleSelection(), wxNOT_FOUND,
+ wxT("use wxListBox::GetSelections for ths listbox") );
- return m_selections.IsEmpty() ? -1 : m_selections[0];
+ return m_selections.IsEmpty() ? wxNOT_FOUND : m_selections[0];
}
-int wxCMPFUNC_CONV wxCompareInts(int *n, int *m)
+static int wxCMPFUNC_CONV wxCompareInts(int *n, int *m)
{
return *n - *m;
}
{
// always return sorted array to the user
selections = m_selections;
- size_t count = m_selections.GetCount();
+ unsigned int count = m_selections.GetCount();
// don't call sort on an empty array
if ( count )
void wxListBox::RefreshHorzScrollbar()
{
m_maxWidth = 0; // recalculate it
- m_updateScrollbarX = TRUE;
+ m_updateScrollbarX = true;
}
void wxListBox::UpdateScrollbars()
wxSize size = GetClientSize();
// is our height enough to show all items?
- int nLines = GetCount();
+ unsigned int nLines = GetCount();
wxCoord lineHeight = GetLineHeight();
- bool showScrollbarY = nLines*lineHeight > size.y;
+ bool showScrollbarY = (int)nLines*lineHeight > size.y;
// check the width too if required
wxCoord charWidth, maxWidth;
else // never show it
{
charWidth = maxWidth = 0;
- showScrollbarX = FALSE;
+ showScrollbarX = false;
}
// what should be the scrollbar range now?
if ( m_updateCount == -1 )
{
// refresh all
- wxLogTrace(_T("listbox"), _T("Refreshing all"));
+ wxLogTrace(wxT("listbox"), wxT("Refreshing all"));
Refresh();
}
// entire line(s)
CalcScrolledPosition(0, rect.y, NULL, &rect.y);
- wxLogTrace(_T("listbox"), _T("Refreshing items %d..%d (%d-%d)"),
+ wxLogTrace(wxT("listbox"), wxT("Refreshing items %d..%d (%d-%d)"),
m_updateFrom, m_updateFrom + m_updateCount - 1,
rect.GetTop(), rect.GetBottom());
- Refresh(TRUE, &rect);
+ Refresh(true, &rect);
}
}
-void wxListBox::OnIdle(wxIdleEvent& event)
+void wxListBox::OnInternalIdle()
{
if ( m_updateScrollbarY || m_updateScrollbarX )
{
UpdateScrollbars();
m_updateScrollbarX =
- m_updateScrollbarY = FALSE;
+ m_updateScrollbarY = false;
}
if ( m_currentChanged )
{
DoEnsureVisible(m_current);
- m_currentChanged = FALSE;
+ m_currentChanged = false;
}
if ( m_updateCount )
m_updateCount = 0;
}
-
- event.Skip();
+ wxListBoxBase::OnInternalIdle();
}
// ----------------------------------------------------------------------------
// get the items which must be redrawn
wxCoord lineHeight = GetLineHeight();
- size_t itemFirst = yTop / lineHeight,
- itemLast = (yBottom + lineHeight - 1) / lineHeight,
- itemMax = m_strings.GetCount();
+ unsigned int itemFirst = yTop / lineHeight,
+ itemLast = (yBottom + lineHeight - 1) / lineHeight,
+ itemMax = GetCount();
if ( itemFirst >= itemMax )
return;
itemLast = itemMax;
// do draw them
- wxLogTrace(_T("listbox"), _T("Repainting items %d..%d"),
+ wxLogTrace(wxT("listbox"), wxT("Repainting items %d..%d"),
itemFirst, itemLast);
DoDrawRange(renderer, itemFirst, itemLast);
bool wxListBox::SetFont(const wxFont& font)
{
if ( !wxControl::SetFont(font) )
- return FALSE;
+ return false;
CalcItemsPerPage();
RefreshAll();
- return TRUE;
+ return true;
}
void wxListBox::CalcItemsPerPage()
{
wxListBox *self = wxConstCast(this, wxListBox);
wxCoord width;
- size_t count = m_strings.GetCount();
- for ( size_t n = 0; n < count; n++ )
+ unsigned int count = GetCount();
+ for ( unsigned int n = 0; n < count; n++ )
{
- GetTextExtent(m_strings[n], &width, NULL);
+ GetTextExtent(this->GetString(n), &width, NULL);
if ( width > m_maxWidth )
{
self->m_maxWidth = width;
// the scrollbars might [dis]appear
m_updateScrollbarX =
- m_updateScrollbarY = TRUE;
+ m_updateScrollbarY = true;
event.Skip();
}
height = ((height - hBorders + hLine - 1) / hLine)*hLine + hBorders;
}
- wxListBoxBase::DoSetSize(x, y, width, height);
+ wxListBoxBase::DoSetSize(x, y, width, height, sizeFlags);
}
wxSize wxListBox::DoGetBestClientSize() const
wxCoord width = 0,
height = 0;
- size_t count = m_strings.GetCount();
- for ( size_t n = 0; n < count; n++ )
+ unsigned int count = GetCount();
+ for ( unsigned int n = 0; n < count; n++ )
{
wxCoord w,h;
- GetTextExtent(m_strings[n], &w, &h);
+ GetTextExtent(this->GetString(n), &w, &h);
if ( w > width )
width = w;
event.SetString(GetString(item));
}
- event.m_commandInt = item;
+ event.SetInt(item);
return GetEventHandler()->ProcessEvent(event);
}
if ( m_current != -1 )
{
- m_currentChanged = TRUE;
+ m_currentChanged = true;
RefreshItem(m_current);
}
bool wxListBox::FindItem(const wxString& prefix, bool strictlyAfter)
{
- int count = GetCount();
- if ( !count )
+ unsigned int count = GetCount();
+ if ( count==0 )
{
// empty listbox, we can't find anything in it
- return FALSE;
+ return false;
}
// start either from the current item or from the next one if strictlyAfter
{
// the following line will set first correctly to 0 if there is no
// selection (m_current == -1)
- first = m_current == count - 1 ? 0 : m_current + 1;
+ first = m_current == (int)(count - 1) ? 0 : m_current + 1;
}
else // start with the current
{
int last = first == 0 ? count - 1 : first - 1;
// if this is not true we'd never exit from the loop below!
- wxASSERT_MSG( first < count && last < count, _T("logic error") );
+ wxASSERT_MSG( first < (int)count && last < (int)count, wxT("logic error") );
// precompute it outside the loop
size_t len = prefix.length();
// loop over all items in the listbox
- for ( int item = first; item != last; item < count - 1 ? item++ : item = 0 )
+ for ( int item = first; item != (int)last; item < (int)(count - 1) ? item++ : item = 0 )
{
- if ( wxStrnicmp(m_strings[item], prefix, len) == 0 )
+ if ( wxStrnicmp(this->GetString(item).c_str(), prefix, len) == 0 )
{
SetCurrentItem(item);
AnchorSelection(item);
}
- return TRUE;
+ return true;
}
}
// nothing found
- return FALSE;
+ return false;
}
void wxListBox::EnsureVisible(int n)
UpdateScrollbars();
m_updateScrollbarX =
- m_updateScrollbarY = FALSE;
+ m_updateScrollbarY = false;
}
DoEnsureVisible(n);
SetSelection(n);
}
- int count = GetCount();
- for ( ; n < count; n++ )
+ unsigned int count = GetCount();
+ for ( ; n < (int)count; n++ )
{
Deselect(n);
}
}
-void wxListBox::Select(bool sel, int item)
+void wxListBox::DoSelect(int item, bool sel)
{
if ( item != -1 )
{
void wxListBox::SelectAndNotify(int item)
{
- Select(TRUE, item);
+ DoSelect(item);
SendEvent(wxEVT_COMMAND_LISTBOX_SELECTED);
}
if ( item != -1 )
{
- Select(TRUE, item);
+ DoSelect(item);
SendEvent(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED);
}
item = m_current;
if ( IsSelected(item) )
- Unselect(item);
+ DoUnselect(item);
else
SelectAndNotify(item);
}
if ( strArg.empty() )
SelectAndNotify(item);
else
- Select(TRUE, item);
+ DoSelect(item);
}
else if ( action == wxACTION_LISTBOX_SELECTADD )
- Select(TRUE, item);
+ DoSelect(item);
else if ( action == wxACTION_LISTBOX_UNSELECT )
- Select(FALSE, item);
+ DoUnselect(item);
else if ( action == wxACTION_LISTBOX_MOVEDOWN )
ChangeCurrent(1);
else if ( action == wxACTION_LISTBOX_MOVEUP )
AnchorSelection(item == -1 ? m_current : item);
else if ( action == wxACTION_LISTBOX_SELECTALL ||
action == wxACTION_LISTBOX_SELTOGGLE )
- wxFAIL_MSG(_T("unimplemented yet"));
+ wxFAIL_MSG(wxT("unimplemented yet"));
else
return wxControl::PerformAction(action, numArg, strArg);
- return TRUE;
+ return true;
+}
+
+/* static */
+wxInputHandler *wxListBox::GetStdInputHandler(wxInputHandler *handlerDef)
+{
+ static wxStdListboxInputHandler s_handler(handlerDef);
+
+ return &s_handler;
}
// ============================================================================
m_btnCapture = 0;
m_toggleOnPressAlways = toggleOnPressAlways;
m_actionMouse = wxACTION_NONE;
- m_trackMouseOutside = TRUE;
+ m_trackMouseOutside = true;
}
int wxStdListboxInputHandler::HitTest(const wxListBox *lbox,
// mouse is above the first item
item = 0;
}
- else if ( item >= lbox->GetCount() )
+ else if ( (unsigned int)item >= lbox->GetCount() )
{
// mouse is below the last item
item = lbox->GetCount() - 1;
bool wxStdListboxInputHandler::IsValidIndex(const wxListBox *lbox, int item)
{
- return item >= 0 && item < lbox->GetCount();
+ return item >= 0 && (unsigned int)item < lbox->GetCount();
}
wxControlAction
}
// by default we always do track it
- m_trackMouseOutside = TRUE;
+ m_trackMouseOutside = true;
return action;
}
// we're only interested in the key press events
if ( pressed && !event.AltDown() )
{
- bool isMoveCmd = TRUE;
+ bool isMoveCmd = true;
int style = consumer->GetInputWindow()->GetWindowStyle();
wxControlAction action;
break;
case WXK_PAGEUP:
-
- case WXK_PRIOR:
action = wxACTION_LISTBOX_PAGEUP;
break;
case WXK_PAGEDOWN:
-
- case WXK_NEXT:
action = wxACTION_LISTBOX_PAGEDOWN;
break;
if ( style & wxLB_MULTIPLE )
{
action = wxACTION_LISTBOX_TOGGLE;
- isMoveCmd = FALSE;
+ isMoveCmd = false;
}
break;
case WXK_RETURN:
action = wxACTION_LISTBOX_ACTIVATE;
- isMoveCmd = FALSE;
+ isMoveCmd = false;
break;
default:
- if ( (keycode < 255) && wxIsalnum(keycode) )
+ if ( (keycode < 255) && wxIsalnum((wxChar)keycode) )
{
action = wxACTION_LISTBOX_FIND;
strArg = (wxChar)keycode;
}
}
- if ( !!action )
+ if ( !action.IsEmpty() )
{
consumer->PerformAction(action, -1, strArg);
//else: nothing to do for multiple selection listboxes
}
- return TRUE;
+ return true;
}
}
action = wxACTION_LISTBOX_ACTIVATE;
}
- if ( !!action )
+ if ( !action.IsEmpty() )
{
lbox->PerformAction(action, item);
- return TRUE;
+ return true;
}
return wxStdInputHandler::HandleMouse(consumer, event);
// when we do it ourselves): in this case we only react to
// the mouse messages when they happen inside the listbox
if ( lbox->HitTest(event.GetPosition()) != wxHT_WINDOW_INSIDE )
- return FALSE;
+ return false;
}
int item = HitTest(lbox, event);
// events
SetupCapture(lbox, event, item);
- m_trackMouseOutside = FALSE;
+ m_trackMouseOutside = false;
}
if ( IsValidIndex(lbox, item) )
{
// pass something into strArg to tell the listbox that it shouldn't
// send the notification message: see PerformAction() above
- lbox->PerformAction(m_actionMouse, item, _T("no"));
+ lbox->PerformAction(m_actionMouse, item, wxT("no"));
}
// else: don't pass invalid index to the listbox
}
projects / wxWidgets.git / blobdiff