comparison main/MainWindow.cpp @ 70:e269ae6ed008

* When adding a layer, make it the selected layer on that pane
* More OSC support, including transforms

 using std::vector;
 using std::map;
 using std::set;
 
 
-MainWindow::MainWindow(bool withAudioOutput) :
+MainWindow::MainWindow(bool withAudioOutput, bool withOSCSupport) :
     m_document(0),
     m_paneStack(0),
     m_viewManager(0),
     m_overview(0),
     m_timeRulerLayer(0),
     m_audioOutput(withAudioOutput),
     m_playSource(0),
     m_playTarget(0),
-    m_oscQueue(new OSCQueue()),
+    m_oscQueue(withOSCSupport ? new OSCQueue() : 0),
     m_recentFiles("RecentFiles"),
     m_recentTransforms("RecentTransforms", 20),
     m_mainMenusCreated(false),
     m_paneMenu(0),
     m_layerMenu(0),

     m_recentTransformsMenu(0),
     m_rightButtonMenu(0),
     m_rightButtonLayerMenu(0),
     m_rightButtonTransformsMenu(0),
     m_documentModified(false),
+    m_openingAudioFile(false),
+    m_abandoning(false),
     m_preferencesDialog(0)
 {
     setWindowTitle(tr("Sonic Visualiser"));
 
     UnitDatabase::getInstance()->registerUnit("Hz");

     connect(Preferences::getInstance(),
             SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
             this,
             SLOT(preferenceChanged(PropertyContainer::PropertyName)));
 
-    if (m_oscQueue->isOK()) {
+    if (m_oscQueue && m_oscQueue->isOK()) {
         connect(m_oscQueue, SIGNAL(messagesAvailable()), this, SLOT(pollOSC()));
         QTimer *oscTimer = new QTimer(this);
         connect(oscTimer, SIGNAL(timeout()), this, SLOT(pollOSC()));
         oscTimer->start(1000);
     }

     newSession();
 }
 
 MainWindow::~MainWindow()
 {
-    closeSession();
+    if (!m_abandoning) {
+        closeSession();
+    }
     delete m_playTarget;
     delete m_playSource;
     delete m_viewManager;
     delete m_oscQueue;
     Profiles::getInstance()->dump();

 	  QFileInfo(path).isFile() &&
 	  QFileInfo(path).isReadable())) {
 	return false;
     }
 
+    m_openingAudioFile = true;
+
     WaveFileModel *newModel = new WaveFileModel(path);
 
     if (!newModel->isOK()) {
 	delete newModel;
+        m_openingAudioFile = false;
 	return false;
     }
 
     bool setAsMain = true;
     static bool prevSetAsMain = true;

                  tr("You already have an audio waveform loaded.\nWhat would you like to do with the new audio file?"),
                  items, prevSetAsMain ? 0 : 1, &ok);
             
             if (!ok || item.isEmpty()) {
                 delete newModel;
+                m_openingAudioFile = false;
                 return false;
             }
             
             setAsMain = (item == items[0]);
             prevSetAsMain = setAsMain;

 	CommandHistory::getInstance()->endCompoundOperation();
     }
 
     updateMenuStates();
     m_recentFiles.addFile(path);
+    m_openingAudioFile = false;
 
     return true;
 }
 
 void

 }
 
 void
 MainWindow::closeEvent(QCloseEvent *e)
 {
-    if (!checkSaveModified()) {
+    if (!m_abandoning && !checkSaveModified()) {
 	e->ignore();
 	return;
     }
 
     QSettings settings;

 
     m_document->setChannel(newLayer, configuration.channel);
     m_document->addLayerToView(pane, newLayer);
 
     m_paneStack->setCurrentPane(pane);
+    m_paneStack->setCurrentLayer(pane, newLayer);
 
     CommandHistory::getInstance()->endCompoundOperation();
 
     updateMenuStates();
 }

 
     if (newLayer) {
         m_document->addLayerToView(pane, newLayer);
         m_document->setChannel(newLayer, context.channel);
         m_recentTransforms.add(transform);
+        m_paneStack->setCurrentLayer(pane, newLayer);
     }
 
     updateMenuStates();
 }
 

 }
 
 void
 MainWindow::pollOSC()
 {
-    if (m_oscQueue->isEmpty()) return;
+    if (!m_oscQueue || m_oscQueue->isEmpty()) return;
     std::cerr << "MainWindow::pollOSC: have " << m_oscQueue->getMessagesAvailable() << " messages" << std::endl;
+
+    if (m_openingAudioFile) return;
 
     OSCMessage message = m_oscQueue->readMessage();
 
     if (message.getTarget() != 0) {
         return; //!!! for now -- this class is target 0, others not handled yet

 }
 
 void
 MainWindow::handleOSCMessage(const OSCMessage &message)
 {
+    std::cerr << "MainWindow::handleOSCMessage: thread id = " 
+              << QThread::currentThreadId() << std::endl;
+
     // This large function should really be abstracted out.
 
     if (message.getMethod() == "open") {
 
         if (message.getArgCount() == 1 &&

 
         CommandHistory::getInstance()->redo();
 
     } else if (message.getMethod() == "set") {
 
-        if (message.getArgCount() >= 2 &&
+        if (message.getArgCount() == 2 &&
             message.getArg(0).canConvert(QVariant::String) &&
             message.getArg(1).canConvert(QVariant::Double)) {
 
             QString property = message.getArg(0).toString();
             float value = (float)message.getArg(1).toDouble();

                 } else if (value < 1.5) {
                     m_viewManager->setOverlayMode(ViewManager::BasicOverlays);
                 } else {
                     m_viewManager->setOverlayMode(ViewManager::AllOverlays);
                 }                    
+            } else if (property == "zoomwheels") {
+                m_viewManager->setZoomWheelsEnabled(value > 0.5);
+            }
+                
+        } else {
+            PropertyContainer *container = 0;
+            Pane *pane = m_paneStack->getCurrentPane();
+            if (pane &&
+                message.getArgCount() == 3 &&
+                message.getArg(0).canConvert(QVariant::String) &&
+                message.getArg(1).canConvert(QVariant::String) &&
+                message.getArg(2).canConvert(QVariant::String)) {
+                if (message.getArg(0).toString() == "pane") {
+                    container = pane->getPropertyContainer(0);
+                } else if (message.getArg(0).toString() == "layer") {
+                    container = pane->getSelectedLayer();
+                }
+            }
+            if (container) {
+                QString nameString = message.getArg(1).toString();
+                QString valueString = message.getArg(2).toString();
+                container->setPropertyWithCommand(nameString, valueString);
             }
         }
 
     } else if (message.getMethod() == "setcurrent") {
 

             }
         }
 
         if (paneIndex >= 0 && paneIndex < m_paneStack->getPaneCount()) {
             Pane *pane = m_paneStack->getPane(paneIndex);
+            m_paneStack->setCurrentPane(pane);
             if (layerIndex >= 0 && layerIndex < pane->getLayerCount()) {
                 Layer *layer = pane->getLayer(layerIndex);
                 m_paneStack->setCurrentLayer(pane, layer);
             } else if (wantLayer && layerIndex == -1) {
                 m_paneStack->setCurrentLayer(pane, 0);
-            } else {
-                m_paneStack->setCurrentPane(pane);
             }
         }
 
     } else if (message.getMethod() == "delete") {
 

             } else if (message.getArg(0).canConvert(QVariant::Double)) {
                 double level = message.getArg(0).toDouble();
                 Pane *currentPane = m_paneStack->getCurrentPane();
                 if (level < 1.0) level = 1.0;
                 if (currentPane) currentPane->setZoomLevel(lrint(level));
+            }
+        }
+
+    } else if (message.getMethod() == "quit") {
+        
+        m_abandoning = true;
+        close();
+
+    } else if (message.getMethod() == "resize") {
+        
+        if (message.getArgCount() == 2) {
+
+            int width = 0, height = 0;
+
+            if (message.getArg(1).canConvert(QVariant::Int)) {
+
+                height = message.getArg(1).toInt();
+
+                if (message.getArg(0).canConvert(QVariant::String) &&
+                    message.getArg(0).toString() == "pane") {
+
+                    Pane *pane = m_paneStack->getCurrentPane();
+                    if (pane) pane->resize(pane->width(), height);
+
+                } else if (message.getArg(0).canConvert(QVariant::Int)) {
+
+                    width = message.getArg(0).toInt();
+                    resize(width, height);
+                }
+            }
+        }
+
+    } else if (message.getMethod() == "transform") {
+
+        Pane *pane = m_paneStack->getCurrentPane();
+
+        if (getMainModel() &&
+            pane &&
+            message.getArgCount() == 1 &&
+            message.getArg(0).canConvert(QVariant::String)) {
+
+            TransformName transform = message.getArg(0).toString();
+
+            Layer *newLayer = m_document->createDerivedLayer
+                (transform,
+                 getMainModel(),
+                 PluginTransform::ExecutionContext(),
+                 "");
+
+            if (newLayer) {
+                m_document->addLayerToView(pane, newLayer);
+                m_recentTransforms.add(transform);
+                m_paneStack->setCurrentLayer(pane, newLayer);
             }
         }
 
     } else {
         std::cerr << "WARNING: MainWindow::handleOSCMessage: Unknown or unsupported "

 #endif
     aboutText += tr("<br>With LADSPA plugin support (API v%1) &copy; Richard Furse, Paul Davis, Stefan Westerfeld").arg(LADSPA_VERSION);
     aboutText += tr("<br>With DSSI plugin support (API v%1) &copy; Chris Cannam, Steve Harris, Sean Bolton").arg(DSSI_VERSION);
 #ifdef HAVE_LIBLO
     aboutText += tr("<br>With liblo Lite OSC library (v%1) &copy; Steve Harris").arg(LIBLO_VERSION);
-    if (m_oscQueue->isOK()) {
+    if (m_oscQueue && m_oscQueue->isOK()) {
         aboutText += tr("<p>The OSC URL for this instance is: \"%1\"").arg(m_oscQueue->getOSCURL());
     }
 #endif
     aboutText += "</p>";
 #endif