Changeset 21e71f1 in sasview for src/sas/qtgui/Perspectives

Timestamp:

Nov 21, 2018 8:39:24 AM (6 years ago)

Author:

Piotr Rozyczko <piotr.rozyczko@…>

Branches:

ESS_GUI, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc

Children:

f2e199e

Parents:

44c15fc (diff), fb39f28 (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_project_save' into ESS_GUI

Location:

src/sas/qtgui/Perspectives/Fitting

Files:

• ComplexConstraint.py (modified) (8 diffs)
• Constraint.py (modified) (6 diffs)
• ConstraintWidget.py (modified) (19 diffs)
• FittingPerspective.py (modified) (7 diffs)
• FittingWidget.py (modified) (25 diffs)
• MultiConstraint.py (modified) (7 diffs)
• UI/ComplexConstraintUI.ui (modified) (6 diffs)
• UI/ConstraintWidgetUI.ui (modified) (5 diffs)
• UI/MultiConstraintUI.ui (modified) (3 diffs)
• UnitTesting/ComplexConstraintTest.py (modified) (2 diffs)
• UnitTesting/FittingWidgetTest.py (modified) (12 diffs)
• FittingUtilities.py (modified) (2 diffs)
• ViewDelegate.py (modified) (1 diff)
• media/fitting_help.rst (modified) (1 diff)

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

@@ -15 +15 @@
 from sas.qtgui.Perspectives.Fitting import FittingUtilities
 import sas.qtgui.Utilities.GuiUtils as GuiUtils
-ALLOWED_OPERATORS = ['=','<','>','>=','<=']
+from sas.qtgui.Perspectives.Fitting.Constraint import Constraint
+
+#ALLOWED_OPERATORS = ['=','<','>','>=','<=']
+ALLOWED_OPERATORS = ['=']
 
 # Local UI
@@ -21 +24 @@
 
 class ComplexConstraint(QtWidgets.QDialog, Ui_ComplexConstraintUI):
+    constraintReadySignal = QtCore.pyqtSignal(tuple)
     def __init__(self, parent=None, tabs=None):
         super(ComplexConstraint, self).__init__()
@@ -32 +36 @@
         self.tab_names = None
         self.operator = '='
+        self._constraint = Constraint()
 
         self.warning = self.lblWarning.text()
@@ -53 +58 @@
         Signals from various elements
         """
-        self.cmdOK.clicked.connect(self.accept)
+        self.cmdOK.clicked.connect(self.onApply)
         self.cmdHelp.clicked.connect(self.onHelp)
         self.cmdRevert.clicked.connect(self.onRevert)
@@ -69 +74 @@
         self.txtName2.setText(self.tab_names[1])
 
-        # Show only parameters not already constrained
+        self.setupParamWidgets()
+
+        # Add menu to the Apply button
+        all_menu   = QtWidgets.QMenu()
+        self.actionAddAll = QtWidgets.QAction(self)
+        self.actionAddAll.setObjectName("actionAddAll")
+        self.actionAddAll.setText(QtCore.QCoreApplication.translate("self", "Add all"))
+        ttip = "Add constraints between all identically named parameters in both fitpages"
+        self.actionAddAll.setToolTip(ttip)
+        self.actionAddAll.triggered.connect(self.onSetAll)
+        all_menu.addAction(self.actionAddAll)
+        # https://bugreports.qt.io/browse/QTBUG-13663
+        all_menu.setToolTipsVisible(True)
+        self.cmdOK.setMenu(all_menu)
+
+    def setupParamWidgets(self):
+        """
+        Fill out comboboxes and set labels with non-constrained parameters
+        """
         self.cbParam1.clear()
-        items = [param for i,param in enumerate(self.params[0]) if not self.tabs[0].rowHasConstraint(i)]
-        self.cbParam1.addItems(items)
+        items1 = [param for param in self.params[0] if not self.tabs[0].paramHasConstraint(param)]
+        self.cbParam1.addItems(items1)
+
+        # M2 doesn't have to be non-constrained
         self.cbParam2.clear()
-        items = [param for i,param in enumerate(self.params[1]) if not self.tabs[1].rowHasConstraint(i)]
-        self.cbParam2.addItems(items)
+        #items2 = [param for param in self.params[1] if not self.tabs[1].paramHasConstraint(param)]
+        items2 = [param for param in self.params[1]]
+        self.cbParam2.addItems(items2)
 
         self.txtParam.setText(self.tab_names[0] + ":" + self.cbParam1.currentText())
@@ -84 +110 @@
 
         self.txtConstraint.setText(self.tab_names[1]+"."+self.cbParam2.currentText())
+
+        # disable Apply if no parameters available
+        if len(items1)==0:
+            self.cmdOK.setEnabled(False)
+            txt = "No parameters in model "+self.tab_names[0] +\
+                " are available for constraining."
+            self.lblWarning.setText(txt)
+        else:
+            self.cmdOK.setEnabled(True)
+            txt = ""
+            self.lblWarning.setText(txt)
 
     def setupTooltip(self):
@@ -144 +181 @@
 
         # Original indices
+        index2 = index2 if index2 >= 0 else 0
+        index1 = index1 if index1 >= 0 else 0
         self.cbParam1.setCurrentIndex(index2)
         self.cbParam2.setCurrentIndex(index1)
@@ -205 +244 @@
     def constraint(self):
         """
-        Return the generated constraint as tuple (model1, param1, operator, constraint)
-        """
-        return (self.txtName1.text(), self.cbParam1.currentText(), self.cbOperator.currentText(), self.txtConstraint.text())
+        Return the generated constraint
+        """
+        param = self.cbParam1.currentText()
+        value = self.cbParam2.currentText()
+        func = self.txtConstraint.text()
+        value_ex = self.txtName2.text() + "." + self.cbParam2.currentText()
+        model1 = self.txtName1.text()
+        operator = self.cbOperator.currentText()
+
+        con = Constraint(self,
+                         param=param,
+                         value=value,
+                         func=func,
+                         value_ex=value_ex,
+                         operator=operator)
+
+        return (model1, con)
+
+    def onApply(self):
+        """
+        Respond to Add constraint action.
+        Send a signal that the constraint is ready to be applied
+        """
+        cons_tuple = self.constraint()
+        self.constraintReadySignal.emit(cons_tuple)
+        # reload the comboboxes
+        self.setupParamWidgets()
+
+    def onSetAll(self):
+        """
+        Set constraints on all identically named parameters between two fitpages
+        """
+        # loop over parameters in constrained model
+        items1 = [param for param in self.params[0] if not self.tabs[0].paramHasConstraint(param)]
+        #items2 = [param for param in self.params[1] if not self.tabs[1].paramHasConstraint(i)]
+        items2 = self.params[1]
+        for item in items1:
+            if item not in items2: continue
+            param = item
+            value = item
+            func = self.txtName2.text() + "." + param
+            value_ex = self.txtName1.text() + "." + param
+            model1 = self.txtName1.text()
+            operator = self.cbOperator.currentText()
+
+            con = Constraint(self,
+                             param=param,
+                             value=value,
+                             func=func,
+                             value_ex=value_ex,
+                             operator=operator)
+
+            self.constraintReadySignal.emit((model1, con))
+
+        # reload the comboboxes
+        self.setupParamWidgets()
 
     def onHelp(self):

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

@@ -5 +5 @@
     hence made into a class.
     """
-    def __init__(self, parent=None, param=None, value=0.0, min=None, max=None, func=None):
+    def __init__(self, parent=None, param=None, value=0.0,
+                 min=None, max=None, func=None, value_ex=None,
+                 operator="="):
         self._value = value
         self._param = param
+        self._value_ex = value_ex
         self._func = func
-        self.active = True
         self._min = min
         self._max = max
+        self._operator = operator
+        self.validate = True
+        self.active = True
 
     @property
     def value(self):
+        # value/parameter to fit to (e.g. 1.0 or sld)
         return self._value
 
@@ -22 +28 @@
 
     @property
+    def value_ex(self):
+        # full parameter name to fit to (e.g. M1.sld)
+        return self._value_ex
+
+    @value_ex.setter
+    def value_ex(self, val):
+        self._value_ex = val
+
+    @property
     def param(self):
+        # parameter which is being fitted
         return self._param
 
@@ -31 +47 @@
     @property
     def func(self):
+        # Function to be used for constraint
+        # e.g. sqrt(M1.sld+1.0)
         return self._func
 
@@ -39 +57 @@
     @property
     def min(self):
+        # min param value for single value constraints
         return self._min
 
@@ -47 +66 @@
     @property
     def max(self):
+        # max param value for single value constraints
         return self._max
 
@@ -53 +73 @@
         self._max = val
 
+    @property
+    def operator(self):
+        # operator to use for constraint
+        return self._operator
+
+    @operator.setter
+    def operator(self, val):
+        self._operator = val
+

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

@@ -23 +23 @@
     Constraints Dialog to select the desired parameter/model constraints.
     """
+    fitCompleteSignal = QtCore.pyqtSignal(tuple)
+    batchCompleteSignal = QtCore.pyqtSignal(tuple)
+    fitFailedSignal = QtCore.pyqtSignal(tuple)
 
     def __init__(self, parent=None):
@@ -32 +35 @@
         # To keep with previous SasView values, use 300 as the start offset
         self.page_id = 301
+        self.tab_id = self.page_id
 
         # Are we chain fitting?
@@ -60 +64 @@
         Set up various widget states
         """
+        # disable special cases until properly defined
+        self.label.setVisible(False)
+        self.cbCases.setVisible(False)
+
         labels = ['FitPage', 'Model', 'Data', 'Mnemonic']
         # tab widget - headers
@@ -79 +87 @@
         self.tblConstraints.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Stretch)
         self.tblConstraints.setEnabled(False)
+        header = self.tblConstraints.horizontalHeaderItem(0)
+        header.setToolTip("Double click a row below to edit the constraint.")
 
         self.tblConstraints.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
@@ -93 +103 @@
         self.cmdFit.clicked.connect(self.onFit)
         self.cmdHelp.clicked.connect(self.onHelp)
+        self.cmdAdd.clicked.connect(self.showMultiConstraint)
         self.chkChain.toggled.connect(self.onChainFit)
 
@@ -100 +111 @@
         self.tblConstraints.cellChanged.connect(self.onConstraintChange)
 
+        # Internal signals
+        self.fitCompleteSignal.connect(self.fitComplete)
+        self.batchCompleteSignal.connect(self.batchComplete)
+        self.fitFailedSignal.connect(self.fitFailed)
+
         # External signals
         self.parent.tabsModifiedSignal.connect(self.initializeFitList)
@@ -156 +172 @@
         fitter = Fit()
         fitter.fitter_id = self.page_id
-
-        # Notify the parent about fitting started
-        self.parent.fittingStartedSignal.emit(tabs_to_fit)
 
         # prepare fitting problems for each tab
@@ -168 +181 @@
         try:
             for tab in tabs_to_fit:
+                if not self.isTabImportable(tab): continue
                 tab_object = ObjectLibrary.getObject(tab)
                 if tab_object is None:
@@ -177 +191 @@
         except ValueError:
             # No parameters selected in one of the tabs
-            no_params_msg = "Fitting can not be performed.\n" +\
+            no_params_msg = "Fitting cannot be performed.\n" +\
                             "Not all tabs chosen for fitting have parameters selected for fitting."
             QtWidgets.QMessageBox.warning(self,
@@ -200 +214 @@
         batch_inputs = {}
         batch_outputs = {}
+
+        # Notify the parent about fitting started
+        self.parent.fittingStartedSignal.emit(tabs_to_fit)
 
         # new fit thread object
@@ -223 +240 @@
 
         #disable the Fit button
+        self.cmdFit.setStyleSheet('QPushButton {color: red;}')
         self.cmdFit.setText('Running...')
         self.parent.communicate.statusBarUpdateSignal.emit('Fitting started...')
@@ -292 +310 @@
         """
         item = self.tblConstraints.item(row, column)
-        if column == 0:
-            # Update the tabs for fitting list
-            constraint = self.available_constraints[row]
-            constraint.active = (item.checkState() == QtCore.Qt.Checked)
+        if column != 0: return
+        # Update the tabs for fitting list
+        constraint = self.available_constraints[row]
+        constraint.active = (item.checkState() == QtCore.Qt.Checked)
+        # Update the constraint formula
+        constraint = self.available_constraints[row]
+        function = item.text()
+        # remove anything left of '=' to get the constraint
+        function = function[function.index('=')+1:]
+        # No check on function here - trust the user (R)
+        if function != constraint.func:
+            # This becomes rather difficult to validate now.
+            # Turn off validation for Edit Constraint
+            constraint.func = function
+            constraint.validate = False
 
     def onTabCellEntered(self, row, column):
@@ -308 +337 @@
     def onFitComplete(self, result):
         """
+        Send the fit complete signal to main thread
+        """
+        self.fitCompleteSignal.emit(result)
+
+    def fitComplete(self, result):
+        """
         Respond to the successful fit complete signal
         """
         #re-enable the Fit button
+        self.cmdFit.setStyleSheet('QPushButton {color: black;}')
         self.cmdFit.setText("Fit")
         self.cmdFit.setEnabled(True)
@@ -347 +383 @@
     def onBatchFitComplete(self, result):
         """
+        Send the fit complete signal to main thread
+        """
+        self.batchCompleteSignal.emit(result)
+
+    def batchComplete(self, result):
+        """
         Respond to the successful batch fit complete signal
         """
         #re-enable the Fit button
+        self.cmdFit.setStyleSheet('QPushButton {color: black;}')
         self.cmdFit.setText("Fit")
         self.cmdFit.setEnabled(True)
@@ -375 +418 @@
     def onFitFailed(self, reason):
         """
+        Send the fit failed signal to main thread
+        """
+        self.fitFailedSignal.emit(result)
+
+    def fitFailed(self, reason):
+        """
         Respond to fitting failure.
         """
         #re-enable the Fit button
+        self.cmdFit.setStyleSheet('QPushButton {color: black;}')
         self.cmdFit.setText("Fit")
         self.cmdFit.setEnabled(True)
@@ -386 +436 @@
         msg = "Fitting failed: %s s.\n" % reason
         self.parent.communicate.statusBarUpdateSignal.emit(msg)
- 
+
     def isTabImportable(self, tab):
         """
@@ -599 +649 @@
             # Show the text in the constraint table
             item = self.uneditableItem(label)
+            item = QtWidgets.QTableWidgetItem(label)
             item.setFlags(item.flags() ^ QtCore.Qt.ItemIsUserCheckable)
             item.setCheckState(QtCore.Qt.Checked)
@@ -667 +718 @@
         return None
 
+    def onAcceptConstraint(self, con_tuple):
+        """
+        Receive constraint tuple from the ComplexConstraint dialog and adds contraint
+        """
+        #"M1, M2, M3" etc
+        model_name, constraint = con_tuple
+        constrained_tab = self.getObjectByName(model_name)
+        if constrained_tab is None:
+            return
+
+        # Find the constrained parameter row
+        constrained_row = constrained_tab.getRowFromName(constraint.param)
+
+        # Update the tab
+        constrained_tab.addConstraintToRow(constraint, constrained_row)
+
+        # Select this parameter for adjusting/fitting
+        constrained_tab.selectCheckbox(constrained_row)
+
+
     def showMultiConstraint(self):
         """
@@ -672 +743 @@
         """
         selected_rows = self.selectedParameters(self.tblTabList)
-        assert(len(selected_rows)==2)
+        if len(selected_rows)!=2:
+            msg = "Please select two fit pages from the Source Choice table."
+            msgbox = QtWidgets.QMessageBox(self.parent)
+            msgbox.setIcon(QtWidgets.QMessageBox.Warning)
+            msgbox.setText(msg)
+            msgbox.setWindowTitle("2 fit page constraints")
+            retval = msgbox.exec_()
+            return
 
         tab_list = [ObjectLibrary.getObject(self.tblTabList.item(s, 0).data(0)) for s in selected_rows]
         # Create and display the widget for param1 and param2
         cc_widget = ComplexConstraint(self, tabs=tab_list)
+        cc_widget.constraintReadySignal.connect(self.onAcceptConstraint)
+
         if cc_widget.exec_() != QtWidgets.QDialog.Accepted:
             return
 
-        constraint = Constraint()
-        model1, param1, operator, constraint_text = cc_widget.constraint()
-
-        constraint.func = constraint_text
-        # param1 is the parameter we're constraining
-        constraint.param = param1
-
-        # Find the right tab
-        constrained_tab = self.getObjectByName(model1)
-        if constrained_tab is None:
-            return
-
-        # Find the constrained parameter row
-        constrained_row = constrained_tab.getRowFromName(param1)
-
-        # Update the tab
-        constrained_tab.addConstraintToRow(constraint, constrained_row)
+    def getFitPage(self):
+        """
+        Retrieves the state of this page
+        """
+        param_list = []
+
+        param_list.append(['is_constraint', 'True'])
+        param_list.append(['data_id', "cs_tab"+str(self.page_id)])
+        param_list.append(['current_type', self.currentType])
+        param_list.append(['is_chain_fitting', str(self.is_chain_fitting)])
+        param_list.append(['special_case', self.cbCases.currentText()])
+
+        return param_list
+
+    def getFitModel(self):
+        """
+        Retrieves current model
+        """
+        model_list = []
+
+        checked_models = {}
+        for row in range(self.tblTabList.rowCount()):
+            model_name = self.tblTabList.item(row,1).data(0)
+            active = self.tblTabList.item(row,0).checkState()# == QtCore.Qt.Checked
+            checked_models[model_name] = str(active)
+
+        checked_constraints = {}
+        for row in range(self.tblConstraints.rowCount()):
+            model_name = self.tblConstraints.item(row,0).data(0)
+            active = self.tblConstraints.item(row,0).checkState()# == QtCore.Qt.Checked
+            checked_constraints[model_name] = str(active)
+
+        model_list.append(['checked_models', checked_models])
+        model_list.append(['checked_constraints', checked_constraints])
+        return model_list
+
+    def createPageForParameters(self, parameters=None):
+        """
+        Update the page with passed parameter values
+        """
+        # checked models
+        if not 'checked_models' in parameters:
+            return
+        models = parameters['checked_models'][0]
+        for model, check_state in models.items():
+            for row in range(self.tblTabList.rowCount()):
+                model_name = self.tblTabList.item(row,1).data(0)
+                if model_name != model:
+                    continue
+                # check/uncheck item
+                self.tblTabList.item(row,0).setCheckState(int(check_state))
+
+        if not 'checked_constraints' in parameters:
+            return
+        # checked constraints
+        models = parameters['checked_constraints'][0]
+        for model, check_state in models.items():
+            for row in range(self.tblConstraints.rowCount()):
+                model_name = self.tblConstraints.item(row,0).data(0)
+                if model_name != model:
+                    continue
+                # check/uncheck item
+                self.tblConstraints.item(row,0).setCheckState(int(check_state))
+
+        # fit/batch radio
+        isBatch = parameters['current_type'][0] == 'BatchPage'
+        if isBatch:
+            self.btnBatch.toggle()
+
+        # chain
+        is_chain = parameters['is_chain_fitting'][0] == 'True'
+        if isBatch:
+            self.chkChain.setChecked(is_chain)

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

@@ -1 +1 @@
 import numpy
+import copy
 
 from PyQt5 import QtCore
@@ -10 +11 @@
 import sas.qtgui.Utilities.LocalConfig as LocalConfig
 import sas.qtgui.Utilities.ObjectLibrary as ObjectLibrary
+import sas.qtgui.Utilities.GuiUtils as GuiUtils
 
 from sas.qtgui.Perspectives.Fitting.FittingWidget import FittingWidget
@@ -37 +39 @@
         self.maxIndex = 1
 
-        ## Index of the current tab
-        #self.currentTab = 0
-
         # The default optimizer
         self.optimizer = 'Levenberg-Marquardt'
@@ -85 +84 @@
         self.updateWindowTitle()
 
+        # Add new tab mini-button
+        self.plusButton = QtWidgets.QToolButton(self)
+        self.plusButton.setText("+")
+        self.setCornerWidget(self.plusButton)
+        self.plusButton.setToolTip("Add a new Fit Page")
+        self.plusButton.clicked.connect(lambda: self.addFit(None))
+
     def updateWindowTitle(self):
         """
@@ -112 +118 @@
     def onLatexCopy(self):
         self.currentTab.onCopyToClipboard("Latex")
+
+    def serializeAllFitpage(self):
+        # serialize all active fitpages and return
+        # a dictionary: {data_id: fitpage_state}
+        params = {}
+        for i, tab in enumerate(self.tabs):
+            tab_data = self.getSerializedFitpage(tab)
+            if 'data_id' not in tab_data: continue
+            id = tab_data['data_id'][0]
+            if isinstance(id, list):
+                for i in id:
+                    if i in params:
+                        params[i].append(tab_data)
+                    else:
+                        params[i] = [tab_data]
+            else:
+                if id in params:
+                    params[id].append(tab_data)
+                else:
+                    params[id] = [tab_data]
+        return params
+
+    def serializeCurrentFitpage(self):
+        # serialize current(active) fitpage
+        return self.getSerializedFitpage(self.currentTab)
+
+    def getSerializedFitpage(self, tab):
+        """
+        get serialize requested fit tab
+        """
+        fitpage_state = tab.getFitPage()
+        fitpage_state += tab.getFitModel()
+        # put the text into dictionary
+        line_dict = {}
+        for line in fitpage_state:
+            #content = line.split(',')
+            if len(line) > 1:
+                line_dict[line[0]] = line[1:]
+        return line_dict
+
+    def currentTabDataId(self):
+        """
+        Returns the data ID of the current tab
+        """
+        tab_id = []
+        if not self.currentTab.data:
+            return tab_id
+        for item in self.currentTab.all_data:
+            data = GuiUtils.dataFromItem(item)
+            tab_id.append(data.id)
+
+        return tab_id
+
+    def updateFromParameters(self, parameters):
+        """
+        Pass the update parameters to the current fit page
+        """
+        self.currentTab.createPageForParameters(parameters)
 
     def closeEvent(self, event):
@@ -246 +310 @@
         for index_to_delete in index_list:
             index_to_delete_str = str(index_to_delete)
-            if index_to_delete_str in list(self.dataToFitTab.keys()):
-                for tab_name in self.dataToFitTab[index_to_delete_str]:
-                    # delete tab #index after corresponding data got removed
-                    self.closeTabByName(tab_name)
-                self.dataToFitTab.pop(index_to_delete_str)
+            orig_dict = copy.deepcopy(self.dataToFitTab)
+            for tab_key in orig_dict.keys():
+                if index_to_delete_str in tab_key:
+                    for tab_name in orig_dict[tab_key]:
+                        self.closeTabByName(tab_name)
+                    self.dataToFitTab.pop(tab_key)
 
     def allowBatch(self):
         """
         Tell the caller that we accept multiple data instances
+        """
+        return True
+
+    def isSerializable(self):
+        """
+        Tell the caller that this perspective writes its state
         """
         return True
@@ -337 +408 @@
         pass
 
+    def getCurrentStateAsXml(self):
+        """
+        Returns an XML version of the current state
+        """
+        state = {}
+        for tab in self.tabs:
+            pass
+        return state
+
     @property
     def currentTab(self):

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

@@ -52 +52 @@
 TAB_POLY = 3
 CATEGORY_DEFAULT = "Choose category..."
+MODEL_DEFAULT = "Choose model..."
 CATEGORY_STRUCTURE = "Structure Factor"
 CATEGORY_CUSTOM = "Plugin Models"
@@ -574 +575 @@
         # Signals from other widgets
         self.communicate.customModelDirectoryChanged.connect(self.onCustomModelChange)
-        self.communicate.saveAnalysisSignal.connect(self.savePageState)
-        #self.communicate.loadAnalysisSignal.connect(self.loadPageState)
         self.smearing_widget.smearingChangedSignal.connect(self.onSmearingOptionsUpdate)
 
@@ -623 +622 @@
         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])
+        has_real_constraints = any([self.rowHasActiveConstraint(i) for i in rows])
 
         self.actionSelect = QtWidgets.QAction(self)
@@ -640 +640 @@
         self.actionRemoveConstraint.setText(QtCore.QCoreApplication.translate("self", "Remove constraint"))
 
+        self.actionEditConstraint = QtWidgets.QAction(self)
+        self.actionEditConstraint.setObjectName("actionEditConstrain")
+        self.actionEditConstraint.setText(QtCore.QCoreApplication.translate("self", "Edit constraint"))
+
         self.actionMultiConstrain = QtWidgets.QAction(self)
         self.actionMultiConstrain.setObjectName("actionMultiConstrain")
@@ -654 +658 @@
         if has_constraints:
             menu.addAction(self.actionRemoveConstraint)
+            if num_rows == 1 and has_real_constraints:
+                menu.addAction(self.actionEditConstraint)
             #if num_rows == 1:
             #    menu.addAction(self.actionEditConstraint)
@@ -664 +670 @@
         self.actionConstrain.triggered.connect(self.addSimpleConstraint)
         self.actionRemoveConstraint.triggered.connect(self.deleteConstraint)
+        self.actionEditConstraint.triggered.connect(self.editConstraint)
         self.actionMutualMultiConstrain.triggered.connect(self.showMultiConstraint)
         self.actionSelect.triggered.connect(self.selectParameters)
@@ -701 +708 @@
         new_func = c_text.replace(param_used, updated_param_used)
         constraint.func = new_func
+        constraint.value_ex = updated_param_used
         # Which row is the constrained parameter in?
         row = self.getRowFromName(constraint.param)
+
+        # what is the parameter to constraint to?
+        constraint.value = param_used
+
+        # Should the new constraint be validated?
+        constraint.validate = mc_widget.validate
 
         # Create a new item and add the Constraint object as a child
@@ -799 +813 @@
         self.communicate.statusBarUpdateSignal.emit('Constraint added')
 
+    def editConstraint(self):
+        """
+        Delete constraints from selected parameters.
+        """
+        params_list = [s.data() for s in self.lstParams.selectionModel().selectedRows()
+                   if self.isCheckable(s.row())]
+        assert len(params_list) == 1
+        row = self.lstParams.selectionModel().selectedRows()[0].row()
+        constraint = self.getConstraintForRow(row)
+        # Create and display the widget for param1 and param2
+        mc_widget = MultiConstraint(self, params=params_list, constraint=constraint)
+        # Check if any of the parameters are polydisperse
+        if not np.any([FittingUtilities.isParamPolydisperse(p, self.model_parameters, is2D=self.is2D) for p in params_list]):
+            # no parameters are pd - reset the text to not show the warning
+            mc_widget.lblWarning.setText("")
+        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]
+        # parameter should have the model name preamble
+        model_name = self.kernel_module.name
+        # param_used is the parameter we're using in constraining function
+        param_used = mc_widget.params[1]
+        # Replace param_used with model_name.param_used
+        updated_param_used = model_name + "." + param_used
+        # Update constraint with new values
+        constraint.func = c_text
+        constraint.value_ex = updated_param_used
+        constraint.value = param_used
+        # Should the new constraint be validated?
+        constraint.validate = mc_widget.validate
+
+        # 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 deleteConstraint(self):
         """
@@ -853 +909 @@
             return None
 
+    def allParamNames(self):
+        """
+        Returns a list of all parameter names defined on the current model
+        """
+        all_params = self.kernel_module._model_info.parameters.kernel_parameters
+        all_param_names = [param.name for param in all_params]
+        # Assure scale and background are always included
+        if 'scale' not in all_param_names:
+            all_param_names.append('scale')
+        if 'background' not in all_param_names:
+            all_param_names.append('background')
+        return all_param_names
+
+    def paramHasConstraint(self, param=None):
+        """
+        Finds out if the given parameter in the main model has a constraint child
+        """
+        if param is None: return False
+        if param not in self.allParamNames(): return False
+
+        for row in range(self._model_model.rowCount()):
+            if self._model_model.item(row,0).text() != param: continue
+            return self.rowHasConstraint(row)
+
+        # nothing found
+        return False
+
     def rowHasConstraint(self, row):
         """
@@ -1018 +1101 @@
         Checks if the current model has magnetic scattering implemented
         """
-        has_params = False
+        has_mag_params = False
         if self.kernel_module:
             has_mag_params = len(self.kernel_module.magnetic_params) > 0
@@ -1029 +1112 @@
         model = self.cbModel.currentText()
 
+        if model == MODEL_DEFAULT:
+            # if the previous category was not the default, keep it.
+            # Otherwise, just return
+            if self._previous_model_index != 0:
+                # We need to block signals, or else state changes on perceived unchanged conditions
+                self.cbModel.blockSignals(True)
+                self.cbModel.setCurrentIndex(self._previous_model_index)
+                self.cbModel.blockSignals(False)
+            return
+
         # Assure the control is active
         if not self.cbModel.isEnabled():
@@ -1035 +1128 @@
         if not model:
             return
+
+        self.chkMagnetism.setEnabled(self.canHaveMagnetism())
+        self.chkMagnetism.setEnabled(self.canHaveMagnetism())
+        self.tabFitting.setTabEnabled(TAB_MAGNETISM, self.chkMagnetism.isChecked() and self.canHaveMagnetism())
+        self._previous_model_index = self.cbModel.currentIndex()
 
         # Reset parameters to fit
@@ -1213 +1311 @@
             self._model_model.clear()
             return
-
+        # Wipe out the parameter model
+        self._model_model.clear()
         # Safely clear and enable the model combo
         self.cbModel.blockSignals(True)
@@ -1225 +1324 @@
         model_list = self.master_category_dict[category]
         # Populate the models combobox
+        self.cbModel.blockSignals(True)
+        self.cbModel.addItem(MODEL_DEFAULT)
         self.cbModel.addItems(sorted([model for (model, _) in model_list]))
+        self.cbModel.blockSignals(False)
 
     def onPolyModelChange(self, top, bottom):
@@ -1937 +2039 @@
         Emits plotRequestedSignal for all plots found in the given model under the provided item name.
         """
-        fitpage_name = "" if self.tab_id is None else "M"+str(self.tab_id)
+        fitpage_name = self.kernel_module.name
         plots = GuiUtils.plotsFromFilename(item_name, item_model)
         # Has the fitted data been shown?
@@ -2425 +2527 @@
     def isCheckable(self, row):
         return self._model_model.item(row, 0).isCheckable()
+
+    def selectCheckbox(self, row):
+        """
+        Select the checkbox in given row.
+        """
+        assert 0<= row <= self._model_model.rowCount()
+        index = self._model_model.index(row, 0)
+        item = self._model_model.itemFromIndex(index)
+        item.setCheckState(QtCore.Qt.Checked)
 
     def checkboxSelected(self, item):
@@ -3430 +3541 @@
         return report_logic.reportList()
 
-    def savePageState(self):
-        """
-        Create and serialize local PageState
-        """
-        filepath = self.saveAsAnalysisFile()
-        if filepath is None or filepath == "":
-            return
-
-        fitpage_state = self.getFitPage()
-        fitpage_state += self.getFitModel()
-
-        with open(filepath, 'w') as statefile:
-            for line in fitpage_state:
-                statefile.write(str(line))
-
-        self.communicate.statusBarUpdateSignal.emit('Analysis saved.')
-
-    def saveAsAnalysisFile(self):
-        """
-        Show the save as... dialog and return the chosen filepath
-        """
-        default_name = "FitPage"+str(self.tab_id)+".fitv"
-
-        wildcard = "fitv files (*.fitv)"
-        kwargs = {
-            'caption'   : 'Save As',
-            'directory' : default_name,
-            'filter'    : wildcard,
-            'parent'    : None,
-        }
-        # Query user for filename.
-        filename_tuple = QtWidgets.QFileDialog.getSaveFileName(**kwargs)
-        filename = filename_tuple[0]
-        return filename
-
     def loadPageStateCallback(self,state=None, datainfo=None, format=None):
         """
@@ -3549 +3625 @@
 
         param_list.append(['is_data', str(self.data_is_loaded)])
-        if self.data_is_loaded:
-            param_list.append(['data_id', str(self.logic.data.id)])
-            param_list.append(['data_name', str(self.logic.data.filename)])
-
+        data_ids = []
+        filenames = []
+        if self.is_batch_fitting:
+            for item in self.all_data:
+                # need item->data->data_id
+                data = GuiUtils.dataFromItem(item)
+                data_ids.append(data.id)
+                filenames.append(data.filename)
+        else:
+            if self.data_is_loaded:
+                data_ids = [str(self.logic.data.id)]
+                filenames = [str(self.logic.data.filename)]
+        param_list.append(['is_batch_fitting', str(self.is_batch_fitting)])
+        param_list.append(['data_name', filenames])
+        param_list.append(['data_id', data_ids])
+        param_list.append(['tab_name', self.modelName()])
         # option tab
         param_list.append(['q_range_min', str(self.q_range_min)])
@@ -3583 +3671 @@
         """
         param_list = []
+        if self.kernel_module is None:
+            return param_list
+
         param_list.append(['model_name', str(self.cbModel.currentText())])
 
@@ -3622 +3713 @@
             except:
                 pass
-
-            param_list.append([param_name, param_checked, param_value, param_error, param_min, param_max])
+            # Do we have any constraints on this parameter?
+            constraint = self.getConstraintForRow(row)
+            cons = ()
+            if constraint is not None:
+                value = constraint.value
+                func = constraint.func
+                value_ex = constraint.value_ex
+                param = constraint.param
+                validate = constraint.validate
+
+                cons = (value, param, value_ex, validate, func)
+
+            param_list.append([param_name, param_checked, param_value,param_error, param_min, param_max, cons])
 
         def gatherPolyParams(row):
@@ -3687 +3789 @@
         cb_text = cb.text()
 
-        context = {}
         lines = cb_text.split(':')
         if lines[0] != 'sasview_parameter_values':
@@ -3699 +3800 @@
                 line_dict[content[0]] = content[1:]
 
+        self.updatePageWithParameters(line_dict)
+
+    def createPageForParameters(self, line_dict):
+        """
+        Sets up page with requested model/str factor
+        and fills it up with sent parameters
+        """
+        if 'fitpage_category' in line_dict:
+            self.cbCategory.setCurrentIndex(self.cbCategory.findText(line_dict['fitpage_category'][0]))
+        if 'fitpage_model' in line_dict:
+            self.cbModel.setCurrentIndex(self.cbModel.findText(line_dict['fitpage_model'][0]))
+        if 'fitpage_structure' in line_dict:
+            self.cbStructureFactor.setCurrentIndex(self.cbStructureFactor.findText(line_dict['fitpage_structure'][0]))
+
+        # Now that the page is ready for parameters, fill it up
+        self.updatePageWithParameters(line_dict)
+
+    def updatePageWithParameters(self, line_dict):
+        """
+        Update FitPage with parameters in line_dict
+        """
+        if 'model_name' not in line_dict.keys():
+            return
         model = line_dict['model_name'][0]
-
-        if 'model_name' not in line_dict.keys():
-            return False
+        context = {}
 
         if 'multiplicity' in line_dict.keys():
@@ -3711 +3833 @@
                 self.updateMultiplicityCombo(multip)
 
+        if 'tab_name' in line_dict.keys():
+            self.kernel_module.name = line_dict['tab_name'][0]
         if 'polydisperse_params' in line_dict.keys():
             self.chkPolydispersity.setChecked(line_dict['polydisperse_params'][0]=='True')
@@ -3833 +3957 @@
             ioffset = 0
             joffset = 0
-            if len(param_dict[param_name])>4:
+            if len(param_dict[param_name])>5:
                 # error values are not editable - no need to update
                 ioffset = 1
@@ -3846 +3970 @@
             except:
                 pass
+
+            # constraints
+            cons = param_dict[param_name][4+ioffset]
+            if cons is not None and len(cons)==5:
+                value = cons[0]
+                param = cons[1]
+                value_ex = cons[2]
+                validate = cons[3]
+                function = cons[4]
+                constraint = Constraint()
+                constraint.value = value
+                constraint.func = function
+                constraint.param = param
+                constraint.value_ex = value_ex
+                constraint.validate = validate
+                self.addConstraintToRow(constraint=constraint, row=row)
 
             self.setFocus()

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

@@ -20 +20 @@
     Logic class for interacting with MultiConstrainedUI view
     """
-    def __init__(self, parent=None, params=None):
+    def __init__(self, parent=None, params=None, constraint=None):
         """
         parent: ConstraintWidget object
@@ -31 +31 @@
         self.params = params
         self.parent = parent
+        # Text of the constraint
+        self.function = None
+        # Should this constraint be validated?
+        self.validate = True
+
+        self.input_constraint = constraint
+        if self.input_constraint is not None:
+            variable = constraint.value
+            self.function = constraint.func
+            self.params.append(variable)
+            self.model_name = constraint.value_ex
+            # Passed constraint may be too complex for simple validation
+            self.validate = constraint.validate
+        else:
+            self.model_name = self.params[1]
 
         self.setupLabels()
@@ -36 +51 @@
 
         # Set param text control to the second parameter passed
-        self.txtConstraint.setText(self.params[1])
-
+        if self.input_constraint is None:
+            self.txtConstraint.setText(self.params[1])
+        else:
+            self.txtConstraint.setText(self.function)
         self.cmdOK.clicked.connect(self.accept)
         self.cmdHelp.clicked.connect(self.onHelp)
@@ -52 +69 @@
         # Switch parameters
         self.params[1], self.params[0] = self.params[0], self.params[1]
+        # change fully qualified param name (e.g. M1.sld -> M1.sld_solvent)
+        self.model_name = self.model_name.replace(self.params[0], self.params[1])
         # Try to swap parameter names in the line edit
         current_text = self.txtConstraint.text()
@@ -64 +83 @@
         Setup labels based on current parameters
         """
-        l1 = self.params[0]
-        l2 = self.params[1]
+        l1 = str(self.params[0])
+        l2 = str(self.params[1])
         self.txtParam1.setText(l1)
         self.txtParam1_2.setText(l1)
@@ -82 +101 @@
         Add visual cues when formula is incorrect
         """
+        # Don't validate if requested
+        if not self.validate: return
+
         formula_is_valid = False
         formula_is_valid = self.validateConstraint(self.txtConstraint.text())
@@ -99 +121 @@
             return False
 
-        param_str = str(self.params[1])
-        constraint_text = constraint_text.strip()
+        param_str = self.model_name
 
         # 1. just the parameter

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

@@ -7 +7 @@
     <x>0</x>
     <y>0</y>
-    <width>367</width>
-    <height>199</height>
+    <width>478</width>
+    <height>257</height>
    </rect>
   </property>
@@ -69 +69 @@
            </sizepolicy>
           </property>
+          <property name="sizeAdjustPolicy">
+           <enum>QComboBox::AdjustToContents</enum>
+          </property>
           <item>
            <property name="text">
@@ -100 +103 @@
            </sizepolicy>
           </property>
+          <property name="sizeAdjustPolicy">
+           <enum>QComboBox::AdjustToContents</enum>
+          </property>
           <item>
            <property name="text">
@@ -161 +167 @@
        <property name="sizeHint" stdset="0">
         <size>
-         <width>40</width>
+         <width>88</width>
          <height>20</height>
         </size>
@@ -168 +174 @@
      </item>
      <item>
-      <widget class="QPushButton" name="cmdOK">
+      <widget class="QToolButton" name="cmdOK">
+       <property name="minimumSize">
+        <size>
+         <width>93</width>
+         <height>28</height>
+        </size>
+       </property>
+       <property name="toolTip">
+        <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Add the constraint as defined by the above expression.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+       </property>
        <property name="text">
-        <string>OK</string>
-       </property>
-       <property name="default">
+        <string>Add</string>
+       </property>
+       <property name="popupMode">
+        <enum>QToolButton::MenuButtonPopup</enum>
+       </property>
+       <property name="toolButtonStyle">
+        <enum>Qt::ToolButtonTextOnly</enum>
+       </property>
+       <property name="autoRaise">
         <bool>false</bool>
        </property>
+       <property name="arrowType">
+        <enum>Qt::DownArrow</enum>
+       </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="cmdCancel">
+       <property name="toolTip">
+        <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Close the window.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+       </property>
        <property name="text">
-        <string>Cancel</string>
+        <string>Close</string>
        </property>
       </widget>
@@ -197 +224 @@
  <resources/>
  <connections>
-  <connection>
-   <sender>cmdOK</sender>
-   <signal>clicked()</signal>
-   <receiver>ComplexConstraintUI</receiver>
-   <slot>accept()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>149</x>
-     <y>144</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>179</x>
-     <y>82</y>
-    </hint>
-   </hints>
-  </connection>
   <connection>
    <sender>cmdCancel</sender>

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

@@ -7 +7 @@
     <x>0</x>
     <y>0</y>
-    <width>428</width>
-    <height>457</height>
+    <width>597</width>
+    <height>607</height>
    </rect>
   </property>
@@ -14 +14 @@
    <string>Constrained and Simultaneous Fit</string>
   </property>
-  <layout class="QGridLayout" name="gridLayout">
+  <layout class="QGridLayout" name="gridLayout_2">
    <item row="0" column="0">
     <widget class="QGroupBox" name="groupBox">
@@ -89 +89 @@
       <string>Constraints</string>
      </property>
-     <layout class="QGridLayout" name="gridLayout_2">
+     <layout class="QGridLayout" name="gridLayout">
       <item row="0" column="0">
-       <layout class="QHBoxLayout" name="horizontalLayout">
-        <item>
-         <widget class="QLabel" name="label">
-          <property name="text">
-           <string>Special cases</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QComboBox" name="cbCases">
+       <layout class="QHBoxLayout" name="horizontalLayout_4">
+        <item>
+         <layout class="QHBoxLayout" name="horizontalLayout">
           <item>
-           <property name="text">
-            <string>None</string>
-           </property>
+           <widget class="QLabel" name="label">
+            <property name="text">
+             <string>Special cases</string>
+            </property>
+           </widget>
           </item>
+          <item>
+           <widget class="QComboBox" name="cbCases">
+            <item>
+             <property name="text">
+              <string>None</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+         </layout>
+        </item>
+        <item>
+         <spacer name="horizontalSpacer_3">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+        <item>
+         <widget class="QPushButton" name="cmdAdd">
+          <property name="toolTip">
+           <string>Define constraints between two fit pages.</string>
+          </property>
+          <property name="text">
+           <string>Add constraints</string>
+          </property>
          </widget>
         </item>
@@ -160 +187 @@
         </size>
        </property>
+       <property name="toolTip">
+        <string>Perform simultaneous fitting of selected fit pages.</string>
+       </property>
        <property name="text">
         <string>Fit</string>
@@ -179 +209 @@
         </size>
        </property>
+       <property name="toolTip">
+        <string>Display help on constrained and simultaneous fitting.</string>
+       </property>
        <property name="text">
         <string>Help</string>

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

@@ -10 +10 @@
     <x>0</x>
     <y>0</y>
-    <width>369</width>
-    <height>201</height>
+    <width>435</width>
+    <height>233</height>
    </rect>
   </property>
@@ -184 +184 @@
  <connections>
   <connection>
+   <sender>cmdCancel</sender>
+   <signal>clicked()</signal>
+   <receiver>MultiConstraintUI</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>187</x>
+     <y>121</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>184</x>
+     <y>71</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
    <sender>cmdOK</sender>
    <signal>clicked()</signal>
@@ -199 +215 @@
    </hints>
   </connection>
-  <connection>
-   <sender>cmdCancel</sender>
-   <signal>clicked()</signal>
-   <receiver>MultiConstraintUI</receiver>
-   <slot>reject()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>187</x>
-     <y>121</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>184</x>
-     <y>71</y>
-    </hint>
-   </hints>
-  </connection>
  </connections>
 </ui>

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

@@ -34 +34 @@
         category_index = self.tab1.cbCategory.findText("Shape Independent")
         self.tab1.cbCategory.setCurrentIndex(category_index)
+        model_index = self.tab1.cbModel.findText("be_polyelectrolyte")
+        self.tab1.cbModel.setCurrentIndex(model_index)
+
         category_index = self.tab2.cbCategory.findText("Cylinder")
         self.tab2.cbCategory.setCurrentIndex(category_index)
+        model_index = self.tab2.cbModel.findText("barbell")
+        self.tab2.cbModel.setCurrentIndex(model_index)
 
         tabs = [self.tab1, self.tab2]
@@ -127 +132 @@
         """
         # default data
-        self.assertEqual(self.widget.constraint(), ('M1', 'scale', '=', 'M1.scale'))
+        c = self.widget.constraint()
+        self.assertEqual(c[0], 'M1')
+        self.assertEqual(c[1].func, 'M1.scale')
 
         # Change parameter and operand
-        self.widget.cbOperator.setCurrentIndex(3)
-        self.widget.cbParam1.setCurrentIndex(3)
-        self.assertEqual(self.widget.constraint(), ('M1', 'bjerrum_length', '>=', 'M1.scale'))
+        #self.widget.cbOperator.setCurrentIndex(3)
+        self.widget.cbParam2.setCurrentIndex(3)
+        c = self.widget.constraint()
+        self.assertEqual(c[0], 'M1')
+        self.assertEqual(c[1].func, 'M1.sld_solvent')
+        #self.assertEqual(c[1].operator, '>=')
 
     def testOnHelp(self):

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

@@ -175 +175 @@
         category_index = self.widget.cbCategory.findText("Shape Independent")
         self.widget.cbCategory.setCurrentIndex(category_index)
+        model_index = self.widget.cbModel.findText("be_polyelectrolyte")
+        self.widget.cbModel.setCurrentIndex(model_index)
 
         # test the model combo content
-        self.assertEqual(self.widget.cbModel.count(), 28)
+        self.assertEqual(self.widget.cbModel.count(), 30)
 
         # Try to change back to default
@@ -183 +185 @@
 
         # Observe no such luck
-        self.assertEqual(self.widget.cbCategory.currentIndex(), 6)
-        self.assertEqual(self.widget.cbModel.count(), 29)
+        self.assertEqual(self.widget.cbCategory.currentIndex(), 7)
+        self.assertEqual(self.widget.cbModel.count(), 30)
 
         # Set the structure factor
@@ -201 +203 @@
         category_index = self.widget.cbCategory.findText("Shape Independent")
         self.widget.cbCategory.setCurrentIndex(category_index)
+        model_index = self.widget.cbModel.findText("be_polyelectrolyte")
+        self.widget.cbModel.setCurrentIndex(model_index)
 
         # check the enablement of controls
@@ -215 +219 @@
         # 
         # Now change the model
-        self.widget.cbModel.setCurrentIndex(2)
+        self.widget.cbModel.setCurrentIndex(4)
         self.assertEqual(self.widget.cbModel.currentText(),'dab')
 
@@ -226 +230 @@
         self.widget.data_is_loaded = True
         # Reset the sasmodel index
-        self.widget.cbModel.setCurrentIndex(1)
+        self.widget.cbModel.setCurrentIndex(2)
         self.assertEqual(self.widget.cbModel.currentText(),'broad_peak')
 
@@ -377 +381 @@
         category_index = self.widget.cbCategory.findText("Shape Independent")
         self.widget.cbCategory.setCurrentIndex(category_index)
+        model_index = self.widget.cbModel.findText("be_polyelectrolyte")
+        self.widget.cbModel.setCurrentIndex(model_index)
+
         # Check the poly model
         self.assertEqual(self.widget._poly_model.rowCount(), 0)
@@ -383 +390 @@
         # Change the category index so we have a model available
         self.widget.cbCategory.setCurrentIndex(2)
+        self.widget.cbModel.setCurrentIndex(1)
 
         # Check the poly model
@@ -556 +564 @@
         category_index = self.widget.cbCategory.findText("Sphere")
         self.widget.cbCategory.setCurrentIndex(category_index)
+        model_index = self.widget.cbModel.findText("adsorbed_layer")
+        self.widget.cbModel.setCurrentIndex(model_index)
 
         # Check the magnetic model
@@ -634 +644 @@
         category_index = self.widget.cbCategory.findText("Sphere")
         self.widget.cbCategory.setCurrentIndex(category_index)
+        model_index = self.widget.cbModel.findText("adsorbed_layer")
+        self.widget.cbModel.setCurrentIndex(model_index)
 
         # Check the enablement/text
@@ -973 +985 @@
         category_index = self.widget.cbCategory.findText("Sphere")
         self.widget.cbCategory.setCurrentIndex(category_index)
+        model_index = self.widget.cbModel.findText("adsorbed_layer")
+        self.widget.cbModel.setCurrentIndex(model_index)
         self.widget.main_params_to_fit = ['scale']
 
@@ -986 +1000 @@
         self.assertListEqual(fp.main_params_to_fit, ['scale'])
 
-    def testPushFitPage(self):
+    def notestPushFitPage(self):
         """
         Push current state of fitpage onto stack
@@ -997 +1011 @@
         self.widget.data = item
         category_index = self.widget.cbCategory.findText("Sphere")
+        model_index = self.widget.cbModel.findText("adsorbed_layer")
+        self.widget.cbModel.setCurrentIndex(model_index)
 
         # Asses the initial state of stack

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

@@ -368 +368 @@
             cbox = createFixedChoiceComboBox(par, row)
 
+            # Apply combobox if required
+            if None not in (view, cbox):
+                # set the min/max cell to be empty
+                item3.setText("")
+                item4.setText("")
+
             # Always add to the model
             if row_num is None:
@@ -375 +381 @@
                 row_num += 1
 
-            # Apply combobox if required
-            if None not in (view, cbox):
+            if cbox is not None:
                 view.setIndexWidget(item2.index(), cbox)
 

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

@@ -95 +95 @@
             # Set some columns uneditable
             return None
+        if index.column() in (self.param_min, self.param_max):
+            # Check if the edit role is set
+            if not (index.flags() & QtCore.Qt.ItemIsEditable):
+                return None
 
         return super(ModelViewDelegate, self).createEditor(widget, option, index)

src/sas/qtgui/Perspectives/Fitting/media/fitting_help.rst

@@ -125 +125 @@
 
 For a complete list of all the library models available in SasView, see
-the `Model Documentation <../../../index.html>`_ .
+the `Model Documentation <models/index.html>`_ .
 
 It is also possible to add your own models.