[wxWidgets.git] / src / generic / editlbox.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/generic/editlbox.cpp
// Purpose:     ListBox with editable items
// Author:      Vaclav Slavik
// Copyright:   (c) Vaclav Slavik
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_EDITABLELISTBOX

// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWidgets headers)
#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include "wx/editlbox.h"
#include "wx/sizer.h"
#include "wx/listctrl.h"

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

const char wxEditableListBoxNameStr[] = "editableListBox";

static const char* const eledit_xpm[] = {
"16 16 3 1",
"   c None",
".  c #000000",
"+  c #00007F",
"                ",
"                ",
"      .. ..     ",
"        .       ",
"        .       ",
"  ++++  .  ++++ ",
"     ++ . ++  ++",
"  +++++ . ++++++",
" ++  ++ . ++    ",
" ++  ++ . ++  ++",
"  +++++ .  ++++ ",
"        .       ",
"        .       ",
"      .. ..     ",
"                ",
"                "};

static const char* const elnew_xpm[] = {
"16 16 5 1",
"   c None",
".  c #7F7F7F",
"+  c #FFFFFF",
"@  c #FFFF00",
"#  c #000000",
"                ",
"                ",
" .  .+ .@       ",
"  . .@.@# # #   ",
"  @.@+....   #  ",
" ... @@         ",
"  @ . @.     #  ",
" .# .@          ",
"    .        #  ",
"  #             ",
"             #  ",
"  #             ",
"             #  ",
"  # # # # # #   ",
"                ",
"                "};

static const char* const eldel_xpm[] = {
"16 16 3 1",
"   c None",
".  c #7F0000",
"+  c #FFFFFF",
"                ",
"                ",
"                ",
" ..+        ..+ ",
" ....+     ..+  ",
"  ....+   ..+   ",
"    ...+ .+     ",
"     .....+     ",
"      ...+      ",
"     .....+     ",
"    ...+ ..+    ",
"   ...+   ..+   ",
"  ...+     .+   ",
"  ...+      .+  ",
"   .         .  ",
"                "};

static const char* const eldown_xpm[] = {
"16 16 2 1",
"   c None",
".  c #000000",
"                ",
"                ",
"         ...    ",
"        ...     ",
"       ...      ",
"       ...      ",
"       ...      ",
"       ...      ",
"   ...........  ",
"    .........   ",
"     .......    ",
"      .....     ",
"       ...      ",
"        .       ",
"                ",
"                "};

static const char* const elup_xpm[] = {
"16 16 2 1",
"   c None",
".  c #000000",
"                ",
"        .       ",
"       ...      ",
"      .....     ",
"     .......    ",
"    .........   ",
"   ...........  ",
"       ...      ",
"       ...      ",
"       ...      ",
"       ...      ",
"      ...       ",
"     ...        ",
"                ",
"                ",
"                "};

// list control with auto-resizable column:
class CleverListCtrl : public wxListCtrl
{
public:
   CleverListCtrl(wxWindow *parent,
                  wxWindowID id = wxID_ANY,
                  const wxPoint &pos = wxDefaultPosition,
                  const wxSize &size = wxDefaultSize,
                  long style = wxLC_ICON,
                  const wxValidator& validator = wxDefaultValidator,
                  const wxString &name = wxListCtrlNameStr)
         : wxListCtrl(parent, id, pos, size, style, validator, name)
    {
        CreateColumns();
    }

    void CreateColumns()
    {
        InsertColumn(0, wxT("item"));
        SizeColumns();
    }

    void SizeColumns()
    {
         int w = GetSize().x;
#ifdef __WXMSW__
         w -= wxSystemSettings::GetMetric(wxSYS_VSCROLL_X) + 6;
#else
         w -= 2*wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
#endif
         if (w < 0) w = 0;
         SetColumnWidth(0, w);
    }

private:
    DECLARE_EVENT_TABLE()
    void OnSize(wxSizeEvent& event)
    {
        SizeColumns();
        event.Skip();
    }
};

BEGIN_EVENT_TABLE(CleverListCtrl, wxListCtrl)
   EVT_SIZE(CleverListCtrl::OnSize)
END_EVENT_TABLE()


// ----------------------------------------------------------------------------
// wxEditableListBox
// ----------------------------------------------------------------------------

IMPLEMENT_CLASS(wxEditableListBox, wxPanel)

// NB: generate the IDs at runtime to avoid conflict with XRCID values,
//     they could cause XRCCTRL() failures in XRC-based dialogs
const wxWindowIDRef wxID_ELB_DELETE = wxWindow::NewControlId();
const wxWindowIDRef wxID_ELB_EDIT = wxWindow::NewControlId();
const wxWindowIDRef wxID_ELB_NEW = wxWindow::NewControlId();
const wxWindowIDRef wxID_ELB_UP = wxWindow::NewControlId();
const wxWindowIDRef wxID_ELB_DOWN = wxWindow::NewControlId();
const wxWindowIDRef wxID_ELB_LISTCTRL = wxWindow::NewControlId();

BEGIN_EVENT_TABLE(wxEditableListBox, wxPanel)
    EVT_LIST_ITEM_SELECTED(wxID_ELB_LISTCTRL, wxEditableListBox::OnItemSelected)
    EVT_LIST_END_LABEL_EDIT(wxID_ELB_LISTCTRL, wxEditableListBox::OnEndLabelEdit)
    EVT_BUTTON(wxID_ELB_NEW, wxEditableListBox::OnNewItem)
    EVT_BUTTON(wxID_ELB_UP, wxEditableListBox::OnUpItem)
    EVT_BUTTON(wxID_ELB_DOWN, wxEditableListBox::OnDownItem)
    EVT_BUTTON(wxID_ELB_EDIT, wxEditableListBox::OnEditItem)
    EVT_BUTTON(wxID_ELB_DELETE, wxEditableListBox::OnDelItem)
END_EVENT_TABLE()

bool wxEditableListBox::Create(wxWindow *parent, wxWindowID id,
                          const wxString& label,
                          const wxPoint& pos, const wxSize& size,
                          long style,
                          const wxString& name)
{
    if (!wxPanel::Create(parent, id, pos, size, wxTAB_TRAVERSAL, name))
        return false;

    m_style = style;

    wxSizer *sizer = new wxBoxSizer(wxVERTICAL);

    wxPanel *subp = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize,
                                wxSUNKEN_BORDER | wxTAB_TRAVERSAL);
    wxSizer *subsizer = new wxBoxSizer(wxHORIZONTAL);
    subsizer->Add(new wxStaticText(subp, wxID_ANY, label), 1, wxALIGN_CENTRE_VERTICAL | wxLEFT, 4);

#ifdef __WXMSW__
    #define BTN_BORDER 4
    // FIXME - why is this needed? There's some reason why sunken border is
    //         ignored by sizers in wxMSW but not in wxGTK that I can't
    //         figure out...
#else
    #define BTN_BORDER 0
#endif

    if ( m_style & wxEL_ALLOW_EDIT )
    {
        m_bEdit = new wxBitmapButton(subp, wxID_ELB_EDIT, wxBitmap(eledit_xpm));
        subsizer->Add(m_bEdit, 0, wxALIGN_CENTRE_VERTICAL | wxTOP | wxBOTTOM, BTN_BORDER);
    }

    if ( m_style & wxEL_ALLOW_NEW )
    {
        m_bNew = new wxBitmapButton(subp, wxID_ELB_NEW, wxBitmap(elnew_xpm));
        subsizer->Add(m_bNew, 0, wxALIGN_CENTRE_VERTICAL | wxTOP | wxBOTTOM, BTN_BORDER);
    }

    if ( m_style & wxEL_ALLOW_DELETE )
    {
        m_bDel = new wxBitmapButton(subp, wxID_ELB_DELETE, wxBitmap(eldel_xpm));
        subsizer->Add(m_bDel, 0, wxALIGN_CENTRE_VERTICAL | wxTOP | wxBOTTOM, BTN_BORDER);
    }

    if (!(m_style & wxEL_NO_REORDER))
    {
        m_bUp = new wxBitmapButton(subp, wxID_ELB_UP, wxBitmap(elup_xpm));
        subsizer->Add(m_bUp, 0, wxALIGN_CENTRE_VERTICAL | wxTOP | wxBOTTOM, BTN_BORDER);

        m_bDown = new wxBitmapButton(subp, wxID_ELB_DOWN, wxBitmap(eldown_xpm));
        subsizer->Add(m_bDown, 0, wxALIGN_CENTRE_VERTICAL | wxTOP | wxBOTTOM, BTN_BORDER);
    }

#if wxUSE_TOOLTIPS
    if ( m_bEdit ) m_bEdit->SetToolTip(_("Edit item"));
    if ( m_bNew ) m_bNew->SetToolTip(_("New item"));
    if ( m_bDel ) m_bDel->SetToolTip(_("Delete item"));
    if ( m_bUp ) m_bUp->SetToolTip(_("Move up"));
    if ( m_bDown ) m_bDown->SetToolTip(_("Move down"));
#endif

    subp->SetSizer(subsizer);
    subsizer->Fit(subp);

    sizer->Add(subp, 0, wxEXPAND);

    long st = wxLC_REPORT | wxLC_NO_HEADER | wxLC_SINGLE_SEL | wxSUNKEN_BORDER;
    if ( style & wxEL_ALLOW_EDIT )
         st |= wxLC_EDIT_LABELS;
    m_listCtrl = new CleverListCtrl(this, wxID_ELB_LISTCTRL,
                                    wxDefaultPosition, wxDefaultSize, st);
    wxArrayString empty_ar;
    SetStrings(empty_ar);

    sizer->Add(m_listCtrl, 1, wxEXPAND);

    SetSizer(sizer);
    Layout();

    return true;
}

void wxEditableListBox::SetStrings(const wxArrayString& strings)
{
    m_listCtrl->DeleteAllItems();
    size_t i;

    for (i = 0; i < strings.GetCount(); i++)
        m_listCtrl->InsertItem(i, strings[i]);

    m_listCtrl->InsertItem(strings.GetCount(), wxEmptyString);
    m_listCtrl->SetItemState(0, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
}

void wxEditableListBox::GetStrings(wxArrayString& strings) const
{
    strings.Clear();

    for (int i = 0; i < m_listCtrl->GetItemCount()-1; i++)
        strings.Add(m_listCtrl->GetItemText(i));
}

void wxEditableListBox::OnItemSelected(wxListEvent& event)
{
    m_selection = event.GetIndex();
    if (!(m_style & wxEL_NO_REORDER))
    {
        m_bUp->Enable(m_selection != 0 && m_selection < m_listCtrl->GetItemCount()-1);
        m_bDown->Enable(m_selection < m_listCtrl->GetItemCount()-2);
    }

    if (m_style & wxEL_ALLOW_EDIT)
        m_bEdit->Enable(m_selection < m_listCtrl->GetItemCount()-1);
    if (m_style & wxEL_ALLOW_DELETE)
        m_bDel->Enable(m_selection < m_listCtrl->GetItemCount()-1);
}

void wxEditableListBox::OnNewItem(wxCommandEvent& WXUNUSED(event))
{
    m_listCtrl->SetItemState(m_listCtrl->GetItemCount()-1,
                             wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
    m_listCtrl->EditLabel(m_selection);
}

void wxEditableListBox::OnEndLabelEdit(wxListEvent& event)
{
    if ( event.GetIndex() == m_listCtrl->GetItemCount()-1 &&
         !event.GetText().empty() )
    {
        // The user edited last (empty) line, i.e. added new entry. We have to
        // add new empty line here so that adding one more line is still
        // possible:
        m_listCtrl->InsertItem(m_listCtrl->GetItemCount(), wxEmptyString);

        // Simulate a wxEVT_LIST_ITEM_SELECTED event for the new item,
        // so that the buttons are enabled/disabled properly
        wxListEvent selectionEvent(wxEVT_LIST_ITEM_SELECTED, m_listCtrl->GetId());
        selectionEvent.m_itemIndex = event.GetIndex();
        m_listCtrl->GetEventHandler()->ProcessEvent(selectionEvent);
    }
}

void wxEditableListBox::OnDelItem(wxCommandEvent& WXUNUSED(event))
{
    m_listCtrl->DeleteItem(m_selection);
    m_listCtrl->SetItemState(m_selection,
                             wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
}

void wxEditableListBox::OnEditItem(wxCommandEvent& WXUNUSED(event))
{
    m_listCtrl->EditLabel(m_selection);
}

void wxEditableListBox::SwapItems(long i1, long i2)
{
    // swap the text
    wxString t1 = m_listCtrl->GetItemText(i1);
    wxString t2 = m_listCtrl->GetItemText(i2);
    m_listCtrl->SetItemText(i1, t2);
    m_listCtrl->SetItemText(i2, t1);

    // swap the item data
    long d1 = m_listCtrl->GetItemData(i1);
    long d2 = m_listCtrl->GetItemData(i2);
    m_listCtrl->SetItemData(i1, d2);
    m_listCtrl->SetItemData(i2, d1);
}


void wxEditableListBox::OnUpItem(wxCommandEvent& WXUNUSED(event))
{
    SwapItems(m_selection - 1, m_selection);
    m_listCtrl->SetItemState(m_selection - 1,
                             wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
}

void wxEditableListBox::OnDownItem(wxCommandEvent& WXUNUSED(event))
{
    SwapItems(m_selection + 1, m_selection);
    m_listCtrl->SetItemState(m_selection + 1,
                             wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
}

#endif // wxUSE_EDITABLELISTBOX
Commit	Line	Data
806ad819	1	/////////////////////////////////////////////////////////////////////////////
80fdcdb9	2	// Name: src/generic/editlbox.cpp
806ad819 VZ	3	// Purpose: ListBox with editable items
806ad819 VZ	4	// Author: Vaclav Slavik
806ad819 VZ	5	// Copyright: (c) Vaclav Slavik
	6	// Licence: wxWindows licence
	7	/////////////////////////////////////////////////////////////////////////////
	8
	9	// For compilers that support precompilation, includes "wx/wx.h".
	10	#include "wx/wxprec.h"
	11
	12	#ifdef __BORLANDC__
	13	#pragma hdrstop
	14	#endif
	15
23575150 RR	16	#if wxUSE_EDITABLELISTBOX
23575150 RR	17
806ad819 VZ	18	// for all others, include the necessary headers (this file is usually all you
	19	// need because it includes almost all "standard" wxWidgets headers)
	20	#ifndef WX_PRECOMP
	21	#include "wx/wx.h"
	22	#endif
	23
	24	#include "wx/editlbox.h"
	25	#include "wx/sizer.h"
	26	#include "wx/listctrl.h"
	27
395367bc RR	28	// ============================================================================
	29	// implementation
	30	// ============================================================================
	31
23318a53	32	const char wxEditableListBoxNameStr[] = "editableListBox";
395367bc	33
a243da29	34	static const char* const eledit_xpm[] = {
806ad819 VZ	35	"16 16 3 1",
	36	" c None",
	37	". c #000000",
	38	"+ c #00007F",
	39	" ",
	40	" ",
	41	" .. .. ",
	42	" . ",
	43	" . ",
	44	" ++++ . ++++ ",
	45	" ++ . ++ ++",
	46	" +++++ . ++++++",
	47	" ++ ++ . ++ ",
	48	" ++ ++ . ++ ++",
	49	" +++++ . ++++ ",
	50	" . ",
	51	" . ",
	52	" .. .. ",
	53	" ",
	54	" "};
	55
a243da29	56	static const char* const elnew_xpm[] = {
806ad819 VZ	57	"16 16 5 1",
	58	" c None",
	59	". c #7F7F7F",
	60	"+ c #FFFFFF",
	61	"@ c #FFFF00",
	62	"# c #000000",
	63	" ",
	64	" ",
	65	" . .+ .@ ",
	66	" . .@.@# # # ",
	67	" @.@+.... # ",
	68	" ... @@ ",
	69	" @ . @. # ",
	70	" .# .@ ",
	71	" . # ",
	72	" # ",
	73	" # ",
	74	" # ",
	75	" # ",
	76	" # # # # # # ",
	77	" ",
	78	" "};
	79
a243da29	80	static const char* const eldel_xpm[] = {
806ad819 VZ	81	"16 16 3 1",
	82	" c None",
	83	". c #7F0000",
	84	"+ c #FFFFFF",
	85	" ",
	86	" ",
	87	" ",
	88	" ..+ ..+ ",
	89	" ....+ ..+ ",
	90	" ....+ ..+ ",
	91	" ...+ .+ ",
	92	" .....+ ",
	93	" ...+ ",
	94	" .....+ ",
	95	" ...+ ..+ ",
	96	" ...+ ..+ ",
	97	" ...+ .+ ",
	98	" ...+ .+ ",
	99	" . . ",
	100	" "};
	101
a243da29	102	static const char* const eldown_xpm[] = {
806ad819 VZ	103	"16 16 2 1",
	104	" c None",
	105	". c #000000",
	106	" ",
	107	" ",
	108	" ... ",
	109	" ... ",
	110	" ... ",
	111	" ... ",
	112	" ... ",
	113	" ... ",
	114	" ........... ",
	115	" ......... ",
	116	" ....... ",
	117	" ..... ",
	118	" ... ",
	119	" . ",
	120	" ",
	121	" "};
	122
a243da29	123	static const char* const elup_xpm[] = {
806ad819 VZ	124	"16 16 2 1",
	125	" c None",
	126	". c #000000",
	127	" ",
	128	" . ",
	129	" ... ",
	130	" ..... ",
	131	" ....... ",
	132	" ......... ",
	133	" ........... ",
	134	" ... ",
	135	" ... ",
	136	" ... ",
	137	" ... ",
	138	" ... ",
	139	" ... ",
	140	" ",
	141	" ",
	142	" "};
	143
	144	// list control with auto-resizable column:
	145	class CleverListCtrl : public wxListCtrl
	146	{
	147	public:
	148	CleverListCtrl(wxWindow *parent,
	149	wxWindowID id = wxID_ANY,
	150	const wxPoint &pos = wxDefaultPosition,
	151	const wxSize &size = wxDefaultSize,
	152	long style = wxLC_ICON,
	153	const wxValidator& validator = wxDefaultValidator,
	154	const wxString &name = wxListCtrlNameStr)
	155	: wxListCtrl(parent, id, pos, size, style, validator, name)
	156	{
	157	CreateColumns();
	158	}
	159
	160	void CreateColumns()
	161	{
9a83f860	162	InsertColumn(0, wxT("item"));
806ad819 VZ	163	SizeColumns();
	164	}
	165
	166	void SizeColumns()
	167	{
	168	int w = GetSize().x;
	169	#ifdef __WXMSW__
	170	w -= wxSystemSettings::GetMetric(wxSYS_VSCROLL_X) + 6;
	171	#else
	172	w -= 2*wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
	173	#endif
d9b22b06	174	if (w < 0) w = 0;
806ad819 VZ	175	SetColumnWidth(0, w);
	176	}
	177
	178	private:
	179	DECLARE_EVENT_TABLE()
	180	void OnSize(wxSizeEvent& event)
	181	{
	182	SizeColumns();
	183	event.Skip();
	184	}
	185	};
	186
	187	BEGIN_EVENT_TABLE(CleverListCtrl, wxListCtrl)
	188	EVT_SIZE(CleverListCtrl::OnSize)
	189	END_EVENT_TABLE()
	190
395367bc RR	191
	192	// ----------------------------------------------------------------------------
	193	// wxEditableListBox
	194	// ----------------------------------------------------------------------------
	195
806ad819 VZ	196	IMPLEMENT_CLASS(wxEditableListBox, wxPanel)
	197
	198	// NB: generate the IDs at runtime to avoid conflict with XRCID values,
	199	// they could cause XRCCTRL() failures in XRC-based dialogs
cf2810aa VZ	200	const wxWindowIDRef wxID_ELB_DELETE = wxWindow::NewControlId();
	201	const wxWindowIDRef wxID_ELB_EDIT = wxWindow::NewControlId();
	202	const wxWindowIDRef wxID_ELB_NEW = wxWindow::NewControlId();
	203	const wxWindowIDRef wxID_ELB_UP = wxWindow::NewControlId();
	204	const wxWindowIDRef wxID_ELB_DOWN = wxWindow::NewControlId();
	205	const wxWindowIDRef wxID_ELB_LISTCTRL = wxWindow::NewControlId();
806ad819 VZ	206
	207	BEGIN_EVENT_TABLE(wxEditableListBox, wxPanel)
	208	EVT_LIST_ITEM_SELECTED(wxID_ELB_LISTCTRL, wxEditableListBox::OnItemSelected)
	209	EVT_LIST_END_LABEL_EDIT(wxID_ELB_LISTCTRL, wxEditableListBox::OnEndLabelEdit)
	210	EVT_BUTTON(wxID_ELB_NEW, wxEditableListBox::OnNewItem)
	211	EVT_BUTTON(wxID_ELB_UP, wxEditableListBox::OnUpItem)
	212	EVT_BUTTON(wxID_ELB_DOWN, wxEditableListBox::OnDownItem)
	213	EVT_BUTTON(wxID_ELB_EDIT, wxEditableListBox::OnEditItem)
	214	EVT_BUTTON(wxID_ELB_DELETE, wxEditableListBox::OnDelItem)
	215	END_EVENT_TABLE()
	216
395367bc	217	bool wxEditableListBox::Create(wxWindow *parent, wxWindowID id,
806ad819 VZ	218	const wxString& label,
	219	const wxPoint& pos, const wxSize& size,
	220	long style,
	221	const wxString& name)
806ad819	222	{
395367bc RR	223	if (!wxPanel::Create(parent, id, pos, size, wxTAB_TRAVERSAL, name))
	224	return false;
	225
806ad819	226	m_style = style;
806ad819 VZ	227
	228	wxSizer *sizer = new wxBoxSizer(wxVERTICAL);
	229
	230	wxPanel *subp = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize,
	231	wxSUNKEN_BORDER \| wxTAB_TRAVERSAL);
	232	wxSizer *subsizer = new wxBoxSizer(wxHORIZONTAL);
	233	subsizer->Add(new wxStaticText(subp, wxID_ANY, label), 1, wxALIGN_CENTRE_VERTICAL \| wxLEFT, 4);
	234
	235	#ifdef __WXMSW__
	236	#define BTN_BORDER 4
	237	// FIXME - why is this needed? There's some reason why sunken border is
	238	// ignored by sizers in wxMSW but not in wxGTK that I can't
	239	// figure out...
	240	#else
	241	#define BTN_BORDER 0
	242	#endif
	243
	244	if ( m_style & wxEL_ALLOW_EDIT )
	245	{
	246	m_bEdit = new wxBitmapButton(subp, wxID_ELB_EDIT, wxBitmap(eledit_xpm));
	247	subsizer->Add(m_bEdit, 0, wxALIGN_CENTRE_VERTICAL \| wxTOP \| wxBOTTOM, BTN_BORDER);
	248	}
	249
	250	if ( m_style & wxEL_ALLOW_NEW )
	251	{
	252	m_bNew = new wxBitmapButton(subp, wxID_ELB_NEW, wxBitmap(elnew_xpm));
	253	subsizer->Add(m_bNew, 0, wxALIGN_CENTRE_VERTICAL \| wxTOP \| wxBOTTOM, BTN_BORDER);
	254	}
	255
	256	if ( m_style & wxEL_ALLOW_DELETE )
	257	{
	258	m_bDel = new wxBitmapButton(subp, wxID_ELB_DELETE, wxBitmap(eldel_xpm));
	259	subsizer->Add(m_bDel, 0, wxALIGN_CENTRE_VERTICAL \| wxTOP \| wxBOTTOM, BTN_BORDER);
	260	}
	261
	262	if (!(m_style & wxEL_NO_REORDER))
	263	{
	264	m_bUp = new wxBitmapButton(subp, wxID_ELB_UP, wxBitmap(elup_xpm));
	265	subsizer->Add(m_bUp, 0, wxALIGN_CENTRE_VERTICAL \| wxTOP \| wxBOTTOM, BTN_BORDER);
	266
	267	m_bDown = new wxBitmapButton(subp, wxID_ELB_DOWN, wxBitmap(eldown_xpm));
	268	subsizer->Add(m_bDown, 0, wxALIGN_CENTRE_VERTICAL \| wxTOP \| wxBOTTOM, BTN_BORDER);
	269	}
	270
	271	#if wxUSE_TOOLTIPS
	272	if ( m_bEdit ) m_bEdit->SetToolTip(_("Edit item"));
	273	if ( m_bNew ) m_bNew->SetToolTip(_("New item"));
	274	if ( m_bDel ) m_bDel->SetToolTip(_("Delete item"));
	275	if ( m_bUp ) m_bUp->SetToolTip(_("Move up"));
	276	if ( m_bDown ) m_bDown->SetToolTip(_("Move down"));
	277	#endif
	278
	279	subp->SetSizer(subsizer);
	280	subsizer->Fit(subp);
	281
	282	sizer->Add(subp, 0, wxEXPAND);
	283
	284	long st = wxLC_REPORT \| wxLC_NO_HEADER \| wxLC_SINGLE_SEL \| wxSUNKEN_BORDER;
	285	if ( style & wxEL_ALLOW_EDIT )
	286	st \|= wxLC_EDIT_LABELS;
	287	m_listCtrl = new CleverListCtrl(this, wxID_ELB_LISTCTRL,
	288	wxDefaultPosition, wxDefaultSize, st);
	289	wxArrayString empty_ar;
	290	SetStrings(empty_ar);
291
292	sizer->Add(m_listCtrl, 1, wxEXPAND);
293
294	SetSizer(sizer);
295	Layout();
ff0846a0 VS	296
ff0846a0 VS	297	return true;
806ad819 VZ	298	}
	299
	300	void wxEditableListBox::SetStrings(const wxArrayString& strings)
	301	{
	302	m_listCtrl->DeleteAllItems();
	303	size_t i;
	304
	305	for (i = 0; i < strings.GetCount(); i++)
	306	m_listCtrl->InsertItem(i, strings[i]);
	307
	308	m_listCtrl->InsertItem(strings.GetCount(), wxEmptyString);
	309	m_listCtrl->SetItemState(0, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
	310	}
	311
	312	void wxEditableListBox::GetStrings(wxArrayString& strings) const
	313	{
	314	strings.Clear();
	315
	316	for (int i = 0; i < m_listCtrl->GetItemCount()-1; i++)
	317	strings.Add(m_listCtrl->GetItemText(i));
	318	}
	319
	320	void wxEditableListBox::OnItemSelected(wxListEvent& event)
	321	{
	322	m_selection = event.GetIndex();
	323	if (!(m_style & wxEL_NO_REORDER))
	324	{
	325	m_bUp->Enable(m_selection != 0 && m_selection < m_listCtrl->GetItemCount()-1);
	326	m_bDown->Enable(m_selection < m_listCtrl->GetItemCount()-2);
	327	}
	328
	329	if (m_style & wxEL_ALLOW_EDIT)
	330	m_bEdit->Enable(m_selection < m_listCtrl->GetItemCount()-1);
	331	if (m_style & wxEL_ALLOW_DELETE)
	332	m_bDel->Enable(m_selection < m_listCtrl->GetItemCount()-1);
	333	}
	334
	335	void wxEditableListBox::OnNewItem(wxCommandEvent& WXUNUSED(event))
	336	{
	337	m_listCtrl->SetItemState(m_listCtrl->GetItemCount()-1,
	338	wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
	339	m_listCtrl->EditLabel(m_selection);
	340	}
	341
	342	void wxEditableListBox::OnEndLabelEdit(wxListEvent& event)
	343	{
	344	if ( event.GetIndex() == m_listCtrl->GetItemCount()-1 &&
	345	!event.GetText().empty() )
	346	{
	347	// The user edited last (empty) line, i.e. added new entry. We have to
	348	// add new empty line here so that adding one more line is still
	349	// possible:
	350	m_listCtrl->InsertItem(m_listCtrl->GetItemCount(), wxEmptyString);
	351
ce7fe42e	352	// Simulate a wxEVT_LIST_ITEM_SELECTED event for the new item,
806ad819	353	// so that the buttons are enabled/disabled properly
ce7fe42e	354	wxListEvent selectionEvent(wxEVT_LIST_ITEM_SELECTED, m_listCtrl->GetId());
806ad819 VZ	355	selectionEvent.m_itemIndex = event.GetIndex();
	356	m_listCtrl->GetEventHandler()->ProcessEvent(selectionEvent);
	357	}
	358	}
	359
	360	void wxEditableListBox::OnDelItem(wxCommandEvent& WXUNUSED(event))
	361	{
	362	m_listCtrl->DeleteItem(m_selection);
	363	m_listCtrl->SetItemState(m_selection,
	364	wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
	365	}
	366
	367	void wxEditableListBox::OnEditItem(wxCommandEvent& WXUNUSED(event))
	368	{
	369	m_listCtrl->EditLabel(m_selection);
	370	}
	371
6b0dfbca	372	void wxEditableListBox::SwapItems(long i1, long i2)
806ad819	373	{
6b0dfbca VZ	374	// swap the text
	375	wxString t1 = m_listCtrl->GetItemText(i1);
	376	wxString t2 = m_listCtrl->GetItemText(i2);
	377	m_listCtrl->SetItemText(i1, t2);
	378	m_listCtrl->SetItemText(i2, t1);
	379
	380	// swap the item data
	381	long d1 = m_listCtrl->GetItemData(i1);
	382	long d2 = m_listCtrl->GetItemData(i2);
	383	m_listCtrl->SetItemData(i1, d2);
	384	m_listCtrl->SetItemData(i2, d1);
	385	}
	386
806ad819	387
6b0dfbca VZ	388	void wxEditableListBox::OnUpItem(wxCommandEvent& WXUNUSED(event))
	389	{
	390	SwapItems(m_selection - 1, m_selection);
806ad819 VZ	391	m_listCtrl->SetItemState(m_selection - 1,
	392	wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
	393	}
	394
	395	void wxEditableListBox::OnDownItem(wxCommandEvent& WXUNUSED(event))
	396	{
6b0dfbca	397	SwapItems(m_selection + 1, m_selection);
806ad819 VZ	398	m_listCtrl->SetItemState(m_selection + 1,
	399	wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
	400	}
23575150 RR	401
23575150 RR	402	#endif // wxUSE_EDITABLELISTBOX