src/univ/combobox.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/univ/combobox.cpp
// Purpose:     wxComboBox implementation
// Author:      Vadim Zeitlin
// Modified by:
// Created:     15.12.00
// RCS-ID:      $Id$
// Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_COMBOBOX

#ifndef WX_PRECOMP
    #include "wx/log.h"

    #include "wx/button.h"
    #include "wx/combobox.h"
    #include "wx/listbox.h"
    #include "wx/textctrl.h"
    #include "wx/bmpbuttn.h"

    #include "wx/validate.h"
#endif

#include "wx/tooltip.h"
#include "wx/combo.h"

#include "wx/univ/renderer.h"
#include "wx/univ/inphand.h"
#include "wx/univ/theme.h"


// ----------------------------------------------------------------------------
// wxComboListBox is a listbox modified to be used as a popup window in a
// combobox
// ----------------------------------------------------------------------------

class wxComboListBox : public wxListBox, public wxComboPopup
{
public:
    // ctor and dtor
    wxComboListBox();
    virtual ~wxComboListBox();

    // implement wxComboPopup methods
    virtual bool Create(wxWindow* parent);
    virtual void SetStringValue(const wxString& s);
    virtual wxString GetStringValue() const;
    virtual wxWindow *GetControl() { return this; }
    virtual void OnPopup();
    virtual wxSize GetAdjustedSize(int minWidth, int prefHeight, int maxHeight);

    // fix virtual function hiding
    virtual void SetSelection(int n) { DoSetSelection(n, true); }
    void SetSelection(int n, bool select) { DoSetSelection(n, select); }

    // used to process wxUniv actions
    bool PerformAction(const wxControlAction& action,
                       long numArg,
                       const wxString& strArg);

protected:
    // set m_clicked value from here
    void OnLeftUp(wxMouseEvent& event);

private:
    DECLARE_EVENT_TABLE()
};

// ----------------------------------------------------------------------------
// event tables and such
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(wxComboListBox, wxListBox)
    EVT_LEFT_UP(wxComboListBox::OnLeftUp)
END_EVENT_TABLE()

IMPLEMENT_DYNAMIC_CLASS2(wxComboBox, wxControl, wxComboCtrl)

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxComboListBox
// ----------------------------------------------------------------------------

wxComboListBox::wxComboListBox() : wxListBox(), wxComboPopup()
{
}

bool wxComboListBox::Create(wxWindow* parent)
{
    if ( !wxListBox::Create(parent, wxID_ANY,
                            wxDefaultPosition, wxDefaultSize,
                            0, NULL,
                            wxBORDER_SIMPLE | wxLB_INT_HEIGHT |
                            m_combo->GetWindowStyle() & wxCB_SORT ? wxLB_SORT : 0) )
        return false;

    // we don't react to the mouse events outside the window at all
    StopAutoScrolling();

    return true;
}

wxComboListBox::~wxComboListBox()
{
}

wxString wxComboListBox::GetStringValue() const
{
    return wxListBox::GetStringSelection();
}

void wxComboListBox::SetStringValue(const wxString& value)
{
    if ( !value.empty() )
    {
		if (FindString(value) != wxNOT_FOUND)
        	wxListBox::SetStringSelection(value);
	}
    else
        wxListBox::SetSelection(-1);
}

void wxComboListBox::OnPopup()
{
}

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

{
    if ( action == wxACTION_LISTBOX_FIND )
    {
        // we don't let the listbox handle this as instead of just using the
        // single key presses, as usual, we use the text ctrl value as prefix
        // and this is done by wxComboCtrl itself
        return true;
    }

    return wxListBox::PerformAction(action, numArg, strArg);
}

void wxComboListBox::OnLeftUp(wxMouseEvent& event)
{
    // we should dismiss the combo now
    // first update the combo and close the listbox
    Dismiss();
    m_combo->SetValue(wxListBox::GetStringSelection());

    // next let the user code have the event
    wxCommandEvent evt(wxEVT_COMMAND_COMBOBOX_SELECTED,m_combo->GetId());
    evt.SetInt(wxListBox::GetSelection());
    evt.SetEventObject(m_combo);
    m_combo->ProcessEvent(evt);

    event.Skip();
}

wxSize wxComboListBox::GetAdjustedSize(int minWidth,
                                       int WXUNUSED(prefHeight),
                                       int maxHeight)
{
    wxSize bestSize = wxListBox::GetBestSize();
    return wxSize(wxMax(bestSize.x,minWidth),
                  wxMin(bestSize.y,maxHeight));
}

// ----------------------------------------------------------------------------
// wxComboBox
// ----------------------------------------------------------------------------

void wxComboBox::Init()
{
    m_lbox = (wxListBox *)NULL;
}

wxComboBox::wxComboBox(wxWindow *parent,
                       wxWindowID id,
                       const wxString& value,
                       const wxPoint& pos,
                       const wxSize& size,
                       const wxArrayString& choices,
                       long style,
                       const wxValidator& validator,
                       const wxString& name)
{
    Init();

    Create(parent, id, value, pos, size, choices, style, validator, name);
}

bool wxComboBox::Create(wxWindow *parent,
                        wxWindowID id,
                        const wxString& value,
                        const wxPoint& pos,
                        const wxSize& size,
                        const wxArrayString& choices,
                        long style,
                        const wxValidator& validator,
                        const wxString& name)
{
    wxCArrayString chs(choices);

    return Create(parent, id, value, pos, size, chs.GetCount(),
                  chs.GetStrings(), style, validator, name);
}

bool wxComboBox::Create(wxWindow *parent,
                        wxWindowID id,
                        const wxString& value,
                        const wxPoint& pos,
                        const wxSize& size,
                        int n,
                        const wxString choices[],
                        long style,
                        const wxValidator& validator,
                        const wxString& name)
{
    if ( !wxComboCtrl::Create(parent, id, value, pos, size, style,
                                 validator, name) )
    {
        return false;
    }

    wxComboListBox *combolbox = new wxComboListBox();
    SetPopupControl(combolbox);

    m_lbox = combolbox;
    m_lbox->Set(n, choices);

    return true;
}

wxComboBox::~wxComboBox()
{
}

// ----------------------------------------------------------------------------
// wxComboBox methods forwarded to wxTextCtrl
// ----------------------------------------------------------------------------

wxString wxComboBox::GetValue() const
{
    return wxComboCtrl::GetValue();
}

void wxComboBox::SetValue(const wxString& value)
{
    wxComboCtrl::SetValue(value);
}

void wxComboBox::Copy()
{
    if ( GetTextCtrl() ) GetTextCtrl()->Copy();
}

void wxComboBox::Cut()
{
    if ( GetTextCtrl() ) GetTextCtrl()->Cut();
}

void wxComboBox::Paste()
{
    if ( GetTextCtrl() ) GetTextCtrl()->Paste();
}

void wxComboBox::SetInsertionPoint(long pos)
{
    if ( GetTextCtrl() ) GetTextCtrl()->SetInsertionPoint(pos);
}

void wxComboBox::SetInsertionPointEnd()
{
    if ( GetTextCtrl() ) GetTextCtrl()->SetInsertionPointEnd();
}

long wxComboBox::GetInsertionPoint() const
{
    if ( GetTextCtrl() )
        return GetTextCtrl()->GetInsertionPoint();
    return -1;
}

wxTextPos wxComboBox::GetLastPosition() const
{
    if ( GetTextCtrl() )
        return GetTextCtrl()->GetLastPosition();
    return -1;
}

void wxComboBox::Replace(long from, long to, const wxString& value)
{
    if ( GetTextCtrl() ) GetTextCtrl()->Replace(from, to, value);
}

void wxComboBox::Remove(long from, long to)
{
    if ( GetTextCtrl() ) GetTextCtrl()->Remove(from, to);
}

void wxComboBox::SetSelection(long from, long to)
{
    if ( GetTextCtrl() ) GetTextCtrl()->SetSelection(from, to);
}

void wxComboBox::SetEditable(bool editable)
{
    if ( GetTextCtrl() ) GetTextCtrl()->SetEditable(editable);
}

// ----------------------------------------------------------------------------
// wxComboBox methods forwarded to wxListBox
// ----------------------------------------------------------------------------

void wxComboBox::Clear()
{
    GetLBox()->Clear();
    if ( GetTextCtrl() ) GetTextCtrl()->SetValue(wxEmptyString);
}

void wxComboBox::Delete(unsigned int n)
{
    wxCHECK_RET( IsValid(n), _T("invalid index in wxComboBox::Delete") );

    if (GetSelection() == (int)n)
        if ( GetTextCtrl() ) GetTextCtrl()->SetValue(wxEmptyString);

    GetLBox()->Delete(n);
}

unsigned int wxComboBox::GetCount() const
{
    return GetLBox()->GetCount();
}

wxString wxComboBox::GetString(unsigned int n) const
{
    wxCHECK_MSG( IsValid(n), wxEmptyString, _T("invalid index in wxComboBox::GetString") );

    return GetLBox()->GetString(n);
}

void wxComboBox::SetString(unsigned int n, const wxString& s)
{
    wxCHECK_RET( IsValid(n), _T("invalid index in wxComboBox::SetString") );

    GetLBox()->SetString(n, s);
}

int wxComboBox::FindString(const wxString& s, bool bCase) const
{
    return GetLBox()->FindString(s, bCase);
}

void wxComboBox::SetSelection(int n)
{
    wxCHECK_RET( IsValid(n), _T("invalid index in wxComboBox::Select") );

    GetLBox()->SetSelection(n);
    if ( GetTextCtrl() ) GetTextCtrl()->SetValue(GetLBox()->GetString(n));
}

int wxComboBox::GetSelection() const
{
#if 1 // FIXME:: What is the correct behavior?
    // if the current value isn't one of the listbox strings, return -1
    return GetLBox()->GetSelection();
#else
    // Why oh why is this done this way?
    // It is not because the value displayed in the text can be found
    // in the list that it is the item that is selected!
    return FindString(if ( GetTextCtrl() ) GetTextCtrl()->GetValue());
#endif
}

int wxComboBox::DoAppend(const wxString& item)
{
    return GetLBox()->Append(item);
}

int wxComboBox::DoInsert(const wxString& item, unsigned int pos)
{
    wxCHECK_MSG(!(GetWindowStyle() & wxCB_SORT), -1, wxT("can't insert into sorted list"));
    wxCHECK_MSG(IsValidInsert(pos), -1, wxT("invalid index"));

    if (pos == GetCount())
        return DoAppend(item);

    GetLBox()->Insert(item, pos);
    return pos;
}

void wxComboBox::DoSetItemClientData(unsigned int n, void* clientData)
{
    GetLBox()->SetClientData(n, clientData);
}

void *wxComboBox::DoGetItemClientData(unsigned int n) const
{
    return GetLBox()->GetClientData(n);
}

void wxComboBox::DoSetItemClientObject(unsigned int n, wxClientData* clientData)
{
    GetLBox()->SetClientObject(n, clientData);
}

wxClientData* wxComboBox::DoGetItemClientObject(unsigned int n) const
{
    return GetLBox()->GetClientObject(n);
}

bool wxComboBox::IsEditable() const
{
    return GetTextCtrl() != NULL && (!HasFlag(wxCB_READONLY) || GetTextCtrl()->IsEditable() );
}

void wxComboBox::Undo()
{
    if (IsEditable())
        if ( GetTextCtrl() ) GetTextCtrl()->Undo();
}

void wxComboBox::Redo()
{
    if (IsEditable())
        if ( GetTextCtrl() ) GetTextCtrl()->Redo();
}

void wxComboBox::SelectAll()
{
    if ( GetTextCtrl() ) GetTextCtrl()->SelectAll();
}

bool wxComboBox::CanCopy() const
{
    if (GetTextCtrl() != NULL)
        return GetTextCtrl()->CanCopy();
    else
        return false;
}

bool wxComboBox::CanCut() const
{
    if (GetTextCtrl() != NULL)
        return GetTextCtrl()->CanCut();
    else
        return false;
}

bool wxComboBox::CanPaste() const
{
    if (IsEditable())
        return GetTextCtrl()->CanPaste();
    else
        return false;
}

bool wxComboBox::CanUndo() const
{
    if (IsEditable())
        return GetTextCtrl()->CanUndo();
    else
        return false;
}

bool wxComboBox::CanRedo() const
{
    if (IsEditable())
        return GetTextCtrl()->CanRedo();
    else
        return false;
}


// ----------------------------------------------------------------------------
// wxStdComboBoxInputHandler
// ----------------------------------------------------------------------------

wxStdComboBoxInputHandler::wxStdComboBoxInputHandler(wxInputHandler *inphand)
                         : wxStdInputHandler(inphand)
{
}

bool wxStdComboBoxInputHandler::HandleKey(wxInputConsumer *consumer,
                                          const wxKeyEvent& event,
                                          bool pressed)
{
    if ( pressed )
    {
        wxControlAction action;
        switch ( event.GetKeyCode() )
        {
            case WXK_DOWN:
                action = wxACTION_COMBOBOX_POPUP;
                break;

            case WXK_ESCAPE:
                action = wxACTION_COMBOBOX_DISMISS;
                break;
        }

        if ( !action.IsEmpty() )
        {
            consumer->PerformAction(action);

            return true;
        }
    }

    return wxStdInputHandler::HandleKey(consumer, event, pressed);
}


#endif // wxUSE_COMBOBOX
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/univ/combobox.cpp
	3	// Purpose: wxComboBox implementation
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 15.12.00
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#include "wx/wxprec.h"
	21
	22	#ifdef __BORLANDC__
	23	#pragma hdrstop
	24	#endif
	25
	26	#if wxUSE_COMBOBOX
	27
	28	#ifndef WX_PRECOMP
	29	#include "wx/log.h"
	30
	31	#include "wx/button.h"
	32	#include "wx/combobox.h"
	33	#include "wx/listbox.h"
	34	#include "wx/textctrl.h"
	35	#include "wx/bmpbuttn.h"
	36
	37	#include "wx/validate.h"
	38	#endif
	39
	40	#include "wx/tooltip.h"
	41	#include "wx/combo.h"
	42
	43	#include "wx/univ/renderer.h"
	44	#include "wx/univ/inphand.h"
	45	#include "wx/univ/theme.h"
	46
	47
	48	// ----------------------------------------------------------------------------
	49	// wxComboListBox is a listbox modified to be used as a popup window in a
	50	// combobox
	51	// ----------------------------------------------------------------------------
	52
	53	class wxComboListBox : public wxListBox, public wxComboPopup
	54	{
	55	public:
	56	// ctor and dtor
	57	wxComboListBox();
	58	virtual ~wxComboListBox();
	59
	60	// implement wxComboPopup methods
	61	virtual bool Create(wxWindow* parent);
	62	virtual void SetStringValue(const wxString& s);
	63	virtual wxString GetStringValue() const;
	64	virtual wxWindow *GetControl() { return this; }
	65	virtual void OnPopup();
	66	virtual wxSize GetAdjustedSize(int minWidth, int prefHeight, int maxHeight);
	67
	68	// fix virtual function hiding
	69	virtual void SetSelection(int n) { DoSetSelection(n, true); }
	70	void SetSelection(int n, bool select) { DoSetSelection(n, select); }
	71
	72	// used to process wxUniv actions
	73	bool PerformAction(const wxControlAction& action,
	74	long numArg,
	75	const wxString& strArg);
	76
	77	protected:
	78	// set m_clicked value from here
	79	void OnLeftUp(wxMouseEvent& event);
	80
	81	private:
	82	DECLARE_EVENT_TABLE()
	83	};
	84
	85	// ----------------------------------------------------------------------------
	86	// event tables and such
	87	// ----------------------------------------------------------------------------
	88
	89	BEGIN_EVENT_TABLE(wxComboListBox, wxListBox)
	90	EVT_LEFT_UP(wxComboListBox::OnLeftUp)
	91	END_EVENT_TABLE()
	92
	93	IMPLEMENT_DYNAMIC_CLASS2(wxComboBox, wxControl, wxComboCtrl)
	94
	95	// ============================================================================
	96	// implementation
	97	// ============================================================================
	98
	99	// ----------------------------------------------------------------------------
	100	// wxComboListBox
	101	// ----------------------------------------------------------------------------
	102
	103	wxComboListBox::wxComboListBox() : wxListBox(), wxComboPopup()
	104	{
	105	}
	106
	107	bool wxComboListBox::Create(wxWindow* parent)
	108	{
	109	if ( !wxListBox::Create(parent, wxID_ANY,
	110	wxDefaultPosition, wxDefaultSize,
	111	0, NULL,
	112	wxBORDER_SIMPLE \| wxLB_INT_HEIGHT \|
	113	m_combo->GetWindowStyle() & wxCB_SORT ? wxLB_SORT : 0) )
	114	return false;
	115
	116	// we don't react to the mouse events outside the window at all
	117	StopAutoScrolling();
	118
	119	return true;
	120	}
	121
	122	wxComboListBox::~wxComboListBox()
	123	{
	124	}
	125
	126	wxString wxComboListBox::GetStringValue() const
	127	{
	128	return wxListBox::GetStringSelection();
	129	}
	130
	131	void wxComboListBox::SetStringValue(const wxString& value)
	132	{
	133	if ( !value.empty() )
	134	{
	135	if (FindString(value) != wxNOT_FOUND)
	136	wxListBox::SetStringSelection(value);
	137	}
	138	else
	139	wxListBox::SetSelection(-1);
	140	}
	141
	142	void wxComboListBox::OnPopup()
	143	{
	144	}
	145
	146	bool wxComboListBox::PerformAction(const wxControlAction& action,
	147	long numArg,
	148	const wxString& strArg)
	149
	150	{
	151	if ( action == wxACTION_LISTBOX_FIND )
	152	{
	153	// we don't let the listbox handle this as instead of just using the
	154	// single key presses, as usual, we use the text ctrl value as prefix
	155	// and this is done by wxComboCtrl itself
	156	return true;
	157	}
	158
	159	return wxListBox::PerformAction(action, numArg, strArg);
	160	}
	161
	162	void wxComboListBox::OnLeftUp(wxMouseEvent& event)
	163	{
	164	// we should dismiss the combo now
	165	// first update the combo and close the listbox
	166	Dismiss();
	167	m_combo->SetValue(wxListBox::GetStringSelection());
	168
	169	// next let the user code have the event
	170	wxCommandEvent evt(wxEVT_COMMAND_COMBOBOX_SELECTED,m_combo->GetId());
	171	evt.SetInt(wxListBox::GetSelection());
	172	evt.SetEventObject(m_combo);
	173	m_combo->ProcessEvent(evt);
	174
	175	event.Skip();
	176	}
	177
	178	wxSize wxComboListBox::GetAdjustedSize(int minWidth,
	179	int WXUNUSED(prefHeight),
	180	int maxHeight)
	181	{
	182	wxSize bestSize = wxListBox::GetBestSize();
	183	return wxSize(wxMax(bestSize.x,minWidth),
	184	wxMin(bestSize.y,maxHeight));
	185	}
	186
	187	// ----------------------------------------------------------------------------
	188	// wxComboBox
	189	// ----------------------------------------------------------------------------
	190
	191	void wxComboBox::Init()
	192	{
	193	m_lbox = (wxListBox *)NULL;
	194	}
	195
	196	wxComboBox::wxComboBox(wxWindow *parent,
	197	wxWindowID id,
	198	const wxString& value,
	199	const wxPoint& pos,
	200	const wxSize& size,
	201	const wxArrayString& choices,
	202	long style,
	203	const wxValidator& validator,
	204	const wxString& name)
	205	{
	206	Init();
	207
	208	Create(parent, id, value, pos, size, choices, style, validator, name);
	209	}
	210
	211	bool wxComboBox::Create(wxWindow *parent,
	212	wxWindowID id,
	213	const wxString& value,
	214	const wxPoint& pos,
	215	const wxSize& size,
	216	const wxArrayString& choices,
	217	long style,
	218	const wxValidator& validator,
	219	const wxString& name)
	220	{
	221	wxCArrayString chs(choices);
	222
	223	return Create(parent, id, value, pos, size, chs.GetCount(),
	224	chs.GetStrings(), style, validator, name);
	225	}
	226
	227	bool wxComboBox::Create(wxWindow *parent,
	228	wxWindowID id,
	229	const wxString& value,
	230	const wxPoint& pos,
	231	const wxSize& size,
	232	int n,
	233	const wxString choices[],
	234	long style,
	235	const wxValidator& validator,
	236	const wxString& name)
	237	{
	238	if ( !wxComboCtrl::Create(parent, id, value, pos, size, style,
	239	validator, name) )
	240	{
	241	return false;
	242	}
	243
	244	wxComboListBox *combolbox = new wxComboListBox();
	245	SetPopupControl(combolbox);
	246
	247	m_lbox = combolbox;
	248	m_lbox->Set(n, choices);
	249
	250	return true;
	251	}
	252
	253	wxComboBox::~wxComboBox()
	254	{
	255	}
	256
	257	// ----------------------------------------------------------------------------
	258	// wxComboBox methods forwarded to wxTextCtrl
	259	// ----------------------------------------------------------------------------
	260
	261	wxString wxComboBox::GetValue() const
	262	{
	263	return wxComboCtrl::GetValue();
	264	}
	265
	266	void wxComboBox::SetValue(const wxString& value)
	267	{
	268	wxComboCtrl::SetValue(value);
	269	}
	270
	271	void wxComboBox::Copy()
	272	{
	273	if ( GetTextCtrl() ) GetTextCtrl()->Copy();
	274	}
	275
	276	void wxComboBox::Cut()
	277	{
	278	if ( GetTextCtrl() ) GetTextCtrl()->Cut();
	279	}
	280
	281	void wxComboBox::Paste()
	282	{
	283	if ( GetTextCtrl() ) GetTextCtrl()->Paste();
	284	}
	285
	286	void wxComboBox::SetInsertionPoint(long pos)
	287	{
	288	if ( GetTextCtrl() ) GetTextCtrl()->SetInsertionPoint(pos);
	289	}
	290
	291	void wxComboBox::SetInsertionPointEnd()
	292	{
	293	if ( GetTextCtrl() ) GetTextCtrl()->SetInsertionPointEnd();
	294	}
	295
	296	long wxComboBox::GetInsertionPoint() const
	297	{
	298	if ( GetTextCtrl() )
	299	return GetTextCtrl()->GetInsertionPoint();
	300	return -1;
	301	}
	302
	303	wxTextPos wxComboBox::GetLastPosition() const
	304	{
	305	if ( GetTextCtrl() )
	306	return GetTextCtrl()->GetLastPosition();
	307	return -1;
	308	}
	309
	310	void wxComboBox::Replace(long from, long to, const wxString& value)
	311	{
	312	if ( GetTextCtrl() ) GetTextCtrl()->Replace(from, to, value);
	313	}
	314
	315	void wxComboBox::Remove(long from, long to)
	316	{
	317	if ( GetTextCtrl() ) GetTextCtrl()->Remove(from, to);
	318	}
	319
	320	void wxComboBox::SetSelection(long from, long to)
	321	{
	322	if ( GetTextCtrl() ) GetTextCtrl()->SetSelection(from, to);
	323	}
	324
	325	void wxComboBox::SetEditable(bool editable)
	326	{
	327	if ( GetTextCtrl() ) GetTextCtrl()->SetEditable(editable);
	328	}
	329
	330	// ----------------------------------------------------------------------------
	331	// wxComboBox methods forwarded to wxListBox
	332	// ----------------------------------------------------------------------------
	333
	334	void wxComboBox::Clear()
	335	{
	336	GetLBox()->Clear();
	337	if ( GetTextCtrl() ) GetTextCtrl()->SetValue(wxEmptyString);
	338	}
	339
	340	void wxComboBox::Delete(unsigned int n)
	341	{
	342	wxCHECK_RET( IsValid(n), _T("invalid index in wxComboBox::Delete") );
	343
	344	if (GetSelection() == (int)n)
	345	if ( GetTextCtrl() ) GetTextCtrl()->SetValue(wxEmptyString);
	346
	347	GetLBox()->Delete(n);
	348	}
	349
	350	unsigned int wxComboBox::GetCount() const
	351	{
	352	return GetLBox()->GetCount();
	353	}
	354
	355	wxString wxComboBox::GetString(unsigned int n) const
	356	{
	357	wxCHECK_MSG( IsValid(n), wxEmptyString, _T("invalid index in wxComboBox::GetString") );
	358
	359	return GetLBox()->GetString(n);
	360	}
	361
	362	void wxComboBox::SetString(unsigned int n, const wxString& s)
	363	{
	364	wxCHECK_RET( IsValid(n), _T("invalid index in wxComboBox::SetString") );
	365
	366	GetLBox()->SetString(n, s);
	367	}
	368
	369	int wxComboBox::FindString(const wxString& s, bool bCase) const
	370	{
	371	return GetLBox()->FindString(s, bCase);
	372	}
	373
	374	void wxComboBox::SetSelection(int n)
	375	{
	376	wxCHECK_RET( IsValid(n), _T("invalid index in wxComboBox::Select") );
	377
	378	GetLBox()->SetSelection(n);
	379	if ( GetTextCtrl() ) GetTextCtrl()->SetValue(GetLBox()->GetString(n));
	380	}
	381
	382	int wxComboBox::GetSelection() const
	383	{
	384	#if 1 // FIXME:: What is the correct behavior?
	385	// if the current value isn't one of the listbox strings, return -1
	386	return GetLBox()->GetSelection();
	387	#else
	388	// Why oh why is this done this way?
	389	// It is not because the value displayed in the text can be found
	390	// in the list that it is the item that is selected!
	391	return FindString(if ( GetTextCtrl() ) GetTextCtrl()->GetValue());
	392	#endif
	393	}
	394
	395	int wxComboBox::DoAppend(const wxString& item)
	396	{
	397	return GetLBox()->Append(item);
	398	}
	399
	400	int wxComboBox::DoInsert(const wxString& item, unsigned int pos)
	401	{
	402	wxCHECK_MSG(!(GetWindowStyle() & wxCB_SORT), -1, wxT("can't insert into sorted list"));
	403	wxCHECK_MSG(IsValidInsert(pos), -1, wxT("invalid index"));
	404
	405	if (pos == GetCount())
	406	return DoAppend(item);
	407
	408	GetLBox()->Insert(item, pos);
	409	return pos;
	410	}
	411
	412	void wxComboBox::DoSetItemClientData(unsigned int n, void* clientData)
	413	{
	414	GetLBox()->SetClientData(n, clientData);
	415	}
	416
	417	void *wxComboBox::DoGetItemClientData(unsigned int n) const
	418	{
	419	return GetLBox()->GetClientData(n);
	420	}
	421
	422	void wxComboBox::DoSetItemClientObject(unsigned int n, wxClientData* clientData)
	423	{
	424	GetLBox()->SetClientObject(n, clientData);
	425	}
	426
	427	wxClientData* wxComboBox::DoGetItemClientObject(unsigned int n) const
	428	{
	429	return GetLBox()->GetClientObject(n);
	430	}
	431
	432	bool wxComboBox::IsEditable() const
	433	{
	434	return GetTextCtrl() != NULL && (!HasFlag(wxCB_READONLY) \|\| GetTextCtrl()->IsEditable() );
	435	}
	436
	437	void wxComboBox::Undo()
	438	{
	439	if (IsEditable())
	440	if ( GetTextCtrl() ) GetTextCtrl()->Undo();
	441	}
	442
	443	void wxComboBox::Redo()
	444	{
	445	if (IsEditable())
	446	if ( GetTextCtrl() ) GetTextCtrl()->Redo();
	447	}
	448
	449	void wxComboBox::SelectAll()
	450	{
	451	if ( GetTextCtrl() ) GetTextCtrl()->SelectAll();
	452	}
	453
	454	bool wxComboBox::CanCopy() const
	455	{
	456	if (GetTextCtrl() != NULL)
	457	return GetTextCtrl()->CanCopy();
	458	else
	459	return false;
	460	}
	461
	462	bool wxComboBox::CanCut() const
	463	{
	464	if (GetTextCtrl() != NULL)
	465	return GetTextCtrl()->CanCut();
	466	else
	467	return false;
	468	}
	469
	470	bool wxComboBox::CanPaste() const
	471	{
	472	if (IsEditable())
	473	return GetTextCtrl()->CanPaste();
	474	else
	475	return false;
	476	}
	477
	478	bool wxComboBox::CanUndo() const
	479	{
	480	if (IsEditable())
	481	return GetTextCtrl()->CanUndo();
	482	else
	483	return false;
	484	}
	485
	486	bool wxComboBox::CanRedo() const
	487	{
	488	if (IsEditable())
	489	return GetTextCtrl()->CanRedo();
	490	else
	491	return false;
	492	}
	493
	494
	495	// ----------------------------------------------------------------------------
	496	// wxStdComboBoxInputHandler
	497	// ----------------------------------------------------------------------------
	498
	499	wxStdComboBoxInputHandler::wxStdComboBoxInputHandler(wxInputHandler *inphand)
	500	: wxStdInputHandler(inphand)
	501	{
	502	}
	503
	504	bool wxStdComboBoxInputHandler::HandleKey(wxInputConsumer *consumer,
	505	const wxKeyEvent& event,
	506	bool pressed)
	507	{
	508	if ( pressed )
	509	{
	510	wxControlAction action;
	511	switch ( event.GetKeyCode() )
	512	{
	513	case WXK_DOWN:
	514	action = wxACTION_COMBOBOX_POPUP;
	515	break;
	516
	517	case WXK_ESCAPE:
	518	action = wxACTION_COMBOBOX_DISMISS;
	519	break;
	520	}
	521
	522	if ( !action.IsEmpty() )
	523	{
	524	consumer->PerformAction(action);
	525
	526	return true;
	527	}
	528	}
	529
	530	return wxStdInputHandler::HandleKey(consumer, event, pressed);
	531	}
	532
	533
	534	#endif // wxUSE_COMBOBOX