comparison framework/MainWindowBase.cpp @ 449:12d982e52190

Merge from branch tonioni

 #include "audioio/AudioTargetFactory.h"
 #include "audioio/PlaySpeedRangeMapper.h"
 #include "data/fileio/DataFileReaderFactory.h"
 #include "data/fileio/PlaylistFileReader.h"
 #include "data/fileio/WavFileWriter.h"
-#include "data/fileio/CSVFileWriter.h"
 #include "data/fileio/MIDIFileWriter.h"
 #include "data/fileio/BZipFileDevice.h"
 #include "data/fileio/FileSource.h"
 #include "data/fileio/AudioFileReaderFactory.h"
 #include "rdf/RDFImporter.h"

 
 #include <iostream>
 #include <cstdio>
 #include <errno.h>
 
-
-
-
 using std::vector;
 using std::map;
 using std::set;
 
 #ifdef Q_WS_X11

     m_statusLabel(0),
     m_menuShortcutMapper(0)
 {
     Profiler profiler("MainWindowBase::MainWindowBase");
 
+    qRegisterMetaType<sv_frame_t>("sv_frame_t");
+    qRegisterMetaType<sv_samplerate_t>("sv_samplerate_t");
+
 #ifdef Q_WS_X11
     XSetErrorHandler(handle_x11_error);
 #endif
 
     connect(CommandHistory::getInstance(), SIGNAL(commandExecuted()),

     connect(m_viewManager, SIGNAL(inProgressSelectionChanged()),
 	    this, SLOT(inProgressSelectionChanged()));
 
     // set a sensible default font size for views -- cannot do this
     // in Preferences, which is in base and not supposed to use QtGui
-    int viewFontSize = QApplication::font().pointSize() * 0.9;
+    int viewFontSize = int(QApplication::font().pointSize() * 0.9);
     QSettings settings;
     settings.beginGroup("Preferences");
     viewFontSize = settings.value("view-font-size", viewFontSize).toInt();
     settings.setValue("view-font-size", viewFontSize);
     settings.endGroup();

             this, SLOT(paneDeleteButtonClicked(Pane *)));
 
     m_playSource = new AudioCallbackPlaySource(m_viewManager,
                                                QApplication::applicationName());
 
-    connect(m_playSource, SIGNAL(sampleRateMismatch(int, int, bool)),
-	    this,           SLOT(sampleRateMismatch(int, int, bool)));
+    connect(m_playSource, SIGNAL(sampleRateMismatch(sv_samplerate_t, sv_samplerate_t, bool)),
+	    this,           SLOT(sampleRateMismatch(sv_samplerate_t, sv_samplerate_t, bool)));
     connect(m_playSource, SIGNAL(audioOverloadPluginDisabled()),
             this,           SLOT(audioOverloadPluginDisabled()));
     connect(m_playSource, SIGNAL(audioTimeStretchMultiChannelDisabled()),
             this,           SLOT(audioTimeStretchMultiChannelDisabled()));
 
     connect(m_viewManager, SIGNAL(outputLevelsChanged(float, float)),
 	    this, SLOT(outputLevelsChanged(float, float)));
 
-    connect(m_viewManager, SIGNAL(playbackFrameChanged(int)),
-            this, SLOT(playbackFrameChanged(int)));
-
-    connect(m_viewManager, SIGNAL(globalCentreFrameChanged(int)),
-            this, SLOT(globalCentreFrameChanged(int)));
-
-    connect(m_viewManager, SIGNAL(viewCentreFrameChanged(View *, int)),
-            this, SLOT(viewCentreFrameChanged(View *, int)));
+    connect(m_viewManager, SIGNAL(playbackFrameChanged(sv_frame_t)),
+            this, SLOT(playbackFrameChanged(sv_frame_t)));
+
+    connect(m_viewManager, SIGNAL(globalCentreFrameChanged(sv_frame_t)),
+            this, SLOT(globalCentreFrameChanged(sv_frame_t)));
+
+    connect(m_viewManager, SIGNAL(viewCentreFrameChanged(View *, sv_frame_t)),
+            this, SLOT(viewCentreFrameChanged(View *, sv_frame_t)));
 
     connect(m_viewManager, SIGNAL(viewZoomLevelChanged(View *, int, bool)),
             this, SLOT(viewZoomLevelChanged(View *, int, bool)));
 
     connect(Preferences::getInstance(),

     // i.e. that will not otherwise work. The downside is that if this
     // bug is fixed in a future Qt release, we will start getting
     // "ambiguous shortcut" errors from the menu entry actions and
     // will need to update the code.)
 
+    // Update: The bug was fixed in Qt 5.4 for shortcuts with no
+    // modifier, and I believe it is fixed in Qt 5.5 for shortcuts
+    // with Shift modifiers. The below reflects that
+
+#if (QT_VERSION < QT_VERSION_CHECK(5, 5, 0))
+
     if (!m_menuShortcutMapper) {
         m_menuShortcutMapper = new QSignalMapper(this);
         connect(m_menuShortcutMapper, SIGNAL(mapped(QObject *)),
                 this, SLOT(menuActionMapperInvoked(QObject *)));
     }

 
             // Note that the set of "single-key shortcuts" that aren't
             // working and that we need to handle here includes those
             // with the Shift modifier mask as well as those with no
             // modifier at all
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 5, 0))
+            // Nothing needed
+            if (false) {
+#elif (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
+            if (sc.count() == 1 &&
+                (sc[0] & Qt::KeyboardModifierMask) == Qt::ShiftModifier) {
+#else
             if (sc.count() == 1 &&
                 ((sc[0] & Qt::KeyboardModifierMask) == Qt::NoModifier ||
                  (sc[0] & Qt::KeyboardModifierMask) == Qt::ShiftModifier)) {
+#endif
                 QShortcut *newSc = new QShortcut(sc, a->parentWidget());
                 QObject::connect(newSc, SIGNAL(activated()),
                                  m_menuShortcutMapper, SLOT(map()));
                 m_menuShortcutMapper->setMapping(newSc, a);
                 m_appShortcuts.push_back(newSc);
             }
         }
     }
+#endif
 #endif
 }
 
 void
 MainWindowBase::menuActionMapperInvoked(QObject *o)

     // we want is the frame that was last committed to the soundcard
     // buffers, as the audio driver will continue playing up to that
     // frame before switching to whichever one we decide we want to
     // switch to, regardless of our efforts.
 
-    int frame = m_playSource->getCurrentBufferedFrame();
+    sv_frame_t frame = m_playSource->getCurrentBufferedFrame();
 
     cerr << "currentPaneChanged: current frame (in ref model) = " << frame << endl;
 
     View::ModelSet soloModels = p->getModels();
     

     if (!model) return;
 
     Pane *currentPane = m_paneStack->getCurrentPane();
     if (!currentPane) return;
 
-    int startFrame, endFrame;
+    sv_frame_t startFrame, endFrame;
 
     if (currentPane->getStartFrame() < 0) startFrame = 0;
     else startFrame = currentPane->getStartFrame();
 
     if (currentPane->getEndFrame() > model->getEndFrame()) endFrame = model->getEndFrame();

 }
 
 void
 MainWindowBase::pasteAtPlaybackPosition()
 {
-    int pos = getFrame();
+    sv_frame_t pos = getFrame();
     Clipboard &clipboard = m_viewManager->getClipboard();
     if (!clipboard.empty()) {
-        int firstEventFrame = clipboard.getPoints()[0].getFrame();
-        int offset = 0;
+        sv_frame_t firstEventFrame = clipboard.getPoints()[0].getFrame();
+        sv_frame_t offset = 0;
         if (firstEventFrame < 0) {
             offset = pos - firstEventFrame;
         } else if (firstEventFrame < pos) {
             offset = pos - firstEventFrame;
         } else {

         pasteRelative(offset);
     }
 }
 
 void
-MainWindowBase::pasteRelative(int offset)
+MainWindowBase::pasteRelative(sv_frame_t offset)
 {
     Pane *currentPane = m_paneStack->getCurrentPane();
     if (!currentPane) return;
 
     Layer *layer = currentPane->getSelectedLayer();

     }
 }
 
 // FrameTimer method
 
-int
+sv_frame_t
 MainWindowBase::getFrame() const
 {
     if (m_playSource && m_playSource->isPlaying()) {
         return m_playSource->getCurrentPlayingFrame();
     } else {

 MainWindowBase::insertInstantsAtBoundaries()
 {
     MultiSelection::SelectionList selections = m_viewManager->getSelections();
     for (MultiSelection::SelectionList::iterator i = selections.begin();
          i != selections.end(); ++i) {
-        int start = i->getStartFrame();
-        int end = i->getEndFrame();
+        sv_frame_t start = i->getStartFrame();
+        sv_frame_t end = i->getEndFrame();
         if (start != end) {
             insertInstantAt(start);
             insertInstantAt(end);
         }
     }
 }
 
 void
-MainWindowBase::insertInstantAt(int frame)
+MainWindowBase::insertInstantAt(sv_frame_t frame)
 {
     Pane *pane = m_paneStack->getCurrentPane();
     if (!pane) {
         return;
     }

 MainWindowBase::insertItemAtSelection()
 {
     MultiSelection::SelectionList selections = m_viewManager->getSelections();
     for (MultiSelection::SelectionList::iterator i = selections.begin();
          i != selections.end(); ++i) {
-        int start = i->getStartFrame();
-        int end = i->getEndFrame();
+        sv_frame_t start = i->getStartFrame();
+        sv_frame_t end = i->getEndFrame();
         if (start < end) {
             insertItemAt(start, end - start);
         }
     }
 }
 
 void
-MainWindowBase::insertItemAt(int frame, int duration)
+MainWindowBase::insertItemAt(sv_frame_t frame, sv_frame_t duration)
 {
     Pane *pane = m_paneStack->getCurrentPane();
     if (!pane) {
         return;
     }
 
     // ugh!
 
-    int alignedStart = pane->alignFromReference(frame);
-    int alignedEnd = pane->alignFromReference(frame + duration);
+    sv_frame_t alignedStart = pane->alignFromReference(frame);
+    sv_frame_t alignedEnd = pane->alignFromReference(frame + duration);
     if (alignedStart >= alignedEnd) return;
-    int alignedDuration = alignedEnd - alignedStart;
+    sv_frame_t alignedDuration = alignedEnd - alignedStart;
 
     Command *c = 0;
 
     QString name = tr("Add Item at %1 s")
         .arg(RealTime::frame2RealTime

 
     source.waitForData();
 
     m_openingAudioFile = true;
 
-    int rate = 0;
+    sv_samplerate_t rate = 0;
 
     if (Preferences::getInstance()->getFixedSampleRate() != 0) {
         rate = Preferences::getInstance()->getFixedSampleRate();
     } else if (Preferences::getInstance()->getResampleOnLoad()) {
         rate = m_playSource->getSourceSampleRate();

 }
 
 MainWindowBase::FileOpenStatus
 MainWindowBase::openLayersFromRDF(FileSource source)
 {
-    int rate = 0;
+    sv_samplerate_t rate = 0;
 
     SVDEBUG << "MainWindowBase::openLayersFromRDF" << endl;
 
     ProgressDialog dialog(tr("Importing from RDF..."), true, 2000, this);
     connect(&dialog, SIGNAL(showing()), this, SIGNAL(hideSplash()));

     if (!currentPane) return;
 
     Model *model = getMainModel();
     if (!model) return;
     
-    int start = model->getStartFrame();
-    int end = model->getEndFrame();
+    sv_frame_t start = model->getStartFrame();
+    sv_frame_t end = model->getEndFrame();
     if (m_playSource) end = std::max(end, m_playSource->getPlayEndFrame());
     int pixels = currentPane->width();
 
     int sw = currentPane->getVerticalScaleWidth();
     if (pixels > sw * 2) pixels -= sw * 2;
     else pixels = 1;
     if (pixels > 4) pixels -= 4;
 
-    int zoomLevel = (end - start) / pixels;
+    int zoomLevel = int((end - start) / pixels);
     if (zoomLevel < 1) zoomLevel = 1;
 
     currentPane->setZoomLevel(zoomLevel);
     currentPane->setCentreFrame((start + end) / 2);
 }

 void
 MainWindowBase::ffwd()
 {
     if (!getMainModel()) return;
 
-    int frame = m_viewManager->getPlaybackFrame();
+    sv_frame_t frame = m_viewManager->getPlaybackFrame();
     ++frame;
 
     Pane *pane = m_paneStack->getCurrentPane();
     Layer *layer = getSnapLayer();
-    int sr = getMainModel()->getSampleRate();
+    sv_samplerate_t sr = getMainModel()->getSampleRate();
 
     if (!layer) {
 
         frame = RealTime::realTime2Frame
             (RealTime::frame2RealTime(frame, sr) + m_defaultFfwdRwdStep, sr);
-        if (frame > int(getMainModel()->getEndFrame())) {
+        if (frame > getMainModel()->getEndFrame()) {
             frame = getMainModel()->getEndFrame();
         }
 
     } else {
 

     }
         
     if (frame < 0) frame = 0;
 
     if (m_viewManager->getPlaySelectionMode()) {
-        frame = m_viewManager->constrainFrameToSelection(int(frame));
+        frame = m_viewManager->constrainFrameToSelection(frame);
     }
     
     m_viewManager->setPlaybackFrame(frame);
 
-    if (frame == (int)getMainModel()->getEndFrame() &&
+    if (frame == getMainModel()->getEndFrame() &&
         m_playSource &&
         m_playSource->isPlaying() &&
         !m_viewManager->getPlayLoopMode()) {
         stop();
     }

         m_playSource->isPlaying() &&
         !m_viewManager->getPlayLoopMode()) {
         stop();
     }
 
-    int frame = getMainModel()->getEndFrame();
+    sv_frame_t frame = getMainModel()->getEndFrame();
 
     if (m_viewManager->getPlaySelectionMode()) {
         frame = m_viewManager->constrainFrameToSelection(frame);
     }
 

 
     Layer *layer = getSnapLayer();
     if (!layer) { ffwd(); return; }
 
     Pane *pane = m_paneStack->getCurrentPane();
-    int frame = m_viewManager->getPlaybackFrame();
+    sv_frame_t frame = m_viewManager->getPlaybackFrame();
 
     int resolution = 0;
     if (pane) frame = pane->alignFromReference(frame);
     if (layer->snapToSimilarFeature(m_paneStack->getCurrentPane(),
                                     frame, resolution, Layer::SnapRight)) {

     }
         
     if (frame < 0) frame = 0;
 
     if (m_viewManager->getPlaySelectionMode()) {
-        frame = m_viewManager->constrainFrameToSelection(int(frame));
+        frame = m_viewManager->constrainFrameToSelection(frame);
     }
     
     m_viewManager->setPlaybackFrame(frame);
 
-    if (frame == (int)getMainModel()->getEndFrame() &&
+    if (frame == getMainModel()->getEndFrame() &&
         m_playSource &&
         m_playSource->isPlaying() &&
         !m_viewManager->getPlayLoopMode()) {
         stop();
     }

 void
 MainWindowBase::rewind()
 {
     if (!getMainModel()) return;
 
-    int frame = m_viewManager->getPlaybackFrame();
+    sv_frame_t frame = m_viewManager->getPlaybackFrame();
     if (frame > 0) --frame;
 
     Pane *pane = m_paneStack->getCurrentPane();
     Layer *layer = getSnapLayer();
-    int sr = getMainModel()->getSampleRate();
+    sv_samplerate_t sr = getMainModel()->getSampleRate();
     
     // when rewinding during playback, we want to allow a period
     // following a rewind target point at which the rewind will go to
     // the prior point instead of the immediately neighbouring one
     if (m_playSource && m_playSource->isPlaying()) {

 
     if (!layer) {
         
         frame = RealTime::realTime2Frame
             (RealTime::frame2RealTime(frame, sr) - m_defaultFfwdRwdStep, sr);
-        if (frame < int(getMainModel()->getStartFrame())) {
+        if (frame < getMainModel()->getStartFrame()) {
             frame = getMainModel()->getStartFrame();
         }
 
     } else {
 

     }
 
     if (frame < 0) frame = 0;
 
     if (m_viewManager->getPlaySelectionMode()) {
-        frame = m_viewManager->constrainFrameToSelection(int(frame));
+        frame = m_viewManager->constrainFrameToSelection(frame);
     }
 
     m_viewManager->setPlaybackFrame(frame);
 }
 
 void
 MainWindowBase::rewindStart()
 {
     if (!getMainModel()) return;
 
-    int frame = getMainModel()->getStartFrame();
+    sv_frame_t frame = getMainModel()->getStartFrame();
 
     if (m_viewManager->getPlaySelectionMode()) {
         frame = m_viewManager->constrainFrameToSelection(frame);
     }
 

 
     Layer *layer = getSnapLayer();
     if (!layer) { rewind(); return; }
 
     Pane *pane = m_paneStack->getCurrentPane();
-    int frame = m_viewManager->getPlaybackFrame();
+    sv_frame_t frame = m_viewManager->getPlaybackFrame();
 
     int resolution = 0;
     if (pane) frame = pane->alignFromReference(frame);
     if (layer->snapToSimilarFeature(m_paneStack->getCurrentPane(),
                                     frame, resolution, Layer::SnapLeft)) {

     }
         
     if (frame < 0) frame = 0;
 
     if (m_viewManager->getPlaySelectionMode()) {
-        frame = m_viewManager->constrainFrameToSelection(int(frame));
+        frame = m_viewManager->constrainFrameToSelection(frame);
     }
     
     m_viewManager->setPlaybackFrame(frame);
 }
 

 
 void
 MainWindowBase::connectLayerEditDialog(ModelDataTableDialog *dialog)
 {
     connect(m_viewManager,
-            SIGNAL(globalCentreFrameChanged(int)),
+            SIGNAL(globalCentreFrameChanged(sv_frame_t)),
             dialog,
-            SLOT(userScrolledToFrame(int)));
+            SLOT(userScrolledToFrame(sv_frame_t)));
 
     connect(m_viewManager,
-            SIGNAL(playbackFrameChanged(int)),
+            SIGNAL(playbackFrameChanged(sv_frame_t)),
             dialog,
-            SLOT(playbackScrolledToFrame(int)));
+            SLOT(playbackScrolledToFrame(sv_frame_t)));
 
     connect(dialog,
-            SIGNAL(scrollToFrame(int)),
+            SIGNAL(scrollToFrame(sv_frame_t)),
             m_viewManager,
-            SLOT(setGlobalCentreFrame(int)));
+            SLOT(setGlobalCentreFrame(sv_frame_t)));
 
     connect(dialog,
-            SIGNAL(scrollToFrame(int)),
+            SIGNAL(scrollToFrame(sv_frame_t)),
             m_viewManager,
-            SLOT(setPlaybackFrame(int)));
+            SLOT(setPlaybackFrame(sv_frame_t)));
 }    
 
 void
 MainWindowBase::previousPane()
 {

 
     updateMenuStates();
 }
 
 void
-MainWindowBase::playbackFrameChanged(int frame)
+MainWindowBase::playbackFrameChanged(sv_frame_t frame)
 {
     if (!(m_playSource && m_playSource->isPlaying()) || !getMainModel()) return;
 
     updatePositionStatusDisplays();
 

 
     getStatusLabel()->setText(m_myStatusMessage);
 }
 
 void
-MainWindowBase::globalCentreFrameChanged(int )
+MainWindowBase::globalCentreFrameChanged(sv_frame_t )
 {
     if ((m_playSource && m_playSource->isPlaying()) || !getMainModel()) return;
     Pane *p = 0;
     if (!m_paneStack || !(p = m_paneStack->getCurrentPane())) return;
     if (!p->getFollowGlobalPan()) return;
     updateVisibleRangeDisplay(p);
 }
 
 void
-MainWindowBase::viewCentreFrameChanged(View *v, int frame)
+MainWindowBase::viewCentreFrameChanged(View *v, sv_frame_t frame)
 {
 //    SVDEBUG << "MainWindowBase::viewCentreFrameChanged(" << v << "," << frame << ")" << endl;
 
     if (m_viewDataDialogMap.find(v) != m_viewDataDialogMap.end()) {
         for (DataDialogSet::iterator i = m_viewDataDialogMap[v].begin();