Fixed a long-standing issue where wxSlider controls with a hardcoded size would mispl...

[wxWidgets.git] / src / msw / choice.cpp

diff --git a/src/msw/choice.cpp b/src/msw/choice.cpp
index 3f349227d3d863b8ed88c5aed305ab92b5d1120c..b7feab4c5bc490b52e47349a177a2a6abfbf6aac 100644 (file)
--- a/src/msw/choice.cpp
+++ b/src/msw/choice.cpp
@@ -2,351 +2,645 @@
 // Name:        choice.cpp
 // Purpose:     wxChoice
 // Author:      Julian Smart
 // Name:        choice.cpp
 // Purpose:     wxChoice
 // Author:      Julian Smart

-// Modified by:
+// Modified by: Vadim Zeitlin to derive from wxChoiceBase

 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Created:     04/01/98
 // RCS-ID:      $Id$

-// Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:     wxWindows license
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef __GNUG__
-#pragma implementation "choice.h"
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
+    #pragma implementation "choice.h"

 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #endif
 

+#if wxUSE_CHOICE && !(defined(__SMARTPHONE__) && defined(__WXWINCE__))
+

 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP

-#include "wx/choice.h"
-#include "wx/utils.h"
+    #include "wx/choice.h"
+    #include "wx/utils.h"
+    #include "wx/log.h"
+    #include "wx/brush.h"
+    #include "wx/settings.h"

 #endif
 
 #include "wx/msw/private.h"
 
 #endif
 
 #include "wx/msw/private.h"
 

-#if !USE_SHARED_LIBRARY
+#if wxUSE_EXTENDED_RTTI
+WX_DEFINE_FLAGS( wxChoiceStyle )
+
+wxBEGIN_FLAGS( wxChoiceStyle )
+    // new style border flags, we put them first to
+    // use them for streaming out
+    wxFLAGS_MEMBER(wxBORDER_SIMPLE)
+    wxFLAGS_MEMBER(wxBORDER_SUNKEN)
+    wxFLAGS_MEMBER(wxBORDER_DOUBLE)
+    wxFLAGS_MEMBER(wxBORDER_RAISED)
+    wxFLAGS_MEMBER(wxBORDER_STATIC)
+    wxFLAGS_MEMBER(wxBORDER_NONE)
+
+    // old style border flags
+    wxFLAGS_MEMBER(wxSIMPLE_BORDER)
+    wxFLAGS_MEMBER(wxSUNKEN_BORDER)
+    wxFLAGS_MEMBER(wxDOUBLE_BORDER)
+    wxFLAGS_MEMBER(wxRAISED_BORDER)
+    wxFLAGS_MEMBER(wxSTATIC_BORDER)
+    wxFLAGS_MEMBER(wxBORDER)
+
+    // standard window styles
+    wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
+    wxFLAGS_MEMBER(wxCLIP_CHILDREN)
+    wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
+    wxFLAGS_MEMBER(wxWANTS_CHARS)
+    wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
+    wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
+    wxFLAGS_MEMBER(wxVSCROLL)
+    wxFLAGS_MEMBER(wxHSCROLL)
+
+wxEND_FLAGS( wxChoiceStyle )
+
+IMPLEMENT_DYNAMIC_CLASS_XTI(wxChoice, wxControl,"wx/choice.h")
+
+wxBEGIN_PROPERTIES_TABLE(wxChoice)
+    wxEVENT_PROPERTY( Select , wxEVT_COMMAND_CHOICE_SELECTED , wxCommandEvent )
+
+    wxPROPERTY( Font , wxFont , SetFont , GetFont  , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
+    wxPROPERTY_COLLECTION( Choices , wxArrayString , wxString , AppendString , GetStrings , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
+    wxPROPERTY( Selection ,int, SetSelection, GetSelection, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
+    wxPROPERTY_FLAGS( WindowStyle , wxChoiceStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
+wxEND_PROPERTIES_TABLE()
+
+wxBEGIN_HANDLERS_TABLE(wxChoice)
+wxEND_HANDLERS_TABLE()
+
+wxCONSTRUCTOR_4( wxChoice , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size )
+#else

 IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControl)
 #endif
 IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControl)
 #endif

+/*
+    TODO PROPERTIES
+        selection (long)
+        content (list)
+            item
+*/

 
 

-bool wxChoice::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// creation
+// ----------------------------------------------------------------------------
+
+bool wxChoice::Create(wxWindow *parent,
+                      wxWindowID id,
+                      const wxPoint& pos,
+                      const wxSize& size,
+                      int n, const wxString choices[],
+                      long style,
+                      const wxValidator& validator,
+                      const wxString& name)

 {
 {

-  if (param == CBN_SELCHANGE)
-  {
-    wxCommandEvent event(wxEVT_COMMAND_CHOICE_SELECTED, m_windowId);
-    event.SetInt(GetSelection());
-    event.SetEventObject(this);
-    event.SetString(GetStringSelection());
-    ProcessCommand(event);
-
-    return TRUE;
-  }
-  else
-      return FALSE;
+    // Experience shows that wxChoice vs. wxComboBox distinction confuses
+    // quite a few people - try to help them
+    wxASSERT_MSG( !(style & wxCB_DROPDOWN) &&
+                  !(style & wxCB_READONLY) &&
+                  !(style & wxCB_SIMPLE),
+                  _T("this style flag is ignored by wxChoice, you ")
+                  _T("probably want to use a wxComboBox") );
+
+    return CreateAndInit(parent, id, pos, size, n, choices, style,
+                         validator, name);

 }
 
 }
 

-bool wxChoice::Create(wxWindow *parent, wxWindowID id,
-           const wxPoint& pos,
-           const wxSize& size,
-       int n, const wxString choices[],
-       long style,
-           const wxValidator& validator,
-           const wxString& name)
+bool wxChoice::CreateAndInit(wxWindow *parent,
+                             wxWindowID id,
+                             const wxPoint& pos,
+                             const wxSize& size,
+                             int n, const wxString choices[],
+                             long style,
+                             const wxValidator& validator,
+                             const wxString& name)

 {
 {

-  SetName(name);
-  SetValidator(validator);
-  if (parent) parent->AddChild(this);
-  SetBackgroundColour(parent->GetBackgroundColour()) ;
-  SetForegroundColour(parent->GetForegroundColour()) ;
-  m_noStrings = 0;
+    // initialize wxControl
+    if ( !CreateControl(parent, id, pos, size, style, validator, name) )
+        return false;

 
 

-  m_windowStyle = style;
+    // now create the real HWND
+    if ( !MSWCreateControl(wxT("COMBOBOX"), _T(""), pos, size) )
+        return false;

 
 

-  if ( id == -1 )
-    m_windowId = (int)NewControlId();
-  else
-  m_windowId = id;

 
 

-  int x = pos.x;
-  int y = pos.y;
-  int width = size.x;
-  int height = size.y;
+    // choice/combobox normally has "white" (depends on colour scheme, of
+    // course) background rather than inheriting the parent's background
+    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));

 
 

-  long msStyle = WS_CHILD | CBS_DROPDOWNLIST | WS_HSCROLL | WS_VSCROLL
-                   | WS_TABSTOP | WS_VISIBLE;
-  if (m_windowStyle & wxCB_SORT)
-    msStyle |= CBS_SORT;
+    // initialize the controls contents
+    for ( int i = 0; i < n; i++ )
+    {
+        Append(choices[i]);
+    }

 
 

-  bool want3D;
-  WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ;
+    // and now we may finally size the control properly (if needed)
+    SetBestSize(size);

 
 

-  // Even with extended styles, need to combine with WS_BORDER
-  // for them to look right.
-  if ( want3D || wxStyleHasBorder(m_windowStyle) )
-    msStyle |= WS_BORDER;
+    return true;
+}

 
 

-  m_hWnd = (WXHWND)::CreateWindowEx(exStyle, _T("COMBOBOX"), NULL,
-                   msStyle,
-                   0, 0, 0, 0, (HWND) parent->GetHWND(), (HMENU)m_windowId,
-                   wxGetInstance(), NULL);
+bool wxChoice::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);
+}

 
 

-  wxCHECK_MSG( m_hWnd, FALSE, _T("Failed to create combobox") );
+bool wxChoice::MSWShouldPreProcessMessage(WXMSG *pMsg)
+{
+    MSG *msg = (MSG *) pMsg;

 
 

-/*
-#if wxUSE_CTL3D
-  if (want3D)
-  {
-    m_useCtl3D = TRUE;
-    Ctl3dSubclassCtl(wx_combo); // Does CTL3D affect the combobox? I think not.
-  }
-#endif
-*/
+    // if the dropdown list is visible, don't preprocess certain keys
+    if ( msg->message == WM_KEYDOWN
+        && (msg->wParam == VK_ESCAPE || msg->wParam == VK_RETURN) )
+    {
+        if (::SendMessage(GetHwndOf(this), CB_GETDROPPEDSTATE, 0, 0))
+        {
+            return false;
+        }
+    }

 
 

-  // Subclass again for purposes of dialog editing mode
-  SubclassWin(m_hWnd);
+    return wxControl::MSWShouldPreProcessMessage(pMsg);
+}

 
 

-  SetFont(parent->GetFont());
+WXDWORD wxChoice::MSWGetStyle(long style, WXDWORD *exstyle) const
+{
+    // we never have an external border
+    WXDWORD msStyle = wxControl::MSWGetStyle
+                      (
+                        (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
+                      );
+
+    // WS_CLIPSIBLINGS is useful with wxChoice and doesn't seem to result in
+    // any problems
+    msStyle |= WS_CLIPSIBLINGS;
+
+    // wxChoice-specific styles
+    msStyle |= CBS_DROPDOWNLIST | WS_HSCROLL | WS_VSCROLL;
+    if ( style & wxCB_SORT )
+        msStyle |= CBS_SORT;
+
+    return msStyle;
+}

 
 

-  int i;
-  for (i = 0; i < n; i++)
-  {
-    Append(choices[i]);
-  }
-  SetSelection(n);
+wxChoice::~wxChoice()
+{
+    Free();
+}
+
+// ----------------------------------------------------------------------------
+// adding/deleting items to/from the list
+// ----------------------------------------------------------------------------

 
 

-  SetSize(x, y, width, height);
+int wxChoice::DoAppend(const wxString& item)
+{
+    int n = (int)SendMessage(GetHwnd(), CB_ADDSTRING, 0, (LPARAM)item.c_str());
+    if ( n == CB_ERR )
+    {
+        wxLogLastError(wxT("SendMessage(CB_ADDSTRING)"));
+    }
+    else // ok
+    {
+        // we need to refresh our size in order to have enough space for the
+        // newly added items
+        if ( !IsFrozen() )
+            UpdateVisibleHeight();
+    }

 
 

-  return TRUE;
+    return n;

 }
 
 }
 

-void wxChoice::Append(const wxString& item)
+int wxChoice::DoInsert(const wxString& item, int pos)

 {
 {

-  SendMessage((HWND) GetHWND(), CB_ADDSTRING, 0, (LONG)(const wxChar *)item);
+    wxCHECK_MSG(!(GetWindowStyle() & wxCB_SORT), -1, wxT("can't insert into sorted list"));
+    wxCHECK_MSG((pos>=0) && (pos<=GetCount()), -1, wxT("invalid index"));

 
 

-  m_noStrings ++;
+    int n = (int)SendMessage(GetHwnd(), CB_INSERTSTRING, pos, (LPARAM)item.c_str());
+    if ( n == CB_ERR )
+    {
+        wxLogLastError(wxT("SendMessage(CB_INSERTSTRING)"));
+    }
+    else // ok
+    {
+        if ( !IsFrozen() )
+            UpdateVisibleHeight();
+    }
+
+    return n;

 }
 
 void wxChoice::Delete(int n)
 {
 }
 
 void wxChoice::Delete(int n)
 {

-  m_noStrings = (int)SendMessage((HWND) GetHWND(), CB_DELETESTRING, n, 0);
+    wxCHECK_RET( n < GetCount(), wxT("invalid item index in wxChoice::Delete") );
+
+    if ( HasClientObjectData() )
+    {
+        delete GetClientObject(n);
+    }
+
+    SendMessage(GetHwnd(), CB_DELETESTRING, n, 0);
+
+    if ( !IsFrozen() )
+        UpdateVisibleHeight();

 }
 
 }
 

-void wxChoice::Clear(void)
+void wxChoice::Clear()

 {
 {

-  SendMessage((HWND) GetHWND(), CB_RESETCONTENT, 0, 0);
+    Free();

 
 

-  m_noStrings = 0;
+    SendMessage(GetHwnd(), CB_RESETCONTENT, 0, 0);
+
+    if ( !IsFrozen() )
+        UpdateVisibleHeight();

 }
 
 }
 

+void wxChoice::Free()
+{
+    if ( HasClientObjectData() )
+    {
+        size_t count = GetCount();
+        for ( size_t n = 0; n < count; n++ )
+        {
+            delete GetClientObject(n);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+// selection
+// ----------------------------------------------------------------------------

 
 

-int wxChoice::GetSelection(void) const
+int wxChoice::GetSelection() const

 {
 {

-  return (int)SendMessage((HWND) GetHWND(), CB_GETCURSEL, 0, 0);
+    return (int)SendMessage(GetHwnd(), CB_GETCURSEL, 0, 0);

 }
 
 void wxChoice::SetSelection(int n)
 {
 }
 
 void wxChoice::SetSelection(int n)
 {

-  SendMessage((HWND) GetHWND(), CB_SETCURSEL, n, 0);
+    SendMessage(GetHwnd(), CB_SETCURSEL, n, 0);
+}
+
+// ----------------------------------------------------------------------------
+// string list functions
+// ----------------------------------------------------------------------------
+
+int wxChoice::GetCount() const
+{
+    return (int)SendMessage(GetHwnd(), CB_GETCOUNT, 0, 0);

 }
 
 int wxChoice::FindString(const wxString& s) const
 {
 #if defined(__WATCOMC__) && defined(__WIN386__)
 }
 
 int wxChoice::FindString(const wxString& s) const
 {
 #if defined(__WATCOMC__) && defined(__WIN386__)

-  // For some reason, Watcom in WIN386 mode crashes in the CB_FINDSTRINGEXACT message.
-  // Do it the long way instead.
-  char buf[512];
-  for (int i = 0; i < Number(); i++)
-  {
-    int len = (int)SendMessage((HWND) GetHWND(), CB_GETLBTEXT, i, (LPARAM)(LPSTR)buf);
-    buf[len] = 0;
-    if (strcmp(buf, (const char *)s) == 0)
-      return i;
-  }
-  return -1;
-#else
- int pos = (int)SendMessage((HWND) GetHWND(), CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPSTR)(const wxChar *)s);
- if (pos == LB_ERR)
-   return -1;
- else
-   return pos;
-#endif
+    // For some reason, Watcom in WIN386 mode crashes in the CB_FINDSTRINGEXACT message.
+    // wxChoice::Do it the long way instead.
+    int count = GetCount();
+    for ( int i = 0; i < count; i++ )
+    {
+        // as CB_FINDSTRINGEXACT is case insensitive, be case insensitive too
+        if ( GetString(i).IsSameAs(s, false) )
+            return i;
+    }
+
+    return wxNOT_FOUND;
+#else // !Watcom
+   //TODO:  Evidently some MSW versions (all?) don't like empty strings
+   //passed to SendMessage, so we have to do it ourselves in that case
+   if ( s.size() == 0 )
+   {
+     int count = GetCount();
+     for ( int i = 0; i < count; i++ )
+     {
+       if ( GetString(i).size() == 0 )
+           return i;
+     }
+
+     return wxNOT_FOUND;
+   }
+   else
+   {
+     int pos = (int)SendMessage(GetHwnd(), CB_FINDSTRINGEXACT,
+                                (WPARAM)-1, (LPARAM)s.c_str());
+ 
+     return pos == LB_ERR ? wxNOT_FOUND : pos;
+   }
+#endif // Watcom/!Watcom
+}
+
+void wxChoice::SetString(int n, const wxString& s)
+{
+    wxCHECK_RET( n >= 0 && n < GetCount(),
+                 wxT("invalid item index in wxChoice::SetString") );
+
+    // we have to delete and add back the string as there is no way to change a
+    // string in place
+
+    // we need to preserve the client data
+    void *data;
+    if ( m_clientDataItemsType != wxClientData_None )
+    {
+        data = DoGetItemClientData(n);
+    }
+    else // no client data
+    {
+        data = NULL;
+    }
+
+    ::SendMessage(GetHwnd(), CB_DELETESTRING, n, 0);
+    ::SendMessage(GetHwnd(), CB_INSERTSTRING, n, (LPARAM)s.c_str() );
+
+    if ( data )
+    {
+        DoSetItemClientData(n, data);
+    }
+    //else: it's already NULL by default

 }
 
 wxString wxChoice::GetString(int n) const
 {
 }
 
 wxString wxChoice::GetString(int n) const
 {

-  int len = (int)SendMessage((HWND) GetHWND(), CB_GETLBTEXT, n, (long)wxBuffer);
-  wxBuffer[len] = 0;
-  return wxString(wxBuffer);
+    int len = (int)::SendMessage(GetHwnd(), CB_GETLBTEXTLEN, n, 0);
+
+    wxString str;
+    if ( len != CB_ERR && len > 0 )
+    {
+        if ( ::SendMessage
+               (
+                GetHwnd(),
+                CB_GETLBTEXT,
+                n,
+                (LPARAM)(wxChar *)wxStringBuffer(str, len)
+               ) == CB_ERR )
+        {
+            wxLogLastError(wxT("SendMessage(CB_GETLBTEXT)"));
+        }
+    }
+
+    return str;

 }
 
 }
 

-void wxChoice::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+// ----------------------------------------------------------------------------
+// client data
+// ----------------------------------------------------------------------------
+
+void wxChoice::DoSetItemClientData( int n, void* clientData )

 {
 {

-  int currentX, currentY;
-  GetPosition(&currentX, &currentY);
-
-  int x1 = x;
-  int y1 = y;
-  int w1 = width;
-  int h1 = height;
-
-  if (x == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
-    x1 = currentX;
-  if (y == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
-    y1 = currentY;
-
-  AdjustForParentClientOrigin(x1, y1, sizeFlags);
-
-  // If we're prepared to use the existing size, then...
-  if (width == -1 && height == -1 && ((sizeFlags & wxSIZE_AUTO) != wxSIZE_AUTO))
-  {
-    GetSize(&w1, &h1);
-  }
-
-  int cx; // button font dimensions
-  int cy;
-  wxGetCharSize(GetHWND(), &cx, &cy, & this->GetFont());
-
-  int control_width, control_height;
-
-  // Ignore height parameter because height doesn't
-  // mean 'initially displayed' height, it refers to the
-  // drop-down menu as well. The wxWindows interpretation
-  // is different; also, getting the size returns the
-  // _displayed_ size (NOT the drop down menu size)
-  // so setting-getting-setting size would not work.
-  h1 = -1;
-
-  // Deal with default size (using -1 values)
-  if (width <= 0)
-  {
-    // Find the longest string
-    if (m_noStrings == 0)
+    if ( ::SendMessage(GetHwnd(), CB_SETITEMDATA,
+                       n, (LPARAM)clientData) == CB_ERR )

     {
     {

-      control_width = 100;
+        wxLogLastError(wxT("CB_SETITEMDATA"));

     }
     }

-    else
+}
+
+void* wxChoice::DoGetItemClientData( int n ) const
+{
+    LPARAM rc = SendMessage(GetHwnd(), CB_GETITEMDATA, n, 0);
+    if ( rc == CB_ERR )

     {
     {

-      int len, ht;
-      int longest = 0;
-      int i;
-      for (i = 0; i < m_noStrings; i++)
-      {
-        wxString str(GetString(i));
-        GetTextExtent(str, &len, &ht, NULL, NULL, & this->GetFont());
-        if ( len > longest)
-            longest = len;
-      }
-
-      control_width = longest + cx*5;
+        wxLogLastError(wxT("CB_GETITEMDATA"));
+
+        // unfortunately, there is no way to return an error code to the user
+        rc = (LPARAM) NULL;

     }
     }

-  }
-  else
-  {
-    // If non-default width...
-    control_width = w1;
-  }
-
-
-  // Choice drop-down list depends on number of items (limited to 10)
-  if (h1 <= 0)
-  {
-    if (m_noStrings == 0)
-        h1 = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy)*10;
-    else
-        h1 = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy)*(wxMin(10, m_noStrings) + 1);
-  }

 
 

-  control_height = h1;
+    return (void *)rc;
+}

 
 

-  // Calculations may have made text size too small
-  if (control_height <= 0)
-    control_height = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
+void wxChoice::DoSetItemClientObject( int n, wxClientData* clientData )
+{
+    DoSetItemClientData(n, clientData);
+}
+
+wxClientData* wxChoice::DoGetItemClientObject( int n ) const
+{
+    return (wxClientData *)DoGetItemClientData(n);
+}

 
 

-  if (control_width <= 0)
-    control_width = 100;
+// ----------------------------------------------------------------------------
+// wxMSW specific helpers
+// ----------------------------------------------------------------------------
+
+void wxChoice::UpdateVisibleHeight()
+{
+    // be careful to not change the width here
+    DoSetSize(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord, GetSize().y, wxSIZE_USE_EXISTING);
+}

 
 

-  MoveWindow((HWND)GetHWND(), x1, y1,
-             control_width, control_height, TRUE);
+void wxChoice::DoMoveWindow(int x, int y, int width, int height)
+{
+    // here is why this is necessary: if the width is negative, the combobox
+    // window proc makes the window of the size width*height instead of
+    // interpreting height in the usual manner (meaning the height of the drop
+    // down list - usually the height specified in the call to MoveWindow()
+    // will not change the height of combo box per se)
+    //
+    // this behaviour is not documented anywhere, but this is just how it is
+    // here (NT 4.4) and, anyhow, the check shouldn't hurt - however without
+    // the check, constraints/sizers using combos may break the height
+    // constraint will have not at all the same value as expected
+    if ( width < 0 )
+        return;
+
+    wxControl::DoMoveWindow(x, y, width, height);

 }
 
 }
 

-WXHBRUSH wxChoice::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
-      WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
+void wxChoice::DoGetSize(int *w, int *h) const

 {
 {

-  return 0;
+    // this is weird: sometimes, the height returned by Windows is clearly the
+    // total height of the control including the drop down list -- but only
+    // sometimes, and normally it isn't... I have no idea about what to do with
+    // this
+    wxControl::DoGetSize(w, h);

 }
 
 }
 

-long wxChoice::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+void wxChoice::DoSetSize(int x, int y,
+                         int width, int height,
+                         int sizeFlags)

 {
 {

-    switch (nMsg)
+    int heightOrig = height;
+
+    // the height which we must pass to Windows should be the total height of
+    // the control including the drop down list while the height given to us
+    // is, of course, just the height of the permanently visible part of it
+    if ( height != wxDefaultCoord )

     {
     {

-/*
-      case WM_GETDLGCODE:
-      {
-        if (GetWindowStyleFlag() & wxPROCESS_ENTER)
-          return DLGC_WANTALLKEYS;
-        break;
-      }
-*/
-/*
-      case WM_CHAR: // Always an ASCII character
-      {
-        if (wParam == VK_RETURN)
+        // don't make the drop down list too tall, arbitrarily limit it to 40
+        // items max and also don't leave it empty
+        size_t nItems = GetCount();
+        if ( !nItems )
+            nItems = 9;
+        else if ( nItems > 24 )
+            nItems = 24;
+
+        // add space for the drop down list
+        const int hItem = SendMessage(GetHwnd(), CB_GETITEMHEIGHT, 0, 0);
+        height += hItem*(nItems + 1);
+    }
+    else
+    {
+        // We cannot pass wxDefaultCoord as height to wxControl. wxControl uses
+        // wxGetWindowRect() to determine the current height of the combobox, 
+        // and then again sets the combobox's height to that value. Unfortunately, 
+        // wxGetWindowRect doesn't include the dropdown list's height (at least 
+        // on Win2K), so this would result in a combobox with dropdown height of 
+        // 1 pixel. We have to determine the default height ourselves and call
+        // wxControl with that value instead.
+        int w, h;
+        RECT r;
+        DoGetSize(&w, &h);
+        if (::SendMessage(GetHwnd(), CB_GETDROPPEDCONTROLRECT, 0, (LPARAM) &r) != 0)

         {
         {

-          wxCommandEvent event(wxEVENT_TYPE_TEXT_ENTER_COMMAND);
-          event.commandString = ((wxTextCtrl *)item)->GetValue();
-          event.eventObject = item;
-          item->ProcessCommand(event);
-          return FALSE;
+            height = h + r.bottom - r.top;       

         }
         }

-        break;
-      }
-*/
-      case WM_LBUTTONUP:
-      {
-        int x = (int)LOWORD(lParam);
-        int y = (int)HIWORD(lParam);
-
-       // Ok, this is truly weird, but if a panel with a wxChoice loses the
-       // focus, then you get a *fake* WM_LBUTTONUP message
-       // with x = 65535 and y = 65535.
-       // Filter out this nonsense.
-       if (x == 65535 && y == 65535)
-         return 0;
-       break;
-      }

     }
 
     }
 

-  return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
+    wxControl::DoSetSize(x, y, width, height, sizeFlags);
+
+    // I'm commenting this out since the code appears to make choices
+    // and comboxes too high when they have associated sizers. I'm sure this
+    // is not the end of the story, which is why I'm leaving it #if'ed out for
+    // now. JACS.
+#if 0
+    // if the height specified for the visible part of the control is
+    // different from the current one, we need to change it separately
+    // as it is not affected by normal WM_SETSIZE
+    if ( height != wxDefaultCoord )
+    {
+        const int delta = heightOrig - GetSize().y;
+        if ( delta )
+        {
+            int h = ::SendMessage(GetHwnd(), CB_GETITEMHEIGHT, (WPARAM)-1, 0);
+            SendMessage(GetHwnd(), CB_SETITEMHEIGHT, (WPARAM)-1, h + delta);
+        }
+    }
+#else
+    wxUnusedVar(heightOrig);
+#endif

 }
 
 }
 

-wxString wxChoice::GetStringSelection (void) const
+wxSize wxChoice::DoGetBestSize() const

 {
 {

-  int sel = GetSelection ();
-  if (sel > -1)
-    return wxString(this->GetString (sel));
-  else
-    return wxString(_T(""));
+    // find the widest string
+    int wChoice = 0;
+    const size_t nItems = GetCount();
+    for ( size_t i = 0; i < nItems; i++ )
+    {
+        int wLine;
+        GetTextExtent(GetString(i), &wLine, NULL);
+        if ( wLine > wChoice )
+            wChoice = wLine;
+    }
+
+    // give it some reasonable default value if there are no strings in the
+    // list
+    if ( wChoice == 0 )
+        wChoice = 100;
+
+    // the combobox should be slightly larger than the widest string
+    wChoice += 5*GetCharWidth();
+
+    return wxSize(wChoice, EDIT_HEIGHT_FROM_CHAR_HEIGHT(GetCharHeight()));

 }
 
 }
 

-bool wxChoice::SetStringSelection (const wxString& s)
+WXLRESULT wxChoice::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)

 {
 {

-  int sel = FindString (s);
-  if (sel > -1)
+    switch ( nMsg )

     {
     {

-      SetSelection (sel);
-      return TRUE;
+        case WM_LBUTTONUP:
+            {
+                int x = (int)LOWORD(lParam);
+                int y = (int)HIWORD(lParam);
+
+                // Ok, this is truly weird, but if a panel with a wxChoice
+                // loses the focus, then you get a *fake* WM_LBUTTONUP message
+                // with x = 65535 and y = 65535. Filter out this nonsense.
+                //
+                // VZ: I'd like to know how to reproduce this please...
+                if ( x == 65535 && y == 65535 )
+                    return 0;
+            }
+            break;
+
+            // we have to handle both: one for the normal case and the other
+            // for readonly
+        case WM_CTLCOLOREDIT:
+        case WM_CTLCOLORLISTBOX:
+        case WM_CTLCOLORSTATIC:
+            {
+                WXHDC hdc;
+                WXHWND hwnd;
+                UnpackCtlColor(wParam, lParam, &hdc, &hwnd);
+
+                WXHBRUSH hbr = MSWControlColor((WXHDC)hdc);
+                if ( hbr )
+                    return (WXLRESULT)hbr;
+                //else: fall through to default window proc
+            }

     }
     }

-  else
-    return FALSE;
+
+    return wxWindow::MSWWindowProc(nMsg, wParam, lParam);

 }
 
 }
 

-void wxChoice::Command(wxCommandEvent & event)
+bool wxChoice::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))

 {
 {

-  SetSelection (event.GetInt());
-  ProcessCommand (event);
+    if ( param != CBN_SELCHANGE)
+    {
+        // "selection changed" is the only event we're after
+        return false;
+    }
+
+    int n = GetSelection();
+    if (n > -1)
+    {
+        wxCommandEvent event(wxEVT_COMMAND_CHOICE_SELECTED, m_windowId);
+        event.SetInt(n);
+        event.SetEventObject(this);
+        event.SetString(GetStringSelection());
+        if ( HasClientObjectData() )
+            event.SetClientObject( GetClientObject(n) );
+        else if ( HasClientUntypedData() )
+            event.SetClientData( GetClientData(n) );
+        ProcessCommand(event);
+    }
+
+    return true;

 }
 
 }
 

+WXHBRUSH wxChoice::MSWControlColor(WXHDC hDC)
+{
+    if ( !IsEnabled() )
+        return MSWControlColorDisabled(hDC);
+
+    return wxChoiceBase::MSWControlColorSolid(hDC);
+}

 
 

+#endif // wxUSE_CHOICE && !(__SMARTPHONE__ && __WXWINCE__)