]> git.saurik.com Git - wxWidgets.git/blobdiff - src/generic/vlbox.cpp
wxRTC: fixed guidelines overwriting adjacent cell borders; corrected capitalisation...
[wxWidgets.git] / src / generic / vlbox.cpp
index 2a3ca54d1cbce461ab5a6664f0dd6fb3af239648..e277070b3dad75608ecdad9c8f99717c599643f0 100644 (file)
@@ -4,9 +4,8 @@
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     31.05.03
-// RCS-ID:      $Id$
 // Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
-// License:     wxWindows license
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
@@ -36,6 +35,7 @@
 
 #include "wx/dcbuffer.h"
 #include "wx/selstore.h"
+#include "wx/renderer.h"
 
 // ----------------------------------------------------------------------------
 // event tables
@@ -47,6 +47,11 @@ BEGIN_EVENT_TABLE(wxVListBox, wxVScrolledWindow)
     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)
+
+    EVT_SIZE(wxVListBox::OnSize)
 END_EVENT_TABLE()
 
 // ============================================================================
@@ -54,6 +59,7 @@ END_EVENT_TABLE()
 // ============================================================================
 
 IMPLEMENT_ABSTRACT_CLASS(wxVListBox, wxVScrolledWindow)
+const char wxVListBoxNameStr[] = "wxVListBox";
 
 // ----------------------------------------------------------------------------
 // wxVListBox creation
@@ -73,6 +79,11 @@ bool wxVListBox::Create(wxWindow *parent,
                         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;
@@ -83,7 +94,10 @@ bool wxVListBox::Create(wxWindow *parent,
     // make sure the native widget has the right colour since we do
     // transparent drawing by default
     SetBackgroundColour(GetBackgroundColour());
-    m_colBgSel = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
+
+    // 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);
@@ -98,13 +112,17 @@ wxVListBox::~wxVListBox()
 
 void wxVListBox::SetItemCount(size_t count)
 {
+    // don't leave the current index invalid
+    if ( m_current != wxNOT_FOUND && (size_t)m_current >= count )
+        m_current = count - 1; // also ok when count == 0 as wxNOT_FOUND == -1
+
     if ( m_selStore )
     {
         // tell the selection store that our number of items has changed
         m_selStore->SetItemCount(count);
     }
 
-    SetLineCount(count);
+    SetRowCount(count);
 }
 
 // ----------------------------------------------------------------------------
@@ -119,16 +137,16 @@ bool wxVListBox::IsSelected(size_t line) const
 bool wxVListBox::Select(size_t item, bool select)
 {
     wxCHECK_MSG( m_selStore, false,
-                 _T("Select() may only be used with multiselection listbox") );
+                 wxT("Select() may only be used with multiselection listbox") );
 
     wxCHECK_MSG( item < GetItemCount(), false,
-                 _T("Select(): invalid item index") );
+                 wxT("Select(): invalid item index") );
 
     bool changed = m_selStore->SelectItem(item, select);
     if ( changed )
     {
         // selection really changed
-        RefreshLine(item);
+        RefreshRow(item);
     }
 
     DoSetCurrent(item);
@@ -139,7 +157,7 @@ bool wxVListBox::Select(size_t item, bool select)
 bool wxVListBox::SelectRange(size_t from, size_t to)
 {
     wxCHECK_MSG( m_selStore, false,
-                 _T("SelectRange() may only be used with multiselection listbox") );
+                 wxT("SelectRange() may only be used with multiselection listbox") );
 
     // make sure items are in correct order
     if ( from > to )
@@ -150,14 +168,14 @@ bool wxVListBox::SelectRange(size_t from, size_t to)
     }
 
     wxCHECK_MSG( to < GetItemCount(), false,
-                    _T("SelectRange(): invalid item index") );
+                    wxT("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
-        RefreshLines(from, to);
+        RefreshRows(from, to);
     }
     else // we've got the indices of the changed items
     {
@@ -171,7 +189,7 @@ bool wxVListBox::SelectRange(size_t from, size_t to)
         // refresh just the lines which have really changed
         for ( size_t n = 0; n < count; n++ )
         {
-            RefreshLine(changed[n]);
+            RefreshRow(changed[n]);
         }
     }
 
@@ -182,7 +200,7 @@ bool wxVListBox::SelectRange(size_t from, size_t to)
 bool wxVListBox::DoSelectAll(bool select)
 {
     wxCHECK_MSG( m_selStore, false,
-                 _T("SelectAll may only be used with multiselection listbox") );
+                 wxT("SelectAll may only be used with multiselection listbox") );
 
     size_t count = GetItemCount();
     if ( count )
@@ -205,7 +223,7 @@ bool wxVListBox::DoSetCurrent(int current)
 {
     wxASSERT_MSG( current == wxNOT_FOUND ||
                     (current >= 0 && (size_t)current < GetItemCount()),
-                  _T("wxVListBox::DoSetCurrent(): invalid item index") );
+                  wxT("wxVListBox::DoSetCurrent(): invalid item index") );
 
     if ( current == m_current )
     {
@@ -214,7 +232,7 @@ bool wxVListBox::DoSetCurrent(int current)
     }
 
     if ( m_current != wxNOT_FOUND )
-        RefreshLine(m_current);
+        RefreshRow(m_current);
 
     m_current = current;
 
@@ -224,33 +242,40 @@ bool wxVListBox::DoSetCurrent(int current)
         // don't need to refresh it -- it will be redrawn anyhow
         if ( !IsVisible(m_current) )
         {
-            ScrollToLine(m_current);
+            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
-            while ( (size_t)m_current == GetLastVisibleLine() &&
-                    ScrollToLine(GetVisibleBegin()+1) ) ;
+            // BUT scrolling down when m_current is first visible makes it
+            // completely hidden, so that is even worse
+            while ( (size_t)m_current + 1 == GetVisibleRowsEnd() &&
+                    (size_t)m_current != GetVisibleRowsBegin() &&
+                    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_current);
+            RefreshRow(m_current);
         }
     }
 
     return true;
 }
 
+void wxVListBox::InitEvent(wxCommandEvent& event, int n)
+{
+    event.SetEventObject(this);
+    event.SetInt(n);
+}
+
 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);
+                    wxT("SendSelectedEvent() shouldn't be called") );
 
+    wxCommandEvent event(wxEVT_LISTBOX, GetId());
+    InitEvent(event, m_current);
     (void)GetEventHandler()->ProcessEvent(event);
 }
 
@@ -258,7 +283,7 @@ void wxVListBox::SetSelection(int selection)
 {
     wxCHECK_RET( selection == wxNOT_FOUND ||
                   (selection >= 0 && (size_t)selection < GetItemCount()),
-                  _T("wxVListBox::SetSelection(): invalid item index") );
+                  wxT("wxVListBox::SetSelection(): invalid item index") );
 
     if ( HasMultipleSelection() )
     {
@@ -288,7 +313,7 @@ int wxVListBox::GetFirstSelected(unsigned long& cookie) const
 int wxVListBox::GetNextSelected(unsigned long& cookie) const
 {
     wxCHECK_MSG( m_selStore, wxNOT_FOUND,
-                  _T("GetFirst/NextSelected() may only be used with multiselection listboxes") );
+                  wxT("GetFirst/NextSelected() may only be used with multiselection listboxes") );
 
     while ( cookie < GetItemCount() )
     {
@@ -299,6 +324,41 @@ int wxVListBox::GetNextSelected(unsigned long& cookie) const
     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);
+    }
+}
+
+wxRect wxVListBox::GetItemRect(size_t n) const
+{
+    wxRect itemrect;
+
+    // check that this item is visible
+    const size_t lineMax = GetVisibleEnd();
+    if ( n >= lineMax )
+        return itemrect;
+    size_t line = GetVisibleBegin();
+    if ( n < line )
+        return itemrect;
+
+    while ( line <= n )
+    {
+        itemrect.y += itemrect.height;
+        itemrect.height = OnGetRowHeight(line);
+
+        line++;
+    }
+
+    itemrect.width = GetClientSize().x;
+
+    return itemrect;
+}
+
 // ----------------------------------------------------------------------------
 // wxVListBox appearance parameters
 // ----------------------------------------------------------------------------
@@ -322,7 +382,7 @@ void wxVListBox::SetSelectionBackground(const wxColour& col)
 // wxVListBox painting
 // ----------------------------------------------------------------------------
 
-wxCoord wxVListBox::OnGetLineHeight(size_t line) const
+wxCoord wxVListBox::OnGetRowHeight(size_t line) const
 {
     return OnMeasureItem(line) + 2*m_ptMargins.y;
 }
@@ -333,8 +393,15 @@ void wxVListBox::OnDrawSeparator(wxDC& WXUNUSED(dc),
 {
 }
 
-void wxVListBox::OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const
+bool
+wxVListBox::DoDrawSolidBackground(const wxColour& col,
+                                  wxDC& dc,
+                                  const wxRect& rect,
+                                  size_t n) const
 {
+    if ( !col.IsOk() )
+        return false;
+
     // we need to render selected and current items differently
     const bool isSelected = IsSelected(n),
                isCurrent = IsCurrent(n);
@@ -342,18 +409,36 @@ void wxVListBox::OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const
     {
         if ( isSelected )
         {
-            dc.SetBrush(wxBrush(m_colBgSel, wxSOLID));
+            dc.SetBrush(wxBrush(col, wxBRUSHSTYLE_SOLID));
         }
         else // !selected
         {
             dc.SetBrush(*wxTRANSPARENT_BRUSH);
         }
-
         dc.SetPen(*(isCurrent ? wxBLACK_PEN : wxTRANSPARENT_PEN));
-
         dc.DrawRectangle(rect);
     }
     //else: do nothing for the normal items
+
+    return true;
+}
+
+void wxVListBox::OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const
+{
+    // use wxRendererNative for more native look unless we use custom bg colour
+    if ( !DoDrawSolidBackground(m_colBgSel, dc, rect, n) )
+    {
+        int flags = 0;
+        if ( IsSelected(n) )
+            flags |= wxCONTROL_SELECTED;
+        if ( IsCurrent(n) )
+            flags |= wxCONTROL_CURRENT;
+        if ( wxWindow::FindFocus() == const_cast<wxVListBox*>(this) )
+            flags |= wxCONTROL_FOCUSED;
+
+        wxRendererNative::Get().DrawItemSelectionRect(
+            const_cast<wxVListBox *>(this), dc, rect, flags);
+    }
 }
 
 void wxVListBox::OnPaint(wxPaintEvent& WXUNUSED(event))
@@ -370,24 +455,24 @@ void wxVListBox::OnPaint(wxPaintEvent& WXUNUSED(event))
     dc.Clear();
 
     // the bounding rectangle of the current line
-    wxRect rectLine;
-    rectLine.width = clientSize.x;
+    wxRect rectRow;
+    rectRow.width = clientSize.x;
 
     // iterate over all visible lines
     const size_t lineMax = GetVisibleEnd();
-    for ( size_t line = GetFirstVisibleLine(); line < lineMax; line++ )
+    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);
 
-            wxRect rect = rectLine;
+            wxRect rect = rectRow;
             OnDrawBackground(dc, rect, line);
 
             OnDrawSeparator(dc, rect, line);
@@ -397,7 +482,7 @@ void wxVListBox::OnPaint(wxPaintEvent& WXUNUSED(event))
         }
         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
@@ -406,10 +491,24 @@ void wxVListBox::OnPaint(wxPaintEvent& WXUNUSED(event))
             //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();
+}
+
+void wxVListBox::OnSize(wxSizeEvent& event)
+{
+    UpdateScrollbar();
+    event.Skip();
+}
+
 // ============================================================================
 // wxVListBox keyboard/mouse handling
 // ============================================================================
@@ -508,23 +607,27 @@ void wxVListBox::OnKeyDown(wxKeyEvent& event)
     switch ( event.GetKeyCode() )
     {
         case WXK_HOME:
+        case WXK_NUMPAD_HOME:
             current = 0;
             break;
 
         case WXK_END:
-            current = GetLineCount() - 1;
+        case WXK_NUMPAD_END:
+            current = GetRowCount() - 1;
             break;
 
         case WXK_DOWN:
-            if ( m_current == (int)GetLineCount() - 1 )
+        case WXK_NUMPAD_DOWN:
+            if ( m_current == (int)GetRowCount() - 1 )
                 return;
 
             current = m_current + 1;
             break;
 
         case WXK_UP:
+        case WXK_NUMPAD_UP:
             if ( m_current == wxNOT_FOUND )
-                current = GetLineCount() - 1;
+                current = GetRowCount() - 1;
             else if ( m_current != 0 )
                 current = m_current - 1;
             else // m_current == 0
@@ -532,17 +635,19 @@ void wxVListBox::OnKeyDown(wxKeyEvent& event)
             break;
 
         case WXK_PAGEDOWN:
+        case WXK_NUMPAD_PAGEDOWN:
             PageDown();
-            current = GetFirstVisibleLine();
+            current = GetVisibleBegin();
             break;
 
         case WXK_PAGEUP:
-            if ( m_current == (int)GetFirstVisibleLine() )
+        case WXK_NUMPAD_PAGEUP:
+            if ( m_current == (int)GetVisibleBegin() )
             {
                 PageUp();
             }
 
-            current = GetFirstVisibleLine();
+            current = GetVisibleBegin();
             break;
 
         case WXK_SPACE:
@@ -557,13 +662,7 @@ void wxVListBox::OnKeyDown(wxKeyEvent& event)
         case WXK_TAB:
             // Since we are using wxWANTS_CHARS we need to send navigation
             // events for the tabs on MSW
-            {
-                wxNavigationKeyEvent ne;
-                ne.SetDirection(!event.ShiftDown());
-                ne.SetCurrentFocus(this);
-                ne.SetEventObject(this);
-                GetParent()->GetEventHandler()->ProcessEvent(ne);
-            }
+            HandleAsNavigationKey(event);
             // fall through to default
 #endif
         default:
@@ -589,7 +688,7 @@ void wxVListBox::OnLeftDown(wxMouseEvent& event)
 {
     SetFocus();
 
-    int item = HitTest(event.GetPosition());
+    int item = VirtualHitTest(event.GetPosition().y);
 
     if ( item != wxNOT_FOUND )
     {
@@ -612,7 +711,7 @@ void wxVListBox::OnLeftDown(wxMouseEvent& event)
 
 void wxVListBox::OnLeftDClick(wxMouseEvent& eventMouse)
 {
-    int item = HitTest(eventMouse.GetPosition());
+    int item = VirtualHitTest(eventMouse.GetPosition().y);
     if ( item != wxNOT_FOUND )
     {
 
@@ -620,10 +719,8 @@ void wxVListBox::OnLeftDClick(wxMouseEvent& eventMouse)
         // this event as a left-click instead
         if ( item == m_current )
         {
-            wxCommandEvent event(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, GetId());
-            event.SetEventObject(this);
-            event.SetInt(item);
-
+            wxCommandEvent event(wxEVT_LISTBOX_DCLICK, GetId());
+            InitEvent(event, item);
             (void)GetEventHandler()->ProcessEvent(event);
         }
         else