Take into account cell's own size, not only the

[wxWidgets.git] / src / univ / listbox.cpp

diff --git a/src/univ/listbox.cpp b/src/univ/listbox.cpp
index a4eda3e861b9d905667adbb23405c1440520a125..663611a6c76d521a8f01232bfe1acc616266224f 100644 (file)
--- a/src/univ/listbox.cpp
+++ b/src/univ/listbox.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        univ/listbox.cpp
+// Name:        src/univ/listbox.cpp

 // Purpose:     wxListBox implementation
 // Author:      Vadim Zeitlin
 // Modified by:
 // Purpose:     wxListBox implementation
 // Author:      Vadim Zeitlin
 // Modified by:


@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "univlistbox.h"
-#endif
-

 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__


@@ -49,8 +45,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
 
 BEGIN_EVENT_TABLE(wxListBox, wxListBoxBase)
     EVT_SIZE(wxListBox::OnSize)
 
 BEGIN_EVENT_TABLE(wxListBox, wxListBoxBase)
     EVT_SIZE(wxListBox::OnSize)

-
-    EVT_IDLE(wxListBox::OnIdle)

 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------
 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------


@@ -65,11 +59,12 @@ void wxListBox::Init()
     m_maxWidth = 0;
     m_scrollRangeY = 0;
     m_maxWidthItem = -1;
     m_maxWidth = 0;
     m_scrollRangeY = 0;
     m_maxWidthItem = -1;

+    m_strings = NULL;

 
     // no items hence no current item
     m_current = -1;
     m_selAnchor = -1;
 
     // 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;
 
     // no need to update anything initially
     m_updateCount = 0;


@@ -78,7 +73,37 @@ void wxListBox::Init()
     m_updateScrollbarX =
     m_showScrollbarX =
     m_updateScrollbarY =
     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,
 }
 
 bool wxListBox::Create(wxWindow *parent,


@@ -101,13 +126,17 @@ bool wxListBox::Create(wxWindow *parent,
     if ( !(style & (wxLB_MULTIPLE | wxLB_EXTENDED)) )
         style |= wxLB_SINGLE;
 
     if ( !(style & (wxLB_MULTIPLE | wxLB_EXTENDED)) )
         style |= wxLB_SINGLE;
 

-    if ( !wxControl::Create(parent, id, pos, size, style, wxDefaultValidator, name) )
-        return FALSE;
+#if wxUSE_TWO_WINDOWS
+    style |=  wxVSCROLL|wxHSCROLL;
+    if ((style & wxBORDER_MASK) == 0)
+        style |= wxBORDER_SUNKEN;
+#endif

 
 

-    SetWindow(this);
+    if ( !wxControl::Create(parent, id, pos, size, style,
+                            validator, name) )
+        return false;

 
 

-    if ( style & wxLB_SORT )
-        m_strings = wxArrayString(TRUE /* auto sort */);
+    m_strings = new wxArrayString;

 
     Set(n, choices);
 
 
     Set(n, choices);
 


@@ -115,23 +144,54 @@ bool wxListBox::Create(wxWindow *parent,
 
     CreateInputHandler(wxINP_HANDLER_LISTBOX);
 
 
     CreateInputHandler(wxINP_HANDLER_LISTBOX);
 

-    return TRUE;
+    return true;

 }
 
 wxListBox::~wxListBox()
 {
 }
 
 wxListBox::~wxListBox()
 {

+    // call this just to free the client data -- and avoid leaking memory
+    DoClear();
+
+    delete m_strings;
+
+    m_strings = NULL;

 }
 
 // ----------------------------------------------------------------------------
 // adding/inserting strings
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // adding/inserting strings
 // ----------------------------------------------------------------------------
 

+int wxCMPFUNC_CONV wxListBoxSortNoCase(wxString* s1, wxString* s2)
+{
+    return  s1->CmpNoCase(*s2);
+}
+
+int wxListBox::DoAppendOnly(const wxString& item)
+{
+    size_t index;
+
+    if ( IsSorted() )
+    {
+        m_strings->Add(item);
+        m_strings->Sort(wxListBoxSortNoCase);
+        index = m_strings->Index(item);
+    }
+    else
+    {
+        index = m_strings->GetCount();
+        m_strings->Add(item);
+    }
+
+    return index;
+}
+

 int wxListBox::DoAppend(const wxString& item)
 {
 int wxListBox::DoAppend(const wxString& item)
 {

-    size_t index = m_strings.Add(item);
+    size_t index = DoAppendOnly( item );
+

     m_itemsClientData.Insert(NULL, index);
 
     m_itemsClientData.Insert(NULL, index);
 

-    m_updateScrollbarY = TRUE;
+    m_updateScrollbarY = true;

 
     if ( HasHorzScrollbar() )
     {
 
     if ( HasHorzScrollbar() )
     {


@@ -142,7 +202,7 @@ int wxListBox::DoAppend(const wxString& item)
         {
             m_maxWidth = width;
             m_maxWidthItem = index;
         {
             m_maxWidth = width;
             m_maxWidthItem = index;

-            m_updateScrollbarX = TRUE;
+            m_updateScrollbarX = true;

         }
     }
 
         }
     }
 


@@ -160,12 +220,12 @@ void wxListBox::DoInsertItems(const wxArrayString& items, int pos)
     size_t count = items.GetCount();
     for ( size_t n = 0; n < count; n++ )
     {
     size_t count = items.GetCount();
     for ( size_t n = 0; n < count; n++ )
     {

-        m_strings.Insert(items[n], pos + n);
+        m_strings->Insert(items[n], pos + n);

         m_itemsClientData.Insert(NULL, pos + n);
     }
 
     // the number of items has changed so we might have to show the scrollbar
         m_itemsClientData.Insert(NULL, pos + n);
     }
 
     // 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
 
     // 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


@@ -185,27 +245,33 @@ void wxListBox::DoSetItems(const wxArrayString& items, void **clientData)
     if ( !count )
         return;
 
     if ( !count )
         return;
 

-    m_strings.Alloc(count);
+    m_strings->Alloc(count);
+

     m_itemsClientData.Alloc(count);
     for ( size_t n = 0; n < count; n++ )
     {
     m_itemsClientData.Alloc(count);
     for ( size_t n = 0; n < count; n++ )
     {

-        size_t index = m_strings.Add(items[n]);
+        size_t index = DoAppendOnly(items[n]);
+

         m_itemsClientData.Insert(clientData ? clientData[n] : NULL, index);
     }
 
         m_itemsClientData.Insert(clientData ? clientData[n] : NULL, index);
     }
 

-    m_updateScrollbarY = TRUE;
+    m_updateScrollbarY = true;

 
     RefreshAll();
 }
 
 void wxListBox::SetString(int n, const wxString& s)
 {
 
     RefreshAll();
 }
 
 void wxListBox::SetString(int n, const wxString& s)
 {

+    wxCHECK_RET( !IsSorted(), _T("can't set string in sorted listbox") );
+
+    (*m_strings)[n] = s;
+

     if ( HasHorzScrollbar() )
     {
         // we need to update m_maxWidth as changing the string may cause the
         // horz scrollbar [dis]appear
         wxCoord width;
     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
         GetTextExtent(s, &width, NULL);
 
         // it might have increased if the new string is long


@@ -213,7 +279,7 @@ void wxListBox::SetString(int n, const wxString& s)
         {
             m_maxWidth = width;
             m_maxWidthItem = n;
         {
             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 )
         }
         // or also decreased if the old string was the longest one
         else if ( n == m_maxWidthItem )


@@ -221,10 +287,6 @@ void wxListBox::SetString(int n, const wxString& s)
             RefreshHorzScrollbar();
         }
     }
             RefreshHorzScrollbar();
         }
     }

-    else // no horz scrollbar
-    {
-        m_strings[n] = s;
-    }

 
     RefreshItem(n);
 }
 
     RefreshItem(n);
 }


@@ -235,7 +297,7 @@ void wxListBox::SetString(int n, const wxString& s)
 
 void wxListBox::DoClear()
 {
 
 void wxListBox::DoClear()
 {

-    m_strings.Clear();
+    m_strings->Clear();

 
     if ( HasClientObjectData() )
     {
 
     if ( HasClientObjectData() )
     {


@@ -256,7 +318,7 @@ void wxListBox::Clear()
 {
     DoClear();
 
 {
     DoClear();
 

-    m_updateScrollbarY = TRUE;
+    m_updateScrollbarY = true;

 
     RefreshHorzScrollbar();
 
 
     RefreshHorzScrollbar();
 


@@ -265,13 +327,14 @@ void wxListBox::Clear()
 
 void wxListBox::Delete(int n)
 {
 
 void wxListBox::Delete(int n)
 {

-    wxCHECK_RET( n < GetCount(), _T("invalid index in wxListBox::Delete") );
+    wxCHECK_RET( IsValid(n),
+                 _T("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);
 
 
     // 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);
+    m_strings->RemoveAt(n);

 
     if ( HasClientObjectData() )
     {
 
     if ( HasClientObjectData() )
     {


@@ -316,7 +379,7 @@ void wxListBox::Delete(int n)
     }
 
     // the number of items has changed, hence the scrollbar may disappear
     }
 
     // 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 )
 
     // finally, if the longest item was deleted the scrollbar may disappear
     if ( n == m_maxWidthItem )


@@ -353,7 +416,7 @@ wxClientData* wxListBox::DoGetItemClientObject(int n) const
 // selection
 // ----------------------------------------------------------------------------
 
 // selection
 // ----------------------------------------------------------------------------
 

-void wxListBox::SetSelection(int n, bool select)
+void wxListBox::DoSetSelection(int n, bool select)

 {
     if ( select )
     {
 {
     if ( select )
     {


@@ -398,10 +461,10 @@ void wxListBox::SetSelection(int n, bool select)
 
 int wxListBox::GetSelection() const
 {
 
 int wxListBox::GetSelection() const
 {

-    wxCHECK_MSG( !HasMultipleSelection(), -1,
+    wxCHECK_MSG( !HasMultipleSelection(), wxNOT_FOUND,

                  _T("use wxListBox::GetSelections for ths listbox") );
 
                  _T("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)
 }
 
 int wxCMPFUNC_CONV wxCompareInts(int *n, int *m)


@@ -503,7 +566,7 @@ void wxListBox::RefreshAll()
 void wxListBox::RefreshHorzScrollbar()
 {
     m_maxWidth = 0; // recalculate it
 void wxListBox::RefreshHorzScrollbar()
 {
     m_maxWidth = 0; // recalculate it

-    m_updateScrollbarX = TRUE;
+    m_updateScrollbarX = true;

 }
 
 void wxListBox::UpdateScrollbars()
 }
 
 void wxListBox::UpdateScrollbars()


@@ -511,9 +574,9 @@ void wxListBox::UpdateScrollbars()
     wxSize size = GetClientSize();
 
     // is our height enough to show all items?
     wxSize size = GetClientSize();
 
     // is our height enough to show all items?

-    int nLines = GetCount();
+    size_t nLines = GetCount();

     wxCoord lineHeight = GetLineHeight();
     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;
 
     // check the width too if required
     wxCoord charWidth, maxWidth;


@@ -527,7 +590,7 @@ void wxListBox::UpdateScrollbars()
     else // never show it
     {
         charWidth = maxWidth = 0;
     else // never show it
     {
         charWidth = maxWidth = 0;

-        showScrollbarX = FALSE;
+        showScrollbarX = false;

     }
 
     // what should be the scrollbar range now?
     }
 
     // what should be the scrollbar range now?


@@ -587,25 +650,25 @@ void wxListBox::UpdateItems()
                    m_updateFrom, m_updateFrom + m_updateCount - 1,
                    rect.GetTop(), rect.GetBottom());
 
                    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 =
 {
     if ( m_updateScrollbarY || m_updateScrollbarX )
     {
         UpdateScrollbars();
 
         m_updateScrollbarX =

-        m_updateScrollbarY = FALSE;
+        m_updateScrollbarY = false;

     }
 
     if ( m_currentChanged )
     {
         DoEnsureVisible(m_current);
 
     }
 
     if ( m_currentChanged )
     {
         DoEnsureVisible(m_current);
 

-        m_currentChanged = FALSE;
+        m_currentChanged = false;

     }
 
     if ( m_updateCount )
     }
 
     if ( m_updateCount )


@@ -614,8 +677,7 @@ void wxListBox::OnIdle(wxIdleEvent& event)
 
         m_updateCount = 0;
     }
 
         m_updateCount = 0;
     }

-
-    event.Skip();
+    wxListBoxBase::OnInternalIdle();

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


@@ -645,7 +707,7 @@ void wxListBox::DoDraw(wxControlRenderer *renderer)
     wxCoord lineHeight = GetLineHeight();
     size_t itemFirst = yTop / lineHeight,
            itemLast = (yBottom + lineHeight - 1) / lineHeight,
     wxCoord lineHeight = GetLineHeight();
     size_t itemFirst = yTop / lineHeight,
            itemLast = (yBottom + lineHeight - 1) / lineHeight,

-           itemMax = m_strings.GetCount();
+           itemMax = m_strings->GetCount();

 
     if ( itemFirst >= itemMax )
         return;
 
     if ( itemFirst >= itemMax )
         return;


@@ -673,13 +735,13 @@ void wxListBox::DoDrawRange(wxControlRenderer *renderer,
 bool wxListBox::SetFont(const wxFont& font)
 {
     if ( !wxControl::SetFont(font) )
 bool wxListBox::SetFont(const wxFont& font)
 {
     if ( !wxControl::SetFont(font) )

-        return FALSE;
+        return false;

 
     CalcItemsPerPage();
 
     RefreshAll();
 
 
     CalcItemsPerPage();
 
     RefreshAll();
 

-    return TRUE;
+    return true;

 }
 
 void wxListBox::CalcItemsPerPage()
 }
 
 void wxListBox::CalcItemsPerPage()


@@ -714,10 +776,10 @@ wxCoord wxListBox::GetMaxWidth() const
     {
         wxListBox *self = wxConstCast(this, wxListBox);
         wxCoord width;
     {
         wxListBox *self = wxConstCast(this, wxListBox);
         wxCoord width;

-        size_t count = m_strings.GetCount();
+        size_t count = m_strings->GetCount();

         for ( size_t n = 0; n < count; n++ )
         {
         for ( size_t 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;
             if ( width > m_maxWidth )
             {
                 self->m_maxWidth = width;


@@ -736,7 +798,7 @@ void wxListBox::OnSize(wxSizeEvent& event)
 
     // the scrollbars might [dis]appear
     m_updateScrollbarX =
 
     // the scrollbars might [dis]appear
     m_updateScrollbarX =

-    m_updateScrollbarY = TRUE;
+    m_updateScrollbarY = true;

 
     event.Skip();
 }
 
     event.Skip();
 }


@@ -763,7 +825,7 @@ void wxListBox::DoSetSize(int x, int y,
         height = ((height - hBorders + hLine - 1) / hLine)*hLine + hBorders;
     }
 
         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
 }
 
 wxSize wxListBox::DoGetBestClientSize() const


@@ -771,11 +833,11 @@ wxSize wxListBox::DoGetBestClientSize() const
     wxCoord width = 0,
             height = 0;
 
     wxCoord width = 0,
             height = 0;
 

-    size_t count = m_strings.GetCount();
+    size_t count = m_strings->GetCount();

     for ( size_t n = 0; n < count; n++ )
     {
         wxCoord w,h;
     for ( size_t 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;
 
         if ( w > width )
             width = w;


@@ -805,11 +867,6 @@ wxSize wxListBox::DoGetBestClientSize() const
 
 bool wxListBox::SendEvent(wxEventType type, int item)
 {
 
 bool wxListBox::SendEvent(wxEventType type, int item)
 {

-    // don't generate select events while the mouse is captured, we will only
-    // send them once it is released
-    if ( (type == wxEVT_COMMAND_LISTBOX_SELECTED) && (GetCapture() == this) )
-        return FALSE;
-

     wxCommandEvent event(type, m_windowId);
     event.SetEventObject(this);
 
     wxCommandEvent event(type, m_windowId);
     event.SetEventObject(this);
 


@@ -830,7 +887,7 @@ bool wxListBox::SendEvent(wxEventType type, int item)
         event.SetString(GetString(item));
     }
 
         event.SetString(GetString(item));
     }
 

-    event.m_commandInt = item;
+    event.SetInt(item);

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


@@ -846,7 +903,7 @@ void wxListBox::SetCurrentItem(int n)
 
         if ( m_current != -1 )
         {
 
         if ( m_current != -1 )
         {

-            m_currentChanged = TRUE;
+            m_currentChanged = true;

 
             RefreshItem(m_current);
         }
 
             RefreshItem(m_current);
         }


@@ -856,11 +913,11 @@ void wxListBox::SetCurrentItem(int n)
 
 bool wxListBox::FindItem(const wxString& prefix, bool strictlyAfter)
 {
 
 bool wxListBox::FindItem(const wxString& prefix, bool strictlyAfter)
 {

-    int count = GetCount();
-    if ( !count )
+    size_t count = GetCount();
+    if ( count==0 )

     {
         // empty listbox, we can't find anything in it
     {
         // 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
     }
 
     // start either from the current item or from the next one if strictlyAfter


@@ -870,7 +927,7 @@ bool wxListBox::FindItem(const wxString& prefix, bool strictlyAfter)
     {
         // the following line will set first correctly to 0 if there is no
         // selection (m_current == -1)
     {
         // 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
     {
     }
     else // start with the current
     {


@@ -880,15 +937,15 @@ bool wxListBox::FindItem(const wxString& prefix, bool strictlyAfter)
     int last = first == 0 ? count - 1 : first - 1;
 
     // if this is not true we'd never exit from the loop below!
     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, _T("logic error") );

 
     // precompute it outside the loop
     size_t len = prefix.length();
 
     // loop over all items in the listbox
 
     // 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);
 
         {
             SetCurrentItem(item);
 


@@ -901,12 +958,12 @@ bool wxListBox::FindItem(const wxString& prefix, bool strictlyAfter)
                     AnchorSelection(item);
             }
 
                     AnchorSelection(item);
             }
 

-            return TRUE;
+            return true;

         }
     }
 
     // nothing found
         }
     }
 
     // nothing found

-    return FALSE;
+    return false;

 }
 
 void wxListBox::EnsureVisible(int n)
 }
 
 void wxListBox::EnsureVisible(int n)


@@ -916,7 +973,7 @@ void wxListBox::EnsureVisible(int n)
         UpdateScrollbars();
 
         m_updateScrollbarX =
         UpdateScrollbars();
 
         m_updateScrollbarX =

-        m_updateScrollbarY = FALSE;
+        m_updateScrollbarY = false;

     }
 
     DoEnsureVisible(n);
     }
 
     DoEnsureVisible(n);


@@ -998,14 +1055,14 @@ void wxListBox::ExtendSelection(int itemTo)
         SetSelection(n);
     }
 
         SetSelection(n);
     }
 

-    int count = GetCount();
-    for ( ; n < count; n++ )
+    size_t count = GetCount();
+    for ( ; n < (int)count; n++ )

     {
         Deselect(n);
     }
 }
 
     {
         Deselect(n);
     }
 }
 

-void wxListBox::Select(bool sel, int item)
+void wxListBox::DoSelect(int item, bool sel)

 {
     if ( item != -1 )
     {
 {
     if ( item != -1 )
     {


@@ -1025,7 +1082,7 @@ void wxListBox::Select(bool sel, int item)
 
 void wxListBox::SelectAndNotify(int item)
 {
 
 void wxListBox::SelectAndNotify(int item)
 {

-    Select(TRUE, item);
+    DoSelect(item);

 
     SendEvent(wxEVT_COMMAND_LISTBOX_SELECTED);
 }
 
     SendEvent(wxEVT_COMMAND_LISTBOX_SELECTED);
 }


@@ -1044,7 +1101,7 @@ void wxListBox::Activate(int item)
 
     if ( item != -1 )
     {
 
     if ( item != -1 )
     {

-        Select(TRUE, item);
+        DoSelect(item);

 
         SendEvent(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED);
     }
 
         SendEvent(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED);
     }


@@ -1054,6 +1111,19 @@ void wxListBox::Activate(int item)
 // input handling
 // ----------------------------------------------------------------------------
 
 // input handling
 // ----------------------------------------------------------------------------
 

+/*
+   The numArg here is the listbox item index while the strArg is used
+   differently for the different actions:
+
+   a) for wxACTION_LISTBOX_FIND it has the natural meaning: this is the string
+      to find
+
+   b) for wxACTION_LISTBOX_SELECT and wxACTION_LISTBOX_EXTENDSEL it is used
+      to decide if the listbox should send the notification event (it is empty)
+      or not (it is not): this allows us to reuse the same action for when the
+      user is dragging the mouse when it has been released although in the
+      first case no notification is sent while in the second it is sent.
+ */

 bool wxListBox::PerformAction(const wxControlAction& action,
                               long numArg,
                               const wxString& strArg)
 bool wxListBox::PerformAction(const wxControlAction& action,
                               long numArg,
                               const wxString& strArg)


@@ -1061,28 +1131,36 @@ bool wxListBox::PerformAction(const wxControlAction& action,
     int item = (int)numArg;
 
     if ( action == wxACTION_LISTBOX_SETFOCUS )
     int item = (int)numArg;
 
     if ( action == wxACTION_LISTBOX_SETFOCUS )

+    {

         SetCurrentItem(item);
         SetCurrentItem(item);

+    }

     else if ( action == wxACTION_LISTBOX_ACTIVATE )
     else if ( action == wxACTION_LISTBOX_ACTIVATE )

+    {

         Activate(item);
         Activate(item);

+    }

     else if ( action == wxACTION_LISTBOX_TOGGLE )
     {
         if ( item == -1 )
             item = m_current;
 
         if ( IsSelected(item) )
     else if ( action == wxACTION_LISTBOX_TOGGLE )
     {
         if ( item == -1 )
             item = m_current;
 
         if ( IsSelected(item) )

-            Unselect(item);
+            DoUnselect(item);

         else
             SelectAndNotify(item);
     }
     else if ( action == wxACTION_LISTBOX_SELECT )
     {
         DeselectAll(item);
         else
             SelectAndNotify(item);
     }
     else if ( action == wxACTION_LISTBOX_SELECT )
     {
         DeselectAll(item);

-        SelectAndNotify(item);
+
+        if ( strArg.empty() )
+            SelectAndNotify(item);
+        else
+            DoSelect(item);

     }
     else if ( action == wxACTION_LISTBOX_SELECTADD )
     }
     else if ( action == wxACTION_LISTBOX_SELECTADD )

-        Select(TRUE, item);
+        DoSelect(item);

     else if ( action == wxACTION_LISTBOX_UNSELECT )
     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 )
     else if ( action == wxACTION_LISTBOX_MOVEDOWN )
         ChangeCurrent(1);
     else if ( action == wxACTION_LISTBOX_MOVEUP )


@@ -1109,7 +1187,7 @@ bool wxListBox::PerformAction(const wxControlAction& action,
     else
         return wxControl::PerformAction(action, numArg, strArg);
 
     else
         return wxControl::PerformAction(action, numArg, strArg);
 

-    return TRUE;
+    return true;

 }
 
 // ============================================================================
 }
 
 // ============================================================================


@@ -1123,7 +1201,7 @@ wxStdListboxInputHandler::wxStdListboxInputHandler(wxInputHandler *handler,
     m_btnCapture = 0;
     m_toggleOnPressAlways = toggleOnPressAlways;
     m_actionMouse = wxACTION_NONE;
     m_btnCapture = 0;
     m_toggleOnPressAlways = toggleOnPressAlways;
     m_actionMouse = wxACTION_NONE;

-    m_trackMouseOutside = TRUE;
+    m_trackMouseOutside = true;

 }
 
 int wxStdListboxInputHandler::HitTest(const wxListBox *lbox,
 }
 
 int wxStdListboxInputHandler::HitTest(const wxListBox *lbox,


@@ -1152,7 +1230,7 @@ int wxStdListboxInputHandler::FixItemIndex(const wxListBox *lbox,
         // mouse is above the first item
         item = 0;
     }
         // mouse is above the first item
         item = 0;
     }

-    else if ( item >= lbox->GetCount() )
+    else if ( (size_t)item >= lbox->GetCount() )

     {
         // mouse is below the last item
         item = lbox->GetCount() - 1;
     {
         // mouse is below the last item
         item = lbox->GetCount() - 1;


@@ -1163,7 +1241,7 @@ int wxStdListboxInputHandler::FixItemIndex(const wxListBox *lbox,
 
 bool wxStdListboxInputHandler::IsValidIndex(const wxListBox *lbox, int item)
 {
 
 bool wxStdListboxInputHandler::IsValidIndex(const wxListBox *lbox, int item)
 {

-    return item >= 0 && item < lbox->GetCount();
+    return item >= 0 && (size_t)item < lbox->GetCount();

 }
 
 wxControlAction
 }
 
 wxControlAction


@@ -1231,7 +1309,7 @@ wxStdListboxInputHandler::SetupCapture(wxListBox *lbox,
     }
 
     // by default we always do track it
     }
 
     // by default we always do track it

-    m_trackMouseOutside = TRUE;
+    m_trackMouseOutside = true;

 
     return action;
 }
 
     return action;
 }


@@ -1243,7 +1321,7 @@ bool wxStdListboxInputHandler::HandleKey(wxInputConsumer *consumer,
     // we're only interested in the key press events
     if ( pressed && !event.AltDown() )
     {
     // 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;
         int style = consumer->GetInputWindow()->GetWindowStyle();
 
         wxControlAction action;


@@ -1253,36 +1331,57 @@ bool wxStdListboxInputHandler::HandleKey(wxInputConsumer *consumer,
         switch ( keycode )
         {
             // movement
         switch ( keycode )
         {
             // movement

-            case WXK_UP:    action = wxACTION_LISTBOX_MOVEUP; break;
-            case WXK_DOWN:  action = wxACTION_LISTBOX_MOVEDOWN; break;
-            case WXK_PRIOR: action = wxACTION_LISTBOX_PAGEUP; break;
-            case WXK_NEXT:  action = wxACTION_LISTBOX_PAGEDOWN; break;
-            case WXK_HOME:  action = wxACTION_LISTBOX_START; break;
-            case WXK_END:   action = wxACTION_LISTBOX_END; break;
+            case WXK_UP:
+                action = wxACTION_LISTBOX_MOVEUP;
+                break;
+
+            case WXK_DOWN:
+                action = wxACTION_LISTBOX_MOVEDOWN;
+                break;
+
+            case WXK_PAGEUP:
+
+            case WXK_PRIOR:
+                action = wxACTION_LISTBOX_PAGEUP;
+                break;
+
+            case WXK_PAGEDOWN:
+
+            case WXK_NEXT:
+                action = wxACTION_LISTBOX_PAGEDOWN;
+                break;
+
+            case WXK_HOME:
+                action = wxACTION_LISTBOX_START;
+                break;
+
+            case WXK_END:
+                action = wxACTION_LISTBOX_END;
+                break;

 
             // selection
             case WXK_SPACE:
                 if ( style & wxLB_MULTIPLE )
                 {
                     action = wxACTION_LISTBOX_TOGGLE;
 
             // selection
             case WXK_SPACE:
                 if ( style & wxLB_MULTIPLE )
                 {
                     action = wxACTION_LISTBOX_TOGGLE;

-                    isMoveCmd = FALSE;
+                    isMoveCmd = false;

                 }
                 break;
 
             case WXK_RETURN:
                 action = wxACTION_LISTBOX_ACTIVATE;
                 }
                 break;
 
             case WXK_RETURN:
                 action = wxACTION_LISTBOX_ACTIVATE;

-                isMoveCmd = FALSE;
+                isMoveCmd = false;

                 break;
 
             default:
                 break;
 
             default:

-                if ( (keycode < 255) && wxIsalnum(keycode) )
+                if ( (keycode < 255) && wxIsalnum((wxChar)keycode) )

                 {
                     action = wxACTION_LISTBOX_FIND;
                     strArg = (wxChar)keycode;
                 }
         }
 
                 {
                     action = wxACTION_LISTBOX_FIND;
                     strArg = (wxChar)keycode;
                 }
         }
 

-        if ( !!action )
+        if ( !action.IsEmpty() )

         {
             consumer->PerformAction(action, -1, strArg);
 
         {
             consumer->PerformAction(action, -1, strArg);
 


@@ -1307,7 +1406,7 @@ bool wxStdListboxInputHandler::HandleKey(wxInputConsumer *consumer,
                 //else: nothing to do for multiple selection listboxes
             }
 
                 //else: nothing to do for multiple selection listboxes
             }
 

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 


@@ -1340,7 +1439,6 @@ bool wxStdListboxInputHandler::HandleMouse(wxInputConsumer *consumer,
             winCapture->ReleaseMouse();
             m_btnCapture = 0;
 
             winCapture->ReleaseMouse();
             m_btnCapture = 0;
 

-            // generate the last event to triiger sending the selection event

             action = m_actionMouse;
         }
         //else: the mouse wasn't presed over the listbox, only released here
             action = m_actionMouse;
         }
         //else: the mouse wasn't presed over the listbox, only released here


@@ -1350,11 +1448,11 @@ bool wxStdListboxInputHandler::HandleMouse(wxInputConsumer *consumer,
         action = wxACTION_LISTBOX_ACTIVATE;
     }
 
         action = wxACTION_LISTBOX_ACTIVATE;
     }
 

-    if ( !!action )
+    if ( !action.IsEmpty() )

     {
         lbox->PerformAction(action, item);
 
     {
         lbox->PerformAction(action, item);
 

-        return TRUE;
+        return true;

     }
 
     return wxStdInputHandler::HandleMouse(consumer, event);
     }
 
     return wxStdInputHandler::HandleMouse(consumer, event);


@@ -1374,7 +1472,7 @@ bool wxStdListboxInputHandler::HandleMouseMove(wxInputConsumer *consumer,
             // 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 )
             // 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);
         }
 
         int item = HitTest(lbox, event);


@@ -1385,12 +1483,14 @@ bool wxStdListboxInputHandler::HandleMouseMove(wxInputConsumer *consumer,
             // events
             SetupCapture(lbox, event, item);
 
             // events
             SetupCapture(lbox, event, item);
 

-            m_trackMouseOutside = FALSE;
+            m_trackMouseOutside = false;

         }
 
         if ( IsValidIndex(lbox, item) )
         {
         }
 
         if ( IsValidIndex(lbox, item) )
         {

-            lbox->PerformAction(m_actionMouse, 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"));

         }
         // else: don't pass invalid index to the listbox
     }
         }
         // else: don't pass invalid index to the listbox
     }