trunk/src/qsamplerInstrumentListForm.cpp

// qsamplerInstrumentListForm.cpp
//
/****************************************************************************
   Copyright (C) 2003-2007, rncbc aka Rui Nuno Capela. All rights reserved.
   Copyright (C) 2007, Christian Schoenebeck

   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 "qsamplerInstrumentListForm.h"

#include "qsamplerInstrumentForm.h"

#include "qsamplerOptions.h"
#include "qsamplerInstrument.h"
#include "qsamplerMainForm.h"

#include <QHeaderView>


namespace QSampler {

InstrumentListForm::InstrumentListForm (
        QWidget* pParent, Qt::WindowFlags wflags )
        : QMainWindow(pParent, wflags)
{
        m_ui.setupUi(this);

        // Setup toolbar widgets.
        m_pMapComboBox = new QComboBox(m_ui.InstrumentToolbar);
        m_pMapComboBox->setMinimumWidth(120);
        m_pMapComboBox->setEnabled(false);
        m_pMapComboBox->setToolTip(tr("Instrument Map"));
        m_ui.InstrumentToolbar->addWidget(m_pMapComboBox);

        m_ui.InstrumentToolbar->addSeparator();
        m_ui.InstrumentToolbar->addAction(m_ui.newInstrumentAction);
        m_ui.InstrumentToolbar->addAction(m_ui.editInstrumentAction);
        m_ui.InstrumentToolbar->addAction(m_ui.deleteInstrumentAction);
        m_ui.InstrumentToolbar->addSeparator();
        m_ui.InstrumentToolbar->addAction(m_ui.refreshInstrumentsAction);

        int iRowHeight = m_ui.InstrumentTable->fontMetrics().height() + 4;
        m_ui.InstrumentTable->verticalHeader()->setDefaultSectionSize(iRowHeight);

        m_ui.InstrumentTable->setModel(&m_model);
        m_ui.InstrumentTable->setItemDelegate(&m_delegate);
        m_ui.InstrumentTable->verticalHeader()->hide();

        QHeaderView *pHeader = m_ui.InstrumentTable->horizontalHeader();
        pHeader->setDefaultAlignment(Qt::AlignLeft);
        pHeader->setMovable(false);
        pHeader->setStretchLastSection(true);
        pHeader->resizeSection(0, 120);                                         // Name
        m_ui.InstrumentTable->resizeColumnToContents(1);        // Map
        m_ui.InstrumentTable->resizeColumnToContents(2);        // Bank
        m_ui.InstrumentTable->resizeColumnToContents(3);        // Prog
        m_ui.InstrumentTable->resizeColumnToContents(4);        // Engine
        pHeader->resizeSection(5, 240);                                         // File
        m_ui.InstrumentTable->resizeColumnToContents(6);        // Nr
        pHeader->resizeSection(7, 60);                                          // vol

        QObject::connect(m_pMapComboBox,
                SIGNAL(activated(int)),
                SLOT(activateMap(int)));
        QObject::connect(
                m_ui.refreshInstrumentsAction,
                SIGNAL(triggered()),
                SLOT(refreshInstruments(void)));
        QObject::connect(
                m_ui.InstrumentTable,
                SIGNAL(activated(const QModelIndex&)),
                SLOT(editInstrument(const QModelIndex&)));
        QObject::connect(
                m_ui.newInstrumentAction,
                SIGNAL(triggered()),
                SLOT(newInstrument()));
        QObject::connect(
                m_ui.deleteInstrumentAction,
                SIGNAL(triggered()),
                SLOT(deleteInstrument()));
        QObject::connect(
                m_ui.editInstrumentAction,
                SIGNAL(triggered()),
                SLOT(editInstrument()));

        MainForm *pMainForm = MainForm::getInstance();
        if (pMainForm) {
                QObject::connect(&m_model,
                        SIGNAL(instrumentsChanged()),
                        pMainForm, SLOT(sessionDirty()));
        }
}


InstrumentListForm::~InstrumentListForm (void)
{
        delete m_pMapComboBox;
}


// Notify our parent that we're emerging.
void InstrumentListForm::showEvent ( QShowEvent *pShowEvent )
{
        MainForm* pMainForm = MainForm::getInstance();
        if (pMainForm)
                pMainForm->stabilizeForm();

        QWidget::showEvent(pShowEvent);
}


// Notify our parent that we're closing.
void InstrumentListForm::hideEvent ( QHideEvent *pHideEvent )
{
        QWidget::hideEvent(pHideEvent);

        MainForm* pMainForm = MainForm::getInstance();
        if (pMainForm)
                pMainForm->stabilizeForm();
}


// Just about to notify main-window that we're closing.
void InstrumentListForm::closeEvent ( QCloseEvent * /*pCloseEvent*/ )
{
        QWidget::hide();

        MainForm *pMainForm = MainForm::getInstance();
        if (pMainForm)
                pMainForm->stabilizeForm();
}


// Refresh all instrument list and views.
void InstrumentListForm::refreshInstruments (void)
{
        MainForm* pMainForm = MainForm::getInstance();
        if (pMainForm == NULL)
                return;

        qsamplerOptions *pOptions = pMainForm->options();
        if (pOptions == NULL)
                return;

        // Get/save current map selection...
        int iMap = m_pMapComboBox->currentIndex();
        if (iMap < 0 || m_pMapComboBox->count() < 2)
                iMap = pOptions->iMidiMap + 1;

        // Populate maps list.
        m_pMapComboBox->clear();
        m_pMapComboBox->addItem(tr("(All)"));
        m_pMapComboBox->insertItems(1, qsamplerInstrument::getMapNames());

        // Adjust to saved selection...
        if (iMap < 0 || iMap >= m_pMapComboBox->count())
                iMap = 0;
        m_pMapComboBox->setCurrentIndex(iMap);
        m_pMapComboBox->setEnabled(m_pMapComboBox->count() > 1);

        activateMap(iMap);
}


// Refresh instrument maps selector.
void InstrumentListForm::activateMap ( int iMap )
{
        MainForm* pMainForm = MainForm::getInstance();
        if (pMainForm == NULL)
                return;

        qsamplerOptions *pOptions = pMainForm->options();
        if (pOptions == NULL)
                return;

        int iMidiMap = iMap - 1;
        if (iMidiMap >= 0)
                pOptions->iMidiMap = iMidiMap;

        m_model.setMidiMap(iMidiMap);
        m_model.refresh();
}


void InstrumentListForm::editInstrument (void)
{
        editInstrument(m_ui.InstrumentTable->currentIndex());
}


void InstrumentListForm::editInstrument ( const QModelIndex& index )
{
        if (!index.isValid() || !index.data(Qt::UserRole).isValid())
                return;

        qsamplerInstrument* pInstrument
                = static_cast<qsamplerInstrument *> (
                        index.data(Qt::UserRole).value<void *> ());

        if (pInstrument == NULL)
                return;

        // Save current key values...
        qsamplerInstrument oldInstrument(*pInstrument);
        // Do the edit dance...
        InstrumentForm form(this);
        form.setup(pInstrument);
        if (form.exec()) {
                // Commit...
                pInstrument->mapInstrument();
                // Check whether we changed instrument key...
                if (oldInstrument.map()  == pInstrument->map()  &&
                        oldInstrument.bank() == pInstrument->bank() &&
                        oldInstrument.prog() == pInstrument->prog()) {
                        // Just update tree item...
                        //pItem->update();
                } else {
                        // Unmap old instance...
                        oldInstrument.unmapInstrument();
                        // correct the position of the instrument in the model
                        m_model.resort(*pInstrument);
                }
                // Notify we've changes...
                emit m_model.reset();
        }
}


void InstrumentListForm::newInstrument (void)
{
        qsamplerInstrument instrument;

        InstrumentForm form(this);
        form.setup(&instrument);
        if (!form.exec())
                return;

        // Commit...
        instrument.mapInstrument();
        // add new item to the table model
        m_model.resort(instrument);
        // Notify we've changes...
        //emit model.reset();
        //FIXME: call above didnt really refresh, so we use this for now ...
        refreshInstruments();
}


void InstrumentListForm::deleteInstrument (void)
{
        const QModelIndex& index = m_ui.InstrumentTable->currentIndex();
        if (!index.isValid() || !index.data(Qt::UserRole).isValid())
                return;

        qsamplerInstrument* pInstrument =
                static_cast<qsamplerInstrument*> (
                        index.data(Qt::UserRole).value<void *> ());

        if (pInstrument == NULL)
                return;

        pInstrument->unmapInstrument();
        // let the instrument vanish from the table model
        m_model.removeInstrument(*pInstrument);
        // Notify we've changes...
        emit m_model.reset();
}

} // namespace QSampler


// end of qsamplerInstrumentListForm.cpp
1	// qsamplerInstrumentListForm.cpp
2	//
3	/****************************************************************************
4	Copyright (C) 2003-2007, rncbc aka Rui Nuno Capela. All rights reserved.
5	Copyright (C) 2007, Christian Schoenebeck
6
7	This program is free software; you can redistribute it and/or
8	modify it under the terms of the GNU General Public License
9	as published by the Free Software Foundation; either version 2
10	of the License, or (at your option) any later version.
11
12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.
16
17	You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software
19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20
21	*****************************************************************************/
22
23	#include "qsamplerAbout.h"
24	#include "qsamplerInstrumentListForm.h"
25
26	#include "qsamplerInstrumentForm.h"
27
28	#include "qsamplerOptions.h"
29	#include "qsamplerInstrument.h"
30	#include "qsamplerMainForm.h"
31
32	#include <QHeaderView>
33
34
35	namespace QSampler {
36
37	InstrumentListForm::InstrumentListForm (
38	QWidget* pParent, Qt::WindowFlags wflags )
39	: QMainWindow(pParent, wflags)
40	{
41	m_ui.setupUi(this);
42
43	// Setup toolbar widgets.
44	m_pMapComboBox = new QComboBox(m_ui.InstrumentToolbar);
45	m_pMapComboBox->setMinimumWidth(120);
46	m_pMapComboBox->setEnabled(false);
47	m_pMapComboBox->setToolTip(tr("Instrument Map"));
48	m_ui.InstrumentToolbar->addWidget(m_pMapComboBox);
49
50	m_ui.InstrumentToolbar->addSeparator();
51	m_ui.InstrumentToolbar->addAction(m_ui.newInstrumentAction);
52	m_ui.InstrumentToolbar->addAction(m_ui.editInstrumentAction);
53	m_ui.InstrumentToolbar->addAction(m_ui.deleteInstrumentAction);
54	m_ui.InstrumentToolbar->addSeparator();
55	m_ui.InstrumentToolbar->addAction(m_ui.refreshInstrumentsAction);
56
57	int iRowHeight = m_ui.InstrumentTable->fontMetrics().height() + 4;
58	m_ui.InstrumentTable->verticalHeader()->setDefaultSectionSize(iRowHeight);
59
60	m_ui.InstrumentTable->setModel(&m_model);
61	m_ui.InstrumentTable->setItemDelegate(&m_delegate);
62	m_ui.InstrumentTable->verticalHeader()->hide();
63
64	QHeaderView *pHeader = m_ui.InstrumentTable->horizontalHeader();
65	pHeader->setDefaultAlignment(Qt::AlignLeft);
66	pHeader->setMovable(false);
67	pHeader->setStretchLastSection(true);
68	pHeader->resizeSection(0, 120); // Name
69	m_ui.InstrumentTable->resizeColumnToContents(1); // Map
70	m_ui.InstrumentTable->resizeColumnToContents(2); // Bank
71	m_ui.InstrumentTable->resizeColumnToContents(3); // Prog
72	m_ui.InstrumentTable->resizeColumnToContents(4); // Engine
73	pHeader->resizeSection(5, 240); // File
74	m_ui.InstrumentTable->resizeColumnToContents(6); // Nr
75	pHeader->resizeSection(7, 60); // vol
76
77	QObject::connect(m_pMapComboBox,
78	SIGNAL(activated(int)),
79	SLOT(activateMap(int)));
80	QObject::connect(
81	m_ui.refreshInstrumentsAction,
82	SIGNAL(triggered()),
83	SLOT(refreshInstruments(void)));
84	QObject::connect(
85	m_ui.InstrumentTable,
86	SIGNAL(activated(const QModelIndex&)),
87	SLOT(editInstrument(const QModelIndex&)));
88	QObject::connect(
89	m_ui.newInstrumentAction,
90	SIGNAL(triggered()),
91	SLOT(newInstrument()));
92	QObject::connect(
93	m_ui.deleteInstrumentAction,
94	SIGNAL(triggered()),
95	SLOT(deleteInstrument()));
96	QObject::connect(
97	m_ui.editInstrumentAction,
98	SIGNAL(triggered()),
99	SLOT(editInstrument()));
100
101	MainForm *pMainForm = MainForm::getInstance();
102	if (pMainForm) {
103	QObject::connect(&m_model,
104	SIGNAL(instrumentsChanged()),
105	pMainForm, SLOT(sessionDirty()));
106	}
107	}
108
109
110	InstrumentListForm::~InstrumentListForm (void)
111	{
112	delete m_pMapComboBox;
113	}
114
115
116	// Notify our parent that we're emerging.
117	void InstrumentListForm::showEvent ( QShowEvent *pShowEvent )
118	{
119	MainForm* pMainForm = MainForm::getInstance();
120	if (pMainForm)
121	pMainForm->stabilizeForm();
122
123	QWidget::showEvent(pShowEvent);
124	}
125
126
127	// Notify our parent that we're closing.
128	void InstrumentListForm::hideEvent ( QHideEvent *pHideEvent )
129	{
130	QWidget::hideEvent(pHideEvent);
131
132	MainForm* pMainForm = MainForm::getInstance();
133	if (pMainForm)
134	pMainForm->stabilizeForm();
135	}
136
137
138	// Just about to notify main-window that we're closing.
139	void InstrumentListForm::closeEvent ( QCloseEvent * /pCloseEvent/ )
140	{
141	QWidget::hide();
142
143	MainForm *pMainForm = MainForm::getInstance();
144	if (pMainForm)
145	pMainForm->stabilizeForm();
146	}
147
148
149	// Refresh all instrument list and views.
150	void InstrumentListForm::refreshInstruments (void)
151	{
152	MainForm* pMainForm = MainForm::getInstance();
153	if (pMainForm == NULL)
154	return;
155
156	qsamplerOptions *pOptions = pMainForm->options();
157	if (pOptions == NULL)
158	return;
159
160	// Get/save current map selection...
161	int iMap = m_pMapComboBox->currentIndex();
162	if (iMap < 0 \|\| m_pMapComboBox->count() < 2)
163	iMap = pOptions->iMidiMap + 1;
164
165	// Populate maps list.
166	m_pMapComboBox->clear();
167	m_pMapComboBox->addItem(tr("(All)"));
168	m_pMapComboBox->insertItems(1, qsamplerInstrument::getMapNames());
169
170	// Adjust to saved selection...
171	if (iMap < 0 \|\| iMap >= m_pMapComboBox->count())
172	iMap = 0;
173	m_pMapComboBox->setCurrentIndex(iMap);
174	m_pMapComboBox->setEnabled(m_pMapComboBox->count() > 1);
175
176	activateMap(iMap);
177	}
178
179
180	// Refresh instrument maps selector.
181	void InstrumentListForm::activateMap ( int iMap )
182	{
183	MainForm* pMainForm = MainForm::getInstance();
184	if (pMainForm == NULL)
185	return;
186
187	qsamplerOptions *pOptions = pMainForm->options();
188	if (pOptions == NULL)
189	return;
190
191	int iMidiMap = iMap - 1;
192	if (iMidiMap >= 0)
193	pOptions->iMidiMap = iMidiMap;
194
195	m_model.setMidiMap(iMidiMap);
196	m_model.refresh();
197	}
198
199
200	void InstrumentListForm::editInstrument (void)
201	{
202	editInstrument(m_ui.InstrumentTable->currentIndex());
203	}
204
205
206	void InstrumentListForm::editInstrument ( const QModelIndex& index )
207	{
208	if (!index.isValid() \|\| !index.data(Qt::UserRole).isValid())
209	return;
210
211	qsamplerInstrument* pInstrument
212	= static_cast<qsamplerInstrument *> (
213	index.data(Qt::UserRole).value<void *> ());
214
215	if (pInstrument == NULL)
216	return;
217
218	// Save current key values...
219	qsamplerInstrument oldInstrument(*pInstrument);
220	// Do the edit dance...
221	InstrumentForm form(this);
222	form.setup(pInstrument);
223	if (form.exec()) {
224	// Commit...
225	pInstrument->mapInstrument();
226	// Check whether we changed instrument key...
227	if (oldInstrument.map() == pInstrument->map() &&
228	oldInstrument.bank() == pInstrument->bank() &&
229	oldInstrument.prog() == pInstrument->prog()) {
230	// Just update tree item...
231	//pItem->update();
232	} else {
233	// Unmap old instance...
234	oldInstrument.unmapInstrument();
235	// correct the position of the instrument in the model
236	m_model.resort(*pInstrument);
237	}
238	// Notify we've changes...
239	emit m_model.reset();
240	}
241	}
242
243
244	void InstrumentListForm::newInstrument (void)
245	{
246	qsamplerInstrument instrument;
247
248	InstrumentForm form(this);
249	form.setup(&instrument);
250	if (!form.exec())
251	return;
252
253	// Commit...
254	instrument.mapInstrument();
255	// add new item to the table model
256	m_model.resort(instrument);
257	// Notify we've changes...
258	//emit model.reset();
259	//FIXME: call above didnt really refresh, so we use this for now ...
260	refreshInstruments();
261	}
262
263
264	void InstrumentListForm::deleteInstrument (void)
265	{
266	const QModelIndex& index = m_ui.InstrumentTable->currentIndex();
267	if (!index.isValid() \|\| !index.data(Qt::UserRole).isValid())
268	return;
269
270	qsamplerInstrument* pInstrument =
271	static_cast<qsamplerInstrument*> (
272	index.data(Qt::UserRole).value<void *> ());
273
274	if (pInstrument == NULL)
275	return;
276
277	pInstrument->unmapInstrument();
278	// let the instrument vanish from the table model
279	m_model.removeInstrument(*pInstrument);
280	// Notify we've changes...
281	emit m_model.reset();
282	}
283
284	} // namespace QSampler
285
286
287	// end of qsamplerInstrumentListForm.cpp