comparison main/MainWindow.cpp @ 665:17fe7e0c23a1

Drop std:: from cerr, cout, endl; drop toStdString etc; build fix

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

     newSession();
 
     connect(m_midiInput, SIGNAL(eventsAvailable()),
             this, SLOT(midiEventsAvailable()));
 
-    NetworkPermissionTester tester(this);
+    NetworkPermissionTester tester;
     bool networkPermission = tester.havePermission();
     if (networkPermission) {
         TransformFactory::getInstance()->startPopulationThread();
         m_surveyer = new Surveyer
             ("sonicvisualiser.org", "survey23-present.txt", "survey23.php");

     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

 	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;
+//		cerr << "found duplicate layer " << layer << endl;
 		continue;
 	    }
 
-//	    std::cerr << "found new layer " << layer << " (name = " 
-//		      << layer->getLayerPresentationName() << ")" << std::endl;
+//	    cerr << "found new layer " << layer << " (name = " 
+//		      << layer->getLayerPresentationName() << ")" << endl;
 
 	    orderedLayers.push_back(layer);
 	    observedLayers.insert(layer);
 
             if (factory->isLayerSliceable(layer)) {

                 (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];
             }
         }

 {
     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;
+	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;
+	cerr << "WARNING: MainWindow::importLayer: No main model -- hence no default sample rate available" << endl;
 	return;
     }
 
     QString path = getOpenFileName(FileFinder::LayerFile);
 

 {
     QObject *obj = sender();
     QAction *action = dynamic_cast<QAction *>(obj);
     
     if (!action) {
-	std::cerr << "WARNING: MainWindow::openRecentFile: sender is not an action"
-		  << std::endl;
+	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;
+	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;
+//        cerr << "Busy - ignoring close event" << endl;
 	e->ignore();
 	return;
     }
 
     if (!m_abandoning && !checkSaveModified()) {
-//        std::cerr << "Close refused by user - ignoring close event" << endl;
+//        cerr << "Close refused by user - ignoring close event" << endl;
 	e->ignore();
 	return;
     }
 
     QSettings settings;

 {
     QObject *s = sender();
     QAction *action = dynamic_cast<QAction *>(s);
     
     if (!action) {
-	std::cerr << "WARNING: MainWindow::addPane: sender is not an action"
-		  << std::endl;
+	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;
+	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;
+//	    cerr << "no time ruler layer, creating one" << endl;
 	    m_timeRulerLayer = m_document->createMainModelLayer
 		(LayerFactory::TimeRuler);
 	}
 
 //	SVDEBUG << "adding time ruler layer " << m_timeRulerLayer << endl;

                 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;
+	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;
+	cerr << "WARNING: MainWindow::addLayer: no current pane" << endl;
 	return;
     }
 
     ExistingLayerActionMap::iterator ei = m_existingLayerActions.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;
+	    cerr << "WARNING: MainWindow::addLayer: unknown action "
+		      << action->objectName() << endl;
 	    return;
 	}
 
 	LayerFactory::LayerType type = i->second.layer;
 	

                 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;
+	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);