trunk/src/qsamplerInstrumentList.cpp

// qsamplerInstrumentList.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 "qsamplerInstrumentList.h"

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

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

#include <QApplication>
#include <QMessageBox>
#include <QMenu>
#include <QAction>
#include <QCursor>
#include <QFileInfo>

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

using namespace QSampler;


//-------------------------------------------------------------------------
// MidiInstrumentsModel - data model for MIDI prog mappings (used for QTableView)
//

MidiInstrumentsModel::MidiInstrumentsModel(QObject* parent) : QAbstractTableModel(parent) {
    m_iMidiMap = LSCP_MIDI_MAP_ALL;
}

int MidiInstrumentsModel::rowCount(const QModelIndex& /*parent*/) const {
    if (m_iMidiMap == LSCP_MIDI_MAP_ALL) {
        int n = 0;
        for (InstrumentsMap::const_iterator itMap = instruments.begin(); itMap != instruments.end(); ++itMap)
            n += (*itMap).size();
        return n;
    }
    InstrumentsMap::const_iterator itMap = instruments.find(m_iMidiMap);
    if (itMap == instruments.end()) return 0;
    return (*itMap).size();
}

int MidiInstrumentsModel::columnCount(const QModelIndex& /*parent*/) const {
    return 9;
}

QVariant MidiInstrumentsModel::data(const QModelIndex &index, int role) const {
    if (!index.isValid()) return QVariant();

    const qsamplerInstrument* pInstr = NULL;

    if (m_iMidiMap == LSCP_MIDI_MAP_ALL) {
        int n = 0;
        for (InstrumentsMap::const_iterator itMap = instruments.begin(); itMap != instruments.end(); ++itMap) {
            n += (*itMap).size();
            if (index.row() < n)
                pInstr = &(*itMap)[index.row() + (*itMap).size() - n];
        }
    } else {
        // resolve MIDI instrument map
        InstrumentsMap::const_iterator itMap = instruments.find(m_iMidiMap);
        if (itMap == instruments.end()) return QVariant();
        // resolve instrument in that map
        if (index.row() >= (*itMap).size()) return QVariant();
        pInstr = &(*itMap)[index.row()];
    }

    if (!pInstr) return QVariant();

    if (role == Qt::UserRole) {
        return QVariant::fromValue((void*)pInstr);
    }

    if (role == Qt::DisplayRole) {
        switch (index.column()) {
            case 0: return pInstr->name();
            case 1: return QVariant::fromValue(pInstr->map());
            case 2: return QVariant::fromValue(pInstr->bank());
            case 3: return QVariant::fromValue(pInstr->prog());
            case 4: return pInstr->engineName();
            case 5: return pInstr->instrumentFile();
            case 6: return QVariant::fromValue(pInstr->instrumentNr());
            case 7: return QString::number(pInstr->volume() * 100.0) + " %";
            case 8: {
                switch (pInstr->loadMode()) {
                    case 3: return QObject::tr("Persistent");
                    case 2: return QObject::tr("On Demand Hold");
                    case 1: return QObject::tr("On Demand");
                    default: return QVariant();
                }
            }
            default: return QVariant();
        }
    }

    return QVariant();
}

QVariant MidiInstrumentsModel::headerData(int section, Qt::Orientation orientation, int role) const {
    if (orientation != Qt::Horizontal || role != Qt::DisplayRole)
        return QVariant();

    switch (section) {
        case 0: return tr("Name");
        case 1: return tr("Map");
        case 2: return tr("Bank");
        case 3: return tr("Prog");
        case 4: return tr("Engine");
        case 5: return tr("File");
        case 6: return tr("Nr");
        case 7: return tr("Vol");
        case 8: return tr("Mode");
        default: return QVariant();
    }
}

qsamplerInstrument* MidiInstrumentsModel::addInstrument(int iMap, int iBank, int iProg) {
    // Check it there's already one instrument item
    // with the very same key (bank, program);
    // if yes, just remove it without prejudice...
    for (int i = 0; i < instruments[iMap].size(); i++) {
        if (
            instruments[iMap][i].bank() == iBank &&
            instruments[iMap][i].prog() == iProg
        ) {
            instruments[iMap].removeAt(i);
            break;
        }
    }

    // resolve the appropriate place, we keep the list sorted that way ...
    int i = 0;
    for (; i < instruments[iMap].size(); i++)
        if (
            iBank > instruments[iMap][i].bank() ||
            ( iBank == instruments[iMap][i].bank() &&
              iProg > instruments[iMap][i].prog() )
        ) break;

    instruments[iMap].insert(i, qsamplerInstrument(iMap, iBank, iProg));
    qsamplerInstrument& instr = instruments[iMap][i];
    if (!instr.getInstrument())
        instruments[iMap].removeAt(i);

    return &instr;
}

void MidiInstrumentsModel::removeInstrument(const qsamplerInstrument& instrument) {
    const int iMap  = instrument.map();
    const int iBank = instrument.bank();
    const int iProg = instrument.prog();
    for (int i = 0; i < instruments[iMap].size(); i++) {
        if (
            instruments[iMap][i].bank() == iBank &&
            instruments[iMap][i].prog() == iProg
        ) {
            instruments[iMap].removeAt(i);
            break;
        }
    }
}

// reposition the instrument in the model (called when map/bank/prg changed)
void MidiInstrumentsModel::resort(const qsamplerInstrument instrument) {
    const int iMap  = instrument.map();
    const int iBank = instrument.bank();
    const int iProg = instrument.prog();
    // remove given instrument from its current list
    removeInstrument(instrument);
    // re-add the instrument
    addInstrument(iMap, iBank, iProg);
}

void MidiInstrumentsModel::setMidiMap(int iMidiMap) {
    if (iMidiMap < 0)
        iMidiMap = LSCP_MIDI_MAP_ALL;

    m_iMidiMap = iMidiMap;
}

int MidiInstrumentsModel::midiMap() const {
    return m_iMidiMap;
}

void MidiInstrumentsModel::refresh() {
        instruments.clear();

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

        QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

        // Load the whole bunch of instrument items...
        lscp_midi_instrument_t* pInstrs
                = ::lscp_list_midi_instruments(pMainForm->client(), m_iMidiMap);
        for (int iInstr = 0; pInstrs && pInstrs[iInstr].map >= 0; ++iInstr) {
                const int iMap  = pInstrs[iInstr].map;
                const int iBank = pInstrs[iInstr].bank;
                const int iProg = pInstrs[iInstr].prog;
                addInstrument(iMap, iBank, iProg);
                // Try to keep it snappy :)
                QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
        }

        QApplication::restoreOverrideCursor();

        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."));
        }

        // inform the outer world (QTableView) that our data changed
        QAbstractTableModel::reset();
}


//-------------------------------------------------------------------------
// MidiInstrumentsDelegate - table cell renderer for MIDI prog mappings
// (doesn't actually do anything ATM, but is already there for a future
// cell editor widget implementation)

MidiInstrumentsDelegate::MidiInstrumentsDelegate(QObject* parent) : QItemDelegate(parent) {
}

QWidget* MidiInstrumentsDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const {
    return QItemDelegate::createEditor(parent, option, index);
    //return new QLabel(index.model()->data(index, Qt::DisplayRole).toString(), parent);
}

void MidiInstrumentsDelegate::setEditorData(QWidget* /*editor*/, const QModelIndex& /*index*/) const {
}

void MidiInstrumentsDelegate::setModelData(QWidget* /*editor*/, QAbstractItemModel* /*model*/, const QModelIndex& /*index*/) const {
}

void MidiInstrumentsDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const {
    QItemDelegate::updateEditorGeometry(editor, option, index);
    //if (editor) editor->setGeometry(option.rect);
}


// end of qsamplerInstrumentList.cpp
1	capela	971	// qsamplerInstrumentList.cpp
2			//
3			/****************************************************************************
4	capela	1013	Copyright (C) 2003-2007, rncbc aka Rui Nuno Capela. All rights reserved.
5	capela	1464	Copyright (C) 2007, Christian Schoenebeck
6	capela	971
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 "qsamplerInstrumentList.h"
25
26			#include "qsamplerInstrument.h"
27			#include "qsamplerInstrumentForm.h"
28
29	capela	987	#include "qsamplerOptions.h"
30	capela	971	#include "qsamplerMainForm.h"
31
32	capela	1499	#include <QApplication>
33			#include <QMessageBox>
34	schoenebeck	1461	#include <QMenu>
35	capela	1499	#include <QAction>
36			#include <QCursor>
37			#include <QFileInfo>
38	schoenebeck	1461
39	capela	971	// Needed for lroundf()
40			#include <math.h>
41
42	capela	972	#ifndef CONFIG_ROUND
43	capela	980	static inline long lroundf ( float x )
44	capela	971	{
45	capela	980	if (x >= 0.0f)
46			return long(x + 0.5f);
47			else
48			return long(x - 0.5f);
49	capela	971	}
50			#endif
51
52	schoenebeck	1461	using namespace QSampler;
53	capela	971
54
55	schoenebeck	1492	//-------------------------------------------------------------------------
56			// MidiInstrumentsModel - data model for MIDI prog mappings (used for QTableView)
57	capela	971	//
58
59	schoenebeck	1461	MidiInstrumentsModel::MidiInstrumentsModel(QObject* parent) : QAbstractTableModel(parent) {
60			m_iMidiMap = LSCP_MIDI_MAP_ALL;
61			}
62	capela	971
63	schoenebeck	1461	int MidiInstrumentsModel::rowCount(const QModelIndex& /parent/) const {
64			if (m_iMidiMap == LSCP_MIDI_MAP_ALL) {
65			int n = 0;
66			for (InstrumentsMap::const_iterator itMap = instruments.begin(); itMap != instruments.end(); ++itMap)
67			n += (*itMap).size();
68			return n;
69			}
70			InstrumentsMap::const_iterator itMap = instruments.find(m_iMidiMap);
71			if (itMap == instruments.end()) return 0;
72			return (*itMap).size();
73			}
74
75			int MidiInstrumentsModel::columnCount(const QModelIndex& /parent/) const {
76			return 9;
77			}
78
79			QVariant MidiInstrumentsModel::data(const QModelIndex &index, int role) const {
80	schoenebeck	1492	if (!index.isValid()) return QVariant();
81	schoenebeck	1461
82	schoenebeck	1492	const qsamplerInstrument* pInstr = NULL;
83
84	schoenebeck	1461	if (m_iMidiMap == LSCP_MIDI_MAP_ALL) {
85			int n = 0;
86			for (InstrumentsMap::const_iterator itMap = instruments.begin(); itMap != instruments.end(); ++itMap) {
87			n += (*itMap).size();
88			if (index.row() < n)
89	schoenebeck	1492	pInstr = &(itMap)[index.row() + (itMap).size() - n];
90	schoenebeck	1461	}
91			} else {
92			// resolve MIDI instrument map
93			InstrumentsMap::const_iterator itMap = instruments.find(m_iMidiMap);
94			if (itMap == instruments.end()) return QVariant();
95			// resolve instrument in that map
96			if (index.row() >= (*itMap).size()) return QVariant();
97	schoenebeck	1492	pInstr = &(*itMap)[index.row()];
98	schoenebeck	1461	}
99
100	schoenebeck	1492	if (!pInstr) return QVariant();
101
102			if (role == Qt::UserRole) {
103			return QVariant::fromValue((void*)pInstr);
104			}
105
106			if (role == Qt::DisplayRole) {
107			switch (index.column()) {
108			case 0: return pInstr->name();
109			case 1: return QVariant::fromValue(pInstr->map());
110			case 2: return QVariant::fromValue(pInstr->bank());
111			case 3: return QVariant::fromValue(pInstr->prog());
112			case 4: return pInstr->engineName();
113			case 5: return pInstr->instrumentFile();
114			case 6: return QVariant::fromValue(pInstr->instrumentNr());
115			case 7: return QString::number(pInstr->volume() * 100.0) + " %";
116			case 8: {
117			switch (pInstr->loadMode()) {
118			case 3: return QObject::tr("Persistent");
119			case 2: return QObject::tr("On Demand Hold");
120			case 1: return QObject::tr("On Demand");
121			default: return QVariant();
122			}
123			}
124			default: return QVariant();
125			}
126			}
127
128	schoenebeck	1461	return QVariant();
129			}
130
131			QVariant MidiInstrumentsModel::headerData(int section, Qt::Orientation orientation, int role) const {
132			if (orientation != Qt::Horizontal \|\| role != Qt::DisplayRole)
133			return QVariant();
134
135			switch (section) {
136			case 0: return tr("Name");
137			case 1: return tr("Map");
138			case 2: return tr("Bank");
139			case 3: return tr("Prog");
140			case 4: return tr("Engine");
141			case 5: return tr("File");
142			case 6: return tr("Nr");
143			case 7: return tr("Vol");
144			case 8: return tr("Mode");
145			default: return QVariant();
146			}
147			}
148
149			qsamplerInstrument* MidiInstrumentsModel::addInstrument(int iMap, int iBank, int iProg) {
150			// Check it there's already one instrument item
151			// with the very same key (bank, program);
152			// if yes, just remove it without prejudice...
153			for (int i = 0; i < instruments[iMap].size(); i++) {
154			if (
155			instruments[iMap][i].bank() == iBank &&
156			instruments[iMap][i].prog() == iProg
157			) {
158			instruments[iMap].removeAt(i);
159			break;
160			}
161			}
162
163			// resolve the appropriate place, we keep the list sorted that way ...
164			int i = 0;
165			for (; i < instruments[iMap].size(); i++)
166			if (
167			iBank > instruments[iMap][i].bank() \|\|
168			( iBank == instruments[iMap][i].bank() &&
169			iProg > instruments[iMap][i].prog() )
170			) break;
171
172	schoenebeck	1492	instruments[iMap].insert(i, qsamplerInstrument(iMap, iBank, iProg));
173			qsamplerInstrument& instr = instruments[iMap][i];
174			if (!instr.getInstrument())
175			instruments[iMap].removeAt(i);
176	schoenebeck	1461
177			return &instr;
178			}
179
180	schoenebeck	1492	void MidiInstrumentsModel::removeInstrument(const qsamplerInstrument& instrument) {
181			const int iMap = instrument.map();
182			const int iBank = instrument.bank();
183			const int iProg = instrument.prog();
184			for (int i = 0; i < instruments[iMap].size(); i++) {
185			if (
186			instruments[iMap][i].bank() == iBank &&
187			instruments[iMap][i].prog() == iProg
188			) {
189			instruments[iMap].removeAt(i);
190			break;
191			}
192			}
193			}
194
195			// reposition the instrument in the model (called when map/bank/prg changed)
196			void MidiInstrumentsModel::resort(const qsamplerInstrument instrument) {
197			const int iMap = instrument.map();
198			const int iBank = instrument.bank();
199			const int iProg = instrument.prog();
200			// remove given instrument from its current list
201			removeInstrument(instrument);
202			// re-add the instrument
203			addInstrument(iMap, iBank, iProg);
204			}
205
206	schoenebeck	1461	void MidiInstrumentsModel::setMidiMap(int iMidiMap) {
207			if (iMidiMap < 0)
208			iMidiMap = LSCP_MIDI_MAP_ALL;
209
210			m_iMidiMap = iMidiMap;
211			}
212
213			int MidiInstrumentsModel::midiMap() const {
214			return m_iMidiMap;
215			}
216
217			void MidiInstrumentsModel::refresh() {
218			instruments.clear();
219
220			MainForm* pMainForm = MainForm::getInstance();
221			if (pMainForm == NULL)
222			return;
223			if (pMainForm->client() == NULL)
224			return;
225
226			QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
227
228			// Load the whole bunch of instrument items...
229			lscp_midi_instrument_t* pInstrs
230			= ::lscp_list_midi_instruments(pMainForm->client(), m_iMidiMap);
231			for (int iInstr = 0; pInstrs && pInstrs[iInstr].map >= 0; ++iInstr) {
232			const int iMap = pInstrs[iInstr].map;
233			const int iBank = pInstrs[iInstr].bank;
234			const int iProg = pInstrs[iInstr].prog;
235			addInstrument(iMap, iBank, iProg);
236			// Try to keep it snappy :)
237	capela	1499	QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
238	schoenebeck	1461	}
239
240			QApplication::restoreOverrideCursor();
241
242			if (pInstrs == NULL && ::lscp_client_get_errno(pMainForm->client())) {
243			pMainForm->appendMessagesClient("lscp_list_midi_instruments");
244			pMainForm->appendMessagesError(tr("Could not get current list of MIDI instrument mappings.\n\nSorry."));
245			}
246
247	schoenebeck	1492	// inform the outer world (QTableView) that our data changed
248			QAbstractTableModel::reset();
249	schoenebeck	1461	}
250
251
252	schoenebeck	1492	//-------------------------------------------------------------------------
253			// MidiInstrumentsDelegate - table cell renderer for MIDI prog mappings
254			// (doesn't actually do anything ATM, but is already there for a future
255			// cell editor widget implementation)
256
257	schoenebeck	1461	MidiInstrumentsDelegate::MidiInstrumentsDelegate(QObject* parent) : QItemDelegate(parent) {
258			}
259
260			QWidget* MidiInstrumentsDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const {
261	schoenebeck	1492	return QItemDelegate::createEditor(parent, option, index);
262			//return new QLabel(index.model()->data(index, Qt::DisplayRole).toString(), parent);
263	schoenebeck	1461	}
264
265	schoenebeck	1492	void MidiInstrumentsDelegate::setEditorData(QWidget* /editor/, const QModelIndex& /index/) const {
266	schoenebeck	1461	}
267
268	schoenebeck	1492	void MidiInstrumentsDelegate::setModelData(QWidget* /editor/, QAbstractItemModel* /model/, const QModelIndex& /index/) const {
269	schoenebeck	1461	}
270
271			void MidiInstrumentsDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const {
272	schoenebeck	1492	QItemDelegate::updateEditorGeometry(editor, option, index);
273			//if (editor) editor->setGeometry(option.rect);
274	schoenebeck	1461	}
275
276	capela	1464
277	capela	971	// end of qsamplerInstrumentList.cpp