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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1013 - (show annotations) (download)
Mon Jan 8 16:52:48 2007 UTC (17 years, 2 months ago) by capela
File size: 18800 byte(s)
* Instruments window gets its own toolbar (and statusbar too);
  also introducing MIDI instrument map selection to the view;
  MIDI instrument item editing now allows changing map, bank
  or program key values (were previously disabled).

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

  ViewVC Help
Powered by ViewVC