Changes in / [04972ea:46f59ba] in sasview


Ignore:
Location:
src/sas/qtgui
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • src/sas/qtgui/MainWindow/GuiManager.py

    r8e2cd79 re4335ae  
    520520    def actionCopy(self): 
    521521        """ 
    522         Send a signal to the fitting perspective so parameters 
    523         can be saved to the clipboard 
    524         """ 
    525         self.communicate.copyFitParamsSignal.emit("") 
     522        """ 
     523        print("actionCopy TRIGGERED") 
    526524        pass 
    527525 
    528526    def actionPaste(self): 
    529527        """ 
    530         Send a signal to the fitting perspective so parameters 
    531         from the clipboard can be used to modify the fit state 
    532         """ 
    533         self.communicate.pasteFitParamsSignal.emit() 
     528        """ 
     529        print("actionPaste TRIGGERED") 
     530        pass 
    534531 
    535532    def actionReport(self): 
    … …  
    558555    def actionExcel(self): 
    559556        """ 
    560         Send a signal to the fitting perspective so parameters 
    561         can be saved to the clipboard 
    562         """ 
    563         self.communicate.copyFitParamsSignal.emit("Excel") 
     557        """ 
     558        print("actionExcel TRIGGERED") 
     559        pass 
    564560 
    565561    def actionLatex(self): 
    566562        """ 
    567         Send a signal to the fitting perspective so parameters 
    568         can be saved to the clipboard 
    569         """ 
    570         self.communicate.copyFitParamsSignal.emit("Latex") 
     563        """ 
     564        print("actionLatex TRIGGERED") 
     565        pass 
    571566 
    572567    #============ VIEW ================= 

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

    r8e2cd79 rb87dc1a  
    33from PyQt5 import QtCore 
    44from PyQt5 import QtGui 
     5from PyQt5 import QtWidgets 
    56 
    67import numpy 
    … …  
    9899                    continue 
    99100                width = kernel_module.getParam(p.name+'.width') 
    100                 ptype = kernel_module.getParam(p.name+'.type') 
     101                type = kernel_module.getParam(p.name+'.type') 
    101102 
    102103                item1_2 = QtGui.QStandardItem(str(width)) 
    … …  
    106107                item1_4 = QtGui.QStandardItem() 
    107108                item1_4.setEditable(False) 
    108                 item1_5 = QtGui.QStandardItem(ptype) 
     109                item1_5 = QtGui.QStandardItem(type) 
    109110                item1_5.setEditable(False) 
    110111                poly_item.appendRow([item1_1, item1_2, item1_3, item1_4, item1_5]) 
    … …  
    457458    returning the modified (deep) copy of the kernel. 
    458459    """ 
    459     assert isinstance(results, dict) 
     460    assert(isinstance(results, dict)) 
    460461    local_kernel = copy.deepcopy(kernel) 
    461462 
    … …  
    478479    for row in range(num_rows): 
    479480        param_name = model.item(row, 0).text() 
    480         checkbox_state = model.item(row, 0).checkState() == QtCore.Qt.Checked 
    481         value = model.item(row, 1).text() 
     481        checkbox_state = model.item(row,0).checkState() == QtCore.Qt.Checked 
     482        value= model.item(row, 1).text() 
    482483        column_shift = 0 
    483484        if model.columnCount() == 5: # no error column 
    … …  
    508509    """ 
    509510    param = [] 
    510     if kernel_module is None: 
     511    if kernel_module is None:  
    511512        return None 
    512513    for param_name in list(kernel_module.params.keys()): 
    … …  
    525526 
    526527    return param 
    527  
    528 def formatParameters(parameters): 
    529     """ 
    530     Prepare the parameter string in the standard SasView layout 
    531     """ 
    532     assert parameters is not None 
    533     assert isinstance(parameters, list) 
    534     output_string = "sasview_parameter_values:" 
    535     for parameter in parameters: 
    536         output_string += ",".join([p for p in parameter if p is not None]) 
    537         output_string += ":" 
    538     return output_string 
    539  
    540 def formatParametersExcel(parameters): 
    541     """ 
    542     Prepare the parameter string in the Excel format (tab delimited) 
    543     """ 
    544     assert parameters is not None 
    545     assert isinstance(parameters, list) 
    546     crlf = chr(13) + chr(10) 
    547     tab = chr(9) 
    548  
    549     output_string = "" 
    550     # names 
    551     names = "" 
    552     values = "" 
    553     for parameter in parameters: 
    554         names += parameter[0]+tab 
    555         # Add the error column if fitted 
    556         if parameter[1] == "True" and parameter[3] is not None: 
    557             names += parameter[0]+"_err"+tab 
    558  
    559         values += parameter[2]+tab 
    560         if parameter[1] == "True" and parameter[3] is not None: 
    561             values += parameter[3]+tab 
    562         # add .npts and .nsigmas when necessary 
    563         if parameter[0][-6:] == ".width": 
    564             names += parameter[0].replace('.width', '.nsigmas') + tab 
    565             names += parameter[0].replace('.width', '.npts') + tab 
    566             values += parameter[5] + tab + parameter[4] + tab 
    567  
    568     output_string = names + crlf + values 
    569     return output_string 
    570  
    571 def formatParametersLatex(parameters): 
    572     """ 
    573     Prepare the parameter string in latex 
    574     """ 
    575     assert parameters is not None 
    576     assert isinstance(parameters, list) 
    577     output_string = r'\begin{table}' 
    578     output_string += r'\begin{tabular}[h]' 
    579  
    580     crlf = chr(13) + chr(10) 
    581     output_string += '{|' 
    582     output_string += 'l|l|'*len(parameters) 
    583     output_string += r'}\hline' 
    584     output_string += crlf 
    585  
    586     for index, parameter in enumerate(parameters): 
    587         name = parameter[0] # Parameter name 
    588         output_string += name.replace('_', r'\_')  # Escape underscores 
    589         # Add the error column if fitted 
    590         if parameter[1] == "True" and parameter[3] is not None: 
    591             output_string += ' & ' 
    592             output_string += parameter[0]+r'\_err' 
    593  
    594         if index < len(parameters) - 1: 
    595             output_string += ' & ' 
    596  
    597         # add .npts and .nsigmas when necessary 
    598         if parameter[0][-6:] == ".width": 
    599             output_string += parameter[0].replace('.width', '.nsigmas') + ' & ' 
    600             output_string += parameter[0].replace('.width', '.npts') 
    601  
    602             if index < len(parameters) - 1: 
    603                 output_string += ' & ' 
    604  
    605     output_string += r'\\ \hline' 
    606     output_string += crlf 
    607  
    608     # Construct row of values and errors 
    609     for index, parameter in enumerate(parameters): 
    610         output_string += parameter[2] 
    611         if parameter[1] == "True" and parameter[3] is not None: 
    612             output_string += ' & ' 
    613             output_string += parameter[3] 
    614  
    615         if index < len(parameters) - 1: 
    616             output_string += ' & ' 
    617  
    618         # add .npts and .nsigmas when necessary 
    619         if parameter[0][-6:] == ".width": 
    620             output_string += parameter[5] + ' & ' 
    621             output_string += parameter[4] 
    622  
    623             if index < len(parameters) - 1: 
    624                 output_string += ' & ' 
    625  
    626     output_string += r'\\ \hline' 
    627     output_string += crlf 
    628     output_string += r'\end{tabular}' 
    629     output_string += r'\end{table}' 
    630  
    631     return output_string 

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

    r8e2cd79 r14acf92  
    11import json 
    22import os 
     3import copy 
    34from collections import defaultdict 
    45 
    … …  
    6970    """ 
    7071    def __init__(self, parent=None): 
    71         QtGui.QStandardItemModel.__init__(self, parent) 
     72        QtGui.QStandardItemModel.__init__(self,parent) 
    7273 
    7374    def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole): 
    … …  
    152153    def logic(self): 
    153154        # make sure the logic contains at least one element 
    154         assert self._logic 
     155        assert(self._logic) 
    155156        # logic connected to the currently shown data 
    156157        return self._logic[self.data_index] 
    … …  
    207208        self.is_chain_fitting = False 
    208209        # Is the fit job running? 
    209         self.fit_started = False 
     210        self.fit_started=False 
    210211        # The current fit thread 
    211212        self.calc_fit = None 
    … …  
    516517        self.communicate.saveAnalysisSignal.connect(self.savePageState) 
    517518        self.smearing_widget.smearingChangedSignal.connect(self.onSmearingOptionsUpdate) 
    518         self.communicate.copyFitParamsSignal.connect(self.onParameterCopy) 
    519         self.communicate.pasteFitParamsSignal.connect(self.onParameterPaste) 
     519        #self.communicate.saveReportSignal.connect(self.saveReport) 
    520520 
    521521    def modelName(self): 
    … …  
    557557            return menu 
    558558        # Select for fitting 
    559         param_string = "parameter " if num_rows == 1 else "parameters " 
    560         to_string = "to its current value" if num_rows == 1 else "to their current values" 
     559        param_string = "parameter " if num_rows==1 else "parameters " 
     560        to_string = "to its current value" if num_rows==1 else "to their current values" 
    561561        has_constraints = any([self.rowHasConstraint(i) for i in rows]) 
    562562 
    … …  
    613613        # There have to be only two rows selected. The caller takes care of that 
    614614        # but let's check the correctness. 
    615         assert len(selected_rows) == 2 
     615        assert(len(selected_rows)==2) 
    616616 
    617617        params_list = [s.data() for s in selected_rows] 
    … …  
    680680        """ 
    681681        # Create a new item and add the Constraint object as a child 
    682         assert isinstance(constraint, Constraint) 
    683         assert 0 <= row <= self._model_model.rowCount() 
     682        assert(isinstance(constraint, Constraint)) 
     683        assert(0<=row<=self._model_model.rowCount()) 
    684684 
    685685        item = QtGui.QStandardItem() 
    … …  
    732732        Delete constraints from selected parameters. 
    733733        """ 
    734         params = [s.data() for s in self.lstParams.selectionModel().selectedRows() 
     734        params =  [s.data() for s in self.lstParams.selectionModel().selectedRows() 
    735735                   if self.isCheckable(s.row())] 
    736736        for param in params: 
    … …  
    783783        Finds out if row of the main model has a constraint child 
    784784        """ 
    785         item = self._model_model.item(row, 1) 
     785        item = self._model_model.item(row,1) 
    786786        if item.hasChildren(): 
    787787            c = item.child(0).data() 
    … …  
    794794        Finds out if row of the main model has an active constraint child 
    795795        """ 
    796         item = self._model_model.item(row, 1) 
     796        item = self._model_model.item(row,1) 
    797797        if item.hasChildren(): 
    798798            c = item.child(0).data() 
    … …  
    805805        Finds out if row of the main model has an active, nontrivial constraint child 
    806806        """ 
    807         item = self._model_model.item(row, 1) 
     807        item = self._model_model.item(row,1) 
    808808        if item.hasChildren(): 
    809809            c = item.child(0).data() 
    … …  
    14431443        qmax = self.q_range_max 
    14441444        params_to_fit = self.parameters_to_fit 
    1445         if not params_to_fit: 
     1445        if (not params_to_fit): 
    14461446            raise ValueError('Fitting requires at least one parameter to optimize.') 
    14471447 
    … …  
    15621562        self.has_error_column = True 
    15631563 
    1564     def iterateOverPolyModel(self, func): 
    1565         """ 
    1566         Take func and throw it inside the poly model row loop 
    1567         """ 
    1568         for row_i in range(self._poly_model.rowCount()): 
    1569             func(row_i) 
    1570  
    15711564    def updatePolyModelFromList(self, param_dict): 
    15721565        """ 
    … …  
    15761569        if not dict: 
    15771570            return 
     1571 
     1572        def iterateOverPolyModel(func): 
     1573            """ 
     1574            Take func and throw it inside the poly model row loop 
     1575            """ 
     1576            for row_i in range(self._poly_model.rowCount()): 
     1577                func(row_i) 
    15781578 
    15791579        def updateFittedValues(row_i): 
    … …  
    16131613        # updating charts with every single model change on the end of fitting 
    16141614        self._poly_model.blockSignals(True) 
    1615         self.iterateOverPolyModel(updateFittedValues) 
     1615        iterateOverPolyModel(updateFittedValues) 
    16161616        self._poly_model.blockSignals(False) 
    16171617 
    … …  
    16211621        self.lstPoly.itemDelegate().addErrorColumn() 
    16221622        error_column = [] 
    1623         self.iterateOverPolyModel(createErrorColumn) 
     1623        iterateOverPolyModel(createErrorColumn) 
    16241624 
    16251625        # switch off reponse to model change 
    … …  
    16301630 
    16311631        self.has_poly_error_column = True 
    1632  
    1633     def iterateOverMagnetModel(self, func): 
    1634         """ 
    1635         Take func and throw it inside the magnet model row loop 
    1636         """ 
    1637         for row_i in range(self._model_model.rowCount()): 
    1638             func(row_i) 
    16391632 
    16401633    def updateMagnetModelFromList(self, param_dict): 
    … …  
    16861679        # updating charts with every single model change on the end of fitting 
    16871680        self._magnet_model.blockSignals(True) 
    1688         self.iterateOverMagnetModel(updateFittedValues) 
     1681        iterateOverMagnetModel(updateFittedValues) 
    16891682        self._magnet_model.blockSignals(False) 
    16901683 
    … …  
    16941687        self.lstMagnetic.itemDelegate().addErrorColumn() 
    16951688        error_column = [] 
    1696         self.iterateOverMagnetModel(createErrorColumn) 
     1689        iterateOverMagnetModel(createErrorColumn) 
    16971690 
    16981691        # switch off reponse to model change 
    … …  
    28102803        #self._copy_parameters_state(self.fixed_param, self.state.fixed_param) 
    28112804 
    2812     def onParameterCopy(self, format=None): 
    2813         """ 
    2814         Copy current parameters into the clipboard 
    2815         """ 
    2816         # run a loop over all parameters and pull out 
    2817         # first - regular params 
    2818         param_list = [] 
    2819         def gatherParams(row): 
    2820             """ 
    2821             Create list of main parameters based on _model_model 
    2822             """ 
    2823             param_name = str(self._model_model.item(row, 0).text()) 
    2824             param_checked = str(self._model_model.item(row, 0).checkState() == QtCore.Qt.Checked) 
    2825             param_value = str(self._model_model.item(row, 1).text()) 
    2826             param_error = None 
    2827             column_offset = 0 
    2828             if self.has_error_column: 
    2829                 param_error = str(self._model_model.item(row, 2).text()) 
    2830                 column_offset = 1 
    2831             param_min = str(self._model_model.item(row, 2+column_offset).text()) 
    2832             param_max = str(self._model_model.item(row, 3+column_offset).text()) 
    2833             param_list.append([param_name, param_checked, param_value, param_error, param_min, param_max]) 
    2834  
    2835         def gatherPolyParams(row): 
    2836             """ 
    2837             Create list of polydisperse parameters based on _poly_model 
    2838             """ 
    2839             param_name = str(self._poly_model.item(row, 0).text()).split()[-1] 
    2840             param_checked = str(self._poly_model.item(row, 0).checkState() == QtCore.Qt.Checked) 
    2841             param_value = str(self._poly_model.item(row, 1).text()) 
    2842             param_error = None 
    2843             column_offset = 0 
    2844             if self.has_poly_error_column: 
    2845                 param_error = str(self._poly_model.item(row, 2).text()) 
    2846                 column_offset = 1 
    2847             param_min   = str(self._poly_model.item(row, 2+column_offset).text()) 
    2848             param_max   = str(self._poly_model.item(row, 3+column_offset).text()) 
    2849             param_npts  = str(self._poly_model.item(row, 4+column_offset).text()) 
    2850             param_nsigs = str(self._poly_model.item(row, 5+column_offset).text()) 
    2851             param_fun   = str(self._poly_model.item(row, 6+column_offset).text()).rstrip() 
    2852             # width 
    2853             name = param_name+".width" 
    2854             param_list.append([name, param_checked, param_value, param_error, 
    2855                                 param_npts, param_nsigs, param_min, param_max, param_fun]) 
    2856  
    2857         def gatherMagnetParams(row): 
    2858             """ 
    2859             Create list of magnetic parameters based on _magnet_model 
    2860             """ 
    2861             param_name = str(self._magnet_model.item(row, 0).text()) 
    2862             param_checked = str(self._magnet_model.item(row, 0).checkState() == QtCore.Qt.Checked) 
    2863             param_value = str(self._magnet_model.item(row, 1).text()) 
    2864             param_error = None 
    2865             column_offset = 0 
    2866             if self.has_magnet_error_column: 
    2867                 param_error = str(self._magnet_model.item(row, 2).text()) 
    2868                 column_offset = 1 
    2869             param_min = str(self._magnet_model.item(row, 2+column_offset).text()) 
    2870             param_max = str(self._magnet_model.item(row, 3+column_offset).text()) 
    2871             param_list.append([param_name, param_checked, param_value, param_error, param_min, param_max]) 
    2872  
    2873         self.iterateOverModel(gatherParams) 
    2874         if self.chkPolydispersity.isChecked(): 
    2875             self.iterateOverPolyModel(gatherPolyParams) 
    2876         if self.chkMagnetism.isChecked() and self.chkMagnetism.isEnabled(): 
    2877             self.iterateOverMagnetModel(sgatherMagnetParams) 
    2878  
    2879         if format=="": 
    2880             formatted_output = FittingUtilities.formatParameters(param_list) 
    2881         elif format == "Excel": 
    2882             formatted_output = FittingUtilities.formatParametersExcel(param_list) 
    2883         elif format == "Latex": 
    2884             formatted_output = FittingUtilities.formatParametersLatex(param_list) 
    2885         else: 
    2886             raise AttributeError("Bad format specifier.") 
    2887  
    2888         # Dump formatted_output to the clipboard 
    2889         cb = QtWidgets.QApplication.clipboard() 
    2890         cb.setText(formatted_output) 
    2891  
    2892     def onParameterPaste(self): 
    2893         """ 
    2894         Use the clipboard to update fit state 
    2895         """ 
    2896         # Check if the clipboard contains right stuff 
    2897         cb = QtWidgets.QApplication.clipboard() 
    2898         cb_text = cb.text() 
    2899  
    2900         context = {} 
    2901         # put the text into dictionary 
    2902         lines = cb_text.split(':') 
    2903         if lines[0] != 'sasview_parameter_values': 
    2904             return False 
    2905         for line in lines[1:-1]: 
    2906             if len(line) != 0: 
    2907                 item = line.split(',') 
    2908                 check = item[1] 
    2909                 name = item[0] 
    2910                 value = item[2] 
    2911                 # Transfer the text to content[dictionary] 
    2912                 context[name] = [check, value] 
    2913  
    2914                 # limits 
    2915                 limit_lo = item[3] 
    2916                 context[name].append(limit_lo) 
    2917                 limit_hi = item[4] 
    2918                 context[name].append(limit_hi) 
    2919  
    2920                 # Polydisp 
    2921                 if len(item) > 5: 
    2922                     value = item[5] 
    2923                     context[name].append(value) 
    2924                     try: 
    2925                         value = item[6] 
    2926                         context[name].append(value) 
    2927                         value = item[7] 
    2928                         context[name].append(value) 
    2929                     except IndexError: 
    2930                         pass 
    2931  
    2932         self.updateFullModel(context) 
    2933         self.updateFullPolyModel(context) 
    2934  
    2935     def updateFullModel(self, param_dict): 
    2936         """ 
    2937         Update the model with new parameters 
    2938         """ 
    2939         assert isinstance(param_dict, dict) 
    2940         if not dict: 
    2941             return 
    2942  
    2943         def updateFittedValues(row): 
    2944             # Utility function for main model update 
    2945             # internal so can use closure for param_dict 
    2946             param_name = str(self._model_model.item(row, 0).text()) 
    2947             if param_name not in list(param_dict.keys()): 
    2948                 return 
    2949             # checkbox state 
    2950             param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked 
    2951             self._model_model.item(row, 0).setCheckState(param_checked) 
    2952  
    2953             # modify the param value 
    2954             param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True) 
    2955             self._model_model.item(row, 1).setText(param_repr) 
    2956  
    2957             # Potentially the error column 
    2958             ioffset = 0 
    2959             if len(param_dict[param_name])>4 and self.has_error_column: 
    2960                 # error values are not editable - no need to update 
    2961                 #error_repr = GuiUtils.formatNumber(param_dict[param_name][2], high=True) 
    2962                 #self._model_model.item(row, 2).setText(error_repr) 
    2963                 ioffset = 1 
    2964             # min/max 
    2965             param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True) 
    2966             self._model_model.item(row, 2+ioffset).setText(param_repr) 
    2967             param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True) 
    2968             self._model_model.item(row, 3+ioffset).setText(param_repr) 
    2969  
    2970         # block signals temporarily, so we don't end up 
    2971         # updating charts with every single model change on the end of fitting 
    2972         self._model_model.blockSignals(True) 
    2973         self.iterateOverModel(updateFittedValues) 
    2974         self._model_model.blockSignals(False) 
    2975  
    2976     def updateFullPolyModel(self, param_dict): 
    2977         """ 
    2978         Update the polydispersity model with new parameters, create the errors column 
    2979         """ 
    2980         assert isinstance(param_dict, dict) 
    2981         if not dict: 
    2982             return 
    2983  
    2984         def updateFittedValues(row): 
    2985             # Utility function for main model update 
    2986             # internal so can use closure for param_dict 
    2987             if row >= self._poly_model.rowCount(): 
    2988                 return 
    2989             param_name = str(self._poly_model.item(row, 0).text()).rsplit()[-1] + '.width' 
    2990             if param_name not in list(param_dict.keys()): 
    2991                 return 
    2992             # checkbox state 
    2993             param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked 
    2994             self._poly_model.item(row,0).setCheckState(param_checked) 
    2995  
    2996             # modify the param value 
    2997             param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True) 
    2998             self._poly_model.item(row, 1).setText(param_repr) 
    2999  
    3000             # Potentially the error column 
    3001             ioffset = 0 
    3002             if len(param_dict[param_name])>4 and self.has_poly_error_column: 
    3003                 ioffset = 1 
    3004             # min 
    3005             param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True) 
    3006             self._poly_model.item(row, 2+ioffset).setText(param_repr) 
    3007             # max 
    3008             param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True) 
    3009             self._poly_model.item(row, 3+ioffset).setText(param_repr) 
    3010             # Npts 
    3011             param_repr = GuiUtils.formatNumber(param_dict[param_name][4+ioffset], high=True) 
    3012             self._poly_model.item(row, 4+ioffset).setText(param_repr) 
    3013             # Nsigs 
    3014             param_repr = GuiUtils.formatNumber(param_dict[param_name][5+ioffset], high=True) 
    3015             self._poly_model.item(row, 5+ioffset).setText(param_repr) 
    3016  
    3017             param_repr = GuiUtils.formatNumber(param_dict[param_name][5+ioffset], high=True) 
    3018             self._poly_model.item(row, 5+ioffset).setText(param_repr) 
    3019  
    3020         # block signals temporarily, so we don't end up 
    3021         # updating charts with every single model change on the end of fitting 
    3022         self._poly_model.blockSignals(True) 
    3023         self.iterateOverPolyModel(updateFittedValues) 
    3024         self._poly_model.blockSignals(False) 
    3025  
    3026  
     2805 

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

    r8e2cd79 rcf8d6c9  
    288288            rect = textRect.topLeft() 
    289289            y = rect.y() 
    290             y += 6.0 # magic value for rendering nice display in the table 
     290            y += 5.0 # magic value for rendering nice display in the table 
    291291            rect.setY(y) 
    292292            painter.translate(rect) 

  • src/sas/qtgui/Utilities/GuiUtils.py

    r8e2cd79 r6ff103a  
    254254    # Mask Editor requested 
    255255    maskEditorSignal = QtCore.pyqtSignal(Data2D) 
    256  
    257     # Fitting parameter copy to clipboard 
    258     copyFitParamsSignal = QtCore.pyqtSignal(str) 
    259  
    260     # Fitting parameter paste from clipboard 
    261     pasteFitParamsSignal = QtCore.pyqtSignal() 
    262256 
    263257def updateModelItemWithPlot(item, update_data, name=""): 
Note: See TracChangeset for help on using the changeset viewer.