trunk/src/qsamplerInstrumentList.cpp

// qsamplerInstrumentList.cpp
//
/****************************************************************************
   Copyright (C) 2003-2005, rncbc aka Rui Nuno Capela. All rights reserved.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*****************************************************************************/

#include "qsamplerAbout.h"
#include "qsamplerInstrumentList.h"

#include "qsamplerInstrument.h"
#include "qsamplerInstrumentForm.h"

#include "qsamplerMainForm.h"

#include <qaction.h>
#include <qfileinfo.h>
#include <qpopupmenu.h>

// Needed for lroundf()
#include <math.h>


//----------------------------------------------------------------------
// class qsamplerInstrumentGroup -- custom group list view item.
//

// Constructors.
qsamplerInstrumentGroup::qsamplerInstrumentGroup (
        qsamplerInstrumentList *pListView, const QString& sName,
        QListViewItem *pItemAfter )
        : QListViewItem(pListView, pItemAfter ? pItemAfter : pListView->lastItem())
{
        QListViewItem::setRenameEnabled(0, true);

        QListViewItem::setPixmap(0, QPixmap::fromMimeSource("itemGroup.png"));
        QListViewItem::setText(0, sName);
}


qsamplerInstrumentGroup::qsamplerInstrumentGroup (
        qsamplerInstrumentGroup *pGroupItem, const QString& sName )
        : QListViewItem(pGroupItem, sName)
{
        QListViewItem::setRenameEnabled(0, true);

        QListViewItem::setPixmap(0, QPixmap::fromMimeSource("itemGroup.png"));
}


// Default destructor.
qsamplerInstrumentGroup::~qsamplerInstrumentGroup (void)
{
}


// Instance accessors.
void qsamplerInstrumentGroup::setName ( const QString& sName )
{
        QListViewItem::setText(0, sName);
}


QString qsamplerInstrumentGroup::name (void) const
{
        return QListViewItem::text(0);
}


qsamplerInstrumentGroup *qsamplerInstrumentGroup::groupItem (void) const
{
        QListViewItem *pParent = QListViewItem::parent();
        while (pParent && pParent->rtti() != qsamplerInstrumentList::Group)
                pParent = pParent->parent();
        return static_cast<qsamplerInstrumentGroup *> (pParent);
}


qsamplerInstrumentList *qsamplerInstrumentGroup::listView (void) const
{
        return static_cast<qsamplerInstrumentList *> (QListViewItem::listView());
}


// To show up whether its open or not.
void qsamplerInstrumentGroup::setOpen ( bool bOpen )
{
        // Set the proper pixmap of this...
        if (rtti() == qsamplerInstrumentList::Group) {
                QListViewItem::setPixmap(0, QPixmap::fromMimeSource(
                        bOpen ? "itemGroupOpen.png" : "itemGroup.png"));
        }
        // Open it up...
        QListViewItem::setOpen(bOpen);

        // All ancestors should be also visible.
        if (bOpen && QListViewItem::parent())
                QListViewItem::parent()->setOpen(true);
}


// To virtually distinguish between list view items.
int qsamplerInstrumentGroup::rtti (void) const
{
        return qsamplerInstrumentList::Group;
}


//----------------------------------------------------------------------
// class qsamplerInstrumentItem -- custom file list view item.
//

// Constructors.
qsamplerInstrumentItem::qsamplerInstrumentItem (
        qsamplerInstrumentList *pListView,
        qsamplerInstrument *pInstrument,
        QListViewItem *pItemAfter )
        : qsamplerInstrumentGroup(pListView, pInstrument->name(), pItemAfter)
{
        m_pInstrument = pInstrument;

        update();
}

qsamplerInstrumentItem::qsamplerInstrumentItem (
        qsamplerInstrumentGroup *pGroupItem,
        qsamplerInstrument *pInstrument )
        : qsamplerInstrumentGroup(pGroupItem, pInstrument->name())
{
        m_pInstrument = pInstrument;

        update();
}


// Default destructor.
qsamplerInstrumentItem::~qsamplerInstrumentItem (void)
{
        if (m_pInstrument)
                delete m_pInstrument;
}


// To virtually distinguish between list view items.
int qsamplerInstrumentItem::rtti (void) const
{
        return qsamplerInstrumentList::Item;
}


// Payload accessor.
qsamplerInstrument *qsamplerInstrumentItem::instrument (void) const
{
        return m_pInstrument;
}


// Item refreshment.
void qsamplerInstrumentItem::update (void)
{
        QListViewItem::setPixmap(0, QPixmap::fromMimeSource("itemFile.png"));

        const QString s = "-";
        if (m_pInstrument) {
                setText(0, m_pInstrument->name());
                setText(1, QString::number(m_pInstrument->bank()));
                setText(2, QString::number(m_pInstrument->program()));
                setText(3, m_pInstrument->engineName());
                setText(4, QFileInfo(m_pInstrument->instrumentFile()).fileName());
                setText(5, QString::number(m_pInstrument->instrumentNr()));
                setText(6, QString::number(::lroundf(100.0f * m_pInstrument->volume())));
                QString sLoadMode = s;
                switch (m_pInstrument->loadMode()) {
                case 3:
                        sLoadMode = QObject::tr("Persistent");
                        break;
                case 2:
                        sLoadMode = QObject::tr("On Demand Hold");
                        break;
                case 1:
                        sLoadMode = QObject::tr("On Demand");
                        break;
                }
                setText(7, sLoadMode);
        } else {
                for (int i = 0; i < listView()->columns(); i++)
                        setText(i, s);
        }
}


//----------------------------------------------------------------------------
// qsamplerInstrumentList -- MIDI instrument list view.
//

// Constructor.
qsamplerInstrumentList::qsamplerInstrumentList (
        QWidget *pParent, const char *pszName )
        : QListView(pParent, pszName)
{
//  QListView::setRootIsDecorated(true);
        QListView::setResizeMode(QListView::NoColumn);
//      QListView::setAcceptDrops(true);
        QListView::setDragAutoScroll(true);
        QListView::setSizePolicy(
                QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
//      QListView::setShowToolTips(false);
        QListView::setSortColumn(-1);

        QListView::addColumn(tr("Name"));
        QListView::addColumn(tr("Bank"));
        QListView::addColumn(tr("Prog"));
        QListView::addColumn(tr("Engine"));
        QListView::addColumn(tr("File"));
        QListView::addColumn(tr("Nr"));
        QListView::addColumn(tr("Vol"));
        QListView::addColumn(tr("Mode"));

        QListView::setColumnAlignment(1, Qt::AlignHCenter);     // Bank
        QListView::setColumnAlignment(2, Qt::AlignHCenter);     // Prog
        QListView::setColumnAlignment(5, Qt::AlignHCenter);     // Nr
        QListView::setColumnAlignment(6, Qt::AlignHCenter);     // Vol

        QListView::setColumnWidth(0, 60);       // Name
        QListView::setColumnWidth(0, 120);      // File

        m_pNewGroupAction = new QAction(tr("New &Group"), tr("Ctrl+G"), this);
        m_pNewItemAction  = new QAction(tr("New &Instrument..."), tr("Ctrl+I"), this);
        m_pEditItemAction = new QAction(tr("&Edit..."), tr("Ctrl+E"), this);
        m_pRenameAction   = new QAction(tr("&Rename"), tr("Ctrl+R"), this);
        m_pDeleteAction   = new QAction(tr("&Delete"), tr("Ctrl+D"), this);
        m_pRefreshAction  = new QAction(tr("Re&fresh"), tr("Ctrl+F"), this);

        QObject::connect(m_pNewGroupAction,
                SIGNAL(activated()),
                SLOT(newGroupSlot()));
        QObject::connect(m_pNewItemAction,
                SIGNAL(activated()),
                SLOT(newItemSlot()));
        QObject::connect(m_pEditItemAction,
                SIGNAL(activated()),
                SLOT(editItemSlot()));
        QObject::connect(m_pRenameAction,
                SIGNAL(activated()),
                SLOT(renameSlot()));
        QObject::connect(m_pDeleteAction,
                SIGNAL(activated()),
                SLOT(deleteSlot()));
        QObject::connect(m_pRefreshAction,
                SIGNAL(activated()),
                SLOT(refresh()));

        QObject::connect(this,
                SIGNAL(selectionChanged()),
                SLOT(selectionChangedSlot()));
        QObject::connect(this,
                SIGNAL(doubleClicked(QListViewItem*, const QPoint&, int)),
                SLOT(activatedSlot(QListViewItem*)));
        QObject::connect(this,
                SIGNAL(returnPressed(QListViewItem*)),
                SLOT(activatedSlot(QListViewItem*)));
        QObject::connect(this,
                SIGNAL(itemRenamed(QListViewItem*,int)),
                SLOT(renamedSlot(QListViewItem*)));

        selectionChangedSlot();
}


// Default destructor.
qsamplerInstrumentList::~qsamplerInstrumentList (void)
{
        delete m_pNewGroupAction;
        delete m_pNewItemAction;
        delete m_pEditItemAction;
        delete m_pRenameAction;
        delete m_pDeleteAction;
}


// Add a new instrument item, optionally under a given group.
qsamplerInstrumentItem *qsamplerInstrumentList::addItem (
        qsamplerInstrument *pInstrument,
        qsamplerInstrumentGroup *pParentGroup )
{
        qsamplerInstrumentItem *pItem = findItem(pInstrument);
        if (pItem == NULL) {
                if (pParentGroup)
                        pItem = new qsamplerInstrumentItem(pParentGroup, pInstrument);
                else
                        pItem = new qsamplerInstrumentItem(this, pInstrument);
        }
        QListView::setSelected(pItem, true);
        return pItem;
}


// Add a new instrument group, optionally under another group.
qsamplerInstrumentGroup *qsamplerInstrumentList::addGroup (
        const QString& sName, qsamplerInstrumentGroup *pParentGroup )
{
        qsamplerInstrumentGroup *pGroup = findGroup(sName);
        if (pGroup == NULL) {
                if (pParentGroup)
                        pGroup = new qsamplerInstrumentGroup(pParentGroup, sName);
                else
                        pGroup = new qsamplerInstrumentGroup(this, sName);
        }
        QListView::setSelected(pGroup, true);
        return pGroup;
}


// Find a group item, given its name.
qsamplerInstrumentGroup *qsamplerInstrumentList::findGroup (
        const QString& sName ) const
{
        // Iterate all over the place to search for the group.
        QListViewItemIterator iter((QListView *) this);
        while (iter.current()) {
                QListViewItem *pItem = iter.current();
                if (pItem->rtti() == Group && pItem->text(0) == sName)
                        return static_cast<qsamplerInstrumentGroup *> (pItem);
                ++iter;
        }
        // Not found.
        return NULL;
}


// Find a file item, given its name.
qsamplerInstrumentItem *qsamplerInstrumentList::findItem (
        qsamplerInstrument *pInstrument ) const
{
        if (pInstrument == NULL)
                return NULL;

        // Iterate all over the place to search for the group.
        QListViewItemIterator iter((QListView *) this);
        while (iter.current()) {
                QListViewItem *pListItem = iter.current();
                if (pListItem->rtti() == Item) {
                        qsamplerInstrumentItem *pItem
                                = static_cast<qsamplerInstrumentItem *> (pListItem);
                        if (pItem && pItem->instrument()
                                && pItem->instrument()->bank() == pInstrument->bank()
                                && pItem->instrument()->program() == pInstrument->program())
                                return pItem;
                }
                ++iter;
        }
        // Not found.
        return NULL;
}


// Find and return the nearest group item...
qsamplerInstrumentGroup *qsamplerInstrumentList::groupItem (
        QListViewItem *pItem ) const
{
        while (pItem && pItem->rtti() != Group)
                pItem = pItem->parent();
        return static_cast<qsamplerInstrumentGroup *> (pItem);
}


// Add a new group item below the current one.
void qsamplerInstrumentList::newGroupSlot (void)
{
        qsamplerInstrumentGroup *pParentGroup
                = groupItem(QListView::selectedItem());
        qsamplerInstrumentGroup *pNewGroup
                = addGroup(tr("New Group"), pParentGroup);
        if (pParentGroup)
                pParentGroup->setOpen(true);
        if (pNewGroup)
                pNewGroup->startRename(0);

        selectionChangedSlot();
}


// Add a new instrument item below the current one.
void qsamplerInstrumentList::newItemSlot (void)
{
        qsamplerInstrument *pInstrument = new qsamplerInstrument();

        qsamplerInstrumentForm form(this);
        form.setup(pInstrument);
        if (!form.exec()) {
                delete pInstrument;
                return;
        }

        // Check it there's already one for the same key (bank, program)
        qsamplerInstrumentItem *pItem = findItem(pInstrument);
        if (pItem)
                delete pItem;

        pInstrument->map();
        emit instrumentsChanged();

        qsamplerInstrumentGroup *pParentGroup
                = groupItem(QListView::selectedItem());
        addItem(pInstrument, pParentGroup);
        if (pParentGroup)
                pParentGroup->setOpen(true);

        selectionChangedSlot();
}


// Edit current item below the current one.
void qsamplerInstrumentList::editItemSlot (void)
{
        QListViewItem *pListItem = QListView::selectedItem();
        if (pListItem == NULL)
                return;
        if (pListItem->rtti() == Item) {
                qsamplerInstrumentItem *pItem
                        = static_cast<qsamplerInstrumentItem *> (pListItem);
                if (pItem && pItem->instrument()) {
                        qsamplerInstrumentForm form(this);
                        form.setup(pItem->instrument());
                        if (form.exec()) {
                                pItem->instrument()->map();
                                emit instrumentsChanged();
                                pItem->update();
                        }
                }
        }

        selectionChangedSlot();
}


// Rename current group/item.
void qsamplerInstrumentList::renameSlot (void)
{
        QListViewItem *pListItem = QListView::selectedItem();
        if (pListItem)
                pListItem->startRename(0);

        selectionChangedSlot();
}


// Remove current group/item.
void qsamplerInstrumentList::deleteSlot (void)
{
        QListViewItem *pListItem = QListView::selectedItem();
        if (pListItem) {
                if (pListItem->rtti() == Item) {
                        qsamplerInstrumentItem *pItem
                                = static_cast<qsamplerInstrumentItem *> (pListItem);
                        if (pItem && pItem->instrument()) {
                                pItem->instrument()->unmap();
                                emit instrumentsChanged();
                        }
                }
                delete pListItem;
        }

        selectionChangedSlot();
}


// In-place selection slot.
void qsamplerInstrumentList::selectionChangedSlot (void)
{
        qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
        QListViewItem *pListItem = QListView::selectedItem();
        bool bEnabled = (pMainForm && pMainForm->client());
        m_pNewItemAction->setEnabled(bEnabled);
        bEnabled = (bEnabled && pListItem != NULL);
        m_pEditItemAction->setEnabled(bEnabled && pListItem->rtti() == Item);
        m_pRenameAction->setEnabled(bEnabled);
        m_pDeleteAction->setEnabled(bEnabled);
}


// In-place activation slot.
void qsamplerInstrumentList::activatedSlot ( QListViewItem *pListItem )
{
        // FIXME: Hope the list view item is the one selected.
        if (pListItem->rtti() == Item)
                editItemSlot();
}


// In-place aliasing slot.
void qsamplerInstrumentList::renamedSlot ( QListViewItem *pListItem )
{
        if (pListItem->rtti() == Item) {
                qsamplerInstrumentItem *pItem
                        = static_cast<qsamplerInstrumentItem *> (pListItem);
                if (pItem && pItem->instrument()) {
                        pItem->instrument()->setName(pListItem->text(0));
                        pItem->instrument()->map();
                        emit instrumentsChanged();
                        pItem->update();
                }
        }
}


// Context menu request event handler.
void qsamplerInstrumentList::contextMenuEvent (
        QContextMenuEvent *pContextMenuEvent )
{
        QPopupMenu menu(this);

        // Construct context menu.
        m_pNewItemAction->addTo(&menu);
//      m_pNewGroupAction->addTo(&menu);
        menu.insertSeparator();
        m_pEditItemAction->addTo(&menu);
        m_pRenameAction->addTo(&menu);
        m_pDeleteAction->addTo(&menu);
        menu.insertSeparator();
        m_pRefreshAction->addTo(&menu);

        menu.exec(pContextMenuEvent->globalPos());
}


// General reloader.
void qsamplerInstrumentList::refresh (void)
{
        clear();

        qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
        if (pMainForm == NULL)
                return;
        if (pMainForm->client() == NULL)
                return;

        qsamplerInstrumentItem *pItem = NULL;
        lscp_midi_instrument_t *pInstrs
                = ::lscp_list_midi_instruments(pMainForm->client());
        for (int iInstr = 0; pInstrs && pInstrs[iInstr].program >= 0; ++iInstr) {
                int iBank = (pInstrs[iInstr].bank_msb << 7) | pInstrs[iInstr].bank_lsb;
                int iProgram = pInstrs[iInstr].program;
                qsamplerInstrument *pInstrument
                        = new qsamplerInstrument(iBank, iProgram);
                if (pInstrument->get())
                        pItem = new qsamplerInstrumentItem(this, pInstrument, pItem);
        }

        if (pInstrs == NULL && ::lscp_client_get_errno(pMainForm->client())) {
                pMainForm->appendMessagesClient("lscp_list_midi_instruments");
                pMainForm->appendMessagesError(tr("Could not get current list of MIDI instrument mappings.\n\nSorry."));
        }

        selectionChangedSlot();
}


// end of qsamplerInstrumentList.cpp

1	// qsamplerInstrumentList.cpp
2	//
3	/****************************************************************************
4	Copyright (C) 2003-2005, rncbc aka Rui Nuno Capela. All rights reserved.
5
6	This program is free software; you can redistribute it and/or
7	modify it under the terms of the GNU General Public License
8	as published by the Free Software Foundation; either version 2
9	of the License, or (at your option) any later version.
10
11	This program is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.
15
16	You should have received a copy of the GNU General Public License
17	along with this program; if not, write to the Free Software
18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20	*****************************************************************************/
21
22	#include "qsamplerAbout.h"
23	#include "qsamplerInstrumentList.h"
24
25	#include "qsamplerInstrument.h"
26	#include "qsamplerInstrumentForm.h"
27
28	#include "qsamplerMainForm.h"
29
30	#include <qaction.h>
31	#include <qfileinfo.h>
32	#include <qpopupmenu.h>
33
34	// Needed for lroundf()
35	#include <math.h>
36
37
38	//----------------------------------------------------------------------
39	// class qsamplerInstrumentGroup -- custom group list view item.
40	//
41
42	// Constructors.
43	qsamplerInstrumentGroup::qsamplerInstrumentGroup (
44	qsamplerInstrumentList *pListView, const QString& sName,
45	QListViewItem *pItemAfter )
46	: QListViewItem(pListView, pItemAfter ? pItemAfter : pListView->lastItem())
47	{
48	QListViewItem::setRenameEnabled(0, true);
49
50	QListViewItem::setPixmap(0, QPixmap::fromMimeSource("itemGroup.png"));
51	QListViewItem::setText(0, sName);
52	}
53
54
55	qsamplerInstrumentGroup::qsamplerInstrumentGroup (
56	qsamplerInstrumentGroup *pGroupItem, const QString& sName )
57	: QListViewItem(pGroupItem, sName)
58	{
59	QListViewItem::setRenameEnabled(0, true);
60
61	QListViewItem::setPixmap(0, QPixmap::fromMimeSource("itemGroup.png"));
62	}
63
64
65	// Default destructor.
66	qsamplerInstrumentGroup::~qsamplerInstrumentGroup (void)
67	{
68	}
69
70
71	// Instance accessors.
72	void qsamplerInstrumentGroup::setName ( const QString& sName )
73	{
74	QListViewItem::setText(0, sName);
75	}
76
77
78	QString qsamplerInstrumentGroup::name (void) const
79	{
80	return QListViewItem::text(0);
81	}
82
83
84	qsamplerInstrumentGroup *qsamplerInstrumentGroup::groupItem (void) const
85	{
86	QListViewItem *pParent = QListViewItem::parent();
87	while (pParent && pParent->rtti() != qsamplerInstrumentList::Group)
88	pParent = pParent->parent();
89	return static_cast<qsamplerInstrumentGroup *> (pParent);
90	}
91
92
93	qsamplerInstrumentList *qsamplerInstrumentGroup::listView (void) const
94	{
95	return static_cast<qsamplerInstrumentList *> (QListViewItem::listView());
96	}
97
98
99	// To show up whether its open or not.
100	void qsamplerInstrumentGroup::setOpen ( bool bOpen )
101	{
102	// Set the proper pixmap of this...
103	if (rtti() == qsamplerInstrumentList::Group) {
104	QListViewItem::setPixmap(0, QPixmap::fromMimeSource(
105	bOpen ? "itemGroupOpen.png" : "itemGroup.png"));
106	}
107	// Open it up...
108	QListViewItem::setOpen(bOpen);
109
110	// All ancestors should be also visible.
111	if (bOpen && QListViewItem::parent())
112	QListViewItem::parent()->setOpen(true);
113	}
114
115
116	// To virtually distinguish between list view items.
117	int qsamplerInstrumentGroup::rtti (void) const
118	{
119	return qsamplerInstrumentList::Group;
120	}
121
122
123	//----------------------------------------------------------------------
124	// class qsamplerInstrumentItem -- custom file list view item.
125	//
126
127	// Constructors.
128	qsamplerInstrumentItem::qsamplerInstrumentItem (
129	qsamplerInstrumentList *pListView,
130	qsamplerInstrument *pInstrument,
131	QListViewItem *pItemAfter )
132	: qsamplerInstrumentGroup(pListView, pInstrument->name(), pItemAfter)
133	{
134	m_pInstrument = pInstrument;
135
136	update();
137	}
138
139	qsamplerInstrumentItem::qsamplerInstrumentItem (
140	qsamplerInstrumentGroup *pGroupItem,
141	qsamplerInstrument *pInstrument )
142	: qsamplerInstrumentGroup(pGroupItem, pInstrument->name())
143	{
144	m_pInstrument = pInstrument;
145
146	update();
147	}
148
149
150	// Default destructor.
151	qsamplerInstrumentItem::~qsamplerInstrumentItem (void)
152	{
153	if (m_pInstrument)
154	delete m_pInstrument;
155	}
156
157
158	// To virtually distinguish between list view items.
159	int qsamplerInstrumentItem::rtti (void) const
160	{
161	return qsamplerInstrumentList::Item;
162	}
163
164
165	// Payload accessor.
166	qsamplerInstrument *qsamplerInstrumentItem::instrument (void) const
167	{
168	return m_pInstrument;
169	}
170
171
172	// Item refreshment.
173	void qsamplerInstrumentItem::update (void)
174	{
175	QListViewItem::setPixmap(0, QPixmap::fromMimeSource("itemFile.png"));
176
177	const QString s = "-";
178	if (m_pInstrument) {
179	setText(0, m_pInstrument->name());
180	setText(1, QString::number(m_pInstrument->bank()));
181	setText(2, QString::number(m_pInstrument->program()));
182	setText(3, m_pInstrument->engineName());
183	setText(4, QFileInfo(m_pInstrument->instrumentFile()).fileName());
184	setText(5, QString::number(m_pInstrument->instrumentNr()));
185	setText(6, QString::number(::lroundf(100.0f * m_pInstrument->volume())));
186	QString sLoadMode = s;
187	switch (m_pInstrument->loadMode()) {
188	case 3:
189	sLoadMode = QObject::tr("Persistent");
190	break;
191	case 2:
192	sLoadMode = QObject::tr("On Demand Hold");
193	break;
194	case 1:
195	sLoadMode = QObject::tr("On Demand");
196	break;
197	}
198	setText(7, sLoadMode);
199	} else {
200	for (int i = 0; i < listView()->columns(); i++)
201	setText(i, s);
202	}
203	}
204
205
206	//----------------------------------------------------------------------------
207	// qsamplerInstrumentList -- MIDI instrument list view.
208	//
209
210	// Constructor.
211	qsamplerInstrumentList::qsamplerInstrumentList (
212	QWidget pParent, const char pszName )
213	: QListView(pParent, pszName)
214	{
215	// QListView::setRootIsDecorated(true);
216	QListView::setResizeMode(QListView::NoColumn);
217	// QListView::setAcceptDrops(true);
218	QListView::setDragAutoScroll(true);
219	QListView::setSizePolicy(
220	QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
221	// QListView::setShowToolTips(false);
222	QListView::setSortColumn(-1);
223
224	QListView::addColumn(tr("Name"));
225	QListView::addColumn(tr("Bank"));
226	QListView::addColumn(tr("Prog"));
227	QListView::addColumn(tr("Engine"));
228	QListView::addColumn(tr("File"));
229	QListView::addColumn(tr("Nr"));
230	QListView::addColumn(tr("Vol"));
231	QListView::addColumn(tr("Mode"));
232
233	QListView::setColumnAlignment(1, Qt::AlignHCenter); // Bank
234	QListView::setColumnAlignment(2, Qt::AlignHCenter); // Prog
235	QListView::setColumnAlignment(5, Qt::AlignHCenter); // Nr
236	QListView::setColumnAlignment(6, Qt::AlignHCenter); // Vol
237
238	QListView::setColumnWidth(0, 60); // Name
239	QListView::setColumnWidth(0, 120); // File
240
241	m_pNewGroupAction = new QAction(tr("New &Group"), tr("Ctrl+G"), this);
242	m_pNewItemAction = new QAction(tr("New &Instrument..."), tr("Ctrl+I"), this);
243	m_pEditItemAction = new QAction(tr("&Edit..."), tr("Ctrl+E"), this);
244	m_pRenameAction = new QAction(tr("&Rename"), tr("Ctrl+R"), this);
245	m_pDeleteAction = new QAction(tr("&Delete"), tr("Ctrl+D"), this);
246	m_pRefreshAction = new QAction(tr("Re&fresh"), tr("Ctrl+F"), this);
247
248	QObject::connect(m_pNewGroupAction,
249	SIGNAL(activated()),
250	SLOT(newGroupSlot()));
251	QObject::connect(m_pNewItemAction,
252	SIGNAL(activated()),
253	SLOT(newItemSlot()));
254	QObject::connect(m_pEditItemAction,
255	SIGNAL(activated()),
256	SLOT(editItemSlot()));
257	QObject::connect(m_pRenameAction,
258	SIGNAL(activated()),
259	SLOT(renameSlot()));
260	QObject::connect(m_pDeleteAction,
261	SIGNAL(activated()),
262	SLOT(deleteSlot()));
263	QObject::connect(m_pRefreshAction,
264	SIGNAL(activated()),
265	SLOT(refresh()));
266
267	QObject::connect(this,
268	SIGNAL(selectionChanged()),
269	SLOT(selectionChangedSlot()));
270	QObject::connect(this,
271	SIGNAL(doubleClicked(QListViewItem*, const QPoint&, int)),
272	SLOT(activatedSlot(QListViewItem*)));
273	QObject::connect(this,
274	SIGNAL(returnPressed(QListViewItem*)),
275	SLOT(activatedSlot(QListViewItem*)));
276	QObject::connect(this,
277	SIGNAL(itemRenamed(QListViewItem*,int)),
278	SLOT(renamedSlot(QListViewItem*)));
279
280	selectionChangedSlot();
281	}
282
283
284	// Default destructor.
285	qsamplerInstrumentList::~qsamplerInstrumentList (void)
286	{
287	delete m_pNewGroupAction;
288	delete m_pNewItemAction;
289	delete m_pEditItemAction;
290	delete m_pRenameAction;
291	delete m_pDeleteAction;
292	}
293
294
295	// Add a new instrument item, optionally under a given group.
296	qsamplerInstrumentItem *qsamplerInstrumentList::addItem (
297	qsamplerInstrument *pInstrument,
298	qsamplerInstrumentGroup *pParentGroup )
299	{
300	qsamplerInstrumentItem *pItem = findItem(pInstrument);
301	if (pItem == NULL) {
302	if (pParentGroup)
303	pItem = new qsamplerInstrumentItem(pParentGroup, pInstrument);
304	else
305	pItem = new qsamplerInstrumentItem(this, pInstrument);
306	}
307	QListView::setSelected(pItem, true);
308	return pItem;
309	}
310
311
312	// Add a new instrument group, optionally under another group.
313	qsamplerInstrumentGroup *qsamplerInstrumentList::addGroup (
314	const QString& sName, qsamplerInstrumentGroup *pParentGroup )
315	{
316	qsamplerInstrumentGroup *pGroup = findGroup(sName);
317	if (pGroup == NULL) {
318	if (pParentGroup)
319	pGroup = new qsamplerInstrumentGroup(pParentGroup, sName);
320	else
321	pGroup = new qsamplerInstrumentGroup(this, sName);
322	}
323	QListView::setSelected(pGroup, true);
324	return pGroup;
325	}
326
327
328	// Find a group item, given its name.
329	qsamplerInstrumentGroup *qsamplerInstrumentList::findGroup (
330	const QString& sName ) const
331	{
332	// Iterate all over the place to search for the group.
333	QListViewItemIterator iter((QListView *) this);
334	while (iter.current()) {
335	QListViewItem *pItem = iter.current();
336	if (pItem->rtti() == Group && pItem->text(0) == sName)
337	return static_cast<qsamplerInstrumentGroup *> (pItem);
338	++iter;
339	}
340	// Not found.
341	return NULL;
342	}
343
344
345	// Find a file item, given its name.
346	qsamplerInstrumentItem *qsamplerInstrumentList::findItem (
347	qsamplerInstrument *pInstrument ) const
348	{
349	if (pInstrument == NULL)
350	return NULL;
351
352	// Iterate all over the place to search for the group.
353	QListViewItemIterator iter((QListView *) this);
354	while (iter.current()) {
355	QListViewItem *pListItem = iter.current();
356	if (pListItem->rtti() == Item) {
357	qsamplerInstrumentItem *pItem
358	= static_cast<qsamplerInstrumentItem *> (pListItem);
359	if (pItem && pItem->instrument()
360	&& pItem->instrument()->bank() == pInstrument->bank()
361	&& pItem->instrument()->program() == pInstrument->program())
362	return pItem;
363	}
364	++iter;
365	}
366	// Not found.
367	return NULL;
368	}
369
370
371	// Find and return the nearest group item...
372	qsamplerInstrumentGroup *qsamplerInstrumentList::groupItem (
373	QListViewItem *pItem ) const
374	{
375	while (pItem && pItem->rtti() != Group)
376	pItem = pItem->parent();
377	return static_cast<qsamplerInstrumentGroup *> (pItem);
378	}
379
380
381	// Add a new group item below the current one.
382	void qsamplerInstrumentList::newGroupSlot (void)
383	{
384	qsamplerInstrumentGroup *pParentGroup
385	= groupItem(QListView::selectedItem());
386	qsamplerInstrumentGroup *pNewGroup
387	= addGroup(tr("New Group"), pParentGroup);
388	if (pParentGroup)
389	pParentGroup->setOpen(true);
390	if (pNewGroup)
391	pNewGroup->startRename(0);
392
393	selectionChangedSlot();
394	}
395
396
397	// Add a new instrument item below the current one.
398	void qsamplerInstrumentList::newItemSlot (void)
399	{
400	qsamplerInstrument *pInstrument = new qsamplerInstrument();
401
402	qsamplerInstrumentForm form(this);
403	form.setup(pInstrument);
404	if (!form.exec()) {
405	delete pInstrument;
406	return;
407	}
408
409	// Check it there's already one for the same key (bank, program)
410	qsamplerInstrumentItem *pItem = findItem(pInstrument);
411	if (pItem)
412	delete pItem;
413
414	pInstrument->map();
415	emit instrumentsChanged();
416
417	qsamplerInstrumentGroup *pParentGroup
418	= groupItem(QListView::selectedItem());
419	addItem(pInstrument, pParentGroup);
420	if (pParentGroup)
421	pParentGroup->setOpen(true);
422
423	selectionChangedSlot();
424	}
425
426
427	// Edit current item below the current one.
428	void qsamplerInstrumentList::editItemSlot (void)
429	{
430	QListViewItem *pListItem = QListView::selectedItem();
431	if (pListItem == NULL)
432	return;
433	if (pListItem->rtti() == Item) {
434	qsamplerInstrumentItem *pItem
435	= static_cast<qsamplerInstrumentItem *> (pListItem);
436	if (pItem && pItem->instrument()) {
437	qsamplerInstrumentForm form(this);
438	form.setup(pItem->instrument());
439	if (form.exec()) {
440	pItem->instrument()->map();
441	emit instrumentsChanged();
442	pItem->update();
443	}
444	}
445	}
446
447	selectionChangedSlot();
448	}
449
450
451	// Rename current group/item.
452	void qsamplerInstrumentList::renameSlot (void)
453	{
454	QListViewItem *pListItem = QListView::selectedItem();
455	if (pListItem)
456	pListItem->startRename(0);
457
458	selectionChangedSlot();
459	}
460
461
462	// Remove current group/item.
463	void qsamplerInstrumentList::deleteSlot (void)
464	{
465	QListViewItem *pListItem = QListView::selectedItem();
466	if (pListItem) {
467	if (pListItem->rtti() == Item) {
468	qsamplerInstrumentItem *pItem
469	= static_cast<qsamplerInstrumentItem *> (pListItem);
470	if (pItem && pItem->instrument()) {
471	pItem->instrument()->unmap();
472	emit instrumentsChanged();
473	}
474	}
475	delete pListItem;
476	}
477
478	selectionChangedSlot();
479	}
480
481
482	// In-place selection slot.
483	void qsamplerInstrumentList::selectionChangedSlot (void)
484	{
485	qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
486	QListViewItem *pListItem = QListView::selectedItem();
487	bool bEnabled = (pMainForm && pMainForm->client());
488	m_pNewItemAction->setEnabled(bEnabled);
489	bEnabled = (bEnabled && pListItem != NULL);
490	m_pEditItemAction->setEnabled(bEnabled && pListItem->rtti() == Item);
491	m_pRenameAction->setEnabled(bEnabled);
492	m_pDeleteAction->setEnabled(bEnabled);
493	}
494
495
496	// In-place activation slot.
497	void qsamplerInstrumentList::activatedSlot ( QListViewItem *pListItem )
498	{
499	// FIXME: Hope the list view item is the one selected.
500	if (pListItem->rtti() == Item)
501	editItemSlot();
502	}
503
504
505	// In-place aliasing slot.
506	void qsamplerInstrumentList::renamedSlot ( QListViewItem *pListItem )
507	{
508	if (pListItem->rtti() == Item) {
509	qsamplerInstrumentItem *pItem
510	= static_cast<qsamplerInstrumentItem *> (pListItem);
511	if (pItem && pItem->instrument()) {
512	pItem->instrument()->setName(pListItem->text(0));
513	pItem->instrument()->map();
514	emit instrumentsChanged();
515	pItem->update();
516	}
517	}
518	}
519
520
521	// Context menu request event handler.
522	void qsamplerInstrumentList::contextMenuEvent (
523	QContextMenuEvent *pContextMenuEvent )
524	{
525	QPopupMenu menu(this);
526
527	// Construct context menu.
528	m_pNewItemAction->addTo(&menu);
529	// m_pNewGroupAction->addTo(&menu);
530	menu.insertSeparator();
531	m_pEditItemAction->addTo(&menu);
532	m_pRenameAction->addTo(&menu);
533	m_pDeleteAction->addTo(&menu);
534	menu.insertSeparator();
535	m_pRefreshAction->addTo(&menu);
536
537	menu.exec(pContextMenuEvent->globalPos());
538	}
539
540
541	// General reloader.
542	void qsamplerInstrumentList::refresh (void)
543	{
544	clear();
545
546	qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
547	if (pMainForm == NULL)
548	return;
549	if (pMainForm->client() == NULL)
550	return;
551
552	qsamplerInstrumentItem *pItem = NULL;
553	lscp_midi_instrument_t *pInstrs
554	= ::lscp_list_midi_instruments(pMainForm->client());
555	for (int iInstr = 0; pInstrs && pInstrs[iInstr].program >= 0; ++iInstr) {
556	int iBank = (pInstrs[iInstr].bank_msb << 7) \| pInstrs[iInstr].bank_lsb;
557	int iProgram = pInstrs[iInstr].program;
558	qsamplerInstrument *pInstrument
559	= new qsamplerInstrument(iBank, iProgram);
560	if (pInstrument->get())
561	pItem = new qsamplerInstrumentItem(this, pInstrument, pItem);
562	}
563
564	if (pInstrs == NULL && ::lscp_client_get_errno(pMainForm->client())) {
565	pMainForm->appendMessagesClient("lscp_list_midi_instruments");
566	pMainForm->appendMessagesError(tr("Could not get current list of MIDI instrument mappings.\n\nSorry."));
567	}
568
569	selectionChangedSlot();
570	}
571
572
573	// end of qsamplerInstrumentList.cpp
574