comparison main/MainWindow.cpp @ 2093:6e3ef3aa341e spectrogramparam

Ensure that operations that need to iterate through action maps in order (most pointedly MainWindow::updateLayerShortcutsFor) get to do it in order of construction and not arbitrary pointer order. Fixes incorrect shortcut associations for add-layer/pane shortcuts in some cases

     menu->addSeparator();
 
     QMenu *numberingMenu = menu->addMenu(tr("Number New Instants with"));
     numberingMenu->setTearOffEnabled(true);
     QActionGroup *numberingGroup = new QActionGroup(this);
+    m_numberingActions.clear();
 
     Labeller::TypeNameMap types = m_labeller->getTypeNames();
     for (Labeller::TypeNameMap::iterator i = types.begin(); i != types.end(); ++i) {
 
         if (i->first == Labeller::ValueFromLabel ||

         connect(action, SIGNAL(triggered()), this, SLOT(setInstantsNumbering()));
         action->setCheckable(true);
         action->setChecked(m_labeller->getType() == i->first);
         numberingGroup->addAction(action);
         numberingMenu->addAction(action);
-        m_numberingActions[action] = (int)i->first;
+        m_numberingActions.push_back({ action, (int)i->first });
 
         if (i->first == Labeller::ValueFromTwoLevelCounter) {
 
             QMenu *cycleMenu = numberingMenu->addMenu(tr("Cycle size"));
             QActionGroup *cycleGroup = new QActionGroup(this);

 
     IconLoader il;
 
     m_keyReference->setCategory(tr("Managing Panes and Layers"));
 
+    m_paneActions.clear();
+    m_layerActions.clear();
+    
     QAction *action = new QAction(il.load("pane"), tr("Add &New Pane"), this);
     action->setShortcut(tr("N"));
     action->setStatusTip(tr("Add a new pane containing only a time ruler"));
     connect(action, SIGNAL(triggered()), this, SLOT(addPane()));
     connect(this, SIGNAL(canAddPane(bool)), action, SLOT(setEnabled(bool)));
-    m_paneActions[action] = LayerConfiguration(LayerFactory::TimeRuler);
+    m_paneActions.push_back({ action, LayerConfiguration(LayerFactory::TimeRuler) });
     m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     menu->addSeparator();
 

             m_keyReference->registerShortcut(action);
         }
 
         connect(action, SIGNAL(triggered()), this, SLOT(addLayer()));
         connect(this, SIGNAL(canAddLayer(bool)), action, SLOT(setEnabled(bool)));
-        m_layerActions[action] = LayerConfiguration(type);
+        m_layerActions.push_back({ action, LayerConfiguration(type) });
         menu->addAction(action);
         m_rightButtonLayerMenu->addAction(action);
     }
     
     m_rightButtonLayerMenu->addSeparator();

                         if (menuType == paneMenuType) {
                             connect(action, SIGNAL(triggered()),
                                     this, SLOT(addPane()));
                             connect(this, SIGNAL(canAddPane(bool)),
                                     action, SLOT(setEnabled(bool)));
-                            m_paneActions[action] =
-                                LayerConfiguration(type, model);
+                            m_paneActions.push_back
+                                ({ action, LayerConfiguration(type, model) });
                         } else {
                             connect(action, SIGNAL(triggered()),
                                     this, SLOT(addLayer()));
                             connect(this, SIGNAL(canAddLayer(bool)),
                                     action, SLOT(setEnabled(bool)));
-                            m_layerActions[action] =
-                                LayerConfiguration(type, model);
+                            m_layerActions.push_back
+                                ({ action, LayerConfiguration(type, model) });
                         }
                         if (shortcutText != "") {
                             m_keyReference->registerShortcut(action);
                         }
                         menu->addAction(action);

                         }
 
                         if (isDefault) {
                             action = new QAction(icon, actionText, this);
                             if (!model || model == getMainModel()) {
+                                // Default for the shortcut is to
+                                // attach to an action that uses the
+                                // main model as input. But this may
+                                // change when the user selects a
+                                // different pane - see
+                                // updateLayerShortcutsFor() below.
                                 action->setShortcut(shortcutText); 
                             }
                         } else {
                             action = new QAction(actionText, this);
                         }

                         if (menuType == paneMenuType) {
                             connect(action, SIGNAL(triggered()),
                                     this, SLOT(addPane()));
                             connect(this, SIGNAL(canAddPane(bool)),
                                     action, SLOT(setEnabled(bool)));
-                            m_paneActions[action] =
-                                LayerConfiguration(type, model, c - 1);
+                            m_paneActions.push_back
+                                ({ action, LayerConfiguration(type, model, c - 1) });
                         } else {
                             connect(action, SIGNAL(triggered()),
                                     this, SLOT(addLayer()));
                             connect(this, SIGNAL(canAddLayer(bool)),
                                     action, SLOT(setEnabled(bool)));
-                            m_layerActions[action] =
-                                LayerConfiguration(type, model, c - 1);
+                            m_layerActions.push_back
+                                ({ action, LayerConfiguration(type, model, c - 1) });
                         }
 
                         submenu->addAction(action);
                     }
 

                         action->setStatusTip(tipText);
                         connect(action, SIGNAL(triggered()),
                                 this, SLOT(addLayer()));
                         connect(this, SIGNAL(canAddLayer(bool)),
                                 action, SLOT(setEnabled(bool)));
-                        m_layerActions[action] = LayerConfiguration(type, 0, 0);
+                        m_layerActions.push_back
+                            ({ action, LayerConfiguration(type, 0, 0) });
                         m_rightButtonLayerMenu->addAction(action);
                     }
                 }
             }
         }

 
     action = new QAction(il.load("timeruler"), tr("Add &Time Ruler"), this);
     action->setStatusTip(tr("Add a new layer showing a time ruler"));
     connect(action, SIGNAL(triggered()), this, SLOT(addLayer()));
     connect(this, SIGNAL(canAddLayer(bool)), action, SLOT(setEnabled(bool)));
-    m_layerActions[action] = LayerConfiguration(LayerFactory::TimeRuler);
+    m_layerActions.push_back({ action, LayerConfiguration(LayerFactory::TimeRuler) });
     menu->addAction(action);
 
     menu->addSeparator();
 
     m_existingLayersMenu = menu->addMenu(tr("Add &Existing Layer"));

 }
 
 void
 MainWindow::updateLayerShortcutsFor(Model *model)
 {
+    // Called when e.g. the current pane has changed, to ensure the
+    // various layer shortcuts select an action whose input model is
+    // the active one in this pane
+    
     set<LayerFactory::LayerType> seen;
     
     for (auto &a : m_paneActions) {
         if (!a.second.sourceModel) continue; // empty pane/layer shortcut
         auto type = a.second.layer;

         } else {
             seenNames.insert(name);
         }
     }
 
+    m_transformActions.clear();
+    m_transformActionsReverse.clear();
+    
     for (int i = 0; in_range_for(transforms, i); ++i) {
         
         QString name = transforms[i].name;
         if (name == "") name = transforms[i].identifier;
 

                 .arg(output);
         }
 
         QAction *action = new QAction(tr("%1...").arg(name), this);
         connect(action, SIGNAL(triggered()), this, SLOT(addLayer()));
-        m_transformActions[action] = transforms[i].identifier;
+        m_transformActions.push_back({ action, transforms[i].identifier });
         m_transformActionsReverse[transforms[i].identifier] = action;
         connect(this, SIGNAL(canAddLayer(bool)), action, SLOT(setEnabled(bool)));
 
         action->setStatusTip(transforms[i].longDescription);
 

             makerMenus[type][maker]->addAction(action);
         }
 
         action = new QAction(tr("%1...").arg(output == "" ? pluginName : output), this);
         connect(action, SIGNAL(triggered()), this, SLOT(addLayer()));
-        m_transformActions[action] = transforms[i].identifier;
+        m_transformActions.push_back({ action, transforms[i].identifier });
         connect(this, SIGNAL(canAddLayer(bool)), action, SLOT(setEnabled(bool)));
         action->setStatusTip(transforms[i].longDescription);
 
 //        cerr << "Transform: \"" << name << "\": plugin name \"" << pluginName << "\"" << endl;
 

                              (factory->getLayerType(layer)));
 
         QAction *action = new QAction(icon, name, this);
         connect(action, SIGNAL(triggered()), this, SLOT(addLayer()));
         connect(this, SIGNAL(canAddLayer(bool)), action, SLOT(setEnabled(bool)));
-        m_existingLayerActions[action] = layer;
+        m_existingLayerActions.push_back({ action, layer });
 
         m_existingLayersMenu->addAction(action);
 
         if (sliceableLayers.find(layer) != sliceableLayers.end()) {
             action = new QAction(icon, name, this);
             connect(action, SIGNAL(triggered()), this, SLOT(addLayer()));
             connect(this, SIGNAL(canAddLayer(bool)), action, SLOT(setEnabled(bool)));
-            m_sliceActions[action] = layer;
+            m_sliceActions.push_back({ action, layer });
             m_sliceMenu->addAction(action);
         }
     }
 
     m_sliceMenu->setEnabled(!m_sliceActions.empty());

     toolbar = addToolBar(tr("Edit Toolbar"));
     CommandHistory::getInstance()->registerToolbar(toolbar);
 
     toolbar = addToolBar(tr("Tools Toolbar"));
     QActionGroup *group = new QActionGroup(this);
-
+    m_toolActions.clear();
+    
     m_keyReference->setCategory(tr("Tool Selection"));
-    QAction *action = toolbar->addAction(il.load("navigate"),
-                                         tr("Navigate"));
+    QAction *action = toolbar->addAction(il.load("navigate"), tr("Navigate"));
     action->setCheckable(true);
     action->setChecked(true);
     action->setShortcut(tr("1"));
     action->setStatusTip(tr("Navigate"));
     connect(action, SIGNAL(triggered()), this, SLOT(toolNavigateSelected()));
     connect(this, SIGNAL(replacedDocument()), action, SLOT(trigger()));
     group->addAction(action);
     m_keyReference->registerShortcut(action);
-    m_toolActions[ViewManager::NavigateMode] = action;
+    m_toolActions.push_back({ ViewManager::NavigateMode, action });
     
     m_keyReference->setCategory
         (tr("Navigate Tool Mouse Actions"));
     m_keyReference->registerShortcut
         (tr("Navigate"), tr("Left"), 

     m_keyReference->registerShortcut
         (tr("Edit"), tr("Double-Click Left"), 
          tr("Double-click left button on an item to edit it"));
 
     m_keyReference->setCategory(tr("Tool Selection"));
-    action = toolbar->addAction(il.load("select"),
-                                tr("Select"));
+    action = toolbar->addAction(il.load("select"), tr("Select"));
     action->setCheckable(true);
     action->setShortcut(tr("2"));
     action->setStatusTip(tr("Select ranges"));
     connect(action, SIGNAL(triggered()), this, SLOT(toolSelectSelected()));
     group->addAction(action);
     m_keyReference->registerShortcut(action);
-    m_toolActions[ViewManager::SelectMode] = action;
+    m_toolActions.push_back({ ViewManager::SelectMode, action });
         
     m_keyReference->setCategory
         (tr("Select Tool Mouse Actions"));
     m_keyReference->registerShortcut
         (tr("Select"), tr("Left"), 

     m_keyReference->registerShortcut
         (tr("Fine Select"), tr("Shift+Left"), 
         tr("Shift-click left button and drag to select without snapping to items or grid"));
 
     m_keyReference->setCategory(tr("Tool Selection"));
-    action = toolbar->addAction(il.load("move"),
-                                tr("Edit"));
+    action = toolbar->addAction(il.load("move"), tr("Edit"));
     action->setCheckable(true);
     action->setShortcut(tr("3"));
     action->setStatusTip(tr("Edit items in layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(toolEditSelected()));
     connect(this, SIGNAL(canEditLayer(bool)), action, SLOT(setEnabled(bool)));
     group->addAction(action);
     m_keyReference->registerShortcut(action);
-    m_toolActions[ViewManager::EditMode] = action;
+    m_toolActions.push_back({ ViewManager::EditMode, action });
     
     m_keyReference->setCategory
         (tr("Edit Tool Mouse Actions"));
     m_keyReference->registerShortcut
         (tr("Move"), tr("Left"), 

     m_keyReference->registerShortcut
         (tr("Edit"), tr("Double-Click Left"), 
         tr("Double-click left button on an item to edit it"));
 
     m_keyReference->setCategory(tr("Tool Selection"));
-    action = toolbar->addAction(il.load("draw"),
-                                tr("Draw"));
+    action = toolbar->addAction(il.load("draw"), tr("Draw"));
     action->setCheckable(true);
     action->setShortcut(tr("4"));
     action->setStatusTip(tr("Draw new items in layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(toolDrawSelected()));
     connect(this, SIGNAL(canEditLayer(bool)), action, SLOT(setEnabled(bool)));
     group->addAction(action);
     m_keyReference->registerShortcut(action);
-    m_toolActions[ViewManager::DrawMode] = action;
+    m_toolActions.push_back({ ViewManager::DrawMode, action });
 
     m_keyReference->setCategory
         (tr("Draw Tool Mouse Actions"));
     m_keyReference->registerShortcut
         (tr("Draw"), tr("Left"), 
         tr("Click left button and drag to create new item"));
 
     m_keyReference->setCategory(tr("Tool Selection"));
-    action = toolbar->addAction(il.load("erase"),
-                                tr("Erase"));
+    action = toolbar->addAction(il.load("erase"), tr("Erase"));
     action->setCheckable(true);
     action->setShortcut(tr("5"));
     action->setStatusTip(tr("Erase items from layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(toolEraseSelected()));
     connect(this, SIGNAL(canEditLayer(bool)), action, SLOT(setEnabled(bool)));
     group->addAction(action);
     m_keyReference->registerShortcut(action);
-    m_toolActions[ViewManager::EraseMode] = action;
+    m_toolActions.push_back({ ViewManager::EraseMode, action });
 
     m_keyReference->setCategory
         (tr("Erase Tool Mouse Actions"));
     m_keyReference->registerShortcut
         (tr("Erase"), tr("Left"), 

     action->setStatusTip(tr("Make measurements in layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(toolMeasureSelected()));
     connect(this, SIGNAL(canMeasureLayer(bool)), action, SLOT(setEnabled(bool)));
     group->addAction(action);
     m_keyReference->registerShortcut(action);
-    m_toolActions[ViewManager::MeasureMode] = action;
+    m_toolActions.push_back({ ViewManager::MeasureMode, action });
 
     m_keyReference->setCategory
         (tr("Measure Tool Mouse Actions"));
     m_keyReference->registerShortcut
         (tr("Measure Area"), tr("Left"), 

         cerr << "WARNING: MainWindow::addPane: sender is not an action"
                   << endl;
         return;
     }
 
-    PaneActionMap::iterator i = m_paneActions.find(action);
+    PaneActions::iterator i = m_paneActions.begin();
+    while (i != m_paneActions.end()) {
+        if (i->first == action) break;
+        ++i;
+    }
 
     if (i == m_paneActions.end()) {
         cerr << "WARNING: MainWindow::addPane: unknown action "
-                  << action->objectName() << endl;
+             << action->objectName() << endl;
         cerr << "known actions are:" << endl;
-        for (PaneActionMap::const_iterator i = m_paneActions.begin();
+        for (PaneActions::const_iterator i = m_paneActions.begin();
              i != m_paneActions.end(); ++i) {
             cerr << i->first << ", name " << i->first->text() << endl;
         }
         return;
     }

     if (!pane) {
         cerr << "WARNING: MainWindow::addLayer: no current pane" << endl;
         return;
     }
 
-    ExistingLayerActionMap::iterator ei = m_existingLayerActions.find(action);
+    ExistingLayerActions::iterator ei = m_existingLayerActions.begin();
+    while (ei != m_existingLayerActions.end()) {
+        if (ei->first == action) break;
+        ++ei;
+    }
 
     if (ei != m_existingLayerActions.end()) {
         Layer *newLayer = ei->second;
         m_document->addLayerToView(pane, newLayer);
         m_paneStack->setCurrentLayer(pane, newLayer);
         return;
     }
 
-    ei = m_sliceActions.find(action);
+    ei = m_sliceActions.begin();
+    while (ei != m_sliceActions.end()) {
+        if (ei->first == action) break;
+        ++ei;
+    }
 
     if (ei != m_sliceActions.end()) {
         Layer *newLayer = m_document->createLayer(LayerFactory::Slice);
 //        document->setModel(newLayer, ei->second->getModel());
         SliceableLayer *source = dynamic_cast<SliceableLayer *>(ei->second);

         m_document->addLayerToView(pane, newLayer);
         m_paneStack->setCurrentLayer(pane, newLayer);
         return;
     }
 
-    TransformActionMap::iterator i = m_transformActions.find(action);
+    TransformActions::iterator i = m_transformActions.begin();
+    while (i != m_transformActions.end()) {
+        if (i->first == action) break;
+        ++i;
+    }
 
     if (i == m_transformActions.end()) {
 
-        LayerActionMap::iterator i = m_layerActions.find(action);
+        LayerActions::iterator i = m_layerActions.begin();
+        while (i != m_layerActions.end()) {
+            if (i->first == action) break;
+            ++i;
+        }
         
         if (i == m_layerActions.end()) {
             cerr << "WARNING: MainWindow::addLayer: unknown action "
                       << action->objectName() << endl;
             return;

 
         if (emptyTypes.find(type) != emptyTypes.end()) {
 
             newLayer = m_document->createEmptyLayer(type);
             if (newLayer) {
-                m_toolActions[ViewManager::DrawMode]->trigger();
+                for (auto &a : m_toolActions) {
+                    if (a.first == ViewManager::DrawMode) {
+                        a.second->trigger();
+                        break;
+                    }
+                }
             }
 
         } else {
 
             Model *model = i->second.sourceModel;

 MainWindow::setInstantsNumbering()
 {
     QAction *a = dynamic_cast<QAction *>(sender());
     if (!a) return;
 
-    int type = m_numberingActions[a];
+    int type = 0;
+    for (auto &ai : m_numberingActions) {
+        if (ai.first == a) type = ai.second;
+    }
     
     if (m_labeller) m_labeller->setType(Labeller::ValueType(type));
 
     QSettings settings;
     settings.beginGroup("MainWindow");