comparison main/MainWindow.cpp @ 2550:a004f981f6f5 startup-timing

Some work to try to get the main window up & functioning quicker - without waiting for the transforms to be populated first. Needs a lot more testing, not to be merged until after 4.1.

     m_preferencesDialog(nullptr),
     m_layerTreeDialog(nullptr),
     m_activityLog(new ActivityLog()),
     m_unitConverter(new UnitConverter()),
     m_keyReference(new KeyReference()),
-    m_templateWatcher(nullptr)
+    m_templateWatcher(nullptr),
+    m_transformPopulater(nullptr)
 {
     Profiler profiler("MainWindow::MainWindow");
 
     SVDEBUG << "MainWindow: " << getReleaseText() << endl;
 

     SVDEBUG << "MainWindow: Creating network permission tester" << endl;
 
     NetworkPermissionTester tester(withOSCSupport);
     bool networkPermission = tester.havePermission();
     if (networkPermission) {
-        SVDEBUG << "MainWindow: Starting transform population thread" << endl;
+        SVDEBUG << "MainWindow: Starting uninstalled-transform population thread" << endl;
         TransformFactory::getInstance()->startPopulationThread();
 
         m_surveyer = nullptr;
 
 #ifdef WITH_FEEDBACK_REQUEST

         SVDEBUG << "MainWindow: Creating internal-only OSC queue without port"
                 << endl;
         startOSCQueue(false);
     }
     
-    QTimer::singleShot(500, this, SLOT(betaReleaseWarning()));
-    
-    QString warning = PluginScan::getInstance()->getStartupFailureReport();
-    if (warning != "") {
-        QTimer::singleShot(500, this, SLOT(pluginPopulationWarning()));
-    }
-
+//    QTimer::singleShot(500, this, SLOT(betaReleaseWarning()));
+    
     SVDEBUG << "MainWindow: Constructor done" << endl;
 }
 
 MainWindow::~MainWindow()
 {
 //    SVDEBUG << "MainWindow::~MainWindow" << endl;
+
+    if (m_transformPopulater) {
+        m_transformPopulater->wait();
+        delete m_transformPopulater;
+    }
+    
     delete m_keyReference;
     delete m_activityLog;
     delete m_unitConverter;
     delete m_preferencesDialog;
     delete m_layerTreeDialog;

 }
 
 void
 MainWindow::setupMenus()
 {
+    SVDEBUG << "MainWindow::setupMenus" << endl;
+    
     if (!m_mainMenusCreated) {
 
 #ifdef Q_OS_LINUX
         // In Ubuntu 14.04 the window's menu bar goes missing entirely
         // if the user is running any desktop environment other than Unity

 
     setupFileMenu();
     setupEditMenu();
     setupViewMenu();
     setupPaneAndLayerMenus();
-    setupTransformsMenu();
+    prepareTransformsMenu();
 
     m_mainMenusCreated = true;
+
+    SVDEBUG << "MainWindow::setupMenus: done" << endl;
 }
 
 void
 MainWindow::goFullScreen()
 {

 }
 
 void
 MainWindow::setupFileMenu()
 {
+    SVDEBUG << "MainWindow::setupFileMenu" << endl;
+    
     if (m_mainMenusCreated) return;
 
     QMenu *menu = menuBar()->addMenu(tr("&File"));
     menu->setTearOffEnabled(true);
     QToolBar *toolbar = addToolBar(tr("File Toolbar"));

     action->setStatusTip(tr("Adjust the application preferences"));
     connect(action, SIGNAL(triggered()), this, SLOT(preferences()));
     menu->addAction(action);
         
     menu->addSeparator();
-    action = new QAction(il.load("exit"),
-                         tr("&Quit"), this);
+    action = new QAction(il.load("exit"), tr("&Quit"), this);
     action->setShortcut(tr("Ctrl+Q"));
     action->setStatusTip(tr("Exit %1").arg(QApplication::applicationName()));
     connect(action, SIGNAL(triggered()), qApp, SLOT(closeAllWindows()));
     m_keyReference->registerShortcut(action);
     menu->addAction(action);
 }
 
 void
 MainWindow::setupEditMenu()
 {
+    SVDEBUG << "MainWindow::setupEditMenu" << endl;
+    
     if (m_mainMenusCreated) return;
 
     QMenu *menu = menuBar()->addMenu(tr("&Edit"));
     menu->setTearOffEnabled(true);
     CommandHistory::getInstance()->registerMenu(menu);

 }
 
 void
 MainWindow::setupViewMenu()
 {
+    SVDEBUG << "MainWindow::setupViewMenu" << endl;
+    
     if (m_mainMenusCreated) return;
 
     IconLoader il;
 
     QAction *action = nullptr;

 }
 
 void
 MainWindow::setupPaneAndLayerMenus()
 {
+    SVDEBUG << "MainWindow::setupPaneAndLayerMenus" << endl;
+    
     Profiler profiler("MainWindow::setupPaneAndLayerMenus");
     
     if (m_paneMenu) {
         m_paneMenu->clear();
         for (auto a: m_paneActions) {

         }
     }
 }
 
 void
-MainWindow::setupTransformsMenu()
-{
+MainWindow::prepareTransformsMenu()
+{
+    SVDEBUG << "MainWindow::prepareTransformsMenu" << endl;
+
+    if (m_transformsMenu) {
+        return;
+    }
+    
+    m_transformsMenu = menuBar()->addMenu(tr("&Transform")); 
+    m_transformsMenu->setTearOffEnabled(true);
+    m_transformsMenu->setSeparatorsCollapsible(true);
+
+    SVDEBUG << "MainWindow::prepareTransformsMenu: Starting installed-transform population thread" << endl;
+    m_transformPopulater = new TransformPopulater(this);
+    m_transformPopulater->start();
+}
+
+void
+MainWindow::TransformPopulater::run()
+{
+    usleep(200000);
+    
+    TransformFactory *tf = TransformFactory::getInstance();
+    if (!tf) return;
+
+    connect(tf, SIGNAL(transformsPopulated()),
+            m_mw, SLOT(populateTransformsMenu()));
+
+    SVDEBUG << "MainWindow::TransformPopulater::run: scanning" << endl;
+    
+    PluginScan::getInstance()->scan();
+
+    QString warning = PluginScan::getInstance()->getStartupFailureReport();
+    if (warning != "") {
+        QTimer::singleShot(500, m_mw, SLOT(pluginPopulationWarning()));
+    }
+
+    SVDEBUG << "MainWindow::TransformPopulater::run: populating" << endl;
+    
+    (void)tf->haveTransform({}); // populate!
+
+    SVDEBUG << "MainWindow::TransformPopulater::run: done" << endl;
+}
+
+void
+MainWindow::populateTransformsMenu()
+{
+    SVDEBUG << "MainWindow::populateTransformsMenu" << endl;
+
     if (m_transformsMenu) {
         m_transformsMenu->clear();
-        m_recentTransformsMenu->clear();
+        m_rightButtonTransformsMenu->clear();
         m_transformActionsReverse.clear();
         m_transformActions.clear();
         for (auto a: m_transformActions) {
             delete a.first;
         }

     m_keyReference->registerShortcut(action);
     m_transformsMenu->addAction(action);
     m_rightButtonTransformsMenu->addAction(action);
 
     setupRecentTransformsMenu();
+
+    updateMenuStates();
 }
 
 void
 MainWindow::setupHelpMenu()
 {
+    SVDEBUG << "MainWindow::setupHelpMenu" << endl;
+    
     QMenu *menu = menuBar()->addMenu(tr("&Help"));
     menu->setTearOffEnabled(true);
     
     m_keyReference->setCategory(tr("Help"));
 

 }
 
 void
 MainWindow::setupRecentFilesMenu()
 {
+    SVDEBUG << "MainWindow::setupRecentFilesMenu" << endl;
+    
     m_recentFilesMenu->clear();
     vector<QString> files = m_recentFiles.getRecent();
     for (size_t i = 0; i < files.size(); ++i) {
         QString path = files[i];
         QAction *action = m_recentFilesMenu->addAction(path);

 }
 
 void
 MainWindow::setupTemplatesMenu()
 {
+    SVDEBUG << "MainWindow::setupTemplatesMenu" << endl;
+    
     m_templatesMenu->clear();
 
     QAction *defaultAction = m_templatesMenu->addAction(tr("Standard Waveform"));
     defaultAction->setObjectName("default");
     connect(defaultAction, SIGNAL(triggered()), this, SLOT(applyTemplate()));

 
 
 void
 MainWindow::setupRecentTransformsMenu()
 {
+    SVDEBUG << "MainWindow::setupRecentTransformsMenu" << endl;
+    
     m_recentTransformsMenu->clear();
     vector<QString> transforms = m_recentTransforms.getRecent();
     for (size_t i = 0; i < transforms.size(); ++i) {
         TransformActionReverseMap::iterator ti =
             m_transformActionsReverse.find(transforms[i]);

 }
 
 void
 MainWindow::setupExistingLayersMenus()
 {
+    SVDEBUG << "MainWindow::setupExistingLayersMenus" << endl;
+    
     if (!m_existingLayersMenu) return; // should have been created by setupMenus
 
 //    SVDEBUG << "MainWindow::setupExistingLayersMenu" << endl;
 
     Profiler profiler1("MainWindow::setupExistingLayersMenu");

 }
 
 void
 MainWindow::setupToolbars()
 {
+    SVDEBUG << "MainWindow::setupToolbars" << endl;
+    
     m_keyReference->setCategory(tr("Playback and Transport Controls"));
 
     IconLoader il;
 
     QMenu *menu = m_playbackMenu = menuBar()->addMenu(tr("Play&back"));

     connect(m_viewManager, SIGNAL(playSoloModeChanged(bool)),
             m_soloAction, SLOT(setChecked(bool)));
     connect(m_soloAction, SIGNAL(triggered()), this, SLOT(playSoloToggled()));
     connect(this, SIGNAL(canChangeSolo(bool)), m_soloAction, SLOT(setEnabled(bool)));
 
-    QAction *alAction = nullptr;
-    if (Document::canAlign()) {
-        alAction = toolbar->addAction(il.load("align"),
-                                      tr("Align File Timelines"));
-        alAction->setCheckable(true);
-        alAction->setChecked(m_viewManager->getAlignMode());
-        alAction->setStatusTip(tr("Treat multiple audio files as versions of the same work, and align their timelines"));
-        connect(m_viewManager, SIGNAL(alignModeChanged(bool)),
-                alAction, SLOT(setChecked(bool)));
-        connect(alAction, SIGNAL(triggered()), this, SLOT(alignToggled()));
-        connect(this, SIGNAL(canAlign(bool)), alAction, SLOT(setEnabled(bool)));
-    }
+    QAction *alAction = toolbar->addAction(il.load("align"),
+                                           tr("Align File Timelines"));
+    alAction->setCheckable(true);
+    alAction->setChecked(m_viewManager->getAlignMode());
+    alAction->setStatusTip(tr("Treat multiple audio files as versions of the same work, and align their timelines"));
+    alAction->setEnabled(false); // until canAlign emitted
+    connect(m_viewManager, SIGNAL(alignModeChanged(bool)),
+            alAction, SLOT(setChecked(bool)));
+    connect(alAction, SIGNAL(triggered()), this, SLOT(alignToggled()));
+    connect(this, SIGNAL(canAlign(bool)), alAction, SLOT(setEnabled(bool)));
 
     m_keyReference->registerShortcut(m_playAction);
     m_keyReference->registerShortcut(m_recordAction);
     m_keyReference->registerShortcut(m_playSelectionAction);
     m_keyReference->registerShortcut(m_playLoopAction);
     m_keyReference->registerShortcut(m_soloAction);
-    if (alAction) m_keyReference->registerShortcut(alAction);
+    m_keyReference->registerShortcut(alAction);
     m_keyReference->registerShortcut(m_rwdAction);
     m_keyReference->registerShortcut(m_ffwdAction);
     m_keyReference->registerShortcut(m_rwdSimilarAction);
     m_keyReference->registerShortcut(m_ffwdSimilarAction);
     m_keyReference->registerShortcut(m_rwdStartAction);

     menu->addAction(m_playAction);
     menu->addAction(m_recordAction);
     menu->addAction(m_playSelectionAction);
     menu->addAction(m_playLoopAction);
     menu->addAction(m_soloAction);
-    if (alAction) menu->addAction(alAction);
+    menu->addAction(alAction);
     menu->addSeparator();
     menu->addAction(m_rwdAction);
     menu->addAction(m_ffwdAction);
     menu->addSeparator();
     menu->addAction(m_rwdSimilarAction);

 }
 
 void
 MainWindow::updateMenuStates()
 {
+    SVDEBUG << "MainWindow::updateMenuStates" << endl;
+    
     MainWindowBase::updateMenuStates();
 
     Pane *currentPane = nullptr;
     Layer *currentLayer = nullptr;
 

         (haveCurrentLayer &&
          dynamic_cast<TimeValueLayer *>(currentLayer));
     
     bool alignMode = m_viewManager && m_viewManager->getAlignMode();
     emit canChangeSolo(havePlayTarget && !alignMode);
-    emit canAlign(havePlayTarget && m_document && m_document->canAlign());
+
+    if (TransformFactory::getInstance()->havePopulated()) {
+        emit canAlign(havePlayTarget && m_document && m_document->canAlign());
+    }
 
     emit canChangePlaybackSpeed(true);
     int v = m_playSpeed->value();
     emit canSpeedUpPlayback(v < m_playSpeed->maximum());
     emit canSlowDownPlayback(v > m_playSpeed->minimum());