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 "qsamplerOptions.h"
#include "qsamplerMainForm.h"

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

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

#ifndef CONFIG_ROUND
static inline long lroundf ( float x )
{
        if (x >= 0.0f)
                return long(x + 0.5f);
        else
                return long(x - 0.5f);
}
#endif


//----------------------------------------------------------------------
// 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->map()));
                setText(2, QString::number(m_pInstrument->bank()));
                setText(3, QString::number(m_pInstrument->prog() + 1));
                setText(4, m_pInstrument->engineName());
                setText(5, QFileInfo(m_pInstrument->instrumentFile()).fileName());
                setText(6, QString::number(m_pInstrument->instrumentNr()));
                setText(7, 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(8, 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("Map"));
        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);     // Map
        QListView::setColumnAlignment(2, Qt::AlignHCenter);     // Bank
        QListView::setColumnAlignment(3, Qt::AlignHCenter);     // Prog
        QListView::setColumnAlignment(6, Qt::AlignHCenter);     // Nr
        QListView::setColumnAlignment(7, Qt::AlignHCenter);     // Vol

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

        m_pNewGroupAction = new QAction(tr("New &Group"), tr("Ctrl+G"), this);
        m_pNewItemAction  = new QAction(tr("New &Instrument..."), tr("Ins"), this);
        m_pEditItemAction = new QAction(tr("&Edit..."), tr("Enter"), this);
        m_pRenameAction   = new QAction(tr("&Rename"), tr("F2"), this);
        m_pDeleteAction   = new QAction(tr("&Delete"), tr("Del"), this);
        m_pRefreshAction  = new QAction(tr("Re&fresh"), tr("F5"), 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()->map()  == pInstrument->map()
                                && pItem->instrument()->bank() == pInstrument->bank()
                                && pItem->instrument()->prog() == pInstrument->prog())
                                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 instrument item
        // with the very same key (bank, program);
        // if yes, just remove it without prejudice...
        qsamplerInstrumentItem *pItem = findItem(pInstrument);
        if (pItem)
                delete pItem;

        pInstrument->mapInstrument();
        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()->mapInstrument();
                                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 == NULL)
                return;

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

        // Prompt user if this is for real...
        qsamplerOptions *pOptions = pMainForm->options();
        if (pOptions && pOptions->bConfirmRemove) {
                if (QMessageBox::warning(this,
                        QSAMPLER_TITLE ": " + tr("Warning"),
                        tr("Delete %1:\n\n"
                        "%2\n\n"
                        "Are you sure?")
                        .arg(pListItem->rtti() == Item ? tr("instrument") : tr("group"))
                        .arg(pListItem->text(0)),
                        tr("OK"), tr("Cancel")) > 0)
                        return;
        }

        // Unmap instrument entry...
        if (pListItem->rtti() == Item) {
                qsamplerInstrumentItem *pItem
                        = static_cast<qsamplerInstrumentItem *> (pListItem);
                if (pItem && pItem->instrument()) {
                        pItem->instrument()->unmapInstrument();
                        emit instrumentsChanged();
                }
        }

        // Do it for real...
        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()->mapInstrument();
                        emit instrumentsChanged();
                        pItem->update();
                }
        }
}


// Context menu request event handler.
void qsamplerInstrumentList::contextMenuEvent (
        QContextMenuEvent *pContextMenuEvent )
{
        if (!m_pNewItemAction->isEnabled())
                return;

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