/[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 987 by capela, Tue Dec 19 11:19:55 2006 UTC revision 1523 by capela, Sun Nov 25 11:40:47 2007 UTC
# Line 1  Line 1 
1  // qsamplerInstrumentList.cpp  // qsamplerInstrumentList.cpp
2  //  //
3  /****************************************************************************  /****************************************************************************
4     Copyright (C) 2003-2005, rncbc aka Rui Nuno Capela. All rights reserved.     Copyright (C) 2003-2007, rncbc aka Rui Nuno Capela. All rights reserved.
5       Copyright (C) 2007, Christian Schoenebeck
6    
7     This program is free software; you can redistribute it and/or     This program is free software; you can redistribute it and/or
8     modify it under the terms of the GNU General Public License     modify it under the terms of the GNU General Public License
# Line 28  Line 29 
29  #include "qsamplerOptions.h"  #include "qsamplerOptions.h"
30  #include "qsamplerMainForm.h"  #include "qsamplerMainForm.h"
31    
32  #include <qmessagebox.h>  #include <QApplication>
33  #include <qaction.h>  #include <QMessageBox>
34  #include <qfileinfo.h>  #include <QMenu>
35  #include <qpopupmenu.h>  #include <QAction>
36    #include <QCursor>
37    #include <QFileInfo>
38    
39  // Needed for lroundf()  // Needed for lroundf()
40  #include <math.h>  #include <math.h>
# Line 46  static inline long lroundf ( float x ) Line 49  static inline long lroundf ( float x )
49  }  }
50  #endif  #endif
51    
52    using namespace QSampler;
 //----------------------------------------------------------------------  
 // class qsamplerInstrumentGroup -- custom group list view item.  
 //  
   
 // Constructors.  
 qsamplerInstrumentGroup::qsamplerInstrumentGroup (  
         qsamplerInstrumentList *pListView, const QString& sName,  
         QListViewItem *pItemAfter )  
         : QListViewItem(pListView, pItemAfter ? pItemAfter : pListView->lastItem())  
 {  
         QListViewItem::setRenameEnabled(0, true);  
   
         QListViewItem::setPixmap(0, QPixmap::fromMimeSource("itemGroup.png"));  
         QListViewItem::setText(0, sName);  
 }  
   
   
 qsamplerInstrumentGroup::qsamplerInstrumentGroup (  
         qsamplerInstrumentGroup *pGroupItem, const QString& sName )  
         : QListViewItem(pGroupItem, sName)  
 {  
         QListViewItem::setRenameEnabled(0, true);  
   
         QListViewItem::setPixmap(0, QPixmap::fromMimeSource("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());  
 }  
53    
54    
55  // To show up whether its open or not.  //-------------------------------------------------------------------------
56  void qsamplerInstrumentGroup::setOpen ( bool bOpen )  // MidiInstrumentsModel - data model for MIDI prog mappings (used for QTableView)
 {  
         // Set the proper pixmap of this...  
         if (rtti() == qsamplerInstrumentList::Group) {  
                 QListViewItem::setPixmap(0, QPixmap::fromMimeSource(  
                         bOpen ? "itemGroupOpen.png" : "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.  
57  //  //
58    
59  // Constructors.  MidiInstrumentsModel::MidiInstrumentsModel ( QObject* pParent)
60  qsamplerInstrumentItem::qsamplerInstrumentItem (          : QAbstractTableModel(pParent)
         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())  
61  {  {
62          m_pInstrument = pInstrument;          m_iMidiMap = LSCP_MIDI_MAP_ALL;
   
         update();  
63  }  }
64    
65    
66  // Default destructor.  int MidiInstrumentsModel::rowCount ( const QModelIndex& /*parent*/) const
 qsamplerInstrumentItem::~qsamplerInstrumentItem (void)  
67  {  {
68          if (m_pInstrument)          if (m_iMidiMap == LSCP_MIDI_MAP_ALL) {
69                  delete m_pInstrument;                  int n = 0;
70                    for (InstrumentsMap::const_iterator itMap = m_instruments.begin();
71                                    itMap != m_instruments.end(); ++itMap)
72                            n += (*itMap).size();
73                    return n;
74            }
75            InstrumentsMap::const_iterator itMap = m_instruments.find(m_iMidiMap);
76            if (itMap == m_instruments.end()) return 0;
77            return (*itMap).size();
78  }  }
79    
80    
81  // To virtually distinguish between list view items.  int MidiInstrumentsModel::columnCount ( const QModelIndex& /*parent*/) const
 int qsamplerInstrumentItem::rtti (void) const  
82  {  {
83          return qsamplerInstrumentList::Item;          return 9;
84  }  }
85    
86    
87  // Payload accessor.  QVariant MidiInstrumentsModel::data ( const QModelIndex &index, int role ) const
 qsamplerInstrument *qsamplerInstrumentItem::instrument (void) const  
88  {  {
89          return m_pInstrument;          if (!index.isValid())
90  }                  return QVariant();
   
91    
92  // Item refreshment.          const qsamplerInstrument* pInstr = NULL;
 void qsamplerInstrumentItem::update (void)  
 {  
         QListViewItem::setPixmap(0, QPixmap::fromMimeSource("itemFile.png"));  
93    
94          const QString s = "-";          if (m_iMidiMap == LSCP_MIDI_MAP_ALL) {
95          if (m_pInstrument) {                  int n = 0;
96                  setText(0, m_pInstrument->name());                  for (InstrumentsMap::const_iterator itMap = m_instruments.begin();
97                  setText(1, QString::number(m_pInstrument->map()));                                  itMap != m_instruments.end(); ++itMap) {
98                  setText(2, QString::number(m_pInstrument->bank()));                          n += (*itMap).size();
99                  setText(3, QString::number(m_pInstrument->prog() + 1));                          if (index.row() < n)
100                  setText(4, m_pInstrument->engineName());                                  pInstr = &(*itMap)[index.row() + (*itMap).size() - n];
                 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;  
101                  }                  }
                 setText(8, sLoadMode);  
102          } else {          } else {
103                  for (int i = 0; i < listView()->columns(); i++)                  // resolve MIDI instrument map
104                          setText(i, s);                  InstrumentsMap::const_iterator itMap = m_instruments.find(m_iMidiMap);
105                    if (itMap == m_instruments.end()) return QVariant();
106                    // resolve instrument in that map
107                    if (index.row() >= (*itMap).size()) return QVariant();
108                    pInstr = &(*itMap)[index.row()];
109            }
110    
111            if (!pInstr)
112                    return QVariant();
113    
114            if (role == Qt::UserRole)
115                    return QVariant::fromValue((void *) pInstr);
116    
117            if (role == Qt::DisplayRole) {
118                    switch (index.column()) {
119                            case 0: return pInstr->name();
120                            case 1: return QVariant::fromValue(pInstr->map());
121                            case 2: return QVariant::fromValue(pInstr->bank());
122                            case 3: return QVariant::fromValue(pInstr->prog());
123                            case 4: return pInstr->engineName();
124                            case 5: return pInstr->instrumentFile();
125                            case 6: return QVariant::fromValue(pInstr->instrumentNr());
126                            case 7: return QString::number(pInstr->volume() * 100.0) + " %";
127                            case 8: {
128                                    switch (pInstr->loadMode()) {
129                                            case 3: return QObject::tr("Persistent");
130                                            case 2: return QObject::tr("On Demand Hold");
131                                            case 1: return QObject::tr("On Demand");
132                                            default: return QVariant();
133                                    }
134                            }
135                            default: return QVariant();
136                    }
137          }          }
 }  
   
   
 //----------------------------------------------------------------------------  
 // qsamplerInstrumentList -- MIDI instrument list view.  
 //  
138    
139  // Constructor.          return QVariant();
 qsamplerInstrumentList::qsamplerInstrumentList (  
         QWidget *pParent, const char *pszName )  
         : QListView(pParent, pszName)  
 {  
 //  QListView::setRootIsDecorated(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(tr("New &Group"), tr("Ctrl+G"), this);  
         m_pNewItemAction  = new QAction(tr("New &Instrument..."), tr("Ins"), this);  
         m_pEditItemAction = new QAction(tr("&Edit..."), tr("Enter"), this);  
         m_pRenameAction   = new QAction(tr("&Rename"), tr("F2"), this);  
         m_pDeleteAction   = new QAction(tr("&Delete"), tr("Del"), this);  
         m_pRefreshAction  = new QAction(tr("Re&fresh"), tr("F5"), this);  
   
         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 )  
 {  
         qsamplerInstrumentItem *pItem = findItem(pInstrument);  
         if (pItem == NULL) {  
                 if (pParentGroup)  
                         pItem = new qsamplerInstrumentItem(pParentGroup, pInstrument);  
                 else  
                         pItem = new qsamplerInstrumentItem(this, pInstrument);  
         }  
         QListView::setSelected(pItem, true);  
         return pItem;  
140  }  }
141    
142    
143  // Add a new instrument group, optionally under another group.  QVariant MidiInstrumentsModel::headerData (
144  qsamplerInstrumentGroup *qsamplerInstrumentList::addGroup (          int section, Qt::Orientation orientation, int role ) const
         const QString& sName, qsamplerInstrumentGroup *pParentGroup )  
145  {  {
146          qsamplerInstrumentGroup *pGroup = findGroup(sName);          if (orientation != Qt::Horizontal || role != Qt::DisplayRole)
147          if (pGroup == NULL) {                  return QVariant();
148                  if (pParentGroup)  
149                          pGroup = new qsamplerInstrumentGroup(pParentGroup, sName);          switch (section) {
150                  else                  case 0: return tr("Name");
151                          pGroup = new qsamplerInstrumentGroup(this, sName);                  case 1: return tr("Map");
152                    case 2: return tr("Bank");
153                    case 3: return tr("Prog");
154                    case 4: return tr("Engine");
155                    case 5: return tr("File");
156                    case 6: return tr("Nr");
157                    case 7: return tr("Vol");
158                    case 8: return tr("Mode");
159                    default: return QVariant();
160          }          }
         QListView::setSelected(pGroup, true);  
         return pGroup;  
161  }  }
162    
163    
164  // Find a group item, given its name.  qsamplerInstrument* MidiInstrumentsModel::addInstrument (
165  qsamplerInstrumentGroup *qsamplerInstrumentList::findGroup (          int iMap, int iBank, int iProg )
166          const QString& sName ) const  {
167  {          // Check it there's already one instrument item
168          // Iterate all over the place to search for the group.          // with the very same key (bank, program);
169          QListViewItemIterator iter((QListView *) this);          // if yes, just remove it without prejudice...
170          while (iter.current()) {          for (int i = 0; i < m_instruments[iMap].size(); i++) {
171                  QListViewItem *pItem = iter.current();                  if (m_instruments[iMap][i].bank() == iBank &&
172                  if (pItem->rtti() == Group && pItem->text(0) == sName)                          m_instruments[iMap][i].prog() == iProg) {
173                          return static_cast<qsamplerInstrumentGroup *> (pItem);                          m_instruments[iMap].removeAt(i);
174                  ++iter;                          break;
175                    }
176          }          }
         // Not found.  
         return NULL;  
 }  
177    
178            // Resolve the appropriate place, we keep the list sorted that way ...
179  // Find a file item, given its name.          int i = 0;
180  qsamplerInstrumentItem *qsamplerInstrumentList::findItem (          for (; i < m_instruments[iMap].size(); ++i) {
181          qsamplerInstrument *pInstrument ) const                  if (iBank < m_instruments[iMap][i].bank()
182  {                          || (iBank == m_instruments[iMap][i].bank() &&
183          if (pInstrument == NULL)                                  iProg < m_instruments[iMap][i].prog())) {
184                  return NULL;                          break;
   
         // 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;  
185                  }                  }
                 ++iter;  
186          }          }
         // Not found.  
         return NULL;  
 }  
187    
188            m_instruments[iMap].insert(i, qsamplerInstrument(iMap, iBank, iProg));
189            qsamplerInstrument& instr = m_instruments[iMap][i];
190            if (!instr.getInstrument())
191                    m_instruments[iMap].removeAt(i);
192    
193  // Find and return the nearest group item...          return &instr;
 qsamplerInstrumentGroup *qsamplerInstrumentList::groupItem (  
         QListViewItem *pItem ) const  
 {  
         while (pItem && pItem->rtti() != Group)  
                 pItem = pItem->parent();  
         return static_cast<qsamplerInstrumentGroup *> (pItem);  
194  }  }
195    
196    
197  // Add a new group item below the current one.  void MidiInstrumentsModel::removeInstrument (
198  void qsamplerInstrumentList::newGroupSlot (void)          const qsamplerInstrument& instrument )
199  {  {
200          qsamplerInstrumentGroup *pParentGroup          const int iMap  = instrument.map();
201                  = groupItem(QListView::selectedItem());          const int iBank = instrument.bank();
202          qsamplerInstrumentGroup *pNewGroup          const int iProg = instrument.prog();
203                  = addGroup(tr("New Group"), pParentGroup);          for (int i = 0; i < m_instruments[iMap].size(); i++) {
204          if (pParentGroup)                  if (m_instruments[iMap][i].bank() == iBank &&
205                  pParentGroup->setOpen(true);                          m_instruments[iMap][i].prog() == iProg) {
206          if (pNewGroup)                          m_instruments[iMap].removeAt(i);
207                  pNewGroup->startRename(0);                          break;
208                    }
209          selectionChangedSlot();          }
210  }  }
211    
212    
213  // Add a new instrument item below the current one.  // Reposition the instrument in the model (called when map/bank/prg changed)
214  void qsamplerInstrumentList::newItemSlot (void)  void MidiInstrumentsModel::resort ( const qsamplerInstrument& instrument )
215  {  {
216          qsamplerInstrument *pInstrument = new qsamplerInstrument();          const int iMap  = instrument.map();
217            const int iBank = instrument.bank();
218          qsamplerInstrumentForm form(this);          const int iProg = instrument.prog();
219          form.setup(pInstrument);          // Remove given instrument from its current list
220          if (!form.exec()) {          removeInstrument(instrument);
221                  delete pInstrument;          // Re-add the instrument
222                  return;          addInstrument(iMap, iBank, iProg);
         }  
   
         // 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)  
                 delete pItem;  
   
         pInstrument->mapInstrument();  
         emit instrumentsChanged();  
   
         qsamplerInstrumentGroup *pParentGroup  
                 = groupItem(QListView::selectedItem());  
         addItem(pInstrument, pParentGroup);  
         if (pParentGroup)  
                 pParentGroup->setOpen(true);  
   
         selectionChangedSlot();  
223  }  }
224    
225    
226  // Edit current item below the current one.  void MidiInstrumentsModel::setMidiMap ( int iMidiMap )
 void qsamplerInstrumentList::editItemSlot (void)  
227  {  {
228          QListViewItem *pListItem = QListView::selectedItem();          if (iMidiMap < 0)
229          if (pListItem == NULL)                  iMidiMap = LSCP_MIDI_MAP_ALL;
                 return;  
         if (pListItem->rtti() == Item) {  
                 qsamplerInstrumentItem *pItem  
                         = static_cast<qsamplerInstrumentItem *> (pListItem);  
                 if (pItem && pItem->instrument()) {  
                         qsamplerInstrumentForm form(this);  
                         form.setup(pItem->instrument());  
                         if (form.exec()) {  
                                 pItem->instrument()->mapInstrument();  
                                 emit instrumentsChanged();  
                                 pItem->update();  
                         }  
                 }  
         }  
230    
231          selectionChangedSlot();          m_iMidiMap = iMidiMap;
232  }  }
233    
234    
235  // Rename current group/item.  int MidiInstrumentsModel::midiMap (void) const
 void qsamplerInstrumentList::renameSlot (void)  
236  {  {
237          QListViewItem *pListItem = QListView::selectedItem();          return m_iMidiMap;
         if (pListItem)  
                 pListItem->startRename(0);  
   
         selectionChangedSlot();  
238  }  }
239    
240    void MidiInstrumentsModel::refresh (void)
 // Remove current group/item.  
 void qsamplerInstrumentList::deleteSlot (void)  
241  {  {
242          QListViewItem *pListItem = QListView::selectedItem();          m_instruments.clear();
         if (pListItem == NULL)  
                 return;  
243    
244          qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();          MainForm* pMainForm = MainForm::getInstance();
245          if (pMainForm == NULL)          if (pMainForm == NULL)
246                  return;                  return;
247            if (pMainForm->client() == NULL)
248                    return;
249    
250          // Prompt user if this is for real...          QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
         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;  
         }  
251    
252          // Unmap instrument entry...          // Load the whole bunch of instrument items...
253          if (pListItem->rtti() == Item) {          lscp_midi_instrument_t* pInstrs
254                  qsamplerInstrumentItem *pItem                  = ::lscp_list_midi_instruments(pMainForm->client(), m_iMidiMap);
255                          = static_cast<qsamplerInstrumentItem *> (pListItem);          for (int iInstr = 0; pInstrs && pInstrs[iInstr].map >= 0; ++iInstr) {
256                  if (pItem && pItem->instrument()) {                  const int iMap  = pInstrs[iInstr].map;
257                          pItem->instrument()->unmapInstrument();                  const int iBank = pInstrs[iInstr].bank;
258                          emit instrumentsChanged();                  const int iProg = pInstrs[iInstr].prog;
259                  }                  addInstrument(iMap, iBank, iProg);
260                    // Try to keep it snappy :)
261                    QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
262          }          }
263    
264          // Do it for real...          QApplication::restoreOverrideCursor();
         delete pListItem;  
265    
266          selectionChangedSlot();          if (pInstrs == NULL && ::lscp_client_get_errno(pMainForm->client())) {
267                    pMainForm->appendMessagesClient("lscp_list_midi_instruments");
268                    pMainForm->appendMessagesError(
269                            tr("Could not get current list of MIDI instrument mappings.\n\nSorry."));
270            }
271    
272            // inform the outer world (QTableView) that our data changed
273            QAbstractTableModel::reset();
274  }  }
275    
276    
277  // In-place selection slot.  //-------------------------------------------------------------------------
278  void qsamplerInstrumentList::selectionChangedSlot (void)  // MidiInstrumentsDelegate - table cell renderer for MIDI prog mappings
279    // (doesn't actually do anything ATM, but is already there for a future
280    // cell editor widget implementation)
281    
282    MidiInstrumentsDelegate::MidiInstrumentsDelegate ( QObject* pParent )
283            : QItemDelegate(pParent)
284  {  {
         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);  
285  }  }
286    
287    
288  // In-place activation slot.  QWidget* MidiInstrumentsDelegate::createEditor ( QWidget* pParent,
289  void qsamplerInstrumentList::activatedSlot ( QListViewItem *pListItem )          const QStyleOptionViewItem& option, const QModelIndex& index ) const
290  {  {
291          // FIXME: Hope the list view item is the one selected.          return QItemDelegate::createEditor(pParent, option, index);
292          if (pListItem->rtti() == Item)  //      return new QLabel(index.model()->data(index, Qt::DisplayRole).toString(), parent);
                 editItemSlot();  
293  }  }
294    
295    
296  // In-place aliasing slot.  void MidiInstrumentsDelegate::setEditorData ( QWidget */*pEditor*/,
297  void qsamplerInstrumentList::renamedSlot ( QListViewItem *pListItem )          const QModelIndex& /*index*/) const
298  {  {
         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();  
                 }  
         }  
299  }  }
300    
301    
302  // Context menu request event handler.  void MidiInstrumentsDelegate::setModelData ( QWidget */*pEditor*/,
303  void qsamplerInstrumentList::contextMenuEvent (          QAbstractItemModel* /*model*/, const QModelIndex& /*index*/) const
         QContextMenuEvent *pContextMenuEvent )  
304  {  {
         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());  
305  }  }
306    
307    
308  // General reloader.  void MidiInstrumentsDelegate::updateEditorGeometry ( QWidget *pEditor,
309  void qsamplerInstrumentList::refresh (void)          const QStyleOptionViewItem& option, const QModelIndex& index) const
310  {  {
311          clear();          QItemDelegate::updateEditorGeometry(pEditor, option, index);
312    //      if (pEditor) pEditor->setGeometry(option.rect);
         qsamplerMainForm *pMainForm = qsamplerMainForm::getInstance();  
         if (pMainForm == NULL)  
                 return;  
         if (pMainForm->client() == NULL)  
                 return;  
   
         qsamplerInstrumentItem *pItem = NULL;  
         lscp_midi_instrument_t *pInstrs  
                 = ::lscp_list_midi_instruments(pMainForm->client(), LSCP_MIDI_MAP_ALL);  
         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);  
         }  
   
         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();  
313  }  }
314    
315    
316  // end of qsamplerInstrumentList.cpp  // end of qsamplerInstrumentList.cpp
   
Legend:
Removed from v.987  
changed lines
  Added in v.1523
  ViewVC Help
Powered by ViewVC