Finish moving state vars to macros

dcwhite · dcwhite · commit 4ddb6cb9b844 · 2021-05-07T11:55:21.000-06:00
diff --git a/src/Interface/Modules/Render/ViewScene.cc b/src/Interface/Modules/Render/ViewScene.cc
@@ -394,7 +394,7 @@ ViewSceneDialog::ViewSceneDialog(const std::string& name, ModuleStateHandle stat
   state->connectSpecificStateChanged(Parameters::GeomData,[this](){Q_EMIT newGeometryValueForwarder();});
   connect(this, SIGNAL(newGeometryValueForwarder()), this, SLOT(updateModifiedGeometriesAndSendScreenShot()));
 
-  state->connectSpecificStateChanged(Parameters::CameraRotation1,[this](){Q_EMIT cameraRotationChangeForwarder();});
+  state->connectSpecificStateChanged(Parameters::CameraRotation,[this](){Q_EMIT cameraRotationChangeForwarder();});
   connect(this, SIGNAL(cameraRotationChangeForwarder()), this, SLOT(pullCameraRotation()));
 
   state->connectSpecificStateChanged(Parameters::CameraLookAt,[this](){Q_EMIT cameraLookAtChangeForwarder();});
@@ -771,9 +771,9 @@ void ViewSceneDialog::pullCameraRotation()
     return;
 
   glm::quat q;
-  auto rotVariable = state_->getValue(Parameters::CameraRotation1);
+  auto rotVariable = state_->getValue(Parameters::CameraRotation);
   if (rotVariable.value().type() == typeid(std::string)) // Legacy interpreter for networks that have this stored as string
-    q = ViewSceneUtility::stringToQuat(state_->getValue(Parameters::CameraRotation1).toString());
+    q = ViewSceneUtility::stringToQuat(state_->getValue(Parameters::CameraRotation).toString());
   else
   {
     auto rotation = toDoubleVector(rotVariable.toVector());
@@ -864,7 +864,7 @@ void ViewSceneDialog::pushCameraRotation()
   if (!spire) return;
 
   auto q = spire->getCameraRotation();
-  state_->setValue(Parameters::CameraRotation1, makeAnonymousVariableList(q.w, q.x, q.y, q.z));
+  state_->setValue(Parameters::CameraRotation, makeAnonymousVariableList(q.w, q.x, q.y, q.z));
   pushingCameraState_ = false;
 }
 
@@ -1340,20 +1340,20 @@ void ViewSceneDialog::mouseMoveEvent(QMouseEvent* event)
   auto spire = mSpire.lock();
   if(!spire) return;
 
-  int x_window = event->x() - mGLWidget->pos().x();
-  int y_window = event->y() - mGLWidget->pos().y();
+  const int x_window = event->x() - mGLWidget->pos().x();
+  const int y_window = event->y() - mGLWidget->pos().y();
 
-  auto btn = getSpireButton(event);
+  const auto btn = getSpireButton(event);
 
   if (selectedWidget_)
   {
     spire->widgetMouseMove(x_window, y_window);
   }
-  else if(!shiftdown_)
+  else if (!shiftdown_)
   {
     float x_ss, y_ss;
     spire->calculateScreenSpaceCoords(x_window, y_window, x_ss, y_ss);
-    for (auto vsd : viewScenesToUpdate)
+    for (auto* vsd : viewScenesToUpdate)
       vsd->inputMouseMoveHelper(btn, x_ss, y_ss);
   }
   else
@@ -1366,7 +1366,7 @@ void ViewSceneDialog::mouseMoveEvent(QMouseEvent* event)
 //--------------------------------------------------------------------------------------------------
 bool ViewSceneDialog::needToWaitForWidgetSelection()
 {
-  auto lastExec = transient_value_cast<unsigned long>(state_->getTransientValue(Modules::Render::ViewScene::TimeExecutionFinished));
+  const auto lastExec = transient_value_cast<unsigned long>(state_->getTransientValue(Parameters::TimeExecutionFinished));
 
   return previousWidgetInfo_->timeSince(lastExec) < delayAfterModuleExecution_
     || previousWidgetInfo_->timeSinceWidgetColorRestored() < delayAfterWidgetColorRestored_
@@ -1390,7 +1390,7 @@ void ViewSceneDialog::mousePressEvent(QMouseEvent* event)
   if (!clickedInViewer(event))
     return;
 
-  auto btn = getSpireButton(event);
+  const auto btn = getSpireButton(event);
   if (!tryWidgetSelection(event->x(), event->y(), btn))
   {
     auto spire = mSpire.lock();
@@ -1402,7 +1402,6 @@ void ViewSceneDialog::mousePressEvent(QMouseEvent* event)
     float x_ss, y_ss;
     spire->calculateScreenSpaceCoords(x_window, y_window, x_ss, y_ss);
 
-
     for (auto vsd : viewScenesToUpdate)
       vsd->inputMouseDownHelper(x_ss, y_ss);
   }
@@ -1440,7 +1439,8 @@ void ViewSceneDialog::mouseReleaseEvent(QMouseEvent* event)
   }
   else if (!shiftdown_)
   {
-    for (auto vsd : viewScenesToUpdate) vsd->inputMouseUpHelper();
+    for (auto* vsd : viewScenesToUpdate) 
+      vsd->inputMouseUpHelper();
   }
 
   mouseButtonPressed_ = false;
@@ -1467,6 +1467,7 @@ void ViewSceneDialog::keyPressEvent(QKeyEvent* event)
     shiftdown_ = true;
     updateCursor();
     break;
+  default: ;
   }
 }
 
@@ -1479,6 +1480,7 @@ void ViewSceneDialog::keyReleaseEvent(QKeyEvent* event)
     shiftdown_ = false;
     updateCursor();
     break;
+  default: ;
   }
 }
 
@@ -1508,7 +1510,6 @@ void ViewSceneDialog::updateCursor()
 //---------------- Camera --------------------------------------------------------------------------
 //--------------------------------------------------------------------------------------------------
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::viewAxisSelected(const QString& name)
 {
   mUpVectorBox->clear();
@@ -1531,7 +1532,6 @@ void ViewSceneDialog::viewAxisSelected(const QString& name)
   mUpVectorBox->setEnabled(true);
 }
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::viewVectorSelected(const QString& name)
 {
   if (name.isEmpty())
@@ -1548,7 +1548,6 @@ void ViewSceneDialog::viewVectorSelected(const QString& name)
   pushCameraState();
 }
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::autoViewClicked()
 {
   auto spire = mSpire.lock();
@@ -1559,7 +1558,6 @@ void ViewSceneDialog::autoViewClicked()
   pushCameraState();
 }
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::menuMouseControlChanged(int index)
 {
   auto spire = mSpire.lock();
@@ -1579,51 +1577,44 @@ void ViewSceneDialog::menuMouseControlChanged(int index)
   mConfigurationDock->updateZoomOptionVisibility();
 }
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::invertZoomClicked(bool value)
 {
   auto spire = mSpire.lock();
   spire->setZoomInverted(value);
   Preferences::Instance().invertMouseZoom.setValue(value);
 }
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::adjustZoomSpeed(int value)
 {
   auto spire = mSpire.lock();
   spire->setZoomSpeed(value);
 }
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::toggleLockColor(bool locked)
 {
   QString color = locked ? "red" : "rgb(66,66,69)";
   controlLock_->setStyleSheet("QPushButton { background-color: " + color + "; }");
   autoViewButton_->setDisabled(locked);
 }
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::lockRotationToggled()
 {
   mGLWidget->setLockRotation(lockRotation_->isChecked());
   toggleLockColor(lockRotation_->isChecked() || lockPan_->isChecked() || lockZoom_->isChecked());
 }
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::lockPanningToggled()
 {
   mGLWidget->setLockPanning(lockPan_->isChecked());
   toggleLockColor(lockRotation_->isChecked() || lockPan_->isChecked() || lockZoom_->isChecked());
 }
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::lockZoomToggled()
 {
   mGLWidget->setLockZoom(lockZoom_->isChecked());
   toggleLockColor(lockRotation_->isChecked() || lockPan_->isChecked() || lockZoom_->isChecked());
 }
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::lockAllTriggered()
 {
   lockRotation_->setChecked(true);
@@ -1635,7 +1626,6 @@ void ViewSceneDialog::lockAllTriggered()
   toggleLockColor(true);
 }
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::unlockAllTriggered()
 {
   lockRotation_->setChecked(false);
@@ -1685,7 +1675,6 @@ void ViewSceneDialog::autoRotateDown()
 //---------------- Widgets -------------------------------------------------------------------------
 //--------------------------------------------------------------------------------------------------
 
-//--------------------------------------------------------------------------------------------------
 void ViewSceneDialog::updateMeshComponentSelection(const QString& showFieldName, const QString& component, bool selected)
 {
   auto name = showFieldName.toStdString();
@@ -1697,8 +1686,7 @@ void ViewSceneDialog::updateMeshComponentSelection(const QString& showFieldName,
   state_->setTransientValue(Parameters::MeshComponentSelection, sel);
 }
 
-//--------------------------------------------------------------------------------------------------
-static std::vector<WidgetHandle> filterGeomObjectsForWidgets(SCIRun::Modules::Render::ViewScene::GeomListPtr geomData, ViewSceneControlsDock* mConfigurationDock)
+static std::vector<WidgetHandle> filterGeomObjectsForWidgets(ViewScene::GeomListPtr geomData, ViewSceneControlsDock* mConfigurationDock)
 {
   //getting geom list
   std::vector<WidgetHandle> objList;
@@ -1751,7 +1739,7 @@ ViewScene::GeomListPtr ViewSceneDialog::getGeomData()
 
 void ViewSceneDialog::selectObject(const int x, const int y, MouseButton button)
 {
-  bool geomDataPresent = false;
+  auto geomDataPresent = false;
   {
     LOG_DEBUG("ViewSceneDialog::asyncExecute before locking");
     Guard lock(Modules::Render::ViewScene::mutex_.get());
@@ -1760,22 +1748,22 @@ void ViewSceneDialog::selectObject(const int x, const int y, MouseButton button)
     auto spire = mSpire.lock();
     if (!spire) return;
 
-    auto geomData = getGeomData();
+    const auto geomData = getGeomData();
     if (geomData)
     {
       geomDataPresent = true;
       // Search for new widgets if geometry has changed
-      bool newGeometry = state_->getValue(Modules::Render::ViewScene::HasNewGeometry).toBool();
+      const bool newGeometry = state_->getValue(Parameters::HasNewGeometry).toBool();
       if (newGeometry)
       {
         widgetHandles_ = filterGeomObjectsForWidgets(geomData, mConfigurationDock);
-        state_->setValue(Modules::Render::ViewScene::HasNewGeometry, false);
+        state_->setValue(Parameters::HasNewGeometry, false);
       }
 
       // Search for new widget unless mouse and camera wasn't moved
-      auto adjustedX = x - mGLWidget->pos().x();
-      auto adjustedY = y - mGLWidget->pos().y();
-      auto currentCameraTransform = spire->getWorldToProjection();
+      const auto adjustedX = x - mGLWidget->pos().x();
+      const auto adjustedY = y - mGLWidget->pos().y();
+      const auto currentCameraTransform = spire->getWorldToProjection();
       //TODO: extract function
       const bool reuseWidget = !newGeometry && previousWidgetInfo_->hasSameMousePosition(x, y)
         && previousWidgetInfo_->hasSameCameraTansform(currentCameraTransform);
@@ -1813,13 +1801,12 @@ void ViewSceneDialog::selectObject(const int x, const int y, MouseButton button)
 
 bool ViewSceneDialog::checkForSelectedWidget(WidgetHandle widget)
 {
-  auto geomData = getGeomData();
+  const auto geomData = getGeomData();
   if (geomData)
   {
-    auto id = widget->uniqueID();
-    for (auto it = geomData->begin(); it != geomData->end(); ++it)
+    const auto id = widget->uniqueID();
+    for (const auto& obj : *geomData)
     {
-      auto obj = *it;
       if (obj->uniqueID() == id)
         return true;
     }
diff --git a/src/Modules/Render/ViewScene.cc b/src/Modules/Render/ViewScene.cc
@@ -57,12 +57,12 @@ Mutex ViewScene::mutex_("ViewScene");
 ViewScene::ScopedExecutionReporter::ScopedExecutionReporter(ModuleStateHandle state)
   : state_(state)
 {
-  state_->setValue(IsExecuting, true);
+  state_->setValue(Parameters::IsExecuting, true);
 }
 
 ViewScene::ScopedExecutionReporter::~ScopedExecutionReporter()
 {
-  state_->setValue(IsExecuting, false);
+  state_->setValue(Parameters::IsExecuting, false);
 }
 
 ALGORITHM_PARAMETER_DEF(Render, GeomData);
@@ -125,15 +125,18 @@ ALGORITHM_PARAMETER_DEF(Render, IsFloating);
 ALGORITHM_PARAMETER_DEF(Render, CameraDistance);
 ALGORITHM_PARAMETER_DEF(Render, CameraDistanceMinimum);
 ALGORITHM_PARAMETER_DEF(Render, CameraLookAt);
-ALGORITHM_PARAMETER_DEF(Render, CameraRotation1);
+ALGORITHM_PARAMETER_DEF(Render, CameraRotation);
+ALGORITHM_PARAMETER_DEF(Render, IsExecuting);
+ALGORITHM_PARAMETER_DEF(Render, TimeExecutionFinished);
+ALGORITHM_PARAMETER_DEF(Render, HasNewGeometry);
 
 ViewScene::ViewScene() : ModuleWithAsyncDynamicPorts(staticInfo_, true)
 {
   RENDERER_LOG_FUNCTION_SCOPE;
-  INITIALIZE_PORT(GeneralGeom);
-  INITIALIZE_PORT(ScreenshotDataRed);
-  INITIALIZE_PORT(ScreenshotDataGreen);
-  INITIALIZE_PORT(ScreenshotDataBlue);
+  INITIALIZE_PORT(GeneralGeom)
+  INITIALIZE_PORT(ScreenshotDataRed)
+  INITIALIZE_PORT(ScreenshotDataGreen)
+  INITIALIZE_PORT(ScreenshotDataBlue)
 
   get_state()->setTransientValue(Parameters::VSMutex, &screenShotMutex_, true);
 }
@@ -199,12 +202,12 @@ void ViewScene::setStateDefaults()
   state->setValue(Parameters::WindowPositionY, 200);
   state->setValue(Parameters::IsFloating, true);
   state->setValue(Parameters::CameraDistance, 3.0);
-  state->setValue(IsExecuting, false);
-  state->setTransientValue(TimeExecutionFinished, 0, false);
+  state->setValue(Parameters::IsExecuting, false);
+  state->setTransientValue(Parameters::TimeExecutionFinished, 0, false);
   state->setValue(Parameters::CameraDistanceMinimum, 1e-10);
   state->setValue(Parameters::CameraLookAt, makeAnonymousVariableList(0.0, 0.0, 0.0));
-  state->setValue(Parameters::CameraRotation1, makeAnonymousVariableList(1.0, 0.0, 0.0, 0.0));
-  state->setValue(HasNewGeometry, false);
+  state->setValue(Parameters::CameraRotation, makeAnonymousVariableList(1.0, 0.0, 0.0, 0.0));
+  state->setValue(Parameters::HasNewGeometry, false);
 
   get_state()->connectSpecificStateChanged(Parameters::GeometryFeedbackInfo, [this]() { processViewSceneObjectFeedback(); });
   get_state()->connectSpecificStateChanged(Parameters::MeshComponentSelection, [this]() { processMeshComponentSelection(); });
@@ -335,8 +338,8 @@ void ViewScene::execute()
     }
   }
 #endif
-  state->setValue(HasNewGeometry, true);
-  state->setTransientValue(TimeExecutionFinished, getCurrentTimeSinceEpoch(), false);
+  state->setValue(Parameters::HasNewGeometry, true);
+  state->setTransientValue(Parameters::TimeExecutionFinished, getCurrentTimeSinceEpoch(), false);
 }
 
 unsigned long ViewScene::getCurrentTimeSinceEpoch()
@@ -368,7 +371,3 @@ void ViewScene::processMeshComponentSelection()
     sendFeedbackUpstreamAlongIncomingConnections(vsInfo);
   }
 }
-
-const AlgorithmParameterName ViewScene::IsExecuting("IsExecuting");
-const AlgorithmParameterName ViewScene::TimeExecutionFinished("TimeExecutionFinished");
-const AlgorithmParameterName ViewScene::HasNewGeometry("HasNewGeometry");
diff --git a/src/Modules/Render/ViewScene.h b/src/Modules/Render/ViewScene.h
@@ -49,6 +49,11 @@ namespace SCIRun
         ALGORITHM_PARAMETER_DECL(VSMutex);
         ALGORITHM_PARAMETER_DECL(GeometryFeedbackInfo);
         ALGORITHM_PARAMETER_DECL(ScreenshotData);
+
+        ALGORITHM_PARAMETER_DECL(IsExecuting);
+        ALGORITHM_PARAMETER_DECL(TimeExecutionFinished);
+        ALGORITHM_PARAMETER_DECL(HasNewGeometry);
+
         // these should move from transient to saved
         ALGORITHM_PARAMETER_DECL(MeshComponentSelection);
         ALGORITHM_PARAMETER_DECL(ShowFieldStates);
@@ -88,7 +93,7 @@ namespace SCIRun
         ALGORITHM_PARAMETER_DECL(CameraDistance);
         ALGORITHM_PARAMETER_DECL(CameraDistanceMinimum);
         ALGORITHM_PARAMETER_DECL(CameraLookAt);
-        ALGORITHM_PARAMETER_DECL(CameraRotation1);
+        ALGORITHM_PARAMETER_DECL(CameraRotation);
 
         // save/load has issues.
         ALGORITHM_PARAMETER_DECL(HeadLightOn);
@@ -154,11 +159,6 @@ namespace Render {
     void asyncExecute(const Dataflow::Networks::PortId& pid, Core::Datatypes::DatatypeHandle data) override;
     void setStateDefaults() override;
 
-
-    static const Core::Algorithms::AlgorithmParameterName IsExecuting;
-    static const Core::Algorithms::AlgorithmParameterName TimeExecutionFinished;
-    static const Core::Algorithms::AlgorithmParameterName HasNewGeometry;
-
     INPUT_PORT_DYNAMIC(0, GeneralGeom, GeometryObject)
     OUTPUT_PORT(0, ScreenshotDataRed, DenseMatrix)
     OUTPUT_PORT(1, ScreenshotDataGreen, DenseMatrix)

Original file line number	Diff line number	Diff line change
`@@ -394,7 +394,7 @@ ViewSceneDialog::ViewSceneDialog(const std::string& name, ModuleStateHandle stat`
`394`	`394`	`state->connectSpecificStateChanged(Parameters::GeomData,[this](){Q_EMIT newGeometryValueForwarder();});`
`395`	`395`	`connect(this, SIGNAL(newGeometryValueForwarder()), this, SLOT(updateModifiedGeometriesAndSendScreenShot()));`
`396`	`396`
`397`		`- state->connectSpecificStateChanged(Parameters::CameraRotation1,[this](){Q_EMIT cameraRotationChangeForwarder();});`
	`397`	`+ state->connectSpecificStateChanged(Parameters::CameraRotation,[this](){Q_EMIT cameraRotationChangeForwarder();});`
`398`	`398`	`connect(this, SIGNAL(cameraRotationChangeForwarder()), this, SLOT(pullCameraRotation()));`
`399`	`399`
`400`	`400`	`state->connectSpecificStateChanged(Parameters::CameraLookAt,[this](){Q_EMIT cameraLookAtChangeForwarder();});`
`@@ -771,9 +771,9 @@ void ViewSceneDialog::pullCameraRotation()`
`771`	`771`	`return;`
`772`	`772`
`773`	`773`	`glm::quat q;`
`774`		`- auto rotVariable = state_->getValue(Parameters::CameraRotation1);`
	`774`	`+ auto rotVariable = state_->getValue(Parameters::CameraRotation);`
`775`	`775`	`if (rotVariable.value().type() == typeid(std::string)) // Legacy interpreter for networks that have this stored as string`
`776`		`- q = ViewSceneUtility::stringToQuat(state_->getValue(Parameters::CameraRotation1).toString());`
	`776`	`+ q = ViewSceneUtility::stringToQuat(state_->getValue(Parameters::CameraRotation).toString());`
`777`	`777`	`else`
`778`	`778`	`{`
`779`	`779`	`auto rotation = toDoubleVector(rotVariable.toVector());`
`@@ -864,7 +864,7 @@ void ViewSceneDialog::pushCameraRotation()`
`864`	`864`	`if (!spire) return;`
`865`	`865`
`866`	`866`	`auto q = spire->getCameraRotation();`
`867`		`- state_->setValue(Parameters::CameraRotation1, makeAnonymousVariableList(q.w, q.x, q.y, q.z));`
	`867`	`+ state_->setValue(Parameters::CameraRotation, makeAnonymousVariableList(q.w, q.x, q.y, q.z));`
`868`	`868`	`pushingCameraState_ = false;`
`869`	`869`	`}`
`870`	`870`
`@@ -1340,20 +1340,20 @@ void ViewSceneDialog::mouseMoveEvent(QMouseEvent* event)`
`1340`	`1340`	`auto spire = mSpire.lock();`
`1341`	`1341`	`if(!spire) return;`
`1342`	`1342`
`1343`		`- int x_window = event->x() - mGLWidget->pos().x();`
`1344`		`- int y_window = event->y() - mGLWidget->pos().y();`
	`1343`	`+ const int x_window = event->x() - mGLWidget->pos().x();`
	`1344`	`+ const int y_window = event->y() - mGLWidget->pos().y();`
`1345`	`1345`
`1346`		`- auto btn = getSpireButton(event);`
	`1346`	`+ const auto btn = getSpireButton(event);`
`1347`	`1347`
`1348`	`1348`	`if (selectedWidget_)`
`1349`	`1349`	`{`
`1350`	`1350`	`spire->widgetMouseMove(x_window, y_window);`
`1351`	`1351`	`}`
`1352`		`- else if(!shiftdown_)`
	`1352`	`+ else if (!shiftdown_)`
`1353`	`1353`	`{`
`1354`	`1354`	`float x_ss, y_ss;`
`1355`	`1355`	`spire->calculateScreenSpaceCoords(x_window, y_window, x_ss, y_ss);`
`1356`		`- for (auto vsd : viewScenesToUpdate)`
	`1356`	`+ for (auto* vsd : viewScenesToUpdate)`
`1357`	`1357`	`vsd->inputMouseMoveHelper(btn, x_ss, y_ss);`
`1358`	`1358`	`}`
`1359`	`1359`	`else`
`@@ -1366,7 +1366,7 @@ void ViewSceneDialog::mouseMoveEvent(QMouseEvent* event)`
`1366`	`1366`	`//--------------------------------------------------------------------------------------------------`
`1367`	`1367`	`bool ViewSceneDialog::needToWaitForWidgetSelection()`
`1368`	`1368`	`{`
`1369`		`- auto lastExec = transient_value_cast<unsigned long>(state_->getTransientValue(Modules::Render::ViewScene::TimeExecutionFinished));`
	`1369`	`+ const auto lastExec = transient_value_cast<unsigned long>(state_->getTransientValue(Parameters::TimeExecutionFinished));`
`1370`	`1370`
`1371`	`1371`	`return previousWidgetInfo_->timeSince(lastExec) < delayAfterModuleExecution_`
`1372`	`1372`	`\|\| previousWidgetInfo_->timeSinceWidgetColorRestored() < delayAfterWidgetColorRestored_`
`@@ -1390,7 +1390,7 @@ void ViewSceneDialog::mousePressEvent(QMouseEvent* event)`
`1390`	`1390`	`if (!clickedInViewer(event))`
`1391`	`1391`	`return;`
`1392`	`1392`
`1393`		`- auto btn = getSpireButton(event);`
	`1393`	`+ const auto btn = getSpireButton(event);`
`1394`	`1394`	`if (!tryWidgetSelection(event->x(), event->y(), btn))`
`1395`	`1395`	`{`
`1396`	`1396`	`auto spire = mSpire.lock();`
`@@ -1402,7 +1402,6 @@ void ViewSceneDialog::mousePressEvent(QMouseEvent* event)`
`1402`	`1402`	`float x_ss, y_ss;`
`1403`	`1403`	`spire->calculateScreenSpaceCoords(x_window, y_window, x_ss, y_ss);`
`1404`	`1404`
`1405`		`-`
`1406`	`1405`	`for (auto vsd : viewScenesToUpdate)`
`1407`	`1406`	`vsd->inputMouseDownHelper(x_ss, y_ss);`
`1408`	`1407`	`}`
`@@ -1440,7 +1439,8 @@ void ViewSceneDialog::mouseReleaseEvent(QMouseEvent* event)`
`1440`	`1439`	`}`
`1441`	`1440`	`else if (!shiftdown_)`
`1442`	`1441`	`{`
`1443`		`- for (auto vsd : viewScenesToUpdate) vsd->inputMouseUpHelper();`
	`1442`	`+ for (auto* vsd : viewScenesToUpdate)`
	`1443`	`+ vsd->inputMouseUpHelper();`
`1444`	`1444`	`}`
`1445`	`1445`
`1446`	`1446`	`mouseButtonPressed_ = false;`
`@@ -1467,6 +1467,7 @@ void ViewSceneDialog::keyPressEvent(QKeyEvent* event)`
`1467`	`1467`	`shiftdown_ = true;`
`1468`	`1468`	`updateCursor();`
`1469`	`1469`	`break;`
	`1470`	`+ default: ;`
`1470`	`1471`	`}`
`1471`	`1472`	`}`
`1472`	`1473`
`@@ -1479,6 +1480,7 @@ void ViewSceneDialog::keyReleaseEvent(QKeyEvent* event)`
`1479`	`1480`	`shiftdown_ = false;`
`1480`	`1481`	`updateCursor();`
`1481`	`1482`	`break;`
	`1483`	`+ default: ;`
`1482`	`1484`	`}`
`1483`	`1485`	`}`
`1484`	`1486`
`@@ -1508,7 +1510,6 @@ void ViewSceneDialog::updateCursor()`
`1508`	`1510`	`//---------------- Camera --------------------------------------------------------------------------`
`1509`	`1511`	`//--------------------------------------------------------------------------------------------------`
`1510`	`1512`
`1511`		`-//--------------------------------------------------------------------------------------------------`
`1512`	`1513`	`void ViewSceneDialog::viewAxisSelected(const QString& name)`
`1513`	`1514`	`{`
`1514`	`1515`	`mUpVectorBox->clear();`
`@@ -1531,7 +1532,6 @@ void ViewSceneDialog::viewAxisSelected(const QString& name)`
`1531`	`1532`	`mUpVectorBox->setEnabled(true);`
`1532`	`1533`	`}`
`1533`	`1534`
`1534`		`-//--------------------------------------------------------------------------------------------------`
`1535`	`1535`	`void ViewSceneDialog::viewVectorSelected(const QString& name)`
`1536`	`1536`	`{`
`1537`	`1537`	`if (name.isEmpty())`
`@@ -1548,7 +1548,6 @@ void ViewSceneDialog::viewVectorSelected(const QString& name)`
`1548`	`1548`	`pushCameraState();`
`1549`	`1549`	`}`
`1550`	`1550`
`1551`		`-//--------------------------------------------------------------------------------------------------`
`1552`	`1551`	`void ViewSceneDialog::autoViewClicked()`
`1553`	`1552`	`{`
`1554`	`1553`	`auto spire = mSpire.lock();`
`@@ -1559,7 +1558,6 @@ void ViewSceneDialog::autoViewClicked()`
`1559`	`1558`	`pushCameraState();`
`1560`	`1559`	`}`
`1561`	`1560`
`1562`		`-//--------------------------------------------------------------------------------------------------`
`1563`	`1561`	`void ViewSceneDialog::menuMouseControlChanged(int index)`
`1564`	`1562`	`{`
`1565`	`1563`	`auto spire = mSpire.lock();`
`@@ -1579,51 +1577,44 @@ void ViewSceneDialog::menuMouseControlChanged(int index)`
`1579`	`1577`	`mConfigurationDock->updateZoomOptionVisibility();`
`1580`	`1578`	`}`
`1581`	`1579`
`1582`		`-//--------------------------------------------------------------------------------------------------`
`1583`	`1580`	`void ViewSceneDialog::invertZoomClicked(bool value)`
`1584`	`1581`	`{`
`1585`	`1582`	`auto spire = mSpire.lock();`
`1586`	`1583`	`spire->setZoomInverted(value);`
`1587`	`1584`	`Preferences::Instance().invertMouseZoom.setValue(value);`
`1588`	`1585`	`}`
`1589`	`1586`
`1590`		`-//--------------------------------------------------------------------------------------------------`
`1591`	`1587`	`void ViewSceneDialog::adjustZoomSpeed(int value)`
`1592`	`1588`	`{`
`1593`	`1589`	`auto spire = mSpire.lock();`
`1594`	`1590`	`spire->setZoomSpeed(value);`
`1595`	`1591`	`}`
`1596`	`1592`
`1597`		`-//--------------------------------------------------------------------------------------------------`
`1598`	`1593`	`void ViewSceneDialog::toggleLockColor(bool locked)`
`1599`	`1594`	`{`
`1600`	`1595`	`QString color = locked ? "red" : "rgb(66,66,69)";`
`1601`	`1596`	`controlLock_->setStyleSheet("QPushButton { background-color: " + color + "; }");`
`1602`	`1597`	`autoViewButton_->setDisabled(locked);`
`1603`	`1598`	`}`
`1604`	`1599`
`1605`		`-//--------------------------------------------------------------------------------------------------`
`1606`	`1600`	`void ViewSceneDialog::lockRotationToggled()`
`1607`	`1601`	`{`
`1608`	`1602`	`mGLWidget->setLockRotation(lockRotation_->isChecked());`
`1609`	`1603`	`toggleLockColor(lockRotation_->isChecked() \|\| lockPan_->isChecked() \|\| lockZoom_->isChecked());`
`1610`	`1604`	`}`
`1611`	`1605`
`1612`		`-//--------------------------------------------------------------------------------------------------`
`1613`	`1606`	`void ViewSceneDialog::lockPanningToggled()`
`1614`	`1607`	`{`
`1615`	`1608`	`mGLWidget->setLockPanning(lockPan_->isChecked());`
`1616`	`1609`	`toggleLockColor(lockRotation_->isChecked() \|\| lockPan_->isChecked() \|\| lockZoom_->isChecked());`
`1617`	`1610`	`}`
`1618`	`1611`
`1619`		`-//--------------------------------------------------------------------------------------------------`
`1620`	`1612`	`void ViewSceneDialog::lockZoomToggled()`
`1621`	`1613`	`{`
`1622`	`1614`	`mGLWidget->setLockZoom(lockZoom_->isChecked());`
`1623`	`1615`	`toggleLockColor(lockRotation_->isChecked() \|\| lockPan_->isChecked() \|\| lockZoom_->isChecked());`
`1624`	`1616`	`}`
`1625`	`1617`
`1626`		`-//--------------------------------------------------------------------------------------------------`
`1627`	`1618`	`void ViewSceneDialog::lockAllTriggered()`
`1628`	`1619`	`{`
`1629`	`1620`	`lockRotation_->setChecked(true);`
`@@ -1635,7 +1626,6 @@ void ViewSceneDialog::lockAllTriggered()`
`1635`	`1626`	`toggleLockColor(true);`
`1636`	`1627`	`}`
`1637`	`1628`
`1638`		`-//--------------------------------------------------------------------------------------------------`
`1639`	`1629`	`void ViewSceneDialog::unlockAllTriggered()`
`1640`	`1630`	`{`
`1641`	`1631`	`lockRotation_->setChecked(false);`
`@@ -1685,7 +1675,6 @@ void ViewSceneDialog::autoRotateDown()`
`1685`	`1675`	`//---------------- Widgets -------------------------------------------------------------------------`
`1686`	`1676`	`//--------------------------------------------------------------------------------------------------`
`1687`	`1677`
`1688`		`-//--------------------------------------------------------------------------------------------------`
`1689`	`1678`	`void ViewSceneDialog::updateMeshComponentSelection(const QString& showFieldName, const QString& component, bool selected)`
`1690`	`1679`	`{`
`1691`	`1680`	`auto name = showFieldName.toStdString();`
`@@ -1697,8 +1686,7 @@ void ViewSceneDialog::updateMeshComponentSelection(const QString& showFieldName,`
`1697`	`1686`	`state_->setTransientValue(Parameters::MeshComponentSelection, sel);`
`1698`	`1687`	`}`
`1699`	`1688`
`1700`		`-//--------------------------------------------------------------------------------------------------`
`1701`		`-static std::vector<WidgetHandle> filterGeomObjectsForWidgets(SCIRun::Modules::Render::ViewScene::GeomListPtr geomData, ViewSceneControlsDock* mConfigurationDock)`
	`1689`	`+static std::vector<WidgetHandle> filterGeomObjectsForWidgets(ViewScene::GeomListPtr geomData, ViewSceneControlsDock* mConfigurationDock)`
`1702`	`1690`	`{`
`1703`	`1691`	`//getting geom list`
`1704`	`1692`	`std::vector<WidgetHandle> objList;`
`@@ -1751,7 +1739,7 @@ ViewScene::GeomListPtr ViewSceneDialog::getGeomData()`
`1751`	`1739`
`1752`	`1740`	`void ViewSceneDialog::selectObject(const int x, const int y, MouseButton button)`
`1753`	`1741`	`{`
`1754`		`- bool geomDataPresent = false;`
	`1742`	`+ auto geomDataPresent = false;`
`1755`	`1743`	`{`
`1756`	`1744`	`LOG_DEBUG("ViewSceneDialog::asyncExecute before locking");`
`1757`	`1745`	`Guard lock(Modules::Render::ViewScene::mutex_.get());`
`@@ -1760,22 +1748,22 @@ void ViewSceneDialog::selectObject(const int x, const int y, MouseButton button)`
`1760`	`1748`	`auto spire = mSpire.lock();`
`1761`	`1749`	`if (!spire) return;`
`1762`	`1750`
`1763`		`- auto geomData = getGeomData();`
	`1751`	`+ const auto geomData = getGeomData();`
`1764`	`1752`	`if (geomData)`
`1765`	`1753`	`{`
`1766`	`1754`	`geomDataPresent = true;`
`1767`	`1755`	`// Search for new widgets if geometry has changed`
`1768`		`- bool newGeometry = state_->getValue(Modules::Render::ViewScene::HasNewGeometry).toBool();`
	`1756`	`+ const bool newGeometry = state_->getValue(Parameters::HasNewGeometry).toBool();`
`1769`	`1757`	`if (newGeometry)`
`1770`	`1758`	`{`
`1771`	`1759`	`widgetHandles_ = filterGeomObjectsForWidgets(geomData, mConfigurationDock);`
`1772`		`- state_->setValue(Modules::Render::ViewScene::HasNewGeometry, false);`
	`1760`	`+ state_->setValue(Parameters::HasNewGeometry, false);`
`1773`	`1761`	`}`
`1774`	`1762`
`1775`	`1763`	`// Search for new widget unless mouse and camera wasn't moved`
`1776`		`- auto adjustedX = x - mGLWidget->pos().x();`
`1777`		`- auto adjustedY = y - mGLWidget->pos().y();`
`1778`		`- auto currentCameraTransform = spire->getWorldToProjection();`
	`1764`	`+ const auto adjustedX = x - mGLWidget->pos().x();`
	`1765`	`+ const auto adjustedY = y - mGLWidget->pos().y();`
	`1766`	`+ const auto currentCameraTransform = spire->getWorldToProjection();`
`1779`	`1767`	`//TODO: extract function`
`1780`	`1768`	`const bool reuseWidget = !newGeometry && previousWidgetInfo_->hasSameMousePosition(x, y)`
`1781`	`1769`	`&& previousWidgetInfo_->hasSameCameraTansform(currentCameraTransform);`
`@@ -1813,13 +1801,12 @@ void ViewSceneDialog::selectObject(const int x, const int y, MouseButton button)`
`1813`	`1801`
`1814`	`1802`	`bool ViewSceneDialog::checkForSelectedWidget(WidgetHandle widget)`
`1815`	`1803`	`{`
`1816`		`- auto geomData = getGeomData();`
	`1804`	`+ const auto geomData = getGeomData();`
`1817`	`1805`	`if (geomData)`
`1818`	`1806`	`{`
`1819`		`- auto id = widget->uniqueID();`
`1820`		`- for (auto it = geomData->begin(); it != geomData->end(); ++it)`
	`1807`	`+ const auto id = widget->uniqueID();`
	`1808`	`+ for (const auto& obj : *geomData)`
`1821`	`1809`	`{`
`1822`		`- auto obj = *it;`
`1823`	`1810`	`if (obj->uniqueID() == id)`
`1824`	`1811`	`return true;`
`1825`	`1812`	`}`