src/msw/combobox.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/combobox.cpp
   3 // Purpose:     wxComboBox class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21 #pragma implementation "combobox.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #if wxUSE_COMBOBOX
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/settings.h"
  35     #include "wx/log.h"
  36     // for wxEVT_COMMAND_TEXT_ENTER
  37     #include "wx/textctrl.h"
  38 #endif
  39
  40 #include "wx/combobox.h"
  41 #include "wx/brush.h"
  42 #include "wx/clipbrd.h"
  43 #include "wx/msw/private.h"
  44
  45 #if wxUSE_TOOLTIPS
  46     #if !defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__)
  47         #include <commctrl.h>
  48     #endif
  49     #include "wx/tooltip.h"
  50 #endif // wxUSE_TOOLTIPS
  51
  52 // ----------------------------------------------------------------------------
  53 // wxWin macros
  54 // ----------------------------------------------------------------------------
  55
  56 #if wxUSE_EXTENDED_RTTI
  57 WX_DEFINE_FLAGS( wxComboBoxStyle )
  58
  59 wxBEGIN_FLAGS( wxComboBoxStyle )
  60     // new style border flags, we put them first to
  61     // use them for streaming out
  62     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
  63     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
  64     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
  65     wxFLAGS_MEMBER(wxBORDER_RAISED)
  66     wxFLAGS_MEMBER(wxBORDER_STATIC)
  67     wxFLAGS_MEMBER(wxBORDER_NONE)
  68
  69     // old style border flags
  70     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
  71     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
  72     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
  73     wxFLAGS_MEMBER(wxRAISED_BORDER)
  74     wxFLAGS_MEMBER(wxSTATIC_BORDER)
  75     wxFLAGS_MEMBER(wxBORDER)
  76
  77     // standard window styles
  78     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
  79     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
  80     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
  81     wxFLAGS_MEMBER(wxWANTS_CHARS)
  82     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
  83     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
  84     wxFLAGS_MEMBER(wxVSCROLL)
  85     wxFLAGS_MEMBER(wxHSCROLL)
  86
  87     wxFLAGS_MEMBER(wxCB_SIMPLE)
  88     wxFLAGS_MEMBER(wxCB_SORT)
  89     wxFLAGS_MEMBER(wxCB_READONLY)
  90     wxFLAGS_MEMBER(wxCB_DROPDOWN)
  91
  92 wxEND_FLAGS( wxComboBoxStyle )
  93
  94 IMPLEMENT_DYNAMIC_CLASS_XTI(wxComboBox, wxControl,"wx/combobox.h")
  95
  96 wxBEGIN_PROPERTIES_TABLE(wxComboBox)
  97     wxEVENT_PROPERTY( Select , wxEVT_COMMAND_COMBOBOX_SELECTED , wxCommandEvent )
  98     wxEVENT_PROPERTY( TextEnter , wxEVT_COMMAND_TEXT_ENTER , wxCommandEvent )
  99
 100     // TODO DELEGATES
 101     wxPROPERTY( Font , wxFont , SetFont , GetFont  , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 102     wxPROPERTY_COLLECTION( Choices , wxArrayString , wxString , AppendString , GetStrings , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 103     wxPROPERTY( Value ,wxString, SetValue, GetValue, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 104     wxPROPERTY( Selection ,int, SetSelection, GetSelection, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 105     wxPROPERTY_FLAGS( WindowStyle , wxComboBoxStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 106 wxEND_PROPERTIES_TABLE()
 107
 108 wxBEGIN_HANDLERS_TABLE(wxComboBox)
 109 wxEND_HANDLERS_TABLE()
 110
 111 wxCONSTRUCTOR_5( wxComboBox , wxWindow* , Parent , wxWindowID , Id , wxString , Value , wxPoint , Position , wxSize , Size )
 112 #else
 113 IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl)
 114
 115 BEGIN_EVENT_TABLE(wxComboBox, wxControl)
 116     EVT_MENU(wxID_CUT, wxComboBox::OnCut)
 117     EVT_MENU(wxID_COPY, wxComboBox::OnCopy)
 118     EVT_MENU(wxID_PASTE, wxComboBox::OnPaste)
 119     EVT_MENU(wxID_UNDO, wxComboBox::OnUndo)
 120     EVT_MENU(wxID_REDO, wxComboBox::OnRedo)
 121     EVT_MENU(wxID_CLEAR, wxComboBox::OnDelete)
 122     EVT_MENU(wxID_SELECTALL, wxComboBox::OnSelectAll)
 123
 124     EVT_UPDATE_UI(wxID_CUT, wxComboBox::OnUpdateCut)
 125     EVT_UPDATE_UI(wxID_COPY, wxComboBox::OnUpdateCopy)
 126     EVT_UPDATE_UI(wxID_PASTE, wxComboBox::OnUpdatePaste)
 127     EVT_UPDATE_UI(wxID_UNDO, wxComboBox::OnUpdateUndo)
 128     EVT_UPDATE_UI(wxID_REDO, wxComboBox::OnUpdateRedo)
 129     EVT_UPDATE_UI(wxID_CLEAR, wxComboBox::OnUpdateDelete)
 130     EVT_UPDATE_UI(wxID_SELECTALL, wxComboBox::OnUpdateSelectAll)
 131 END_EVENT_TABLE()
 132
 133 #endif
 134
 135 // ----------------------------------------------------------------------------
 136 // function prototypes
 137 // ----------------------------------------------------------------------------
 138
 139 LRESULT APIENTRY _EXPORT wxComboEditWndProc(HWND hWnd,
 140                                             UINT message,
 141                                             WPARAM wParam,
 142                                             LPARAM lParam);
 143
 144 // ---------------------------------------------------------------------------
 145 // global vars
 146 // ---------------------------------------------------------------------------
 147
 148 // the pointer to standard radio button wnd proc
 149 static WNDPROC gs_wndprocEdit = (WNDPROC)NULL;
 150
 151 // ============================================================================
 152 // implementation
 153 // ============================================================================
 154
 155 // ----------------------------------------------------------------------------
 156 // wnd proc for subclassed edit control
 157 // ----------------------------------------------------------------------------
 158
 159 LRESULT APIENTRY _EXPORT wxComboEditWndProc(HWND hWnd,
 160                                             UINT message,
 161                                             WPARAM wParam,
 162                                             LPARAM lParam)
 163 {
 164     HWND hwndCombo = ::GetParent(hWnd);
 165     wxWindow *win = wxFindWinFromHandle((WXHWND)hwndCombo);
 166
 167     switch ( message )
 168     {
 169         // forward some messages to the combobox to generate the appropriate
 170         // wxEvents from them
 171         case WM_KEYUP:
 172         case WM_KEYDOWN:
 173         case WM_CHAR:
 174         case WM_SETFOCUS:
 175         case WM_KILLFOCUS:
 176             {
 177                 wxComboBox *combo = wxDynamicCast(win, wxComboBox);
 178                 if ( !combo )
 179                 {
 180                     // we can get WM_KILLFOCUS while our parent is already half
 181                     // destroyed and hence doesn't look like a combobx any
 182                     // longer, check for it to avoid bogus assert failures
 183                     if ( !win->IsBeingDeleted() )
 184                     {
 185                         wxFAIL_MSG( _T("should have combo as parent") );
 186                     }
 187                 }
 188                 else if ( combo->MSWProcessEditMsg(message, wParam, lParam) )
 189                 {
 190                     // handled by parent
 191                     return 0;
 192                 }
 193             }
 194             break;
 195
 196         case WM_GETDLGCODE:
 197             {
 198                 wxCHECK_MSG( win, 0, _T("should have a parent") );
 199
 200                 if ( win->GetWindowStyle() & wxPROCESS_ENTER )
 201                 {
 202                     // need to return a custom dlg code or we'll never get it
 203                     return DLGC_WANTMESSAGE;
 204                 }
 205             }
 206             break;
 207
 208         // deal with tooltips here
 209 #if wxUSE_TOOLTIPS && defined(TTN_NEEDTEXT)
 210         case WM_NOTIFY:
 211             {
 212                 wxCHECK_MSG( win, 0, _T("should have a parent") );
 213
 214                 NMHDR* hdr = (NMHDR *)lParam;
 215                 if ( hdr->code == TTN_NEEDTEXT )
 216                 {
 217                     wxToolTip *tooltip = win->GetToolTip();
 218                     if ( tooltip )
 219                     {
 220                         TOOLTIPTEXT *ttt = (TOOLTIPTEXT *)lParam;
 221                         ttt->lpszText = (wxChar *)tooltip->GetTip().c_str();
 222                     }
 223
 224                     // processed
 225                     return 0;
 226                 }
 227             }
 228             break;
 229 #endif // wxUSE_TOOLTIPS
 230     }
 231
 232     return ::CallWindowProc(CASTWNDPROC gs_wndprocEdit, hWnd, message, wParam, lParam);
 233 }
 234
 235 // ----------------------------------------------------------------------------
 236 // wxComboBox callbacks
 237 // ----------------------------------------------------------------------------
 238
 239 WXLRESULT wxComboBox::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 240 {
 241     // handle WM_CTLCOLOR messages from our EDIT control to be able to set its
 242     // colour correctly (to be the same as our own one)
 243     switch ( nMsg )
 244     {
 245         case CB_SETCURSEL:
 246             // Selection was set with SetSelection.  Update the value too.
 247             if ((int)wParam > GetCount())
 248                 m_value = wxEmptyString;
 249             else
 250                 m_value = GetString(wParam);
 251             break;
 252     }
 253
 254     return wxChoice::MSWWindowProc(nMsg, wParam, lParam);
 255 }
 256
 257 bool wxComboBox::MSWProcessEditMsg(WXUINT msg, WXWPARAM wParam, WXLPARAM lParam)
 258 {
 259     switch ( msg )
 260     {
 261         case WM_CHAR:
 262             // for compatibility with wxTextCtrl, generate a special message
 263             // when Enter is pressed
 264             if ( wParam == VK_RETURN )
 265             {
 266                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
 267                 InitCommandEvent(event);
 268                 event.SetString(GetValue());
 269                 event.SetInt(GetSelection());
 270                 ProcessCommand(event);
 271             }
 272
 273             return HandleChar(wParam, lParam, true /* isASCII */);
 274
 275         case WM_KEYDOWN:
 276             return HandleKeyDown(wParam, lParam);
 277
 278         case WM_KEYUP:
 279             return HandleKeyUp(wParam, lParam);
 280
 281         case WM_SETFOCUS:
 282             return HandleSetFocus((WXHWND)wParam);
 283
 284         case WM_KILLFOCUS:
 285             return HandleKillFocus((WXHWND)wParam);
 286     }
 287
 288     return false;
 289 }
 290
 291 bool wxComboBox::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
 292 {
 293     wxString value;
 294     int sel = -1;
 295     switch ( param )
 296     {
 297         case CBN_SELCHANGE:
 298             sel = GetSelection();
 299
 300             // somehow we get 2 CBN_SELCHANGE events with the same index when
 301             // the user selects an item in the combobox -- ignore duplicates
 302             if ( sel > -1 && sel != m_selectionOld )
 303             {
 304                 m_selectionOld = sel;
 305
 306                 // GetValue() would still return the old value from here but
 307                 // according to the docs we should return the new value if the
 308                 // user calls it in his event handler, so update internal
 309                 // m_value
 310                 m_value = GetString(sel);
 311
 312                 wxCommandEvent event(wxEVT_COMMAND_COMBOBOX_SELECTED, GetId());
 313                 event.SetInt(sel);
 314                 event.SetEventObject(this);
 315                 event.SetString(m_value);
 316                 ProcessCommand(event);
 317             }
 318             else // no valid selection
 319             {
 320                 m_selectionOld = sel;
 321
 322                 // hence no EVT_TEXT neither
 323                 break;
 324             }
 325
 326             // fall through: for compability with wxGTK, also send the text
 327             // update event when the selection changes (this also seems more
 328             // logical as the text does change)
 329
 330         case CBN_EDITCHANGE:
 331             {
 332                 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
 333
 334                 // if sel != -1, value was initialized above (and we can't use
 335                 // GetValue() here as it would return the old selection and we
 336                 // want the new one)
 337                 if ( sel == -1 )
 338                 {
 339                     m_value = wxGetWindowText(GetHwnd());
 340                 }
 341                 else // we're synthesizing text updated event from sel change
 342                 {
 343                     // We need to retrieve the current selection because the
 344                     // user may have changed it in the previous handler (for
 345                     // CBN_SELCHANGE above).
 346                     sel = GetSelection();
 347                     if ( sel > -1 )
 348                     {
 349                         m_value = GetString(sel);
 350                     }
 351                 }
 352
 353                 event.SetString(m_value);
 354                 event.SetEventObject(this);
 355                 ProcessCommand(event);
 356             }
 357             break;
 358     }
 359
 360     // there is no return value for the CBN_ notifications, so always return
 361     // false from here to pass the message to DefWindowProc()
 362     return false;
 363 }
 364
 365 WXHWND wxComboBox::GetEditHWND() const
 366 {
 367     // this function should not be called for wxCB_READONLY controls, it is
 368     // the callers responsability to check this
 369     wxASSERT_MSG( !(GetWindowStyle() & wxCB_READONLY),
 370                   _T("read-only combobox doesn't have any edit control") );
 371
 372     POINT pt;
 373     pt.x = pt.y = 4;
 374     HWND hwndEdit = ::ChildWindowFromPoint(GetHwnd(), pt);
 375     if ( !hwndEdit || hwndEdit == GetHwnd() )
 376     {
 377         wxFAIL_MSG(_T("not read only combobox without edit control?"));
 378     }
 379
 380     return (WXHWND)hwndEdit;
 381 }
 382
 383 // ----------------------------------------------------------------------------
 384 // wxComboBox creation
 385 // ----------------------------------------------------------------------------
 386
 387 bool wxComboBox::Create(wxWindow *parent, wxWindowID id,
 388                         const wxString& value,
 389                         const wxPoint& pos,
 390                         const wxSize& size,
 391                         int n, const wxString choices[],
 392                         long style,
 393                         const wxValidator& validator,
 394                         const wxString& name)
 395 {
 396     // pretend that wxComboBox is hidden while it is positioned and resized and
 397     // show it only right before leaving this method because otherwise there is
 398     // some noticeable flicker while the control rearranges itself
 399     m_isShown = false;
 400
 401     if ( !CreateAndInit(parent, id, pos, size, n, choices, style,
 402                         validator, name) )
 403         return false;
 404
 405     // we shouldn't call SetValue() for an empty string because this would
 406     // (correctly) result in an assert with a read only combobox and is useless
 407     // for the other ones anyhow
 408     if ( !value.empty() )
 409         SetValue(value);
 410
 411     // a (not read only) combobox is, in fact, 2 controls: the combobox itself
 412     // and an edit control inside it and if we want to catch events from this
 413     // edit control, we must subclass it as well
 414     if ( !(style & wxCB_READONLY) )
 415     {
 416         gs_wndprocEdit = wxSetWindowProc((HWND)GetEditHWND(),
 417                                          wxComboEditWndProc);
 418     }
 419
 420     // and finally, show the control
 421     Show(true);
 422
 423     return true;
 424 }
 425
 426 bool wxComboBox::Create(wxWindow *parent, wxWindowID id,
 427                         const wxString& value,
 428                         const wxPoint& pos,
 429                         const wxSize& size,
 430                         const wxArrayString& choices,
 431                         long style,
 432                         const wxValidator& validator,
 433                         const wxString& name)
 434 {
 435     wxCArrayString chs(choices);
 436     return Create(parent, id, value, pos, size, chs.GetCount(),
 437                   chs.GetStrings(), style, validator, name);
 438 }
 439
 440 WXDWORD wxComboBox::MSWGetStyle(long style, WXDWORD *exstyle) const
 441 {
 442     // we never have an external border
 443     WXDWORD msStyle = wxChoice::MSWGetStyle
 444                       (
 445                         (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
 446                       );
 447
 448     // remove the style always added by wxChoice
 449     msStyle &= ~CBS_DROPDOWNLIST;
 450
 451     if ( style & wxCB_READONLY )
 452         msStyle |= CBS_DROPDOWNLIST;
 453 #ifndef __WXWINCE__
 454     else if ( style & wxCB_SIMPLE )
 455         msStyle |= CBS_SIMPLE; // A list (shown always) and edit control
 456 #endif
 457     else
 458         msStyle |= CBS_DROPDOWN;
 459
 460     // there is no reason to not always use CBS_AUTOHSCROLL, so do use it
 461     msStyle |= CBS_AUTOHSCROLL;
 462
 463     // NB: we used to also add CBS_NOINTEGRALHEIGHT here but why?
 464
 465     return msStyle;
 466 }
 467
 468 // ----------------------------------------------------------------------------
 469 // wxComboBox text control-like methods
 470 // ----------------------------------------------------------------------------
 471
 472 void wxComboBox::SetValue(const wxString& value)
 473 {
 474     if ( HasFlag(wxCB_READONLY) )
 475         SetStringSelection(value);
 476     else
 477         SetWindowText(GetHwnd(), value.c_str());
 478
 479     m_value = value;
 480     m_selectionOld = GetSelection();
 481 }
 482
 483 // Clipboard operations
 484 void wxComboBox::Copy()
 485 {
 486     SendMessage(GetHwnd(), WM_COPY, 0, 0L);
 487 }
 488
 489 void wxComboBox::Cut()
 490 {
 491     SendMessage(GetHwnd(), WM_CUT, 0, 0L);
 492 }
 493
 494 void wxComboBox::Paste()
 495 {
 496     SendMessage(GetHwnd(), WM_PASTE, 0, 0L);
 497 }
 498
 499 void wxComboBox::Undo()
 500 {
 501     if (CanUndo())
 502     {
 503         HWND hEditWnd = (HWND) GetEditHWND() ;
 504         if ( hEditWnd )
 505             ::SendMessage(hEditWnd, EM_UNDO, 0, 0);
 506     }
 507 }
 508
 509 void wxComboBox::Redo()
 510 {
 511     if (CanUndo())
 512     {
 513         // Same as Undo, since Undo undoes the undo, i.e. a redo.
 514         HWND hEditWnd = (HWND) GetEditHWND() ;
 515         if ( hEditWnd )
 516             ::SendMessage(hEditWnd, EM_UNDO, 0, 0);
 517     }
 518 }
 519
 520 void wxComboBox::SelectAll()
 521 {
 522     SetSelection(0, GetLastPosition());
 523 }
 524
 525 bool wxComboBox::CanUndo() const
 526 {
 527     HWND hEditWnd = (HWND) GetEditHWND() ;
 528     if ( hEditWnd )
 529         return ::SendMessage(hEditWnd, EM_CANUNDO, 0, 0) != 0;
 530     else
 531         return false;
 532 }
 533
 534 bool wxComboBox::CanRedo() const
 535 {
 536     HWND hEditWnd = (HWND) GetEditHWND() ;
 537     if ( hEditWnd )
 538         return ::SendMessage(hEditWnd, EM_CANUNDO, 0, 0) != 0;
 539     else
 540         return false;
 541 }
 542
 543 bool wxComboBox::HasSelection() const
 544 {
 545     long from, to;
 546     GetSelection(&from, &to);
 547     return from != to;
 548 }
 549
 550 bool wxComboBox::CanCopy() const
 551 {
 552     // Can copy if there's a selection
 553     return HasSelection();
 554 }
 555
 556 bool wxComboBox::CanCut() const
 557 {
 558     return CanCopy() && IsEditable();
 559 }
 560
 561 bool wxComboBox::CanPaste() const
 562 {
 563     if ( !IsEditable() )
 564         return false;
 565
 566     // Standard edit control: check for straight text on clipboard
 567     if ( !::OpenClipboard(GetHwndOf(wxTheApp->GetTopWindow())) )
 568         return false;
 569
 570     bool isTextAvailable = ::IsClipboardFormatAvailable(CF_TEXT) != 0;
 571     ::CloseClipboard();
 572
 573     return isTextAvailable;
 574 }
 575
 576 bool wxComboBox::IsEditable() const
 577 {
 578     return !HasFlag(wxCB_READONLY);
 579 }
 580
 581 void wxComboBox::SetEditable(bool WXUNUSED(editable))
 582 {
 583   // Can't implement in MSW?
 584 //  HWND hWnd = GetHwnd();
 585 //  SendMessage(hWnd, EM_SETREADONLY, (WPARAM)!editable, (LPARAM)0L);
 586 }
 587
 588 void wxComboBox::SetInsertionPoint(long pos)
 589 {
 590     if ( GetWindowStyle() & wxCB_READONLY )
 591         return;
 592
 593 #ifdef __WIN32__
 594     HWND hWnd = GetHwnd();
 595     ::SendMessage(hWnd, CB_SETEDITSEL, 0, MAKELPARAM(pos, pos));
 596     HWND hEditWnd = (HWND) GetEditHWND() ;
 597     if ( hEditWnd )
 598     {
 599         // Scroll insertion point into view
 600         SendMessage(hEditWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0);
 601         // Why is this necessary? (Copied from wxTextCtrl::SetInsertionPoint)
 602         SendMessage(hEditWnd, EM_REPLACESEL, 0, (LPARAM) wxEmptyString);
 603     }
 604 #endif // __WIN32__
 605 }
 606
 607 void wxComboBox::SetInsertionPointEnd()
 608 {
 609     // setting insertion point doesn't make sense for read only comboboxes
 610     if ( !(GetWindowStyle() & wxCB_READONLY) )
 611     {
 612         long pos = GetLastPosition();
 613         SetInsertionPoint(pos);
 614     }
 615 }
 616
 617 long wxComboBox::GetInsertionPoint() const
 618 {
 619 #ifdef __WIN32__
 620     DWORD Pos=(DWORD)SendMessage(GetHwnd(), CB_GETEDITSEL, 0, 0L);
 621     return Pos&0xFFFF;
 622 #else
 623     return 0;
 624 #endif
 625 }
 626
 627 long wxComboBox::GetLastPosition() const
 628 {
 629     HWND hEditWnd = (HWND) GetEditHWND();
 630
 631     // Get number of characters in the last (only) line. We'll add this to the character
 632     // index for the last line, 1st position.
 633     int lineLength = (int)SendMessage(hEditWnd, EM_LINELENGTH, (WPARAM) 0, (LPARAM)0L);
 634
 635     return (long)(lineLength);
 636 }
 637
 638 void wxComboBox::Replace(long from, long to, const wxString& value)
 639 {
 640 #if wxUSE_CLIPBOARD
 641     Remove(from, to);
 642
 643     // Now replace with 'value', by pasting.
 644     wxSetClipboardData(wxDF_TEXT, (wxObject *)(const wxChar *)value, 0, 0);
 645
 646     // Paste into edit control
 647     SendMessage(GetHwnd(), WM_PASTE, (WPARAM)0, (LPARAM)0L);
 648 #endif
 649 }
 650
 651 void wxComboBox::Remove(long from, long to)
 652 {
 653     // Set selection and remove it
 654     SetSelection(from, to);
 655     SendMessage(GetHwnd(), WM_CUT, (WPARAM)0, (LPARAM)0);
 656 }
 657
 658 void wxComboBox::SetSelection(long from, long to)
 659 {
 660     HWND hWnd = GetHwnd();
 661     long fromChar = from;
 662     long toChar = to;
 663     // if from and to are both -1, it means
 664     // (in wxWidgets) that all text should be selected.
 665     // This translates into Windows convention
 666     if ((from == -1) && (to == -1))
 667     {
 668       fromChar = 0;
 669       toChar = -1;
 670     }
 671
 672     if ( SendMessage(hWnd, CB_SETEDITSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar)) == CB_ERR )
 673     {
 674         wxLogDebug(_T("CB_SETEDITSEL failed"));
 675     }
 676 }
 677
 678 void wxComboBox::GetSelection(long* from, long* to) const
 679 {
 680     DWORD dwStart, dwEnd;
 681     ::SendMessage(GetHwnd(), CB_GETEDITSEL, (WPARAM)&dwStart, (LPARAM)&dwEnd);
 682
 683     *from = dwStart;
 684     *to = dwEnd;
 685 }
 686
 687 int wxComboBox::GetSelection() const
 688 {
 689     return wxChoice::GetSelection();
 690 }
 691
 692 // ----------------------------------------------------------------------------
 693 // standard event handling
 694 // ----------------------------------------------------------------------------
 695
 696 void wxComboBox::OnCut(wxCommandEvent& WXUNUSED(event))
 697 {
 698     Cut();
 699 }
 700
 701 void wxComboBox::OnCopy(wxCommandEvent& WXUNUSED(event))
 702 {
 703     Copy();
 704 }
 705
 706 void wxComboBox::OnPaste(wxCommandEvent& WXUNUSED(event))
 707 {
 708     Paste();
 709 }
 710
 711 void wxComboBox::OnUndo(wxCommandEvent& WXUNUSED(event))
 712 {
 713     Undo();
 714 }
 715
 716 void wxComboBox::OnRedo(wxCommandEvent& WXUNUSED(event))
 717 {
 718     Redo();
 719 }
 720
 721 void wxComboBox::OnDelete(wxCommandEvent& WXUNUSED(event))
 722 {
 723     long from, to;
 724     GetSelection(& from, & to);
 725     if (from != -1 && to != -1)
 726         Remove(from, to);
 727 }
 728
 729 void wxComboBox::OnSelectAll(wxCommandEvent& WXUNUSED(event))
 730 {
 731     SetSelection(-1, -1);
 732 }
 733
 734 void wxComboBox::OnUpdateCut(wxUpdateUIEvent& event)
 735 {
 736     event.Enable( CanCut() );
 737 }
 738
 739 void wxComboBox::OnUpdateCopy(wxUpdateUIEvent& event)
 740 {
 741     event.Enable( CanCopy() );
 742 }
 743
 744 void wxComboBox::OnUpdatePaste(wxUpdateUIEvent& event)
 745 {
 746     event.Enable( CanPaste() );
 747 }
 748
 749 void wxComboBox::OnUpdateUndo(wxUpdateUIEvent& event)
 750 {
 751     event.Enable( CanUndo() );
 752 }
 753
 754 void wxComboBox::OnUpdateRedo(wxUpdateUIEvent& event)
 755 {
 756     event.Enable( CanRedo() );
 757 }
 758
 759 void wxComboBox::OnUpdateDelete(wxUpdateUIEvent& event)
 760 {
 761     event.Enable(HasSelection() && IsEditable()) ;
 762 }
 763
 764 void wxComboBox::OnUpdateSelectAll(wxUpdateUIEvent& event)
 765 {
 766     event.Enable(GetLastPosition() > 0);
 767 }
 768
 769 #endif // wxUSE_COMBOBOX
 770