///////////////////////////////////////////////////////////////////////////////
-// Name: generic/vlbox.cpp
+// Name: src/generic/vlbox.cpp
// Purpose: implementation of wxVListBox
// Author: Vadim Zeitlin
// Modified by:
#pragma hdrstop
#endif
+#if wxUSE_LISTBOX
+
+#include "wx/vlbox.h"
+
#ifndef WX_PRECOMP
#include "wx/settings.h"
#include "wx/dcclient.h"
+ #include "wx/listbox.h"
#endif //WX_PRECOMP
-#include "wx/vlbox.h"
+#include "wx/dcbuffer.h"
+#include "wx/selstore.h"
+#include "wx/renderer.h"
// ----------------------------------------------------------------------------
// event tables
EVT_KEY_DOWN(wxVListBox::OnKeyDown)
EVT_LEFT_DOWN(wxVListBox::OnLeftDown)
EVT_LEFT_DCLICK(wxVListBox::OnLeftDClick)
+
+ EVT_SET_FOCUS(wxVListBox::OnSetOrKillFocus)
+ EVT_KILL_FOCUS(wxVListBox::OnSetOrKillFocus)
END_EVENT_TABLE()
// ============================================================================
// implementation
// ============================================================================
+IMPLEMENT_ABSTRACT_CLASS(wxVListBox, wxVScrolledWindow)
+
// ----------------------------------------------------------------------------
// wxVListBox creation
// ----------------------------------------------------------------------------
void wxVListBox::Init()
{
- m_selection = -1;
+ m_current =
+ m_anchor = wxNOT_FOUND;
+ m_selStore = NULL;
}
bool wxVListBox::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
- size_t countItems,
long style,
const wxString& name)
{
+#ifdef __WXMSW__
+ if ((style & wxBORDER_MASK) == wxDEFAULT)
+ style |= wxBORDER_THEME;
+#endif
+
+ style |= wxWANTS_CHARS | wxFULL_REPAINT_ON_RESIZE;
if ( !wxVScrolledWindow::Create(parent, id, pos, size, style, name) )
return false;
- SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX));
+ if ( style & wxLB_MULTIPLE )
+ m_selStore = new wxSelectionStore;
+
+ // make sure the native widget has the right colour since we do
+ // transparent drawing by default
+ SetBackgroundColour(GetBackgroundColour());
- SetItemCount(countItems);
+ // leave m_colBgSel in an invalid state: it means for OnDrawBackground()
+ // to use wxRendererNative instead of painting selection bg ourselves
+ m_colBgSel = wxNullColour;
+
+ // flicker-free drawing requires this
+ SetBackgroundStyle(wxBG_STYLE_CUSTOM);
return true;
}
+wxVListBox::~wxVListBox()
+{
+ delete m_selStore;
+}
+
+void wxVListBox::SetItemCount(size_t count)
+{
+ if ( m_selStore )
+ {
+ // tell the selection store that our number of items has changed
+ m_selStore->SetItemCount(count);
+ }
+
+ SetRowCount(count);
+}
+
// ----------------------------------------------------------------------------
// selection handling
// ----------------------------------------------------------------------------
-void wxVListBox::DoSetSelection(int selection, bool sendEvent)
+bool wxVListBox::IsSelected(size_t line) const
+{
+ return m_selStore ? m_selStore->IsSelected(line) : (int)line == m_current;
+}
+
+bool wxVListBox::Select(size_t item, bool select)
+{
+ wxCHECK_MSG( m_selStore, false,
+ _T("Select() may only be used with multiselection listbox") );
+
+ wxCHECK_MSG( item < GetItemCount(), false,
+ _T("Select(): invalid item index") );
+
+ bool changed = m_selStore->SelectItem(item, select);
+ if ( changed )
+ {
+ // selection really changed
+ RefreshRow(item);
+ }
+
+ DoSetCurrent(item);
+
+ return changed;
+}
+
+bool wxVListBox::SelectRange(size_t from, size_t to)
{
- if ( selection == m_selection )
+ wxCHECK_MSG( m_selStore, false,
+ _T("SelectRange() may only be used with multiselection listbox") );
+
+ // make sure items are in correct order
+ if ( from > to )
+ {
+ size_t tmp = from;
+ from = to;
+ to = tmp;
+ }
+
+ wxCHECK_MSG( to < GetItemCount(), false,
+ _T("SelectRange(): invalid item index") );
+
+ wxArrayInt changed;
+ if ( !m_selStore->SelectRange(from, to, true, &changed) )
+ {
+ // too many items have changed, we didn't record them in changed array
+ // so we have no choice but to refresh everything between from and to
+ RefreshRows(from, to);
+ }
+ else // we've got the indices of the changed items
+ {
+ const size_t count = changed.GetCount();
+ if ( !count )
+ {
+ // nothing changed
+ return false;
+ }
+
+ // refresh just the lines which have really changed
+ for ( size_t n = 0; n < count; n++ )
+ {
+ RefreshRow(changed[n]);
+ }
+ }
+
+ // something changed
+ return true;
+}
+
+bool wxVListBox::DoSelectAll(bool select)
+{
+ wxCHECK_MSG( m_selStore, false,
+ _T("SelectAll may only be used with multiselection listbox") );
+
+ size_t count = GetItemCount();
+ if ( count )
+ {
+ wxArrayInt changed;
+ if ( !m_selStore->SelectRange(0, count - 1, select) ||
+ !changed.IsEmpty() )
+ {
+ Refresh();
+
+ // something changed
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool wxVListBox::DoSetCurrent(int current)
+{
+ wxASSERT_MSG( current == wxNOT_FOUND ||
+ (current >= 0 && (size_t)current < GetItemCount()),
+ _T("wxVListBox::DoSetCurrent(): invalid item index") );
+
+ if ( current == m_current )
{
// nothing to do
- return;
+ return false;
}
- if ( m_selection != -1 )
- RefreshLine(m_selection);
+ if ( m_current != wxNOT_FOUND )
+ RefreshRow(m_current);
- m_selection = selection;
+ m_current = current;
- if ( m_selection != -1 )
+ if ( m_current != wxNOT_FOUND )
{
// if the line is not visible at all, we scroll it into view but we
// don't need to refresh it -- it will be redrawn anyhow
- if ( !IsVisible(m_selection) )
+ if ( !IsVisible(m_current) )
{
- ScrollToLine(m_selection);
+ ScrollToRow(m_current);
}
else // line is at least partly visible
{
// it is, indeed, only partly visible, so scroll it into view to
// make it entirely visible
- if ( (size_t)m_selection == GetLastVisibleLine() )
- {
- ScrollToLine(m_selection);
- }
+ while ( (size_t)m_current + 1 == GetVisibleRowsEnd() &&
+ ScrollToRow(GetVisibleBegin() + 1) ) ;
// but in any case refresh it as even if it was only partly visible
// before we need to redraw it entirely as its background changed
- RefreshLine(m_selection);
+ RefreshRow(m_current);
}
+ }
- // send a notification event if we were not called directly by user
- if ( sendEvent )
- {
- wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, GetId());
- event.SetEventObject(this);
- event.m_commandInt = selection;
+ return true;
+}
- (void)GetEventHandler()->ProcessEvent(event);
- }
+void wxVListBox::SendSelectedEvent()
+{
+ wxASSERT_MSG( m_current != wxNOT_FOUND,
+ _T("SendSelectedEvent() shouldn't be called") );
+
+ wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, GetId());
+ event.SetEventObject(this);
+ event.SetInt(m_current);
+
+ (void)GetEventHandler()->ProcessEvent(event);
+}
+
+void wxVListBox::SetSelection(int selection)
+{
+ wxCHECK_RET( selection == wxNOT_FOUND ||
+ (selection >= 0 && (size_t)selection < GetItemCount()),
+ _T("wxVListBox::SetSelection(): invalid item index") );
+
+ if ( HasMultipleSelection() )
+ {
+ if (selection != wxNOT_FOUND)
+ Select(selection);
+ else
+ DeselectAll();
+ m_anchor = selection;
+ }
+
+ DoSetCurrent(selection);
+}
+
+size_t wxVListBox::GetSelectedCount() const
+{
+ return m_selStore ? m_selStore->GetSelectedCount()
+ : m_current == wxNOT_FOUND ? 0 : 1;
+}
+
+int wxVListBox::GetFirstSelected(unsigned long& cookie) const
+{
+ cookie = 0;
+
+ return GetNextSelected(cookie);
+}
+
+int wxVListBox::GetNextSelected(unsigned long& cookie) const
+{
+ wxCHECK_MSG( m_selStore, wxNOT_FOUND,
+ _T("GetFirst/NextSelected() may only be used with multiselection listboxes") );
+
+ while ( cookie < GetItemCount() )
+ {
+ if ( IsSelected(cookie++) )
+ return cookie - 1;
+ }
+
+ return wxNOT_FOUND;
+}
+
+void wxVListBox::RefreshSelected()
+{
+ // only refresh those items which are currently visible and selected:
+ for ( size_t n = GetVisibleBegin(), end = GetVisibleEnd(); n < end; n++ )
+ {
+ if ( IsSelected(n) )
+ RefreshRow(n);
}
}
// ----------------------------------------------------------------------------
-// wxVListBox painting
+// wxVListBox appearance parameters
// ----------------------------------------------------------------------------
void wxVListBox::SetMargins(const wxPoint& pt)
}
}
-wxCoord wxVListBox::OnGetLineHeight(size_t line) const
+void wxVListBox::SetSelectionBackground(const wxColour& col)
+{
+ m_colBgSel = col;
+}
+
+// ----------------------------------------------------------------------------
+// wxVListBox painting
+// ----------------------------------------------------------------------------
+
+wxCoord wxVListBox::OnGetRowHeight(size_t line) const
{
return OnMeasureItem(line) + 2*m_ptMargins.y;
}
{
}
-void wxVListBox::OnPaint(wxPaintEvent& event)
+void wxVListBox::OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const
+{
+ if ( m_colBgSel.IsOk() )
+ {
+ // we need to render selected and current items differently
+ const bool isSelected = IsSelected(n),
+ isCurrent = IsCurrent(n);
+ if ( isSelected || isCurrent )
+ {
+ if ( isSelected )
+ {
+ dc.SetBrush(wxBrush(m_colBgSel, wxSOLID));
+ }
+ else // !selected
+ {
+ dc.SetBrush(*wxTRANSPARENT_BRUSH);
+ }
+ dc.SetPen(*(isCurrent ? wxBLACK_PEN : wxTRANSPARENT_PEN));
+ dc.DrawRectangle(rect);
+ }
+ //else: do nothing for the normal items
+ }
+ else // use wxRendererNative for a more native look&feel:
+ {
+ int flags = 0;
+ if ( IsSelected(n) )
+ flags |= wxCONTROL_SELECTED;
+ if ( IsCurrent(n) )
+ flags |= wxCONTROL_CURRENT;
+ if ( wxWindow::FindFocus() == wx_const_cast(wxVListBox*, this) )
+ flags |= wxCONTROL_FOCUSED;
+
+ wxRendererNative::Get().DrawItemSelectionRect(
+ wx_const_cast(wxVListBox *, this), dc, rect, flags);
+ }
+}
+
+void wxVListBox::OnPaint(wxPaintEvent& WXUNUSED(event))
{
- wxPaintDC dc(this);
+ wxSize clientSize = GetClientSize();
+
+ wxAutoBufferedPaintDC dc(this);
// the update rectangle
wxRect rectUpdate = GetUpdateClientRect();
+ // fill it with background colour
+ dc.SetBackground(GetBackgroundColour());
+ dc.Clear();
+
// the bounding rectangle of the current line
- wxRect rectLine;
- rectLine.width = GetClientSize().x;
+ wxRect rectRow;
+ rectRow.width = clientSize.x;
// iterate over all visible lines
- const size_t lineMax = GetLastVisibleLine();
- for ( size_t line = GetFirstVisibleLine(); line <= lineMax; line++ )
+ const size_t lineMax = GetVisibleEnd();
+ for ( size_t line = GetVisibleBegin(); line < lineMax; line++ )
{
- const wxCoord hLine = OnGetLineHeight(line);
+ const wxCoord hRow = OnGetRowHeight(line);
- rectLine.height = hLine;
+ rectRow.height = hRow;
// and draw the ones which intersect the update rect
- if ( rectLine.Intersects(rectUpdate) )
+ if ( rectRow.Intersects(rectUpdate) )
{
// don't allow drawing outside of the lines rectangle
- wxDCClipper clip(dc, rectLine);
+ wxDCClipper clip(dc, rectRow);
- if ( IsSelected(line) )
- {
- wxBrush brush(wxSystemSettings::
- GetColour(wxSYS_COLOUR_HIGHLIGHT),
- wxSOLID);
- dc.SetBrush(brush);
- dc.SetPen(*wxTRANSPARENT_PEN);
- dc.DrawRectangle(rectLine);
- }
+ wxRect rect = rectRow;
+ OnDrawBackground(dc, rect, line);
- wxRect rect = rectLine;
OnDrawSeparator(dc, rect, line);
rect.Deflate(m_ptMargins.x, m_ptMargins.y);
}
else // no intersection
{
- if ( rectLine.GetTop() > rectUpdate.GetBottom() )
+ if ( rectRow.GetTop() > rectUpdate.GetBottom() )
{
// we are already below the update rect, no need to continue
// further
//else: the next line may intersect the update rect
}
- rectLine.y += hLine;
+ rectRow.y += hRow;
}
}
+void wxVListBox::OnSetOrKillFocus(wxFocusEvent& WXUNUSED(event))
+{
+ // we need to repaint the selection when we get the focus since
+ // wxRendererNative in general draws the focused selection differently
+ // from the unfocused selection (see OnDrawItem):
+ RefreshSelected();
+}
+
+
+// ============================================================================
+// wxVListBox keyboard/mouse handling
+// ============================================================================
+
+void wxVListBox::DoHandleItemClick(int item, int flags)
+{
+ // has anything worth telling the client code about happened?
+ bool notify = false;
+
+ if ( HasMultipleSelection() )
+ {
+ // select the iteem clicked?
+ bool select = true;
+
+ // NB: the keyboard interface we implement here corresponds to
+ // wxLB_EXTENDED rather than wxLB_MULTIPLE but this one makes more
+ // sense IMHO
+ if ( flags & ItemClick_Shift )
+ {
+ if ( m_current != wxNOT_FOUND )
+ {
+ if ( m_anchor == wxNOT_FOUND )
+ m_anchor = m_current;
+
+ select = false;
+
+ // only the range from the selection anchor to new m_current
+ // must be selected
+ if ( DeselectAll() )
+ notify = true;
+
+ if ( SelectRange(m_anchor, item) )
+ notify = true;
+ }
+ //else: treat it as ordinary click/keypress
+ }
+ else // Shift not pressed
+ {
+ m_anchor = item;
+
+ if ( flags & ItemClick_Ctrl )
+ {
+ select = false;
+
+ if ( !(flags & ItemClick_Kbd) )
+ {
+ Toggle(item);
+
+ // the status of the item has definitely changed
+ notify = true;
+ }
+ //else: Ctrl-arrow pressed, don't change selection
+ }
+ //else: behave as in single selection case
+ }
+
+ if ( select )
+ {
+ // make the clicked item the only selection
+ if ( DeselectAll() )
+ notify = true;
+
+ if ( Select(item) )
+ notify = true;
+ }
+ }
+
+ // in any case the item should become the current one
+ if ( DoSetCurrent(item) )
+ {
+ if ( !HasMultipleSelection() )
+ {
+ // this has also changed the selection for single selection case
+ notify = true;
+ }
+ }
+
+ if ( notify )
+ {
+ // notify the user about the selection change
+ SendSelectedEvent();
+ }
+ //else: nothing changed at all
+}
+
// ----------------------------------------------------------------------------
-// wxVListBox keyboard handling
+// keyboard handling
// ----------------------------------------------------------------------------
void wxVListBox::OnKeyDown(wxKeyEvent& event)
{
- int selection = 0; // just to silent the stupid compiler warnings
+ // flags for DoHandleItemClick()
+ int flags = ItemClick_Kbd;
+
+ int current;
switch ( event.GetKeyCode() )
{
case WXK_HOME:
- selection = 0;
+ current = 0;
break;
case WXK_END:
- selection = GetLineCount() - 1;
+ current = GetRowCount() - 1;
break;
case WXK_DOWN:
- if ( m_selection == (int)GetLineCount() - 1 )
+ if ( m_current == (int)GetRowCount() - 1 )
return;
- selection = m_selection + 1;
+ current = m_current + 1;
break;
case WXK_UP:
- if ( m_selection == -1 )
- selection = GetLineCount() - 1;
- else if ( m_selection != 0 )
- selection = m_selection - 1;
- else // m_selection == 0
+ if ( m_current == wxNOT_FOUND )
+ current = GetRowCount() - 1;
+ else if ( m_current != 0 )
+ current = m_current - 1;
+ else // m_current == 0
return;
break;
case WXK_PAGEDOWN:
- case WXK_NEXT:
PageDown();
- selection = GetFirstVisibleLine();
+ current = GetVisibleBegin();
break;
case WXK_PAGEUP:
- case WXK_PRIOR:
- if ( m_selection == (int)GetFirstVisibleLine() )
+ if ( m_current == (int)GetVisibleBegin() )
{
PageUp();
}
- selection = GetFirstVisibleLine();
+ current = GetVisibleBegin();
+ break;
+
+ case WXK_SPACE:
+ // hack: pressing space should work like a mouse click rather than
+ // like a keyboard arrow press, so trick DoHandleItemClick() in
+ // thinking we were clicked
+ flags &= ~ItemClick_Kbd;
+ current = m_current;
break;
+#ifdef __WXMSW__
+ case WXK_TAB:
+ // Since we are using wxWANTS_CHARS we need to send navigation
+ // events for the tabs on MSW
+ HandleAsNavigationKey(event);
+ // fall through to default
+#endif
default:
event.Skip();
+ current = 0; // just to silent the stupid compiler warnings
+ wxUnusedVar(current);
return;
}
- DoSetSelection(selection);
+ if ( event.ShiftDown() )
+ flags |= ItemClick_Shift;
+ if ( event.ControlDown() )
+ flags |= ItemClick_Ctrl;
+
+ DoHandleItemClick(current, flags);
}
// ----------------------------------------------------------------------------
void wxVListBox::OnLeftDown(wxMouseEvent& event)
{
- int item = HitTest(event.GetPosition());
+ SetFocus();
+
+ int item = VirtualHitTest(event.GetPosition().y);
+
+ if ( item != wxNOT_FOUND )
+ {
+ int flags = 0;
+ if ( event.ShiftDown() )
+ flags |= ItemClick_Shift;
+
+ // under Mac Apple-click is used in the same way as Ctrl-click
+ // elsewhere
+#ifdef __WXMAC__
+ if ( event.MetaDown() )
+#else
+ if ( event.ControlDown() )
+#endif
+ flags |= ItemClick_Ctrl;
- DoSetSelection(item);
+ DoHandleItemClick(item, flags);
+ }
}
-void wxVListBox::OnLeftDClick(wxMouseEvent& event)
+void wxVListBox::OnLeftDClick(wxMouseEvent& eventMouse)
{
- int item = HitTest(event.GetPosition());
- if ( item != -1 )
+ int item = VirtualHitTest(eventMouse.GetPosition().y);
+ if ( item != wxNOT_FOUND )
{
- wxCommandEvent event(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, GetId());
- event.SetEventObject(this);
- event.m_commandInt = item;
- (void)GetEventHandler()->ProcessEvent(event);
+ // if item double-clicked was not yet selected, then treat
+ // this event as a left-click instead
+ if ( item == m_current )
+ {
+ wxCommandEvent event(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, GetId());
+ event.SetEventObject(this);
+ event.SetInt(item);
+
+ (void)GetEventHandler()->ProcessEvent(event);
+ }
+ else
+ {
+ OnLeftDown(eventMouse);
+ }
+
}
}
+
+// ----------------------------------------------------------------------------
+// use the same default attributes as wxListBox
+// ----------------------------------------------------------------------------
+
+//static
+wxVisualAttributes
+wxVListBox::GetClassDefaultAttributes(wxWindowVariant variant)
+{
+ return wxListBox::GetClassDefaultAttributes(variant);
+}
+
+#endif
projects / wxWidgets.git / blobdiff