comparison src/MainWindow.cpp @ 399:ffd1a89a68fa cxx11-types

Build fixes etc

 #include <errno.h>
 
 using std::vector;
 
 
-MainWindow::MainWindow(bool withAudioOutput, bool withOSCSupport) :
+MainWindow::MainWindow(bool withAudioOutput) :
     MainWindowBase(withAudioOutput, false),
     m_overview(0),
     m_mainMenusCreated(false),
     m_playbackMenu(0),
     m_recentFilesMenu(0), 

     // We have a pane stack: it comes with the territory. However, we
     // have a fixed and known number of panes in it -- it isn't
     // variable
     m_paneStack->setLayoutStyle(PaneStack::NoPropertyStacks);
     m_paneStack->setShowPaneAccessories(false);
-    connect(m_paneStack, SIGNAL(doubleClickSelectInvoked(size_t)),
-            this, SLOT(doubleClickSelectInvoked(size_t)));
+    connect(m_paneStack, SIGNAL(doubleClickSelectInvoked(sv_frame_t)),
+            this, SLOT(doubleClickSelectInvoked(sv_frame_t)));
     scroll->setWidget(m_paneStack);
 
     m_overview = new Overview(frame);
     m_overview->setViewManager(m_viewManager);
     m_overview->setFixedHeight(40);

 
 
 void
 MainWindow::moveByOneNote(bool right, bool doSelect)
 {
-    int frame = m_viewManager->getPlaybackFrame();
+    sv_frame_t frame = m_viewManager->getPlaybackFrame();
     cerr << "MainWindow::moveByOneNote startframe: " << frame << endl;
     
-    Pane *p = m_analyser->getPane();
-
     bool isAtSelectionBoundary = false;
     MultiSelection::SelectionList selections = m_viewManager->getSelections();
     if (!selections.empty()) {
         Selection sel = *selections.begin();
         isAtSelectionBoundary = (frame == sel.getStartFrame()) || (frame == sel.getEndFrame());

 
     FlexiNoteModel::PointList points = model->getPoints();
     if (points.empty()) return;
 
     FlexiNoteModel::PointList::iterator i = points.begin();
-    std::set<int> snapFrames;
+    std::set<sv_frame_t> snapFrames;
     snapFrames.insert(0);
     while (i != points.end()) {
         snapFrames.insert(i->frame);
         snapFrames.insert(i->frame + i->duration + 1);
         ++i;
     }
-    std::set<int>::iterator i2;
-    if (snapFrames.find(frame) == snapFrames.end())
-    {
+    std::set<sv_frame_t>::iterator i2;
+    if (snapFrames.find(frame) == snapFrames.end()) {
         // we're not on an existing snap point, so go to previous
         snapFrames.insert(frame);
     }
     i2 = snapFrames.find(frame);
-    if (right)
-    {
+    if (right) {
         i2++;
         if (i2 == snapFrames.end()) i2--;
     } else {
         if (i2 != snapFrames.begin()) i2--;
     }

         (haveCurrentPane &&
          (currentLayer != 0));
     bool haveSelection = 
         (m_viewManager &&
          !m_viewManager->getSelections().empty());
-    bool haveCurrentEditableLayer =
-        (haveCurrentLayer &&
-         currentLayer->isLayerEditable());
     bool haveCurrentTimeInstantsLayer = 
         (haveCurrentLayer &&
          qobject_cast<TimeInstantLayer *>(currentLayer));
     bool haveCurrentTimeValueLayer = 
         (haveCurrentLayer &&
          qobject_cast<TimeValueLayer *>(currentLayer));
     bool pitchCandidatesVisible = 
         m_analyser->arePitchCandidatesShown();
-    bool haveHigher =
-        m_analyser->haveHigherPitchCandidate();
-    bool haveLower =
-        m_analyser->haveLowerPitchCandidate();
 
     emit canChangePlaybackSpeed(true);
     int v = m_playSpeed->value();
     emit canSpeedUpPlayback(v < m_playSpeed->maximum());
     emit canSlowDownPlayback(v > m_playSpeed->minimum());

 }
 
 void
 MainWindow::editDisplayExtents()
 {
-    float min, max;
-    float vmin = 0;
-    float vmax = getMainModel()->getSampleRate() /2;
+    double min, max;
+    double vmin = 0;
+    double vmax = getMainModel()->getSampleRate() /2;
     
     if (!m_analyser->getDisplayFrequencyExtents(min, max)) {
         //!!!
         return;
     }
 
     RangeInputDialog dialog(tr("Set frequency range"),
                             tr("Enter new frequency range, from %1 to %2 Hz.\nThese values will be rounded to the nearest spectrogram bin.")
                             .arg(vmin).arg(vmax),
-                            "Hz", vmin, vmax, this);
-    dialog.setRange(min, max);
+                            "Hz", float(vmin), float(vmax), this);
+    dialog.setRange(float(min), float(max));
 
     if (dialog.exec() == QDialog::Accepted) {
-        dialog.getRange(min, max);
+        float fmin, fmax;
+        dialog.getRange(fmin, fmax);
+        min = fmin;
+        max = fmax;
         if (min > max) {
-            float tmp = max;
+            double tmp = max;
             max = min;
             min = tmp;
         }
         m_analyser->setDisplayFrequencyExtents(min, max);
     }

         emit activity(tr("Export layer to \"%1\"").arg(path));
     }
 }
 
 void
-MainWindow::doubleClickSelectInvoked(size_t frame)
-{
-    size_t f0, f1;
+MainWindow::doubleClickSelectInvoked(sv_frame_t frame)
+{
+    sv_frame_t f0, f1;
     m_analyser->getEnclosingSelectionScope(frame, f0, f1);
     
     cerr << "MainWindow::doubleClickSelectInvoked(" << frame << "): [" << f0 << "," << f1 << "]" << endl;
 
     Selection sel(f0, f1);

     if (!spectrogram) {
         cerr << "MainWindow::regionOutlined: no spectrogram layer, ignoring" << endl;
         return;
     }
 
-    int f0 = pane->getFrameForX(r.x());
-    int f1 = pane->getFrameForX(r.x() + r.width());
+    sv_frame_t f0 = pane->getFrameForX(r.x());
+    sv_frame_t f1 = pane->getFrameForX(r.x() + r.width());
     
-    float v0 = spectrogram->getFrequencyForY(pane, r.y() + r.height());
-    float v1 = spectrogram->getFrequencyForY(pane, r.y());
+    double v0 = spectrogram->getFrequencyForY(pane, r.y() + r.height());
+    double v1 = spectrogram->getFrequencyForY(pane, r.y());
 
     cerr << "MainWindow::regionOutlined: frame " << f0 << " -> " << f1 
          << ", frequency " << v0 << " -> " << v1 << endl;
 
     m_pendingConstraint = Analyser::FrequencyRange(v0, v1);

     
         CommandHistory::getInstance()->startCompoundOperation
             (tr("Form Note from Selection"), true);
         for (MultiSelection::SelectionList::iterator k = selections.begin();
              k != selections.end(); ++k) {
-            if (!model->getNotes(k->getStartFrame(), k->getEndFrame()).empty()) {
+            if (!model->getNotesWithin(k->getStartFrame(), k->getEndFrame()).empty()) {
                 layer->splitNotesAt(m_analyser->getPane(), k->getStartFrame());
                 layer->splitNotesAt(m_analyser->getPane(), k->getEndFrame());
                 layer->mergeNotes(m_analyser->getPane(), *k, false);
             } else {
                 layer->addNoteOn(k->getStartFrame(), 100, 100);

 void
 MainWindow::playSpeedChanged(int position)
 {
     PlaySpeedRangeMapper mapper(0, 200);
 
-    float percent = m_playSpeed->mappedValue();
-    float factor = mapper.getFactorForValue(percent);
+    double percent = m_playSpeed->mappedValue();
+    double factor = mapper.getFactorForValue(percent);
 
     cerr << "speed = " << position << " percent = " << percent << " factor = " << factor << endl;
 
     bool something = (position != 100);
 
-    int pc = lrintf(percent);
+    int pc = int(lrint(percent));
 
     if (!something) {
         contextHelpChanged(tr("Playback speed: Normal"));
     } else {
         contextHelpChanged(tr("Playback speed: %1%2%")

 }
 
 void
 MainWindow::audioGainChanged(int position)
 {
-    float level = m_gainAudio->mappedValue();
-    float gain = powf(10, level / 20.0);
+    double level = m_gainAudio->mappedValue();
+    double gain = pow(10, level / 20.0);
 
     cerr << "gain = " << gain << " (" << position << " dB)" << endl;
 
     contextHelpChanged(tr("Audio Gain: %1 dB").arg(position));
 
-    m_analyser->setGain(Analyser::Audio, gain);
+    m_analyser->setGain(Analyser::Audio, float(gain));
 
     updateMenuStates();
 } 
 
 void

 }
 
 void
 MainWindow::pitchGainChanged(int position)
 {
-    float level = m_gainPitch->mappedValue();
-    float gain = powf(10, level / 20.0);
+    double level = m_gainPitch->mappedValue();
+    double gain = pow(10, level / 20.0);
 
     cerr << "gain = " << gain << " (" << position << " dB)" << endl;
 
     contextHelpChanged(tr("Pitch Gain: %1 dB").arg(position));
 
-    m_analyser->setGain(Analyser::PitchTrack, gain);
+    m_analyser->setGain(Analyser::PitchTrack, float(gain));
 
     updateMenuStates();
 } 
 
 void

 }
 
 void
 MainWindow::notesGainChanged(int position)
 {
-    float level = m_gainNotes->mappedValue();
-    float gain = powf(10, level / 20.0);
+    double level = m_gainNotes->mappedValue();
+    double gain = pow(10, level / 20.0);
 
     cerr << "gain = " << gain << " (" << position << " dB)" << endl;
 
     contextHelpChanged(tr("Notes Gain: %1 dB").arg(position));
 
-    m_analyser->setGain(Analyser::Notes, gain);
+    m_analyser->setGain(Analyser::Notes, float(gain));
 
     updateMenuStates();
 } 
 
 void

 }
 
 void
 MainWindow::audioPanChanged(int position)
 {
-    float level = m_panAudio->mappedValue();
-    float pan = level/100.f;
+    double level = m_panAudio->mappedValue();
+    double pan = level/100.0;
 
     cerr << "pan = " << pan << " (" << position << ")" << endl;
 
     contextHelpChanged(tr("Audio Pan: %1").arg(position));
 
-    m_analyser->setPan(Analyser::Audio, pan);
+    m_analyser->setPan(Analyser::Audio, float(pan));
 
     updateMenuStates();
 } 
 
 void

 }
 
 void
 MainWindow::pitchPanChanged(int position)
 {
-    float level = m_panPitch->mappedValue();
-    float pan = level/100.f;
+    double level = m_panPitch->mappedValue();
+    double pan = level/100.0;
 
     cerr << "pan = " << pan << " (" << position << ")" << endl;
 
     contextHelpChanged(tr("Pitch Pan: %1").arg(position));
 
-    m_analyser->setPan(Analyser::PitchTrack, pan);
+    m_analyser->setPan(Analyser::PitchTrack, float(pan));
 
     updateMenuStates();
 } 
 
 void

 }
 
 void
 MainWindow::notesPanChanged(int position)
 {
-    float level = m_panNotes->mappedValue();
-    float pan = level/100.f;
+    double level = m_panNotes->mappedValue();
+    double pan = level/100.0;
 
     cerr << "pan = " << pan << " (" << position << ")" << endl;
 
     contextHelpChanged(tr("Notes Pan: %1").arg(position));
 
-    m_analyser->setPan(Analyser::Notes, pan);
+    m_analyser->setPan(Analyser::Notes, float(pan));
 
     updateMenuStates();
 } 
 
 void

     m_fader->setPeakLeft(left);
     m_fader->setPeakRight(right);
 }
 
 void
-MainWindow::sampleRateMismatch(size_t requested, size_t actual,
-                               bool willResample)
+MainWindow::sampleRateMismatch(sv_samplerate_t ,
+                               sv_samplerate_t ,
+                               bool )
 {
     updateDescriptionLabel();
 }
 
 void

              QMessageBox::Ok);
     }
 }
 
 void
-MainWindow::modelGenerationWarning(QString transformName, QString message)
+MainWindow::modelGenerationWarning(QString /* transformName */, QString message)
 {
     QMessageBox::warning
         (this, tr("Warning"), message, QMessageBox::Ok);
 }
 
 void
 MainWindow::modelRegenerationFailed(QString layerName,
-                                    QString transformName, QString message)
+                                    QString transformName,
+                                    QString message)
 {
     if (message != "") {
 
         QMessageBox::warning
             (this,

     }
 }
 
 void
 MainWindow::modelRegenerationWarning(QString layerName,
-                                     QString transformName, QString message)
+                                     QString /* transformName */,
+                                     QString message)
 {
     QMessageBox::warning
         (this, tr("Warning"), tr("<b>Warning when regenerating layer</b><p>When regenerating the derived layer \"%1\" using new data model as input:<p>%2").arg(layerName).arg(message), QMessageBox::Ok);
 }
 

     m_paneStack->setCurrentPane(pane);
     m_rightButtonMenu->popup(position);
 }
 
 void
-MainWindow::handleOSCMessage(const OSCMessage &message)
+MainWindow::handleOSCMessage(const OSCMessage &)
 {
     cerr << "MainWindow::handleOSCMessage: Not implemented" << endl;
 }
 
 void