trunk/src/qsamplerInstrumentListForm.cpp

// qsamplerInstrumentListForm.cpp
//
/****************************************************************************
   Copyright (C) 2003-2010, 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 "qsamplerInstrumentList.h"

#include "qsamplerInstrumentForm.h"

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

#include <QHeaderView>
#include <QMessageBox>
#include <QContextMenuEvent>


namespace QSampler {

//-------------------------------------------------------------------------
// QSampler::InstrumentListForm -- Instrument map list form implementation.
//

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

        m_pInstrumentListView = new InstrumentListView(this);
        QMainWindow::setCentralWidget(m_pInstrumentListView);

        // 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);

        QObject::connect(m_pMapComboBox,
                SIGNAL(activated(int)),
                SLOT(activateMap(int)));
        QObject::connect(m_pInstrumentListView->selectionModel(),
                SIGNAL(currentRowChanged(const QModelIndex&,const QModelIndex&)),
                SLOT(stabilizeForm()));
        QObject::connect(
                m_pInstrumentListView,
                SIGNAL(doubleClicked(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()));
        QObject::connect(
                m_ui.refreshInstrumentsAction,
                SIGNAL(triggered()),
                SLOT(refreshInstruments()));

        // Things must be stable from the start.
        stabilizeForm();
}


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


// 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;

        Options *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, Instrument::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;

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

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

        m_pInstrumentListView->setMidiMap(iMidiMap);
        m_pInstrumentListView->refresh();

        stabilizeForm();
}


void InstrumentListForm::editInstrument (void)
{
        editInstrument(m_pInstrumentListView->currentIndex());
}


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

        Instrument *pInstrument
                = static_cast<Instrument *> (index.internalPointer());
        if (pInstrument == NULL)
                return;

        // Save current key values...
        int iMap  = pInstrument->map();
        int iBank = pInstrument->bank();
        int iProg = pInstrument->prog();

        Instrument instrument(iMap, iBank, iProg);

        // Do the edit dance...
        InstrumentForm form(this);
        form.setup(&instrument);
        if (form.exec()) {
                // Commit...
                instrument.mapInstrument();
                // Check whether we changed instrument key...
                if (instrument.map()  == iMap  &&
                        instrument.bank() == iBank &&
                        instrument.prog() == iProg) {
                        // Just update tree item...
                        //pItem->update();
                } else {
                        // Unmap old instance...
                        Instrument(iMap, iBank, iProg).unmapInstrument();
                        // correct the position of the instrument in the model
                        m_pInstrumentListView->updateInstrument(pInstrument);
                }
        }

        stabilizeForm();
}


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

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

        // Commit...
        instrument.mapInstrument();

        // add new item to the table model
        m_pInstrumentListView->addInstrument(
                instrument.map(),
                instrument.bank(),
                instrument.prog());

        stabilizeForm();
}


void InstrumentListForm::deleteInstrument (void)
{
        const QModelIndex& index = m_pInstrumentListView->currentIndex();
        if (!index.isValid())
                return;

        Instrument *pInstrument
                = static_cast<Instrument *> (index.internalPointer());
        if (pInstrument == NULL)
                return;

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

        // Prompt user if this is for real...
        Options *pOptions = pMainForm->options();
        if (pOptions && pOptions->bConfirmRemove) {
                if (QMessageBox::warning(this,
                        QSAMPLER_TITLE ": " + tr("Warning"),
                        tr("About to delete instrument map entry:\n\n"
                        "%1\n\n"
                        "Are you sure?")
                        .arg(pInstrument->name()),
                        QMessageBox::Ok | QMessageBox::Cancel)
                        == QMessageBox::Cancel)
                        return;
        }

        pInstrument->unmapInstrument();

        // let the instrument vanish from the table model
        m_pInstrumentListView->removeInstrument(pInstrument);

        stabilizeForm();
}


// Update form actions enablement...
void InstrumentListForm::stabilizeForm (void)
{
        MainForm *pMainForm = MainForm::getInstance();

        bool bEnabled = (pMainForm && pMainForm->client());
        m_ui.newInstrumentAction->setEnabled(bEnabled);
        const QModelIndex& index = m_pInstrumentListView->currentIndex();
        bEnabled = (bEnabled && index.isValid());
        m_ui.editInstrumentAction->setEnabled(bEnabled);
        m_ui.deleteInstrumentAction->setEnabled(bEnabled);
}


// Context menu request.
void InstrumentListForm::contextMenuEvent (
        QContextMenuEvent *pContextMenuEvent )
{
        if (m_ui.newInstrumentAction->isEnabled())
                m_ui.contextMenu->exec(pContextMenuEvent->globalPos());
}


} // namespace QSampler


// end of qsamplerInstrumentListForm.cpp
1	// qsamplerInstrumentListForm.cpp
2	//
3	/****************************************************************************
4	Copyright (C) 2003-2010, 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 "qsamplerInstrumentList.h"
27
28	#include "qsamplerInstrumentForm.h"
29
30	#include "qsamplerOptions.h"
31	#include "qsamplerInstrument.h"
32	#include "qsamplerMainForm.h"
33
34	#include <QHeaderView>
35	#include <QMessageBox>
36	#include <QContextMenuEvent>
37
38
39	namespace QSampler {
40
41	//-------------------------------------------------------------------------
42	// QSampler::InstrumentListForm -- Instrument map list form implementation.
43	//
44
45	InstrumentListForm::InstrumentListForm (
46	QWidget* pParent, Qt::WindowFlags wflags )
47	: QMainWindow(pParent, wflags)
48	{
49	m_ui.setupUi(this);
50
51	m_pInstrumentListView = new InstrumentListView(this);
52	QMainWindow::setCentralWidget(m_pInstrumentListView);
53
54	// Setup toolbar widgets.
55	m_pMapComboBox = new QComboBox(m_ui.instrumentToolbar);
56	m_pMapComboBox->setMinimumWidth(120);
57	m_pMapComboBox->setEnabled(false);
58	m_pMapComboBox->setToolTip(tr("Instrument Map"));
59
60	m_ui.instrumentToolbar->addWidget(m_pMapComboBox);
61	m_ui.instrumentToolbar->addSeparator();
62	m_ui.instrumentToolbar->addAction(m_ui.newInstrumentAction);
63	m_ui.instrumentToolbar->addAction(m_ui.editInstrumentAction);
64	m_ui.instrumentToolbar->addAction(m_ui.deleteInstrumentAction);
65	m_ui.instrumentToolbar->addSeparator();
66	m_ui.instrumentToolbar->addAction(m_ui.refreshInstrumentsAction);
67
68	QObject::connect(m_pMapComboBox,
69	SIGNAL(activated(int)),
70	SLOT(activateMap(int)));
71	QObject::connect(m_pInstrumentListView->selectionModel(),
72	SIGNAL(currentRowChanged(const QModelIndex&,const QModelIndex&)),
73	SLOT(stabilizeForm()));
74	QObject::connect(
75	m_pInstrumentListView,
76	SIGNAL(doubleClicked(const QModelIndex&)),
77	SLOT(editInstrument(const QModelIndex&)));
78	QObject::connect(
79	m_ui.newInstrumentAction,
80	SIGNAL(triggered()),
81	SLOT(newInstrument()));
82	QObject::connect(
83	m_ui.deleteInstrumentAction,
84	SIGNAL(triggered()),
85	SLOT(deleteInstrument()));
86	QObject::connect(
87	m_ui.editInstrumentAction,
88	SIGNAL(triggered()),
89	SLOT(editInstrument()));
90	QObject::connect(
91	m_ui.refreshInstrumentsAction,
92	SIGNAL(triggered()),
93	SLOT(refreshInstruments()));
94
95	// Things must be stable from the start.
96	stabilizeForm();
97	}
98
99
100	InstrumentListForm::~InstrumentListForm (void)
101	{
102	delete m_pMapComboBox;
103	delete m_pInstrumentListView;
104	}
105
106
107	// Notify our parent that we're emerging.
108	void InstrumentListForm::showEvent ( QShowEvent *pShowEvent )
109	{
110	MainForm* pMainForm = MainForm::getInstance();
111	if (pMainForm)
112	pMainForm->stabilizeForm();
113
114	QWidget::showEvent(pShowEvent);
115	}
116
117
118	// Notify our parent that we're closing.
119	void InstrumentListForm::hideEvent ( QHideEvent *pHideEvent )
120	{
121	QWidget::hideEvent(pHideEvent);
122
123	MainForm* pMainForm = MainForm::getInstance();
124	if (pMainForm)
125	pMainForm->stabilizeForm();
126	}
127
128
129	// Just about to notify main-window that we're closing.
130	void InstrumentListForm::closeEvent ( QCloseEvent * /pCloseEvent/ )
131	{
132	QWidget::hide();
133
134	MainForm *pMainForm = MainForm::getInstance();
135	if (pMainForm)
136	pMainForm->stabilizeForm();
137	}
138
139
140	// Refresh all instrument list and views.
141	void InstrumentListForm::refreshInstruments (void)
142	{
143	MainForm* pMainForm = MainForm::getInstance();
144	if (pMainForm == NULL)
145	return;
146
147	Options *pOptions = pMainForm->options();
148	if (pOptions == NULL)
149	return;
150
151	// Get/save current map selection...
152	int iMap = m_pMapComboBox->currentIndex();
153	if (iMap < 0 \|\| m_pMapComboBox->count() < 2)
154	iMap = pOptions->iMidiMap + 1;
155
156	// Populate maps list.
157	m_pMapComboBox->clear();
158	m_pMapComboBox->addItem(tr("(All)"));
159	m_pMapComboBox->insertItems(1, Instrument::getMapNames());
160
161	// Adjust to saved selection...
162	if (iMap < 0 \|\| iMap >= m_pMapComboBox->count())
163	iMap = 0;
164	m_pMapComboBox->setCurrentIndex(iMap);
165	m_pMapComboBox->setEnabled(m_pMapComboBox->count() > 1);
166
167	activateMap(iMap);
168	}
169
170
171	// Refresh instrument maps selector.
172	void InstrumentListForm::activateMap ( int iMap )
173	{
174	MainForm* pMainForm = MainForm::getInstance();
175	if (pMainForm == NULL)
176	return;
177
178	Options *pOptions = pMainForm->options();
179	if (pOptions == NULL)
180	return;
181
182	int iMidiMap = iMap - 1;
183	if (iMidiMap >= 0)
184	pOptions->iMidiMap = iMidiMap;
185
186	m_pInstrumentListView->setMidiMap(iMidiMap);
187	m_pInstrumentListView->refresh();
188
189	stabilizeForm();
190	}
191
192
193	void InstrumentListForm::editInstrument (void)
194	{
195	editInstrument(m_pInstrumentListView->currentIndex());
196	}
197
198
199	void InstrumentListForm::editInstrument ( const QModelIndex& index )
200	{
201	if (!index.isValid())
202	return;
203
204	Instrument *pInstrument
205	= static_cast<Instrument *> (index.internalPointer());
206	if (pInstrument == NULL)
207	return;
208
209	// Save current key values...
210	int iMap = pInstrument->map();
211	int iBank = pInstrument->bank();
212	int iProg = pInstrument->prog();
213
214	Instrument instrument(iMap, iBank, iProg);
215
216	// Do the edit dance...
217	InstrumentForm form(this);
218	form.setup(&instrument);
219	if (form.exec()) {
220	// Commit...
221	instrument.mapInstrument();
222	// Check whether we changed instrument key...
223	if (instrument.map() == iMap &&
224	instrument.bank() == iBank &&
225	instrument.prog() == iProg) {
226	// Just update tree item...
227	//pItem->update();
228	} else {
229	// Unmap old instance...
230	Instrument(iMap, iBank, iProg).unmapInstrument();
231	// correct the position of the instrument in the model
232	m_pInstrumentListView->updateInstrument(pInstrument);
233	}
234	}
235
236	stabilizeForm();
237	}
238
239
240	void InstrumentListForm::newInstrument (void)
241	{
242	Instrument instrument;
243
244	InstrumentForm form(this);
245	form.setup(&instrument);
246	if (!form.exec())
247	return;
248
249	// Commit...
250	instrument.mapInstrument();
251
252	// add new item to the table model
253	m_pInstrumentListView->addInstrument(
254	instrument.map(),
255	instrument.bank(),
256	instrument.prog());
257
258	stabilizeForm();
259	}
260
261
262	void InstrumentListForm::deleteInstrument (void)
263	{
264	const QModelIndex& index = m_pInstrumentListView->currentIndex();
265	if (!index.isValid())
266	return;
267
268	Instrument *pInstrument
269	= static_cast<Instrument *> (index.internalPointer());
270	if (pInstrument == NULL)
271	return;
272
273	MainForm *pMainForm = MainForm::getInstance();
274	if (pMainForm == NULL)
275	return;
276
277	// Prompt user if this is for real...
278	Options *pOptions = pMainForm->options();
279	if (pOptions && pOptions->bConfirmRemove) {
280	if (QMessageBox::warning(this,
281	QSAMPLER_TITLE ": " + tr("Warning"),
282	tr("About to delete instrument map entry:\n\n"
283	"%1\n\n"
284	"Are you sure?")
285	.arg(pInstrument->name()),
286	QMessageBox::Ok \| QMessageBox::Cancel)
287	== QMessageBox::Cancel)
288	return;
289	}
290
291	pInstrument->unmapInstrument();
292
293	// let the instrument vanish from the table model
294	m_pInstrumentListView->removeInstrument(pInstrument);
295
296	stabilizeForm();
297	}
298
299
300	// Update form actions enablement...
301	void InstrumentListForm::stabilizeForm (void)
302	{
303	MainForm *pMainForm = MainForm::getInstance();
304
305	bool bEnabled = (pMainForm && pMainForm->client());
306	m_ui.newInstrumentAction->setEnabled(bEnabled);
307	const QModelIndex& index = m_pInstrumentListView->currentIndex();
308	bEnabled = (bEnabled && index.isValid());
309	m_ui.editInstrumentAction->setEnabled(bEnabled);
310	m_ui.deleteInstrumentAction->setEnabled(bEnabled);
311	}
312
313
314	// Context menu request.
315	void InstrumentListForm::contextMenuEvent (
316	QContextMenuEvent *pContextMenuEvent )
317	{
318	if (m_ui.newInstrumentAction->isEnabled())
319	m_ui.contextMenu->exec(pContextMenuEvent->globalPos());
320	}
321
322
323	} // namespace QSampler
324
325
326	// end of qsamplerInstrumentListForm.cpp