Rename wxWebNavigationError to wxWebViewNavigationError and wxWebNavigationEvent...

[wxWidgets.git] / src / generic / vlbox.cpp

diff --git a/src/generic/vlbox.cpp b/src/generic/vlbox.cpp
index bc846054a238b49dceae8b7b79ea47752fe1b91f..aa68ea17127a36b5e5d0f88a0f84f273dd02eee1 100644 (file)
--- a/src/generic/vlbox.cpp
+++ b/src/generic/vlbox.cpp
@@ -1,12 +1,12 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        generic/vlbox.cpp
+// Name:        src/generic/vlbox.cpp

 // Purpose:     implementation of wxVListBox
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     31.05.03
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
 // Purpose:     implementation of wxVListBox
 // 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

 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -24,13 +24,19 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#if wxUSE_LISTBOX
+
+#include "wx/vlbox.h"
+

 #ifndef WX_PRECOMP
     #include "wx/settings.h"
     #include "wx/dcclient.h"
 #ifndef WX_PRECOMP
     #include "wx/settings.h"
     #include "wx/dcclient.h"

+    #include "wx/listbox.h"

 #endif //WX_PRECOMP
 
 #endif //WX_PRECOMP
 

-#include "wx/vlbox.h"
+#include "wx/dcbuffer.h"

 #include "wx/selstore.h"
 #include "wx/selstore.h"

+#include "wx/renderer.h"

 
 // ----------------------------------------------------------------------------
 // event tables
 
 // ----------------------------------------------------------------------------
 // event tables


@@ -42,12 +48,20 @@ BEGIN_EVENT_TABLE(wxVListBox, wxVScrolledWindow)
     EVT_KEY_DOWN(wxVListBox::OnKeyDown)
     EVT_LEFT_DOWN(wxVListBox::OnLeftDown)
     EVT_LEFT_DCLICK(wxVListBox::OnLeftDClick)
     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()
 
 // ============================================================================
 // implementation
 // ============================================================================
 
 END_EVENT_TABLE()
 
 // ============================================================================
 // implementation
 // ============================================================================
 

+IMPLEMENT_ABSTRACT_CLASS(wxVListBox, wxVScrolledWindow)
+const char wxVListBoxNameStr[] = "wxVListBox";
+

 // ----------------------------------------------------------------------------
 // wxVListBox creation
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxVListBox creation
 // ----------------------------------------------------------------------------


@@ -66,14 +80,29 @@ bool wxVListBox::Create(wxWindow *parent,
                         long style,
                         const wxString& name)
 {
                         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;
 
     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;
 
     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());
+
+    // 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;
 }
 
     return true;
 }
 


@@ -84,13 +113,17 @@ wxVListBox::~wxVListBox()
 
 void wxVListBox::SetItemCount(size_t count)
 {
 
 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);
     }
 
     if ( m_selStore )
     {
         // tell the selection store that our number of items has changed
         m_selStore->SetItemCount(count);
     }
 

-    SetLineCount(count);
+    SetRowCount(count);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -105,16 +138,16 @@ bool wxVListBox::IsSelected(size_t line) const
 bool wxVListBox::Select(size_t item, bool select)
 {
     wxCHECK_MSG( m_selStore, false,
 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,
 
     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
 
     bool changed = m_selStore->SelectItem(item, select);
     if ( changed )
     {
         // selection really changed

-        RefreshLine(item);
+        RefreshRow(item);

     }
 
     DoSetCurrent(item);
     }
 
     DoSetCurrent(item);


@@ -125,7 +158,7 @@ bool wxVListBox::Select(size_t item, bool select)
 bool wxVListBox::SelectRange(size_t from, size_t to)
 {
     wxCHECK_MSG( m_selStore, false,
 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 )
 
     // make sure items are in correct order
     if ( from > to )


@@ -136,14 +169,14 @@ bool wxVListBox::SelectRange(size_t from, size_t to)
     }
 
     wxCHECK_MSG( to < GetItemCount(), false,
     }
 
     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
 
     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
     {
     }
     else // we've got the indices of the changed items
     {


@@ -157,7 +190,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++ )
         {
         // refresh just the lines which have really changed
         for ( size_t n = 0; n < count; n++ )
         {

-            RefreshLine(changed[n]);
+            RefreshRow(changed[n]);

         }
     }
 
         }
     }
 


@@ -168,7 +201,7 @@ bool wxVListBox::SelectRange(size_t from, size_t to)
 bool wxVListBox::DoSelectAll(bool select)
 {
     wxCHECK_MSG( m_selStore, false,
 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 )
 
     size_t count = GetItemCount();
     if ( count )


@@ -191,7 +224,7 @@ bool wxVListBox::DoSetCurrent(int current)
 {
     wxASSERT_MSG( current == wxNOT_FOUND ||
                     (current >= 0 && (size_t)current < GetItemCount()),
 {
     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 )
     {
 
     if ( current == m_current )
     {


@@ -200,7 +233,7 @@ bool wxVListBox::DoSetCurrent(int current)
     }
 
     if ( m_current != wxNOT_FOUND )
     }
 
     if ( m_current != wxNOT_FOUND )

-        RefreshLine(m_current);
+        RefreshRow(m_current);

 
     m_current = current;
 
 
     m_current = current;
 


@@ -210,35 +243,37 @@ bool wxVListBox::DoSetCurrent(int current)
         // don't need to refresh it -- it will be redrawn anyhow
         if ( !IsVisible(m_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
         }
         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_current == GetLastVisibleLine() )
-            {
-                ScrollToLine(m_current);
-            }
+            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
 
             // 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;
 }
 
         }
     }
 
     return true;
 }
 

+void wxVListBox::InitEvent(wxCommandEvent& event, int n)
+{
+    event.SetEventObject(this);
+    event.SetInt(n);
+}
+

 void wxVListBox::SendSelectedEvent()
 {
     wxASSERT_MSG( m_current != wxNOT_FOUND,
 void wxVListBox::SendSelectedEvent()
 {
     wxASSERT_MSG( m_current != wxNOT_FOUND,

-                    _T("SendSelectedEvent() shouldn't be called") );
+                    wxT("SendSelectedEvent() shouldn't be called") );

 
     wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, GetId());
 
     wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, GetId());

-    event.SetEventObject(this);
-    event.m_commandInt = m_current;
-
+    InitEvent(event, m_current);

     (void)GetEventHandler()->ProcessEvent(event);
 }
 
     (void)GetEventHandler()->ProcessEvent(event);
 }
 


@@ -246,10 +281,16 @@ void wxVListBox::SetSelection(int selection)
 {
     wxCHECK_RET( selection == wxNOT_FOUND ||
                   (selection >= 0 && (size_t)selection < GetItemCount()),
 {
     wxCHECK_RET( selection == wxNOT_FOUND ||
                   (selection >= 0 && (size_t)selection < GetItemCount()),

-                  _T("wxVListBox::SetSelection(): invalid item index") );
+                  wxT("wxVListBox::SetSelection(): invalid item index") );

 
 

-    wxASSERT_MSG( !HasMultipleSelection(),
-                  _T("SetSelection() is invalid with multiselection listbox") );
+    if ( HasMultipleSelection() )
+    {
+        if (selection != wxNOT_FOUND)
+            Select(selection);
+        else
+            DeselectAll();
+        m_anchor = selection;
+    }

 
     DoSetCurrent(selection);
 }
 
     DoSetCurrent(selection);
 }


@@ -270,7 +311,7 @@ int wxVListBox::GetFirstSelected(unsigned long& cookie) const
 int wxVListBox::GetNextSelected(unsigned long& cookie) const
 {
     wxCHECK_MSG( m_selStore, wxNOT_FOUND,
 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() )
     {
 
     while ( cookie < GetItemCount() )
     {


@@ -281,8 +322,43 @@ int wxVListBox::GetNextSelected(unsigned long& cookie) const
     return wxNOT_FOUND;
 }
 
     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 painting
+// wxVListBox appearance parameters

 // ----------------------------------------------------------------------------
 
 void wxVListBox::SetMargins(const wxPoint& pt)
 // ----------------------------------------------------------------------------
 
 void wxVListBox::SetMargins(const wxPoint& pt)


@@ -295,7 +371,16 @@ 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;
 }
 {
     return OnMeasureItem(line) + 2*m_ptMargins.y;
 }


@@ -306,53 +391,88 @@ void wxVListBox::OnDrawSeparator(wxDC& WXUNUSED(dc),
 {
 }
 
 {
 }
 

-void wxVListBox::OnPaint(wxPaintEvent& event)
+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);
+    if ( isSelected || isCurrent )
+    {
+        if ( isSelected )
+        {
+            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

 {
 {

-    wxPaintDC dc(this);
+    // 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))
+{
+    wxSize clientSize = GetClientSize();
+
+    wxAutoBufferedPaintDC dc(this);

 
     // the update rectangle
     wxRect rectUpdate = GetUpdateClientRect();
 
 
     // the update rectangle
     wxRect rectUpdate = GetUpdateClientRect();
 

+    // fill it with background colour
+    dc.SetBackground(GetBackgroundColour());
+    dc.Clear();
+

     // the bounding rectangle of the current line
     // the bounding rectangle of the current line

-    wxRect rectLine;
-    rectLine.width = GetClientSize().x;
+    wxRect rectRow;
+    rectRow.width = clientSize.x;

 
     // iterate over all visible lines
 
     // 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
 
         // 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
         {
             // don't allow drawing outside of the lines rectangle

-            wxDCClipper clip(dc, rectLine);
+            wxDCClipper clip(dc, rectRow);

 
 

-            // we need to render selected and current items differently
-            const bool isSelected = IsSelected(line);
-            if ( isSelected || IsCurrent(line) )
-            {
-                if ( isSelected )
-                {
-                    wxBrush brush(wxSystemSettings::
-                                    GetColour(wxSYS_COLOUR_HIGHLIGHT),
-                                    wxSOLID);
-                    dc.SetBrush(brush);
-                }
-                else // !selected
-                {
-                    dc.SetBrush(*wxTRANSPARENT_BRUSH);
-                }
+            wxRect rect = rectRow;
+            OnDrawBackground(dc, rect, line);

 
 

-                dc.SetPen(*(IsCurrent(line) ? wxBLACK_PEN : wxTRANSPARENT_PEN));
-
-                dc.DrawRectangle(rectLine);
-            }
-
-            wxRect rect = rectLine;

             OnDrawSeparator(dc, rect, line);
 
             rect.Deflate(m_ptMargins.x, m_ptMargins.y);
             OnDrawSeparator(dc, rect, line);
 
             rect.Deflate(m_ptMargins.x, m_ptMargins.y);


@@ -360,7 +480,7 @@ void wxVListBox::OnPaint(wxPaintEvent& event)
         }
         else // no intersection
         {
         }
         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
             {
                 // we are already below the update rect, no need to continue
                 // further


@@ -369,10 +489,24 @@ void wxVListBox::OnPaint(wxPaintEvent& event)
             //else: the next line may intersect the update rect
         }
 
             //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
 // ============================================================================
 // ============================================================================
 // wxVListBox keyboard/mouse handling
 // ============================================================================


@@ -467,27 +601,31 @@ void wxVListBox::OnKeyDown(wxKeyEvent& event)
     // flags for DoHandleItemClick()
     int flags = ItemClick_Kbd;
 
     // flags for DoHandleItemClick()
     int flags = ItemClick_Kbd;
 

-    int current = 0; // just to silent the stupid compiler warnings
+    int current;

     switch ( event.GetKeyCode() )
     {
         case WXK_HOME:
     switch ( event.GetKeyCode() )
     {
         case WXK_HOME:

+        case WXK_NUMPAD_HOME:

             current = 0;
             break;
 
         case WXK_END:
             current = 0;
             break;
 
         case WXK_END:

-            current = GetLineCount() - 1;
+        case WXK_NUMPAD_END:
+            current = GetRowCount() - 1;

             break;
 
         case WXK_DOWN:
             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:
                 return;
 
             current = m_current + 1;
             break;
 
         case WXK_UP:

+        case WXK_NUMPAD_UP:

             if ( m_current == wxNOT_FOUND )
             if ( m_current == wxNOT_FOUND )

-                current = GetLineCount() - 1;
+                current = GetRowCount() - 1;

             else if ( m_current != 0 )
                 current = m_current - 1;
             else // m_current == 0
             else if ( m_current != 0 )
                 current = m_current - 1;
             else // m_current == 0


@@ -495,19 +633,19 @@ void wxVListBox::OnKeyDown(wxKeyEvent& event)
             break;
 
         case WXK_PAGEDOWN:
             break;
 
         case WXK_PAGEDOWN:

-        case WXK_NEXT:
+        case WXK_NUMPAD_PAGEDOWN:

             PageDown();
             PageDown();

-            current = GetFirstVisibleLine();
+            current = GetVisibleBegin();

             break;
 
         case WXK_PAGEUP:
             break;
 
         case WXK_PAGEUP:

-        case WXK_PRIOR:
-            if ( m_current == (int)GetFirstVisibleLine() )
+        case WXK_NUMPAD_PAGEUP:
+            if ( m_current == (int)GetVisibleBegin() )

             {
                 PageUp();
             }
 
             {
                 PageUp();
             }
 

-            current = GetFirstVisibleLine();
+            current = GetVisibleBegin();

             break;
 
         case WXK_SPACE:
             break;
 
         case WXK_SPACE:


@@ -518,8 +656,17 @@ void wxVListBox::OnKeyDown(wxKeyEvent& event)
             current = m_current;
             break;
 
             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();
         default:
             event.Skip();

+            current = 0; // just to silent the stupid compiler warnings
+            wxUnusedVar(current);

             return;
     }
 
             return;
     }
 


@@ -537,7 +684,9 @@ void wxVListBox::OnKeyDown(wxKeyEvent& event)
 
 void wxVListBox::OnLeftDown(wxMouseEvent& event)
 {
 
 void wxVListBox::OnLeftDown(wxMouseEvent& event)
 {

-    int item = HitTest(event.GetPosition());
+    SetFocus();
+
+    int item = VirtualHitTest(event.GetPosition().y);

 
     if ( item != wxNOT_FOUND )
     {
 
     if ( item != wxNOT_FOUND )
     {


@@ -558,16 +707,38 @@ void wxVListBox::OnLeftDown(wxMouseEvent& event)
     }
 }
 
     }
 }
 

-void wxVListBox::OnLeftDClick(wxMouseEvent& event)
+void wxVListBox::OnLeftDClick(wxMouseEvent& eventMouse)

 {
 {

-    int item = HitTest(event.GetPosition());
+    int item = VirtualHitTest(eventMouse.GetPosition().y);

     if ( item != wxNOT_FOUND )
     {
     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());
+            InitEvent(event, 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