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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1491 by capela, Thu Nov 1 17:14:21 2007 UTC revision 1492 by schoenebeck, Mon Nov 19 21:08:18 2007 UTC
# Line 53  static inline long lroundf ( float x ) Line 53  static inline long lroundf ( float x )
53    
54  using namespace QSampler;  using namespace QSampler;
55    
 //----------------------------------------------------------------------  
 // class qsamplerInstrumentGroup -- custom group list view item.  
 //  
   
 #if 0  
 // Constructors.  
 qsamplerInstrumentGroup::qsamplerInstrumentGroup (  
         qsamplerInstrumentList *pListView, const QString& sName,  
         QListViewItem *pItemAfter )  
         : QListViewItem(pListView, pItemAfter ? pItemAfter : pListView->lastItem())  
 {  
         QListViewItem::setRenameEnabled(0, true);  
   
         QListViewItem::setPixmap(0, QPixmap(":/icons/itemGroup.png"));  
         QListViewItem::setText(0, sName);  
 }  
   
   
 qsamplerInstrumentGroup::qsamplerInstrumentGroup (  
         qsamplerInstrumentGroup *pGroupItem, const QString& sName )  
         : QListViewItem(pGroupItem, sName)  
 {  
         QListViewItem::setRenameEnabled(0, true);  
   
         QListViewItem::setPixmap(0, QPixmap(":/icons/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(bOpen ?  
                         ":/icons/itemGroupOpen.png" : ":/icons/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(":/icons/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);  
         }  
 }  
   
56    
57  //----------------------------------------------------------------------------  //-------------------------------------------------------------------------
58  // qsamplerInstrumentList -- MIDI instrument list view.  // MidiInstrumentsModel - data model for MIDI prog mappings (used for QTableView)
59  //  //
60    
 // Constructor.  
 qsamplerInstrumentList::qsamplerInstrumentList (  
         QWidget *pParent, const char *pszName )  
         : QListView(pParent, pszName)  
 {  
         m_iMidiMap = LSCP_MIDI_MAP_ALL;  
   
 //  QListView::setRootIsDecorated(true);  
         QListView::setAllColumnsShowFocus(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(  
                 QIcon(":/icons/itemGroupNew.png"),  
                 tr("New &Group"), tr("Ctrl+G"), this);  
         m_pNewItemAction  = new QAction(  
                 QIcon(":/icons/itemNew.png"),  
                 tr("New &Instrument..."), tr("Ins"), this);  
         m_pEditItemAction = new QAction(  
                 QIcon(":/icons/formEdit.png"),  
                 tr("&Edit..."), tr("Enter"), this);  
         m_pRenameAction   = new QAction(tr("&Rename"), tr("F2"), this);  
         m_pDeleteAction   = new QAction(  
                 QIcon(":/icons/formRemove.png"),  
                 tr("&Delete"), tr("Del"), this);  
         m_pRefreshAction  = new QAction(  
                 QIcon(":/icons/formRefresh.png"),  
                 tr("Re&fresh"), tr("F5"), this);  
   
         m_pNewGroupAction->setToolTip(tr("New Group"));  
         m_pNewItemAction->setToolTip(tr("New Instrument"));  
         m_pEditItemAction->setToolTip(tr("Edit"));  
         m_pRenameAction->setToolTip(tr("Rename"));  
         m_pDeleteAction->setToolTip(tr("Delete"));  
         m_pRefreshAction->setToolTip(tr("Refresh"));  
   
         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 )  
 {  
         // 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) {  
                 // If exactly the same, just update view and bail out...  
                 if (pItem->instrument() == pInstrument) {  
                         pItem->update();  
                         return pItem;  
                 }  
                 // Remove it, as instrument keys must be unique.  
                 delete pItem;  
         }  
   
         // Add the new item under proper group one, if any...  
         if (pParentGroup) {  
                 pParentGroup->setOpen(true);  
                 pItem = new qsamplerInstrumentItem(pParentGroup, pInstrument);  
         } else {  
                 pItem = new qsamplerInstrumentItem(this, pInstrument);  
         }  
   
         // Set it as current selection...  
         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) {  
                         pParentGroup->setOpen(true);  
                         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 *pNewGroup  
                 = addGroup(tr("New Group"), groupItem(QListView::selectedItem()));  
         if (pNewGroup)  
                 pNewGroup->startRename(0);  
   
         selectionChangedSlot();  
 }  
   
   
 // Map selector.  
 void qsamplerInstrumentList::setMidiMap ( int iMidiMap )  
 {  
         if (iMidiMap < 0)  
                 iMidiMap = LSCP_MIDI_MAP_ALL;  
   
         m_iMidiMap = iMidiMap;  
 }  
   
 int qsamplerInstrumentList::midiMap (void) const  
 {  
         return m_iMidiMap;  
 }  
   
   
 // List actions accessors.  
 QAction *qsamplerInstrumentList::newGroupAction (void) const  
 {  
         return m_pNewGroupAction;  
 }  
   
 QAction *qsamplerInstrumentList::newItemAction (void) const  
 {  
         return m_pNewItemAction;  
 }  
   
 QAction *qsamplerInstrumentList::editItemAction (void) const  
 {  
         return m_pEditItemAction;  
 }  
   
 QAction *qsamplerInstrumentList::renameAction (void) const  
 {  
         return m_pRenameAction;  
 }  
   
 QAction *qsamplerInstrumentList::deleteAction (void) const  
 {  
         return m_pDeleteAction;  
 }  
   
 QAction *qsamplerInstrumentList::refreshAction (void) const  
 {  
         return m_pRefreshAction;  
 }  
   
   
 // 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;  
         }  
   
         // Commit...  
         pInstrument->mapInstrument();  
         // add new item to the tree...  
         addItem(pInstrument, groupItem(QListView::selectedItem()));  
         // Notify we've changes...  
         emit instrumentsChanged();  
   
         selectionChangedSlot();  
 }  
   
   
 // Edit current item below the current one.  
 void qsamplerInstrumentList::editItemSlot (void)  
 {  
         QListViewItem *pListItem = QListView::selectedItem();  
         if (pListItem == NULL)  
                 return;  
         if (pListItem->rtti() == Item) {  
                 qsamplerInstrument *pInstrument = NULL;  
                 qsamplerInstrumentItem *pItem  
                         = static_cast<qsamplerInstrumentItem *> (pListItem);  
                 if (pItem)  
                         pInstrument = pItem->instrument();  
                 if (pInstrument) {  
                         // Save current key values...  
                         qsamplerInstrument oldInstrument(*pInstrument);  
                         // Do the edit dance...  
                         qsamplerInstrumentForm 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();  
                                         // Change item tree, whether applicable...  
                                         if (m_iMidiMap < 0 || m_iMidiMap == pInstrument->map()) {  
                                                 // Add new brand item into view...  
                                                 addItem(pInstrument, groupItem(pListItem));  
                                         } else {  
                                                 // Just remove/hide old one.  
                                                 delete pItem;  
                                         }  
                                 }  
                                 // Notify we've changes...  
                                 emit instrumentsChanged();  
                         }  
                 }  
         }  
   
         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 && 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;  
   
         QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));  
   
         // Load the whole bunch of instrument items...  
         qsamplerInstrumentItem *pItem = NULL;  
         lscp_midi_instrument_t *pInstrs  
                 = ::lscp_list_midi_instruments(pMainForm->client(), m_iMidiMap);  
         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);  
                 // Try to keep it snappy :)  
                 QApplication::eventLoop()->processEvents(QEventLoop::ExcludeUserInput);  
         }  
   
         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."));  
         }  
   
         selectionChangedSlot();  
 }  
 #endif  
   
61  MidiInstrumentsModel::MidiInstrumentsModel(QObject* parent) : QAbstractTableModel(parent) {  MidiInstrumentsModel::MidiInstrumentsModel(QObject* parent) : QAbstractTableModel(parent) {
62      m_iMidiMap = LSCP_MIDI_MAP_ALL;      m_iMidiMap = LSCP_MIDI_MAP_ALL;
63  }  }
# Line 747  int MidiInstrumentsModel::columnCount(co Line 79  int MidiInstrumentsModel::columnCount(co
79  }  }
80    
81  QVariant MidiInstrumentsModel::data(const QModelIndex &index, int role) const {  QVariant MidiInstrumentsModel::data(const QModelIndex &index, int role) const {
82      if (!index.isValid() || role != Qt::DisplayRole) return QVariant();      if (!index.isValid()) return QVariant();
83    
84        const qsamplerInstrument* pInstr = NULL;
85    
86      if (m_iMidiMap == LSCP_MIDI_MAP_ALL) {      if (m_iMidiMap == LSCP_MIDI_MAP_ALL) {
87          int n = 0;          int n = 0;
88          for (InstrumentsMap::const_iterator itMap = instruments.begin(); itMap != instruments.end(); ++itMap) {          for (InstrumentsMap::const_iterator itMap = instruments.begin(); itMap != instruments.end(); ++itMap) {
89              n += (*itMap).size();              n += (*itMap).size();
90              if (index.row() < n)              if (index.row() < n)
91                  return QVariant::fromValue(                  pInstr = &(*itMap)[index.row() + (*itMap).size() - n];
                     (*itMap)[index.row() + (*itMap).size() - n]  
                 );  
92          }          }
93      } else {      } else {
94          // resolve MIDI instrument map          // resolve MIDI instrument map
# Line 764  QVariant MidiInstrumentsModel::data(cons Line 96  QVariant MidiInstrumentsModel::data(cons
96          if (itMap == instruments.end()) return QVariant();          if (itMap == instruments.end()) return QVariant();
97          // resolve instrument in that map          // resolve instrument in that map
98          if (index.row() >= (*itMap).size()) return QVariant();          if (index.row() >= (*itMap).size()) return QVariant();
99          return QVariant::fromValue(          pInstr = &(*itMap)[index.row()];
100              (*itMap)[index.row()]      }
101          );  
102        if (!pInstr) return QVariant();
103    
104        if (role == Qt::UserRole) {
105            return QVariant::fromValue((void*)pInstr);
106        }
107    
108        if (role == Qt::DisplayRole) {
109            switch (index.column()) {
110                case 0: return pInstr->name();
111                case 1: return QVariant::fromValue(pInstr->map());
112                case 2: return QVariant::fromValue(pInstr->bank());
113                case 3: return QVariant::fromValue(pInstr->prog());
114                case 4: return pInstr->engineName();
115                case 5: return pInstr->instrumentFile();
116                case 6: return QVariant::fromValue(pInstr->instrumentNr());
117                case 7: return QString::number(pInstr->volume() * 100.0) + " %";
118                case 8: {
119                    switch (pInstr->loadMode()) {
120                        case 3: return QObject::tr("Persistent");
121                        case 2: return QObject::tr("On Demand Hold");
122                        case 1: return QObject::tr("On Demand");
123                        default: return QVariant();
124                    }
125                }
126                default: return QVariant();
127            }
128      }      }
129    
130      return QVariant();      return QVariant();
# Line 813  qsamplerInstrument* MidiInstrumentsModel Line 171  qsamplerInstrument* MidiInstrumentsModel
171                iProg > instruments[iMap][i].prog() )                iProg > instruments[iMap][i].prog() )
172          ) break;          ) break;
173    
174      qsamplerInstrument& instr = instruments[iMap][i] = qsamplerInstrument(iMap, iBank, iProg);      instruments[iMap].insert(i, qsamplerInstrument(iMap, iBank, iProg));
175        qsamplerInstrument& instr = instruments[iMap][i];
176        if (!instr.getInstrument())
177            instruments[iMap].removeAt(i);
178    
179      return &instr;      return &instr;
180  }  }
181    
182    void MidiInstrumentsModel::removeInstrument(const qsamplerInstrument& instrument) {
183        const int iMap  = instrument.map();
184        const int iBank = instrument.bank();
185        const int iProg = instrument.prog();
186        for (int i = 0; i < instruments[iMap].size(); i++) {
187            if (
188                instruments[iMap][i].bank() == iBank &&
189                instruments[iMap][i].prog() == iProg
190            ) {
191                instruments[iMap].removeAt(i);
192                break;
193            }
194        }
195    }
196    
197    // reposition the instrument in the model (called when map/bank/prg changed)
198    void MidiInstrumentsModel::resort(const qsamplerInstrument instrument) {
199        const int iMap  = instrument.map();
200        const int iBank = instrument.bank();
201        const int iProg = instrument.prog();
202        // remove given instrument from its current list
203        removeInstrument(instrument);
204        // re-add the instrument
205        addInstrument(iMap, iBank, iProg);
206    }
207    
208  void MidiInstrumentsModel::setMidiMap(int iMidiMap) {  void MidiInstrumentsModel::setMidiMap(int iMidiMap) {
209      if (iMidiMap < 0)      if (iMidiMap < 0)
210          iMidiMap = LSCP_MIDI_MAP_ALL;          iMidiMap = LSCP_MIDI_MAP_ALL;
# Line 859  void MidiInstrumentsModel::refresh() { Line 246  void MidiInstrumentsModel::refresh() {
246                  pMainForm->appendMessagesError(tr("Could not get current list of MIDI instrument mappings.\n\nSorry."));                  pMainForm->appendMessagesError(tr("Could not get current list of MIDI instrument mappings.\n\nSorry."));
247          }          }
248    
249          //selectionChangedSlot();          // inform the outer world (QTableView) that our data changed
250            QAbstractTableModel::reset();
251  }  }
252    
253    
254    //-------------------------------------------------------------------------
255    // MidiInstrumentsDelegate - table cell renderer for MIDI prog mappings
256    // (doesn't actually do anything ATM, but is already there for a future
257    // cell editor widget implementation)
258    
259  MidiInstrumentsDelegate::MidiInstrumentsDelegate(QObject* parent) : QItemDelegate(parent) {  MidiInstrumentsDelegate::MidiInstrumentsDelegate(QObject* parent) : QItemDelegate(parent) {
260  }  }
261    
262  QWidget* MidiInstrumentsDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const {  QWidget* MidiInstrumentsDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const {
263      return new QLabel(index.model()->data(index, Qt::DisplayRole).toString(), parent);      return QItemDelegate::createEditor(parent, option, index);
264        //return new QLabel(index.model()->data(index, Qt::DisplayRole).toString(), parent);
265  }  }
266    
267  void MidiInstrumentsDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const {  void MidiInstrumentsDelegate::setEditorData(QWidget* /*editor*/, const QModelIndex& /*index*/) const {
268  }  }
269    
270  void MidiInstrumentsDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const {  void MidiInstrumentsDelegate::setModelData(QWidget* /*editor*/, QAbstractItemModel* /*model*/, const QModelIndex& /*index*/) const {
271  }  }
272    
273  void MidiInstrumentsDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const {  void MidiInstrumentsDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const {
274      if (editor) editor->setGeometry(option.rect);      QItemDelegate::updateEditorGeometry(editor, option, index);
275        //if (editor) editor->setGeometry(option.rect);
276  }  }
277    
278    
Legend:
Removed from v.1491  
changed lines
  Added in v.1492
  ViewVC Help
Powered by ViewVC