Changeset 135f544 in sasview for src/sas

Timestamp:

Feb 22, 2018 8:04:57 AM (7 years ago)

Author:

Piotr Rozyczko <rozyczko@…>

Branches:

ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc

Children:

c3eb858

Parents:

626c7c5 (diff), 06234fc (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'ESS_GUI_cns' into ESS_GUI

Location:

src/sas

Files:

• qtgui/GUITests.py (modified) (2 diffs)
• qtgui/MainWindow/GuiManager.py (modified) (3 diffs)
• qtgui/MainWindow/UnitTesting/GuiManagerTest.py (modified) (2 diffs)
• qtgui/Perspectives/Fitting/ComplexConstraint.py (added)
• qtgui/Perspectives/Fitting/Constraint.py (added)
• qtgui/Perspectives/Fitting/ConstraintWidget.py (added)
• qtgui/Perspectives/Fitting/FitThread.py (modified) (1 diff, 1 prop)
• qtgui/Perspectives/Fitting/FittingPerspective.py (modified) (14 diffs)
• qtgui/Perspectives/Fitting/FittingWidget.py (modified) (31 diffs)
• qtgui/Perspectives/Fitting/MultiConstraint.py (added)
• qtgui/Perspectives/Fitting/UI/ComplexConstraintUI.ui (added)
• qtgui/Perspectives/Fitting/UI/ConstraintWidgetUI.ui (added)
• qtgui/Perspectives/Fitting/UI/FittingWidgetUI.ui (modified) (9 diffs)
• qtgui/Perspectives/Fitting/UI/MultiConstraintUI.ui (added)
• qtgui/Perspectives/Fitting/UnitTesting/ComplexConstraintTest.py (added)
• qtgui/Perspectives/Fitting/UnitTesting/ConstraintWidgetTest.py (added)
• qtgui/Perspectives/Fitting/UnitTesting/FittingOptionsTest.py (modified) (4 diffs)
• qtgui/Perspectives/Fitting/UnitTesting/FittingPerspectiveTest.py (modified) (7 diffs)
• qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py (modified) (12 diffs, 1 prop)
• qtgui/Perspectives/Fitting/UnitTesting/MultiConstraintTest.py (added)
• qtgui/Plotting/Plotter.py (modified) (2 diffs)
• qtgui/Plotting/PlotterBase.py (modified) (3 diffs)
• qtgui/Plotting/UnitTesting/PlotterTest.py (modified) (5 diffs, 1 prop)
• qtgui/Plotting/UnitTesting/SlicerParametersTest.py (modified) (4 diffs)
• qtgui/Utilities/GuiUtils.py (modified) (1 diff)
• qtgui/Utilities/LocalConfig.py (modified) (1 diff, 1 prop)
• qtgui/Utilities/ObjectLibrary.py (modified) (1 prop)
• sascalc/fit/AbstractFitEngine.py (modified) (1 diff)

src/sas/qtgui/GUITests.py

@@ -56 +56 @@
 from Perspectives.Fitting.UnitTesting import FitPageTest
 from Perspectives.Fitting.UnitTesting import FittingOptionsTest
+from Perspectives.Fitting.UnitTesting import MultiConstraintTest
+from Perspectives.Fitting.UnitTesting import ComplexConstraintTest
+from Perspectives.Fitting.UnitTesting import ConstraintWidgetTest
+
 #  Invariant
 from Perspectives.Invariant.UnitTesting import InvariantPerspectiveTest
-from Perspectives.Invariant.UnitTesting import InvariantDetailsTest
+
 #  Inversion
 from Perspectives.Inversion.UnitTesting import InversionPerspectiveTest
-
 
 def suite():
@@ -114 +117 @@
         unittest.makeSuite(FitPageTest.FitPageTest,                       'test'),
         unittest.makeSuite(FittingOptionsTest.FittingOptionsTest,         'test'),
+        unittest.makeSuite(MultiConstraintTest.MultiConstraintTest,       'test'),
+        unittest.makeSuite(ConstraintWidgetTest.ConstraintWidgetTest,     'test'),
+        unittest.makeSuite(ComplexConstraintTest.ComplexConstraintTest,   'test'),
+
         #  Invariant
         unittest.makeSuite(InvariantPerspectiveTest.InvariantPerspectiveTest,  'test'),
-        unittest.makeSuite(InvariantDetailsTest.InvariantDetailsTest,     'test'),
         #  Inversion
         unittest.makeSuite(InversionPerspectiveTest.InversionTest,  'test'),
-     )
+        )
     return unittest.TestSuite(suites)
 

src/sas/qtgui/MainWindow/GuiManager.py

@@ -9 +9 @@
 from PyQt5.QtGui import *
 from PyQt5.QtCore import Qt, QLocale, QUrl
-from PyQt5.QtWebKitWidgets import QWebView
 
 from twisted.internet import reactor
@@ -185 +184 @@
 
         # Save users from themselves...
-        if isinstance(self._current_perspective, Perspectives.PERSPECTIVES[str(perspective_name)]):
-            self.setupPerspectiveMenubarOptions(self._current_perspective)
-            return
+        #if isinstance(self._current_perspective, Perspectives.PERSPECTIVES[str(perspective_name)]):
+        self.setupPerspectiveMenubarOptions(self._current_perspective)
+        #    return
 
         # Close the previous perspective
@@ -623 +622 @@
     def actionConstrained_Fit(self):
         """
-        """
-        print("actionConstrained_Fit TRIGGERED")
-        pass
+        Add a new Constrained and Simult. Fit page in the fitting perspective.
+        """
+        per = self.perspective()
+        if not isinstance(per, FittingWindow):
+            return
+        per.addConstraintTab()
 
     def actionCombine_Batch_Fit(self):

src/sas/qtgui/MainWindow/UnitTesting/GuiManagerTest.py

@@ -9 +9 @@
 from PyQt5.QtTest import QTest
 from PyQt5.QtCore import *
-from PyQt5.QtWebKit import *
 from unittest.mock import MagicMock
 
@@ -272 +271 @@
     #### HELP ####
     # test when PyQt5 works with html
-    def notestActionDocumentation(self):
+    def testActionDocumentation(self):
         """
         Menu Help/Documentation
         """
-        #Mock the QWebView method
-        QWebView.show = MagicMock()
-
-        # Assure the filename is correct
-        self.assertIn("index.html", self.manager._helpLocation)
+        webbrowser.open = MagicMock()
 
         # Invoke the action
         self.manager.actionDocumentation()
 
-        # Check if show() got called
-        self.assertTrue(QWebView.show.called)
+        # see that webbrowser open was attempted
+        webbrowser.open.assert_called_once()
+
 
     def skip_testActionTutorial(self):

src/sas/qtgui/Perspectives/Fitting/FitThread.py

@@ -95 +95 @@
             # print "ERROR IN FIT THREAD: ", traceback.format_exc()
             if self.handler is not None:
-                self.handler.error(msg=traceback.format_exc())
+                self.handler.error(msg=str(ex))
+                self.completefn(None)
+            else:
+                return(None)
 
 

src/sas/qtgui/Perspectives/Fitting/FittingPerspective.py

@@ -11 +11 @@
 
 from sas.qtgui.Perspectives.Fitting.FittingWidget import FittingWidget
+from sas.qtgui.Perspectives.Fitting.ConstraintWidget import ConstraintWidget
 from sas.qtgui.Perspectives.Fitting.FittingOptions import FittingOptions
 from sas.qtgui.Perspectives.Fitting.GPUOptions import GPUOptions
@@ -17 +18 @@
     """
     """
+    tabsModifiedSignal = QtCore.pyqtSignal()
+    fittingStartedSignal = QtCore.pyqtSignal(list)
+    fittingStoppedSignal = QtCore.pyqtSignal(list)
+
     name = "Fitting" # For displaying in the combo box in DataExplorer
     def __init__(self, parent=None, data=None):
@@ -37 +42 @@
         self.optimizer = 'Levenberg-Marquardt'
 
-        # Dataset inde -> Fitting tab mapping
+        # Dataset index -> Fitting tab mapping
         self.dataToFitTab = {}
 
         # The tabs need to be closeable
         self.setTabsClosable(True)
+
+        # The tabs need to be movabe
+        self.setMovable(True)
 
         self.communicate = self.parent.communicator()
@@ -51 +59 @@
         self.tabCloseRequested.connect(self.tabCloses)
         self.communicate.dataDeletedSignal.connect(self.dataDeleted)
+        self.fittingStartedSignal.connect(self.onFittingStarted)
+        self.fittingStoppedSignal.connect(self.onFittingStopped)
 
         # Perspective window not allowed to close by default
@@ -66 +76 @@
         self.gpu_options_widget = GPUOptions(self)
 
-        #self.setWindowTitle('Fit panel - Active Fitting Optimizer: %s' % self.optimizer)
         self.updateWindowTitle()
 
@@ -79 +88 @@
     def setClosable(self, value=True):
         """
-        Allow outsiders close this widget
+        Allow outsiders to close this widget
         """
         assert isinstance(value, bool)
@@ -108 +117 @@
         tab.is_batch_fitting = is_batch
         # Add this tab to the object library so it can be retrieved by scripting/jupyter
-        tab_name = self.tabName(is_batch=is_batch)
+        tab_name = self.getTabName(is_batch=is_batch)
         ObjectLibrary.addObject(tab_name, tab)
         self.tabs.append(tab)
@@ -115 +124 @@
         self.maxIndex += 1
         self.addTab(tab, tab_name)
+        self.tabsModifiedSignal.emit()
+
+    def addConstraintTab(self):
+        """
+        Add a new C&S fitting tab
+        """
+        tabs = [isinstance(tab, ConstraintWidget) for tab in self.tabs]
+        if any(tabs):
+            # We already have a C&S tab: show it
+            self.setCurrentIndex(tabs.index(True))
+            return
+        tab     = ConstraintWidget(parent=self)
+        # Add this tab to the object library so it can be retrieved by scripting/jupyter
+        tab_name = self.getCSTabName() # TODO update the tab name scheme
+        ObjectLibrary.addObject(tab_name, tab)
+        self.tabs.append(tab)
+        self.addTab(tab, tab_name)
 
     def updateFitDict(self, item_key, tab_name):
@@ -126 +152 @@
             self.dataToFitTab[item_key_str] = [tab_name]
 
-        #print "CURRENT dict: ", self.dataToFitTab
-
-    def tabName(self, is_batch=False):
+    def getTabName(self, is_batch=False):
         """
         Get the new tab name, based on the number of fitting tabs so far
@@ -134 +158 @@
         page_name = "BatchPage" if is_batch else "FitPage"
         page_name = page_name + str(self.maxIndex)
+        return page_name
+
+    def getCSTabName(self):
+        """
+        Get the new tab name, based on the number of fitting tabs so far
+        """
+        page_name = "Const. & Simul. Fit"
         return page_name
 
@@ -162 +193 @@
             self.removeTab(index)
             del self.tabs[index]
+            self.tabsModifiedSignal.emit()
         except IndexError:
             # The tab might have already been deleted previously
@@ -189 +221 @@
                 self.dataToFitTab.pop(index_to_delete_str)
 
-        #print "CURRENT dict: ", self.dataToFitTab
-
     def allowBatch(self):
         """
@@ -213 +243 @@
             raise AttributeError(msg)
 
+        if is_batch:
+            # Just create a new fit tab. No empty batchFit tabs
+            self.addFit(data_item, is_batch=is_batch)
+            return
+
         items = [data_item] if is_batch else data_item
-
         for data in items:
             # Find the first unassigned tab.
             # If none, open a new tab.
-            available_tabs = list([tab.acceptsData() for tab in self.tabs])
+            available_tabs = [tab.acceptsData() for tab in self.tabs]
 
             if numpy.any(available_tabs):
@@ -238 +272 @@
         self.updateWindowTitle()
 
+    def onFittingStarted(self, tabs_for_fitting=None):
+        """
+        Notify tabs listed in tabs_for_fitting
+        that the fitting thread started
+        """
+        assert(isinstance(tabs_for_fitting, list))
+        assert(len(tabs_for_fitting)>0)
+
+        for tab_object in self.tabs:
+            if not isinstance(tab_object, FittingWidget):
+                continue
+            page_name = "Page%s"%tab_object.tab_id
+            if any([page_name in tab for tab in tabs_for_fitting]):
+                tab_object.setFittingStarted()
+
         pass
+
+    def onFittingStopped(self, tabs_for_fitting=None):
+        """
+        Notify tabs listed in tabs_for_fitting
+        that the fitting thread stopped
+        """
+        assert(isinstance(tabs_for_fitting, list))
+        assert(len(tabs_for_fitting)>0)
+
+        for tab_object in self.tabs:
+            if not isinstance(tab_object, FittingWidget):
+                continue
+            page_name = "Page%s"%tab_object.tab_id
+            if any([page_name in tab for tab in tabs_for_fitting]):
+                tab_object.setFittingStopped()
+
+        pass

src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

@@ -23 +23 @@
 
 import sas.qtgui.Utilities.GuiUtils as GuiUtils
+import sas.qtgui.Utilities.LocalConfig as LocalConfig
 from sas.qtgui.Utilities.CategoryInstaller import CategoryInstaller
 from sas.qtgui.Plotting.PlotterData import Data1D
@@ -41 +42 @@
 from sas.qtgui.Perspectives.Fitting.ViewDelegate import PolyViewDelegate
 from sas.qtgui.Perspectives.Fitting.ViewDelegate import MagnetismViewDelegate
+from sas.qtgui.Perspectives.Fitting.Constraint import Constraint
+from sas.qtgui.Perspectives.Fitting.MultiConstraint import MultiConstraint
 
 
@@ -51 +54 @@
 DEFAULT_POLYDISP_FUNCTION = 'gaussian'
 
-USING_TWISTED = True
-#USING_TWISTED = False
 
 class ToolTippedItemModel(QtGui.QStandardItemModel):
@@ -80 +81 @@
     Main widget for selecting form and structure factor models
     """
+    constraintAddedSignal = QtCore.pyqtSignal(list)
+    newModelSignal = QtCore.pyqtSignal()
     def __init__(self, parent=None, data=None, tab_id=1):
 
@@ -178 +181 @@
         # Batch/single fitting
         self.is_batch_fitting = False
+        self.is_chain_fitting = False
         # Current SasModel in view
         self.kernel_module = None
@@ -207 +211 @@
         self.orig_poly_index = 3
 
+        # Page id for fitting
+        # To keep with previous SasView values, use 200 as the start offset
+        self.page_id = 200 + self.tab_id
+
         # Data for chosen model
         self.model_data = None
@@ -301 +309 @@
         self.lstParams.setStyleSheet(stylesheet)
         self.lstParams.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
-        self.lstParams.customContextMenuRequested.connect(self.showModelDescription)
+        self.lstParams.customContextMenuRequested.connect(self.showModelContextMenu)
         self.lstParams.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
         # Poly model displayed in poly list
@@ -350 +358 @@
                 self.cbFileNames.addItem(filename)
             self.cbFileNames.setVisible(True)
+            self.chkChainFit.setEnabled(True)
+            self.chkChainFit.setVisible(True)
             # This panel is not designed to view individual fits, so disable plotting
             self.cmdPlot.setVisible(False)
@@ -389 +399 @@
         """ Enable/disable the magnetism tab """
         self.tabFitting.setTabEnabled(TAB_MAGNETISM, isChecked)
+
+    def toggleChainFit(self, isChecked):
+        """ Enable/disable chain fitting """
+        self.is_chain_fitting = isChecked
 
     def toggle2D(self, isChecked):
@@ -412 +426 @@
         self.chkMagnetism.setEnabled(False)
         self.chkMagnetism.setCheckState(False)
+        self.chkChainFit.setEnabled(False)
+        self.chkChainFit.setVisible(False)
         # Tabs
         self.tabFitting.setTabEnabled(TAB_POLY, False)
@@ -434 +450 @@
         self.chkPolydispersity.toggled.connect(self.togglePoly)
         self.chkMagnetism.toggled.connect(self.toggleMagnetism)
+        self.chkChainFit.toggled.connect(self.toggleChainFit)
         # Buttons
         self.cmdFit.clicked.connect(self.onFit)
@@ -442 +459 @@
         # Respond to change in parameters from the UI
         self._model_model.itemChanged.connect(self.onMainParamsChange)
+        #self.constraintAddedSignal.connect(self.modifyViewOnConstraint)
         self._poly_model.itemChanged.connect(self.onPolyModelChange)
         self._magnet_model.itemChanged.connect(self.onMagnetModelChange)
@@ -448 +466 @@
         self.options_widget.plot_signal.connect(self.onOptionsUpdate)
 
-    def showModelDescription(self, position):
-        """
-        Shows a window with model description, when right clicked in the treeview
+    def modelName(self):
+        """
+        Returns model name, by default M<tab#>, e.g. M1, M2
+        """
+        return "M%i" % self.tab_id
+
+    def nameForFittedData(self, name):
+        """
+        Generate name for the current fit
+        """
+        if self.is2D:
+            name += "2d"
+        name = "%s [%s]" % (self.modelName(), name)
+        return name
+
+    def showModelContextMenu(self, position):
+        """
+        Show context specific menu in the parameter table.
+        When clicked on parameter(s): fitting/constraints options
+        When clicked on white space: model description
+        """
+        rows = [s.row() for s in self.lstParams.selectionModel().selectedRows()]
+        menu = self.showModelDescription() if not rows else self.modelContextMenu(rows)
+        try:
+            menu.exec_(self.lstParams.viewport().mapToGlobal(position))
+        except AttributeError as ex:
+            logging.error("Error generating context menu: %s" % ex)
+        return
+
+    def modelContextMenu(self, rows):
+        """
+        Create context menu for the parameter selection
+        """
+        menu = QtWidgets.QMenu()
+        num_rows = len(rows)
+        if num_rows < 1:
+            return menu
+        # Select for fitting
+        param_string = "parameter " if num_rows==1 else "parameters "
+        to_string = "to its current value" if num_rows==1 else "to their current values"
+        has_constraints = any([self.rowHasConstraint(i) for i in rows])
+
+        self.actionSelect = QtWidgets.QAction(self)
+        self.actionSelect.setObjectName("actionSelect")
+        self.actionSelect.setText(QtCore.QCoreApplication.translate("self", "Select "+param_string+" for fitting"))
+        # Unselect from fitting
+        self.actionDeselect = QtWidgets.QAction(self)
+        self.actionDeselect.setObjectName("actionDeselect")
+        self.actionDeselect.setText(QtCore.QCoreApplication.translate("self", "De-select "+param_string+" from fitting"))
+
+        self.actionConstrain = QtWidgets.QAction(self)
+        self.actionConstrain.setObjectName("actionConstrain")
+        self.actionConstrain.setText(QtCore.QCoreApplication.translate("self", "Constrain "+param_string + to_string))
+
+        self.actionRemoveConstraint = QtWidgets.QAction(self)
+        self.actionRemoveConstraint.setObjectName("actionRemoveConstrain")
+        self.actionRemoveConstraint.setText(QtCore.QCoreApplication.translate("self", "Remove constraint"))
+
+        self.actionMultiConstrain = QtWidgets.QAction(self)
+        self.actionMultiConstrain.setObjectName("actionMultiConstrain")
+        self.actionMultiConstrain.setText(QtCore.QCoreApplication.translate("self", "Constrain selected parameters to their current values"))
+
+        self.actionMutualMultiConstrain = QtWidgets.QAction(self)
+        self.actionMutualMultiConstrain.setObjectName("actionMutualMultiConstrain")
+        self.actionMutualMultiConstrain.setText(QtCore.QCoreApplication.translate("self", "Mutual constrain of selected parameters..."))
+
+        menu.addAction(self.actionSelect)
+        menu.addAction(self.actionDeselect)
+        menu.addSeparator()
+
+        if has_constraints:
+            menu.addAction(self.actionRemoveConstraint)
+            #if num_rows == 1:
+            #    menu.addAction(self.actionEditConstraint)
+        else:
+            menu.addAction(self.actionConstrain)
+            if num_rows == 2:
+                menu.addAction(self.actionMutualMultiConstrain)
+
+        # Define the callbacks
+        self.actionConstrain.triggered.connect(self.addSimpleConstraint)
+        self.actionRemoveConstraint.triggered.connect(self.deleteConstraint)
+        self.actionMutualMultiConstrain.triggered.connect(self.showMultiConstraint)
+        self.actionSelect.triggered.connect(self.selectParameters)
+        self.actionDeselect.triggered.connect(self.deselectParameters)
+        return menu
+
+    def showMultiConstraint(self):
+        """
+        Show the constraint widget and receive the expression
+        """
+        selected_rows = self.lstParams.selectionModel().selectedRows()
+        # There have to be only two rows selected. The caller takes care of that
+        # but let's check the correctness.
+        assert(len(selected_rows)==2)
+
+        params_list = [s.data() for s in selected_rows]
+        # Create and display the widget for param1 and param2
+        mc_widget = MultiConstraint(self, params=params_list)
+        if mc_widget.exec_() != QtWidgets.QDialog.Accepted:
+            return
+
+        constraint = Constraint()
+        c_text = mc_widget.txtConstraint.text()
+
+        # widget.params[0] is the parameter we're constraining
+        constraint.param = mc_widget.params[0]
+        # Function should have the model name preamble
+        model_name = self.kernel_module.name
+        constraint.func = model_name + "." + c_text
+        # Which row is the constrained parameter in?
+        row = self.getRowFromName(constraint.param)
+
+        # Create a new item and add the Constraint object as a child
+        self.addConstraintToRow(constraint=constraint, row=row)
+
+    def getRowFromName(self, name):
+        """
+        Given parameter name get the row number in self._model_model
+        """
+        for row in range(self._model_model.rowCount()):
+            row_name = self._model_model.item(row).text()
+            if row_name == name:
+                return row
+        return None
+
+    def getParamNames(self):
+        """
+        Return list of all parameters for the current model
+        """
+        return [self._model_model.item(row).text() for row in range(self._model_model.rowCount())]
+
+    def modifyViewOnRow(self, row, font=None, brush=None):
+        """
+        Chage how the given row of the main model is shown
+        """
+        fields_enabled = False
+        if font is None:
+            font = QtGui.QFont()
+            fields_enabled = True
+        if brush is None:
+            brush = QtGui.QBrush()
+            fields_enabled = True
+        self._model_model.blockSignals(True)
+        # Modify font and foreground of affected rows
+        for column in range(0, self._model_model.columnCount()):
+            self._model_model.item(row, column).setForeground(brush)
+            self._model_model.item(row, column).setFont(font)
+            self._model_model.item(row, column).setEditable(fields_enabled)
+        self._model_model.blockSignals(False)
+
+    def addConstraintToRow(self, constraint=None, row=0):
+        """
+        Adds the constraint object to requested row
+        """
+        # Create a new item and add the Constraint object as a child
+        assert(isinstance(constraint, Constraint))
+        assert(0<=row<=self._model_model.rowCount())
+
+        item = QtGui.QStandardItem()
+        item.setData(constraint)
+        self._model_model.item(row, 1).setChild(0, item)
+        # Set min/max to the value constrained
+        self.constraintAddedSignal.emit([row])
+        # Show visual hints for the constraint
+        font = QtGui.QFont()
+        font.setItalic(True)
+        brush = QtGui.QBrush(QtGui.QColor('blue'))
+        self.modifyViewOnRow(row, font=font, brush=brush)
+        self.communicate.statusBarUpdateSignal.emit('Constraint added')
+
+    def addSimpleConstraint(self):
+        """
+        Adds a constraint on a single parameter.
+        """
+        min_col = self.lstParams.itemDelegate().param_min
+        max_col = self.lstParams.itemDelegate().param_max
+        for row in self.selectedParameters():
+            param = self._model_model.item(row, 0).text()
+            value = self._model_model.item(row, 1).text()
+            min_t = self._model_model.item(row, min_col).text()
+            max_t = self._model_model.item(row, max_col).text()
+            # Create a Constraint object
+            constraint = Constraint(param=param, value=value, min=min_t, max=max_t)
+            # Create a new item and add the Constraint object as a child
+            item = QtGui.QStandardItem()
+            item.setData(constraint)
+            self._model_model.item(row, 1).setChild(0, item)
+            # Assumed correctness from the validator
+            value = float(value)
+            # BUMPS calculates log(max-min) without any checks, so let's assign minor range
+            min_v = value - (value/10000.0)
+            max_v = value + (value/10000.0)
+            # Set min/max to the value constrained
+            self._model_model.item(row, min_col).setText(str(min_v))
+            self._model_model.item(row, max_col).setText(str(max_v))
+            self.constraintAddedSignal.emit([row])
+            # Show visual hints for the constraint
+            font = QtGui.QFont()
+            font.setItalic(True)
+            brush = QtGui.QBrush(QtGui.QColor('blue'))
+            self.modifyViewOnRow(row, font=font, brush=brush)
+        self.communicate.statusBarUpdateSignal.emit('Constraint added')
+
+    def deleteConstraint(self):
+        """
+        Delete constraints from selected parameters.
+        """
+        self.deleteConstraintOnParameter(param=None)
+
+    def deleteConstraintOnParameter(self, param=None):
+        """
+        Delete the constraint on model parameter 'param'
+        """
+        min_col = self.lstParams.itemDelegate().param_min
+        max_col = self.lstParams.itemDelegate().param_max
+        for row in range(self._model_model.rowCount()):
+            # Get the Constraint object from of the model item
+            item = self._model_model.item(row, 1)
+            if not item.hasChildren():
+                continue
+            constraint = item.child(0).data()
+            if constraint is None:
+                continue
+            if not isinstance(constraint, Constraint):
+                continue
+            if param and constraint.param != param:
+                continue
+            # Now we got the right row. Delete the constraint and clean up
+            # Retrieve old values and put them on the model
+            if constraint.min is not None:
+                self._model_model.item(row, min_col).setText(constraint.min)
+            if constraint.max is not None:
+                self._model_model.item(row, max_col).setText(constraint.max)
+            # Remove constraint item
+            item.removeRow(0)
+            self.constraintAddedSignal.emit([row])
+            self.modifyViewOnRow(row)
+
+        self.communicate.statusBarUpdateSignal.emit('Constraint removed')
+
+    def getConstraintForRow(self, row):
+        """
+        For the given row, return its constraint, if any
+        """
+        try:
+            item = self._model_model.item(row, 1)
+            return item.child(0).data()
+        except AttributeError:
+            # return none when no constraints
+            return None
+
+    def rowHasConstraint(self, row):
+        """
+        Finds out if row of the main model has a constraint child
+        """
+        item = self._model_model.item(row,1)
+        if item.hasChildren():
+            c = item.child(0).data()
+            if isinstance(c, Constraint):
+                return True
+        return False
+
+    def rowHasActiveConstraint(self, row):
+        """
+        Finds out if row of the main model has an active constraint child
+        """
+        item = self._model_model.item(row,1)
+        if item.hasChildren():
+            c = item.child(0).data()
+            if isinstance(c, Constraint) and c.active:
+                return True
+        return False
+
+    def rowHasActiveComplexConstraint(self, row):
+        """
+        Finds out if row of the main model has an active, nontrivial constraint child
+        """
+        item = self._model_model.item(row,1)
+        if item.hasChildren():
+            c = item.child(0).data()
+            if isinstance(c, Constraint) and c.func and c.active:
+                return True
+        return False
+
+    def selectParameters(self):
+        """
+        Selected parameter is chosen for fitting
+        """
+        status = QtCore.Qt.Checked
+        self.setParameterSelection(status)
+
+    def deselectParameters(self):
+        """
+        Selected parameters are removed for fitting
+        """
+        status = QtCore.Qt.Unchecked
+        self.setParameterSelection(status)
+
+    def selectedParameters(self):
+        """ Returns list of selected (highlighted) parameters """
+        return [s.row() for s in self.lstParams.selectionModel().selectedRows()
+                if self.isCheckable(s.row())]
+
+    def setParameterSelection(self, status=QtCore.Qt.Unchecked):
+        """
+        Selected parameters are chosen for fitting
+        """
+        # Convert to proper indices and set requested enablement
+        for row in self.selectedParameters():
+            self._model_model.item(row, 0).setCheckState(status)
+
+    def getConstraintsForModel(self):
+        """
+        Return a list of tuples. Each tuple contains constraints mapped as
+        ('constrained parameter', 'function to constrain')
+        e.g. [('sld','5*sld_solvent')]
+        """
+        param_number = self._model_model.rowCount()
+        params = [(self._model_model.item(s, 0).text(),
+                    self._model_model.item(s, 1).child(0).data().func)
+                    for s in range(param_number) if self.rowHasActiveConstraint(s)]
+        return params
+
+    def getComplexConstraintsForModel(self):
+        """
+        Return a list of tuples. Each tuple contains constraints mapped as
+        ('constrained parameter', 'function to constrain')
+        e.g. [('sld','5*M2.sld_solvent')].
+        Only for constraints with defined VALUE
+        """
+        param_number = self._model_model.rowCount()
+        params = [(self._model_model.item(s, 0).text(),
+                    self._model_model.item(s, 1).child(0).data().func)
+                    for s in range(param_number) if self.rowHasActiveComplexConstraint(s)]
+        return params
+
+    def getConstraintObjectsForModel(self):
+        """
+        Returns Constraint objects present on the whole model
+        """
+        param_number = self._model_model.rowCount()
+        constraints = [self._model_model.item(s, 1).child(0).data()
+                       for s in range(param_number) if self.rowHasConstraint(s)]
+
+        return constraints
+
+    def showModelDescription(self):
+        """
+        Creates a window with model description, when right clicked in the treeview
         """
         msg = 'Model description:\n'
@@ -466 +831 @@
         action.setDefaultWidget(label)
         menu.addAction(action)
-        menu.exec_(self.lstParams.viewport().mapToGlobal(position))
+        return menu
 
     def onSelectModel(self):
@@ -506 +871 @@
         self.respondToModelStructure(model=model, structure_factor=structure)
 
-    def respondToModelStructure(self, model=None, structure_factor=None):
-        # Set enablement on calculate/plot
-        self.cmdPlot.setEnabled(True)
-
-        # kernel parameters -> model_model
-        self.SASModelToQModel(model, structure_factor)
-
+    def replaceConstraintName(self, old_name, new_name=""):
+        """
+        Replace names of models in defined constraints
+        """
+        param_number = self._model_model.rowCount()
+        # loop over parameters
+        for row in range(param_number):
+            if self.rowHasConstraint(row):
+                func = self._model_model.item(row, 1).child(0).data().func
+                if old_name in func:
+                    new_func = func.replace(old_name, new_name)
+                    self._model_model.item(row, 1).child(0).data().func = new_func
+
+    def updateData(self):
+        """
+        Helper function for recalculation of data used in plotting
+        """
+        # Update the chart
         if self.data_is_loaded:
             self.cmdPlot.setText("Show Plot")
@@ -521 +897 @@
             self.createDefaultDataset()
 
+    def respondToModelStructure(self, model=None, structure_factor=None):
+        # Set enablement on calculate/plot
+        self.cmdPlot.setEnabled(True)
+
+        # kernel parameters -> model_model
+        self.SASModelToQModel(model, structure_factor)
+
+        # Update plot
+        self.updateData()
+
         # Update state stack
         self.updateUndo()
+
+        # Let others know
+        self.newModelSignal.emit()
 
     def onSelectCategory(self):
@@ -596 +985 @@
             # name of the function - just pass
             return
-        elif model_column == self.lstPoly.itemDelegate().poly_filename:
-            # filename for array - just pass
-            return
         else:
             try:
@@ -610 +996 @@
             self.kernel_module.setParam(parameter_name + '.' + \
                                         self.lstPoly.itemDelegate().columnDict()[model_column], value)
+
+            # Update plot
+            self.updateData()
 
     def onMagnetModelChange(self, item):
@@ -693 +1082 @@
         Perform fitting on the current data
         """
-
-        # Data going in
-        data = self.logic.data
-        model = self.kernel_module
-        qmin = self.q_range_min
-        qmax = self.q_range_max
-        params_to_fit = self.parameters_to_fit
-
-        # Potential weights added directly to data
-        self.addWeightingToData(data)
-
-        # Potential smearing added
-        # Remember that smearing_min/max can be None ->
-        # deal with it until Python gets discriminated unions
-        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state()
-
-        # These should be updating somehow?
+        # initialize fitter constants
         fit_id = 0
-        constraints = []
-        smearer = None
-        page_id = [210]
         handler = None
         batch_inputs = {}
         batch_outputs = {}
-        list_page_id = [page_id]
         #---------------------------------
-        if USING_TWISTED:
+        if LocalConfig.USING_TWISTED:
             handler = None
             updater = None
@@ -728 +1097 @@
             updater = handler.update_fit
 
-        # Parameterize the fitter
-        fitters = []
-        for fit_index in self.all_data:
-            fitter = Fit()
-            data = GuiUtils.dataFromItem(fit_index)
-            try:
-                fitter.set_model(model, fit_id, params_to_fit, data=data,
-                             constraints=constraints)
-            except ValueError as ex:
-                logging.error("Setting model parameters failed with: %s" % ex)
-                return
-
-            qmin, qmax, _ = self.logic.computeRangeFromData(data)
-            fitter.set_data(data=data, id=fit_id, smearer=smearer, qmin=qmin,
-                            qmax=qmax)
-            fitter.select_problem_for_fit(id=fit_id, value=1)
-            fitter.fitter_id = page_id
-            fit_id += 1
-            fitters.append(fitter)
+        # Prepare the fitter object
+        try:
+            fitters, _ = self.prepareFitters()
+        except ValueError as ex:
+            # This should not happen! GUI explicitly forbids this situation
+            self.communicate.statusBarUpdateSignal.emit('Fitting attempt without parameters.')
+            return
 
         # Create the fitting thread, based on the fitter
@@ -752 +1109 @@
 
         calc_fit = FitThread(handler=handler,
-                                fn=fitters,
-                                batch_inputs=batch_inputs,
-                                batch_outputs=batch_outputs,
-                                page_id=list_page_id,
-                                updatefn=updater,
-                                completefn=completefn)
-
-        if USING_TWISTED:
+                            fn=fitters,
+                            batch_inputs=batch_inputs,
+                            batch_outputs=batch_outputs,
+                            page_id=[[self.page_id]],
+                            updatefn=updater,
+                            completefn=completefn)
+
+        if LocalConfig.USING_TWISTED:
             # start the trhrhread with twisted
             calc_thread = threads.deferToThread(calc_fit.compute)
-            calc_thread.addCallback(self.fitComplete)
+            calc_thread.addCallback(completefn)
             calc_thread.addErrback(self.fitFailed)
         else:
@@ -769 +1126 @@
             calc_fit.ready(2.5)
 
-
-        #disable the Fit button
-        self.cmdFit.setText('Running...')
         self.communicate.statusBarUpdateSignal.emit('Fitting started...')
-        self.cmdFit.setEnabled(False)
+        # Disable some elements
+        self.setFittingStarted()
 
     def updateFit(self):
@@ -792 +1147 @@
         """
         #re-enable the Fit button
-        self.cmdFit.setText("Fit")
-        self.cmdFit.setEnabled(True)
-
-        print ("BATCH FITTING FINISHED")
-        # Add the Qt version of wx.aui.AuiNotebook and populate it
-        pass
+        self.setFittingStopped()
 
     def fitComplete(self, result):
@@ -805 +1155 @@
         """
         #re-enable the Fit button
-        self.cmdFit.setText("Fit")
-        self.cmdFit.setEnabled(True)
-
-        assert result is not None
+        self.setFittingStopped()
+
+        #assert result is not None
+        if assert in None:
+            msg = "Fitting failed after: %s s.\n" % GuiUtils.formatNumber(elapsed)
+            self.communicate.statusBarUpdateSignal.emit(msg)
+            return
 
         res_list = result[0][0]
@@ -816 +1169 @@
             np.any(res.pvec is None) or \
             not np.all(np.isfinite(res.pvec)):
-            msg = "Fitting did not converge!!!"
+            msg = "Fitting did not converge!"
             self.communicate.statusBarUpdateSignal.emit(msg)
             logging.error(msg)
@@ -846 +1199 @@
         chi2_repr = GuiUtils.formatNumber(self.chi2, high=True)
         self.lblChi2Value.setText(chi2_repr)
+
+    def prepareFitters(self, fitter=None, fit_id=0):
+        """
+        Prepare the Fitter object for use in fitting
+        """
+        # fitter = None -> single/batch fitting
+        # fitter = Fit() -> simultaneous fitting
+
+        # Data going in
+        data = self.logic.data
+        model = self.kernel_module
+        qmin = self.q_range_min
+        qmax = self.q_range_max
+        params_to_fit = self.parameters_to_fit
+        if (not params_to_fit):
+            raise ValueError('Fitting requires at least one parameter to optimize.')
+
+        # Potential weights added directly to data
+        self.addWeightingToData(data)
+
+        # Potential smearing added
+        # Remember that smearing_min/max can be None ->
+        # deal with it until Python gets discriminated unions
+        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state()
+
+        constraints = self.getComplexConstraintsForModel()
+        smearer = None
+        handler = None
+        batch_inputs = {}
+        batch_outputs = {}
+
+        fitters = []
+        for fit_index in self.all_data:
+            fitter_single = Fit() if fitter is None else fitter
+            data = GuiUtils.dataFromItem(fit_index)
+            try:
+                fitter_single.set_model(model, fit_id, params_to_fit, data=data,
+                             constraints=constraints)
+            except ValueError as ex:
+                logging.error("Setting model parameters failed with: %s" % ex)
+                return
+
+            qmin, qmax, _ = self.logic.computeRangeFromData(data)
+            fitter_single.set_data(data=data, id=fit_id, smearer=smearer, qmin=qmin,
+                            qmax=qmax)
+            fitter_single.select_problem_for_fit(id=fit_id, value=1)
+            if fitter is None:
+                # Assign id to the new fitter only
+                fitter_single.fitter_id = [self.page_id]
+            fit_id += 1
+            fitters.append(fitter_single)
+
+        return fitters, fit_id
 
     def iterateOverModel(self, func):
@@ -1240 +1646 @@
         # Now we claim the model has been loaded
         self.model_is_loaded = True
+        # Change the model name to a monicker
+        self.kernel_module.name = self.modelName()
 
         # (Re)-create headers
@@ -1344 +1752 @@
         self.updateUndo()
 
+    def isCheckable(self, row):
+        return self._model_model.item(row, 0).isCheckable()
+
     def checkboxSelected(self, item):
         # Assure we're dealing with checkboxes
@@ -1350 +1761 @@
         status = item.checkState()
 
-        def isCheckable(row):
-            return self._model_model.item(row, 0).isCheckable()
-
         # If multiple rows selected - toggle all of them, filtering uncheckable
-        rows = [s.row() for s in self.lstParams.selectionModel().selectedRows() if isCheckable(s.row())]
-
         # Switch off signaling from the model to avoid recursion
         self._model_model.blockSignals(True)
         # Convert to proper indices and set requested enablement
-        [self._model_model.item(row, 0).setCheckState(status) for row in rows]
+        self.setParameterSelection(status)
+        #[self._model_model.item(row, 0).setCheckState(status) for row in self.selectedParameters()]
         self._model_model.blockSignals(False)
 
@@ -1382 +1789 @@
                 for row_index in range(model.rowCount())
                 if isChecked(row_index)]
-
-    def nameForFittedData(self, name):
-        """
-        Generate name for the current fit
-        """
-        if self.is2D:
-            name += "2d"
-        name = "M%i [%s]" % (self.tab_id, name)
-        return name
 
     def createNewIndex(self, fitted_data):
@@ -1832 +2230 @@
         self.setMagneticModel()
 
+    def setFittingStarted(self):
+        """
+        Set item enablement on fitting start
+        """
+        #disable the Fit button
+        self.cmdFit.setText('Running...')
+        self.cmdFit.setEnabled(False)
+
+    def setFittingStopped(self):
+        """
+        Set item enablement on fitting stop
+        """
+        #enable the Fit button
+        self.cmdFit.setText("Fit")
+        self.cmdFit.setEnabled(True)
+
     def readFitPage(self, fp):
         """

src/sas/qtgui/Perspectives/Fitting/UI/FittingWidgetUI.ui

@@ -7 +7 @@
     <x>0</x>
     <y>0</y>
-    <width>434</width>
-    <height>466</height>
+    <width>448</width>
+    <height>526</height>
    </rect>
   </property>
@@ -26 +26 @@
    <string>FittingWidget</string>
   </property>
-  <layout class="QGridLayout" name="gridLayout_4">
-   <item row="0" column="0" colspan="4">
+  <layout class="QGridLayout" name="gridLayout_5">
+   <item row="0" column="0">
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
@@ -72 +72 @@
     </layout>
    </item>
-   <item row="1" column="0" colspan="4">
+   <item row="1" column="0">
     <widget class="QTabWidget" name="tabFitting">
      <property name="currentIndex">
@@ -81 +81 @@
        <string>Model</string>
       </attribute>
-      <layout class="QGridLayout" name="gridLayout_19">
+      <layout class="QGridLayout" name="gridLayout_4">
        <item row="0" column="0" colspan="4">
         <widget class="QGroupBox" name="groupBox_6">
@@ -161 +161 @@
           <string>Options </string>
          </property>
-         <layout class="QGridLayout" name="gridLayout_16">
-          <item row="0" column="0">
+         <layout class="QVBoxLayout" name="verticalLayout">
+          <item>
            <widget class="QCheckBox" name="chkPolydispersity">
             <property name="enabled">
@@ -178 +178 @@
            </widget>
           </item>
-          <item row="1" column="0">
+          <item>
            <widget class="QCheckBox" name="chk2DView">
             <property name="enabled">
@@ -194 +194 @@
            </widget>
           </item>
-          <item row="2" column="0">
+          <item>
            <widget class="QCheckBox" name="chkMagnetism">
             <property name="enabled">
@@ -204 +204 @@
             <property name="text">
              <string>Magnetism</string>
+            </property>
+            <property name="checkable">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="chkChainFit">
+            <property name="enabled">
+             <bool>true</bool>
+            </property>
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Switch on magnetic scattering parameters.&lt;/p&gt;&lt;p&gt;This option is available only for 2D models.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+            <property name="text">
+             <string>Chain fit</string>
             </property>
             <property name="checkable">
@@ -412 +428 @@
    </item>
    <item row="2" column="0">
-    <spacer name="horizontalSpacer">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>273</width>
-       <height>20</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-   <item row="2" column="1">
-    <widget class="QPushButton" name="cmdPlot">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="minimumSize">
-      <size>
-       <width>75</width>
-       <height>23</height>
-      </size>
-     </property>
-     <property name="text">
-      <string>Show Plot</string>
-     </property>
-    </widget>
-   </item>
-   <item row="2" column="2">
-    <widget class="QPushButton" name="cmdFit">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="minimumSize">
-      <size>
-       <width>75</width>
-       <height>23</height>
-      </size>
-     </property>
-     <property name="text">
-      <string>Fit</string>
-     </property>
-    </widget>
-   </item>
-   <item row="2" column="3">
-    <widget class="QPushButton" name="cmdHelp">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="minimumSize">
-      <size>
-       <width>75</width>
-       <height>23</height>
-      </size>
-     </property>
-     <property name="text">
-      <string>Help</string>
-     </property>
-    </widget>
+    <layout class="QHBoxLayout" name="horizontalLayout_3">
+     <item>
+      <spacer name="horizontalSpacer">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>273</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QPushButton" name="cmdPlot">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>75</width>
+         <height>23</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>Show Plot</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="cmdFit">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>75</width>
+         <height>23</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>Fit</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="cmdHelp">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>75</width>
+         <height>23</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>Help</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
    </item>
   </layout>

src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingOptionsTest.py

@@ -1 +1 @@
 import sys
 import unittest
+import webbrowser
 from bumps import options
 
 from PyQt5 import QtGui, QtWidgets
-from PyQt5 import QtWebKit
 
 from unittest.mock import MagicMock
@@ -114 +114 @@
 
     # test disabled until pyQt5 works well
-    def notestOnHelp(self):
+    def testOnHelp(self):
         ''' Test help display'''
-        #Mock the QWebView method
-        QtWebKit.QWebView.show = MagicMock()
-        QtWebKit.QWebView.load = MagicMock()
+        webbrowser.open = MagicMock()
 
         # Invoke the action on default tab
         self.widget.onHelp()
         # Check if show() got called
-        self.assertTrue(QtWebKit.QWebView.show.called)
+        self.assertTrue(webbrowser.open.called)
         # Assure the filename is correct
-        self.assertIn("optimizer.html", QtWebKit.QWebView.load.call_args[0][0].toString())
+        self.assertIn("optimizer.html", webbrowser.open.call_args[0][0])
 
         # Change the combo index
@@ -131 +129 @@
         self.widget.onHelp()
         # Check if show() got called
-        self.assertEqual(QtWebKit.QWebView.show.call_count, 2)
+        self.assertEqual(webbrowser.open.call_count, 2)
         # Assure the filename is correct
-        self.assertIn("fit-dream", QtWebKit.QWebView.load.call_args[0][0].toString())
+        self.assertIn("fit-dream", webbrowser.open.call_args[0][0])
 
         # Change the index again
@@ -139 +137 @@
         self.widget.onHelp()
         # Check if show() got called
-        self.assertEqual(QtWebKit.QWebView.show.call_count, 3)
+        self.assertEqual(webbrowser.open.call_count, 3)
         # Assure the filename is correct
-        self.assertIn("fit-lm", QtWebKit.QWebView.load.call_args[0][0].toString())
+        self.assertIn("fit-lm", webbrowser.open.call_args[0][0])
 
     def testWidgetFromOptions(self):

src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingPerspectiveTest.py

@@ -19 +19 @@
 if not QtWidgets.QApplication.instance():
     app = QtWidgets.QApplication(sys.argv)
+
 
 class FittingPerspectiveTest(unittest.TestCase):
@@ -44 +45 @@
         self.assertEqual(len(self.widget.tabs), 1)
         self.assertEqual(self.widget.maxIndex, 1)
-        self.assertEqual(self.widget.tabName(), "FitPage1")
+        self.assertEqual(self.widget.maxCSIndex, 0)
+        self.assertEqual(self.widget.getTabName(), "FitPage1")
 
     def testAddTab(self):
@@ -52 +54 @@
         self.widget.addFit(None)
         self.assertEqual(len(self.widget.tabs), 2)
-        self.assertEqual(self.widget.tabName(), "FitPage2")
+        self.assertEqual(self.widget.getTabName(), "FitPage2")
         self.assertEqual(self.widget.maxIndex, 2)
         # Add an empty batch tab
         self.widget.addFit(None, is_batch=True)
         self.assertEqual(len(self.widget.tabs), 3)
-        self.assertEqual(self.widget.tabName(2), "BatchPage3")
+        self.assertEqual(self.widget.getTabName(2), "BatchPage3")
         self.assertEqual(self.widget.maxIndex, 3)
+
+    def testAddCSTab(self):
+        ''' Add a constraint/simult tab'''
+        self.widget.addConstraintTab()
+        self.assertEqual(len(self.widget.tabs), 2)
+        self.assertEqual(self.widget.getCSTabName(), "Const. & Simul. Fit1")
+        self.assertEqual(self.widget.maxCSIndex, 1)
 
     def testResetTab(self):
         ''' Remove data from last tab'''
         self.assertEqual(len(self.widget.tabs), 1)
-        self.assertEqual(self.widget.tabName(), "FitPage1")
+        self.assertEqual(self.widget.getTabName(), "FitPage1")
         self.assertEqual(self.widget.maxIndex, 1)
 
@@ -71 +80 @@
         # see that the tab didn't disappear, just changed the name/id
         self.assertEqual(len(self.widget.tabs), 1)
-        self.assertEqual(self.widget.tabName(), "FitPage2")
+        self.assertEqual(self.widget.getTabName(), "FitPage2")
         self.assertEqual(self.widget.maxIndex, 2)
 
@@ -95 +104 @@
         self.assertEqual(len(self.widget.tabs), 1)
         self.assertEqual(self.widget.maxIndex, 2)
-        self.assertEqual(self.widget.tabName(), "FitPage2")
+        self.assertEqual(self.widget.getTabName(), "FitPage2")
 
         # Attemtp to remove the last tab
@@ -102 +111 @@
         self.assertEqual(len(self.widget.tabs), 1)
         self.assertEqual(self.widget.maxIndex, 3)
-        self.assertEqual(self.widget.tabName(), "FitPage3")
+        self.assertEqual(self.widget.getTabName(), "FitPage3")
 
     def testAllowBatch(self):
@@ -138 +147 @@
         self.assertEqual(len(self.widget.tabs), 4)
 
+    def testSetBatchData(self):
+        ''' Assure that setting batch data is correct'''
+
+        # Mock the datafromitem() call from FittingWidget
+        data1 = Data1D(x=[1,2], y=[1,2])
+        data2 = Data1D(x=[1,2], y=[1,2])
+        data_batch = [data1, data2]
+        GuiUtils.dataFromItem = MagicMock(return_value=data1)
+
+        item = QtGui.QStandardItem("test")
+        self.widget.setData([item, item], is_batch=True)
+
+        # First tab should not accept data
+        self.assertEqual(len(self.widget.tabs), 2)
+
+        # Add another set of data
+        self.widget.setData([item, item], is_batch=True)
+
+        # Now we should have two batch tabs
+        self.assertEqual(len(self.widget.tabs), 3)
+
+        # Check the names of the new tabs
+        self.assertEqual(self.widget.tabText(1), "BatchPage1")
+        self.assertEqual(self.widget.tabText(2), "BatchPage2")
 
 if __name__ == "__main__":

src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py

@@ -17 +17 @@
 from sas.qtgui.Utilities.GuiUtils import *
 from sas.qtgui.Perspectives.Fitting.FittingWidget import *
+from sas.qtgui.Perspectives.Fitting.Constraint import Constraint
+
 from sas.qtgui.UnitTesting.TestUtils import QtSignalSpy
 
@@ -112 +114 @@
         fittingWindow =  self.widget
 
-        self.assertIsInstance(fittingWindow.lstMagnetic.itemDelegate(), QtGui.QStyledItemDelegate)
+        self.assertIsInstance(fittingWindow.lstMagnetic.itemDelegate(), QtWidgets.QStyledItemDelegate)
         #Test loading from json categories
         fittingWindow.SASModelToQModel("cylinder")
         mag_index = fittingWindow.lstMagnetic.model().index(0,0)
-        self.assertEqual(str(mag_index.data().toString()), "up:frac_i")
+        self.assertEqual(mag_index.data(), "up:frac_i")
         mag_index = fittingWindow.lstMagnetic.model().index(1,0)
-        self.assertEqual(str(mag_index.data().toString()), "up:frac_f")
+        self.assertEqual(mag_index.data(), "up:frac_f")
         mag_index = fittingWindow.lstMagnetic.model().index(2,0)
-        self.assertEqual(str(mag_index.data().toString()), "up:angle")
+        self.assertEqual(mag_index.data(), "up:angle")
         mag_index = fittingWindow.lstMagnetic.model().index(3,0)
-        self.assertEqual(str(mag_index.data().toString()), "M0:sld")
+        self.assertEqual(mag_index.data(), "M0:sld")
         mag_index = fittingWindow.lstMagnetic.model().index(4,0)
-        self.assertEqual(str(mag_index.data().toString()), "mtheta:sld")
+        self.assertEqual(mag_index.data(), "mtheta:sld")
         mag_index = fittingWindow.lstMagnetic.model().index(5,0)
-        self.assertEqual(str(mag_index.data().toString()), "mphi:sld")
+        self.assertEqual(mag_index.data(), "mphi:sld")
         mag_index = fittingWindow.lstMagnetic.model().index(6,0)
-        self.assertEqual(str(mag_index.data().toString()), "M0:sld_solvent")
+        self.assertEqual(mag_index.data(), "M0:sld_solvent")
         mag_index = fittingWindow.lstMagnetic.model().index(7,0)
-        self.assertEqual(str(mag_index.data().toString()), "mtheta:sld_solvent")
+        self.assertEqual(mag_index.data(), "mtheta:sld_solvent")
         mag_index = fittingWindow.lstMagnetic.model().index(8,0)
-        self.assertEqual(str(mag_index.data().toString()), "mphi:sld_solvent")
+        self.assertEqual(mag_index.data(), "mphi:sld_solvent")
 
         # test the delegate a bit
         delegate = fittingWindow.lstMagnetic.itemDelegate()
         self.assertEqual(delegate.editableParameters(), [1, 2, 3])
-        self.assertIsInstance(delegate.combo_updated, QtCore.pyqtBoundSignal)
 
     def testSelectStructureFactor(self):
@@ -662 +663 @@
         test_data = Data1D(x=[1,2], y=[1,2])
         item = QtGui.QStandardItem()
-        updateModelItem(item, [test_data], "test")
+        updateModelItem(item, test_data, "test")
         # Force same data into logic
         self.widget.data = item
@@ -688 +689 @@
         # Force same data into logic
         item = QtGui.QStandardItem()
-        updateModelItem(item, [test_data], "test")
+        updateModelItem(item, test_data, "test")
         # Force same data into logic
         self.widget.data = item
@@ -714 +715 @@
         test_data = Data1D(x=[1,2], y=[1,2])
         item = QtGui.QStandardItem()
-        updateModelItem(item, [test_data], "test")
+        updateModelItem(item, test_data, "test")
         # Force same data into logic
         self.widget.data = item
@@ -758 +759 @@
         # Force same data into logic
         item = QtGui.QStandardItem()
-        updateModelItem(item, [test_data], "test")
+        updateModelItem(item, test_data, "test")
         # Force same data into logic
         self.widget.data = item
@@ -786 +787 @@
             self.assertEqual(update_spy.count(), 1)
 
-    # test disabled until pyqt5 deals with html properly
-    def notestOnHelp(self):
+    def testOnHelp(self):
         """
         Test various help pages shown in this widget
         """
-        #Mock the QWebView method
-        QtWebKit.QWebView.show = MagicMock()
-        QtWebKit.QWebView.load = MagicMock()
+        #Mock the webbrowser.open method
+        self.widget.parent.showHelp = MagicMock()
+        #webbrowser.open = MagicMock()
 
         # Invoke the action on default tab
         self.widget.onHelp()
         # Check if show() got called
-        self.assertTrue(QtWebKit.QWebView.show.called)
+        self.assertTrue(self.widget.parent.showHelp.called)
         # Assure the filename is correct
-        self.assertIn("fitting_help.html", QtWebKit.QWebView.load.call_args[0][0].toString())
+        self.assertIn("fitting_help.html", self.widget.parent.showHelp.call_args[0][0])
 
         # Change the tab to options
@@ -806 +806 @@
         self.widget.onHelp()
         # Check if show() got called
-        self.assertEqual(QtWebKit.QWebView.show.call_count, 2)
+        self.assertEqual(self.widget.parent.showHelp.call_count, 2)
         # Assure the filename is correct
-        self.assertIn("residuals_help.html", QtWebKit.QWebView.load.call_args[0][0].toString())
+        self.assertIn("residuals_help.html", self.widget.parent.showHelp.call_args[0][0])
 
         # Change the tab to smearing
@@ -814 +814 @@
         self.widget.onHelp()
         # Check if show() got called
-        self.assertEqual(QtWebKit.QWebView.show.call_count, 3)
+        self.assertEqual(self.widget.parent.showHelp.call_count, 3)
         # Assure the filename is correct
-        self.assertIn("sm_help.html", QtWebKit.QWebView.load.call_args[0][0].toString())
+        self.assertIn("resolution.html", self.widget.parent.showHelp.call_args[0][0])
 
         # Change the tab to poly
@@ -822 +822 @@
         self.widget.onHelp()
         # Check if show() got called
-        self.assertEqual(QtWebKit.QWebView.show.call_count, 4)
+        self.assertEqual(self.widget.parent.showHelp.call_count, 4)
         # Assure the filename is correct
-        self.assertIn("pd_help.html", QtWebKit.QWebView.load.call_args[0][0].toString())
+        self.assertIn("polydispersity.html", self.widget.parent.showHelp.call_args[0][0])
 
         # Change the tab to magnetism
@@ -830 +830 @@
         self.widget.onHelp()
         # Check if show() got called
-        self.assertEqual(QtWebKit.QWebView.show.call_count, 5)
+        self.assertEqual(self.widget.parent.showHelp.call_count, 5)
         # Assure the filename is correct
-        self.assertIn("mag_help.html", QtWebKit.QWebView.load.call_args[0][0].toString())
+        self.assertIn("magnetism.html", self.widget.parent.showHelp.call_args[0][0])
 
     def testReadFitPage(self):
@@ -1026 +1026 @@
         self.assertNotIn(new_value, self.widget.kernel_module.details[name_modified_param] )
 
+    def testModelContextMenu(self):
+        """
+        Test the right click context menu in the parameter table
+        """
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        # no rows selected
+        menu = self.widget.modelContextMenu([])
+        self.assertEqual(len(menu.actions()), 0)
+
+        # 1 row selected
+        menu = self.widget.modelContextMenu([1])
+        self.assertEqual(len(menu.actions()), 4)
+
+        # 2 rows selected
+        menu = self.widget.modelContextMenu([1,3])
+        self.assertEqual(len(menu.actions()), 5)
+
+        # 3 rows selected
+        menu = self.widget.modelContextMenu([1,2,3])
+        self.assertEqual(len(menu.actions()), 4)
+
+        # over 9000
+        with self.assertRaises(AttributeError):
+            menu = self.widget.modelContextMenu([i for i in range(9001)])
+        self.assertEqual(len(menu.actions()), 4)
+
+    def testShowModelContextMenu(self):
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        # No selection
+        logging.error = MagicMock()
+        self.widget.showModelDescription = MagicMock()
+        # Show the menu
+        self.widget.showModelContextMenu(QtCore.QPoint(10,20))
+
+        # Assure the description menu is shown
+        self.assertTrue(self.widget.showModelDescription.called)
+        self.assertFalse(logging.error.called)
+
+        # "select" two rows
+        index1 = self.widget.lstParams.model().index(1, 0, QtCore.QModelIndex())
+        index2 = self.widget.lstParams.model().index(2, 0, QtCore.QModelIndex())
+        selection_model = self.widget.lstParams.selectionModel()
+        selection_model.select(index1, selection_model.Select | selection_model.Rows)
+        selection_model.select(index2, selection_model.Select | selection_model.Rows)
+
+        QtWidgets.QMenu.exec_ = MagicMock()
+        logging.error = MagicMock()
+        # Show the menu
+        self.widget.showModelContextMenu(QtCore.QPoint(10,20))
+
+        # Assure the menu is shown
+        self.assertFalse(logging.error.called)
+        self.assertTrue(QtWidgets.QMenu.exec_.called)
+
+    def testShowMultiConstraint(self):
+        """
+        Test the widget update on new multi constraint
+        """
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        # nothing selected
+        with self.assertRaises(AssertionError):
+            self.widget.showMultiConstraint()
+
+        # one row selected
+        index = self.widget.lstParams.model().index(1, 0, QtCore.QModelIndex())
+        selection_model = self.widget.lstParams.selectionModel()
+        selection_model.select(index, selection_model.Select | selection_model.Rows)
+        with self.assertRaises(AssertionError):
+            # should also throw
+            self.widget.showMultiConstraint()
+
+        # two rows selected
+        index1 = self.widget.lstParams.model().index(1, 0, QtCore.QModelIndex())
+        index2 = self.widget.lstParams.model().index(2, 0, QtCore.QModelIndex())
+        selection_model = self.widget.lstParams.selectionModel()
+        selection_model.select(index1, selection_model.Select | selection_model.Rows)
+        selection_model.select(index2, selection_model.Select | selection_model.Rows)
+
+        # return non-OK from dialog
+        QtWidgets.QDialog.exec_ = MagicMock()
+        self.widget.showMultiConstraint()
+        # Check the dialog called
+        self.assertTrue(QtWidgets.QDialog.exec_.called)
+
+        # return OK from dialog
+        QtWidgets.QDialog.exec_ = MagicMock(return_value=QtWidgets.QDialog.Accepted)
+        spy = QtSignalSpy(self.widget, self.widget.constraintAddedSignal)
+
+        self.widget.showMultiConstraint()
+
+        # Make sure the signal has been emitted
+        self.assertEqual(spy.count(), 1)
+
+        # Check the argument value - should be row '1'
+        self.assertEqual(spy.called()[0]['args'][0], [1])
+
+    def testGetRowFromName(self):
+        """
+        Helper function for parameter table
+        """
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        # several random parameters
+        self.assertEqual(self.widget.getRowFromName('scale'), 0)
+        self.assertEqual(self.widget.getRowFromName('length'), 5)
+
+    def testGetParamNames(self):
+        """
+        Helper function for parameter table
+        """
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        cylinder_params = ['scale','background','sld','sld_solvent','radius','length']
+        # assure all parameters are returned
+        self.assertEqual(self.widget.getParamNames(), cylinder_params)
+
+        # Switch to another model
+        model_index = self.widget.cbModel.findText("pringle")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        # make sure the parameters are different than before
+        self.assertFalse(self.widget.getParamNames() == cylinder_params)
+
+    def testAddConstraintToRow(self):
+        """
+        Test the constraint row add operation
+        """
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        # Create a constraint object
+        const = Constraint(parent=None, value=7.0)
+        row = 2
+
+        spy = QtSignalSpy(self.widget, self.widget.constraintAddedSignal)
+
+        # call the method tested
+        self.widget.addConstraintToRow(constraint=const, row=row)
+
+        # Make sure the signal has been emitted
+        self.assertEqual(spy.count(), 1)
+
+        # Check the argument value - should be row 'row'
+        self.assertEqual(spy.called()[0]['args'][0], [row])
+
+        # Assure the row has the constraint
+        self.assertEqual(self.widget.getConstraintForRow(row), const)
+        # but not complex constraint!
+        self.assertFalse(self.widget.rowHasConstraint(row))
+
+        # assign complex constraint now
+        const = Constraint(parent=None, param='radius', func='5*sld')
+        row = 4
+        # call the method tested
+        self.widget.addConstraintToRow(constraint=const, row=row)
+
+        # Make sure the signal has been emitted
+        self.assertEqual(spy.count(), 2)
+
+        # Check the argument value - should be row 'row'
+        self.assertEqual(spy.called()[1]['args'][0], [row])
+
+        # Assure the row has the constraint
+        self.assertEqual(self.widget.getConstraintForRow(row), const)
+        # and it is a complex constraint
+        self.assertTrue(self.widget.rowHasConstraint(row))
+
+    def testAddSimpleConstraint(self):
+        """
+        Test the constraint add operation
+        """
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        # select two rows
+        row1 = 1
+        row2 = 4
+        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex())
+        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex())
+        selection_model = self.widget.lstParams.selectionModel()
+        selection_model.select(index1, selection_model.Select | selection_model.Rows)
+        selection_model.select(index2, selection_model.Select | selection_model.Rows)
+
+        # define the signal spy
+        spy = QtSignalSpy(self.widget, self.widget.constraintAddedSignal)
+
+        # call the method tested
+        self.widget.addSimpleConstraint()
+
+        # Make sure the signal has been emitted
+        self.assertEqual(spy.count(), 2)
+
+        # Check the argument value
+        self.assertEqual(spy.called()[0]['args'][0], [row1])
+        self.assertEqual(spy.called()[1]['args'][0], [row2])
+
+        # Other properties
+        self.assertEqual(self.widget.getConstraintsForModel(), [('background', '0.001'), ('radius', '20')])
+
+    def testDeleteConstraintOnParameter(self):
+        """
+        Test the constraint deletion in model/view
+        """
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        # select two rows
+        row1 = 1
+        row2 = 4
+        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex())
+        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex())
+        selection_model = self.widget.lstParams.selectionModel()
+        selection_model.select(index1, selection_model.Select | selection_model.Rows)
+        selection_model.select(index2, selection_model.Select | selection_model.Rows)
+
+        # add constraints
+        self.widget.addSimpleConstraint()
+
+        # deselect the model
+        selection_model.clear()
+
+        # select a single row
+        selection_model.select(index1, selection_model.Select | selection_model.Rows)
+
+        # delete one of the constraints
+        self.widget.deleteConstraintOnParameter(param='background')
+
+        # see that the other constraint is still present
+        self.assertEqual(self.widget.getConstraintsForModel(), [('radius', '20')])
+
+        # kill the other constraint
+        self.widget.deleteConstraint()
+
+        # see that the other constraint is still present
+        self.assertEqual(self.widget.getConstraintsForModel(), [])
+
+    def testGetConstraintForRow(self):
+        """
+        Helper function for parameter table
+        """
+        # tested extensively elsewhere
+        pass
+
+    def testRowHasConstraint(self):
+        """
+        Helper function for parameter table
+        """
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        # select two rows
+        row1 = 1
+        row2 = 4
+        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex())
+        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex())
+        selection_model = self.widget.lstParams.selectionModel()
+        selection_model.select(index1, selection_model.Select | selection_model.Rows)
+        selection_model.select(index2, selection_model.Select | selection_model.Rows)
+
+        # add constraints
+        self.widget.addSimpleConstraint()
+
+        con_list = [False, True, False, False, True, False]
+        new_list = []
+        for row in range(self.widget._model_model.rowCount()):
+            new_list.append(self.widget.rowHasConstraint(row))
+
+        self.assertEqual(new_list, con_list)
+
+    def testRowHasActiveConstraint(self):
+        """
+        Helper function for parameter table
+        """
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        # select two rows
+        row1 = 1
+        row2 = 4
+        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex())
+        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex())
+        selection_model = self.widget.lstParams.selectionModel()
+        selection_model.select(index1, selection_model.Select | selection_model.Rows)
+        selection_model.select(index2, selection_model.Select | selection_model.Rows)
+
+        # add constraints
+        self.widget.addSimpleConstraint()
+
+        # deactivate the first constraint
+        constraint_objects = self.widget.getConstraintObjectsForModel()
+        constraint_objects[0].active = False
+
+        con_list = [False, False, False, False, True, False]
+        new_list = []
+        for row in range(self.widget._model_model.rowCount()):
+            new_list.append(self.widget.rowHasActiveConstraint(row))
+
+        self.assertEqual(new_list, con_list)
+
+    def testGetConstraintsForModel(self):
+        """
+        Test the constraint getter for constraint texts
+        """
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        # no constraints
+        self.assertEqual(self.widget.getConstraintsForModel(),[])
+
+        # select two rows
+        row1 = 1
+        row2 = 4
+        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex())
+        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex())
+        selection_model = self.widget.lstParams.selectionModel()
+        selection_model.select(index1, selection_model.Select | selection_model.Rows)
+        selection_model.select(index2, selection_model.Select | selection_model.Rows)
+
+        # add constraints
+        self.widget.addSimpleConstraint()
+
+        # simple constraints
+        self.assertEqual(self.widget.getConstraintsForModel(), [('background', '0.001'), ('radius', '20')])
+        objects = self.widget.getConstraintObjectsForModel()
+        self.assertEqual(len(objects), 2)
+        self.assertEqual(objects[1].value, '20')
+        self.assertEqual(objects[0].param, 'background')
+
+
+        # add complex constraint
+        const = Constraint(parent=None, param='scale', func='5*sld')
+        row = 0
+        self.widget.addConstraintToRow(constraint=const, row=row)
+        self.assertEqual(self.widget.getConstraintsForModel(),[('scale', '5*sld'), ('background', '0.001'), ('radius', '20')])
+        objects = self.widget.getConstraintObjectsForModel()
+        self.assertEqual(len(objects), 3)
+        self.assertEqual(objects[0].func, '5*sld')
+
+    def testReplaceConstraintName(self):
+        """
+        Test the replacement of constraint moniker
+        """
+        # select model: cylinder / cylinder
+        category_index = self.widget.cbCategory.findText("Cylinder")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+
+        model_index = self.widget.cbModel.findText("cylinder")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
+        old_name = 'M5'
+        new_name = 'poopy'
+        # add complex constraint
+        const = Constraint(parent=None, param='scale', func='%s.5*sld'%old_name)
+        row = 0
+        self.widget.addConstraintToRow(constraint=const, row=row)
+
+        # Replace 'm5' with 'poopy'
+        self.widget.replaceConstraintName(old_name, new_name)
+
+        self.assertEqual(self.widget.getConstraintsForModel(),[('scale', 'poopy.5*sld')])
+
 
 if __name__ == "__main__":

src/sas/qtgui/Plotting/Plotter.py

@@ -282 +282 @@
         Show a dialog allowing adding custom text to the chart
         """
-        if self.addText.exec_() == QtWidgets.QDialog.Accepted:
-            # Retrieve the new text, its font and color
-            extra_text = self.addText.text()
-            extra_font = self.addText.font()
-            extra_color = self.addText.color()
-
-            # Place the text on the screen at (0,0)
-            pos_x = self.x_click
-            pos_y = self.y_click
-
-            # Map QFont onto MPL font
-            mpl_font = FontProperties()
-            mpl_font.set_size(int(extra_font.pointSize()))
-            mpl_font.set_family(str(extra_font.family()))
-            mpl_font.set_weight(int(extra_font.weight()))
-            # MPL style names
-            styles = ['normal', 'italic', 'oblique']
-            # QFont::Style maps directly onto the above
-            try:
-                mpl_font.set_style(styles[extra_font.style()])
-            except:
-                pass
-
-            if len(extra_text) > 0:
-                new_text = self.ax.text(str(pos_x),
-                                        str(pos_y),
-                                        extra_text,
-                                        color=extra_color,
-                                        fontproperties=mpl_font)
-                # Update the list of annotations
-                self.textList.append(new_text)
-                self.canvas.draw_idle()
-                pass
+        if self.addText.exec_() != QtWidgets.QDialog.Accepted:
+            return
+
+        # Retrieve the new text, its font and color
+        extra_text = self.addText.text()
+        extra_font = self.addText.font()
+        extra_color = self.addText.color()
+
+        # Place the text on the screen at the click location
+        pos_x = self.x_click
+        pos_y = self.y_click
+
+        # Map QFont onto MPL font
+        mpl_font = FontProperties()
+        mpl_font.set_size(int(extra_font.pointSize()))
+        mpl_font.set_family(str(extra_font.family()))
+        mpl_font.set_weight(int(extra_font.weight()))
+        # MPL style names
+        styles = ['normal', 'italic', 'oblique']
+        # QFont::Style maps directly onto the above
+        try:
+            mpl_font.set_style(styles[extra_font.style()])
+        except:
+            pass
+
+        if len(extra_text) > 0:
+            new_text = self.ax.text(pos_x,
+                                    pos_y,
+                                    extra_text,
+                                    color=extra_color,
+                                    fontproperties=mpl_font)
+
+            # Update the list of annotations
+            self.textList.append(new_text)
+            self.canvas.draw()
 
     def onRemoveText(self):
@@ -325 +327 @@
         txt = self.textList[num_text - 1]
         text_remove = txt.get_text()
-        txt.remove()
+        try:
+            txt.remove()
+        except ValueError:
+            # Text got already deleted somehow
+            pass
         self.textList.remove(txt)
 

src/sas/qtgui/Plotting/PlotterBase.py

@@ -6 +6 @@
 from PyQt5 import QtWidgets, QtPrintSupport
 
-# TODO: Replace the qt4agg calls below with qt5 equivalent.
-# Requires some code modifications.
-# https://www.boxcontrol.net/embedding-matplotlib-plot-on-pyqt5-gui.html
-#
-# matplotlib.use("Qt5Agg")
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
@@ -36 +31 @@
 
         #plt.style.use('ggplot')
-        plt.style.use('seaborn-darkgrid')
+        #plt.style.use('seaborn-darkgrid')
 
         # a figure instance to plot on
@@ -176 +171 @@
     def xscale(self, scale='linear'):
         """ X-axis scale setter """
+        self.ax.cla()
         self.ax.set_xscale(scale)
         self._xscale = scale

src/sas/qtgui/Plotting/UnitTesting/PlotterTest.py

@@ -50 +50 @@
         self.assertEqual(self.plotter.data, self.data)
         self.assertEqual(self.plotter._title, self.data.name)
-        self.assertEqual(self.plotter.xLabel, "$()$")
-        self.assertEqual(self.plotter.yLabel, "$()$")
+        self.assertEqual(self.plotter.xLabel, "")
+        self.assertEqual(self.plotter.yLabel, "")
 
     def testPlotWithErrors(self):
@@ -91 +91 @@
         self.plotter.data = data
         self.plotter.show()
-        FigureCanvas.draw = MagicMock()
+        FigureCanvas.draw_idle = MagicMock()
 
         self.plotter.plot(hide_error=True)
@@ -97 +97 @@
         self.assertEqual(self.plotter.ax.get_xscale(), 'linear')
         self.assertEqual(self.plotter.ax.get_yscale(), 'linear')
-        self.assertTrue(FigureCanvas.draw.called)
+        self.assertTrue(FigureCanvas.draw_idle.called)
 
     def testCreateContextMenuQuick(self):
@@ -200 +200 @@
         self.plotter.addText.exec_ = MagicMock(return_value = QtWidgets.QDialog.Accepted)
         # Add text to graph
+        self.plotter.x_click = 1.0
+        self.plotter.y_click = 5.0
         self.plotter.onAddText()
         self.plotter.show()
@@ -394 +396 @@
         xl = self.plotter.ax.xaxis.label.get_text()
         yl = self.plotter.ax.yaxis.label.get_text()
-        self.assertEqual(xl, "$()$")
-        self.assertEqual(yl, "$()$")
+        self.assertEqual(xl, "")
+        self.assertEqual(yl, "")
 
         # Prepare new data

src/sas/qtgui/Plotting/UnitTesting/SlicerParametersTest.py

@@ -1 +1 @@
 import sys
 import unittest
+import webbrowser
 from unittest.mock import MagicMock
 
@@ -6 +7 @@
 from PyQt5 import QtCore
 from PyQt5 import QtTest
-from PyQt5 import QtWebKit
 
 # set up import paths
@@ -72 +72 @@
         self.widget.show()
 
-        #Mock the QWebView method
-        QtWebKit.QWebView.show = MagicMock()
-        QtWebKit.QWebView.load = MagicMock()
+        #Mock the webbrowser.open method
+        webbrowser.open = MagicMock()
 
         # Invoke the action
@@ -80 +79 @@
 
         # Check if show() got called
-        self.assertTrue(QtWebKit.QWebView.show.called)
+        self.assertTrue(webbrowser.open.called)
 
         # Assure the filename is correct
-        self.assertIn("graph_help.html", QtWebKit.QWebView.load.call_args[0][0].toString())
+        self.assertIn("graph_help.html", webbrowser.open.call_args[0][0])
         
     def testSetModel(self):

src/sas/qtgui/Utilities/GuiUtils.py

@@ -325 +325 @@
     """
     assert isinstance(item, QtGui.QStandardItem)
-    assert isinstance(update_data, list)
+    #assert isinstance(update_data, list)
 
     # Add the actual Data1D/Data2D object

src/sas/qtgui/Utilities/LocalConfig.py

@@ -132 +132 @@
 DEFAULT_PERSPECTIVE = 'None'
 
+# Default threading model
+USING_TWISTED = False
+
 # Time out for updating sasview
 UPDATE_TIMEOUT = 2

src/sas/sascalc/fit/AbstractFitEngine.py

@@ -300 +300 @@
             self.qmax = math.sqrt(x_max * x_max + y_max * y_max)
         ## new error image for fitting purpose
-        if self.err_data is None or self.err_data == []:
+        if self.err_data is None or not self.err_data:
             self.res_err_data = np.ones(len(self.data))
         else: