Compilation fir for VC6 after r73124.

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

diff --git a/src/msw/combobox.cpp b/src/msw/combobox.cpp
index 6b3ec7f57fb63ccd237e604e387aee624ee458c8..b823cc589942d478e1a1ca3ec6d166b0d15e4b69 100644 (file)
--- a/src/msw/combobox.cpp
+++ b/src/msw/combobox.cpp
@@ -29,6 +29,7 @@
 #include "wx/combobox.h"
 
 #ifndef WX_PRECOMP
 #include "wx/combobox.h"
 
 #ifndef WX_PRECOMP

+    #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"

     #include "wx/settings.h"
     #include "wx/log.h"
     // for wxEVT_COMMAND_TEXT_ENTER
     #include "wx/settings.h"
     #include "wx/log.h"
     // for wxEVT_COMMAND_TEXT_ENTER


@@ -38,10 +39,12 @@
 #endif
 
 #include "wx/clipbrd.h"
 #endif
 
 #include "wx/clipbrd.h"

+#include "wx/wupdlock.h"

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

-// include <commctrl.h> "properly"
-#include "wx/msw/wrapcctl.h"
+#if wxUSE_UXTHEME
+    #include "wx/msw/uxtheme.h"
+#endif

 
 #if wxUSE_TOOLTIPS
     #include "wx/tooltip.h"
 
 #if wxUSE_TOOLTIPS
     #include "wx/tooltip.h"


@@ -51,69 +54,6 @@
 // wxWin macros
 // ----------------------------------------------------------------------------
 
 // wxWin macros
 // ----------------------------------------------------------------------------
 

-#if wxUSE_EXTENDED_RTTI
-WX_DEFINE_FLAGS( wxComboBoxStyle )
-
-wxBEGIN_FLAGS( wxComboBoxStyle )
-    // 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)
-
-    wxFLAGS_MEMBER(wxCB_SIMPLE)
-    wxFLAGS_MEMBER(wxCB_SORT)
-    wxFLAGS_MEMBER(wxCB_READONLY)
-    wxFLAGS_MEMBER(wxCB_DROPDOWN)
-
-wxEND_FLAGS( wxComboBoxStyle )
-
-IMPLEMENT_DYNAMIC_CLASS_XTI(wxComboBox, wxControl,"wx/combobox.h")
-
-wxBEGIN_PROPERTIES_TABLE(wxComboBox)
-    wxEVENT_PROPERTY( Select , wxEVT_COMMAND_COMBOBOX_SELECTED , wxCommandEvent )
-    wxEVENT_PROPERTY( TextEnter , wxEVT_COMMAND_TEXT_ENTER , wxCommandEvent )
-
-    // TODO DELEGATES
-    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( Value ,wxString, SetValue, GetValue, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
-    wxPROPERTY( Selection ,int, SetSelection, GetSelection, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
-    wxPROPERTY_FLAGS( WindowStyle , wxComboBoxStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
-wxEND_PROPERTIES_TABLE()
-
-wxBEGIN_HANDLERS_TABLE(wxComboBox)
-wxEND_HANDLERS_TABLE()
-
-wxCONSTRUCTOR_5( wxComboBox , wxWindow* , Parent , wxWindowID , Id , wxString , Value , wxPoint , Position , wxSize , Size )
-
-#else
-
-IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl)
-
-#endif
-

 BEGIN_EVENT_TABLE(wxComboBox, wxControl)
     EVT_MENU(wxID_CUT, wxComboBox::OnCut)
     EVT_MENU(wxID_COPY, wxComboBox::OnCopy)
 BEGIN_EVENT_TABLE(wxComboBox, wxControl)
     EVT_MENU(wxID_CUT, wxComboBox::OnCut)
     EVT_MENU(wxID_COPY, wxComboBox::OnCopy)


@@ -152,22 +92,17 @@ static WNDPROC gs_wndprocEdit = (WNDPROC)NULL;
 // implementation
 // ============================================================================
 
 // implementation
 // ============================================================================
 

-// ----------------------------------------------------------------------------
-// wnd proc for subclassed edit control
-// ----------------------------------------------------------------------------
-
-LRESULT APIENTRY _EXPORT wxComboEditWndProc(HWND hWnd,
-                                            UINT message,
-                                            WPARAM wParam,
-                                            LPARAM lParam)
+namespace

 {
 {

-    HWND hwndCombo = ::GetParent(hWnd);
-    wxWindow *win = wxFindWinFromHandle((WXHWND)hwndCombo);

 
 

+// Check if the given message should be forwarded from the edit control which
+// is part of the combobox to wxComboBox itself. All messages generating the
+// events that the code using wxComboBox could be interested in must be
+// forwarded.
+bool ShouldForwardFromEditToCombo(UINT message)
+{

     switch ( message )
     {
     switch ( message )
     {

-        // forward some messages to the combobox to generate the appropriate
-        // wxEvents from them

         case WM_KEYUP:
         case WM_KEYDOWN:
         case WM_CHAR:
         case WM_KEYUP:
         case WM_KEYDOWN:
         case WM_CHAR:


@@ -176,44 +111,57 @@ LRESULT APIENTRY _EXPORT wxComboEditWndProc(HWND hWnd,
         case WM_SYSKEYUP:
         case WM_SETFOCUS:
         case WM_KILLFOCUS:
         case WM_SYSKEYUP:
         case WM_SETFOCUS:
         case WM_KILLFOCUS:

-            {
-                wxComboBox *combo = wxDynamicCast(win, wxComboBox);
-                if ( !combo )
-                {
-                    // we can get WM_KILLFOCUS while our parent is already half
-                    // destroyed and hence doesn't look like a combobx any
-                    // longer, check for it to avoid bogus assert failures
-                    if ( !win->IsBeingDeleted() )
-                    {
-                        wxFAIL_MSG( _T("should have combo as parent") );
-                    }
-                }
-                else if ( combo->MSWProcessEditMsg(message, wParam, lParam) )
-                {
-                    // handled by parent
-                    return 0;
-                }
-            }
-            break;
+        case WM_CUT:
+        case WM_COPY:
+        case WM_PASTE:
+            return true;
+    }

 
 

-        case WM_GETDLGCODE:
-            {
-                wxCHECK_MSG( win, 0, _T("should have a parent") );
+    return false;
+}

 
 

-                if ( win->GetWindowStyle() & wxTE_PROCESS_ENTER )
-                {
-                    // need to return a custom dlg code or we'll never get it
-                    return DLGC_WANTMESSAGE;
-                }
+} // anonymous namespace
+
+// ----------------------------------------------------------------------------
+// wnd proc for subclassed edit control
+// ----------------------------------------------------------------------------
+
+LRESULT APIENTRY _EXPORT wxComboEditWndProc(HWND hWnd,
+                                            UINT message,
+                                            WPARAM wParam,
+                                            LPARAM lParam)
+{
+    HWND hwndCombo = ::GetParent(hWnd);
+    wxWindow *win = wxFindWinFromHandle((WXHWND)hwndCombo);
+
+    if ( ShouldForwardFromEditToCombo(message) )
+    {
+        wxComboBox *combo = wxDynamicCast(win, wxComboBox);
+        if ( !combo )
+        {
+            // we can get WM_KILLFOCUS while our parent is already half
+            // destroyed and hence doesn't look like a combobx any
+            // longer, check for it to avoid bogus assert failures
+            if ( !win->IsBeingDeleted() )
+            {
+                wxFAIL_MSG( wxT("should have combo as parent") );

             }
             }

-            break;
+        }
+        else if ( combo->MSWProcessEditMsg(message, wParam, lParam) )
+        {
+            // handled by parent
+            return 0;
+        }
+    }
+    else if ( message == WM_GETDLGCODE )
+    {
+        wxCHECK_MSG( win, 0, wxT("should have a parent") );

 
 

-        case WM_CUT:
-        case WM_COPY:
-        case WM_PASTE:
-            if( win->HandleClipboardEvent( message ) )
-                return 0;
-            break;
+        if ( win->GetWindowStyle() & wxTE_PROCESS_ENTER )
+        {
+            // need to return a custom dlg code or we'll never get it
+            return DLGC_WANTMESSAGE;
+        }

     }
 
     return ::CallWindowProc(CASTWNDPROC gs_wndprocEdit, hWnd, message, wParam, lParam);
     }
 
     return ::CallWindowProc(CASTWNDPROC gs_wndprocEdit, hWnd, message, wParam, lParam);


@@ -237,10 +185,28 @@ WXLRESULT wxComboBox::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lPara
             {
                 // combobox selection sometimes spontaneously changes when its
                 // size changes, restore it to the old value if necessary
             {
                 // combobox selection sometimes spontaneously changes when its
                 // size changes, restore it to the old value if necessary

+                if ( !GetEditHWNDIfAvailable() )
+                    break;
+

                 long fromOld, toOld;
                 GetSelection(&fromOld, &toOld);
                 long fromOld, toOld;
                 GetSelection(&fromOld, &toOld);

+
+                // if an editable combobox has a not empty text not from the
+                // list, it tries to autocomplete it from the list when it is
+                // resized, but we don't want this to happen as it doesn't seem
+                // to make any sense, so we forcefully restore the old text
+                wxString textOld;
+                if ( !HasFlag(wxCB_READONLY) && GetCurrentSelection() == -1 )
+                    textOld = GetValue();
+
+                // eliminate flickering during following hacks
+                wxWindowUpdateLocker lock(this);
+

                 WXLRESULT result = wxChoice::MSWWindowProc(nMsg, wParam, lParam);
 
                 WXLRESULT result = wxChoice::MSWWindowProc(nMsg, wParam, lParam);
 

+                if ( !textOld.empty() && GetValue() != textOld )
+                    SetLabel(textOld);
+

                 long fromNew, toNew;
                 GetSelection(&fromNew, &toNew);
 
                 long fromNew, toNew;
                 GetSelection(&fromNew, &toNew);
 


@@ -265,6 +231,9 @@ bool wxComboBox::MSWProcessEditMsg(WXUINT msg, WXWPARAM wParam, WXLPARAM lParam)
             // when Enter is pressed
             if ( wParam == VK_RETURN )
             {
             // when Enter is pressed
             if ( wParam == VK_RETURN )
             {

+                if (SendMessage(GetHwnd(), CB_GETDROPPEDSTATE, 0, 0))
+                    return false;
+

                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
 
                 const int sel = GetSelection();
                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
 
                 const int sel = GetSelection();


@@ -280,24 +249,16 @@ bool wxComboBox::MSWProcessEditMsg(WXUINT msg, WXWPARAM wParam, WXLPARAM lParam)
                     return true;
                 }
             }
                     return true;
                 }
             }

-            // fall through
-
-        case WM_SYSCHAR:
-            return HandleChar(wParam, lParam, true /* isASCII */);
-
-        case WM_SYSKEYDOWN:
-        case WM_KEYDOWN:
-            return HandleKeyDown(wParam, lParam);
-
-        case WM_SYSKEYUP:
-        case WM_KEYUP:
-            return HandleKeyUp(wParam, lParam);
+            // fall through, WM_CHAR is one of the message we should forward.

 
 

-        case WM_SETFOCUS:
-            return HandleSetFocus((WXHWND)wParam);
-
-        case WM_KILLFOCUS:
-            return HandleKillFocus((WXHWND)wParam);
+        default:
+            if ( ShouldForwardFromEditToCombo(msg) )
+            {
+                // For all the messages forward from the edit control the
+                // result is not used.
+                WXLRESULT result;
+                return MSWHandleMessage(&result, msg, wParam, lParam);
+            }

     }
 
     return false;
     }
 
     return false;


@@ -310,6 +271,30 @@ bool wxComboBox::MSWCommand(WXUINT param, WXWORD id)
 
     switch ( param )
     {
 
     switch ( param )
     {

+        case CBN_DROPDOWN:
+            // remember the last selection, just as wxChoice does
+            m_lastAcceptedSelection = GetCurrentSelection();
+            {
+                wxCommandEvent event(wxEVT_COMMAND_COMBOBOX_DROPDOWN, GetId());
+                event.SetEventObject(this);
+                ProcessCommand(event);
+            }
+            break;
+
+        case CBN_CLOSEUP:
+            // Do the same thing as in wxChoice but using different event type.
+            if ( m_pendingSelection != wxID_NONE )
+            {
+                SendSelectionChangedEvent(wxEVT_COMMAND_COMBOBOX_SELECTED);
+                m_pendingSelection = wxID_NONE;
+            }
+            {
+                wxCommandEvent event(wxEVT_COMMAND_COMBOBOX_CLOSEUP, GetId());
+                event.SetEventObject(this);
+                ProcessCommand(event);
+            }
+            break;
+

         case CBN_SELENDOK:
 #ifndef __SMARTPHONE__
             // we need to reset this to prevent the selection from being undone
         case CBN_SELENDOK:
 #ifndef __SMARTPHONE__
             // we need to reset this to prevent the selection from being undone


@@ -325,22 +310,16 @@ bool wxComboBox::MSWCommand(WXUINT param, WXWORD id)
             // this string is going to become the new combobox value soon but
             // we need it to be done right now, otherwise the event handler
             // could get a wrong value when it calls our GetValue()
             // this string is going to become the new combobox value soon but
             // we need it to be done right now, otherwise the event handler
             // could get a wrong value when it calls our GetValue()

-            ::SetWindowText(GetHwnd(), value);
+            ::SetWindowText(GetHwnd(), value.t_str());

 
 

-            {
-                wxCommandEvent event(wxEVT_COMMAND_COMBOBOX_SELECTED, GetId());
-                event.SetInt(sel);
-                event.SetString(value);
-                InitCommandEventWithItems(event, sel);
-
-                ProcessCommand(event);
-            }
+            SendSelectionChangedEvent(wxEVT_COMMAND_COMBOBOX_SELECTED);

 
 

-            // fall through: for compability with wxGTK, also send the text
+            // fall through: for compatibility with wxGTK, also send the text

             // update event when the selection changes (this also seems more
             // logical as the text does change)
 
         case CBN_EDITCHANGE:
             // update event when the selection changes (this also seems more
             // logical as the text does change)
 
         case CBN_EDITCHANGE:

+            if ( m_allowTextEvents )

             {
                 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
 
             {
                 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
 


@@ -362,26 +341,79 @@ bool wxComboBox::MSWCommand(WXUINT param, WXWORD id)
     }
 
     // skip wxChoice version as it would generate its own events for
     }
 
     // skip wxChoice version as it would generate its own events for

-    // CBN_SELENDOK
-    return wxControl::MSWCommand(param, id);
+    // CBN_SELENDOK and also interfere with our handling of CBN_DROPDOWN
+    return true;

 }
 
 }
 

-WXHWND wxComboBox::GetEditHWND() const
+bool wxComboBox::MSWShouldPreProcessMessage(WXMSG *pMsg)

 {
 {

-    // this function should not be called for wxCB_READONLY controls, it is
-    // the callers responsability to check this
-    wxASSERT_MSG( !(GetWindowStyle() & wxCB_READONLY),
-                  _T("read-only combobox doesn't have any edit control") );
-
-    POINT pt;
-    pt.x = pt.y = 4;
-    HWND hwndEdit = ::ChildWindowFromPoint(GetHwnd(), pt);
-    if ( !hwndEdit || hwndEdit == GetHwnd() )
+    // prevent command accelerators from stealing editing
+    // hotkeys when we have the focus
+    if (wxIsCtrlDown())
+    {
+        WPARAM vkey = pMsg->wParam;
+
+        switch (vkey)
+        {
+            case 'C':
+            case 'V':
+            case 'X':
+            case VK_INSERT:
+            case VK_DELETE:
+            case VK_HOME:
+            case VK_END:
+                return false;
+        }
+    }
+
+    return wxChoice::MSWShouldPreProcessMessage(pMsg);
+}
+
+WXHWND wxComboBox::GetEditHWNDIfAvailable() const
+{
+    // FIXME-VC6: Only VC6 needs this guard, see WINVER definition in
+    //            include/wx/msw/wrapwin.h
+#if defined(WINVER) && WINVER >= 0x0500
+    WinStruct<COMBOBOXINFO> info;
+    if ( MSWGetComboBoxInfo(&info) )
+        return info.hwndItem;
+#endif // WINVER >= 0x0500
+
+    if (HasFlag(wxCB_SIMPLE))

     {
     {

-        wxFAIL_MSG(_T("not read only combobox without edit control?"));
+        POINT pt;
+        pt.x = pt.y = 4;
+        return (WXHWND) ::ChildWindowFromPoint(GetHwnd(), pt);

     }
 
     }
 

-    return (WXHWND)hwndEdit;
+    // notice that a slightly safer alternative could be to use FindWindowEx()
+    // but it's not available under WinCE so just take the first child for now
+    // to keep one version of the code for all platforms and fix it later if
+    // problems are discovered
+
+    // we assume that the only child of the combobox is the edit window
+    return (WXHWND)::GetWindow(GetHwnd(), GW_CHILD);
+}
+
+WXHWND wxComboBox::GetEditHWND() const
+{
+    // this function should not be called for wxCB_READONLY controls, it is
+    // the callers responsibility to check this
+    wxASSERT_MSG( !HasFlag(wxCB_READONLY),
+                  wxT("read-only combobox doesn't have any edit control") );
+
+    WXHWND hWndEdit = GetEditHWNDIfAvailable();
+    wxASSERT_MSG( hWndEdit, wxT("combobox without edit control?") );
+
+    return hWndEdit;
+}
+
+wxWindow *wxComboBox::GetEditableWindow()
+{
+    wxASSERT_MSG( !HasFlag(wxCB_READONLY),
+                  wxT("read-only combobox doesn't have any edit control") );
+
+    return this;

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


@@ -479,7 +511,8 @@ WXDWORD wxComboBox::MSWGetStyle(long style, WXDWORD *exstyle) const
 
 wxString wxComboBox::GetValue() const
 {
 
 wxString wxComboBox::GetValue() const
 {

-    return wxGetWindowText(m_hWnd);
+    return HasFlag(wxCB_READONLY) ? GetStringSelection()
+                                  : wxTextEntry::GetValue();

 }
 
 void wxComboBox::SetValue(const wxString& value)
 }
 
 void wxComboBox::SetValue(const wxString& value)


@@ -487,222 +520,39 @@ void wxComboBox::SetValue(const wxString& value)
     if ( HasFlag(wxCB_READONLY) )
         SetStringSelection(value);
     else
     if ( HasFlag(wxCB_READONLY) )
         SetStringSelection(value);
     else

-        SetWindowText(GetHwnd(), value.c_str());
+        wxTextEntry::SetValue(value);

 }
 
 }
 

-// Clipboard operations
-void wxComboBox::Copy()
+void wxComboBox::Clear()

 {
 {

-    SendMessage(GetHwnd(), WM_COPY, 0, 0L);
+    wxChoice::Clear();
+    if ( !HasFlag(wxCB_READONLY) )
+        wxTextEntry::Clear();

 }
 
 }
 

-void wxComboBox::Cut()
+bool wxComboBox::ContainsHWND(WXHWND hWnd) const

 {
 {

-    SendMessage(GetHwnd(), WM_CUT, 0, 0L);
+    return hWnd == GetEditHWNDIfAvailable();

 }
 
 }
 

-void wxComboBox::Paste()
+void wxComboBox::GetSelection(long *from, long *to) const

 {
 {

-    SendMessage(GetHwnd(), WM_PASTE, 0, 0L);
-}
-
-void wxComboBox::Undo()
-{
-    if (CanUndo())
+    if ( !HasFlag(wxCB_READONLY) )

     {
     {

-        HWND hEditWnd = (HWND) GetEditHWND();
-        if ( hEditWnd )
-            ::SendMessage(hEditWnd, EM_UNDO, 0, 0);
+        wxTextEntry::GetSelection(from, to);

     }
     }

-}
-
-void wxComboBox::Redo()
-{
-    if (CanUndo())
+    else // text selection doesn't make sense for read only comboboxes

     {
     {

-        // Same as Undo, since Undo undoes the undo, i.e. a redo.
-        HWND hEditWnd = (HWND) GetEditHWND();
-        if ( hEditWnd )
-            ::SendMessage(hEditWnd, EM_UNDO, 0, 0);
+        if ( from )
+            *from = -1;
+        if ( to )
+            *to = -1;

     }
 }
 
     }
 }
 

-void wxComboBox::SelectAll()
-{
-    SetSelection(0, GetLastPosition());
-}
-
-bool wxComboBox::CanUndo() const
-{
-    if (!IsEditable())
-        return false;
-
-    HWND hEditWnd = (HWND) GetEditHWND();
-    if ( hEditWnd )
-        return ::SendMessage(hEditWnd, EM_CANUNDO, 0, 0) != 0;
-    else
-        return false;
-}
-
-bool wxComboBox::CanRedo() const
-{
-    if (!IsEditable())
-        return false;
-
-    HWND hEditWnd = (HWND) GetEditHWND();
-    if ( hEditWnd )
-        return ::SendMessage(hEditWnd, EM_CANUNDO, 0, 0) != 0;
-    else
-        return false;
-}
-
-bool wxComboBox::HasSelection() const
-{
-    long from, to;
-    GetSelection(&from, &to);
-    return from != to;
-}
-
-bool wxComboBox::CanCopy() const
-{
-    // Can copy if there's a selection
-    return HasSelection();
-}
-
-bool wxComboBox::CanCut() const
-{
-    return IsEditable() && CanCopy();
-}
-
-bool wxComboBox::CanPaste() const
-{
-    if ( !IsEditable() )
-        return false;
-
-    // Standard edit control: check for straight text on clipboard
-    if ( !::OpenClipboard(GetHwndOf(wxTheApp->GetTopWindow())) )
-        return false;
-
-    bool isTextAvailable = ::IsClipboardFormatAvailable(CF_TEXT) != 0;
-    ::CloseClipboard();
-
-    return isTextAvailable;
-}
-

 bool wxComboBox::IsEditable() const
 {
 bool wxComboBox::IsEditable() const
 {

-    return !HasFlag(wxCB_READONLY);
-}
-
-void wxComboBox::SetEditable(bool WXUNUSED(editable))
-{
-  // Can't implement in MSW?
-//  HWND hWnd = GetHwnd();
-//  SendMessage(hWnd, EM_SETREADONLY, (WPARAM)!editable, (LPARAM)0L);
-}
-
-void wxComboBox::SetInsertionPoint(long pos)
-{
-    if ( GetWindowStyle() & wxCB_READONLY )
-        return;
-
-#ifdef __WIN32__
-    HWND hWnd = GetHwnd();
-    ::SendMessage(hWnd, CB_SETEDITSEL, 0, MAKELPARAM(pos, pos));
-    HWND hEditWnd = (HWND) GetEditHWND();
-    if ( hEditWnd )
-    {
-        // Scroll insertion point into view
-        SendMessage(hEditWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0);
-        // Why is this necessary? (Copied from wxTextCtrl::SetInsertionPoint)
-        SendMessage(hEditWnd, EM_REPLACESEL, 0, (LPARAM) wxEmptyString);
-    }
-#endif // __WIN32__
-}
-
-void wxComboBox::SetInsertionPointEnd()
-{
-    // setting insertion point doesn't make sense for read only comboboxes
-    if ( !(GetWindowStyle() & wxCB_READONLY) )
-    {
-        wxTextPos pos = GetLastPosition();
-        SetInsertionPoint(pos);
-    }
-}
-
-long wxComboBox::GetInsertionPoint() const
-{
-    // CB_GETEDITSEL returns the index of the first character of the selection in
-    // its low-order word
-    DWORD pos= (DWORD)::SendMessage(GetHwnd(), CB_GETEDITSEL, 0, 0L);
-    return LOWORD(pos);
-}
-
-wxTextPos wxComboBox::GetLastPosition() const
-{
-    HWND hEditWnd = (HWND) GetEditHWND();
-
-    // Get number of characters in the last (only) line. We'll add this to the character
-    // index for the last line, 1st position.
-    wxTextPos lineLength = (wxTextPos)SendMessage(hEditWnd, EM_LINELENGTH, (WPARAM) 0, (LPARAM)0L);
-
-    return lineLength;
-}
-
-void wxComboBox::Replace(long from, long to, const wxString& value)
-{
-#if wxUSE_CLIPBOARD
-    Remove(from, to);
-
-    // Now replace with 'value', by pasting.
-    wxSetClipboardData(wxDF_TEXT, (wxObject *)(const wxChar *)value, 0, 0);
-
-    // Paste into edit control
-    SendMessage(GetHwnd(), WM_PASTE, (WPARAM)0, (LPARAM)0L);
-#else
-    wxUnusedVar(from);
-    wxUnusedVar(to);
-    wxUnusedVar(value);
-#endif
-}
-
-void wxComboBox::Remove(long from, long to)
-{
-    // Set selection and remove it
-    SetSelection(from, to);
-    SendMessage(GetHwnd(), WM_CUT, (WPARAM)0, (LPARAM)0);
-}
-
-void wxComboBox::SetSelection(long from, long to)
-{
-    // if from and to are both -1, it means (in wxWidgets) that all text should
-    // be selected, translate this into Windows convention
-    if ( (from == -1) && (to == -1) )
-    {
-        from = 0;
-    }
-
-    if ( SendMessage(GetHwnd(), CB_SETEDITSEL,
-                     0, (LPARAM)MAKELONG(from, to)) == CB_ERR )
-    {
-        wxLogDebug(_T("CB_SETEDITSEL failed"));
-    }
-}
-
-void wxComboBox::GetSelection(long* from, long* to) const
-{
-    DWORD dwStart, dwEnd;
-    if ( ::SendMessage(GetHwnd(), CB_GETEDITSEL,
-                       (WPARAM)&dwStart, (LPARAM)&dwEnd) == CB_ERR )
-    {
-        *from =
-        *to = 0;
-    }
-    else
-    {
-        *from = dwStart;
-        *to = dwEnd;
-    }
+    return !HasFlag(wxCB_READONLY) && wxTextEntry::IsEditable();

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


@@ -736,15 +586,12 @@ void wxComboBox::OnRedo(wxCommandEvent& WXUNUSED(event))
 
 void wxComboBox::OnDelete(wxCommandEvent& WXUNUSED(event))
 {
 
 void wxComboBox::OnDelete(wxCommandEvent& WXUNUSED(event))
 {

-    long from, to;
-    GetSelection(& from, & to);
-    if (from != -1 && to != -1)
-        Remove(from, to);
+    RemoveSelection();

 }
 
 void wxComboBox::OnSelectAll(wxCommandEvent& WXUNUSED(event))
 {
 }
 
 void wxComboBox::OnSelectAll(wxCommandEvent& WXUNUSED(event))
 {

-    SetSelection(-1, -1);
+    SelectAll();

 }
 
 void wxComboBox::OnUpdateCut(wxUpdateUIEvent& event)
 }
 
 void wxComboBox::OnUpdateCut(wxUpdateUIEvent& event)


@@ -764,22 +611,68 @@ void wxComboBox::OnUpdatePaste(wxUpdateUIEvent& event)
 
 void wxComboBox::OnUpdateUndo(wxUpdateUIEvent& event)
 {
 
 void wxComboBox::OnUpdateUndo(wxUpdateUIEvent& event)
 {

-    event.Enable( CanUndo() );
+    event.Enable( IsEditable() && CanUndo() );

 }
 
 void wxComboBox::OnUpdateRedo(wxUpdateUIEvent& event)
 {
 }
 
 void wxComboBox::OnUpdateRedo(wxUpdateUIEvent& event)
 {

-    event.Enable( CanRedo() );
+    event.Enable( IsEditable() && CanRedo() );

 }
 
 void wxComboBox::OnUpdateDelete(wxUpdateUIEvent& event)
 {
 }
 
 void wxComboBox::OnUpdateDelete(wxUpdateUIEvent& event)
 {

-    event.Enable(HasSelection() && IsEditable());
+    event.Enable(IsEditable() && HasSelection());

 }
 
 void wxComboBox::OnUpdateSelectAll(wxUpdateUIEvent& event)
 {
 }
 
 void wxComboBox::OnUpdateSelectAll(wxUpdateUIEvent& event)
 {

-    event.Enable(GetLastPosition() > 0);
+    event.Enable(IsEditable() && !wxTextEntry::IsEmpty());
+}
+
+#if wxUSE_TOOLTIPS
+
+void wxComboBox::DoSetToolTip(wxToolTip *tip)
+{
+    wxChoice::DoSetToolTip(tip);
+
+    if ( tip && !HasFlag(wxCB_READONLY) )
+        tip->AddOtherWindow(GetEditHWND());
+}
+
+#endif // wxUSE_TOOLTIPS
+
+#if wxUSE_UXTHEME
+
+bool wxComboBox::SetHint(const wxString& hintOrig)
+{
+    wxString hint(hintOrig);
+    if ( wxUxThemeEngine::GetIfActive() )
+    {
+        // under XP (but not Vista) there is a bug in cue banners
+        // implementation for combobox edit control: the first character is
+        // partially chopped off, so prepend a space to make it fully visible
+        hint.insert(0, " ");
+    }
+
+    return wxTextEntry::SetHint(hint);
+}
+
+#endif // wxUSE_UXTHEME
+
+wxSize wxComboBox::DoGetSizeFromTextSize(int xlen, int ylen) const
+{
+    wxSize tsize( wxChoice::DoGetSizeFromTextSize(xlen, ylen) );
+
+    if ( !HasFlag(wxCB_READONLY) )
+    {
+        // Add the margins we have previously set
+        wxPoint marg( GetMargins() );
+        marg.x = wxMax(0, marg.x);
+        marg.y = wxMax(0, marg.y);
+        tsize.IncBy( marg );
+    }
+
+    return tsize;

 }
 
 #endif // wxUSE_COMBOBOX
 }
 
 #endif // wxUSE_COMBOBOX