/[svn]/qsampler/trunk/src/qsamplerInstrumentList.cpp
ViewVC logotype

Annotation of /qsampler/trunk/src/qsamplerInstrumentList.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1463 - (hide annotations) (download)
Thu Nov 1 13:01:27 2007 UTC (12 years, 5 months ago) by capela
File size: 24431 byte(s)
* Qt4 migration: configure and icon/pixmaps resource arrangement.

1 capela 971 // qsamplerInstrumentList.cpp
2     //
3     /****************************************************************************
4 capela 1013 Copyright (C) 2003-2007, rncbc aka Rui Nuno Capela. All rights reserved.
5 capela 971
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 capela 987 #include "qsamplerOptions.h"
29 capela 971 #include "qsamplerMainForm.h"
30    
31 capela 1015 #include <qapplication.h>
32 capela 987 #include <qmessagebox.h>
33 capela 1015 #include <qeventloop.h>
34 capela 971 #include <qaction.h>
35 capela 1015 #include <qcursor.h>
36 capela 971 #include <qfileinfo.h>
37    
38 schoenebeck 1461 #include <QMenu>
39    
40 capela 971 // Needed for lroundf()
41     #include <math.h>
42    
43 capela 972 #ifndef CONFIG_ROUND
44 capela 980 static inline long lroundf ( float x )
45 capela 971 {
46 capela 980 if (x >= 0.0f)
47     return long(x + 0.5f);
48     else
49     return long(x - 0.5f);
50 capela 971 }
51     #endif
52    
53 schoenebeck 1461 using namespace QSampler;
54 capela 971
55     //----------------------------------------------------------------------
56     // class qsamplerInstrumentGroup -- custom group list view item.
57     //
58    
59 schoenebeck 1461 #if 0
60 capela 971 // Constructors.
61     qsamplerInstrumentGroup::qsamplerInstrumentGroup (
62     qsamplerInstrumentList *pListView, const QString& sName,
63     QListViewItem *pItemAfter )
64     : QListViewItem(pListView, pItemAfter ? pItemAfter : pListView->lastItem())
65     {
66     QListViewItem::setRenameEnabled(0, true);
67    
68 capela 1463 QListViewItem::setPixmap(0, QPixmap(":/icons/itemGroup.png"));
69 capela 971 QListViewItem::setText(0, sName);
70     }
71    
72    
73     qsamplerInstrumentGroup::qsamplerInstrumentGroup (
74     qsamplerInstrumentGroup *pGroupItem, const QString& sName )
75     : QListViewItem(pGroupItem, sName)
76     {
77     QListViewItem::setRenameEnabled(0, true);
78    
79 capela 1463 QListViewItem::setPixmap(0, QPixmap(":/icons/itemGroup.png"));
80 capela 971 }
81    
82    
83     // Default destructor.
84     qsamplerInstrumentGroup::~qsamplerInstrumentGroup (void)
85     {
86     }
87    
88    
89     // Instance accessors.
90     void qsamplerInstrumentGroup::setName ( const QString& sName )
91     {
92     QListViewItem::setText(0, sName);
93     }
94    
95    
96     QString qsamplerInstrumentGroup::name (void) const
97     {
98     return QListViewItem::text(0);
99     }
100    
101    
102     qsamplerInstrumentGroup *qsamplerInstrumentGroup::groupItem (void) const
103     {
104     QListViewItem *pParent = QListViewItem::parent();
105     while (pParent && pParent->rtti() != qsamplerInstrumentList::Group)
106     pParent = pParent->parent();
107     return static_cast<qsamplerInstrumentGroup *> (pParent);
108     }
109    
110    
111     qsamplerInstrumentList *qsamplerInstrumentGroup::listView (void) const
112     {
113     return static_cast<qsamplerInstrumentList *> (QListViewItem::listView());
114     }
115    
116    
117     // To show up whether its open or not.
118     void qsamplerInstrumentGroup::setOpen ( bool bOpen )
119     {
120     // Set the proper pixmap of this...
121     if (rtti() == qsamplerInstrumentList::Group) {
122 capela 1463 QListViewItem::setPixmap(0, QPixmap(bOpen ?
123     ":/icons/itemGroupOpen.png" : ":/icons/itemGroup.png"));
124 capela 971 }
125     // Open it up...
126     QListViewItem::setOpen(bOpen);
127    
128     // All ancestors should be also visible.
129     if (bOpen && QListViewItem::parent())
130     QListViewItem::parent()->setOpen(true);
131     }
132    
133    
134     // To virtually distinguish between list view items.
135     int qsamplerInstrumentGroup::rtti (void) const
136     {
137     return qsamplerInstrumentList::Group;
138     }
139    
140    
141     //----------------------------------------------------------------------
142     // class qsamplerInstrumentItem -- custom file list view item.
143     //
144    
145     // Constructors.
146     qsamplerInstrumentItem::qsamplerInstrumentItem (
147     qsamplerInstrumentList *pListView,
148     qsamplerInstrument *pInstrument,
149     QListViewItem *pItemAfter )
150     : qsamplerInstrumentGroup(pListView, pInstrument->name(), pItemAfter)
151     {
152     m_pInstrument = pInstrument;
153    
154     update();
155     }
156    
157     qsamplerInstrumentItem::qsamplerInstrumentItem (
158     qsamplerInstrumentGroup *pGroupItem,
159     qsamplerInstrument *pInstrument )
160     : qsamplerInstrumentGroup(pGroupItem, pInstrument->name())
161     {
162     m_pInstrument = pInstrument;
163    
164     update();
165     }
166    
167    
168     // Default destructor.
169     qsamplerInstrumentItem::~qsamplerInstrumentItem (void)
170     {
171     if (m_pInstrument)
172     delete m_pInstrument;
173     }
174    
175    
176     // To virtually distinguish between list view items.
177     int qsamplerInstrumentItem::rtti (void) const
178     {
179     return qsamplerInstrumentList::Item;
180     }
181    
182    
183     // Payload accessor.
184     qsamplerInstrument *qsamplerInstrumentItem::instrument (void) const
185     {
186     return m_pInstrument;
187     }
188    
189    
190     // Item refreshment.
191     void qsamplerInstrumentItem::update (void)
192     {
193 capela 1463 QListViewItem::setPixmap(0, QPixmap(":/icons/itemFile.png"));
194 capela 971
195     const QString s = "-";
196     if (m_pInstrument) {
197     setText(0, m_pInstrument->name());
198 capela 980 setText(1, QString::number(m_pInstrument->map()));
199     setText(2, QString::number(m_pInstrument->bank()));
200     setText(3, QString::number(m_pInstrument->prog() + 1));
201     setText(4, m_pInstrument->engineName());
202     setText(5, QFileInfo(m_pInstrument->instrumentFile()).fileName());
203     setText(6, QString::number(m_pInstrument->instrumentNr()));
204     setText(7, QString::number(::lroundf(100.0f * m_pInstrument->volume())));
205 capela 971 QString sLoadMode = s;
206     switch (m_pInstrument->loadMode()) {
207     case 3:
208     sLoadMode = QObject::tr("Persistent");
209     break;
210     case 2:
211     sLoadMode = QObject::tr("On Demand Hold");
212     break;
213     case 1:
214     sLoadMode = QObject::tr("On Demand");
215     break;
216     }
217 capela 980 setText(8, sLoadMode);
218 capela 971 } else {
219     for (int i = 0; i < listView()->columns(); i++)
220     setText(i, s);
221     }
222     }
223    
224    
225     //----------------------------------------------------------------------------
226     // qsamplerInstrumentList -- MIDI instrument list view.
227     //
228    
229     // Constructor.
230     qsamplerInstrumentList::qsamplerInstrumentList (
231     QWidget *pParent, const char *pszName )
232     : QListView(pParent, pszName)
233     {
234 capela 1013 m_iMidiMap = LSCP_MIDI_MAP_ALL;
235    
236 capela 971 // QListView::setRootIsDecorated(true);
237 capela 1013 QListView::setAllColumnsShowFocus(true);
238 capela 971 QListView::setResizeMode(QListView::NoColumn);
239     // QListView::setAcceptDrops(true);
240     QListView::setDragAutoScroll(true);
241     QListView::setSizePolicy(
242     QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
243     // QListView::setShowToolTips(false);
244     QListView::setSortColumn(-1);
245    
246     QListView::addColumn(tr("Name"));
247 capela 980 QListView::addColumn(tr("Map"));
248 capela 971 QListView::addColumn(tr("Bank"));
249     QListView::addColumn(tr("Prog"));
250     QListView::addColumn(tr("Engine"));
251     QListView::addColumn(tr("File"));
252     QListView::addColumn(tr("Nr"));
253     QListView::addColumn(tr("Vol"));
254     QListView::addColumn(tr("Mode"));
255    
256 capela 980 QListView::setColumnAlignment(1, Qt::AlignHCenter); // Map
257     QListView::setColumnAlignment(2, Qt::AlignHCenter); // Bank
258     QListView::setColumnAlignment(3, Qt::AlignHCenter); // Prog
259     QListView::setColumnAlignment(6, Qt::AlignHCenter); // Nr
260     QListView::setColumnAlignment(7, Qt::AlignHCenter); // Vol
261 capela 971
262 capela 980 QListView::setColumnWidth(0, 120); // Name
263     QListView::setColumnWidth(5, 240); // File
264 capela 971
265 capela 1013 m_pNewGroupAction = new QAction(
266 capela 1463 QIcon(":/icons/itemGroupNew.png"),
267 capela 1013 tr("New &Group"), tr("Ctrl+G"), this);
268     m_pNewItemAction = new QAction(
269 capela 1463 QIcon(":/icons/itemNew.png"),
270 capela 1013 tr("New &Instrument..."), tr("Ins"), this);
271     m_pEditItemAction = new QAction(
272 capela 1463 QIcon(":/icons/formEdit.png"),
273 capela 1013 tr("&Edit..."), tr("Enter"), this);
274 capela 987 m_pRenameAction = new QAction(tr("&Rename"), tr("F2"), this);
275 capela 1013 m_pDeleteAction = new QAction(
276 capela 1463 QIcon(":/icons/formRemove.png"),
277 capela 1013 tr("&Delete"), tr("Del"), this);
278     m_pRefreshAction = new QAction(
279 capela 1463 QIcon(":/icons/formRefresh.png"),
280 capela 1013 tr("Re&fresh"), tr("F5"), this);
281 capela 971
282 capela 1013 m_pNewGroupAction->setToolTip(tr("New Group"));
283     m_pNewItemAction->setToolTip(tr("New Instrument"));
284     m_pEditItemAction->setToolTip(tr("Edit"));
285     m_pRenameAction->setToolTip(tr("Rename"));
286     m_pDeleteAction->setToolTip(tr("Delete"));
287     m_pRefreshAction->setToolTip(tr("Refresh"));
288    
289 capela 971 QObject::connect(m_pNewGroupAction,
290     SIGNAL(activated()),
291     SLOT(newGroupSlot()));
292     QObject::connect(m_pNewItemAction,
293     SIGNAL(activated()),
294     SLOT(newItemSlot()));
295     QObject::connect(m_pEditItemAction,
296     SIGNAL(activated()),
297     SLOT(editItemSlot()));
298     QObject::connect(m_pRenameAction,
299     SIGNAL(activated()),
300     SLOT(renameSlot()));
301     QObject::connect(m_pDeleteAction,
302     SIGNAL(activated()),
303     SLOT(deleteSlot()));
304     QObject::connect(m_pRefreshAction,
305     SIGNAL(activated()),
306     SLOT(refresh()));
307    
308     QObject::connect(this,
309     SIGNAL(selectionChanged()),
310     SLOT(selectionChangedSlot()));
311     QObject::connect(this,
312     SIGNAL(doubleClicked(QListViewItem*, const QPoint&, int)),
313     SLOT(activatedSlot(QListViewItem*)));
314     QObject::connect(this,
315     SIGNAL(returnPressed(QListViewItem*)),
316     SLOT(activatedSlot(QListViewItem*)));
317     QObject::connect(this,
318     SIGNAL(itemRenamed(QListViewItem*,int)),
319     SLOT(renamedSlot(QListViewItem*)));
320    
321     selectionChangedSlot();
322     }
323    
324    
325     // Default destructor.
326     qsamplerInstrumentList::~qsamplerInstrumentList (void)
327     {
328     delete m_pNewGroupAction;
329     delete m_pNewItemAction;
330     delete m_pEditItemAction;
331     delete m_pRenameAction;
332     delete m_pDeleteAction;
333     }
334    
335    
336     // Add a new instrument item, optionally under a given group.
337     qsamplerInstrumentItem *qsamplerInstrumentList::addItem (
338     qsamplerInstrument *pInstrument,
339     qsamplerInstrumentGroup *pParentGroup )
340     {
341 capela 1013 // Check it there's already one instrument item
342     // with the very same key (bank, program);
343     // if yes, just remove it without prejudice...
344 capela 971 qsamplerInstrumentItem *pItem = findItem(pInstrument);
345 capela 1015 if (pItem) {
346     // If exactly the same, just update view and bail out...
347     if (pItem->instrument() == pInstrument) {
348     pItem->update();
349     return pItem;
350     }
351     // Remove it, as instrument keys must be unique.
352 capela 1013 delete pItem;
353 capela 1015 }
354 capela 1013
355     // Add the new item under proper group one, if any...
356     if (pParentGroup) {
357     pParentGroup->setOpen(true);
358     pItem = new qsamplerInstrumentItem(pParentGroup, pInstrument);
359     } else {
360     pItem = new qsamplerInstrumentItem(this, pInstrument);
361 capela 971 }
362 capela 1013
363     // Set it as current selection...
364 capela 971 QListView::setSelected(pItem, true);
365 capela 1013
366 capela 971 return pItem;
367     }
368    
369    
370     // Add a new instrument group, optionally under another group.
371     qsamplerInstrumentGroup *qsamplerInstrumentList::addGroup (
372     const QString& sName, qsamplerInstrumentGroup *pParentGroup )
373     {
374     qsamplerInstrumentGroup *pGroup = findGroup(sName);
375     if (pGroup == NULL) {
376 capela 1013 if (pParentGroup) {
377     pParentGroup->setOpen(true);
378 capela 971 pGroup = new qsamplerInstrumentGroup(pParentGroup, sName);
379 capela 1013 } else {
380 capela 971 pGroup = new qsamplerInstrumentGroup(this, sName);
381 capela 1013 }
382 capela 971 }
383     QListView::setSelected(pGroup, true);
384     return pGroup;
385     }
386    
387    
388     // Find a group item, given its name.
389     qsamplerInstrumentGroup *qsamplerInstrumentList::findGroup (
390     const QString& sName ) const
391     {
392     // Iterate all over the place to search for the group.
393     QListViewItemIterator iter((QListView *) this);
394     while (iter.current()) {
395     QListViewItem *pItem = iter.current();
396     if (pItem->rtti() == Group && pItem->text(0) == sName)
397     return static_cast<qsamplerInstrumentGroup *> (pItem);
398     ++iter;
399     }
400     // Not found.
401     return NULL;
402     }
403    
404    
405     // Find a file item, given its name.
406     qsamplerInstrumentItem *qsamplerInstrumentList::findItem (
407     qsamplerInstrument *pInstrument ) const
408     {
409     if (pInstrument == NULL)
410     return NULL;
411    
412     // Iterate all over the place to search for the group.
413     QListViewItemIterator iter((QListView *) this);
414     while (iter.current()) {
415     QListViewItem *pListItem = iter.current();
416     if (pListItem->rtti() == Item) {
417     qsamplerInstrumentItem *pItem
418     = static_cast<qsamplerInstrumentItem *> (pListItem);
419     if (pItem && pItem->instrument()
420 capela 980 && pItem->instrument()->map() == pInstrument->map()
421 capela 971 && pItem->instrument()->bank() == pInstrument->bank()
422 capela 980 && pItem->instrument()->prog() == pInstrument->prog())
423 capela 971 return pItem;
424     }
425     ++iter;
426     }
427     // Not found.
428     return NULL;
429     }
430    
431    
432     // Find and return the nearest group item...
433     qsamplerInstrumentGroup *qsamplerInstrumentList::groupItem (
434     QListViewItem *pItem ) const
435     {
436     while (pItem && pItem->rtti() != Group)
437     pItem = pItem->parent();
438     return static_cast<qsamplerInstrumentGroup *> (pItem);
439     }
440    
441    
442     // Add a new group item below the current one.
443     void qsamplerInstrumentList::newGroupSlot (void)
444     {
445     qsamplerInstrumentGroup *pNewGroup
446 capela 1013 = addGroup(tr("New Group"), groupItem(QListView::selectedItem()));
447 capela 971 if (pNewGroup)
448     pNewGroup->startRename(0);
449    
450     selectionChangedSlot();
451     }
452    
453    
454 capela 1013 // Map selector.
455     void qsamplerInstrumentList::setMidiMap ( int iMidiMap )
456     {
457     if (iMidiMap < 0)
458     iMidiMap = LSCP_MIDI_MAP_ALL;
459    
460     m_iMidiMap = iMidiMap;
461     }
462    
463     int qsamplerInstrumentList::midiMap (void) const
464     {
465     return m_iMidiMap;
466     }
467    
468    
469     // List actions accessors.
470     QAction *qsamplerInstrumentList::newGroupAction (void) const
471     {
472     return m_pNewGroupAction;
473     }
474    
475     QAction *qsamplerInstrumentList::newItemAction (void) const
476     {
477     return m_pNewItemAction;
478     }
479    
480     QAction *qsamplerInstrumentList::editItemAction (void) const
481     {
482     return m_pEditItemAction;
483     }
484    
485     QAction *qsamplerInstrumentList::renameAction (void) const
486     {
487     return m_pRenameAction;
488     }
489    
490     QAction *qsamplerInstrumentList::deleteAction (void) const
491     {
492     return m_pDeleteAction;
493     }
494    
495     QAction *qsamplerInstrumentList::refreshAction (void) const
496     {
497     return m_pRefreshAction;
498     }
499    
500    
501 capela 971 // Add a new instrument item below the current one.
502     void qsamplerInstrumentList::newItemSlot (void)
503     {
504     qsamplerInstrument *pInstrument = new qsamplerInstrument();
505    
506     qsamplerInstrumentForm form(this);
507     form.setup(pInstrument);
508     if (!form.exec()) {
509     delete pInstrument;
510     return;
511     }
512    
513 capela 1013 // Commit...
514 capela 980 pInstrument->mapInstrument();
515 capela 1013 // add new item to the tree...
516     addItem(pInstrument, groupItem(QListView::selectedItem()));
517     // Notify we've changes...
518 capela 971 emit instrumentsChanged();
519    
520     selectionChangedSlot();
521     }
522    
523    
524     // Edit current item below the current one.
525     void qsamplerInstrumentList::editItemSlot (void)
526     {
527     QListViewItem *pListItem = QListView::selectedItem();
528     if (pListItem == NULL)
529     return;
530     if (pListItem->rtti() == Item) {
531 capela 1013 qsamplerInstrument *pInstrument = NULL;
532 capela 971 qsamplerInstrumentItem *pItem
533     = static_cast<qsamplerInstrumentItem *> (pListItem);
534 capela 1013 if (pItem)
535     pInstrument = pItem->instrument();
536     if (pInstrument) {
537     // Save current key values...
538 capela 1016 qsamplerInstrument oldInstrument(*pInstrument);
539 capela 1013 // Do the edit dance...
540 capela 971 qsamplerInstrumentForm form(this);
541 capela 1013 form.setup(pInstrument);
542 capela 971 if (form.exec()) {
543 capela 1013 // Commit...
544     pInstrument->mapInstrument();
545     // Check whether we changed instrument key...
546 capela 1016 if (oldInstrument.map() == pInstrument->map() &&
547     oldInstrument.bank() == pInstrument->bank() &&
548     oldInstrument.prog() == pInstrument->prog()) {
549 capela 1013 // just update tree item...
550     pItem->update();
551     } else {
552 capela 1016 // Unmap old instance...
553     oldInstrument.unmapInstrument();
554 capela 1013 // Change item tree, whether applicable...
555     if (m_iMidiMap < 0 || m_iMidiMap == pInstrument->map()) {
556     // Add new brand item into view...
557     addItem(pInstrument, groupItem(pListItem));
558     } else {
559     // Just remove/hide old one.
560     delete pItem;
561     }
562     }
563     // Notify we've changes...
564 capela 971 emit instrumentsChanged();
565     }
566     }
567     }
568    
569     selectionChangedSlot();
570     }
571    
572    
573     // Rename current group/item.
574     void qsamplerInstrumentList::renameSlot (void)
575     {
576     QListViewItem *pListItem = QListView::selectedItem();
577     if (pListItem)
578     pListItem->startRename(0);
579    
580     selectionChangedSlot();
581     }
582    
583    
584     // Remove current group/item.
585     void qsamplerInstrumentList::deleteSlot (void)
586     {
587     QListViewItem *pListItem = QListView::selectedItem();
588 capela 987 if (pListItem == NULL)
589     return;
590    
591     qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
592     if (pMainForm == NULL)
593     return;
594    
595     // Prompt user if this is for real...
596     qsamplerOptions *pOptions = pMainForm->options();
597     if (pOptions && pOptions->bConfirmRemove) {
598     if (QMessageBox::warning(this,
599     QSAMPLER_TITLE ": " + tr("Warning"),
600     tr("Delete %1:\n\n"
601     "%2\n\n"
602     "Are you sure?")
603     .arg(pListItem->rtti() == Item ? tr("instrument") : tr("group"))
604     .arg(pListItem->text(0)),
605     tr("OK"), tr("Cancel")) > 0)
606     return;
607     }
608    
609     // Unmap instrument entry...
610     if (pListItem->rtti() == Item) {
611     qsamplerInstrumentItem *pItem
612     = static_cast<qsamplerInstrumentItem *> (pListItem);
613     if (pItem && pItem->instrument()) {
614     pItem->instrument()->unmapInstrument();
615     emit instrumentsChanged();
616 capela 971 }
617     }
618    
619 capela 987 // Do it for real...
620     delete pListItem;
621    
622 capela 971 selectionChangedSlot();
623     }
624    
625    
626     // In-place selection slot.
627     void qsamplerInstrumentList::selectionChangedSlot (void)
628     {
629     qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
630     QListViewItem *pListItem = QListView::selectedItem();
631     bool bEnabled = (pMainForm && pMainForm->client());
632     m_pNewItemAction->setEnabled(bEnabled);
633     bEnabled = (bEnabled && pListItem != NULL);
634     m_pEditItemAction->setEnabled(bEnabled && pListItem->rtti() == Item);
635     m_pRenameAction->setEnabled(bEnabled);
636     m_pDeleteAction->setEnabled(bEnabled);
637     }
638    
639    
640     // In-place activation slot.
641     void qsamplerInstrumentList::activatedSlot ( QListViewItem *pListItem )
642     {
643     // FIXME: Hope the list view item is the one selected.
644 capela 1234 if (pListItem && pListItem->rtti() == Item)
645 capela 971 editItemSlot();
646     }
647    
648    
649     // In-place aliasing slot.
650     void qsamplerInstrumentList::renamedSlot ( QListViewItem *pListItem )
651     {
652     if (pListItem->rtti() == Item) {
653     qsamplerInstrumentItem *pItem
654     = static_cast<qsamplerInstrumentItem *> (pListItem);
655     if (pItem && pItem->instrument()) {
656     pItem->instrument()->setName(pListItem->text(0));
657 capela 980 pItem->instrument()->mapInstrument();
658 capela 971 emit instrumentsChanged();
659     pItem->update();
660     }
661     }
662     }
663    
664    
665     // Context menu request event handler.
666     void qsamplerInstrumentList::contextMenuEvent (
667     QContextMenuEvent *pContextMenuEvent )
668     {
669     if (!m_pNewItemAction->isEnabled())
670     return;
671    
672     QPopupMenu menu(this);
673    
674     // Construct context menu.
675     m_pNewItemAction->addTo(&menu);
676     // m_pNewGroupAction->addTo(&menu);
677     menu.insertSeparator();
678     m_pEditItemAction->addTo(&menu);
679     m_pRenameAction->addTo(&menu);
680     m_pDeleteAction->addTo(&menu);
681     menu.insertSeparator();
682     m_pRefreshAction->addTo(&menu);
683    
684     menu.exec(pContextMenuEvent->globalPos());
685     }
686    
687    
688     // General reloader.
689     void qsamplerInstrumentList::refresh (void)
690     {
691     clear();
692    
693     qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();
694     if (pMainForm == NULL)
695     return;
696     if (pMainForm->client() == NULL)
697     return;
698    
699 capela 1015 QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
700    
701     // Load the whole bunch of instrument items...
702 capela 971 qsamplerInstrumentItem *pItem = NULL;
703     lscp_midi_instrument_t *pInstrs
704 capela 1013 = ::lscp_list_midi_instruments(pMainForm->client(), m_iMidiMap);
705 capela 987 for (int iInstr = 0; pInstrs && pInstrs[iInstr].map >= 0; ++iInstr) {
706 capela 980 int iMap = pInstrs[iInstr].map;
707     int iBank = pInstrs[iInstr].bank;
708     int iProg = pInstrs[iInstr].prog;
709 capela 971 qsamplerInstrument *pInstrument
710 capela 980 = new qsamplerInstrument(iMap, iBank, iProg);
711     if (pInstrument->getInstrument())
712 capela 971 pItem = new qsamplerInstrumentItem(this, pInstrument, pItem);
713 capela 1015 // Try to keep it snappy :)
714     QApplication::eventLoop()->processEvents(QEventLoop::ExcludeUserInput);
715 capela 971 }
716    
717 capela 1015 QApplication::restoreOverrideCursor();
718    
719 capela 971 if (pInstrs == NULL && ::lscp_client_get_errno(pMainForm->client())) {
720     pMainForm->appendMessagesClient("lscp_list_midi_instruments");
721     pMainForm->appendMessagesError(tr("Could not get current list of MIDI instrument mappings.\n\nSorry."));
722     }
723    
724     selectionChangedSlot();
725     }
726 schoenebeck 1461 #endif
727 capela 971
728 schoenebeck 1461 MidiInstrumentsModel::MidiInstrumentsModel(QObject* parent) : QAbstractTableModel(parent) {
729     m_iMidiMap = LSCP_MIDI_MAP_ALL;
730     }
731 capela 971
732 schoenebeck 1461 int MidiInstrumentsModel::rowCount(const QModelIndex& /*parent*/) const {
733     if (m_iMidiMap == LSCP_MIDI_MAP_ALL) {
734     int n = 0;
735     for (InstrumentsMap::const_iterator itMap = instruments.begin(); itMap != instruments.end(); ++itMap)
736     n += (*itMap).size();
737     return n;
738     }
739     InstrumentsMap::const_iterator itMap = instruments.find(m_iMidiMap);
740     if (itMap == instruments.end()) return 0;
741     return (*itMap).size();
742     }
743    
744     int MidiInstrumentsModel::columnCount(const QModelIndex& /*parent*/) const {
745     return 9;
746     }
747    
748     QVariant MidiInstrumentsModel::data(const QModelIndex &index, int role) const {
749     if (!index.isValid() || role != Qt::DisplayRole) return QVariant();
750    
751     if (m_iMidiMap == LSCP_MIDI_MAP_ALL) {
752     int n = 0;
753     for (InstrumentsMap::const_iterator itMap = instruments.begin(); itMap != instruments.end(); ++itMap) {
754     n += (*itMap).size();
755     if (index.row() < n)
756     return QVariant::fromValue(
757     (*itMap)[index.row() + (*itMap).size() - n]
758     );
759     }
760     } else {
761     // resolve MIDI instrument map
762     InstrumentsMap::const_iterator itMap = instruments.find(m_iMidiMap);
763     if (itMap == instruments.end()) return QVariant();
764     // resolve instrument in that map
765     if (index.row() >= (*itMap).size()) return QVariant();
766     return QVariant::fromValue(
767     (*itMap)[index.row()]
768     );
769     }
770    
771     return QVariant();
772     }
773    
774     QVariant MidiInstrumentsModel::headerData(int section, Qt::Orientation orientation, int role) const {
775     if (orientation != Qt::Horizontal || role != Qt::DisplayRole)
776     return QVariant();
777    
778     switch (section) {
779     case 0: return tr("Name");
780     case 1: return tr("Map");
781     case 2: return tr("Bank");
782     case 3: return tr("Prog");
783     case 4: return tr("Engine");
784     case 5: return tr("File");
785     case 6: return tr("Nr");
786     case 7: return tr("Vol");
787     case 8: return tr("Mode");
788     default: return QVariant();
789     }
790     }
791    
792     qsamplerInstrument* MidiInstrumentsModel::addInstrument(int iMap, int iBank, int iProg) {
793     // Check it there's already one instrument item
794     // with the very same key (bank, program);
795     // if yes, just remove it without prejudice...
796     for (int i = 0; i < instruments[iMap].size(); i++) {
797     if (
798     instruments[iMap][i].bank() == iBank &&
799     instruments[iMap][i].prog() == iProg
800     ) {
801     instruments[iMap].removeAt(i);
802     break;
803     }
804     }
805    
806     // resolve the appropriate place, we keep the list sorted that way ...
807     int i = 0;
808     for (; i < instruments[iMap].size(); i++)
809     if (
810     iBank > instruments[iMap][i].bank() ||
811     ( iBank == instruments[iMap][i].bank() &&
812     iProg > instruments[iMap][i].prog() )
813     ) break;
814    
815     qsamplerInstrument& instr = instruments[iMap][i] = qsamplerInstrument(iMap, iBank, iProg);
816    
817     return &instr;
818     }
819    
820     void MidiInstrumentsModel::setMidiMap(int iMidiMap) {
821     if (iMidiMap < 0)
822     iMidiMap = LSCP_MIDI_MAP_ALL;
823    
824     m_iMidiMap = iMidiMap;
825     }
826    
827     int MidiInstrumentsModel::midiMap() const {
828     return m_iMidiMap;
829     }
830    
831     void MidiInstrumentsModel::refresh() {
832     instruments.clear();
833    
834     MainForm* pMainForm = MainForm::getInstance();
835     if (pMainForm == NULL)
836     return;
837     if (pMainForm->client() == NULL)
838     return;
839    
840     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
841    
842     // Load the whole bunch of instrument items...
843     lscp_midi_instrument_t* pInstrs
844     = ::lscp_list_midi_instruments(pMainForm->client(), m_iMidiMap);
845     for (int iInstr = 0; pInstrs && pInstrs[iInstr].map >= 0; ++iInstr) {
846     const int iMap = pInstrs[iInstr].map;
847     const int iBank = pInstrs[iInstr].bank;
848     const int iProg = pInstrs[iInstr].prog;
849     addInstrument(iMap, iBank, iProg);
850     // Try to keep it snappy :)
851     QApplication::processEvents(QEventLoop::ExcludeUserInput);
852     }
853    
854     QApplication::restoreOverrideCursor();
855    
856     if (pInstrs == NULL && ::lscp_client_get_errno(pMainForm->client())) {
857     pMainForm->appendMessagesClient("lscp_list_midi_instruments");
858     pMainForm->appendMessagesError(tr("Could not get current list of MIDI instrument mappings.\n\nSorry."));
859     }
860    
861     //selectionChangedSlot();
862     }
863    
864    
865     MidiInstrumentsDelegate::MidiInstrumentsDelegate(QObject* parent) : QItemDelegate(parent) {
866     }
867    
868     QWidget* MidiInstrumentsDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const {
869     return new QLabel(index.model()->data(index, Qt::DisplayRole).toString(), parent);
870     }
871    
872     void MidiInstrumentsDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const {
873     }
874    
875     void MidiInstrumentsDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const {
876     }
877    
878     void MidiInstrumentsDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const {
879     if (editor) editor->setGeometry(option.rect);
880     }
881    
882 capela 971 // end of qsamplerInstrumentList.cpp
883    

  ViewVC Help
Powered by ViewVC