/[svn]/qsampler/trunk/src/qsamplerMainForm.cpp

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

Parent Directory | Revision Log | View Patch Patch

-revision 1514 by capela,
Fri Nov 23 10:51:37 2007 UTC
+revision 3759 by capela,
Sat Mar 28 00:28:13 2020 UTC
 Line 1
  // qsamplerMainForm.cpp
  //
  /****************************************************************************
-    Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
+    Copyright (C) 2004-2020, rncbc aka Rui Nuno Capela. All rights reserved.
-    Copyright (C) 2007, Christian Schoenebeck
+    Copyright (C) 2007-2019 Christian Schoenebeck
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License
 Line 33
  #include "qsamplerInstrumentListForm.h"
  #include "qsamplerDeviceForm.h"
  #include "qsamplerOptionsForm.h"
+ #include "qsamplerDeviceStatusForm.h"
+ #include <QMdiArea>
+ #include <QMdiSubWindow>
  #include <QApplication>
- #include <QWorkspace>
  #include <QProcess>
  #include <QMessageBox>
-Line 55
+Line 58
  #include <QTimer>
  #include <QDateTime>
+ #include <QElapsedTimer>
- #ifdef HAVE_SIGNAL_H
+ #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
- #include <signal.h>
+ #include <QMimeData>
+ #endif
+ #if QT_VERSION < QT_VERSION_CHECK(4, 5, 0)
+ namespace Qt {
+ const WindowFlags WindowCloseButtonHint = WindowFlags(0x08000000);
+ }
  #endif
+ // Deprecated QTextStreamFunctions/Qt namespaces workaround.
+ #if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
+ #define endl    Qt::endl
+ #endif
  #ifdef CONFIG_LIBGIG
  #include <gig.h>
  #endif
-Line 77 
 static inline long lroundf ( float x )
+Line 93 
 static inline long lroundf ( float x )
  }
  #endif
+ // All winsock apps needs this.
+ #if defined(__WIN32__) || defined(_WIN32) || defined(WIN32)
+ static WSADATA _wsaData;
+ #undef HAVE_SIGNAL_H
+ #endif
+ //-------------------------------------------------------------------------
+ // LADISH Level 1 support stuff.
+ #if defined(HAVE_SIGNAL_H) && defined(HAVE_SYS_SOCKET_H)
+ #include <QSocketNotifier>
+ #include <unistd.h>
+ #include <sys/types.h>
+ #include <sys/socket.h>
+ #include <signal.h>
+ // File descriptor for SIGUSR1 notifier.
+ static int g_fdSigusr1[2] = { -1, -1 };
+ // Unix SIGUSR1 signal handler.
+ static void qsampler_sigusr1_handler ( int /* signo */ )
+ {
+         char c = 1;
+         (::write(g_fdSigusr1[0], &c, sizeof(c)) > 0);
+ }
+ // File descriptor for SIGTERM notifier.
+ static int g_fdSigterm[2] = { -1, -1 };
+ // Unix SIGTERM signal handler.
+ static void qsampler_sigterm_handler ( int /* signo */ )
+ {
+         char c = 1;
+         (::write(g_fdSigterm[0], &c, sizeof(c)) > 0);
+ }
+ #endif  // HAVE_SIGNAL_H
+ //-------------------------------------------------------------------------
+ // QSampler -- namespace
+ namespace QSampler {
  // Timer constant stuff.
  #define QSAMPLER_TIMER_MSECS    200
-Line 87 
 static inline long lroundf ( float x )
+Line 154 
 static inline long lroundf ( float x )
  #define QSAMPLER_STATUS_SESSION 3       // Current session modification state.
- // All winsock apps needs this.
+ // Specialties for thread-callback comunication.
- #if defined(WIN32)
+ #define QSAMPLER_LSCP_EVENT   QEvent::Type(QEvent::User + 1)
- static WSADATA _wsaData;
- #endif
  //-------------------------------------------------------------------------
- // qsamplerCustomEvent -- specialty for callback comunication.
+ // QSampler::LscpEvent -- specialty for LSCP callback comunication.
- #define QSAMPLER_CUSTOM_EVENT   QEvent::Type(QEvent::User + 0)
+ class LscpEvent : public QEvent
- class qsamplerCustomEvent : public QEvent
  {
  public:
          // Constructor.
-         qsamplerCustomEvent(lscp_event_t event, const char *pchData, int cchData)
+         LscpEvent(lscp_event_t event, const char *pchData, int cchData)
-                 : QEvent(QSAMPLER_CUSTOM_EVENT)
+                 : QEvent(QSAMPLER_LSCP_EVENT)
          {
                  m_event = event;
                  m_data  = QString::fromUtf8(pchData, cchData);
          }
          // Accessors.
-         lscp_event_t event() { return m_event; }
+         lscp_event_t  event() { return m_event; }
-         QString&     data()  { return m_data;  }
+         const QString& data() { return m_data;  }
  private:
-Line 124 
 private:
+Line 187 
 private:
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- Main window form implementation.
+ // QSampler::Workspace -- Main window workspace (MDI Area) decl.
- namespace QSampler {
+ class Workspace : public QMdiArea
+ {
+ public:
+         Workspace(MainForm *pMainForm) : QMdiArea(pMainForm) {}
+ protected:
+         void resizeEvent(QResizeEvent *)
+         {
+                 MainForm *pMainForm = static_cast<MainForm *> (parentWidget());
+                 if (pMainForm)
+                         pMainForm->channelsArrangeAuto();
+         }
+ };
+ //-------------------------------------------------------------------------
+ // QSampler::MainForm -- Main window form implementation.
  // Kind of singleton reference.
- MainForm* MainForm::g_pMainForm = NULL;
+ MainForm *MainForm::g_pMainForm = nullptr;
  MainForm::MainForm ( QWidget *pParent )
          : QMainWindow(pParent)
-Line 140 
 MainForm::MainForm ( QWidget *pParent )
+Line 221 
 MainForm::MainForm ( QWidget *pParent )
          g_pMainForm = this;
          // Initialize some pointer references.
-         m_pOptions = NULL;
+         m_pOptions = nullptr;
          // All child forms are to be created later, not earlier than setup.
-         m_pMessages = NULL;
+         m_pMessages = nullptr;
-         m_pInstrumentListForm = NULL;
+         m_pInstrumentListForm = nullptr;
-         m_pDeviceForm = NULL;
+         m_pDeviceForm = nullptr;
          // We'll start clean.
          m_iUntitled   = 0;
+         m_iDirtySetup = 0;
          m_iDirtyCount = 0;
-         m_pServer = NULL;
+         m_pServer = nullptr;
-         m_pClient = NULL;
+         m_pClient = nullptr;
          m_iStartDelay = 0;
          m_iTimerDelay = 0;
          m_iTimerSlot = 0;
- #ifdef HAVE_SIGNAL_H
+ #if defined(HAVE_SIGNAL_H) && defined(HAVE_SYS_SOCKET_H)
          // Set to ignore any fatal "Broken pipe" signals.
          ::signal(SIGPIPE, SIG_IGN);
- #endif
+         // LADISH Level 1 suport.
+         // Initialize file descriptors for SIGUSR1 socket notifier.
+         ::socketpair(AF_UNIX, SOCK_STREAM, 0, g_fdSigusr1);
+         m_pSigusr1Notifier
+                 = new QSocketNotifier(g_fdSigusr1[1], QSocketNotifier::Read, this);
+         QObject::connect(m_pSigusr1Notifier,
+                 SIGNAL(activated(int)),
+                 SLOT(handle_sigusr1()));
+         // Install SIGUSR1 signal handler.
+         struct sigaction sigusr1;
+         sigusr1.sa_handler = qsampler_sigusr1_handler;
+         sigemptyset(&sigusr1.sa_mask);
+         sigusr1.sa_flags = 0;
+         sigusr1.sa_flags |= SA_RESTART;
+         ::sigaction(SIGUSR1, &sigusr1, nullptr);
+         // Initialize file descriptors for SIGTERM socket notifier.
+         ::socketpair(AF_UNIX, SOCK_STREAM, 0, g_fdSigterm);
+         m_pSigtermNotifier
+                 = new QSocketNotifier(g_fdSigterm[1], QSocketNotifier::Read, this);
+         QObject::connect(m_pSigtermNotifier,
+                 SIGNAL(activated(int)),
+                 SLOT(handle_sigterm()));
+         // Install SIGTERM signal handler.
+         struct sigaction sigterm;
+         sigterm.sa_handler = qsampler_sigterm_handler;
+         sigemptyset(&sigterm.sa_mask);
+         sigterm.sa_flags = 0;
+         sigterm.sa_flags |= SA_RESTART;
+         ::sigaction(SIGTERM, &sigterm, nullptr);
+         ::sigaction(SIGQUIT, &sigterm, nullptr);
+         // Ignore SIGHUP/SIGINT signals.
+         ::signal(SIGHUP, SIG_IGN);
+         ::signal(SIGINT, SIG_IGN);
+ #else   // HAVE_SIGNAL_H
+         m_pSigusr1Notifier = nullptr;
+         m_pSigtermNotifier = nullptr;
+ #endif  // !HAVE_SIGNAL_H
  #ifdef CONFIG_VOLUME
          // Make some extras into the toolbar...
-Line 171 
 MainForm::MainForm ( QWidget *pParent )
+Line 301 
 MainForm::MainForm ( QWidget *pParent )
          // Volume slider...
          m_ui.channelsToolbar->addSeparator();
          m_pVolumeSlider = new QSlider(Qt::Horizontal, m_ui.channelsToolbar);
-         m_pVolumeSlider->setTickPosition(QSlider::TicksBelow);
+         m_pVolumeSlider->setTickPosition(QSlider::TicksBothSides);
          m_pVolumeSlider->setTickInterval(10);
          m_pVolumeSlider->setPageStep(10);
          m_pVolumeSlider->setSingleStep(10);
-Line 183 
 MainForm::MainForm ( QWidget *pParent )
+Line 313 
 MainForm::MainForm ( QWidget *pParent )
          QObject::connect(m_pVolumeSlider,
                  SIGNAL(valueChanged(int)),
                  SLOT(volumeChanged(int)));
-         //m_ui.channelsToolbar->setHorizontallyStretchable(true);
-         //m_ui.channelsToolbar->setStretchableWidget(m_pVolumeSlider);
          m_ui.channelsToolbar->addWidget(m_pVolumeSlider);
          // Volume spin-box
          m_ui.channelsToolbar->addSeparator();
-Line 200 
 MainForm::MainForm ( QWidget *pParent )
+Line 328 
 MainForm::MainForm ( QWidget *pParent )
  #endif
          // Make it an MDI workspace.
-         m_pWorkspace = new QWorkspace(this);
+         m_pWorkspace = new Workspace(this);
-         m_pWorkspace->setScrollBarsEnabled(true);
+         m_pWorkspace->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+         m_pWorkspace->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
          // Set the activation connection.
          QObject::connect(m_pWorkspace,
-                 SIGNAL(windowActivated(QWidget *)),
+                 SIGNAL(subWindowActivated(QMdiSubWindow *)),
-                 SLOT(activateStrip(QWidget *)));
+                 SLOT(activateStrip(QMdiSubWindow *)));
          // Make it shine :-)
          setCentralWidget(m_pWorkspace);
-Line 234 
 MainForm::MainForm ( QWidget *pParent )
+Line 363 
 MainForm::MainForm ( QWidget *pParent )
          m_statusItem[QSAMPLER_STATUS_SESSION] = pLabel;
          statusBar()->addWidget(pLabel);
- #if defined(WIN32)
+ #if defined(__WIN32__) || defined(_WIN32) || defined(WIN32)
          WSAStartup(MAKEWORD(1, 1), &_wsaData);
  #endif
-Line 322 
 MainForm::MainForm ( QWidget *pParent )
+Line 451 
 MainForm::MainForm ( QWidget *pParent )
          QObject::connect(m_ui.channelsMenu,
                  SIGNAL(aboutToShow()),
                  SLOT(channelsMenuAboutToShow()));
+ #ifdef CONFIG_VOLUME
+         QObject::connect(m_ui.channelsToolbar,
+                 SIGNAL(orientationChanged(Qt::Orientation)),
+                 SLOT(channelsToolbarOrientation(Qt::Orientation)));
+ #endif
  }
  // Destructor.
-Line 330 
 MainForm::~MainForm()
+Line 464 
 MainForm::~MainForm()
          // Do final processing anyway.
          processServerExit();
- #if defined(WIN32)
+ #if defined(__WIN32__) || defined(_WIN32) || defined(WIN32)
          WSACleanup();
  #endif
+ #if defined(HAVE_SIGNAL_H) && defined(HAVE_SYS_SOCKET_H)
+         if (m_pSigusr1Notifier)
+                 delete m_pSigusr1Notifier;
+         if (m_pSigtermNotifier)
+                 delete m_pSigtermNotifier;
+ #endif
          // Finally drop any widgets around...
          if (m_pDeviceForm)
                  delete m_pDeviceForm;
-Line 360 
 MainForm::~MainForm()
+Line 501 
 MainForm::~MainForm()
  #endif
          // Pseudo-singleton reference shut-down.
-         g_pMainForm = NULL;
+         g_pMainForm = nullptr;
  }
  // Make and set a proper setup options step.
- void MainForm::setup ( qsamplerOptions *pOptions )
+ void MainForm::setup ( Options *pOptions )
  {
          // We got options?
          m_pOptions = pOptions;
          // What style do we create these forms?
          Qt::WindowFlags wflags = Qt::Window
- #if QT_VERSION >= 0x040200
                  | Qt::CustomizeWindowHint
- #endif
                  | Qt::WindowTitleHint
                  | Qt::WindowSystemMenuHint
-                 | Qt::WindowMinMaxButtonsHint;
+                 | Qt::WindowMinMaxButtonsHint
+                 | Qt::WindowCloseButtonHint;
          if (m_pOptions->bKeepOnTop)
                  wflags |= Qt::Tool;
          // Some child forms are to be created right now.
-         m_pMessages = new qsamplerMessages(this);
+         m_pMessages = new Messages(this);
          m_pDeviceForm = new DeviceForm(this, wflags);
  #ifdef CONFIG_MIDI_INSTRUMENT
          m_pInstrumentListForm = new InstrumentListForm(this, wflags);
  #else
-         viewInstrumentsAction->setEnabled(false);
+         m_ui.viewInstrumentsAction->setEnabled(false);
  #endif
+         // Setup messages logging appropriately...
+         m_pMessages->setLogging(
+                 m_pOptions->bMessagesLog,
+                 m_pOptions->sMessagesLogPath);
          // Set message defaults...
          updateMessagesFont();
          updateMessagesLimit();
          updateMessagesCapture();
          // Set the visibility signal.
          QObject::connect(m_pMessages,
                  SIGNAL(visibilityChanged(bool)),
-Line 418 
 void MainForm::setup ( qsamplerOptions *
+Line 566 
 void MainForm::setup ( qsamplerOptions *
          }
          // Try to restore old window positioning and initial visibility.
-         m_pOptions->loadWidgetGeometry(this);
+         m_pOptions->loadWidgetGeometry(this, true);
          m_pOptions->loadWidgetGeometry(m_pInstrumentListForm);
          m_pOptions->loadWidgetGeometry(m_pDeviceForm);
-Line 457 
 bool MainForm::queryClose (void)
+Line 605 
 bool MainForm::queryClose (void)
                                  || m_ui.channelsToolbar->isVisible());
                          m_pOptions->bStatusbar = statusBar()->isVisible();
                          // Save the dock windows state.
-                         const QString sDockables = saveState().toBase64().data();
                          m_pOptions->settings().setValue("/Layout/DockWindows", saveState());
                          // And the children, and the main windows state,.
                          m_pOptions->saveWidgetGeometry(m_pDeviceForm);
                          m_pOptions->saveWidgetGeometry(m_pInstrumentListForm);
-                         m_pOptions->saveWidgetGeometry(this);
+                         m_pOptions->saveWidgetGeometry(this, true);
                          // Close popup widgets.
                          if (m_pInstrumentListForm)
                                  m_pInstrumentListForm->close();
                          if (m_pDeviceForm)
                                  m_pDeviceForm->close();
                          // Stop client and/or server, gracefully.
-                         stopServer();
+                         stopServer(true /*interactive*/);
                  }
          }
-Line 479 
 bool MainForm::queryClose (void)
+Line 626 
 bool MainForm::queryClose (void)
  void MainForm::closeEvent ( QCloseEvent *pCloseEvent )
  {
-         if (queryClose())
+         if (queryClose()) {
+                 DeviceStatusForm::deleteAllInstances();
                  pCloseEvent->accept();
-         else
+         } else
                  pCloseEvent->ignore();
  }
-Line 490 
 void MainForm::closeEvent ( QCloseEvent
+Line 638 
 void MainForm::closeEvent ( QCloseEvent
  void MainForm::dragEnterEvent ( QDragEnterEvent* pDragEnterEvent )
  {
          // Accept external drags only...
-         if (pDragEnterEvent->source() == NULL
+         if (pDragEnterEvent->source() == nullptr
                  && pDragEnterEvent->mimeData()->hasUrls()) {
                  pDragEnterEvent->accept();
          } else {
-Line 499 
 void MainForm::dragEnterEvent ( QDragEnt
+Line 647 
 void MainForm::dragEnterEvent ( QDragEnt
  }
- void MainForm::dropEvent ( QDropEvent* pDropEvent )
+ void MainForm::dropEvent ( QDropEvent *pDropEvent )
  {
          // Accept externally originated drops only...
          if (pDropEvent->source())
-Line 510 
 void MainForm::dropEvent ( QDropEvent* p
+Line 658 
 void MainForm::dropEvent ( QDropEvent* p
                  QListIterator<QUrl> iter(pMimeData->urls());
                  while (iter.hasNext()) {
                          const QString& sPath = iter.next().toLocalFile();
-                         if (qsamplerChannel::isInstrumentFile(sPath)) {
+                 //      if (Channel::isDlsInstrumentFile(sPath)) {
+                         if (QFileInfo(sPath).exists()) {
                                  // Try to create a new channel from instrument file...
-                                 qsamplerChannel *pChannel = new qsamplerChannel();
+                                 Channel *pChannel = new Channel();
-                                 if (pChannel == NULL)
+                                 if (pChannel == nullptr)
                                          return;
                                  // Start setting the instrument filename...
                                  pChannel->setInstrument(sPath, 0);
-Line 544 
 void MainForm::dropEvent ( QDropEvent* p
+Line 693 
 void MainForm::dropEvent ( QDropEvent* p
  // Custome event handler.
- void MainForm::customEvent(QEvent* pCustomEvent)
+ void MainForm::customEvent ( QEvent* pEvent )
  {
          // For the time being, just pump it to messages.
-         if (pCustomEvent->type() == QSAMPLER_CUSTOM_EVENT) {
+         if (pEvent->type() == QSAMPLER_LSCP_EVENT) {
-                 qsamplerCustomEvent *pEvent = (qsamplerCustomEvent *) pCustomEvent;
+                 LscpEvent *pLscpEvent = static_cast<LscpEvent *> (pEvent);
-                 if (pEvent->event() == LSCP_EVENT_CHANNEL_INFO) {
+                 switch (pLscpEvent->event()) {
-                         int iChannelID = pEvent->data().toInt();
+                         case LSCP_EVENT_CHANNEL_COUNT:
-                         ChannelStrip *pChannelStrip = channelStrip(iChannelID);
+                                 updateAllChannelStrips(true);
-                         if (pChannelStrip)
+                                 break;
-                                 channelStripChanged(pChannelStrip);
+                         case LSCP_EVENT_CHANNEL_INFO: {
-                 } else {
+                                 const int iChannelID = pLscpEvent->data().toInt();
-                         appendMessagesColor(tr("Notify event: %1 data: %2")
+                                 ChannelStrip *pChannelStrip = channelStrip(iChannelID);
-                                 .arg(::lscp_event_to_text(pEvent->event()))
+                                 if (pChannelStrip)
-                                 .arg(pEvent->data()), "#996699");
+                                         channelStripChanged(pChannelStrip);
+                                 break;
+                         }
+                         case LSCP_EVENT_MIDI_INPUT_DEVICE_COUNT:
+                                 if (m_pDeviceForm) m_pDeviceForm->refreshDevices();
+                                 DeviceStatusForm::onDevicesChanged();
+                                 updateViewMidiDeviceStatusMenu();
+                                 break;
+                         case LSCP_EVENT_MIDI_INPUT_DEVICE_INFO: {
+                                 if (m_pDeviceForm) m_pDeviceForm->refreshDevices();
+                                 const int iDeviceID = pLscpEvent->data().section(' ', 0, 0).toInt();
+                                 DeviceStatusForm::onDeviceChanged(iDeviceID);
+                                 break;
+                         }
+                         case LSCP_EVENT_AUDIO_OUTPUT_DEVICE_COUNT:
+                                 if (m_pDeviceForm) m_pDeviceForm->refreshDevices();
+                                 break;
+                         case LSCP_EVENT_AUDIO_OUTPUT_DEVICE_INFO:
+                                 if (m_pDeviceForm) m_pDeviceForm->refreshDevices();
+                                 break;
+                 #if CONFIG_EVENT_CHANNEL_MIDI
+                         case LSCP_EVENT_CHANNEL_MIDI: {
+                                 const int iChannelID = pLscpEvent->data().section(' ', 0, 0).toInt();
+                                 ChannelStrip *pChannelStrip = channelStrip(iChannelID);
+                                 if (pChannelStrip)
+                                         pChannelStrip->midiActivityLedOn();
+                                 break;
+                         }
+                 #endif
+                 #if CONFIG_EVENT_DEVICE_MIDI
+                         case LSCP_EVENT_DEVICE_MIDI: {
+                                 const int iDeviceID = pLscpEvent->data().section(' ', 0, 0).toInt();
+                                 const int iPortID   = pLscpEvent->data().section(' ', 1, 1).toInt();
+                                 DeviceStatusForm *pDeviceStatusForm
+                                         = DeviceStatusForm::getInstance(iDeviceID);
+                                 if (pDeviceStatusForm)
+                                         pDeviceStatusForm->midiArrived(iPortID);
+                                 break;
+                         }
+                 #endif
+                         default:
+                                 appendMessagesColor(tr("LSCP Event: %1 data: %2")
+                                         .arg(::lscp_event_to_text(pLscpEvent->event()))
+                                         .arg(pLscpEvent->data()), "#996699");
                  }
          }
  }
+ // LADISH Level 1 -- SIGUSR1 signal handler.
+ void MainForm::handle_sigusr1 (void)
+ {
+ #if defined(HAVE_SIGNAL_H) && defined(HAVE_SYS_SOCKET_H)
+         char c;
+         if (::read(g_fdSigusr1[1], &c, sizeof(c)) > 0)
+                 saveSession(false);
+ #endif
+ }
+ void MainForm::handle_sigterm (void)
+ {
+ #if defined(HAVE_SIGNAL_H) && defined(HAVE_SYS_SOCKET_H)
+         char c;
+         if (::read(g_fdSigterm[1], &c, sizeof(c)) > 0)
+                 close();
+ #endif
+ }
+ void MainForm::updateViewMidiDeviceStatusMenu (void)
+ {
+         m_ui.viewMidiDeviceStatusMenu->clear();
+         const std::map<int, DeviceStatusForm *> statusForms
+                 = DeviceStatusForm::getInstances();
+         std::map<int, DeviceStatusForm *>::const_iterator iter
+                 = statusForms.begin();
+         for ( ; iter != statusForms.end(); ++iter) {
+                 DeviceStatusForm *pStatusForm = iter->second;
+                 m_ui.viewMidiDeviceStatusMenu->addAction(
+                         pStatusForm->visibleAction());
+         }
+ }
  // Context menu event handler.
  void MainForm::contextMenuEvent( QContextMenuEvent *pEvent )
  {
-Line 572 
 void MainForm::contextMenuEvent( QContex
+Line 807 
 void MainForm::contextMenuEvent( QContex
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- Brainless public property accessors.
+ // QSampler::MainForm -- Brainless public property accessors.
  // The global options settings property.
- qsamplerOptions *MainForm::options (void) const
+ Options *MainForm::options (void) const
  {
          return m_pOptions;
  }
-Line 596 
 MainForm *MainForm::getInstance (void)
+Line 831 
 MainForm *MainForm::getInstance (void)
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- Session file stuff.
+ // QSampler::MainForm -- Session file stuff.
  // Format the displayable session filename.
  QString MainForm::sessionName ( const QString& sFilename )
  {
-         bool bCompletePath = (m_pOptions && m_pOptions->bCompletePath);
+         const bool bCompletePath = (m_pOptions && m_pOptions->bCompletePath);
          QString sSessionName = sFilename;
          if (sSessionName.isEmpty())
                  sSessionName = tr("Untitled") + QString::number(m_iUntitled);
-Line 625 
 bool MainForm::newSession (void)
+Line 860 
 bool MainForm::newSession (void)
          m_iUntitled++;
          // Stabilize form.
-         m_sFilename = QString::null;
+         m_sFilename = QString();
          m_iDirtyCount = 0;
          appendMessages(tr("New session: \"%1\".").arg(sessionName(m_sFilename)));
          stabilizeForm();
-Line 637 
 bool MainForm::newSession (void)
+Line 872 
 bool MainForm::newSession (void)
  // Open an existing sampler session.
  bool MainForm::openSession (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return false;
          // Ask for the filename to open...
          QString sFilename = QFileDialog::getOpenFileName(this,
-                 QSAMPLER_TITLE ": " + tr("Open Session"), // Caption.
+                 tr("Open Session"),                       // Caption.
                  m_pOptions->sSessionDir,                  // Start here.
                  tr("LSCP Session files") + " (*.lscp)"    // Filter (LSCP files)
          );
-Line 663 
 bool MainForm::openSession (void)
+Line 898 
 bool MainForm::openSession (void)
  // Save current sampler session with another name.
  bool MainForm::saveSession ( bool bPrompt )
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return false;
          QString sFilename = m_sFilename;
-Line 675 
 bool MainForm::saveSession ( bool bPromp
+Line 910 
 bool MainForm::saveSession ( bool bPromp
                          sFilename = m_pOptions->sSessionDir;
                  // Prompt the guy...
                  sFilename = QFileDialog::getSaveFileName(this,
-                         QSAMPLER_TITLE ": " + tr("Save Session"), // Caption.
+                         tr("Save Session"),                       // Caption.
                          sFilename,                                // Start here.
                          tr("LSCP Session files") + " (*.lscp)"    // Filter (LSCP files)
                  );
-Line 685 
 bool MainForm::saveSession ( bool bPromp
+Line 920 
 bool MainForm::saveSession ( bool bPromp
                  // Enforce .lscp extension...
                  if (QFileInfo(sFilename).suffix().isEmpty())
                          sFilename += ".lscp";
+         #if 0
                  // Check if already exists...
                  if (sFilename != m_sFilename && QFileInfo(sFilename).exists()) {
                          if (QMessageBox::warning(this,
-                                 QSAMPLER_TITLE ": " + tr("Warning"),
+                                 tr("Warning"),
                                  tr("The file already exists:\n\n"
                                  "\"%1\"\n\n"
                                  "Do you want to replace it?")
                                  .arg(sFilename),
-                                 tr("Replace"), tr("Cancel")) > 0)
+                                 QMessageBox::Yes | QMessageBox::No)
+                                 == QMessageBox::No)
                                  return false;
                  }
+         #endif
          }
          // Save it right away.
-Line 711 
 bool MainForm::closeSession ( bool bForc
+Line 949 
 bool MainForm::closeSession ( bool bForc
          // Are we dirty enough to prompt it?
          if (m_iDirtyCount > 0) {
                  switch (QMessageBox::warning(this,
-                         QSAMPLER_TITLE ": " + tr("Warning"),
+                         tr("Warning"),
                          tr("The current session has been changed:\n\n"
                          "\"%1\"\n\n"
                          "Do you want to save the changes?")
                          .arg(sessionName(m_sFilename)),
-                         tr("Save"), tr("Discard"), tr("Cancel"))) {
+                         QMessageBox::Save |
-                 case 0:     // Save...
+                         QMessageBox::Discard |
+                         QMessageBox::Cancel)) {
+                 case QMessageBox::Save:
                          bClose = saveSession(false);
                          // Fall thru....
-                 case 1:     // Discard
+                 case QMessageBox::Discard:
                          break;
                  default:    // Cancel.
                          bClose = false;
-Line 732 
 bool MainForm::closeSession ( bool bForc
+Line 972 
 bool MainForm::closeSession ( bool bForc
          if (bClose) {
                  // Remove all channel strips from sight...
                  m_pWorkspace->setUpdatesEnabled(false);
-                 QWidgetList wlist = m_pWorkspace->windowList();
+                 const QList<QMdiSubWindow *>& wlist
-                 for (int iChannel = 0; iChannel < (int) wlist.count(); iChannel++) {
+                         = m_pWorkspace->subWindowList();
-                         ChannelStrip *pChannelStrip = (ChannelStrip*) wlist.at(iChannel);
+                 foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
+                         ChannelStrip *pChannelStrip
+                                 = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
                          if (pChannelStrip) {
-                                 qsamplerChannel *pChannel = pChannelStrip->channel();
+                                 Channel *pChannel = pChannelStrip->channel();
                                  if (bForce && pChannel)
                                          pChannel->removeChannel();
                                  delete pChannelStrip;
                          }
+                         delete pMdiSubWindow;
                  }
                  m_pWorkspace->setUpdatesEnabled(true);
                  // We're now clean, for sure.
-Line 754 
 bool MainForm::closeSession ( bool bForc
+Line 997 
 bool MainForm::closeSession ( bool bForc
  // Load a session from specific file path.
  bool MainForm::loadSessionFile ( const QString& sFilename )
  {
-         if (m_pClient == NULL)
+         if (m_pClient == nullptr)
                  return false;
          // Open and read from real file.
-Line 830 
 bool MainForm::loadSessionFile ( const Q
+Line 1073 
 bool MainForm::loadSessionFile ( const Q
  // Save current session to specific file path.
  bool MainForm::saveSessionFile ( const QString& sFilename )
  {
-         if (m_pClient == NULL)
+         if (m_pClient == nullptr)
                  return false;
          // Check whether server is apparently OK...
-Line 852 
 bool MainForm::saveSessionFile ( const Q
+Line 1095 
 bool MainForm::saveSessionFile ( const Q
          QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
          // Write the file.
-         int  iErrors = 0;
+         int iErrors = 0;
          QTextStream ts(&file);
          ts << "# " << QSAMPLER_TITLE " - " << tr(QSAMPLER_SUBTITLE) << endl;
-         ts << "# " << tr("Version")
+         ts << "# " << tr("Version") << ": " CONFIG_BUILD_VERSION << endl;
-         << ": " QSAMPLER_VERSION << endl;
+ //      ts << "# " << tr("Build") << ": " CONFIG_BUILD_DATE << endl;
-         ts << "# " << tr("Build")
-         << ": " __DATE__ " " __TIME__ << endl;
          ts << "#"  << endl;
          ts << "# " << tr("File")
          << ": " << QFileInfo(sFilename).fileName() << endl;
-Line 871 
 bool MainForm::saveSessionFile ( const Q
+Line 1112 
 bool MainForm::saveSessionFile ( const Q
          // It is assumed that this new kind of device+session file
          // will be loaded from a complete initialized server...
          int *piDeviceIDs;
-         int  iDevice;
+         int  i, iDevice;
          ts << "RESET" << endl;
          // Audio device mapping.
-         QMap<int, int> audioDeviceMap;
+         QMap<int, int> audioDeviceMap; iDevice = 0;
-         piDeviceIDs = qsamplerDevice::getDevices(m_pClient, qsamplerDevice::Audio);
+         piDeviceIDs = Device::getDevices(m_pClient, Device::Audio);
-         for (iDevice = 0; piDeviceIDs && piDeviceIDs[iDevice] >= 0; iDevice++) {
+         for (i = 0; piDeviceIDs && piDeviceIDs[i] >= 0; ++i) {
-                 ts << endl;
+                 Device device(Device::Audio, piDeviceIDs[i]);
-                 qsamplerDevice device(qsamplerDevice::Audio, piDeviceIDs[iDevice]);
+                 // Avoid plug-in driver devices...
+                 if (device.driverName().toUpper() == "PLUGIN")
+                         continue;
                  // Audio device specification...
+                 ts << endl;
                  ts << "# " << device.deviceTypeName() << " " << device.driverName()
                          << " " << tr("Device") << " " << iDevice << endl;
                  ts << "CREATE AUDIO_OUTPUT_DEVICE " << device.driverName();
-                 qsamplerDeviceParamMap::ConstIterator deviceParam;
+                 DeviceParamMap::ConstIterator deviceParam;
                  for (deviceParam = device.params().begin();
                                  deviceParam != device.params().end();
                                          ++deviceParam) {
-                         const qsamplerDeviceParam& param = deviceParam.value();
+                         const DeviceParam& param = deviceParam.value();
                          if (param.value.isEmpty()) ts << "# ";
                          ts << " " << deviceParam.key() << "='" << param.value << "'";
                  }
                  ts << endl;
                  // Audio channel parameters...
                  int iPort = 0;
-                 QListIterator<qsamplerDevicePort *> iter(device.ports());
+                 QListIterator<DevicePort *> iter(device.ports());
                  while (iter.hasNext()) {
-                         qsamplerDevicePort *pPort = iter.next();
+                         DevicePort *pPort = iter.next();
-                         qsamplerDeviceParamMap::ConstIterator portParam;
+                         DeviceParamMap::ConstIterator portParam;
                          for (portParam = pPort->params().begin();
                                          portParam != pPort->params().end();
                                                  ++portParam) {
-                                 const qsamplerDeviceParam& param = portParam.value();
+                                 const DeviceParam& param = portParam.value();
                                  if (param.fix || param.value.isEmpty()) ts << "# ";
                                  ts << "SET AUDIO_OUTPUT_CHANNEL_PARAMETER " << iDevice
                                          << " " << iPort << " " << portParam.key()
-Line 911 
 bool MainForm::saveSessionFile ( const Q
+Line 1155 
 bool MainForm::saveSessionFile ( const Q
                          iPort++;
                  }
                  // Audio device index/id mapping.
-                 audioDeviceMap[device.deviceID()] = iDevice;
+                 audioDeviceMap.insert(device.deviceID(), iDevice++);
                  // Try to keep it snappy :)
                  QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
          }
          // MIDI device mapping.
-         QMap<int, int> midiDeviceMap;
+         QMap<int, int> midiDeviceMap; iDevice = 0;
-         piDeviceIDs = qsamplerDevice::getDevices(m_pClient, qsamplerDevice::Midi);
+         piDeviceIDs = Device::getDevices(m_pClient, Device::Midi);
-         for (iDevice = 0; piDeviceIDs && piDeviceIDs[iDevice] >= 0; iDevice++) {
+         for (i = 0; piDeviceIDs && piDeviceIDs[i] >= 0; ++i) {
-                 ts << endl;
+                 Device device(Device::Midi, piDeviceIDs[i]);
-                 qsamplerDevice device(qsamplerDevice::Midi, piDeviceIDs[iDevice]);
+                 // Avoid plug-in driver devices...
+                 if (device.driverName().toUpper() == "PLUGIN")
+                         continue;
                  // MIDI device specification...
+                 ts << endl;
                  ts << "# " << device.deviceTypeName() << " " << device.driverName()
                          << " " << tr("Device") << " " << iDevice << endl;
                  ts << "CREATE MIDI_INPUT_DEVICE " << device.driverName();
-                 qsamplerDeviceParamMap::ConstIterator deviceParam;
+                 DeviceParamMap::ConstIterator deviceParam;
                  for (deviceParam = device.params().begin();
                                  deviceParam != device.params().end();
                                          ++deviceParam) {
-                         const qsamplerDeviceParam& param = deviceParam.value();
+                         const DeviceParam& param = deviceParam.value();
                          if (param.value.isEmpty()) ts << "# ";
                          ts << " " << deviceParam.key() << "='" << param.value << "'";
                  }
                  ts << endl;
                  // MIDI port parameters...
                  int iPort = 0;
-                 QListIterator<qsamplerDevicePort *> iter(device.ports());
+                 QListIterator<DevicePort *> iter(device.ports());
                  while (iter.hasNext()) {
-                         qsamplerDevicePort *pPort = iter.next();
+                         DevicePort *pPort = iter.next();
-                         qsamplerDeviceParamMap::ConstIterator portParam;
+                         DeviceParamMap::ConstIterator portParam;
                          for (portParam = pPort->params().begin();
                                          portParam != pPort->params().end();
                                                  ++portParam) {
-                                 const qsamplerDeviceParam& param = portParam.value();
+                                 const DeviceParam& param = portParam.value();
                                  if (param.fix || param.value.isEmpty()) ts << "# ";
                                  ts << "SET MIDI_INPUT_PORT_PARAMETER " << iDevice
                                  << " " << iPort << " " << portParam.key()
-Line 953 
 bool MainForm::saveSessionFile ( const Q
+Line 1200 
 bool MainForm::saveSessionFile ( const Q
                          iPort++;
                  }
                  // MIDI device index/id mapping.
-                 midiDeviceMap[device.deviceID()] = iDevice;
+                 midiDeviceMap.insert(device.deviceID(), iDevice++);
                  // Try to keep it snappy :)
                  QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
          }
-Line 964 
 bool MainForm::saveSessionFile ( const Q
+Line 1211 
 bool MainForm::saveSessionFile ( const Q
          QMap<int, int> midiInstrumentMap;
          int *piMaps = ::lscp_list_midi_instrument_maps(m_pClient);
          for (int iMap = 0; piMaps && piMaps[iMap] >= 0; iMap++) {
-                 int iMidiMap = piMaps[iMap];
+                 const int iMidiMap = piMaps[iMap];
                  const char *pszMapName
                          = ::lscp_get_midi_instrument_map_name(m_pClient, iMidiMap);
                  ts << "# " << tr("MIDI instrument map") << " " << iMap;
-Line 1016 
 bool MainForm::saveSessionFile ( const Q
+Line 1263 
 bool MainForm::saveSessionFile ( const Q
                  }
                  ts << endl;
                  // Check for errors...
-                 if (pInstrs == NULL && ::lscp_client_get_errno(m_pClient)) {
+                 if (pInstrs == nullptr && ::lscp_client_get_errno(m_pClient)) {
                          appendMessagesClient("lscp_list_midi_instruments");
                          iErrors++;
                  }
                  // MIDI strument index/id mapping.
-                 midiInstrumentMap[iMidiMap] = iMap;
+                 midiInstrumentMap.insert(iMidiMap, iMap);
          }
          // Check for errors...
-         if (piMaps == NULL && ::lscp_client_get_errno(m_pClient)) {
+         if (piMaps == nullptr && ::lscp_client_get_errno(m_pClient)) {
                  appendMessagesClient("lscp_list_midi_instrument_maps");
                  iErrors++;
          }
  #endif  // CONFIG_MIDI_INSTRUMENT
-         // Sampler channel mapping.
+         // Sampler channel mapping...
-         QWidgetList wlist = m_pWorkspace->windowList();
+         int iChannelID = 0;
-         for (int iChannel = 0; iChannel < (int) wlist.count(); iChannel++) {
+         const QList<QMdiSubWindow *>& wlist
-                 ChannelStrip* pChannelStrip
+                 = m_pWorkspace->subWindowList();
-                         = static_cast<ChannelStrip *> (wlist.at(iChannel));
+         foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
+                 ChannelStrip *pChannelStrip
+                         = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
                  if (pChannelStrip) {
-                         qsamplerChannel *pChannel = pChannelStrip->channel();
+                         Channel *pChannel = pChannelStrip->channel();
                          if (pChannel) {
-                                 ts << "# " << tr("Channel") << " " << iChannel << endl;
+                                 // Avoid "artifial" plug-in devices...
+                                 const int iAudioDevice = pChannel->audioDevice();
+                                 if (!audioDeviceMap.contains(iAudioDevice))
+                                         continue;
+                                 const int iMidiDevice = pChannel->midiDevice();
+                                 if (!midiDeviceMap.contains(iMidiDevice))
+                                         continue;
+                                 // Go for regular, canonical devices...
+                                 ts << "# " << tr("Channel") << " " << iChannelID << endl;
                                  ts << "ADD CHANNEL" << endl;
                                  if (audioDeviceMap.isEmpty()) {
-                                         ts << "SET CHANNEL AUDIO_OUTPUT_TYPE " << iChannel
+                                         ts << "SET CHANNEL AUDIO_OUTPUT_TYPE " << iChannelID
                                                  << " " << pChannel->audioDriver() << endl;
                                  } else {
-                                         ts << "SET CHANNEL AUDIO_OUTPUT_DEVICE " << iChannel
+                                         ts << "SET CHANNEL AUDIO_OUTPUT_DEVICE " << iChannelID
-                                                 << " " << audioDeviceMap[pChannel->audioDevice()] << endl;
+                                                 << " " << audioDeviceMap.value(iAudioDevice) << endl;
                                  }
                                  if (midiDeviceMap.isEmpty()) {
-                                         ts << "SET CHANNEL MIDI_INPUT_TYPE " << iChannel
+                                         ts << "SET CHANNEL MIDI_INPUT_TYPE " << iChannelID
                                                  << " " << pChannel->midiDriver() << endl;
                                  } else {
-                                         ts << "SET CHANNEL MIDI_INPUT_DEVICE " << iChannel
+                                         ts << "SET CHANNEL MIDI_INPUT_DEVICE " << iChannelID
-                                                 << " " << midiDeviceMap[pChannel->midiDevice()] << endl;
+                                                 << " " << midiDeviceMap.value(iMidiDevice) << endl;
                                  }
-                                 ts << "SET CHANNEL MIDI_INPUT_PORT " << iChannel
+                                 ts << "SET CHANNEL MIDI_INPUT_PORT " << iChannelID
                                          << " " << pChannel->midiPort() << endl;
-                                 ts << "SET CHANNEL MIDI_INPUT_CHANNEL " << iChannel << " ";
+                                 ts << "SET CHANNEL MIDI_INPUT_CHANNEL " << iChannelID << " ";
                                  if (pChannel->midiChannel() == LSCP_MIDI_CHANNEL_ALL)
                                          ts << "ALL";
                                  else
                                          ts << pChannel->midiChannel();
                                  ts << endl;
                                  ts << "LOAD ENGINE " << pChannel->engineName()
-                                         << " " << iChannel << endl;
+                                         << " " << iChannelID << endl;
                                  if (pChannel->instrumentStatus() < 100) ts << "# ";
                                  ts << "LOAD INSTRUMENT NON_MODAL '"
                                          << pChannel->instrumentFile() << "' "
-                                         << pChannel->instrumentNr() << " " << iChannel << endl;
+                                         << pChannel->instrumentNr() << " " << iChannelID << endl;
-                                 qsamplerChannelRoutingMap::ConstIterator audioRoute;
+                                 ChannelRoutingMap::ConstIterator audioRoute;
                                  for (audioRoute = pChannel->audioRouting().begin();
                                                  audioRoute != pChannel->audioRouting().end();
                                                          ++audioRoute) {
-                                         ts << "SET CHANNEL AUDIO_OUTPUT_CHANNEL " << iChannel
+                                         ts << "SET CHANNEL AUDIO_OUTPUT_CHANNEL " << iChannelID
                                                  << " " << audioRoute.key()
                                                  << " " << audioRoute.value() << endl;
                                  }
-                                 ts << "SET CHANNEL VOLUME " << iChannel
+                                 ts << "SET CHANNEL VOLUME " << iChannelID
                                          << " " << pChannel->volume() << endl;
                                  if (pChannel->channelMute())
-                                         ts << "SET CHANNEL MUTE " << iChannel << " 1" << endl;
+                                         ts << "SET CHANNEL MUTE " << iChannelID << " 1" << endl;
                                  if (pChannel->channelSolo())
-                                         ts << "SET CHANNEL SOLO " << iChannel << " 1" << endl;
+                                         ts << "SET CHANNEL SOLO " << iChannelID << " 1" << endl;
- #ifdef CONFIG_MIDI_INSTRUMENT
+                         #ifdef CONFIG_MIDI_INSTRUMENT
-                                 if (pChannel->midiMap() >= 0) {
+                                 const int iMidiMap = pChannel->midiMap();
-                                         ts << "SET CHANNEL MIDI_INSTRUMENT_MAP " << iChannel
+                                 if (midiInstrumentMap.contains(iMidiMap)) {
-                                                 << " " << midiInstrumentMap[pChannel->midiMap()] << endl;
+                                         ts << "SET CHANNEL MIDI_INSTRUMENT_MAP " << iChannelID
+                                                 << " " << midiInstrumentMap.value(iMidiMap) << endl;
                                  }
- #endif
+                         #endif
- #ifdef CONFIG_FXSEND
+                         #ifdef CONFIG_FXSEND
-                                 int iChannelID = pChannel->channelID();
                                  int *piFxSends = ::lscp_list_fxsends(m_pClient, iChannelID);
                                  for (int iFxSend = 0;
                                                  piFxSends && piFxSends[iFxSend] >= 0;
-Line 1097 
 bool MainForm::saveSessionFile ( const Q
+Line 1354 
 bool MainForm::saveSessionFile ( const Q
                                          lscp_fxsend_info_t *pFxSendInfo = ::lscp_get_fxsend_info(
                                                  m_pClient, iChannelID, piFxSends[iFxSend]);
                                          if (pFxSendInfo) {
-                                                 ts << "CREATE FX_SEND " << iChannel
+                                                 ts << "CREATE FX_SEND " << iChannelID
                                                          << " " << pFxSendInfo->midi_controller;
                                                  if (pFxSendInfo->name)
                                                          ts << " '" << pFxSendInfo->name << "'";
-Line 1107 
 bool MainForm::saveSessionFile ( const Q
+Line 1364 
 bool MainForm::saveSessionFile ( const Q
                                                                  piRouting && piRouting[iAudioSrc] >= 0;
                                                                          iAudioSrc++) {
                                                          ts << "SET FX_SEND AUDIO_OUTPUT_CHANNEL "
-                                                                 << iChannel
+                                                                 << iChannelID
                                                                  << " " << iFxSend
                                                                  << " " << iAudioSrc
                                                                  << " " << piRouting[iAudioSrc] << endl;
                                                  }
- #ifdef CONFIG_FXSEND_LEVEL
+                                         #ifdef CONFIG_FXSEND_LEVEL
-                                                 ts << "SET FX_SEND LEVEL " << iChannel
+                                                 ts << "SET FX_SEND LEVEL " << iChannelID
                                                          << " " << iFxSend
                                                          << " " << pFxSendInfo->level << endl;
- #endif
+                                         #endif
                                          }       // Check for errors...
                                          else if (::lscp_client_get_errno(m_pClient)) {
                                                  appendMessagesClient("lscp_get_fxsend_info");
                                                  iErrors++;
                                          }
                                  }
- #endif
+                         #endif
                                  ts << endl;
+                                 // Go for next channel...
+                                 ++iChannelID;
                          }
                  }
                  // Try to keep it snappy :)
-Line 1176 
 void MainForm::sessionDirty (void)
+Line 1435 
 void MainForm::sessionDirty (void)
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- File Action slots.
+ // QSampler::MainForm -- File Action slots.
  // Create a new sampler session.
  void MainForm::fileNew (void)
-Line 1200 
 void MainForm::fileOpenRecent (void)
+Line 1459 
 void MainForm::fileOpenRecent (void)
          // Retrive filename index from action data...
          QAction *pAction = qobject_cast<QAction *> (sender());
          if (pAction && m_pOptions) {
-                 int iIndex = pAction->data().toInt();
+                 const int iIndex = pAction->data().toInt();
                  if (iIndex >= 0 && iIndex < m_pOptions->recentFiles.count()) {
                          QString sFilename = m_pOptions->recentFiles[iIndex];
                          // Check if we can safely close the current session...
-Line 1230 
 void MainForm::fileSaveAs (void)
+Line 1489 
 void MainForm::fileSaveAs (void)
  // Reset the sampler instance.
  void MainForm::fileReset (void)
  {
-         if (m_pClient == NULL)
+         if (m_pClient == nullptr)
                  return;
          // Ask user whether he/she want's an internal sampler reset...
-         if (QMessageBox::warning(this,
+         if (m_pOptions && m_pOptions->bConfirmReset) {
-                 QSAMPLER_TITLE ": " + tr("Warning"),
+                 const QString& sTitle = tr("Warning");
-                 tr("Resetting the sampler instance will close\n"
+                 const QString& sText = tr(
-                 "all device and channel configurations.\n\n"
+                         "Resetting the sampler instance will close\n"
-                 "Please note that this operation may cause\n"
+                         "all device and channel configurations.\n\n"
-                 "temporary MIDI and Audio disruption.\n\n"
+                         "Please note that this operation may cause\n"
-                 "Do you want to reset the sampler engine now?"),
+                         "temporary MIDI and Audio disruption.\n\n"
-                 tr("Reset"), tr("Cancel")) > 0)
+                         "Do you want to reset the sampler engine now?");
-                 return;
+         #if 0
+                 if (QMessageBox::warning(this, sTitle, sText,
+                         QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Cancel)
+                         return;
+         #else
+                 QMessageBox mbox(this);
+                 mbox.setIcon(QMessageBox::Warning);
+                 mbox.setWindowTitle(sTitle);
+                 mbox.setText(sText);
+                 mbox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
+                 QCheckBox cbox(tr("Don't ask this again"));
+                 cbox.setChecked(false);
+                 cbox.blockSignals(true);
+                 mbox.addButton(&cbox, QMessageBox::ActionRole);
+                 if (mbox.exec() == QMessageBox::Cancel)
+                         return;
+                 if (cbox.isChecked())
+                         m_pOptions->bConfirmReset = false;
+         #endif
+         }
          // Trye closing the current session, first...
          if (!closeSession(true))
-Line 1267 
 void MainForm::fileReset (void)
+Line 1545 
 void MainForm::fileReset (void)
  // Restart the client/server instance.
  void MainForm::fileRestart (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          bool bRestart = true;
          // Ask user whether he/she want's a complete restart...
          // (if we're currently up and running)
-         if (bRestart && m_pClient) {
+         if (m_pOptions && m_pOptions->bConfirmRestart) {
-                 bRestart = (QMessageBox::warning(this,
+                 const QString& sTitle = tr("Warning");
-                         QSAMPLER_TITLE ": " + tr("Warning"),
+                 const QString& sText = tr(
-                         tr("New settings will be effective after\n"
+                         "New settings will be effective after\n"
                          "restarting the client/server connection.\n\n"
                          "Please note that this operation may cause\n"
                          "temporary MIDI and Audio disruption.\n\n"
-                         "Do you want to restart the connection now?"),
+                         "Do you want to restart the connection now?");
-                         tr("Restart"), tr("Cancel")) == 0);
+         #if 0
+                 if (QMessageBox::warning(this, sTitle, sText,
+                         QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Cancel)
+                         bRestart = false;
+         #else
+                 QMessageBox mbox(this);
+                 mbox.setIcon(QMessageBox::Warning);
+                 mbox.setWindowTitle(sTitle);
+                 mbox.setText(sText);
+                 mbox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
+                 QCheckBox cbox(tr("Don't ask this again"));
+                 cbox.setChecked(false);
+                 cbox.blockSignals(true);
+                 mbox.addButton(&cbox, QMessageBox::ActionRole);
+                 if (mbox.exec() == QMessageBox::Cancel)
+                         bRestart = false;
+                 else
+                 if (cbox.isChecked())
+                         m_pOptions->bConfirmRestart = false;
+         #endif
          }
          // Are we still for it?
-Line 1304 
 void MainForm::fileExit (void)
+Line 1601 
 void MainForm::fileExit (void)
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- Edit Action slots.
+ // QSampler::MainForm -- Edit Action slots.
  // Add a new sampler channel.
  void MainForm::editAddChannel (void)
  {
-         if (m_pClient == NULL)
+         ++m_iDirtySetup;
+         addChannelStrip();
+         --m_iDirtySetup;
+ }
+ void MainForm::addChannelStrip (void)
+ {
+         if (m_pClient == nullptr)
                  return;
          // Just create the channel instance...
-         qsamplerChannel *pChannel = new qsamplerChannel();
+         Channel *pChannel = new Channel();
-         if (pChannel == NULL)
+         if (pChannel == nullptr)
                  return;
          // Before we show it up, may be we'll
-Line 1331 
 void MainForm::editAddChannel (void)
+Line 1635 
 void MainForm::editAddChannel (void)
                  return;
          }
+         // Do we auto-arrange?
+         channelsArrangeAuto();
          // Make that an overall update.
          m_iDirtyCount++;
          stabilizeForm();
-Line 1340 
 void MainForm::editAddChannel (void)
+Line 1647 
 void MainForm::editAddChannel (void)
  // Remove current sampler channel.
  void MainForm::editRemoveChannel (void)
  {
-         if (m_pClient == NULL)
+         ++m_iDirtySetup;
+         removeChannelStrip();
+         --m_iDirtySetup;
+ }
+ void MainForm::removeChannelStrip (void)
+ {
+         if (m_pClient == nullptr)
                  return;
-         ChannelStrip* pChannelStrip = activeChannelStrip();
+         ChannelStrip *pChannelStrip = activeChannelStrip();
-         if (pChannelStrip == NULL)
+         if (pChannelStrip == nullptr)
                  return;
-         qsamplerChannel *pChannel = pChannelStrip->channel();
+         Channel *pChannel = pChannelStrip->channel();
-         if (pChannel == NULL)
+         if (pChannel == nullptr)
                  return;
          // Prompt user if he/she's sure about this...
          if (m_pOptions && m_pOptions->bConfirmRemove) {
-                 if (QMessageBox::warning(this,
+                 const QString& sTitle = tr("Warning");
-                         QSAMPLER_TITLE ": " + tr("Warning"),
+                 const QString& sText = tr(
-                         tr("About to remove channel:\n\n"
+                         "About to remove channel:\n\n"
                          "%1\n\n"
                          "Are you sure?")
-                         .arg(pChannelStrip->windowTitle()),
+                         .arg(pChannelStrip->windowTitle());
-                         tr("OK"), tr("Cancel")) > 0)
+         #if 0
+                 if (QMessageBox::warning(this, sTitle, sText,
+                         QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Cancel)
                          return;
+         #else
+                 QMessageBox mbox(this);
+                 mbox.setIcon(QMessageBox::Warning);
+                 mbox.setWindowTitle(sTitle);
+                 mbox.setText(sText);
+                 mbox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
+                 QCheckBox cbox(tr("Don't ask this again"));
+                 cbox.setChecked(false);
+                 cbox.blockSignals(true);
+                 mbox.addButton(&cbox, QMessageBox::ActionRole);
+                 if (mbox.exec() == QMessageBox::Cancel)
+                         return;
+                 if (cbox.isChecked())
+                         m_pOptions->bConfirmRemove = false;
+         #endif
          }
          // Remove the existing sampler channel.
-Line 1368 
 void MainForm::editRemoveChannel (void)
+Line 1699 
 void MainForm::editRemoveChannel (void)
                  return;
          // Just delete the channel strip.
-         delete pChannelStrip;
+         destroyChannelStrip(pChannelStrip);
-         // Do we auto-arrange?
-         if (m_pOptions && m_pOptions->bAutoArrange)
-                 channelsArrange();
          // We'll be dirty, for sure...
          m_iDirtyCount++;
-Line 1383 
 void MainForm::editRemoveChannel (void)
+Line 1710 
 void MainForm::editRemoveChannel (void)
  // Setup current sampler channel.
  void MainForm::editSetupChannel (void)
  {
-         if (m_pClient == NULL)
+         if (m_pClient == nullptr)
                  return;
-         ChannelStrip* pChannelStrip = activeChannelStrip();
+         ChannelStrip *pChannelStrip = activeChannelStrip();
-         if (pChannelStrip == NULL)
+         if (pChannelStrip == nullptr)
                  return;
          // Just invoque the channel strip procedure.
-Line 1398 
 void MainForm::editSetupChannel (void)
+Line 1725 
 void MainForm::editSetupChannel (void)
  // Edit current sampler channel.
  void MainForm::editEditChannel (void)
  {
-         if (m_pClient == NULL)
+         if (m_pClient == nullptr)
                  return;
-         ChannelStrip* pChannelStrip = activeChannelStrip();
+         ChannelStrip *pChannelStrip = activeChannelStrip();
-         if (pChannelStrip == NULL)
+         if (pChannelStrip == nullptr)
                  return;
          // Just invoque the channel strip procedure.
-Line 1413 
 void MainForm::editEditChannel (void)
+Line 1740 
 void MainForm::editEditChannel (void)
  // Reset current sampler channel.
  void MainForm::editResetChannel (void)
  {
-         if (m_pClient == NULL)
+         if (m_pClient == nullptr)
                  return;
-         ChannelStrip* pChannelStrip = activeChannelStrip();
+         ChannelStrip *pChannelStrip = activeChannelStrip();
-         if (pChannelStrip == NULL)
+         if (pChannelStrip == nullptr)
                  return;
          // Just invoque the channel strip procedure.
-Line 1428 
 void MainForm::editResetChannel (void)
+Line 1755 
 void MainForm::editResetChannel (void)
  // Reset all sampler channels.
  void MainForm::editResetAllChannels (void)
  {
-         if (m_pClient == NULL)
+         if (m_pClient == nullptr)
                  return;
          // Invoque the channel strip procedure,
          // for all channels out there...
          m_pWorkspace->setUpdatesEnabled(false);
-         QWidgetList wlist = m_pWorkspace->windowList();
+         const QList<QMdiSubWindow *>& wlist
-         for (int iChannel = 0; iChannel < (int) wlist.count(); iChannel++) {
+                 = m_pWorkspace->subWindowList();
-                 ChannelStrip* pChannelStrip = (ChannelStrip*) wlist.at(iChannel);
+         foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
+                 ChannelStrip *pChannelStrip
+                         = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
                  if (pChannelStrip)
                          pChannelStrip->channelReset();
          }
-Line 1445 
 void MainForm::editResetAllChannels (voi
+Line 1774 
 void MainForm::editResetAllChannels (voi
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- View Action slots.
+ // QSampler::MainForm -- View Action slots.
  // Show/hide the main program window menubar.
  void MainForm::viewMenubar ( bool bOn )
-Line 1495 
 void MainForm::viewMessages ( bool bOn )
+Line 1824 
 void MainForm::viewMessages ( bool bOn )
  // Show/hide the MIDI instrument list-view form.
  void MainForm::viewInstruments (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          if (m_pInstrumentListForm) {
-Line 1514 
 void MainForm::viewInstruments (void)
+Line 1843 
 void MainForm::viewInstruments (void)
  // Show/hide the device configurator form.
  void MainForm::viewDevices (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          if (m_pDeviceForm) {
-Line 1533 
 void MainForm::viewDevices (void)
+Line 1862 
 void MainForm::viewDevices (void)
  // Show options dialog.
  void MainForm::viewOptions (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          OptionsForm* pOptionsForm = new OptionsForm(this);
          if (pOptionsForm) {
                  // Check out some initial nullities(tm)...
-                 ChannelStrip* pChannelStrip = activeChannelStrip();
+                 ChannelStrip *pChannelStrip = activeChannelStrip();
                  if (m_pOptions->sDisplayFont.isEmpty() && pChannelStrip)
                          m_pOptions->sDisplayFont = pChannelStrip->displayFont().toString();
                  if (m_pOptions->sMessagesFont.isEmpty() && m_pMessages)
                          m_pOptions->sMessagesFont = m_pMessages->messagesFont().toString();
                  // To track down deferred or immediate changes.
-                 QString sOldServerHost      = m_pOptions->sServerHost;
+                 const QString sOldServerHost      = m_pOptions->sServerHost;
-                 int     iOldServerPort      = m_pOptions->iServerPort;
+                 const int     iOldServerPort      = m_pOptions->iServerPort;
-                 int     iOldServerTimeout   = m_pOptions->iServerTimeout;
+                 const int     iOldServerTimeout   = m_pOptions->iServerTimeout;
-                 bool    bOldServerStart     = m_pOptions->bServerStart;
+                 const bool    bOldServerStart     = m_pOptions->bServerStart;
-                 QString sOldServerCmdLine   = m_pOptions->sServerCmdLine;
+                 const QString sOldServerCmdLine   = m_pOptions->sServerCmdLine;
-                 QString sOldDisplayFont     = m_pOptions->sDisplayFont;
+                 const bool    bOldMessagesLog     = m_pOptions->bMessagesLog;
-                 bool    bOldDisplayEffect   = m_pOptions->bDisplayEffect;
+                 const QString sOldMessagesLogPath = m_pOptions->sMessagesLogPath;
-                 int     iOldMaxVolume       = m_pOptions->iMaxVolume;
+                 const QString sOldDisplayFont     = m_pOptions->sDisplayFont;
-                 QString sOldMessagesFont    = m_pOptions->sMessagesFont;
+                 const bool    bOldDisplayEffect   = m_pOptions->bDisplayEffect;
-                 bool    bOldKeepOnTop       = m_pOptions->bKeepOnTop;
+                 const int     iOldMaxVolume       = m_pOptions->iMaxVolume;
-                 bool    bOldStdoutCapture   = m_pOptions->bStdoutCapture;
+                 const QString sOldMessagesFont    = m_pOptions->sMessagesFont;
-                 int     bOldMessagesLimit   = m_pOptions->bMessagesLimit;
+                 const bool    bOldKeepOnTop       = m_pOptions->bKeepOnTop;
-                 int     iOldMessagesLimitLines = m_pOptions->iMessagesLimitLines;
+                 const bool    bOldStdoutCapture   = m_pOptions->bStdoutCapture;
-                 bool    bOldCompletePath    = m_pOptions->bCompletePath;
+                 const int     bOldMessagesLimit   = m_pOptions->bMessagesLimit;
-                 bool    bOldInstrumentNames = m_pOptions->bInstrumentNames;
+                 const int     iOldMessagesLimitLines = m_pOptions->iMessagesLimitLines;
-                 int     iOldMaxRecentFiles  = m_pOptions->iMaxRecentFiles;
+                 const bool    bOldCompletePath    = m_pOptions->bCompletePath;
+                 const bool    bOldInstrumentNames = m_pOptions->bInstrumentNames;
+                 const int     iOldMaxRecentFiles  = m_pOptions->iMaxRecentFiles;
+                 const int     iOldBaseFontSize    = m_pOptions->iBaseFontSize;
                  // Load the current setup settings.
                  pOptionsForm->setup(m_pOptions);
                  // Show the setup dialog...
-Line 1569 
 void MainForm::viewOptions (void)
+Line 1901 
 void MainForm::viewOptions (void)
                          if (( bOldStdoutCapture && !m_pOptions->bStdoutCapture) ||
                                  (!bOldStdoutCapture &&  m_pOptions->bStdoutCapture) ||
                                  ( bOldKeepOnTop     && !m_pOptions->bKeepOnTop)     ||
-                                 (!bOldKeepOnTop     &&  m_pOptions->bKeepOnTop)) {
+                                 (!bOldKeepOnTop     &&  m_pOptions->bKeepOnTop)     ||
+                                 (iOldBaseFontSize   !=  m_pOptions->iBaseFontSize)) {
                                  QMessageBox::information(this,
-                                         QSAMPLER_TITLE ": " + tr("Information"),
+                                         tr("Information"),
                                          tr("Some settings may be only effective\n"
-                                         "next time you start this program."), tr("OK"));
+                                         "next time you start this program."));
                                  updateMessagesCapture();
                          }
                          // Check wheather something immediate has changed.
+                         if (( bOldMessagesLog && !m_pOptions->bMessagesLog) ||
+                                 (!bOldMessagesLog &&  m_pOptions->bMessagesLog) ||
+                                 (sOldMessagesLogPath != m_pOptions->sMessagesLogPath))
+                                 m_pMessages->setLogging(
+                                         m_pOptions->bMessagesLog, m_pOptions->sMessagesLogPath);
                          if (( bOldCompletePath && !m_pOptions->bCompletePath) ||
                                  (!bOldCompletePath &&  m_pOptions->bCompletePath) ||
                                  (iOldMaxRecentFiles != m_pOptions->iMaxRecentFiles))
-Line 1617 
 void MainForm::viewOptions (void)
+Line 1955 
 void MainForm::viewOptions (void)
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- Channels action slots.
+ // QSampler::MainForm -- Channels action slots.
  // Arrange channel strips.
  void MainForm::channelsArrange (void)
  {
          // Full width vertical tiling
-         QWidgetList wlist = m_pWorkspace->windowList();
+         const QList<QMdiSubWindow *>& wlist
+                 = m_pWorkspace->subWindowList();
          if (wlist.isEmpty())
                  return;
          m_pWorkspace->setUpdatesEnabled(false);
          int y = 0;
-         for (int iChannel = 0; iChannel < (int) wlist.count(); iChannel++) {
+         foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
-                 ChannelStrip* pChannelStrip = (ChannelStrip*) wlist.at(iChannel);
+                 pMdiSubWindow->adjustSize();
-         /*  if (pChannelStrip->testWState(WState_Maximized | WState_Minimized)) {
+                 const QRect& frameRect
-                         // Prevent flicker...
+                         = pMdiSubWindow->frameGeometry();
-                         pChannelStrip->hide();
+                 int w = m_pWorkspace->width();
-                         pChannelStrip->showNormal();
+                 if (w < frameRect.width())
-                 }   */
+                         w = frameRect.width();
-                 pChannelStrip->adjustSize();
+                 const int h = frameRect.height();
-                 int iWidth  = m_pWorkspace->width();
+                 pMdiSubWindow->setGeometry(0, y, w, h);
-                 if (iWidth < pChannelStrip->width())
+                 y += h;
-                         iWidth = pChannelStrip->width();
-         //  int iHeight = pChannelStrip->height()
-         //              + pChannelStrip->parentWidget()->baseSize().height();
-                 int iHeight = pChannelStrip->parentWidget()->frameGeometry().height();
-                 pChannelStrip->parentWidget()->setGeometry(0, y, iWidth, iHeight);
-                 y += iHeight;
          }
          m_pWorkspace->setUpdatesEnabled(true);
-Line 1655 
 void MainForm::channelsArrange (void)
+Line 1988 
 void MainForm::channelsArrange (void)
  // Auto-arrange channel strips.
  void MainForm::channelsAutoArrange ( bool bOn )
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          // Toggle the auto-arrange flag.
          m_pOptions->bAutoArrange = bOn;
          // If on, update whole workspace...
-         if (m_pOptions->bAutoArrange)
+         channelsArrangeAuto();
+ }
+ void MainForm::channelsArrangeAuto (void)
+ {
+         if (m_pOptions && m_pOptions->bAutoArrange)
                  channelsArrange();
  }
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- Help Action slots.
+ // QSampler::MainForm -- Help Action slots.
  // Show information about the Qt toolkit.
  void MainForm::helpAboutQt (void)
-Line 1680 
 void MainForm::helpAboutQt (void)
+Line 2019 
 void MainForm::helpAboutQt (void)
  // Show information about application program.
  void MainForm::helpAbout (void)
  {
-         // Stuff the about box text...
+         QStringList list;
-         QString sText = "<p>\n";
-         sText += "<b>" QSAMPLER_TITLE " - " + tr(QSAMPLER_SUBTITLE) + "</b><br />\n";
-         sText += "<br />\n";
-         sText += tr("Version") + ": <b>" QSAMPLER_VERSION "</b><br />\n";
-         sText += "<small>" + tr("Build") + ": " __DATE__ " " __TIME__ "</small><br />\n";
  #ifdef CONFIG_DEBUG
-         sText += "<small><font color=\"red\">";
+         list << tr("Debugging option enabled.");
-         sText += tr("Debugging option enabled.");
-         sText += "</font></small><br />";
  #endif
  #ifndef CONFIG_LIBGIG
-         sText += "<small><font color=\"red\">";
+         list << tr("GIG (libgig) file support disabled.");
-         sText += tr("GIG (libgig) file support disabled.");
-         sText += "</font></small><br />";
  #endif
  #ifndef CONFIG_INSTRUMENT_NAME
-         sText += "<small><font color=\"red\">";
+         list << tr("LSCP (liblscp) instrument_name support disabled.");
-         sText += tr("LSCP (liblscp) instrument_name support disabled.");
-         sText += "</font></small><br />";
  #endif
  #ifndef CONFIG_MUTE_SOLO
-         sText += "<small><font color=\"red\">";
+         list << tr("Sampler channel Mute/Solo support disabled.");
-         sText += tr("Sampler channel Mute/Solo support disabled.");
-         sText += "</font></small><br />";
  #endif
  #ifndef CONFIG_AUDIO_ROUTING
-         sText += "<small><font color=\"red\">";
+         list << tr("LSCP (liblscp) audio_routing support disabled.");
-         sText += tr("LSCP (liblscp) audio_routing support disabled.");
-         sText += "</font></small><br />";
  #endif
  #ifndef CONFIG_FXSEND
-         sText += "<small><font color=\"red\">";
+         list << tr("Sampler channel Effect Sends support disabled.");
-         sText += tr("Sampler channel Effect Sends support disabled.");
-         sText += "</font></small><br />";
  #endif
  #ifndef CONFIG_VOLUME
-         sText += "<small><font color=\"red\">";
+         list << tr("Global volume support disabled.");
-         sText += tr("Global volume support disabled.");
-         sText += "</font></small><br />";
  #endif
  #ifndef CONFIG_MIDI_INSTRUMENT
-         sText += "<small><font color=\"red\">";
+         list << tr("MIDI instrument mapping support disabled.");
-         sText += tr("MIDI instrument mapping support disabled.");
-         sText += "</font></small><br />";
  #endif
  #ifndef CONFIG_EDIT_INSTRUMENT
-         sText += "<small><font color=\"red\">";
+         list << tr("Instrument editing support disabled.");
-         sText += tr("Instrument editing support disabled.");
+ #endif
-         sText += "</font></small><br />";
+ #ifndef CONFIG_EVENT_CHANNEL_MIDI
+         list << tr("Channel MIDI event support disabled.");
+ #endif
+ #ifndef CONFIG_EVENT_DEVICE_MIDI
+         list << tr("Device MIDI event support disabled.");
  #endif
+ #ifndef CONFIG_MAX_VOICES
+         list << tr("Runtime max. voices / disk streams support disabled.");
+ #endif
+         // Stuff the about box text...
+         QString sText = "<p>\n";
+         sText += "<b>" QSAMPLER_TITLE " - " + tr(QSAMPLER_SUBTITLE) + "</b><br />\n";
+         sText += "<br />\n";
+         sText += tr("Version") + ": <b>" CONFIG_BUILD_VERSION "</b><br />\n";
+ //      sText += "<small>" + tr("Build") + ": " CONFIG_BUILD_DATE "</small><br />\n";
+         if (!list.isEmpty()) {
+                 sText += "<small><font color=\"red\">";
+                 sText += list.join("<br />\n");
+                 sText += "</font></small>";
+         }
          sText += "<br />\n";
          sText += tr("Using") + ": ";
          sText += ::lscp_client_package();
-Line 1755 
 void MainForm::helpAbout (void)
+Line 2092 
 void MainForm::helpAbout (void)
          sText += "</small>";
          sText += "</p>\n";
-         QMessageBox::about(this, tr("About") + " " QSAMPLER_TITLE, sText);
+         QMessageBox::about(this, tr("About"), sText);
  }
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- Main window stabilization.
+ // QSampler::MainForm -- Main window stabilization.
  void MainForm::stabilizeForm (void)
  {
-Line 1768 
 void MainForm::stabilizeForm (void)
+Line 2105 
 void MainForm::stabilizeForm (void)
          QString sSessionName = sessionName(m_sFilename);
          if (m_iDirtyCount > 0)
                  sSessionName += " *";
-         setWindowTitle(tr(QSAMPLER_TITLE " - [%1]").arg(sSessionName));
+         setWindowTitle(sSessionName);
          // Update the main menu state...
-         ChannelStrip* pChannelStrip = activeChannelStrip();
+         ChannelStrip *pChannelStrip = activeChannelStrip();
-         bool bHasClient  = (m_pOptions != NULL && m_pClient != NULL);
+         const QList<QMdiSubWindow *>& wlist = m_pWorkspace->subWindowList();
-         bool bHasChannel = (bHasClient && pChannelStrip != NULL);
+         const bool bHasClient = (m_pOptions != nullptr && m_pClient != nullptr);
+         const bool bHasChannel = (bHasClient && pChannelStrip != nullptr);
+         const bool bHasChannels = (bHasClient && wlist.count() > 0);
          m_ui.fileNewAction->setEnabled(bHasClient);
          m_ui.fileOpenAction->setEnabled(bHasClient);
          m_ui.fileSaveAction->setEnabled(bHasClient && m_iDirtyCount > 0);
          m_ui.fileSaveAsAction->setEnabled(bHasClient);
          m_ui.fileResetAction->setEnabled(bHasClient);
-         m_ui.fileRestartAction->setEnabled(bHasClient || m_pServer == NULL);
+         m_ui.fileRestartAction->setEnabled(bHasClient || m_pServer == nullptr);
          m_ui.editAddChannelAction->setEnabled(bHasClient);
          m_ui.editRemoveChannelAction->setEnabled(bHasChannel);
          m_ui.editSetupChannelAction->setEnabled(bHasChannel);
-Line 1789 
 void MainForm::stabilizeForm (void)
+Line 2128 
 void MainForm::stabilizeForm (void)
          m_ui.editEditChannelAction->setEnabled(false);
  #endif
          m_ui.editResetChannelAction->setEnabled(bHasChannel);
-         m_ui.editResetAllChannelsAction->setEnabled(bHasChannel);
+         m_ui.editResetAllChannelsAction->setEnabled(bHasChannels);
          m_ui.viewMessagesAction->setChecked(m_pMessages && m_pMessages->isVisible());
  #ifdef CONFIG_MIDI_INSTRUMENT
          m_ui.viewInstrumentsAction->setChecked(m_pInstrumentListForm
-Line 1801 
 void MainForm::stabilizeForm (void)
+Line 2140 
 void MainForm::stabilizeForm (void)
          m_ui.viewDevicesAction->setChecked(m_pDeviceForm
                  && m_pDeviceForm->isVisible());
          m_ui.viewDevicesAction->setEnabled(bHasClient);
-         m_ui.channelsArrangeAction->setEnabled(bHasChannel);
+         m_ui.viewMidiDeviceStatusMenu->setEnabled(
+                 DeviceStatusForm::getInstances().size() > 0);
+         m_ui.channelsArrangeAction->setEnabled(bHasChannels);
  #ifdef CONFIG_VOLUME
          // Toolbar widgets are also affected...
-Line 1851 
 void MainForm::volumeChanged ( int iVolu
+Line 2192 
 void MainForm::volumeChanged ( int iVolu
                  m_pVolumeSpinBox->setValue(iVolume);
          // Do it as commanded...
-         float fVolume = 0.01f * float(iVolume);
+         const float fVolume = 0.01f * float(iVolume);
          if (::lscp_set_volume(m_pClient, fVolume) == LSCP_OK)
                  appendMessages(QObject::tr("Volume: %1.").arg(fVolume));
          else
-Line 1867 
 void MainForm::volumeChanged ( int iVolu
+Line 2208 
 void MainForm::volumeChanged ( int iVolu
  // Channel change receiver slot.
- void MainForm::channelStripChanged(ChannelStrip* pChannelStrip)
+ void MainForm::channelStripChanged ( ChannelStrip *pChannelStrip )
  {
          // Add this strip to the changed list...
          if (!m_changedStrips.contains(pChannelStrip)) {
-Line 1886 
 void MainForm::channelStripChanged(Chann
+Line 2227 
 void MainForm::channelStripChanged(Chann
  void MainForm::updateSession (void)
  {
  #ifdef CONFIG_VOLUME
-         int iVolume = ::lroundf(100.0f * ::lscp_get_volume(m_pClient));
+         const int iVolume = ::lroundf(100.0f * ::lscp_get_volume(m_pClient));
          m_iVolumeChanging++;
          m_pVolumeSlider->setValue(iVolume);
          m_pVolumeSpinBox->setValue(iVolume);
-Line 1894 
 void MainForm::updateSession (void)
+Line 2235 
 void MainForm::updateSession (void)
  #endif
  #ifdef CONFIG_MIDI_INSTRUMENT
          // FIXME: Make some room for default instrument maps...
-         int iMaps = ::lscp_get_midi_instrument_maps(m_pClient);
+         const int iMaps = ::lscp_get_midi_instrument_maps(m_pClient);
          if (iMaps < 0)
                  appendMessagesClient("lscp_get_midi_instrument_maps");
          else if (iMaps < 1) {
-Line 1905 
 void MainForm::updateSession (void)
+Line 2246 
 void MainForm::updateSession (void)
          }
  #endif
+         updateAllChannelStrips(false);
+         // Do we auto-arrange?
+         channelsArrangeAuto();
+         // Remember to refresh devices and instruments...
+         if (m_pInstrumentListForm)
+                 m_pInstrumentListForm->refreshInstruments();
+         if (m_pDeviceForm)
+                 m_pDeviceForm->refreshDevices();
+ }
+ void MainForm::updateAllChannelStrips ( bool bRemoveDeadStrips )
+ {
+         // Skip if setting up a new channel strip...
+         if (m_iDirtySetup > 0)
+                 return;
          // Retrieve the current channel list.
          int *piChannelIDs = ::lscp_list_channels(m_pClient);
-         if (piChannelIDs == NULL) {
+         if (piChannelIDs == nullptr) {
                  if (::lscp_client_get_errno(m_pClient)) {
                          appendMessagesClient("lscp_list_channels");
                          appendMessagesError(
-Line 1916 
 void MainForm::updateSession (void)
+Line 2276 
 void MainForm::updateSession (void)
          } else {
                  // Try to (re)create each channel.
                  m_pWorkspace->setUpdatesEnabled(false);
-                 for (int iChannel = 0; piChannelIDs[iChannel] >= 0; iChannel++) {
+                 for (int iChannel = 0; piChannelIDs[iChannel] >= 0; ++iChannel) {
                          // Check if theres already a channel strip for this one...
                          if (!channelStrip(piChannelIDs[iChannel]))
-                                 createChannelStrip(new qsamplerChannel(piChannelIDs[iChannel]));
+                                 createChannelStrip(new Channel(piChannelIDs[iChannel]));
+                 }
+                 // Do we auto-arrange?
+                 channelsArrangeAuto();
+                 // remove dead channel strips
+                 if (bRemoveDeadStrips) {
+                         const QList<QMdiSubWindow *>& wlist
+                                 = m_pWorkspace->subWindowList();
+                         foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
+                                 ChannelStrip *pChannelStrip
+                                         = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
+                                 if (pChannelStrip) {
+                                         bool bExists = false;
+                                         for (int iChannel = 0; piChannelIDs[iChannel] >= 0; ++iChannel) {
+                                                 Channel *pChannel = pChannelStrip->channel();
+                                                 if (pChannel == nullptr)
+                                                         break;
+                                                 if (piChannelIDs[iChannel] == pChannel->channelID()) {
+                                                         // strip exists, don't touch it
+                                                         bExists = true;
+                                                         break;
+                                                 }
+                                         }
+                                         if (!bExists)
+                                                 destroyChannelStrip(pChannelStrip);
+                                 }
+                         }
                  }
                  m_pWorkspace->setUpdatesEnabled(true);
          }
-         // Do we auto-arrange?
+         stabilizeForm();
-         if (m_pOptions && m_pOptions->bAutoArrange)
-                 channelsArrange();
-         // Remember to refresh devices and instruments...
-         if (m_pInstrumentListForm)
-                 m_pInstrumentListForm->refreshInstruments();
-         if (m_pDeviceForm)
-                 m_pDeviceForm->refreshDevices();
  }
  // Update the recent files list and menu.
  void MainForm::updateRecentFiles ( const QString& sFilename )
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          // Remove from list if already there (avoid duplicates)
-         int iIndex = m_pOptions->recentFiles.indexOf(sFilename);
+         const int iIndex = m_pOptions->recentFiles.indexOf(sFilename);
          if (iIndex >= 0)
                  m_pOptions->recentFiles.removeAt(iIndex);
          // Put it to front...
-Line 1954 
 void MainForm::updateRecentFiles ( const
+Line 2332 
 void MainForm::updateRecentFiles ( const
  // Update the recent files list and menu.
  void MainForm::updateRecentFilesMenu (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          // Time to keep the list under limits.
-Line 1982 
 void MainForm::updateRecentFilesMenu (vo
+Line 2360 
 void MainForm::updateRecentFilesMenu (vo
  void MainForm::updateInstrumentNames (void)
  {
          // Full channel list update...
-         QWidgetList wlist = m_pWorkspace->windowList();
+         const QList<QMdiSubWindow *>& wlist
+                 = m_pWorkspace->subWindowList();
          if (wlist.isEmpty())
                  return;
          m_pWorkspace->setUpdatesEnabled(false);
-         for (int iChannel = 0; iChannel < (int) wlist.count(); iChannel++) {
+         foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
-                 ChannelStrip *pChannelStrip = (ChannelStrip *) wlist.at(iChannel);
+                 ChannelStrip *pChannelStrip
+                         = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
                  if (pChannelStrip)
                          pChannelStrip->updateInstrumentName(true);
          }
-Line 1999 
 void MainForm::updateInstrumentNames (vo
+Line 2379 
 void MainForm::updateInstrumentNames (vo
  // Force update of the channels display font.
  void MainForm::updateDisplayFont (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          // Check if display font is legal.
          if (m_pOptions->sDisplayFont.isEmpty())
                  return;
          // Realize it.
          QFont font;
          if (!font.fromString(m_pOptions->sDisplayFont))
                  return;
          // Full channel list update...
-         QWidgetList wlist = m_pWorkspace->windowList();
+         const QList<QMdiSubWindow *>& wlist
+                 = m_pWorkspace->subWindowList();
          if (wlist.isEmpty())
                  return;
          m_pWorkspace->setUpdatesEnabled(false);
-         for (int iChannel = 0; iChannel < (int) wlist.count(); iChannel++) {
+         foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
-                 ChannelStrip* pChannelStrip = (ChannelStrip*) wlist.at(iChannel);
+                 ChannelStrip *pChannelStrip
+                         = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
                  if (pChannelStrip)
                          pChannelStrip->setDisplayFont(font);
          }
-Line 2029 
 void MainForm::updateDisplayFont (void)
+Line 2412 
 void MainForm::updateDisplayFont (void)
  void MainForm::updateDisplayEffect (void)
  {
          // Full channel list update...
-         QWidgetList wlist = m_pWorkspace->windowList();
+         const QList<QMdiSubWindow *>& wlist
+                 = m_pWorkspace->subWindowList();
          if (wlist.isEmpty())
                  return;
          m_pWorkspace->setUpdatesEnabled(false);
-         for (int iChannel = 0; iChannel < (int) wlist.count(); iChannel++) {
+         foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
-                 ChannelStrip* pChannelStrip = (ChannelStrip*) wlist.at(iChannel);
+                 ChannelStrip *pChannelStrip
+                         = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
                  if (pChannelStrip)
                          pChannelStrip->setDisplayEffect(m_pOptions->bDisplayEffect);
          }
-Line 2046 
 void MainForm::updateDisplayEffect (void
+Line 2431 
 void MainForm::updateDisplayEffect (void
  // Force update of the channels maximum volume setting.
  void MainForm::updateMaxVolume (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
  #ifdef CONFIG_VOLUME
-Line 2057 
 void MainForm::updateMaxVolume (void)
+Line 2442 
 void MainForm::updateMaxVolume (void)
  #endif
          // Full channel list update...
-         QWidgetList wlist = m_pWorkspace->windowList();
+         const QList<QMdiSubWindow *>& wlist
+                 = m_pWorkspace->subWindowList();
          if (wlist.isEmpty())
                  return;
          m_pWorkspace->setUpdatesEnabled(false);
-         for (int iChannel = 0; iChannel < (int) wlist.count(); iChannel++) {
+         foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
-                 ChannelStrip* pChannelStrip = (ChannelStrip*) wlist.at(iChannel);
+                 ChannelStrip *pChannelStrip
+                         = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
                  if (pChannelStrip)
                          pChannelStrip->setMaxVolume(m_pOptions->iMaxVolume);
          }
-Line 2072 
 void MainForm::updateMaxVolume (void)
+Line 2459 
 void MainForm::updateMaxVolume (void)
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- Messages window form handlers.
+ // QSampler::MainForm -- Messages window form handlers.
  // Messages output methods.
  void MainForm::appendMessages( const QString& s )
-Line 2097 
 void MainForm::appendMessagesText( const
+Line 2484 
 void MainForm::appendMessagesText( const
                  m_pMessages->appendMessagesText(s);
  }
- void MainForm::appendMessagesError( const QString& s )
+ void MainForm::appendMessagesError( const QString& sText )
  {
          if (m_pMessages)
                  m_pMessages->show();
-         appendMessagesColor(s.simplified(), "#ff0000");
+         appendMessagesColor(sText.simplified(), "#ff0000");
          // Make it look responsive...:)
          QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
-         QMessageBox::critical(this,
+         if (m_pOptions && m_pOptions->bConfirmError) {
-                 QSAMPLER_TITLE ": " + tr("Error"), s, tr("Cancel"));
+                 const QString& sTitle = tr("Error");
+         #if 0
+                 QMessageBox::critical(this, sTitle, sText, QMessageBox::Cancel);
+         #else
+                 QMessageBox mbox(this);
+                 mbox.setIcon(QMessageBox::Critical);
+                 mbox.setWindowTitle(sTitle);
+                 mbox.setText(sText);
+                 mbox.setStandardButtons(QMessageBox::Cancel);
+                 QCheckBox cbox(tr("Don't show this again"));
+                 cbox.setChecked(false);
+                 cbox.blockSignals(true);
+                 mbox.addButton(&cbox, QMessageBox::ActionRole);
+                 if (mbox.exec() && cbox.isChecked())
+                         m_pOptions->bConfirmError = false;
+         #endif
+         }
  }
  // This is a special message format, just for client results.
  void MainForm::appendMessagesClient( const QString& s )
  {
-         if (m_pClient == NULL)
+         if (m_pClient == nullptr)
                  return;
          appendMessagesColor(s + QString(": %1 (errno=%2)")
-Line 2130 
 void MainForm::appendMessagesClient( con
+Line 2533 
 void MainForm::appendMessagesClient( con
  // Force update of the messages font.
  void MainForm::updateMessagesFont (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          if (m_pMessages && !m_pOptions->sMessagesFont.isEmpty()) {
-Line 2144 
 void MainForm::updateMessagesFont (void)
+Line 2547 
 void MainForm::updateMessagesFont (void)
  // Update messages window line limit.
  void MainForm::updateMessagesLimit (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          if (m_pMessages) {
-Line 2159 
 void MainForm::updateMessagesLimit (void
+Line 2562 
 void MainForm::updateMessagesLimit (void
  // Enablement of the messages capture feature.
  void MainForm::updateMessagesCapture (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          if (m_pMessages)
-Line 2168 
 void MainForm::updateMessagesCapture (vo
+Line 2571 
 void MainForm::updateMessagesCapture (vo
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- MDI channel strip management.
+ // QSampler::MainForm -- MDI channel strip management.
  // The channel strip creation executive.
- ChannelStrip* MainForm::createChannelStrip(qsamplerChannel* pChannel)
+ ChannelStrip *MainForm::createChannelStrip ( Channel *pChannel )
  {
-         if (m_pClient == NULL || pChannel == NULL)
+         if (m_pClient == nullptr || pChannel == nullptr)
-                 return NULL;
+                 return nullptr;
-         // Prepare for auto-arrange?
-         ChannelStrip* pChannelStrip = NULL;
-         int y = 0;
-         if (m_pOptions && m_pOptions->bAutoArrange) {
-                 QWidgetList wlist = m_pWorkspace->windowList();
-                 for (int iChannel = 0; iChannel < (int) wlist.count(); iChannel++) {
-                         pChannelStrip = static_cast<ChannelStrip *> (wlist.at(iChannel));
-                         if (pChannelStrip) {
-                         //  y += pChannelStrip->height()
-                         //              + pChannelStrip->parentWidget()->baseSize().height();
-                                 y += pChannelStrip->parentWidget()->frameGeometry().height();
-                         }
-                 }
-         }
          // Add a new channel itema...
-         pChannelStrip = new ChannelStrip();
+         ChannelStrip *pChannelStrip = new ChannelStrip();
-         if (pChannelStrip == NULL)
+         if (pChannelStrip == nullptr)
-                 return NULL;
+                 return nullptr;
-         m_pWorkspace->addWindow(pChannelStrip, Qt::FramelessWindowHint);
-         // Actual channel strip setup...
+         // Set some initial channel strip options...
-         pChannelStrip->setup(pChannel);
-         QObject::connect(pChannelStrip,
-                 SIGNAL(channelChanged(ChannelStrip*)),
-                 SLOT(channelStripChanged(ChannelStrip*)));
-         // Set some initial aesthetic options...
          if (m_pOptions) {
                  // Background display effect...
                  pChannelStrip->setDisplayEffect(m_pOptions->bDisplayEffect);
                  // We'll need a display font.
                  QFont font;
-                 if (font.fromString(m_pOptions->sDisplayFont))
+                 if (!m_pOptions->sDisplayFont.isEmpty() &&
+                         font.fromString(m_pOptions->sDisplayFont))
                          pChannelStrip->setDisplayFont(font);
                  // Maximum allowed volume setting.
                  pChannelStrip->setMaxVolume(m_pOptions->iMaxVolume);
          }
+         // Add it to workspace...
+         QMdiSubWindow *pMdiSubWindow
+                 = m_pWorkspace->addSubWindow(pChannelStrip,
+                         Qt::SubWindow | Qt::FramelessWindowHint);
+         pMdiSubWindow->setAttribute(Qt::WA_DeleteOnClose);
+         // Actual channel strip setup...
+         pChannelStrip->setup(pChannel);
+         QObject::connect(pChannelStrip,
+                 SIGNAL(channelChanged(ChannelStrip *)),
+                 SLOT(channelStripChanged(ChannelStrip *)));
          // Now we show up us to the world.
          pChannelStrip->show();
-         // Only then, we'll auto-arrange...
-         if (m_pOptions && m_pOptions->bAutoArrange) {
-                 int iWidth  = m_pWorkspace->width();
-         //  int iHeight = pChannel->height()
-         //              + pChannel->parentWidget()->baseSize().height();
-                 int iHeight = pChannelStrip->parentWidget()->frameGeometry().height();
-                 pChannelStrip->parentWidget()->setGeometry(0, y, iWidth, iHeight);
-         }
          // This is pretty new, so we'll watch for it closely.
          channelStripChanged(pChannelStrip);
-Line 2234 
 ChannelStrip* MainForm::createChannelStr
+Line 2621 
 ChannelStrip* MainForm::createChannelStr
  }
+ void MainForm::destroyChannelStrip ( ChannelStrip *pChannelStrip )
+ {
+         QMdiSubWindow *pMdiSubWindow
+                 = static_cast<QMdiSubWindow *> (pChannelStrip->parentWidget());
+         if (pMdiSubWindow == nullptr)
+                 return;
+         // Just delete the channel strip.
+         delete pChannelStrip;
+         delete pMdiSubWindow;
+         // Do we auto-arrange?
+         channelsArrangeAuto();
+ }
  // Retrieve the active channel strip.
- ChannelStrip* MainForm::activeChannelStrip (void)
+ ChannelStrip *MainForm::activeChannelStrip (void)
  {
-         return static_cast<ChannelStrip *> (m_pWorkspace->activeWindow());
+         QMdiSubWindow *pMdiSubWindow = m_pWorkspace->activeSubWindow();
+         if (pMdiSubWindow)
+                 return static_cast<ChannelStrip *> (pMdiSubWindow->widget());
+         else
+                 return nullptr;
  }
  // Retrieve a channel strip by index.
- ChannelStrip* MainForm::channelStripAt ( int iChannel )
+ ChannelStrip *MainForm::channelStripAt ( int iStrip )
  {
-         QWidgetList wlist = m_pWorkspace->windowList();
+         if (!m_pWorkspace) return nullptr;
+         const QList<QMdiSubWindow *>& wlist
+                 = m_pWorkspace->subWindowList();
          if (wlist.isEmpty())
-                 return NULL;
+                 return nullptr;
+         if (iStrip < 0 || iStrip >= wlist.count())
+                 return nullptr;
-         return static_cast<ChannelStrip *> (wlist.at(iChannel));
+         QMdiSubWindow *pMdiSubWindow = wlist.at(iStrip);
+         if (pMdiSubWindow)
+                 return static_cast<ChannelStrip *> (pMdiSubWindow->widget());
+         else
+                 return nullptr;
  }
  // Retrieve a channel strip by sampler channel id.
- ChannelStrip* MainForm::channelStrip ( int iChannelID )
+ ChannelStrip *MainForm::channelStrip ( int iChannelID )
  {
-         QWidgetList wlist = m_pWorkspace->windowList();
+         const QList<QMdiSubWindow *>& wlist
+                 = m_pWorkspace->subWindowList();
          if (wlist.isEmpty())
-                 return NULL;
+                 return nullptr;
-         for (int iChannel = 0; iChannel < (int) wlist.count(); iChannel++) {
+         foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
-                 ChannelStrip* pChannelStrip
+                 ChannelStrip *pChannelStrip
-                         = static_cast<ChannelStrip*> (wlist.at(iChannel));
+                         = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
                  if (pChannelStrip) {
-                         qsamplerChannel *pChannel = pChannelStrip->channel();
+                         Channel *pChannel = pChannelStrip->channel();
                          if (pChannel && pChannel->channelID() == iChannelID)
                                  return pChannelStrip;
                  }
          }
          // Not found.
-         return NULL;
+         return nullptr;
  }
-Line 2281 
 void MainForm::channelsMenuAboutToShow (
+Line 2699 
 void MainForm::channelsMenuAboutToShow (
          m_ui.channelsMenu->addAction(m_ui.channelsArrangeAction);
          m_ui.channelsMenu->addAction(m_ui.channelsAutoArrangeAction);
-         QWidgetList wlist = m_pWorkspace->windowList();
+         const QList<QMdiSubWindow *>& wlist
+                 = m_pWorkspace->subWindowList();
          if (!wlist.isEmpty()) {
                  m_ui.channelsMenu->addSeparator();
-                 for (int iChannel = 0; iChannel < (int) wlist.count(); iChannel++) {
+                 int iStrip = 0;
-                         ChannelStrip* pChannelStrip
+                 foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
-                                 = static_cast<ChannelStrip*> (wlist.at(iChannel));
+                         ChannelStrip *pChannelStrip
+                                 = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
                          if (pChannelStrip) {
                                  QAction *pAction = m_ui.channelsMenu->addAction(
                                          pChannelStrip->windowTitle(),
                                          this, SLOT(channelsMenuActivated()));
                                  pAction->setCheckable(true);
                                  pAction->setChecked(activeChannelStrip() == pChannelStrip);
-                                 pAction->setData(iChannel);
+                                 pAction->setData(iStrip);
                          }
+                         ++iStrip;
                  }
          }
  }
-Line 2305 
 void MainForm::channelsMenuActivated (vo
+Line 2726 
 void MainForm::channelsMenuActivated (vo
  {
          // Retrive channel index from action data...
          QAction *pAction = qobject_cast<QAction *> (sender());
-         if (pAction == NULL)
+         if (pAction == nullptr)
                  return;
-         ChannelStrip* pChannelStrip = channelStripAt(pAction->data().toInt());
+         ChannelStrip *pChannelStrip = channelStripAt(pAction->data().toInt());
          if (pChannelStrip) {
                  pChannelStrip->showNormal();
                  pChannelStrip->setFocus();
-Line 2317 
 void MainForm::channelsMenuActivated (vo
+Line 2738 
 void MainForm::channelsMenuActivated (vo
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- Timer stuff.
+ // QSampler::MainForm -- Timer stuff.
  // Set the pseudo-timer delay schedule.
  void MainForm::startSchedule ( int iStartDelay )
-Line 2336 
 void MainForm::stopSchedule (void)
+Line 2757 
 void MainForm::stopSchedule (void)
  // Timer slot funtion.
  void MainForm::timerSlot (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          // Is it the first shot on server start after a few delay?
-Line 2358 
 void MainForm::timerSlot (void)
+Line 2779 
 void MainForm::timerSlot (void)
                          ChannelStrip *pChannelStrip = iter.next();
                          // If successfull, remove from pending list...
                          if (pChannelStrip->updateChannelInfo()) {
-                                 int iChannelStrip = m_changedStrips.indexOf(pChannelStrip);
+                                 const int iChannelStrip = m_changedStrips.indexOf(pChannelStrip);
                                  if (iChannelStrip >= 0)
                                          m_changedStrips.removeAt(iChannelStrip);
                          }
-Line 2369 
 void MainForm::timerSlot (void)
+Line 2790 
 void MainForm::timerSlot (void)
                          if (m_iTimerSlot >= m_pOptions->iAutoRefreshTime)  {
                                  m_iTimerSlot = 0;
                                  // Update the channel stream usage for each strip...
-                                 QWidgetList wlist = m_pWorkspace->windowList();
+                                 const QList<QMdiSubWindow *>& wlist
-                                 for (int iChannel = 0;
+                                         = m_pWorkspace->subWindowList();
-                                                 iChannel < (int) wlist.count(); iChannel++) {
+                                 foreach (QMdiSubWindow *pMdiSubWindow, wlist) {
-                                         ChannelStrip* pChannelStrip
+                                         ChannelStrip *pChannelStrip
-                                                 = (ChannelStrip*) wlist.at(iChannel);
+                                                 = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
                                          if (pChannelStrip && pChannelStrip->isVisible())
                                                  pChannelStrip->updateChannelUsage();
                                  }
                          }
                  }
+         #if CONFIG_LSCP_CLIENT_CONNECTION_LOST
+                 // If we lost connection to server: Try to automatically reconnect if we
+                 // did not start the server.
+                 //
+                 // TODO: If we started the server, then we might inform the user that
+                 // the server probably crashed and asking user ONCE whether we should
+                 // restart the server.
+                 if (lscp_client_connection_lost(m_pClient) && !m_pServer)
+                         startAutoReconnectClient();
+         #endif // CONFIG_LSCP_CLIENT_CONNECTION_LOST
          }
          // Register the next timer slot.
-Line 2387 
 void MainForm::timerSlot (void)
+Line 2819 
 void MainForm::timerSlot (void)
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- Server stuff.
+ // QSampler::MainForm -- Server stuff.
  // Start linuxsampler server...
  void MainForm::startServer (void)
  {
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return;
          // Aren't already a client, are we?
-Line 2401 
 void MainForm::startServer (void)
+Line 2833 
 void MainForm::startServer (void)
          // Is the server process instance still here?
          if (m_pServer) {
-                 switch (QMessageBox::warning(this,
+                 if (QMessageBox::warning(this,
-                         QSAMPLER_TITLE ": " + tr("Warning"),
+                         tr("Warning"),
                          tr("Could not start the LinuxSampler server.\n\n"
-                         "Maybe it ss already started."),
+                         "Maybe it is already started."),
-                         tr("Stop"), tr("Kill"), tr("Cancel"))) {
+                         QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok) {
-                 case 0:
                          m_pServer->terminate();
-                         break;
-                 case 1:
                          m_pServer->kill();
-                         break;
                  }
                  return;
          }
-Line 2424 
 void MainForm::startServer (void)
+Line 2852 
 void MainForm::startServer (void)
                  return;
          // OK. Let's build the startup process...
-         m_pServer = new QProcess(this);
+         m_pServer = new QProcess();
+         m_bForceServerStop = true;
          // Setup stdout/stderr capture...
- //      if (m_pOptions->bStdoutCapture) {
+         m_pServer->setProcessChannelMode(QProcess::ForwardedChannels);
-                 //m_pServer->setProcessChannelMode(
+         QObject::connect(m_pServer,
-                 //      QProcess::StandardOutput);
+                 SIGNAL(readyReadStandardOutput()),
-                 QObject::connect(m_pServer,
+                 SLOT(readServerStdout()));
-                         SIGNAL(readyReadStandardOutput()),
+         QObject::connect(m_pServer,
-                         SLOT(readServerStdout()));
+                 SIGNAL(readyReadStandardError()),
-                 QObject::connect(m_pServer,
+                 SLOT(readServerStdout()));
-                         SIGNAL(readyReadStandardError()),
-                         SLOT(readServerStdout()));
- //      }
          // The unforgiveable signal communication...
          QObject::connect(m_pServer,
-                 SIGNAL(finished(int,QProcess::ExitStatus)),
+                 SIGNAL(finished(int, QProcess::ExitStatus)),
                  SLOT(processServerExit()));
          // Build process arguments...
-Line 2471 
 void MainForm::startServer (void)
+Line 2897 
 void MainForm::startServer (void)
  // Stop linuxsampler server...
- void MainForm::stopServer (void)
+ void MainForm::stopServer ( bool bInteractive )
  {
          // Stop client code.
          stopClient();
+         if (m_pServer && bInteractive) {
+                 if (QMessageBox::question(this,
+                         tr("The backend's fate ..."),
+                         tr("You have the option to keep the sampler backend (LinuxSampler)\n"
+                         "running in the background. The sampler would continue to work\n"
+                         "according to your current sampler session and you could alter the\n"
+                         "sampler session at any time by relaunching QSampler.\n\n"
+                         "Do you want LinuxSampler to stop?"),
+                         QMessageBox::Yes | QMessageBox::No,
+                         QMessageBox::Yes) == QMessageBox::No) {
+                         m_bForceServerStop = false;
+                 }
+         }
+         bool bGraceWait = true;
          // And try to stop server.
-         if (m_pServer) {
+         if (m_pServer && m_bForceServerStop) {
                  appendMessages(tr("Server is stopping..."));
-                 if (m_pServer->state() == QProcess::Running)
+                 if (m_pServer->state() == QProcess::Running) {
+                 #if defined(__WIN32__) || defined(_WIN32) || defined(WIN32)
+                         // Try harder...
+                         m_pServer->kill();
+                 #else
+                         // Try softly...
                          m_pServer->terminate();
-         }
+                         bool bFinished = m_pServer->waitForFinished(QSAMPLER_TIMER_MSECS * 1000);
+                         if (bFinished) bGraceWait = false;
+                 #endif
+                 }
+         }       // Do final processing anyway.
+         else processServerExit();
          // Give it some time to terminate gracefully and stabilize...
-         QTime t;
+         if (bGraceWait) {
-         t.start();
+                 QElapsedTimer timer;
-         while (t.elapsed() < QSAMPLER_TIMER_MSECS)
+                 timer.start();
-                 QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
+                 while (timer.elapsed() < QSAMPLER_TIMER_MSECS)
+                         QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
-         // Do final processing anyway.
+         }
-         processServerExit();
  }
-Line 2512 
 void MainForm::processServerExit (void)
+Line 2963 
 void MainForm::processServerExit (void)
          if (m_pMessages)
                  m_pMessages->flushStdoutBuffer();
-         if (m_pServer) {
+         if (m_pServer && m_bForceServerStop) {
+                 if (m_pServer->state() != QProcess::NotRunning) {
+                         appendMessages(tr("Server is being forced..."));
+                         // Force final server shutdown...
+                         m_pServer->kill();
+                         // Give it some time to terminate gracefully and stabilize...
+                         QElapsedTimer timer;
+                         timer.start();
+                         while (timer.elapsed() < QSAMPLER_TIMER_MSECS)
+                                 QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
+                 }
                  // Force final server shutdown...
                  appendMessages(
                          tr("Server was stopped with exit status %1.")
                          .arg(m_pServer->exitStatus()));
-                 m_pServer->terminate();
-                 if (!m_pServer->waitForFinished(2000))
-                         m_pServer->kill();
-                 // Destroy it.
                  delete m_pServer;
-                 m_pServer = NULL;
+                 m_pServer = nullptr;
          }
          // Again, make status visible stable.
-Line 2531 
 void MainForm::processServerExit (void)
+Line 2988 
 void MainForm::processServerExit (void)
  //-------------------------------------------------------------------------
- // qsamplerMainForm -- Client stuff.
+ // QSampler::MainForm -- Client stuff.
  // The LSCP client callback procedure.
  lscp_status_t qsampler_client_callback ( lscp_client_t */*pClient*/,
          lscp_event_t event, const char *pchData, int cchData, void *pvData )
  {
          MainForm* pMainForm = (MainForm *) pvData;
-         if (pMainForm == NULL)
+         if (pMainForm == nullptr)
                  return LSCP_FAILED;
          // ATTN: DO NOT EVER call any GUI code here,
          // as this is run under some other thread context.
          // A custom event must be posted here...
          QApplication::postEvent(pMainForm,
-                 new qsamplerCustomEvent(event, pchData, cchData));
+                 new LscpEvent(event, pchData, cchData));
          return LSCP_OK;
  }
  // Start our almighty client...
- bool MainForm::startClient (void)
+ bool MainForm::startClient (bool bReconnectOnly)
  {
          // Have it a setup?
-         if (m_pOptions == NULL)
+         if (m_pOptions == nullptr)
                  return false;
          // Aren't we already started, are we?
-Line 2569 
 bool MainForm::startClient (void)
+Line 3026 
 bool MainForm::startClient (void)
          m_pClient = ::lscp_client_create(
                  m_pOptions->sServerHost.toUtf8().constData(),
                  m_pOptions->iServerPort, qsampler_client_callback, this);
-         if (m_pClient == NULL) {
+         if (m_pClient == nullptr) {
                  // Is this the first try?
                  // maybe we need to start a local server...
                  if ((m_pServer && m_pServer->state() == QProcess::Running)
-                         || !m_pOptions->bServerStart) {
+                         || !m_pOptions->bServerStart || bReconnectOnly)
-                         appendMessagesError(
+                 {
-                                 tr("Could not connect to server as client.\n\nSorry."));
+                         // if this method is called from autoReconnectClient()
+                         // then don't bother user with an error message...
+                         if (!bReconnectOnly) {
+                                 appendMessagesError(
+                                         tr("Could not connect to server as client.\n\nSorry.")
+                                 );
+                         }
                  } else {
                          startServer();
                  }
-Line 2583 
 bool MainForm::startClient (void)
+Line 3046 
 bool MainForm::startClient (void)
                  stabilizeForm();
                  return false;
          }
          // Just set receive timeout value, blindly.
          ::lscp_client_set_timeout(m_pClient, m_pOptions->iServerTimeout);
          appendMessages(
-Line 2590 
 bool MainForm::startClient (void)
+Line 3054 
 bool MainForm::startClient (void)
                  .arg(::lscp_client_get_timeout(m_pClient)));
          // Subscribe to channel info change notifications...
+         if (::lscp_client_subscribe(m_pClient, LSCP_EVENT_CHANNEL_COUNT) != LSCP_OK)
+                 appendMessagesClient("lscp_client_subscribe(CHANNEL_COUNT)");
          if (::lscp_client_subscribe(m_pClient, LSCP_EVENT_CHANNEL_INFO) != LSCP_OK)
-                 appendMessagesClient("lscp_client_subscribe");
+                 appendMessagesClient("lscp_client_subscribe(CHANNEL_INFO)");
+         DeviceStatusForm::onDevicesChanged(); // initialize
+         updateViewMidiDeviceStatusMenu();
+         if (::lscp_client_subscribe(m_pClient, LSCP_EVENT_MIDI_INPUT_DEVICE_COUNT) != LSCP_OK)
+                 appendMessagesClient("lscp_client_subscribe(MIDI_INPUT_DEVICE_COUNT)");
+         if (::lscp_client_subscribe(m_pClient, LSCP_EVENT_MIDI_INPUT_DEVICE_INFO) != LSCP_OK)
+                 appendMessagesClient("lscp_client_subscribe(MIDI_INPUT_DEVICE_INFO)");
+         if (::lscp_client_subscribe(m_pClient, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_COUNT) != LSCP_OK)
+                 appendMessagesClient("lscp_client_subscribe(AUDIO_OUTPUT_DEVICE_COUNT)");
+         if (::lscp_client_subscribe(m_pClient, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_INFO) != LSCP_OK)
+                 appendMessagesClient("lscp_client_subscribe(AUDIO_OUTPUT_DEVICE_INFO)");
+ #if CONFIG_EVENT_CHANNEL_MIDI
+         // Subscribe to channel MIDI data notifications...
+         if (::lscp_client_subscribe(m_pClient, LSCP_EVENT_CHANNEL_MIDI) != LSCP_OK)
+                 appendMessagesClient("lscp_client_subscribe(CHANNEL_MIDI)");
+ #endif
+ #if CONFIG_EVENT_DEVICE_MIDI
+         // Subscribe to channel MIDI data notifications...
+         if (::lscp_client_subscribe(m_pClient, LSCP_EVENT_DEVICE_MIDI) != LSCP_OK)
+                 appendMessagesClient("lscp_client_subscribe(DEVICE_MIDI)");
+ #endif
          // We may stop scheduling around.
          stopSchedule();
-Line 2613 
 bool MainForm::startClient (void)
+Line 3102 
 bool MainForm::startClient (void)
          if (!m_pOptions->sSessionFile.isEmpty()) {
                  // Just load the prabably startup session...
                  if (loadSessionFile(m_pOptions->sSessionFile)) {
-                         m_pOptions->sSessionFile = QString::null;
+                         m_pOptions->sSessionFile = QString();
                          return true;
                  }
          }
+         // send the current / loaded fine tuning settings to the sampler
+         m_pOptions->sendFineTuningSettings();
          // Make a new session
          return newSession();
  }
-Line 2626 
 bool MainForm::startClient (void)
+Line 3118 
 bool MainForm::startClient (void)
  // Stop client...
  void MainForm::stopClient (void)
  {
-         if (m_pClient == NULL)
+         if (m_pClient == nullptr)
                  return;
          // Log prepare here.
-Line 2645 
 void MainForm::stopClient (void)
+Line 3137 
 void MainForm::stopClient (void)
          closeSession(false);
          // Close us as a client...
+ #if CONFIG_EVENT_DEVICE_MIDI
+         ::lscp_client_unsubscribe(m_pClient, LSCP_EVENT_DEVICE_MIDI);
+ #endif
+ #if CONFIG_EVENT_CHANNEL_MIDI
+         ::lscp_client_unsubscribe(m_pClient, LSCP_EVENT_CHANNEL_MIDI);
+ #endif
+         ::lscp_client_unsubscribe(m_pClient, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_INFO);
+         ::lscp_client_unsubscribe(m_pClient, LSCP_EVENT_AUDIO_OUTPUT_DEVICE_COUNT);
+         ::lscp_client_unsubscribe(m_pClient, LSCP_EVENT_MIDI_INPUT_DEVICE_INFO);
+         ::lscp_client_unsubscribe(m_pClient, LSCP_EVENT_MIDI_INPUT_DEVICE_COUNT);
          ::lscp_client_unsubscribe(m_pClient, LSCP_EVENT_CHANNEL_INFO);
+         ::lscp_client_unsubscribe(m_pClient, LSCP_EVENT_CHANNEL_COUNT);
          ::lscp_client_destroy(m_pClient);
-         m_pClient = NULL;
+         m_pClient = nullptr;
          // Hard-notify instrumnet and device configuration forms,
          // if visible, that we're running out...
-Line 2664 
 void MainForm::stopClient (void)
+Line 3167 
 void MainForm::stopClient (void)
  }
+ void MainForm::startAutoReconnectClient (void)
+ {
+         stopClient();
+         appendMessages(tr("Trying to reconnect..."));
+         QTimer::singleShot(QSAMPLER_TIMER_MSECS, this, SLOT(autoReconnectClient()));
+ }
+ void MainForm::autoReconnectClient (void)
+ {
+         const bool bSuccess = startClient(true);
+         if (!bSuccess)
+                 QTimer::singleShot(QSAMPLER_TIMER_MSECS, this, SLOT(autoReconnectClient()));
+ }
  // Channel strip activation/selection.
- void MainForm::activateStrip ( QWidget *pWidget )
+ void MainForm::activateStrip ( QMdiSubWindow *pMdiSubWindow )
  {
-         ChannelStrip *pChannelStrip
+         ChannelStrip *pChannelStrip = nullptr;
-                 = static_cast<ChannelStrip *> (pWidget);
+         if (pMdiSubWindow)
+                 pChannelStrip = static_cast<ChannelStrip *> (pMdiSubWindow->widget());
          if (pChannelStrip)
                  pChannelStrip->setSelected(true);
-Line 2676 
 void MainForm::activateStrip ( QWidget *
+Line 3196 
 void MainForm::activateStrip ( QWidget *
  }
+ // Channel toolbar orientation change.
+ void MainForm::channelsToolbarOrientation ( Qt::Orientation orientation )
+ {
+ #ifdef CONFIG_VOLUME
+         m_pVolumeSlider->setOrientation(orientation);
+         if (orientation == Qt::Horizontal) {
+                 m_pVolumeSlider->setMinimumHeight(24);
+                 m_pVolumeSlider->setMaximumHeight(32);
+                 m_pVolumeSlider->setMinimumWidth(120);
+                 m_pVolumeSlider->setMaximumWidth(640);
+                 m_pVolumeSpinBox->setMaximumWidth(64);
+                 m_pVolumeSpinBox->setButtonSymbols(QSpinBox::UpDownArrows);
+         } else {
+                 m_pVolumeSlider->setMinimumHeight(120);
+                 m_pVolumeSlider->setMaximumHeight(480);
+                 m_pVolumeSlider->setMinimumWidth(24);
+                 m_pVolumeSlider->setMaximumWidth(32);
+                 m_pVolumeSpinBox->setMaximumWidth(32);
+                 m_pVolumeSpinBox->setButtonSymbols(QSpinBox::NoButtons);
+         }
+ #endif
+ }
  } // namespace QSampler

 Legend:



Removed from v.1514
 


changed lines


 
Added in v.3759
 Legend:



Removed from v.1514
 


changed lines


 
Added in v.3759
-Removed from v.1514
+Added in v.3759

	ViewVC Help
Powered by ViewVC