comparison framework/MainWindowBase.cpp @ 371:dfcc5b355f33

Merge from branch warnfix_no_size_t

     m_recentTransforms("RecentTransforms", 20),
     m_documentModified(false),
     m_openingAudioFile(false),
     m_abandoning(false),
     m_labeller(0),
-    m_lastPlayStatusSec(0)
+    m_lastPlayStatusSec(0),
+    m_initialDarkBackground(false),
+    m_defaultFfwdRwdStep(2, 0)
 {
     Profiler profiler("MainWindowBase::MainWindowBase");
 
 #ifdef Q_WS_X11
     XSetErrorHandler(handle_x11_error);

             this, SLOT(paneDeleteButtonClicked(Pane *)));
 
     m_playSource = new AudioCallbackPlaySource(m_viewManager,
                                                QApplication::applicationName());
 
-    connect(m_playSource, SIGNAL(sampleRateMismatch(size_t, size_t, bool)),
-	    this,           SLOT(sampleRateMismatch(size_t, size_t, bool)));
+    connect(m_playSource, SIGNAL(sampleRateMismatch(int, int, bool)),
+	    this,           SLOT(sampleRateMismatch(int, int, 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(unsigned long)),
-            this, SLOT(playbackFrameChanged(unsigned long)));
-
-    connect(m_viewManager, SIGNAL(globalCentreFrameChanged(unsigned long)),
-            this, SLOT(globalCentreFrameChanged(unsigned long)));
-
-    connect(m_viewManager, SIGNAL(viewCentreFrameChanged(View *, unsigned long)),
-            this, SLOT(viewCentreFrameChanged(View *, unsigned long)));
-
-    connect(m_viewManager, SIGNAL(viewZoomLevelChanged(View *, unsigned long, bool)),
-            this, SLOT(viewZoomLevelChanged(View *, unsigned long, bool)));
+    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(viewZoomLevelChanged(View *, int, bool)),
+            this, SLOT(viewZoomLevelChanged(View *, int, bool)));
 
     connect(Preferences::getInstance(),
             SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
             this,
             SLOT(preferenceChanged(PropertyContainer::PropertyName)));

         if (menu) finaliseMenu(menu);
     }
 }
 
 void
-MainWindowBase::finaliseMenu(QMenu *menu)
+MainWindowBase::finaliseMenu(QMenu *
+#ifdef Q_OS_MAC
+                             menu
+#endif
+    )
 {
 #ifdef Q_OS_MAC
     // See https://bugreports.qt-project.org/browse/QTBUG-38256 and
     // our issue #890 http://code.soundsoftware.ac.uk/issues/890 --
     // single-key shortcuts that are associated only with a menu

 
 QString
 MainWindowBase::getOpenFileName(FileFinder::FileType type)
 {
     FileFinder *ff = FileFinder::getInstance();
-    switch (type) {
-    case FileFinder::SessionFile:
-        return ff->getOpenFileName(type, m_sessionFile);
-    case FileFinder::AudioFile:
-        return ff->getOpenFileName(type, m_audioFile);
-    case FileFinder::LayerFile:
-        return ff->getOpenFileName(type, m_sessionFile);
-    case FileFinder::LayerFileNoMidi:
-        return ff->getOpenFileName(type, m_sessionFile);
-    case FileFinder::LayerFileNonSV:
-        return ff->getOpenFileName(type, m_sessionFile);
-    case FileFinder::LayerFileNoMidiNonSV:
-        return ff->getOpenFileName(type, m_sessionFile);
-    case FileFinder::SessionOrAudioFile:
-        return ff->getOpenFileName(type, m_sessionFile);
-    case FileFinder::ImageFile:
-        return ff->getOpenFileName(type, m_sessionFile);
-    case FileFinder::CSVFile:
-        return ff->getOpenFileName(type, m_sessionFile);
-    case FileFinder::AnyFile:
+
+    if (type == FileFinder::AnyFile) {
         if (getMainModel() != 0 &&
             m_paneStack != 0 &&
             m_paneStack->getCurrentPane() != 0) { // can import a layer
             return ff->getOpenFileName(FileFinder::AnyFile, m_sessionFile);
         } else {
             return ff->getOpenFileName(FileFinder::SessionOrAudioFile,
                                        m_sessionFile);
         }
-    }
-    return "";
+    }        
+
+    QString lastPath = m_sessionFile;
+
+    if (type == FileFinder::AudioFile) {
+        lastPath = m_audioFile;
+    }
+
+    return ff->getOpenFileName(type, lastPath);
 }
 
 QString
 MainWindowBase::getSaveFileName(FileFinder::FileType type)
 {
+    QString lastPath = m_sessionFile;
+
+    if (type == FileFinder::AudioFile) {
+        lastPath = m_audioFile;
+    }
+
     FileFinder *ff = FileFinder::getInstance();
-    switch (type) {
-    case FileFinder::SessionFile:
-        return ff->getSaveFileName(type, m_sessionFile);
-    case FileFinder::AudioFile:
-        return ff->getSaveFileName(type, m_audioFile);
-    case FileFinder::LayerFile:
-        return ff->getSaveFileName(type, m_sessionFile);
-    case FileFinder::LayerFileNoMidi:
-        return ff->getSaveFileName(type, m_sessionFile);
-    case FileFinder::LayerFileNonSV:
-        return ff->getSaveFileName(type, m_sessionFile);
-    case FileFinder::LayerFileNoMidiNonSV:
-        return ff->getSaveFileName(type, m_sessionFile);
-    case FileFinder::SessionOrAudioFile:
-        return ff->getSaveFileName(type, m_sessionFile);
-    case FileFinder::ImageFile:
-        return ff->getSaveFileName(type, m_sessionFile);
-    case FileFinder::CSVFile:
-        return ff->getSaveFileName(type, m_sessionFile);
-    case FileFinder::AnyFile:
-        return ff->getSaveFileName(type, m_sessionFile);
-    }
-    return "";
+    return ff->getSaveFileName(type, lastPath);
 }
 
 void
 MainWindowBase::registerLastOpenedFilePath(FileFinder::FileType type, QString path)
 {

     emit canRenumberInstants(haveCurrentTimeInstantsLayer && haveSelection);
     emit canPlaySelection(haveMainModel && havePlayTarget && haveSelection);
     emit canClearSelection(haveSelection);
     emit canEditSelection(haveSelection && haveCurrentEditableLayer);
     emit canSave(m_sessionFile != "" && m_documentModified);
+    emit canSaveAs(haveMainModel);
     emit canSelectPreviousPane(havePrevPane);
     emit canSelectNextPane(haveNextPane);
     emit canSelectPreviousLayer(havePrevLayer);
     emit canSelectNextLayer(haveNextLayer);
 }

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

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

     }
 }
 
 // FrameTimer method
 
-unsigned long
+int
 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) {
-        size_t start = i->getStartFrame();
-        size_t end = i->getEndFrame();
+        int start = i->getStartFrame();
+        int end = i->getEndFrame();
         if (start != end) {
             insertInstantAt(start);
             insertInstantAt(end);
         }
     }
 }
 
 void
-MainWindowBase::insertInstantAt(size_t frame)
+MainWindowBase::insertInstantAt(int 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) {
-        size_t start = i->getStartFrame();
-        size_t end = i->getEndFrame();
+        int start = i->getStartFrame();
+        int end = i->getEndFrame();
         if (start < end) {
             insertItemAt(start, end - start);
         }
     }
 }
 
 void
-MainWindowBase::insertItemAt(size_t frame, size_t duration)
+MainWindowBase::insertItemAt(int frame, int duration)
 {
     Pane *pane = m_paneStack->getCurrentPane();
     if (!pane) {
         return;
     }
 
     // ugh!
 
-    size_t alignedStart = pane->alignFromReference(frame);
-    size_t alignedEnd = pane->alignFromReference(frame + duration);
+    int alignedStart = pane->alignFromReference(frame);
+    int alignedEnd = pane->alignFromReference(frame + duration);
     if (alignedStart >= alignedEnd) return;
-    size_t alignedDuration = alignedEnd - alignedStart;
+    int alignedDuration = alignedEnd - alignedStart;
 
     Command *c = 0;
 
     QString name = tr("Add Item at %1 s")
         .arg(RealTime::frame2RealTime

     if (!source.isAvailable()) return FileOpenFailed;
     source.waitForData();
 
     m_openingAudioFile = true;
 
-    size_t rate = 0;
-
-    if (Preferences::getInstance()->getResampleOnLoad()) {
+    int rate = 0;
+
+    if (Preferences::getInstance()->getFixedSampleRate() != 0) {
+        rate = Preferences::getInstance()->getFixedSampleRate();
+    } else if (Preferences::getInstance()->getResampleOnLoad()) {
         rate = m_playSource->getSourceSampleRate();
     }
 
     WaveFileModel *newModel = new WaveFileModel(source, rate);
 

     if (!source.isAvailable()) return FileOpenFailed;
     source.waitForData();
 
     QXmlInputSource *inputSource = 0;
     QFile *file = 0;
-    bool isTemplate = false;
 
     file = new QFile(source.getLocalFilename());
     inputSource = new QXmlInputSource(file);
 
     if (!checkSaveModified()) {

 }
 
 MainWindowBase::FileOpenStatus
 MainWindowBase::openLayersFromRDF(FileSource source)
 {
-    size_t rate = 0;
+    int 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;
     
-    size_t start = model->getStartFrame();
-    size_t end = model->getEndFrame();
+    int start = model->getStartFrame();
+    int end = model->getEndFrame();
     if (m_playSource) end = std::max(end, m_playSource->getPlayEndFrame());
-    size_t pixels = currentPane->width();
-
-    size_t sw = currentPane->getVerticalScaleWidth();
+    int pixels = currentPane->width();
+
+    int sw = currentPane->getVerticalScaleWidth();
     if (pixels > sw * 2) pixels -= sw * 2;
     else pixels = 1;
     if (pixels > 4) pixels -= 4;
 
-    size_t zoomLevel = (end - start) / pixels;
+    int zoomLevel = (end - start) / pixels;
     if (zoomLevel < 1) zoomLevel = 1;
 
     currentPane->setZoomLevel(zoomLevel);
     currentPane->setCentreFrame((start + end) / 2);
 }

     int frame = m_viewManager->getPlaybackFrame();
     ++frame;
 
     Pane *pane = m_paneStack->getCurrentPane();
     Layer *layer = getSnapLayer();
-    size_t sr = getMainModel()->getSampleRate();
+    int sr = getMainModel()->getSampleRate();
 
     if (!layer) {
 
         frame = RealTime::realTime2Frame
-            (RealTime::frame2RealTime(frame, sr) + RealTime(2, 0), sr);
+            (RealTime::frame2RealTime(frame, sr) + m_defaultFfwdRwdStep, sr);
         if (frame > int(getMainModel()->getEndFrame())) {
             frame = getMainModel()->getEndFrame();
         }
 
     } else {
 
-        size_t resolution = 0;
+        int resolution = 0;
         if (pane) frame = pane->alignFromReference(frame);
         if (layer->snapToFeatureFrame(m_paneStack->getCurrentPane(),
                                       frame, resolution, Layer::SnapRight)) {
             if (pane) frame = pane->alignToReference(frame);
         } else {

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

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

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

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

     int frame = m_viewManager->getPlaybackFrame();
     if (frame > 0) --frame;
 
     Pane *pane = m_paneStack->getCurrentPane();
     Layer *layer = getSnapLayer();
-    size_t sr = getMainModel()->getSampleRate();
+    int 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()) {
         RealTime ct = RealTime::frame2RealTime(frame, sr);
-        ct = ct - RealTime::fromSeconds(0.25);
+        ct = ct - RealTime::fromSeconds(0.15);
         if (ct < RealTime::zeroTime) ct = RealTime::zeroTime;
         frame = RealTime::realTime2Frame(ct, sr);
     }
 
     if (!layer) {
         
         frame = RealTime::realTime2Frame
-            (RealTime::frame2RealTime(frame, sr) - RealTime(2, 0), sr);
+            (RealTime::frame2RealTime(frame, sr) - m_defaultFfwdRwdStep, sr);
         if (frame < int(getMainModel()->getStartFrame())) {
             frame = getMainModel()->getStartFrame();
         }
 
     } else {
 
-        size_t resolution = 0;
+        int resolution = 0;
         if (pane) frame = pane->alignFromReference(frame);
         if (layer->snapToFeatureFrame(m_paneStack->getCurrentPane(),
                                       frame, resolution, Layer::SnapLeft)) {
             if (pane) frame = pane->alignToReference(frame);
         } else {

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

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

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

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

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

 
     statusBar()->showMessage(m_myStatusMessage);
 }
 
 void
-MainWindowBase::globalCentreFrameChanged(unsigned long )
+MainWindowBase::globalCentreFrameChanged(int )
 {
     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, unsigned long frame)
+MainWindowBase::viewCentreFrameChanged(View *v, int frame)
 {
 //    SVDEBUG << "MainWindowBase::viewCentreFrameChanged(" << v << "," << frame << ")" << endl;
 
     if (m_viewDataDialogMap.find(v) != m_viewDataDialogMap.end()) {
         for (DataDialogSet::iterator i = m_viewDataDialogMap[v].begin();

     if (!m_paneStack || !(p = m_paneStack->getCurrentPane())) return;
     if (v == p) updateVisibleRangeDisplay(p);
 }
 
 void
-MainWindowBase::viewZoomLevelChanged(View *v, unsigned long , bool )
+MainWindowBase::viewZoomLevelChanged(View *v, int , bool )
 {
     if ((m_playSource && m_playSource->isPlaying()) || !getMainModel()) return;
     Pane *p = 0;
     if (!m_paneStack || !(p = m_paneStack->getCurrentPane())) return;
     if (v == p) updateVisibleRangeDisplay(p);

 MainWindowBase::mainModelChanged(WaveFileModel *model)
 {
 //    SVDEBUG << "MainWindowBase::mainModelChanged(" << model << ")" << endl;
     updateDescriptionLabel();
     if (model) m_viewManager->setMainModelSampleRate(model->getSampleRate());
-    if (model && !m_playTarget && m_audioOutput) createPlayTarget();
+    if (model && !m_playTarget && m_audioOutput) {
+        createPlayTarget();
+    }
 }
 
 void
 MainWindowBase::modelAboutToBeDeleted(Model *model)
 {

 #ifdef Q_OS_MAC
     args.append(url);
     process->start("open", args);
 #else
 #ifdef Q_OS_WIN32
-
-	QString pf(getenv("ProgramFiles"));
-	QString command = pf + QString("\\Internet Explorer\\IEXPLORE.EXE");
-
-	args.append(url);
-	process->start(command, args);
-
+    QString pf(getenv("ProgramFiles"));
+    QString command = pf + QString("\\Internet Explorer\\IEXPLORE.EXE");
+
+    args.append(url);
+    process->start(command, args);
 #else
-#ifdef Q_WS_X11
     if (!qgetenv("KDE_FULL_SESSION").isEmpty()) {
         args.append("exec");
         args.append(url);
         process->start("kfmclient", args);
     } else if (!qgetenv("BROWSER").isEmpty()) {

         args.append(url);
         process->start("firefox", args);
     }
 #endif
 #endif
-#endif
 }