comparison main/MainWindow.cpp @ 677:bfd68cc71a25 imaf_enc

Merge from default branch, fix build

 #include "layer/ColourDatabase.h"
 #include "widgets/ModelDataTableDialog.h"
 #include "rdf/PluginRDFIndexer.h"
 #include "rdf/RDFExporter.h"
 
+#include "Surveyer.h"
+#include "NetworkPermissionTester.h"
 #include "framework/VersionTester.h"
 
 // For version information
 #include <vamp/vamp.h>
 #include <vamp-hostsdk/PluginBase.h>

 #include <QFileSystemWatcher>
 
 #include <iostream>
 #include <cstdio>
 #include <errno.h>
-
-using std::cerr;
-using std::endl;
 
 using std::vector;
 using std::map;
 using std::set;
 

     connect(m_playSpeed, SIGNAL(mouseEntered()), this, SLOT(mouseEnteredWidget()));
     connect(m_playSpeed, SIGNAL(mouseLeft()), this, SLOT(mouseLeftWidget()));
 
     IconLoader il;
 
-    QSettings settings;
-    settings.beginGroup("MainWindow");
-    settings.endGroup();
-
     m_playControlsSpacer = new QFrame;
 
     layout->setSpacing(4);
     layout->addWidget(m_mainScroll, 0, 0, 1, 5);
     layout->addWidget(m_overview, 1, 1);

     newSession();
 
     connect(m_midiInput, SIGNAL(eventsAvailable()),
             this, SLOT(midiEventsAvailable()));
 
-    TransformFactory::getInstance()->startPopulationThread();
-
-    VersionTester *vt = new VersionTester
-        ("sonicvisualiser.org", "/latest-version.txt", SV_VERSION);
-    connect(vt, SIGNAL(newerVersionAvailable(QString)),
-            this, SLOT(newerVersionAvailable(QString)));
+    NetworkPermissionTester tester;
+    bool networkPermission = tester.havePermission();
+    if (networkPermission) {
+        TransformFactory::getInstance()->startPopulationThread();
+        m_surveyer = 0;
+        m_versionTester = 0;
+/*
+        m_surveyer = new Surveyer
+            ("sonicvisualiser.org", "survey23-present.txt", "survey23.php");
+        m_versionTester = new VersionTester
+            ("sonicvisualiser.org", "latest-version.txt", SV_VERSION);
+        connect(m_versionTester, SIGNAL(newerVersionAvailable(QString)),
+                this, SLOT(newerVersionAvailable(QString)));
+*/
+    } else {
+        m_surveyer = 0;
+        m_versionTester = 0;
+    }
 }
 
 MainWindow::~MainWindow()
 {
 //    SVDEBUG << "MainWindow::~MainWindow" << endl;
     delete m_keyReference;
     delete m_activityLog;
     delete m_preferencesDialog;
     delete m_layerTreeDialog;
+    delete m_versionTester;
+    delete m_surveyer;
     Profiles::getInstance()->dump();
 //    SVDEBUG << "MainWindow::~MainWindow finishing" << endl;
 }
 
 void

     action->setStatusTip(tr("Export selection as an audio file"));
     connect(action, SIGNAL(triggered()), this, SLOT(exportAudio()));
     connect(this, SIGNAL(canExportAudio(bool)), action, SLOT(setEnabled(bool)));
     menu->addAction(action);
 
-    action = new QAction(tr("&Export Audio Data..."), this);
+    action = new QAction(tr("Export Audio Data..."), this);
     action->setStatusTip(tr("Export audio from selection into a data file"));
     connect(action, SIGNAL(triggered()), this, SLOT(exportAudioData()));
     connect(this, SIGNAL(canExportAudio(bool)), action, SLOT(setEnabled(bool)));
     menu->addAction(action);
 
-    QAction *actionCreateIMAF = new QAction(tr("&Export IMAF File..."), this);
+    QAction *actionCreateIMAF = new QAction(tr("Export IMAF File..."), this);
     actionCreateIMAF->setStatusTip(tr("Export selection as an IMAF file"));
     menu->addAction(actionCreateIMAF);
     connect(actionCreateIMAF,SIGNAL(triggered()),this,SLOT(exportIMAF()));
 
-    QAction *actionOpenIMAF = new QAction(tr("&Import IMAF File..."), this);
+    QAction *actionOpenIMAF = new QAction(tr("Import IMAF File..."), this);
     actionOpenIMAF->setStatusTip(tr("Import IMAF file"));
     menu->addAction(actionOpenIMAF);
     connect(actionOpenIMAF,SIGNAL(triggered()),this,SLOT(importIMAF()));
 
     menu->addSeparator();

     for (unsigned int i = 0; i < transforms.size(); ++i) {
 
     QString name = transforms[i].name;
     if (name == "") name = transforms[i].identifier;
 
-//        std::cerr << "Plugin Name: " << name << std::endl;
+//        cerr << "Plugin Name: " << name << endl;
 
         TransformDescription::Type type = transforms[i].type;
         QString typeStr = factory->getTransformTypeName(type);
 
         QString category = transforms[i].category;

     connect(this, SIGNAL(canAddLayer(bool)), action, SLOT(setEnabled(bool)));
 
         action->setStatusTip(transforms[i].longDescription);
 
         if (categoryMenus[type].find(category) == categoryMenus[type].end()) {
-            std::cerr << "WARNING: MainWindow::setupMenus: Internal error: "
+            cerr << "WARNING: MainWindow::setupMenus: Internal error: "
                       << "No category menu for transform \""
                       << name << "\" (category = \""
-                      << category << "\")" << std::endl;
+                      << category << "\")" << endl;
         } else {
             categoryMenus[type][category]->addAction(action);
         }
 
         if (makerMenus[type].find(maker) == makerMenus[type].end()) {
-            std::cerr << "WARNING: MainWindow::setupMenus: Internal error: "
+            cerr << "WARNING: MainWindow::setupMenus: Internal error: "
                       << "No maker menu for transform \""
                       << name << "\" (maker = \""
-                      << maker << "\")" << std::endl;
+                      << maker << "\")" << endl;
         } else {
             makerMenus[type][maker]->addAction(action);
         }
 
         action = new QAction(tr("%1...").arg(output == "" ? pluginName : output), this);

     vector<QString> transforms = m_recentTransforms.getRecent();
     for (size_t i = 0; i < transforms.size(); ++i) {
         TransformActionReverseMap::iterator ti =
             m_transformActionsReverse.find(transforms[i]);
         if (ti == m_transformActionsReverse.end()) {
-            std::cerr << "WARNING: MainWindow::setupRecentTransformsMenu: "
-                      << "Unknown transform \"" << transforms[i].toStdString()
-                      << "\" in recent transforms list" << std::endl;
+            cerr << "WARNING: MainWindow::setupRecentTransformsMenu: "
+                      << "Unknown transform \"" << transforms[i]
+                      << "\" in recent transforms list" << endl;
             continue;
         }
         if (i == 0) {
             ti->second->setShortcut(tr("Ctrl+T"));
             m_keyReference->registerShortcut

 
     LayerFactory *factory = LayerFactory::getInstance();
 
     for (int i = 0; i < m_paneStack->getPaneCount(); ++i) {
 
-    Pane *pane = m_paneStack->getPane(i);
-    if (!pane) continue;
-
-    for (int j = 0; j < pane->getLayerCount(); ++j) {
-
-        Layer *layer = pane->getLayer(j);
-        if (!layer) continue;
-        if (observedLayers.find(layer) != observedLayers.end()) {
-//		std::cerr << "found duplicate layer " << layer << std::endl;
-        continue;
-        }
-
-//	    std::cerr << "found new layer " << layer << " (name = "
-//		      << layer->getLayerPresentationName() << ")" << std::endl;
-
-        orderedLayers.push_back(layer);
-        observedLayers.insert(layer);
+	Pane *pane = m_paneStack->getPane(i);
+	if (!pane) continue;
+
+	for (int j = 0; j < pane->getLayerCount(); ++j) {
+
+	    Layer *layer = pane->getLayer(j);
+	    if (!layer) continue;
+	    if (observedLayers.find(layer) != observedLayers.end()) {
+//		cerr << "found duplicate layer " << layer << endl;
+		continue;
+	    }
+
+//	    cerr << "found new layer " << layer << " (name = " 
+//		      << layer->getLayerPresentationName() << ")" << endl;
+            
+            orderedLayers.push_back(layer);
+            observedLayers.insert(layer);
 
             if (factory->isLayerSliceable(layer)) {
                 sliceableLayers.insert(layer);
             }
-    }
+        }
     }
 
     map<QString, int> observedNames;
 
     for (size_t i = 0; i < orderedLayers.size(); ++i) {

                 (this, tr("Select audio file to export"),
                  tr("Which audio file do you want to export from?"),
                  items, c, false, &ok);
             if (!ok || item.isEmpty()) return;
             if (m.find(item) == m.end()) {
-                cerr << "WARNING: Model " << item.toStdString()
+                cerr << "WARNING: Model " << item
                      << " not found in list!" << endl;
             } else {
                 model = m[item];
             }
         }

 MainWindow::importLayer()
 {
     Pane *pane = m_paneStack->getCurrentPane();
 
     if (!pane) {
-    // shouldn't happen, as the menu action should have been disabled
-    std::cerr << "WARNING: MainWindow::importLayer: no current pane" << std::endl;
-    return;
+	// shouldn't happen, as the menu action should have been disabled
+	cerr << "WARNING: MainWindow::importLayer: no current pane" << endl;
+	return;
     }
 
     if (!getMainModel()) {
-    // shouldn't happen, as the menu action should have been disabled
-    std::cerr << "WARNING: MainWindow::importLayer: No main model -- hence no default sample rate available" << std::endl;
-    return;
+	// shouldn't happen, as the menu action should have been disabled
+	cerr << "WARNING: MainWindow::importLayer: No main model -- hence no default sample rate available" << endl;
+	return;
     }
 
     QString path = getOpenFileName(FileFinder::LayerFile);
 
     if (path != "") {

 {
     QObject *obj = sender();
     QAction *action = dynamic_cast<QAction *>(obj);
 
     if (!action) {
-    std::cerr << "WARNING: MainWindow::openRecentFile: sender is not an action"
-          << std::endl;
-    return;
+	cerr << "WARNING: MainWindow::openRecentFile: sender is not an action"
+		  << endl;
+	return;
     }
 
     QString path = action->text();
     if (path == "") return;
 

 {
     QObject *s = sender();
     QAction *action = qobject_cast<QAction *>(s);
 
     if (!action) {
-    std::cerr << "WARNING: MainWindow::applyTemplate: sender is not an action"
-          << std::endl;
-    return;
+	cerr << "WARNING: MainWindow::applyTemplate: sender is not an action"
+		  << endl;
+	return;
     }
 
     QString n = action->objectName();
     if (n == "") n = action->text();
 
     if (n == "") {
-        std::cerr << "WARNING: MainWindow::applyTemplate: sender has no name"
-                  << std::endl;
+        cerr << "WARNING: MainWindow::applyTemplate: sender has no name"
+                  << endl;
         return;
     }
 
     QString mainModelLocation;
     WaveFileModel *mm = getMainModel();

 }
 
 void
 MainWindow::closeEvent(QCloseEvent *e)
 {
-//    std::cerr << "MainWindow::closeEvent" << std::endl;
+//    cerr << "MainWindow::closeEvent" << endl;
 
     if (m_openingAudioFile) {
-//        std::cerr << "Busy - ignoring close event" << std::endl;
-    e->ignore();
-    return;
+//        cerr << "Busy - ignoring close event" << endl;
+	e->ignore();
+	return;
     }
 
     if (!m_abandoning && !checkSaveModified()) {
-//        std::cerr << "Close refused by user - ignoring close event" << endl;
-    e->ignore();
-    return;
+//        cerr << "Close refused by user - ignoring close event" << endl;
+	e->ignore();
+	return;
     }
 
     QSettings settings;
     settings.beginGroup("MainWindow");
     settings.setValue("maximised", isMaximized());

 {
     QObject *s = sender();
     QAction *action = dynamic_cast<QAction *>(s);
 
     if (!action) {
-    std::cerr << "WARNING: MainWindow::addPane: sender is not an action"
-          << std::endl;
-    return;
+	cerr << "WARNING: MainWindow::addPane: sender is not an action"
+		  << endl;
+	return;
     }
 
     PaneActionMap::iterator i = m_paneActions.find(action);
 
     if (i == m_paneActions.end()) {
-    std::cerr << "WARNING: MainWindow::addPane: unknown action "
-          << action->objectName() << std::endl;
-    return;
+	cerr << "WARNING: MainWindow::addPane: unknown action "
+		  << action->objectName() << endl;
+	return;
     }
 
     addPane(i->second, action->text());
 }
 

     }
 
     if (configuration.layer != LayerFactory::TimeRuler &&
         configuration.layer != LayerFactory::Spectrum) {
 
-    if (!m_timeRulerLayer) {
-//	    std::cerr << "no time ruler layer, creating one" << std::endl;
-        m_timeRulerLayer = m_document->createMainModelLayer
-        (LayerFactory::TimeRuler);
-    }
+	if (!m_timeRulerLayer) {
+//	    cerr << "no time ruler layer, creating one" << endl;
+	    m_timeRulerLayer = m_document->createMainModelLayer
+		(LayerFactory::TimeRuler);
+	}
 
 //	SVDEBUG << "adding time ruler layer " << m_timeRulerLayer << endl;
 
-    m_document->addLayerToView(pane, m_timeRulerLayer);
+        m_document->addLayerToView(pane, m_timeRulerLayer);
     }
 
     Layer *newLayer = m_document->createLayer(configuration.layer);
 
     Model *suggestedModel = configuration.sourceModel;

                 break;
             }
         }
 
         if (!model) {
-            std::cerr << "WARNING: Model " << (void *)suggestedModel
+            cerr << "WARNING: Model " << (void *)suggestedModel
                       << " appears in pane action map, but is not reported "
-                      << "by document as a valid transform source" << std::endl;
+                      << "by document as a valid transform source" << endl;
         }
     }
 
     if (!model) {
         model = m_document->getMainModel();

 {
     QObject *s = sender();
     QAction *action = dynamic_cast<QAction *>(s);
 
     if (!action) {
-    std::cerr << "WARNING: MainWindow::addLayer: sender is not an action"
-          << std::endl;
-    return;
+	cerr << "WARNING: MainWindow::addLayer: sender is not an action"
+		  << endl;
+	return;
     }
 
     Pane *pane = m_paneStack->getCurrentPane();
 
     if (!pane) {
-    std::cerr << "WARNING: MainWindow::addLayer: no current pane" << std::endl;
-    return;
+	cerr << "WARNING: MainWindow::addLayer: no current pane" << endl;
+	return;
     }
 
     ExistingLayerActionMap::iterator ei = m_existingLayerActions.find(action);
 
     if (ei != m_existingLayerActions.end()) {

 
     TransformActionMap::iterator i = m_transformActions.find(action);
 
     if (i == m_transformActions.end()) {
 
-    LayerActionMap::iterator i = m_layerActions.find(action);
-
-    if (i == m_layerActions.end()) {
-        std::cerr << "WARNING: MainWindow::addLayer: unknown action "
-              << action->objectName() << std::endl;
-        return;
-    }
-
-    LayerFactory::LayerType type = i->second.layer;
-
-    LayerFactory::LayerTypeSet emptyTypes =
-        LayerFactory::getInstance()->getValidEmptyLayerTypes();
-
-    Layer *newLayer = 0;
-
-    if (emptyTypes.find(type) != emptyTypes.end()) {
-
-        newLayer = m_document->createEmptyLayer(type);
+	LayerActionMap::iterator i = m_layerActions.find(action);
+	
+	if (i == m_layerActions.end()) {
+	    cerr << "WARNING: MainWindow::addLayer: unknown action "
+		      << action->objectName() << endl;
+	    return;
+	}
+
+	LayerFactory::LayerType type = i->second.layer;
+	
+	LayerFactory::LayerTypeSet emptyTypes =
+	    LayerFactory::getInstance()->getValidEmptyLayerTypes();
+
+	Layer *newLayer = 0;
+
+	if (emptyTypes.find(type) != emptyTypes.end()) {
+
+	    newLayer = m_document->createEmptyLayer(type);
+
             if (newLayer) {
                 m_toolActions[ViewManager::DrawMode]->trigger();
             }
 
-    } else {
+        } else {
 
             Model *model = i->second.sourceModel;
 
             cerr << "model = "<< model << endl;
 

                 newLayer = m_document->createLayer(type);
                 if (m_document->isKnownModel(model)) {
                     m_document->setChannel(newLayer, i->second.channel);
                     m_document->setModel(newLayer, model);
                 } else {
-                    std::cerr << "WARNING: MainWindow::addLayer: unknown model "
+                    cerr << "WARNING: MainWindow::addLayer: unknown model "
                               << model
                               << " (\""
-                              << (model ? model->objectName().toStdString() : "")
+                              << (model ? model->objectName() : "")
                               << "\") in layer action map"
-                              << std::endl;
+                              << endl;
                 }
             }
         }
 
         if (newLayer) {

 void
 MainWindow:: addLayer(QString transformId)
 {
     Pane *pane = m_paneStack->getCurrentPane();
     if (!pane) {
-    std::cerr << "WARNING: MainWindow::addLayer: no current pane" << std::endl;
-    return;
+	cerr << "WARNING: MainWindow::addLayer: no current pane" << endl;
+	return;
     }
 
     Transform transform = TransformFactory::getInstance()->
         getDefaultTransformFor(transformId);
 

     PlaySpeedRangeMapper mapper(0, 200);
 
     float percent = m_playSpeed->mappedValue();
     float factor = mapper.getFactorForValue(percent);
 
-//    std::cerr << "speed = " << position << " percent = " << percent << " factor = " << factor << std::endl;
+//    cerr << "speed = " << position << " percent = " << percent << " factor = " << factor << endl;
 
     bool something = (position != 100);
 
     int pc = lrintf(percent);
 

     QSettings settings;
     settings.beginGroup("NewerVersionWarning");
     QString tag = QString("version-%1-available-show").arg(version);
     if (settings.value(tag, true).toBool()) {
         QString title(tr("Newer version available"));
-        QString text(tr("<h3>Newer version available</h3><p>You are using version %1 of Sonic Visualiser, but version %3 is now available.</p><p>Please see the <a href=\"http://sonicvisualiser.org/\">Sonic Visualiser website</a> for more information.</p>").arg(SV_VERSION).arg(version));
+        QString text(tr("<h3>Newer version available</h3><p>You are using version %1 of Sonic Visualiser, but version %2 is now available.</p><p>Please see the <a href=\"http://sonicvisualiser.org/\">Sonic Visualiser website</a> for more information.</p>").arg(SV_VERSION).arg(version));
         QMessageBox::information(this, title, text);
         settings.setValue(tag, false);
     }
     settings.endGroup();
 }