Changeset dceff6e for src/sas/sasgui – SasView

src/sas/sasgui/guiframe/data_panel.py

-                      rd85c194
+                      re767897
 #This software was developed by the University of Tennessee as part of the
 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
 #project funded by the US National Science Foundation.
+#project funded by the US National Science Foundation.
+#
 #See the license text in license.txt
 …
 import wx
 from wx.build import build_options
 # Check version
 toks = str(wx.__version__).split('.')
 …
         as QucikPlotDialog
 import sas.sasgui.guiframe.config as config
 extension_list = []
 if config.APPLICATION_STATE_EXTENSION is not None:
     extension_list.append(config.APPLICATION_STATE_EXTENSION)
 EXTENSIONS = config.PLUGIN_STATE_EXTENSIONS + extension_list
+EXTENSIONS = config.PLUGIN_STATE_EXTENSIONS + extension_list
 PLUGINS_WLIST = config.PLUGINS_WLIST
 APPLICATION_WLIST = config.APPLICATION_WLIST
 #Control panel width
+#Control panel width
 if sys.platform.count("win32") > 0:
     PANEL_WIDTH = 235
 …
 STYLE_FLAG = wx.RAISED_BORDER|CT.TR_HAS_BUTTONS| CT.TR_HIDE_ROOT|\
                     wx.WANTS_CHARS|CT.TR_HAS_VARIABLE_ROW_HEIGHT
 class DataTreeCtrl(CT.CustomTreeCtrl):
     """
 …
                     CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds)
         self.root = self.AddRoot("Available Data")
     def OnCompareItems(self, item1, item2):
         """
         Overrides OnCompareItems in wx.TreeCtrl.
         Used by the SortChildren method.
+        """
+        Overrides OnCompareItems in wx.TreeCtrl.
+        Used by the SortChildren method.
         """
         # Get the item data
 …
         else:
             return 0
 class DataPanel(ScrolledPanel, PanelBase):
     """
     This panel displays data available in the application and widgets to
+    This panel displays data available in the application and widgets to
     interact with data.
     """
 …
     ## Title to appear on top of the window
     window_caption = "Data Explorer"
     #type of window
+    #type of window
     window_type = "Data Panel"
     ## Flag to tell the GUI manager that this panel is not
     #  tied to any perspective
     #ALWAYS_ON = True
     def __init__(self, parent,
+    def __init__(self, parent,
                  list=None,
                  size=(PANEL_WIDTH, PANEL_HEIGHT),
 …
         PanelBase.__init__(self, parent)
         self.SetupScrolling()
         #Set window's font size
+        #Set window's font size
         self.SetWindowVariant(variant=FONT_VARIANT)
         self.loader = Loader()
+        self.loader = Loader()
         #Default location
         self._default_save_location = None
+        self._default_save_location = None
         self.all_data1d = True
         self.parent = parent.parent
 …
         if self.parent is not None:
             self.parent.Bind(EVT_DELETE_PLOTPANEL, self._on_delete_plot_panel)
     def do_layout(self):
         """
 …
         self.layout_batch()
         self.layout_button()
     def disable_app_combo(self, enable):
         """
 …
         """
         self.perspective_cbox.Enable(enable)
     def define_panel_structure(self):
         """
 …
         self.sizer1 = wx.BoxSizer(wx.VERTICAL)
         self.sizer1.SetMinSize(wx.Size(w/13, h*2/5))
         self.sizer2 = wx.BoxSizer(wx.VERTICAL)
         self.sizer3 = wx.FlexGridSizer(9, 2, 4, 1)
         self.sizer4 = wx.BoxSizer(wx.VERTICAL)
         self.sizer5 = wx.BoxSizer(wx.VERTICAL)
         self.vbox.Add(self.sizer5, 0, wx.EXPAND|wx.ALL, 1)
         self.vbox.Add(self.sizer1, 1, wx.EXPAND|wx.ALL, 0)
 …
         self.vbox.Add(self.sizer3, 0, wx.EXPAND|wx.ALL, 10)
         #self.vbox.Add(self.sizer4, 0, wx.EXPAND|wx.ALL,5)
         self.SetSizer(self.vbox)
     def layout_selection(self):
         """
 …
         self.selection_cbox.SetValue('Select all Data')
         wx.EVT_COMBOBOX(self.selection_cbox, -1, self._on_selection_type)
         self.sizer5.AddMany([(select_txt, 0, wx.ALL, 5),
+        self.sizer5.AddMany([(select_txt, 0, wx.ALL, 5),
                             (self.selection_cbox, 0, wx.ALL,5)])
         self.enable_selection()
     def _on_selection_type(self, event):
         """
 …
             :param event: UI event
         """
+        def check_item_and_children(control, check_value=True):
+            self.tree_ctrl.CheckItem(data_ctrl, check_value)
+            if data_ctrl.HasChildren():
+                if check_value == True and not control.IsExpanded():
+                    # Only select children if control is expanded
+                    # Always deselect children, regardless (see ticket #259)
+                    return
+                for child_ctrl in data_ctrl.GetChildren():
+                    self.tree_ctrl.CheckItem(child_ctrl, check_value)
         option = self.selection_cbox.GetValue()
         pos = self.selection_cbox.GetSelection()
         if pos == wx.NOT_FOUND:
             return
+            return
         option = self.selection_cbox.GetString(pos)
         for item in self.list_cb_data.values():
             data_ctrl, _, _, _, _, _, _, _ = item
             _, data_class, _ = self.tree_ctrl.GetItemPyData(data_ctrl)
+            _, data_class, _ = self.tree_ctrl.GetItemPyData(data_ctrl)
             if option == 'Select all Data':
                 self.tree_ctrl.CheckItem(data_ctrl, True)
+                check_item_and_children(data_ctrl, check_value=True)
             elif option == 'Unselect all Data':
                 self.tree_ctrl.CheckItem(data_ctrl, False)
+                check_item_and_children(data_ctrl, check_value=False)
             elif option == 'Select all Data 1D':
                 if data_class == 'Data1D':
                     self.tree_ctrl.CheckItem(data_ctrl, True)
+                    check_item_and_children(data_ctrl, check_value=True)
             elif option == 'Unselect all Data 1D':
                 if data_class == 'Data1D':
+                    self.tree_ctrl.CheckItem(data_ctrl, False)
+            elif option == 'Select all Data 1D':
+                if data_class == 'Data1D':
+                    self.tree_ctrl.CheckItem(data_ctrl, True)
+                    check_item_and_children(data_ctrl, check_value=False)
             elif option == 'Select all Data 2D':
                 if data_class == 'Data2D':
                     self.tree_ctrl.CheckItem(data_ctrl, True)
+                    check_item_and_children(data_ctrl, check_value=True)
             elif option == 'Unselect all Data 2D':
                 if data_class == 'Data2D':
                     self.tree_ctrl.CheckItem(data_ctrl, False)
+                    check_item_and_children(data_ctrl, check_value=False)
         self.enable_append()
         self.enable_freeze()
 …
         self.enable_import()
         self.enable_remove()
     def layout_button(self):
         """
         Layout widgets related to buttons
         """
+        self.bt_add = wx.Button(self, wx.NewId(), "Load Data",
+        #Load Data Button
+        self.bt_add = wx.Button(self, wx.NewId(), "Load Data",
                                 size=(BUTTON_WIDTH, -1))
         self.bt_add.SetToolTipString("Load data files")
         wx.EVT_BUTTON(self, self.bt_add.GetId(), self._load_data)
+        #Delete Data Button
         self.bt_remove = wx.Button(self, wx.NewId(), "Delete Data",
          size=(BUTTON_WIDTH, -1))
         self.bt_remove.SetToolTipString("Delete data from the application")
         wx.EVT_BUTTON(self, self.bt_remove.GetId(), self.on_remove)
+        #Send data to perspective button
         self.bt_import = wx.Button(self, wx.NewId(), "Send To",
                                     size=(BUTTON_WIDTH, -1))
         self.bt_import.SetToolTipString("Send Data set to active perspective")
         wx.EVT_BUTTON(self, self.bt_import.GetId(), self.on_import)
+        #Choose perspective to be send data to combo box
         self.perspective_cbox = wx.ComboBox(self, -1,
                                 style=wx.CB_READONLY)
         if not IS_MAC:
             self.perspective_cbox.SetMinSize((BUTTON_WIDTH*1.6, -1))
         wx.EVT_COMBOBOX(self.perspective_cbox, -1,
+        wx.EVT_COMBOBOX(self.perspective_cbox, -1,
                         self._on_perspective_selection)
+        #Append data to current Graph Button
         self.bt_append_plot = wx.Button(self, wx.NewId(), "Append Plot To",
                                         size=(BUTTON_WIDTH, -1))
 …
                                 "Plot the selected data in the active panel")
         wx.EVT_BUTTON(self, self.bt_append_plot.GetId(), self.on_append_plot)
+        self.bt_plot = wx.Button(self, wx.NewId(), "New Plot",
+        #Create a new graph and send data to that new graph button
+        self.bt_plot = wx.Button(self, wx.NewId(), "New Plot",
                                  size=(BUTTON_WIDTH, -1))
         self.bt_plot.SetToolTipString("To trigger plotting")
         wx.EVT_BUTTON(self, self.bt_plot.GetId(), self.on_plot)
+        self.bt_freeze = wx.Button(self, wx.NewId(), "Freeze Theory",
+        #Freeze current theory button - becomes a data set and stays on graph
+        self.bt_freeze = wx.Button(self, wx.NewId(), "Freeze Theory",
                                    size=(BUTTON_WIDTH, -1))
         freeze_tip = "To trigger freeze a theory: making a copy\n"
 …
         self.bt_freeze.SetToolTipString(freeze_tip)
         wx.EVT_BUTTON(self, self.bt_freeze.GetId(), self.on_freeze)
+        #select plot to send to combo box (blank if no data)
         if sys.platform == 'darwin':
             self.cb_plotpanel = wx.ComboBox(self, -1,
+            self.cb_plotpanel = wx.ComboBox(self, -1,
                                             style=wx.CB_READONLY)
         else:
             self.cb_plotpanel = wx.ComboBox(self, -1,
+            self.cb_plotpanel = wx.ComboBox(self, -1,
                                             style=wx.CB_READONLY|wx.CB_SORT)
         wx.EVT_COMBOBOX(self.cb_plotpanel, -1, self._on_plot_selection)
         self.cb_plotpanel.Disable()
+        #Help button
+        self.bt_help = wx.Button(self, wx.NewId(), "HELP",
+                                 size=(BUTTON_WIDTH, -1))
+        self.bt_help.SetToolTipString("Help for the Data Explorer.")
+        wx.EVT_BUTTON(self,self.bt_help.GetId(), self.on_help)
         self.sizer3.AddMany([(self.bt_add),
 …
                              ((10, 10)),
                              (self.bt_append_plot),
                              (self.cb_plotpanel,
+                             (self.cb_plotpanel,
                               wx.EXPAND|wx.ADJUST_MINSIZE, 5),
                              ((5, 5)),
                              ((5, 5)),
                              (self.bt_import, 0, wx.EXPAND|wx.RIGHT, 5),
                              (self.perspective_cbox,
+                             (self.perspective_cbox,
                               wx.EXPAND|wx.ADJUST_MINSIZE, 5),
                              ((10, 10)),
                              (self.sizer4),
                              ((10, 40)),
                              ((10, 40))])
+                             ((10, 10)),
+                             (self.bt_help, 0, wx.RIGHT, 5)])
         self.sizer3.AddGrowableCol(1, 1)
 …
         self.enable_freeze()
         self.enable_remove_plot()
     def layout_batch(self):
         """
 …
         self.Bind(wx.EVT_RADIOBUTTON, self.on_batch_mode,
                    id=self.rb_batch_mode.GetId())
         self.rb_single_mode.SetValue(not self.parent.batch_on)
         self.rb_batch_mode.SetValue(self.parent.batch_on)
         self.sizer4.AddMany([(self.rb_single_mode, 0, wx.ALL, 4),
                              (self.rb_batch_mode, 0, wx.ALL, 4)])
     def on_single_mode(self, event):
         """
 …
         if self.parent is not None:
             wx.PostEvent(self.parent, NewBatchEvent(enable=False))
     def on_batch_mode(self, event):
         """
 …
         """
         if self.parent is not None:
             wx.PostEvent(self.parent,
+            wx.PostEvent(self.parent,
                          NewBatchEvent(enable=True))
     def _get_data_selection(self, event):
+    def _get_data_selection(self, event):
         """
             Get data selection from the right click
 …
             data = theory_list.values()[0][0]
         return data
     def on_edit_data(self, event):
         """
 …
         from sas.sasgui.guiframe.local_perspectives.plotting.masking \
             import MaskPanel as MaskDialog
         panel = MaskDialog(parent=self.parent, base=self,
+        panel = MaskDialog(parent=self.parent, base=self,
                            data=data, id=wx.NewId())
         panel.ShowModal()
     def on_plot_3d(self, event):
         """
 …
         from sas.sasgui.guiframe.local_perspectives.plotting.masking \
         import FloatPanel as Float3dDialog
         panel = Float3dDialog(base=self, data=data,
+        panel = Float3dDialog(base=self, data=data,
                               dimension=3, id=wx.NewId())
         panel.ShowModal()
+        panel.ShowModal()
     def on_quick_plot(self, event):
         """
 …
             dimension = 2
         else:
             dimension = 1
         #panel = QucikPlotDialog(base=self, data=data,
+            dimension = 1
+        #panel = QucikPlotDialog(base=self, data=data,
         #                        dimension=dimension, id=wx.NewId())
         frame = QucikPlotDialog(self, -1, "Plot " + data.name, 'log_{10}')
 …
         frame.Show(True)
         frame.SetFocus()
         #panel.ShowModal()
+        #panel.ShowModal()
     def on_data_info(self, event):
         """
 …
         else:
             self.parent.show_data1d(data, data.name)
     def on_save_as(self, event):
         """
 …
             else:
                 print "unable to save this type of data"
     def layout_data_list(self):
         """
 …
         self.data_menu.Append(id, name, msg)
         wx.EVT_MENU(self, id, self.on_data_info)
         id = wx.NewId()
         name = "Save As"
 …
         self.data_menu.Append(id, name, msg)
         wx.EVT_MENU(self, id, self.on_save_as)
         quickplot_id = wx.NewId()
         name = "Quick Plot"
 …
         self.data_menu.Append(quickplot_id, name, msg)
         wx.EVT_MENU(self, quickplot_id, self.on_quick_plot)
         self.plot3d_id = wx.NewId()
         name = "Quick 3DPlot (Slow)"
 …
         self.data_menu.Append(self.plot3d_id, name, msg)
         wx.EVT_MENU(self, self.plot3d_id, self.on_plot_3d)
         self.editmask_id = wx.NewId()
         name = "Edit Mask"
 …
         self.data_menu.Append(self.editmask_id, name, msg)
         wx.EVT_MENU(self, self.editmask_id, self.on_edit_data)
         tree_ctrl_theory_label = wx.StaticText(self, -1, "Theory")
         tree_ctrl_theory_label.SetForegroundColour('blue')
         self.tree_ctrl_theory = DataTreeCtrl(parent=self,
+        self.tree_ctrl_theory = DataTreeCtrl(parent=self,
                                                     style=wx.SUNKEN_BORDER)
         self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_CHECKING,
+        self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_CHECKING,
                                                     self.on_check_item)
         self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_MENU,
+        self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_MENU,
                                    self.on_right_click_theory)
         self.sizer1.Add(tree_ctrl_label, 0, wx.LEFT, 10)
 …
         self.sizer1.Add(tree_ctrl_theory_label, 0,  wx.LEFT, 10)
         self.sizer1.Add(self.tree_ctrl_theory, 1, wx.EXPAND|wx.ALL, 10)
     def on_right_click_theory(self, event):
         """
 …
             self.data_menu.Enable(self.editmask_id, False)
             self.data_menu.Enable(self.plot3d_id, menu_enable)
             self.PopupMenu(self.data_menu)
+            self.PopupMenu(self.data_menu)
     def on_right_click_data(self, event):
         """
 …
             self.data_menu.Enable(self.editmask_id, maskmenu_enable)
             self.data_menu.Enable(self.plot3d_id, menu_enable)
             self.PopupMenu(self.data_menu)
     def onContextMenu(self, event):
+            self.PopupMenu(self.data_menu)
+    def onContextMenu(self, event):
         """
         Retrieve the state selected state
 …
         pos = event.GetPosition()
         pos = self.ScreenToClient(pos)
         self.PopupMenu(self.popUpMenu, pos)
+        self.PopupMenu(self.popUpMenu, pos)
     def on_check_item(self, event):
         """
 …
         """
         item = event.GetItem()
         item.Check(not item.IsChecked())
+        item.Check(not item.IsChecked())
         self.enable_append()
         self.enable_freeze()
 …
         self.enable_remove()
         event.Skip()
     def fill_cbox_analysis(self, plugin):
         """
 …
                 if plug.get_perspective():
                     self.perspective_cbox.Append(plug.sub_menu, plug)
             curr_pers = self.parent.get_current_perspective()
             if curr_pers:
                 self.perspective_cbox.SetStringSelection(curr_pers.sub_menu)
                 self.enable_import()
     def load_data_list(self, list):
         """
 …
                     data_run = str(data.run)
                     data_class = data.__class__.__name__
                     path = dstate.get_path()
+                    path = dstate.get_path()
                     process_list = data.process
                     data_id = data.id
 …
                         #new state
                         data_c = self.tree_ctrl.InsertItem(self.tree_ctrl.root,
 , data_name, ct_type=1,
+, data_name, ct_type=1,
                                         data=(data_id, data_class, state_id))
                         data_c.Check(True)
                         d_i_c = self.tree_ctrl.AppendItem(data_c, 'Info')
                         d_t_c = self.tree_ctrl.AppendItem(d_i_c,
+                        d_t_c = self.tree_ctrl.AppendItem(d_i_c,
                                                       'Title: %s' % data_title)
                         r_n_c = self.tree_ctrl.AppendItem(d_i_c,
+                        r_n_c = self.tree_ctrl.AppendItem(d_i_c,
                                                       'Run: %s' % data_run)
                         i_c_c = self.tree_ctrl.AppendItem(d_i_c,
+                        i_c_c = self.tree_ctrl.AppendItem(d_i_c,
                                                       'Type: %s' % data_class)
                         p_c_c = self.tree_ctrl.AppendItem(d_i_c,
                                                       "Path: '%s'" % s_path)
                         d_p_c = self.tree_ctrl.AppendItem(d_i_c, 'Process')
                         for process in process_list:
                             process_str = str(process).replace('\n',' ')
 …
                                 process_str = process_str[:20]+' [...]'
                             self.tree_ctrl.AppendItem(d_p_c, process_str)
                         theory_child = self.tree_ctrl.AppendItem(data_c,
+                        theory_child = self.tree_ctrl.AppendItem(data_c,
                                                                  "THEORIES")
                         self.list_cb_data[state_id] = [data_c,
+                        self.list_cb_data[state_id] = [data_c,
                                                        d_i_c,
                                                        d_t_c,
 …
                         data_c, d_i_c, d_t_c, r_n_c,  i_c_c, p_c_c, d_p_c, _ \
                                 = data_ctrl_list
                         self.tree_ctrl.SetItemText(data_c, data_name)
+                        self.tree_ctrl.SetItemText(data_c, data_name)
                         temp = (data_id, data_class, state_id)
                         self.tree_ctrl.SetItemPyData(data_c, temp)
                         self.tree_ctrl.SetItemText(i_c_c,
+                        self.tree_ctrl.SetItemPyData(data_c, temp)
+                        self.tree_ctrl.SetItemText(i_c_c,
                                                    'Type: %s' % data_class)
                         self.tree_ctrl.SetItemText(p_c_c,
                                                    'Path: %s' % s_path)
                         self.tree_ctrl.DeleteChildren(d_p_c)
+                        self.tree_ctrl.SetItemText(p_c_c,
+                                                   'Path: %s' % s_path)
+                        self.tree_ctrl.DeleteChildren(d_p_c)
                         for process in process_list:
                             if not process.is_empty():
 …
             # Sort by data name
             if self.tree_ctrl.root:
                 self.tree_ctrl.SortChildren(self.tree_ctrl.root)
+                self.tree_ctrl.SortChildren(self.tree_ctrl.root)
         self.enable_remove()
         self.enable_import()
 …
         self.enable_freeze()
         self.enable_selection()
     def _uncheck_all(self):
         """
 …
         for item in self.list_cb_data.values():
             data_ctrl, _, _, _, _, _, _, _ = item
             self.tree_ctrl.CheckItem(data_ctrl, False)
+            self.tree_ctrl.CheckItem(data_ctrl, False)
         self.enable_append()
         self.enable_freeze()
 …
         self.enable_import()
         self.enable_remove()
     def append_theory(self, state_id, theory_list):
         """
 …
         """
         if not theory_list:
             return
+            return
         if state_id not in self.list_cb_data.keys():
             root = self.tree_ctrl_theory.root
 …
             tree = self.tree_ctrl
         if root is not None:
             wx.CallAfter(self.append_theory_helper, tree=tree, root=root,
                                        state_id=state_id,
+            wx.CallAfter(self.append_theory_helper, tree=tree, root=root,
+                                       state_id=state_id,
                                        theory_list=theory_list)
     def append_theory_helper(self, tree, root, state_id, theory_list):
         """
 …
                                                     name, ct_type=1, data=temp)
                     t_i_c = tree.AppendItem(t_child, 'Info')
                     i_c_c = tree.AppendItem(t_i_c,
+                    i_c_c = tree.AppendItem(t_i_c,
                                                   'Type: %s' % theory_class)
                     t_p_c = tree.AppendItem(t_i_c, 'Process')
                     for process in theory_data.process:
                         tree.AppendItem(t_p_c, process.__str__())
                     theory_list_ctrl[theory_id] = [t_child,
                                                    i_c_c,
+                    theory_list_ctrl[theory_id] = [t_child,
+                                                   i_c_c,
                                                    t_p_c]
                 else:
                     #replace theory
                     t_child, i_c_c, t_p_c = theory_list_ctrl[theory_id]
                     tree.SetItemText(t_child, name)
                     tree.SetItemPyData(t_child, temp)
                     tree.SetItemText(i_c_c, 'Type: %s' % theory_class)
                     tree.DeleteChildren(t_p_c)
+                    tree.SetItemText(t_child, name)
+                    tree.SetItemPyData(t_child, temp)
+                    tree.SetItemText(i_c_c, 'Type: %s' % theory_class)
+                    tree.DeleteChildren(t_p_c)
                     for process in theory_data.process:
                         tree.AppendItem(t_p_c, process.__str__())
         else:
             #data didn't have a theory associated it before
 …
                     theory_id = theory_data.id
                     #if theory_state is not None:
                     #    name = theory_state.model.name
+                    #    name = theory_state.model.name
                     temp = (theory_id, theory_class, state_id)
                     t_child = tree.AppendItem(root,
                             name, ct_type=1,
+                            name, ct_type=1,
                             data=(theory_data.id, theory_class, state_id))
                     t_i_c = tree.AppendItem(t_child, 'Info')
                     i_c_c = tree.AppendItem(t_i_c,
+                    i_c_c = tree.AppendItem(t_i_c,
                                                   'Type: %s' % theory_class)
                     t_p_c = tree.AppendItem(t_i_c, 'Process')
                     for process in theory_data.process:
                         tree.AppendItem(t_p_c, process.__str__())
                     theory_list_ctrl[theory_id] = [t_child, i_c_c, t_p_c]
                 #self.list_cb_theory[data_id] = theory_list_ctrl
                 self.list_cb_theory[state_id] = theory_list_ctrl
     def set_data_helper(self):
         """
 …
                 if state_id not in state_to_plot:
                     state_to_plot.append(state_id)
         for theory_dict in self.list_cb_theory.values():
             for _, value in theory_dict.iteritems():
 …
                         state_to_plot.append(state_id)
         return data_to_plot, theory_to_plot, state_to_plot
     def remove_by_id(self, id):
         """
 …
         for item in self.list_cb_data.values():
             data_c, _, _, _, _, _,  _, _ = item
             data_id, _, state_id = self.tree_ctrl.GetItemPyData(data_c)
+            data_id, _, state_id = self.tree_ctrl.GetItemPyData(data_c)
             if id == data_id:
                 self.tree_ctrl.Delete(data_c)
                 del self.list_cb_data[state_id]
                 del self.list_cb_theory[data_id]
     def load_error(self, error=None):
         """
         Pop up an error message.
         :param error: details error message to be displayed
         """
         if error is not None or str(error).strip() != "":
             dial = wx.MessageDialog(self.parent, str(error),
+            dial = wx.MessageDialog(self.parent, str(error),
                                     'Error Loading File',
                                     wx.OK | wx.ICON_EXCLAMATION)
             dial.ShowModal()
+            dial.ShowModal()
     def _load_data(self, event):
         """
 …
         if self.parent is not None:
             wx.PostEvent(self.parent, NewLoadDataEvent())
     def on_remove(self, event):
         """
         Get a list of item checked and remove them from the treectrl
         Ask the parent to remove reference to this item
+        Ask the parent to remove reference to this item
         """
         msg = "This operation will delete the data sets checked "
 …
         if msg_box.ShowModal() != wx.ID_OK:
             return
         data_to_remove, theory_to_remove, _ = self.set_data_helper()
         data_key = []
 …
                     theory_list_ctrl = self.list_cb_theory[d_key]
                     theory_to_remove += theory_list_ctrl.keys()
         # Remove theory from treectrl
+        # Remove theory from treectrl
         for _, theory_dict in self.list_cb_theory.iteritems():
             for  key, value in theory_dict.iteritems():
 …
                         pass
                     theory_key.append(key)
         #Remove data and related theory references
         for key in data_key:
 …
                                 pass
                     del theory_dict[key]
         self.parent.remove_data(data_id=data_to_remove,
                                   theory_id=theory_to_remove)
 …
         self.enable_freeze()
         self.enable_remove_plot()
     def on_import(self, event=None):
         """
 …
         temp = data_id + state_id
         self.parent.set_data(data_id=temp, theory_id=theory_id)
     def on_append_plot(self, event=None):
         """
 …
         self._on_plot_selection()
         data_id, theory_id, state_id = self.set_data_helper()
         self.parent.plot_data(data_id=data_id,
+        self.parent.plot_data(data_id=data_id,
                               state_id=state_id,
                               theory_id=theory_id,
                               append=True)
     def on_plot(self, event=None):
         """
 …
         """
         data_id, theory_id, state_id = self.set_data_helper()
         self.parent.plot_data(data_id=data_id,
+        self.parent.plot_data(data_id=data_id,
                               state_id=state_id,
                               theory_id=theory_id,
                               append=False)
         self.enable_remove_plot()
     def on_close_page(self, event=None):
         """
 …
         # send parent to update menu with no show nor hide action
         self.parent.show_data_panel(action=False)
     def on_freeze(self, event):
         """
 …
             msg = "Freeze Theory: Requires at least one theory checked."
         wx.PostEvent(self.parent, StatusEvent(status=msg))
     def set_active_perspective(self, name):
         """
 …
         self.perspective_cbox.SetStringSelection(name)
         self.enable_import()
     def _on_delete_plot_panel(self, event):
         """
         get an event with attribute name and caption to delete existing name
+        get an event with attribute name and caption to delete existing name
         from the combobox of the current panel
         """
 …
         caption = event.caption
         if self.cb_plotpanel is not None:
             pos = self.cb_plotpanel.FindString(str(caption))
+            pos = self.cb_plotpanel.FindString(str(caption))
             if pos != wx.NOT_FOUND:
                 self.cb_plotpanel.Delete(pos)
         self.enable_append()
     def set_panel_on_focus(self, name=None):
         """
 …
         self.enable_append()
         self.enable_remove_plot()
     def set_plot_unfocus(self):
         """
 …
         """
         return
     def _on_perspective_selection(self, event=None):
         """
 …
             perspective.on_perspective(event=None)
             self.parent.check_multimode(perspective=perspective)
     def _on_plot_selection(self, event=None):
         """
 …
         if combo.GetValue() != 'None':
             panel = combo.GetClientData(selection)
             self.parent.on_set_plot_focus(panel)
+            self.parent.on_set_plot_focus(panel)
     def on_close_plot(self, event):
         """
         clseo the panel on focus
         """
+        """
         self.enable_append()
         selection = self.cb_plotpanel.GetSelection()
 …
             panel = self.cb_plotpanel.GetClientData(selection)
             if self.parent is not None and panel is not None:
                 wx.PostEvent(self.parent,
+                wx.PostEvent(self.parent,
                              NewPlotEvent(group_id=panel.group_id,
                                           action="delete"))
         self.enable_remove_plot()
     def set_frame(self, frame):
         """
         """
         self.frame = frame
     def get_frame(self):
         """
         """
+        return self.frame
+        return self.frame
+    def on_help(self, event):
+        """
+        Bring up the data manager Documentation whenever
+        the HELP button is clicked.
+        Calls DocumentationWindow with the path of the location within the
+        documentation tree (after /doc/ ....".  Note that when using old
+        versions of Wx (before 2.9) and thus not the release version of
+        installers, the help comes up at the top level of the file as
+        webbrowser does not pass anything past the # to the browser when it is
+        running "file:///...."
+    :param evt: Triggers on clicking the help button
+    """
+        #import documentation window here to avoid circular imports
+        #if put at top of file with rest of imports.
+        from documentation_window import DocumentationWindow
+        _TreeLocation = "user/sasgui/guiframe/data_explorer_help.html"
+        _doc_viewer = DocumentationWindow(self, -1, _TreeLocation, "",
+                                          "Data Explorer Help")
     def on_close(self, event):
         """
 …
         """
         self.parent.show_data_panel(event)
     def set_schedule_full_draw(self, panel=None, func='del'):
         """
 …
         """
         self.parent.set_schedule_full_draw(panel, func)
     def enable_remove_plot(self):
         """
 …
         #else:
         #    self.bt_close_plot.Enable()
     def enable_remove(self):
         """
 …
         else:
             self.bt_remove.Enable()
     def enable_import(self):
         """
 …
         else:
             self.perspective_cbox.Enable()
     def enable_plot(self):
         """
         enable or disable plot button
         """
         n_t = 0
+        n_t = 0
         n_t_t = 0
         if self.tree_ctrl != None:
 …
             self.bt_plot.Enable()
         self.enable_append()
     def enable_append(self):
         """
         enable or disable append button
         """
         n_t = 0
+        n_t = 0
         n_t_t = 0
         if self.tree_ctrl != None:
 …
         if self.tree_ctrl_theory != None:
             n_t_t = self.tree_ctrl_theory.GetCount()
         if n_t + n_t_t <= 0:
+        if n_t + n_t_t <= 0:
             self.bt_append_plot.Disable()
             self.cb_plotpanel.Disable()
 …
             self.bt_append_plot.Enable()
             self.cb_plotpanel.Enable()
     def check_theory_to_freeze(self):
         """
 …
         else:
             self.bt_freeze.Disable()
     def enable_selection(self):
         """
 …
         else:
             self.selection_cbox.Disable()
     def show_data_button(self):
         """
         show load data and remove data button if
+        show load data and remove data button if
         dataloader on else hide them
         """
 …
             gui_style = self.parent.get_style()
             style = gui_style & GUIFRAME.DATALOADER_ON
             if style == GUIFRAME.DATALOADER_ON:
+            if style == GUIFRAME.DATALOADER_ON:
                 #self.bt_remove.Show(True)
                 self.bt_add.Show(True)
+                self.bt_add.Show(True)
             else:
                 #self.bt_remove.Hide()
                 self.bt_add.Hide()
         except:
+        except:
             #self.bt_remove.Hide()
             self.bt_add.Hide()
+            self.bt_add.Hide()
 …
         self.list_of_ctrl = []
         if not data_list:
             return
+            return
         self._sizer_main = wx.BoxSizer(wx.VERTICAL)
         self._sizer_txt = wx.BoxSizer(wx.VERTICAL)
 …
         self._panel.SetupScrolling()
         self.__do_layout(data_list, text=text)
     def __do_layout(self, data_list, text=''):
         """
 …
         """
         if not data_list or len(data_list) <= 1:
             return
+            return
         #add text
         text = "Deleting these file reset some panels.\n"
         text += "Do you want to proceed?\n"
 …
                                 wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
         static_line = wx.StaticLine(self, -1)
         self._sizer_txt.Add(self._panel, 1, wx.EXPAND|wx.LEFT|wx.RIGHT, 5)
         self._sizer_main.Add(self._sizer_txt, 1, wx.EXPAND|wx.ALL, 10)
         #self._sizer_main.Add(self._data_text_ctrl, 0,
+        #self._sizer_main.Add(self._data_text_ctrl, 0,
         #                     wx.EXPAND|wx.LEFT|wx.RIGHT, 10)
         self._sizer_main.Add(static_line, 0, wx.EXPAND, 0)
 …
         self.SetSizer(self._sizer_main)
         self.Layout()
     def get_data(self):
         """
 …
                 temp.append(data)
         return temp
 class DataFrame(wx.Frame):
     """
 …
     #  tied to any perspective
     ALWAYS_ON = True
     def __init__(self, parent=None, owner=None, manager=None, size=(300, 800),
                          list_of_perspective=[], list=[], *args, **kwds):
 …
         self.owner = owner
         self._manager = manager
         self.panel = DataPanel(parent=self,
+        self.panel = DataPanel(parent=self,
                                manager=manager,
                                list_of_perspective=list_of_perspective)
     def load_data_list(self, list=[]):
         """
 …
         """
         self.panel.load_data_list(list=list)
 from sas.sasgui.guiframe.dataFitting import Theory1D
 from sas.sasgui.guiframe.data_state import DataState
 …
         self.msg += "name  value\n"
         return self.msg
 def set_data_state(data=None, path=None, theory=None, state=None):
     """
 …
     dstate.set_path(path=path)
     dstate.set_theory(theory, state)
     return dstate
 if __name__ == "__main__":
     app = wx.App()
     try:
 …
         #raise
         print "error", sys.exc_value
+    app.MainLoop()
+    app.MainLoop()

src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

-                      rfaa3ae7
+                      ra674d0b
             logging.error("Loader returned an invalid object:\n %s" % str(item))
             data_error = True
         data = self.parent.create_gui_data(item, p_file)
         output[data.id] = data
 …
         """
         """
+        message = ""
+        log_msg = ''
+        file_errors = {}
         output = {}
+        any_error = False
+        data_error = False
+        error_message = ""
+        exception_occurred = False
         for p_file in path:
-            info = "info"
             basename = os.path.basename(p_file)
             _, extension = os.path.splitext(basename)
             if extension.lower() in EXTENSIONS:
-                any_error = True
                 log_msg = "Data Loader cannot "
+                log_msg += "load: %s\n" % str(p_file)
+                log_msg += """Please try to open that file from "open project" """
+                log_msg += """or "open analysis" menu\n"""
+                error_message = log_msg + "\n"
+                log_msg += "load: {}\n".format(str(p_file))
+                log_msg += "Please try to open that file from \"open project\""
+                log_msg += "or \"open analysis\" menu."
                 logging.info(log_msg)
+                file_errors[basename] = [log_msg]
                 continue
             try:
                 message = "Loading Data... " + str(p_file) + "\n"
                 self.load_update(output=output, message=message, info=info)
+                message = "Loading {}...\n".format(p_file)
+                self.load_update(output=output, message=message, info="info")
                 temp = self.loader.load(p_file, format)
+                if temp.__class__.__name__ == "list":
+                    for item in temp:
+                        output, error_message, data_error = \
+                            self._process_data_and_errors(item,
+                                                          p_file,
+                                                          output,
+                                                          error_message)
+                else:
+                if not isinstance(temp, list):
+                    temp = [temp]
+                for item in temp:
+                    error_message = ""
                     output, error_message, data_error = \
+                            self._process_data_and_errors(temp,
+                                                          p_file,
+                                                          output,
+                                                          error_message)
+                        self._process_data_and_errors(item,
+                                                      p_file,
+                                                      output,
+                                                      error_message)
+                    if data_error:
+                        if basename in file_errors.keys():
+                            file_errors[basename] += [error_message]
+                        else:
+                            file_errors[basename] = [error_message]
+                        self.load_update(output=output,
+                            message=error_message, info="warning")
+                self.load_update(output=output,
+                message="Loaded {}\n".format(p_file),
+                info="info")
             except:
                 logging.error(sys.exc_value)
+                any_error = True
+            if any_error or error_message != "":
+                if error_message == "":
+                    error = "Error: " + str(sys.exc_info()[1]) + "\n"
+                    error += "while loading Data: \n%s\n" % str(basename)
+                    error_message += "The data file you selected could not be loaded.\n"
+                    error_message += "Make sure the content of your file"
+                    error_message += " is properly formatted.\n\n"
+                    error_message += "When contacting the SasView team, mention the"
+                    error_message += " following:\n%s" % str(error)
+                elif data_error:
+                    base_message = "Errors occurred while loading "
+                    base_message += "{0}\n".format(basename)
+                    base_message += "The data file loaded but with errors.\n"
+                    error_message = base_message + error_message
+                else:
+                    error_message += "%s\n" % str(p_file)
+                info = "error"
+        if any_error or error_message:
+            self.load_update(output=output, message=error_message, info=info)
+        else:
+            message = "Loading Data Complete! "
+        message += log_msg
+        self.load_complete(output=output, error_message=error_message,
+                           message=message, path=path, info='info')
+                error_message = "The Data file you selected could not be loaded.\n"
+                error_message += "Make sure the content of your file"
+                error_message += " is properly formatted.\n"
+                error_message += "When contacting the SasView team, mention the"
+                error_message += " following:\n"
+                error_message += "Error: " + str(sys.exc_info()[1])
+                file_errors[basename] = [error_message]
+                self.load_update(output=output, message=error_message, info="warning")
+        if len(file_errors) > 0:
+            error_message = ""
+            for filename, error_array in file_errors.iteritems():
+                error_message += "The following errors occured whilst "
+                error_message += "loading {}:\n".format(filename)
+                for message in error_array:
+                    error_message += message + "\n"
+                error_message += "\n"
+            self.load_update(output=output, message=error_message, info="error")
+        self.load_complete(output=output, message="Loading data complete!",
+            info="info")
     def load_update(self, output=None, message="", info="warning"):
 …
         #    self.load_error(error_message)
         self.parent.add_data(data_list=output)

src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter1D.py

-                      rd85c194
+                      r895c9cb
             self.subplot.set_xlim((xlo, xhi))
             self.subplot.set_ylim((ylo, yhi))
+        self.graph.selected_plottable = None
 …
         self._slicerpop.set_graph(self.graph)
         ids = iter(self._menu_ids)
+        if not self.graph.selected_plottable in self.plots:
             # Various plot options
             wx_id = ids.next()
             self._slicerpop.Append(wx_id, '&Save Image', 'Save image as PNG')
             wx.EVT_MENU(self, wx_id, self.onSaveImage)
             wx_id = ids.next()
             self._slicerpop.Append(wx_id, '&Print Image', 'Print image ')
             wx.EVT_MENU(self, wx_id, self.onPrint)
             wx_id = ids.next()
             self._slicerpop.Append(wx_id, '&Copy to Clipboard',
                                    'Copy to the clipboard')
             wx.EVT_MENU(self, wx_id, self.OnCopyFigureMenu)
             self._slicerpop.AppendSeparator()
+        # Various plot options
+        wx_id = ids.next()
+        self._slicerpop.Append(wx_id, '&Save Image', 'Save image as PNG')
+        wx.EVT_MENU(self, wx_id, self.onSaveImage)
+        wx_id = ids.next()
+        self._slicerpop.Append(wx_id, '&Print Image', 'Print image ')
+        wx.EVT_MENU(self, wx_id, self.onPrint)
+        wx_id = ids.next()
+        self._slicerpop.Append(wx_id, '&Copy to Clipboard',
+                               'Copy to the clipboard')
+        wx.EVT_MENU(self, wx_id, self.OnCopyFigureMenu)
+        self._slicerpop.AppendSeparator()
         for plot in self.plots.values():
 …
             item_list = self.parent.get_current_context_menu(self)
             if (not item_list == None) and (not len(item_list) == 0):
+                # Note: reusing menu ids in submenu.  This code works because
+                # IdItems is set up as a lazy iterator returning each id in
+                # sequence, creating new ids as needed so it never runs out.
+                # zip() is set up to stop when any iterator is empty, so it
+                # only asks for the number of ids in item_list.
+                for item, wx_id in zip(item_list, self._menu_ids):
+                for item, wx_id in zip(item_list, [ids.next() for i in range(len(item_list))]):
                     try:
 …
             if self.parent.ClassName.count('wxDialog') == 0:
+                wx_id = ids.next()
+                plot_menu.Append(wx_id, '&Linear Fit', name)
+                wx.EVT_MENU(self, wx_id, self.onFitting)
+                plot_menu.AppendSeparator()
+                if plot.id != 'fit':
+                    wx_id = ids.next()
+                    plot_menu.Append(wx_id, '&Linear Fit', name)
+                    wx.EVT_MENU(self, wx_id, self.onFitting)
+                    plot_menu.AppendSeparator()
                 wx_id = ids.next()
 …
             # Option to hide
             # TODO: implement functionality to hide a plottable (legend click)
+        if not self.graph.selected_plottable in self.plots:
+        self._slicerpop.AppendSeparator()
+        loc_menu = wx.Menu()
+        for label in self._loc_labels:
+            wx_id = ids.next()
+            loc_menu.Append(wx_id, str(label), str(label))
+            wx.EVT_MENU(self, wx_id, self.onChangeLegendLoc)
+        wx_id = ids.next()
+        self._slicerpop.Append(wx_id, '&Modify Graph Appearance',
+                               'Modify graph appearance')
+        wx.EVT_MENU(self, wx_id, self.modifyGraphAppearance)
+        self._slicerpop.AppendSeparator()
+        if self.position != None:
+            wx_id = ids.next()
+            self._slicerpop.Append(wx_id, '&Add Text')
+            wx.EVT_MENU(self, wx_id, self._on_addtext)
+            wx_id = ids.next()
+            self._slicerpop.Append(wx_id, '&Remove Text')
+            wx.EVT_MENU(self, wx_id, self._on_removetext)
             self._slicerpop.AppendSeparator()
+            loc_menu = wx.Menu()
+            for label in self._loc_labels:
+                wx_id = ids.next()
+                loc_menu.Append(wx_id, str(label), str(label))
+                wx.EVT_MENU(self, wx_id, self.onChangeLegendLoc)
+            wx_id = ids.next()
+            self._slicerpop.Append(wx_id, '&Modify Graph Appearance',
+                                   'Modify graph appearance')
+            wx.EVT_MENU(self, wx_id, self.modifyGraphAppearance)
+            self._slicerpop.AppendSeparator()
+            if self.position != None:
+                wx_id = ids.next()
+                self._slicerpop.Append(wx_id, '&Add Text')
+                wx.EVT_MENU(self, wx_id, self._on_addtext)
+                wx_id = ids.next()
+                self._slicerpop.Append(wx_id, '&Remove Text')
+                wx.EVT_MENU(self, wx_id, self._on_removetext)
+                self._slicerpop.AppendSeparator()
+            wx_id = ids.next()
+            self._slicerpop.Append(wx_id, '&Change Scale')
+            wx.EVT_MENU(self, wx_id, self._onProperties)
+        wx_id = ids.next()
+        self._slicerpop.Append(wx_id, '&Change Scale')
+        wx.EVT_MENU(self, wx_id, self._onProperties)
+        self._slicerpop.AppendSeparator()
+        wx_id = ids.next()
+        self._slicerpop.Append(wx_id, '&Set Graph Range')
+        wx.EVT_MENU(self, wx_id, self.onSetRange)
+        wx_id = ids.next()
+        self._slicerpop.Append(wx_id, '&Reset Graph Range')
+        wx.EVT_MENU(self, wx_id, self.onResetGraph)
+        if self.parent.ClassName.count('wxDialog') == 0:
             self._slicerpop.AppendSeparator()
             wx_id = ids.next()
+            self._slicerpop.Append(wx_id, '&Reset Graph Range')
+            wx.EVT_MENU(self, wx_id, self.onResetGraph)
+            if self.parent.ClassName.count('wxDialog') == 0:
+                self._slicerpop.AppendSeparator()
+                wx_id = ids.next()
+                self._slicerpop.Append(wx_id, '&Window Title')
+                wx.EVT_MENU(self, wx_id, self.onChangeCaption)
+            self._slicerpop.Append(wx_id, '&Window Title')
+            wx.EVT_MENU(self, wx_id, self.onChangeCaption)
         try:
             pos_evt = event.GetPosition()
 …
             pos = (pos_x, pos_y + 5)
         self.PopupMenu(self._slicerpop, pos)
+    def onSetRange(self, event):
+        # Display dialog
+        # self.subplot.set_xlim((low, high))
+        # self.subplot.set_ylim((low, high))
+        from sas.sasgui.plottools.RangeDialog import RangeDialog
+        d = RangeDialog(self, -1)
+        xlim = self.subplot.get_xlim()
+        ylim = self.subplot.get_ylim()
+        d.SetXRange(xlim)
+        d.SetYRange(ylim)
+        if d.ShowModal() == wx.ID_OK:
+            x_range = d.GetXRange()
+            y_range = d.GetYRange()
+            if x_range is not None and y_range is not None:
+                self.subplot.set_xlim(x_range)
+                self.subplot.set_ylim(y_range)
+                self.subplot.figure.canvas.draw_idle()
+        d.Destroy()
     def onFreeze(self, event):
 …
                                                              int(curr_symbol))), curr_label)
         self.appD.Bind(wx.EVT_CLOSE, self.on_AppDialog_close)
+        self.graph.selected_plottable = None
     def on_AppDialog_close(self, event):

src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter2D.py

-                      rd85c194
+                      r1a696bf
         wx_id = ids.next()
         slicerpop.Append(wx_id, '&Save Image')
+        slicerpop.Append(wx_id, '&Save Image', 'Save image as png')
         wx.EVT_MENU(self, wx_id, self.onSaveImage)
 …
             if (not item_list == None) and (not len(item_list) == 0) and\
                 self.data2D.name.split(" ")[0] != 'Residuals':
+                # The line above; Not for trunk
+                # Note: reusing menu ids for the sub-menus.  See Plotter1D.
+                for item, wx_id in zip(item_list, self._menu_ids):
+                for item, wx_id in zip(item_list, [ids.next() for i in range(len(item_list))]):
                     try:
                         slicerpop.Append(wx_id, item[0], item[1])

src/sas/sasgui/guiframe/local_perspectives/plotting/SimplePlot.py

-                      rd85c194
+                      r25b9707a
     """
     def __init__(self, parent, id, title, scale='log_{10}',
                  size=wx.Size(550, 470)):
+                 size=wx.Size(550, 470), show_menu_icons=True):
         """
         comment
 …
         self._default_save_location = None
         self.scale = scale
+        self._show_menu_icons = show_menu_icons
         self.plotpanel = SimplePlotPanel(self, -1)
         self._build_menubar()
 …
         quit_bmp = wx.ArtProvider.GetBitmap(wx.ART_QUIT, wx.ART_TOOLBAR, tsize)
         print_bmp = wx.ArtProvider.GetBitmap(wx.ART_PRINT, wx.ART_TOOLBAR, tsize)
-        preview_bmp = wx.ArtProvider.GetBitmap(wx.ART_REPORT_VIEW, wx.ART_TOOLBAR, tsize)
         copy_bmp = wx.ArtProvider.GetBitmap(wx.ART_COPY, wx.ART_TOOLBAR, tsize)
         menu_bar = wx.MenuBar()
 …
         menu = wx.Menu()
         id = wx.NewId()
+        item = wx.MenuItem(menu, id, "&Save Image")
+        item.SetBitmap(save_bmp)
+        menu.AppendItem(item)
+        save_item = wx.MenuItem(menu, id, "&Save Image")
+        menu.AppendItem(save_item)
         wx.EVT_MENU(self, id, self.on_save_file)
         id = wx.NewId()
+        item = wx.MenuItem(menu, id, "&Print Image")
+        item.SetBitmap(print_bmp)
+        menu.AppendItem(item)
+        print_item = wx.MenuItem(menu, id, "&Print Image")
+        menu.AppendItem(print_item)
         wx.EVT_MENU(self, id, self.on_print_image)
         menu.AppendSeparator()
         id = wx.NewId()
+        item = wx.MenuItem(menu, id, "&Quit")
+        item.SetBitmap(quit_bmp)
+        menu.AppendItem(item)
+        quit_item = wx.MenuItem(menu, id, "&Quit")
+        menu.AppendItem(quit_item)
         menu_bar.Append(menu, "&File")
 …
         menu_edit = wx.Menu()
         id = wx.NewId()
+        item = wx.MenuItem(menu_edit, id, "&Copy")
+        item.SetBitmap(copy_bmp)
+        menu_edit.AppendItem(item)
+        copy_item = wx.MenuItem(menu_edit, id, "&Copy")
+        menu_edit.AppendItem(copy_item)
         wx.EVT_MENU(self, id, self.on_copy_image)
+        if self._show_menu_icons:
+            save_item.SetBitmap(save_bmp)
+            print_item.SetBitmap(print_bmp)
+            quit_item.SetBitmap(quit_bmp)
+            copy_item.SetBitmap(copy_bmp)
         menu_bar.Append(menu_edit, "&Edit")
 …
         except:
             self.Destroy()

src/sas/sasgui/guiframe/local_perspectives/plotting/detector_dialog.py

rd85c194	r8416a02
7	7	from sas.sasgui.guiframe.events import StatusEvent
8	8	from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as Canvas
9		~~from matplotlib import~~ mpl
	9	import matplotlib as mpl
10	10	from matplotlib import pylab
11	11	# FONT size

src/sas/sasgui/guiframe/media/data_explorer_help.rst

-                      rd85c194
+                      rb64b87c
 *NOTE! When* Data Explorer *is hidden, all data loaded will be sent directly
 to the current active analysis perspective, if possible. When* Data Explorer *is
+to the current active analysis, if possible. When* Data Explorer *is
 shown, data go first to the* Data Explorer.
 …
 Click on the *Send To* button to send the currently selected data to one of the
 perspectives (for *Fitting*, *P(r) Inversion*, or *Invariant* calculation).
+available types of analysis (*Fitting*, *P(r) Inversion*, or *Invariant* calculation).
 The *Single*/*Batch* mode radio buttons only apply to the *Fitting* perspective.
+The *Single*/*Batch* mode radio buttons only apply to *Fitting*.
 *Batch mode* provides serial (batch) fitting with one model function, that is,

src/sas/sasgui/guiframe/media/graph_help.rst

-                      rf93b473f
+                      re68c9bf
 ^^^^^^^^^^^^^^^^^^^^^^^
 To invoke the *Graph Menu* simply right-click on a data/theory plot, or click
 the *Graph Menu* (bullet list) icon in the toolbar at the bottom of the plot.
+To invoke the *Graph Menu* simply right-click on a data/theory plot, or click
+the *Graph Menu* (bullet list) icon in the toolbar at the bottom of the plot.
 Then select a menu item.
 …
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 To expand a plot window, click the *Maximise* (square) icon in the top-right
+To expand a plot window, click the *Maximise* (square) icon in the top-right
 corner.
 To shrink a plot window, click the *Restore down* (square-on-square) icon in
+To shrink a plot window, click the *Restore down* (square-on-square) icon in
 the top-right corner.
 To hide a plot, click the *Minimise* (-) icon in the top-right corner of the
+To hide a plot, click the *Minimise* (-) icon in the top-right corner of the
 plot window.
 To show a hidden plot, select the *Restore up* (square-on-square) icon on the
+To show a hidden plot, select the *Restore up* (square-on-square) icon on the
 minimised window.
 To delete a plot, click the *Close* (x) icon in the top-right corner of the
+To delete a plot, click the *Close* (x) icon in the top-right corner of the
 plot window.
 *NOTE! If a residuals graph (when fitting data) is hidden, it will not show up
+*NOTE! If a residuals graph (when fitting data) is hidden, it will not show up
 after computation.*
 …
 ^^^^^^^^^^^^^^^
 Select the *Pan* (crossed arrows) icon in the toolbar at the bottom of the plot
 to activate this option. Move the mouse pointer to the plot. It will change to
 a hand. Then left-click and drag the plot around. The axis values will adjust
+Select the *Pan* (crossed arrows) icon in the toolbar at the bottom of the plot
+to activate this option. Move the mouse pointer to the plot. It will change to
+a hand. Then left-click and drag the plot around. The axis values will adjust
 accordingly.
 To disable dragging mode, unselect the *crossed arrows* icon on the toolbar.
 …
 ^^^^^^^^^^^^^^^^^^^^^^^^
 Select the *Zoom* (magnifying glass) button in the toolbar at the bottom of
 the plot to activate this option. Move the mouse pointer to the plot. It will
 change to a cross-hair. Then left-click and drag the pointer around to generate
+Select the *Zoom* (magnifying glass) button in the toolbar at the bottom of
+the plot to activate this option. Move the mouse pointer to the plot. It will
+change to a cross-hair. Then left-click and drag the pointer around to generate
 a region of interest. Release the mouse button to generate the new view.
 To disable zoom mode, unselect the *Zoom* button on the toolbar.
 After zooming in on a a region, the *left arrow* or *right arrow* buttons on
+After zooming in on a a region, the *left arrow* or *right arrow* buttons on
 the toolbar will switch between recent views.
 *NOTE! If a wheel mouse is available scrolling the wheel will zoom in/out
 on the current plot (changing both axes). Alternatively, point at the numbers
+*NOTE! If a wheel mouse is available scrolling the wheel will zoom in/out
+on the current plot (changing both axes). Alternatively, point at the numbers
 on one axis and scroll the wheel to zoom in/out on just that axis.*
 To return to the original view of the data, click the the *Reset* (home) icon
+To return to the original view of the data, click the the *Reset* (home) icon
 in the toolbar at the bottom of the plot (see Resetting_the_graph_ for further details).
 …
 ^^^^^^^^^^^^^^^^^^^
 To save the current plot as an image file, right click on the plot to bring up
+To save the current plot as an image file, right click on the plot to bring up
 the *Graph Menu* (see Invoking_the_graph_menu_) and select *Save Image*.
 Alternatively, click on the *Save* (floppy disk) icon in the toolbar at the
+Alternatively, click on the *Save* (floppy disk) icon in the toolbar at the
 bottom of the plot.
 A dialog window will open. Select a folder, enter a filename, choose an output
+A dialog window will open. Select a folder, enter a filename, choose an output
 image type, and click *Save*.
 …
 *  PNG (portable network graphics)
 *  PS (postscript)
 *  RAW/RGBA (bitmap)
+*  RAW/RGBA (bitmap, stored as 935x635 pixels of depth 8)
 *  SVG/SVGA (scalable vector graphics)
 *  TIF/TIFF (tagged iamge file)
 …
 ^^^^^^^^^^^^^^^
 To send the current plot to a printer, click on the *Print* (printer) icon in
+To send the current plot to a printer, click on the *Print* (printer) icon in
 the toolbar at the bottom of the plot.
 …
 ^^^^^^^^^^^^^^^^^^^
 To reset the axis range of a graph to its initial values select *Reset Graph
+To reset the axis range of a graph to its initial values select *Reset Graph
 Range* on the *Graph Menu* (see Invoking_the_graph_menu_). Alternatively, use
 the *Reset* (home) icon in the toolbar at the bottom of the plot.
 …
 From the *Graph Menu* (see Invoking_the_graph_menu_) select *Change Scale*. A
 dialog window will appear in which it is possible to choose different
+dialog window will appear in which it is possible to choose different
 transformations of the x (usually Q) or y (usually I(Q)) axes, including:
 …
 *  y, 1/y, ln(y), y^2, y.(x^4), 1/sqrt(y),
 *  log10(y), ln(y.x), ln(y.x^2), ln(y.x^4), log10(y.x^4)
 A *View* option includes short-cuts to common SAS transformations, such as:
 …
 *  Kratky
 For properly corrected and scaled data, these SAS transformations can be used
 to estimate, for example, Rg, rod diameter, or SANS incoherent background
+For properly corrected and scaled data, these SAS transformations can be used
+to estimate, for example, Rg, rod diameter, or SANS incoherent background
 levels, via a linear fit (see Making_a_linear_fit_).
 …
 From the *Graph Menu* (see Invoking_the_graph_menu_) select *Toggle Linear/Log
 Scale* to switch between a linear to log intensity scale. The type of scale
+Scale* to switch between a linear to log intensity scale. The type of scale
 selected is written alongside the colour scale.
 …
 From the *Graph Menu* (see Invoking_the_graph_menu_) select *2D Color Map* to
 choose a different color scale for the image and/or change the maximum or
+choose a different color scale for the image and/or change the maximum or
 minimum limits of the scale.
 …
 ^^^^^^^^^^^^^^^^^^^^^^^^
 Clicking anywhere in the plot window will cause the current coordinates to be
+Clicking anywhere in the plot window will cause the current coordinates to be
 displayed in the status bar at the very bottom-left of the SasView window.
 .. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
 …
 In the *Dataset Menu* (see Invoking_the_dataset_menu_), highlight a data set
 and select *DataInfo* to bring up a data information dialog panel for that
+and select *DataInfo* to bring up a data information dialog panel for that
 data set.
 …
 In the *Dataset Menu* (see Invoking_the_dataset_menu_), select *Save Points as
 a File* (if 1D data) or *Save as a file(DAT)* (if 2D data). A save dialog will
+a File* (if 1D data) or *Save as a file(DAT)* (if 2D data). A save dialog will
 appear.
 D data can be saved in either ASCII text (.TXT) or CanSAS/SASXML (.XML)
+D data can be saved in either ASCII text (.TXT) or CanSAS/SASXML (.XML)
 formats (see :ref:`Formats`).
 …
 In the *Dataset Menu* (see Invoking_the_dataset_menu_), select *Linear Fit*. A
 fitting dialog will appear. Set some initial parameters and data limits and
 click *Fit*. The fitted parameter values are displayed and the resulting line
 calculated from them is added to the plot.
+fitting dialog will appear. Set some initial parameters and data limits and
+click *Fit*. The fitted parameter values are displayed and the resulting line
+calculated from them is added to the plot.
 This option is most useful for performing simple Guinier, XS Guinier, and
 Porod type analyses, for example, to estimate Rg, a rod diameter, or incoherent
+Porod type analyses, for example, to estimate Rg, a rod diameter, or incoherent
 background level, respectively.
 …
 In the *Dataset Menu* (see Invoking_the_dataset_menu_), select *Show Error Bar*
 or *Hide Error Bar* to switch between showing/hiding the errors associated
 with the chosen dataset.
+or *Hide Error Bar* to switch between showing/hiding the errors associated
+with the chosen dataset.
 Modify plot properties
 …
 In the *Dataset Menu* (see Invoking_the_dataset_menu_), select *Modify Plot
 Property* to change the size, color, or shape of the displayed marker for the
+Property* to change the size, color, or shape of the displayed marker for the
 chosen dataset, or to change the dataset label that appears on the plot.
 …
 This feature is only available with 2D data.
 D data averaging allows you to perform different types of averages on your
 data. The region to be averaged is displayed in the plot window and its limits
+D data averaging allows you to perform different types of averages on your
+data. The region to be averaged is displayed in the plot window and its limits
 can be modified by dragging the boundaries around.
 …
 *  Box averaging on Qy
 A 'slicer' will appear (except for *Perform Circular Average*) in the plot that
 you can drag by clicking on a slicer's handle. When the handle is highlighted
+A 'slicer' will appear (except for *Perform Circular Average*) in the plot that
+you can drag by clicking on a slicer's handle. When the handle is highlighted
 in red, it means that the slicer can move/change size.
 *NOTE! The slicer size will reset if you try to select a region greater than
+*NOTE! The slicer size will reset if you try to select a region greater than
 the size of the data.*
 Alternatively, once a 'slicer' is active you can also select the region to
 average by bringing back the *Dataset Menu* and selecting *Edit Slicer
 Parameters*. A dialog window will appear in which you can enter values to
+Alternatively, once a 'slicer' is active you can also select the region to
+average by bringing back the *Dataset Menu* and selecting *Edit Slicer
+Parameters*. A dialog window will appear in which you can enter values to
 define a region or select the number of points to plot (*nbins*).
 A separate plot window will also have appeared, displaying the requested
+A separate plot window will also have appeared, displaying the requested
 average.
 *NOTE! The displayed average only updates when input focus is moved back to
+*NOTE! The displayed average only updates when input focus is moved back to
 that window; ie, when the mouse pointer is moved onto that plot.*
 Selecting *Box Sum* automatically brings up the 'Slicer Parameters' dialog in
+Selecting *Box Sum* automatically brings up the 'Slicer Parameters' dialog in
 order to display the average numerically, rather than graphically.
 …
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 This operation will perform an average in constant Q-rings around the (x,y)
+This operation will perform an average in constant Q-rings around the (x,y)
 pixel location of the beam center.
 …
 ^^^^^^^^^^^^^^^^^^^^^^^
 This operation is the same as 'Unmasked Circular Average' except that any
+This operation is the same as 'Unmasked Circular Average' except that any
 masked region is excluded.
 …
 This operation averages in constant Q-arcs.
 The width of the sector is specified in degrees (+/- |delta|\|phi|\) each side
+The width of the sector is specified in degrees (+/- |delta|\|phi|\) each side
 of the central angle (|phi|\).
 …
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 This operation performs an average between two Q-values centered on (0,0),
+This operation performs an average between two Q-values centered on (0,0),
 and averaged over a specified number of pixels.
 The data is returned as a function of angle (|phi|\) in degrees with zero
+The data is returned as a function of angle (|phi|\) in degrees with zero
 degrees at the 3 O'clock position.
 …
 This operation performs a sum of counts in a 2D region of interest.
 When editing the slicer parameters, the user can enter the length and the width
+When editing the slicer parameters, the user can enter the length and the width
 the rectangular slicer and the coordinates of the center of the rectangle.
 …
 This operation computes an average I(Qx) for the region of interest.
 When editing the slicer parameters, the user can control the length and the
 width the rectangular slicer. The averaged output is calculated from constant
 bins with rectangular shape. The resultant Q values are nominal values, that
+When editing the slicer parameters, the user can control the length and the
+width the rectangular slicer. The averaged output is calculated from constant
+bins with rectangular shape. The resultant Q values are nominal values, that
 is, the central value of each bin on the x-axis.
 …
 This operation computes an average I(Qy) for the region of interest.
 When editing the slicer parameters, the user can control the length and the
 width the rectangular slicer. The averaged output is calculated from constant
 bins with rectangular shape. The resultant Q values are nominal values, that
+When editing the slicer parameters, the user can control the length and the
+width the rectangular slicer. The averaged output is calculated from constant
+bins with rectangular shape. The resultant Q values are nominal values, that
 is, the central value of each bin on the x-axis.

src/sas/sasgui/guiframe/report_dialog.py

-                      rd85c194
+                      r6dd6e32
     FONT_VARIANT = 0
     ISPDF = True
+elif sys.platform == "darwin":
+# For OSX and everything else
+else:
     _STATICBOX_WIDTH = 480
     PANEL_WIDTH = 530

src/sas/sasgui/perspectives/calculator/data_operator.py

-                      re871a2d
+                      r0e760e9
 from sas.sasgui.guiframe.documentation_window import DocumentationWindow
 #Control panel width
+#Control panel width
 if sys.platform.count("win32") > 0:
     PANEL_TOP = 0
 …
         wx.EVT_TEXT_ENTER(self.data_namectr, -1, self.on_name)
         wx.EVT_TEXT_ENTER(self.numberctr, -1, self.on_number)
+        wx.EVT_TEXT(self.numberctr, -1, self.on_number)
         wx.EVT_COMBOBOX(self.data1_cbox, -1, self.on_select_data1)
         wx.EVT_COMBOBOX(self.operator_cbox, -1, self.on_select_operator)
 …
         self.name_sizer.Layout()
     def on_number(self, event=None):
+    def on_number(self, event=None, control=None):
         """
         On selecting Number for Data2
         """
         self.send_warnings('')
+        item = event.GetEventObject()
+        item = control
+        if item is None and event is not None:
+            item = event.GetEventObject()
+        elif item is None:
+            raise ValueError("Event or control must be supplied")
         text = item.GetValue().strip()
         if self.numberctr.IsShown():
 …
                 except:
                     self._set_textctrl_color(self.numberctr, 'pink')
+                    msg = "DataOperation: Number requires a float number."
+                    self.send_warnings(msg, 'error')
+                    return
+                    if event is None:
+                        msg = "DataOperation: Number requires a float number."
+                        self.send_warnings(msg, 'error')
+                    return False
             else:
                 self._set_textctrl_color(self.numberctr, self.color)
 …
         self.draw_output(self.output)
         self.Refresh()
+        return True
     def on_select_data1(self, event=None):
 …
             wx.MessageBox(msg, 'Error')
             return
+        if self.numberctr.IsEnabled() and self.numberctr.IsShown():
+            valid_num = self.on_number(control=self.numberctr)
+            if not valid_num:
+                return
         # send data to data manager
         self.output.name = name
 …
         #add plot
         self.graph.add(plot)
         #draw
+        #draw
         self.graph.render(self)
 …
     window = DataOperatorWindow(parent=None, data=[], title="Data Editor")
     app.MainLoop()

src/sas/sasgui/perspectives/calculator/image_viewer.py

-                      rd0248bd
+                      r25b9707a
                     parent.put_icon(plot_frame)
             except:
-                print "parent", parent
                 err_msg += "Failed to load '%s'.\n" % basename
         if err_msg:
 …
         """
         # Initialize the Frame object
+        PlotFrame.__init__(self, parent, id, title, scale, size)
+        PlotFrame.__init__(self, parent, id, title, scale, size,
+            show_menu_icons=False)
         self.parent = parent
         self.data = image
 …
     ImageView(None).load()
     app.MainLoop()

src/sas/sasgui/perspectives/calculator/model_editor.py

-                      rbb841ef
+                      r9501661
                     else:
                         out_f.write(line + "\n")
                 elif line.count("P1 = make_class"):
+                elif line.count("P1 = find_model"):
                     out_f.write(line % (name1) + "\n")
                 elif line.count("P2 = make_class"):
+                elif line.count("P2 = find_model"):
                     out_f.write(line % (name2) + "\n")
 …
         Do the layout for parameter related widgets
         """
+        param_txt = wx.StaticText(self, -1, 'Fit Parameters (if any): ')
+        param_tip = "#Set the parameters and initial values.\n"
+        param_txt = wx.StaticText(self, -1, 'Fit Parameters NOT requiring' + \
+                                  ' polydispersity (if any): ')
+        param_tip = "#Set the parameters NOT requiring polydispersity " + \
+        "and their initial values.\n"
         param_tip += "#Example:\n"
         param_tip += "A = 1\nB = 1"
 …
         # Parameters with polydispersity
+        pd_param_txt = wx.StaticText(self, -1, 'Fit Parameters requiring polydispersity (if any): ')
+        pd_param_tip = "#Set the parameters and initial values.\n"
+        pd_param_txt = wx.StaticText(self, -1, 'Fit Parameters requiring ' + \
+                                     'polydispersity (if any): ')
+        pd_param_tip = "#Set the parameters requiring polydispersity and " + \
+        "their initial values.\n"
         pd_param_tip += "#Example:\n"
         pd_param_tip += "C = 2\nD = 2"
 …
         self.bt_close.SetToolTipString("Close this panel.")
+        self.button_sizer.AddMany([(self.bt_apply, 0,
+                                    wx.LEFT, EDITOR_WIDTH * 0.8),
+                                   (self.bt_help, 0,
+                                    wx.LEFT,15),
+                                   (self.bt_close, 0,
+                                    wx.LEFT | wx.BOTTOM, 15)])
+        self.button_sizer.AddMany([(self.bt_apply, 0,0),
+                                   (self.bt_help, 0, wx.LEFT | wx.BOTTOM,15),
+                                   (self.bt_close, 0, wx.LEFT | wx.RIGHT, 15)])
     def _do_layout(self):
 …
                                   wx.ALL | wx.EXPAND, 5),
                                  (self.msg_sizer, 0, wx.EXPAND | wx.ALL, 5),
                                  (self.button_sizer, 0, wx.EXPAND | wx.ALL, 5)])
+                                 (self.button_sizer, 0, wx.ALIGN_RIGHT)])
         self.SetSizer(self.main_sizer)
         self.SetAutoLayout(True)
 …
 ##import scipy?
 #class Model(Model1DPlugin):
 #    name = ""
+#    name = basename without extension of __file__
 #    def __init__(self):
 #        Model1DPlugin.__init__(self, name=self.name)
 #        #set name same as file name
-#        self.name = self.get_fname()
 #        #self.params here
 #        self.description = "%s"
 …
 """
 TEST_TEMPLATE = """
-    def get_fname(self):
-        path = sys._getframe().f_code.co_filename
-        basename  = os.path.basename(path)
-        name, _ = os.path.splitext(basename)
-        return name
 ######################################################################
 ## THIS IS FOR TEST. DO NOT MODIFY THE FOLLOWING LINES!!!!!!!!!!!!!!!!
 …
 import sys
 import copy
+import collections
 import numpy
 from sas.sascalc.fit.pluginmodel import Model1DPlugin
+from sasmodels.sasview_model import make_class
+from sasmodels.core import load_model_info
+# User can change the name of the model (only with single functional model)
+#P1_model:
+#from %s import Model as P1
+#P2_model:
+#from %s import Model as P2
+from sasmodels.sasview_model import find_model
 class Model(Model1DPlugin):
+    name = ""
+    def __init__(self):
+    name = os.path.splitext(os.path.basename(__file__))[0]
+    is_multiplicity_model = False
+    def __init__(self, multiplicity=1):
         Model1DPlugin.__init__(self, name='')
         P1 = make_class('%s')
         P2 = make_class('%s')
+        P1 = find_model('%s')
+        P2 = find_model('%s')
         p_model1 = P1()
         p_model2 = P2()
         ## Setting  model name model description
         self.description = '%s'
-        self.name = self.get_fname()
         if self.name.rstrip().lstrip() == '':
             self.name = self._get_name(p_model1.name, p_model2.name)
 …
         ## Define parameters
         self.params = {}
+        self.params = collections.OrderedDict()
         ## Parameter details [units, min, max]
 …
         #list of parameter that can be fitted
         self._set_fixed_params()
         ## parameters with orientation
+        self.orientation_params = []
         for item in self.p_model1.orientation_params:
             new_item = "p1_" + item
 …
                 self.orientation_params.append(new_item)
         ## magnetic params
+        self.magnetic_params = []
         for item in self.p_model1.magnetic_params:
             new_item = "p1_" + item
 …
     def _set_dispersion(self):
+        self.dispersion = collections.OrderedDict()
         ##set dispersion only from p_model
         for name , value in self.p_model1.dispersion.iteritems():
 …
     def _set_fixed_params(self):
+        self.fixed = []
         for item in self.p_model1.fixed:
             new_item = "p1" + item
 …
         self.description += description
-    def get_fname(self):
-        path = sys._getframe().f_code.co_filename
-        basename  = os.path.basename(path)
-        name, _ = os.path.splitext(basename)
-        return name
 if __name__ == "__main__":
     m1= Model()

src/sas/sasgui/perspectives/calculator/pyconsole.py

-                      r26d6e045
+                      r7673ecd
     """
     # try running the model
     from sasmodels.core import load_model, call_kernel
     model = load_model(path)
+    from sasmodels.sasview_model import load_custom_model
+    Model = load_custom_model(path)
+    model = Model()
     q =  np.array([0.01, 0.1])
+    kernel = model.make_kernel([q])
+    Iq = call_kernel(kernel, {})
+    Iq = model.evalDistribution(q)
     qx, qy =  np.array([0.01, 0.01]), np.array([0.1, 0.1])
+    kernel = model.make_kernel([qx, qy])
+    Iqxy = call_kernel(kernel, {})
+    Iqxy = model.evalDistribution([qx, qy])
     result = """
 …
     except Exception:
         import traceback
         result, errmsg = None, traceback.format_exc(limit=2)
+        result, errmsg = None, traceback.format_exc()
     parts = ["Running model '%s'..." % os.path.basename(fname)]

src/sas/sasgui/perspectives/fitting/basepage.py

-                      rcb4ef58
+                      ree4b3cb
 import json
 import logging
+import traceback
 from collections import defaultdict
 from wx.lib.scrolledpanel import ScrolledPanel
+import sasmodels.sasview_model
 from sas.sasgui.guiframe.panel_base import PanelBase
 from sas.sasgui.guiframe.utils import format_number, check_float, IdList
 …
         self.state_change = False
         ## save customized array
         self.values = []
         self.weights = []
+        self.values = {}   # type: Dict[str, List[float, ...]]
+        self.weights = {}   # type: Dict[str, List[float, ...]]
         ## retrieve saved state
         self.number_saved_state = 0
 …
                     angles.append(angle)
                     weights.append(weight)
                 except:
+                except Exception:
                     # Skip non-data lines
                     logging.error(sys.exc_info()[1])
+                    logging.error(traceback.format_exc())
             return numpy.array(angles), numpy.array(weights)
         except:
 …
                 self.model._persistency_dict[key] = \
                                  [state.values, state.weights]
             except:
                 logging.error(sys.exc_info()[1])
+            except Exception:
+                logging.error(traceback.format_exc())
             selection = self._find_polyfunc_selection(disp_model)
             for list in self.fittable_param:
 …
                             list[5].Disable()
                             list[6].Disable()
                         except:
                             logging.error(sys.exc_info()[1])
+                        except Exception:
+                            logging.error(traceback.format_exc())
             # For array, disable all fixed params
             if selection == 1:
 …
                         try:
                             item[2].Disable()
                         except:
                             logging.error(sys.exc_info()[1])
+                        except Exception:
+                            logging.error(traceback.format_exc())
         # Make sure the check box updated when all checked
 …
             is_2Ddata = True
         if self.model != None:
+            try:
+                is_modified = self._check_value_enter(self.fittable_param,
+                                                      is_modified)
+                is_modified = self._check_value_enter(self.fixed_param,
+                                                      is_modified)
+                is_modified = self._check_value_enter(self.parameters,
+                                                      is_modified)
+            except:
+                logging.error(sys.exc_info()[1])
+            is_modified = (self._check_value_enter(self.fittable_param)
+                           or self._check_value_enter(self.fixed_param)
+                           or self._check_value_enter(self.parameters))
             # Here we should check whether the boundaries have been modified.
 …
         flag = True
         self.fitrange = True
-        is_modified = False
         #wx.PostEvent(self._manager.parent, StatusEvent(status=" \
 …
                                                                 [self.data])
             ##Check the values
             self._check_value_enter(self.fittable_param, is_modified)
             self._check_value_enter(self.fixed_param, is_modified)
             self._check_value_enter(self.parameters, is_modified)
+            self._check_value_enter(self.fittable_param)
+            self._check_value_enter(self.fixed_param)
+            self._check_value_enter(self.parameters)
             # If qmin and qmax have been modified, update qmin and qmax and
 …
         try:
             self.save_current_state()
         except:
             logging.error(sys.exc_info()[1])
+        except Exception:
+            logging.error(traceback.format_exc())
         return flag
-    def _is_modified(self, is_modified):
-        """
-        return to self._is_modified
-        """
-        return is_modified
     def _reset_parameters_state(self, listtorestore, statelist):
 …
             if mod_cat == custom_model:
                 for model in self.model_list_box[mod_cat]:
+                    if 'sasmodels.sasview_model.' in str(model):
+                        str_m = model.id
+                    else:
+                        str_m = str(model).split(".")[0]
+                    #self.model_box.Append(str_m)
+                    str_m = model.id if hasattr(model, 'id') else model.name
                     m_list.append(self.model_dict[str_m])
             else:
 …
                     #    wx.PostEvent(self.parent.parent,
                     #                 StatusEvent(status=msg, info="error"))
         except:
             msg = "%s\n" % (sys.exc_info()[1])
+        except Exception:
+            msg = traceback.format_exc()
             wx.PostEvent(self._manager.parent,
                          StatusEvent(status=msg, info="error"))
 …
         wx.PostEvent(self.parent, StatusEvent(status=msg))
         # Flag to register when a parameter has changed.
-        #is_modified = False
         if tcrtl.GetValue().lstrip().rstrip() != "":
             try:
 …
                     if temp_npts != self.num_points:
                         self.num_points = temp_npts
-                        #is_modified = True
                 else:
                     msg = "Cannot plot: No points in Q range!!!  "
 …
                 self.temp_multi_functional = True
         elif form_factor != None:
+            self.model = form_factor(self.multi_factor)
+            if self.multi_factor is not None:
+                self.model = form_factor(self.multi_factor)
+            else:
+                # old style plugin models do not accept a multiplicity argument
+                self.model = form_factor()
         else:
             self.model = None
 …
         self.on_set_focus(None)
         self.Layout()
     def _validate_qrange(self, qmin_ctrl, qmax_ctrl):
 …
         return flag
     def _check_value_enter(self, list, modified):
+    def _check_value_enter(self, list):
         """
         :param list: model parameter and panel info
 …
                 parameter's maximum value ,
                 parameter's units]
+        """
         is_modified = modified
         if len(list) == 0:
             return is_modified
+        Returns True if the model parameters have changed.
+        """
+        is_modified = False
         for item in list:
             #skip angle parameters for 1D
+            if not self.enable2D:
+                if item in self.orientation_params:
+                    continue
+            #try:
+            if not self.enable2D and item in self.orientation_params:
+                continue
             name = str(item[1])
+            if string.find(name, ".npts") == -1 and \
+                                        string.find(name, ".nsigmas") == -1:
+                ## check model parameters range
+                param_min = None
+                param_max = None
+                ## check minimun value
+                if item[5] != None and item[5] != "":
+                    if item[5].GetValue().lstrip().rstrip() != "":
+                        try:
+                            param_min = float(item[5].GetValue())
+                            if not self._validate_qrange(item[5], item[2]):
+                                if numpy.isfinite(param_min):
+                                    item[2].SetValue(format_number(param_min))
+                            item[5].SetBackgroundColour(wx.WHITE)
+                            item[2].SetBackgroundColour(wx.WHITE)
+                        except:
+                            msg = "Wrong fit parameter range entered"
+                            wx.PostEvent(self._manager.parent,
+                                         StatusEvent(status=msg))
+                            raise ValueError, msg
+                        is_modified = True
+                ## check maximum value
+                if item[6] != None and item[6] != "":
+                    if item[6].GetValue().lstrip().rstrip() != "":
+                        try:
+                            param_max = float(item[6].GetValue())
+                            if not self._validate_qrange(item[2], item[6]):
+                                if numpy.isfinite(param_max):
+                                    item[2].SetValue(format_number(param_max))
+                            item[6].SetBackgroundColour(wx.WHITE)
+                            item[2].SetBackgroundColour(wx.WHITE)
+                        except:
+                            msg = "Wrong Fit parameter range entered "
+                            wx.PostEvent(self._manager.parent,
+                                         StatusEvent(status=msg))
+                            raise ValueError, msg
+                        is_modified = True
+                if param_min != None and param_max != None:
+                    if not self._validate_qrange(item[5], item[6]):
+                        msg = "Wrong Fit range entered for parameter "
+                        msg += "name %s of model %s " % (name, self.model.name)
+                        wx.PostEvent(self._manager.parent,
+                                     StatusEvent(status=msg))
+                if name in self.model.details.keys():
+                    self.model.details[name][1:3] = param_min, param_max
+                    is_modified = True
+                else:
+                    self.model.details[name] = ["", param_min, param_max]
+                    is_modified = True
+            try:
+                # Check if the textctr is enabled
+                if item[2].IsEnabled():
+                    value = float(item[2].GetValue())
+                    item[2].SetBackgroundColour("white")
+                    # If the value of the parameter has changed,
+                    # +update the model and set the is_modified flag
+                    if value != self.model.getParam(name) and \
+                                                numpy.isfinite(value):
+                        self.model.setParam(name, value)
+            except:
+                item[2].SetBackgroundColour("pink")
+                msg = "Wrong Fit parameter value entered "
+                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
+            if name.endswith(".npts") or name.endswith(".nsigmas"):
+                continue
+            # Check that min, max and value are floats
+            value_ctrl, min_ctrl, max_ctrl = item[2], item[5], item[6]
+            min_str = min_ctrl.GetValue().strip()
+            max_str = max_ctrl.GetValue().strip()
+            value_str = value_ctrl.GetValue().strip()
+            validity = check_float(value_ctrl)
+            if min_str != "":
+                validity = validity and check_float(min_ctrl)
+            if max_str != "":
+                validity = validity and check_float(max_ctrl)
+            if not validity:
+                continue
+            # Check that min is less than max
+            low = -numpy.inf if min_str == "" else float(min_str)
+            high = numpy.inf if max_str == "" else float(max_str)
+            if high < low:
+                min_ctrl.SetBackgroundColour("pink")
+                min_ctrl.Refresh()
+                max_ctrl.SetBackgroundColour("pink")
+                max_ctrl.Refresh()
+                #msg = "Invalid fit range for %s: min must be smaller than max"%name
+                #wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
+                continue
+            # Force value between min and max
+            value = float(value_str)
+            if value < low:
+                value = low
+                value_ctrl.SetValue(format_number(value))
+            elif value > high:
+                value = high
+                value_ctrl.SetValue(format_number(value))
+            # Update value in model if it has changed
+            if value != self.model.getParam(name):
+                self.model.setParam(name, value)
+                is_modified = True
+            if name not in self.model.details.keys():
+                self.model.details[name] = ["", None, None]
+            old_low, old_high = self.model.details[name][1:3]
+            if old_low != low or old_high != high:
+                # The configuration has changed but it won't change the
+                # computed curve so no need to set is_modified to True
+                #is_modified = True
+                self.model.details[name][1:3] = low, high
         return is_modified
 …
                 try:
                     self.model.set_dispersion(p, disp_model)
                 except:
                     logging.error(sys.exc_info()[1])
+                except Exception:
+                    logging.error(traceback.format_exc())
         ## save state into
 …
             self._draw_model()
             self.Refresh()
+        except:
+        except Exception:
+            logging.error(traceback.format_exc())
             # Error msg
             msg = "Error occurred:"
 …
         # Try to delete values and weight of the names array dic if exists
         try:
+            del self.values[name]
+            del self.weights[name]
+            # delete all other dic
+            del self.state.values[name]
+            del self.state.weights[name]
+            del self.model._persistency_dict[name.split('.')[0]]
+            del self.state.model._persistency_dict[name.split('.')[0]]
+        except:
+            logging.error(sys.exc_info()[1])
+            if name in self.values:
+                del self.values[name]
+                del self.weights[name]
+                # delete all other dic
+                del self.state.values[name]
+                del self.state.weights[name]
+                del self.model._persistency_dict[name.split('.')[0]]
+                del self.state.model._persistency_dict[name.split('.')[0]]
+        except Exception:
+            logging.error(traceback.format_exc())
     def _lay_out(self):
 …
                         graphs.append(item2.figure)
                         canvases.append(item2.canvas)
             except:
+            except Exception:
                 # Not for control panels
                 logging.error(sys.exc_info()[1])
+                logging.error(traceback.format_exc())
         # Make sure the resduals plot goes to the last
         if res_item != None:
 …
         """
         _TreeLocation = "user/sasgui/perspectives/fitting/mag_help.html"
+        _TreeLocation = "user/magnetism.html"
         _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
                                           "Polarized Beam/Magnetc Help")
 …
                 if item[7].__class__.__name__ == 'ComboBox':
                     disfunc = str(item[7].GetValue())
             except:
                 logging.error(sys.exc_info()[1])
+            except Exception:
+                logging.error(traceback.format_exc())
             # 2D
 …
                 try:
                     check = item[0].GetValue()
                 except:
+                except Exception:
                     check = None
                 name = item[1]
 …
                     for weight in self.weights[name]:
                         disfunc += ' ' + str(weight)
             except:
                 logging.error(sys.exc_info()[1])
+            except Exception:
+                logging.error(traceback.format_exc())
             content += name + ',' + str(check) + ',' + value + disfunc + ':'
 …
                                                        weights=pd_weights)
                             is_array = True
                 except:
                     logging.error(sys.exc_info()[1])
+                except Exception:
+                    logging.error(traceback.format_exc())
                 if not is_array:
                     self._disp_obj_dict[name] = disp_model
 …
                                              self.state.weights]
             except:
                 logging.error(sys.exc_info()[1])
+            except Exception:
+                logging.error(traceback.format_exc())
                 print "Error in BasePage._paste_poly_help: %s" % \
                                         sys.exc_info()[1]

src/sas/sasgui/perspectives/fitting/batchfitpage.py

-                      rfc18690
+                      ree4b3cb
 #         if self.model != None:
 #             ##Check the values
 #             self._check_value_enter( self.fittable_param, is_modified)
 #             self._check_value_enter( self.fixed_param, is_modified)
 #             self._check_value_enter( self.parameters, is_modified)
+#             self._check_value_enter( self.fittable_param)
+#             self._check_value_enter( self.fixed_param)
+#             self._check_value_enter( self.parameters)
+#
 #             # If qmin and qmax have been modified, update qmin and qmax and

src/sas/sasgui/perspectives/fitting/fitpage.py

-                      r934ce649
+                      ree4b3cb
             try:
                 tcrtl.SetBackgroundColour(wx.WHITE)
                 self._check_value_enter(self.fittable_param, is_modified)
                 self._check_value_enter(self.parameters, is_modified)
+                self._check_value_enter(self.fittable_param)
+                self._check_value_enter(self.parameters)
             except:
                 tcrtl.SetBackgroundColour("pink")

src/sas/sasgui/perspectives/fitting/fitting.py

-                      r934ce649
+                      r7673ecd
                         wx.PostEvent(self.parent, evt)
                         break
+        except:
+        except Exception:
+            import traceback; traceback.print_exc()
             msg = 'Delete Error: \nCould not delete the file; Check if in use.'
             wx.MessageBox(msg, 'Error')
 …
                 _, theory_state = item
                 self.fit_panel.set_model_state(theory_state)
             except:
+            except Exception:
                 msg = "Fitting: cannot deal with the theory received"
                 evt = StatusEvent(status=msg, info="error")

src/sas/sasgui/perspectives/fitting/media/fitting_help.rst

-                      r20846be
+                      rb64b87c
 Fitting Perspective
 ===================
+Fitting
+=======
 .. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
 …
 To fit some data you must first load some data, activate one or more data sets,
+send those data sets to the fitting perspective, and select a model to fit to
+each data set.
+send those data sets to fitting, and select a model to fit to each data set.
 Instructions on how to load and activate data are in the section :ref:`Loading_data`.
 …
 This mode fits one data set.
+When data is sent to the fitting perspective it is plotted in a graph window as
+markers.
+When data is sent to the fitting it is plotted in a graph window as markers.
 If a graph does not appear, or a graph window appears but is empty, then the data

src/sas/sasgui/perspectives/fitting/media/pd_help.rst

-                      r7805458
+                      rb64b87c
 The median value for the distribution will be the value given for the respective
 size parameter in the *Fitting Perspective*, for example, radius = 60.
+size parameter in the *FitPage*, for example, radius = 60.
 The polydispersity is given by |sigma|
 …
 SasView only uses these array values during the computation, therefore any mean
 value of the parameter represented by *x* present in the *Fitting Perspective*
+value of the parameter represented by *x* present in the *FitPage*
 will be ignored.

src/sas/sasgui/perspectives/fitting/models.py

-                      r6afc14b
+                      rdceff6e
     Utilities to manage models
 """
 import imp
+import traceback
 import os
 import sys
 …
 # Time is needed by the log method
 import time
+import datetime
 import logging
 import py_compile
 …
 PLUGIN_DIR = 'plugin_models'
+PLUGIN_LOG = os.path.join(os.path.expanduser("~"), '.sasview', PLUGIN_DIR,
+                          "plugins.log")
 def get_model_python_path():
 …
 def log(message):
+def plugin_log(message):
     """
     Log a message in a file located in the user's home directory
     """
+    dir = os.path.join(os.path.expanduser("~"), '.sasview', PLUGIN_DIR)
+    out = open(os.path.join(dir, "plugins.log"), 'a')
+    out.write("%10g:  %s\n" % (time.clock(), message))
+    out = open(PLUGIN_LOG, 'a')
+    now = time.time()
+    stamp = datetime.datetime.fromtimestamp(now).strftime('%Y-%m-%d %H:%M:%S')
+    out.write("%s: %s\n" % (stamp, message))
     out.close()
 …
     if not issubclass(model, Model1DPlugin):
         msg = "Plugin %s must be of type Model1DPlugin \n" % str(name)
         log(msg)
+        plugin_log(msg)
         return None
     if model.__name__ != "Model":
         msg = "Plugin %s class name must be Model \n" % str(name)
         log(msg)
+        plugin_log(msg)
         return None
     try:
 …
                                                              str(sys.exc_type),
                                                              sys.exc_info()[1])
         log(msg)
+        plugin_log(msg)
         return None
 …
             msg = "Plugin %s: error writing function \n\t :%s %s\n " % \
                     (str(name), str(sys.exc_type), sys.exc_info()[1])
             log(msg)
+            plugin_log(msg)
             return None
     else:
         msg = "Plugin  %s needs a method called function \n" % str(name)
         log(msg)
+        plugin_log(msg)
         return None
     return model
 …
     """
     def __nonzero__(self):
         type, value, traceback = sys.exc_info()
+        type, value, tb = sys.exc_info()
         if type is not None and issubclass(type, py_compile.PyCompileError):
             print "Problem with", repr(value)
             raise type, value, traceback
+            raise type, value, tb
         return 1
 …
 def _findModels(dir):
+    """
+    Find custom models
+    """
     # List of plugin objects
-    plugins = {}
     dir = find_plugins_dir()
     # Go through files in plug-in directory
-    #always recompile the folder plugin
     if not os.path.isdir(dir):
+        msg = "SasView couldn't locate Model plugin folder."
+        msg += """ "%s" does not exist""" % dir
+        msg = "SasView couldn't locate Model plugin folder %r." % dir
         logging.warning(msg)
+        return plugins
+    else:
+        log("looking for models in: %s" % str(dir))
+        compile_file(dir)
+        logging.info("plugin model dir: %s" % str(dir))
+    try:
+        list = os.listdir(dir)
+        for item in list:
+            toks = os.path.splitext(os.path.basename(item))
+            if toks[1] == '.py' and not toks[0] == '__init__':
+                name = toks[0]
+                path = [os.path.abspath(dir)]
+                file = None
+                try:
+                    (file, path, info) = imp.find_module(name, path)
+                    module = imp.load_module(name, file, item, info)
+                    if hasattr(module, "Model"):
+                        try:
+                            if _check_plugin(module.Model, name) != None:
+                                plugins[name] = module.Model
+                        except:
+                            msg = "Error accessing Model"
+                            msg += "in %s\n  %s %s\n" % (name,
+                                                         str(sys.exc_type),
+                                                         sys.exc_info()[1])
+                            log(msg)
+                    else:
+                        filename = os.path.join(dir, item)
+                        plugins[name] = load_custom_model(filename)
+                except:
+                    msg = "Error accessing Model"
+                    msg += " in %s\n  %s %s \n" % (name,
+                                                   str(sys.exc_type),
+                                                   sys.exc_info()[1])
+                    log(msg)
+                finally:
+                    if not file == None:
+                        file.close()
+    except:
+        # Don't deal with bad plug-in imports. Just skip.
+        msg = "Could not import model plugin: %s" % sys.exc_info()[1]
+        log(msg)
+        return {}
+    plugin_log("looking for models in: %s" % str(dir))
+    #compile_file(dir)  #always recompile the folder plugin
+    logging.info("plugin model dir: %s" % str(dir))
+    plugins = {}
+    for filename in os.listdir(dir):
+        name, ext = os.path.splitext(filename)
+        if ext == '.py' and not name == '__init__':
+            path = os.path.abspath(os.path.join(dir, filename))
+            try:
+                model = load_custom_model(path)
+                plugins[model.name] = model
+            except Exception:
+                msg = traceback.format_exc()
+                msg += "\nwhile accessing model in %r" % path
+                plugin_log(msg)
+                logging.warning("Failed to load plugin %r. See %s for details"
+                                % (path, PLUGIN_LOG))
     return plugins

src/sas/sasgui/perspectives/fitting/pagestate.py

-                      rc10d9d6c
+                      r7673ecd
 import logging
 import numpy
 import string
+import traceback
 import xml.dom.minidom
 …
             try:
                 value = content[1]
             except:
                 logging.error(sys.exc_value)
+            except Exception:
+                logging.error(traceback.format_exc())
             if name.count("State created"):
                 repo_time = "" + value
 …
                         title = content[2] + " [" + repo_time + "]"
                         title_name = HEADER % title
                 except:
                     logging.error(sys.exc_value)
+                except Exception:
+                    logging.error(traceback.format_exc())
             if name == "model name ":
                 try:
 …
                     q_name = ("Q Range:    " + q_range)
                     q_range = CENTRE % q_name
                 except:
                     logging.error(sys.exc_value)
+                except Exception:
+                    logging.error(traceback.format_exc())
         paramval = ""
         for lines in param_string.split(":"):
 …
                             attribute = getattr(self, item[1])
                             attribute[name] = com_name
                         except:
                             logging.error(sys.exc_value)
+                        except Exception:
+                            logging.error(traceback.format_exc())
                 # get self.values and self.weights dic. if exists
 …
                                 val = float(line)
                                 value_list.append(val)
                             except:
+                            except Exception:
                                 # pass if line is empty (it happens)
                                 logging.error(sys.exc_value)
+                                logging.error(traceback.format_exc())
                         dic[name] = numpy.array(value_list)
                     setattr(self, item[1], dic)
 …
                     if len(note_value) > 0:
                         data_info.notes.append(note_value)
             except:
+            except Exception:
                 err_mess = "cansas_reader.read: error processing entry notes\n  %s" % sys.exc_value
                 self.errors.append(err_mess)
 …
                     if len(detail_value) > 0:
                         data_info.sample.details.append(detail_value)
             except:
+            except Exception:
                 err_mess = "cansas_reader.read: error processing sample details\n  %s" % sys.exc_value
                 self.errors.append(err_mess)

src/sas/sasgui/perspectives/invariant/invariant_panel.py

-                      rc12f9b4
+                      rcb93b40
             num = self.state.saved_state['state_num']
             if num > 0:
+            if int(num) > 0:
                 self._set_undo_flag(True)
             if num < len(state.state_list) - 1:
+            if int(num) < len(state.state_list) - 1:
                 self._set_redo_flag(True)
 …
                                    (self.button_calculate, 0,
                                     wx.RIGHT | wx.TOP | wx.BOTTOM, 10),
                                    (self.button_help, 0,
+                                   (self.button_help, 0,
                                     wx.RIGHT | wx.TOP | wx.BOTTOM, 10),])
     def _do_layout(self):
 …
         self.SetSizer(self.main_sizer)
         self.SetAutoLayout(True)
     def on_help(self, event):
         """
         Bring up the Invariant Documentation whenever the HELP button is
+        Bring up the Invariant Documentation whenever the HELP button is
         clicked.

src/sas/sasgui/perspectives/invariant/invariant_state.py

-                      rc10d9d6c
+                      rcb93b40
                         if input_field is not None:
                             temp_state[item] = val
                             self.state_list[ind] = temp_state
+                            self.state_list[str(ind)] = temp_state
             # Parse current state (ie, saved_state)
 …
             doc = state.toXML(datainfo.name, doc=doc, entry_node=sasentry)
         return doc

src/sas/sasgui/perspectives/invariant/media/invariant_help.rst

-                      r70305bd2
+                      rb64b87c
 .. by S King, ISIS, during SasView CodeCamp-III in Feb 2015.
 Invariant Calculation Perspective
 =================================
+Invariant Calculation
+=====================
 Description
 …
 .. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
 Using the perspective
 ---------------------
+Using invariant analysis
+------------------------
 ) Select *Invariant* from the *Analysis* menu on the SasView toolbar.
 …
 ) Select a dataset and use the *Send To* button on the *Data Explorer* to load
    the dataset into the *Invariant* perspective.
+   the dataset into the *Invariant* panel.
 ) Use the *Customised Input* boxes on the *Invariant* perspective to subtract
+) Use the *Customised Input* boxes on the *Invariant* panel to subtract
    any background, specify the contrast (i.e. difference in SLDs - this must be
    specified for the eventual value of Q*\  to be on an absolute scale), or to
 …
 ) If the value of Q*\  calculated with the extrapolated regions is invalid, a
    red warning will appear at the top of the *Invariant* perspective panel.
+   red warning will appear at the top of the *Invariant* panel.
    The details of the calculation are available by clicking the *Details*

src/sas/sasgui/perspectives/pr/media/pr_help.rst

-                      r7805458
+                      rb64b87c
 .. by S King, ISIS, during SasView CodeCamp-III in Feb 2015.
 P(r) Inversion Perspective
 ==========================
+P(r) Calculation
+================
 Description
 …
 .. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
 Using the perspective
 ---------------------
+Using P(r) inversion
+--------------------
 The user must enter

src/sas/sasgui/plottools/LineModel.py

-                      rd7bb526
+                      rdd5bf63
 #!/usr/bin/env python
 """
+Provide Line function (y= A + Bx)
+Provide Line function (y= Ax + B). Until July 10, 2016 this function provided
+(y= A + Bx).  This however was contrary to all the other code using it which
+assumed (y= mx+b) or in this nomenclature (y=Ax + B). This lead to some
+contortions in the code and worse incorrect calculations until now for at least
+some of the functions.  This seemed the easiest to fix particularly since this
+function should disappear in a future iteration (see notes in fitDialog)
+                -PDB   July 10, 2016
 """
 …
     Class that evaluates a linear model.
     f(x) = A + Bx
+    f(x) = Ax + B
     List of default parameters:
     A = 0.0
     B = 0.0
+    A = 1.0
+    B = 1.0
     """
 …
         """
         return  self.params['A'] + (x * self.params['B'])
+        return  (self.params['A'] * x) + self.params['B']
     def run(self, x=0.0):
         """
         Evaluate the model
+        :note: This is the function called by fitDialog to calculate the
+        the y(xmin) and y(xmax), but the only difference between this and
+        runXY is when the if statement is true. I however cannot see what that
+        function is for.  It needs to be documented here or removed.
+        -PDB 7/10/16
         :param x: simple value
 …
     def runXY(self, x=0.0):
         """
+        Evaluate the model
+        Evaluate the model.
+        :note: This is to be what is called by fitDialog for the actual fit
+        but the only difference between this and run is when the if
+        statement is true. I however cannot see what that function
+        is for.  It needs to be documented here or removed. -PDB 7/10/16
         :param x: simple value

src/sas/sasgui/plottools/PlotPanel.py

-                      r16b769b
+                      r1a8e2e8e
 import os
 import transform
-from plottables import Data1D
 #TODO: make the plottables interactive
 from binder import BindArtist
 …
         #List of texts currently on the plot
         self.textList = []
+        self.selectedText = None
         #User scale
         if xtransform != None:
 …
         # new data for the fit
+        from sas.sasgui.guiframe.dataFitting import Data1D
         self.fit_result = Data1D(x=[], y=[], dy=None)
         self.fit_result.symbol = 13
 …
             self.leftdown = True
             ax = event.inaxes
+            for text in self.textList:
+                if text.contains(event)[0]: # If user has clicked on text
+                    self.selectedText = text
+                    return
             if ax != None:
                 self.xInit, self.yInit = event.xdata, event.ydata
 …
             self.mousemotion = False
             self.leftup = True
+            self.selectedText = None
         #release the legend
 …
             self._on_legend_motion(event)
             return
+        if self.leftdown and self.selectedText is not None:
+            # User has clicked on text and is dragging
+            ax = event.inaxes
+            if ax != None:
+                # Only move text if mouse is within axes
+                self.selectedText.set_position((event.xdata, event.ydata))
+                self._dragHelper(0, 0)
+            else:
+                # User has dragged outside of axes
+                self.selectedText = None
+            return
         if self.enable_toolbar:
             #Disable dragging without the toolbar to allow zooming with toolbar
 …
                 dlg.setFitRange(self.xminView, self.xmaxView,
                                 self.xmin, self.xmax)
+            else:
+                xlim = self.subplot.get_xlim()
+                ylim = self.subplot.get_ylim()
+                dlg.setFitRange(xlim[0], xlim[1], ylim[0], ylim[1])
+            # It would be nice for this to NOT be modal (i.e. Show).
+            # Not sure about other ramifications - for example
+            # if a second linear fit is started before the first is closed.
+            # consider for future - being able to work on the plot while
+            # seing the fit values would be very nice  -- PDB 7/10/16
             dlg.ShowModal()
 …
                 if dial.ShowModal() == wx.ID_OK:
                     self.xLabel, self.yLabel, self.viewModel = dial.getValues()
-                    if self.viewModel == "Linear y vs x":
-                        self.xLabel = "x"
-                        self.yLabel = "y"
-                        self.viewModel = "--"
-                        dial.setValues(self.xLabel, self.yLabel, self.viewModel)
-                    if self.viewModel == "Guinier lny vs x^(2)":
-                        self.xLabel = "x^(2)"
-                        self.yLabel = "ln(y)"
-                        self.viewModel = "--"
-                        dial.setValues(self.xLabel, self.yLabel, self.viewModel)
-                    if self.viewModel == "XS Guinier ln(y*x) vs x^(2)":
-                        self.xLabel = "x^(2)"
-                        self.yLabel = "ln(y*x)"
-                        self.viewModel = "--"
-                        dial.setValues(self.xLabel, self.yLabel, self.viewModel)
-                    if self.viewModel == "Porod y*x^(4) vs x^(4)":
-                        self.xLabel = "x^(4)"
-                        self.yLabel = "y*x^(4)"
-                        self.viewModel = "--"
-                        dial.setValues(self.xLabel, self.yLabel, self.viewModel)
                     self._onEVT_FUNC_PROPERTY()
                 dial.Destroy()
 …
         # Properties defined by plot
         # Ricardo:
+        # A empty label "$$" will prevent the panel from displaying!
+        # A empty label "$$" will prevent the panel from displaying!
         if prop["xlabel"]:
             self.subplot.set_xlabel(r"$%s$"%prop["xlabel"])
 …
             self.subplot.set_ylabel(r"$%s$"%prop["ylabel"])
         self.subplot.set_title(prop["title"])
     def clear(self):
 …
                                                   bins=[self.y_bins, self.x_bins],
                                                   weights=self.data)
         # Now, normalize the image by weights only for weights>1:
+        # Now, normalize the image by weights only for weights>1:
         # If weight == 1, there is only one data point in the bin so
         # that no normalization is required.
 …
         if remove_fit:
             self.graph.delete(self.fit_result)
+            if hasattr(self, 'plots'):
+                if 'fit' in self.plots.keys():
+                    del self.plots['fit']
         self.ly = None
         self.q_ctrl = None
 …
         _yscale = 'linear'
         for item in list:
+            if item.id == 'fit':
+                continue
             item.setLabel(self.xLabel, self.yLabel)
             # control axis labels from the panel itself
             yname, yunits = item.get_yaxis()
 …
             if self.xLabel == "ln(x)":
                 item.transformX(transform.toLogX, transform.errToLogX)
                 self.graph._xaxis_transformed("\ln\\ %s" % xname, "%s" % xunits)
+                self.graph._xaxis_transformed("\ln{(%s)}" % xname, "%s" % xunits)
             if self.xLabel == "log10(x)":
                 item.transformX(transform.toX_pos, transform.errToX_pos)
 …
             if self.yLabel == "ln(y)":
                 item.transformY(transform.toLogX, transform.errToLogX)
                 self.graph._yaxis_transformed("\ln\\ %s" % yname, "%s" % yunits)
+                self.graph._yaxis_transformed("\ln{(%s)}" % yname, "%s" % yunits)
             if self.yLabel == "y":
                 item.transformY(transform.toX, transform.errToX)
 …
                 yunits = convert_unit(-1, yunits)
                 self.graph._yaxis_transformed("1/%s" % yname, "%s" % yunits)
+            if self.yLabel == "y*x^(2)":
+                item.transformY(transform.toYX2, transform.errToYX2)
+                xunits = convert_unit(2, self.xaxis_unit)
+                self.graph._yaxis_transformed("%s \ \ %s^{2}" % (yname, xname),
+                                              "%s%s" % (yunits, xunits))
             if self.yLabel == "y*x^(4)":
                 item.transformY(transform.toYX4, transform.errToYX4)
 …
             if self.yLabel == "ln(y*x)":
                 item.transformY(transform.toLogXY, transform.errToLogXY)
                 self.graph._yaxis_transformed("\ln (%s \ \ %s)" % (yname, xname),
+                self.graph._yaxis_transformed("\ln{(%s \ \ %s)}" % (yname, xname),
                                               "%s%s" % (yunits, self.xaxis_unit))
             if self.yLabel == "ln(y*x^(2))":
 …
                 self.graph._yaxis_transformed("%s \ \ %s^{4}" % (yname, xname),
                                               "%s%s" % (yunits, xunits))
-            if self.viewModel == "Guinier lny vs x^(2)":
-                item.transformX(transform.toX2, transform.errToX2)
-                xunits = convert_unit(2, xunits)
-                self.graph._xaxis_transformed("%s^{2}" % xname, "%s" % xunits)
-                item.transformY(transform.toLogX, transform.errToLogX)
-                self.graph._yaxis_transformed("\ln\ \ %s" % yname, "%s" % yunits)
-            if self.viewModel == "Porod y*x^(4) vs x^(4)":
-                item.transformX(transform.toX4, transform.errToX4)
-                xunits = convert_unit(4, self.xaxis_unit)
-                self.graph._xaxis_transformed("%s^{4}" % xname, "%s" % xunits)
-                item.transformY(transform.toYX4, transform.errToYX4)
-                self.graph._yaxis_transformed("%s \ \ %s^{4}" % (yname, xname),
-                                              "%s%s" % (yunits, xunits))
             item.transformView()
 …
         """
+        xlim = self.subplot.get_xlim()
+        ylim = self.subplot.get_ylim()
         # Saving value to redisplay in Fit Dialog when it is opened again
         self.Avalue, self.Bvalue, self.ErrAvalue, \
 …
         self.graph.render(self)
         self._offset_graph()
+        if hasattr(self, 'plots'):
+            # Used by Plotter1D
+            fit_id = 'fit'
+            self.fit_result.id = fit_id
+            self.fit_result.title = 'Fit'
+            self.fit_result.name = 'Fit'
+            self.plots[fit_id] = self.fit_result
+        self.subplot.set_xlim(xlim)
+        self.subplot.set_ylim(ylim)
         self.subplot.figure.canvas.draw_idle()

src/sas/sasgui/plottools/PropertyDialog.py

-                      rd7bb526
+                      r5129686
         iy += 1
         ix = 1
         self.xvalue = wx.ComboBox(self, -1)
+        self.xvalue = wx.ComboBox(self, -1, style=wx.CB_READONLY)
         x_size += self.xvalue.GetSize()[0]
         sizer.Add(self.xvalue, (iy, ix), (1, 1), wx.EXPAND | wx.ADJUST_MINSIZE, 0)
+        sizer.Add(self.xvalue, (iy, ix), (1, 1), wx.ADJUST_MINSIZE, 0)
         ix += 2
         self.yvalue = wx.ComboBox(self, -1)
+        self.yvalue = wx.ComboBox(self, -1, style=wx.CB_READONLY)
         x_size += self.yvalue.GetSize()[0]
         sizer.Add(self.yvalue, (iy, ix), (1, 1), wx.EXPAND | wx.ADJUST_MINSIZE, 0)
+        sizer.Add(self.yvalue, (iy, ix), (1, 1), wx.ADJUST_MINSIZE, 0)
         ix += 2
+        self.view = wx.ComboBox(self, -1)
+        self.view = wx.ComboBox(self, -1, style=wx.CB_READONLY)
+        self.view.Bind(wx.EVT_COMBOBOX, self.viewChanged)
         x_size += self.view.GetSize()[0]
         self.view.SetMinSize((160, 30))
 …
         self.yvalue.Insert("ln(y)", 2)
         self.yvalue.Insert("y^(2)", 3)
+        self.yvalue.Insert("y*x^(4)", 4)
+        self.yvalue.Insert("1/sqrt(y)", 5)
+        self.yvalue.Insert("log10(y)", 6)
+        self.yvalue.Insert("ln(y*x)", 7)
+        self.yvalue.Insert("ln(y*x^(2))", 8)
+        self.yvalue.Insert("ln(y*x^(4))", 9)
+        self.yvalue.Insert("log10(y*x^(4))", 10)
+        self.yvalue.Insert("y*x^(2)", 4)
+        self.yvalue.Insert("y*x^(4)", 5)
+        self.yvalue.Insert("1/sqrt(y)", 6)
+        self.yvalue.Insert("log10(y)", 7)
+        self.yvalue.Insert("ln(y*x)", 8)
+        self.yvalue.Insert("ln(y*x^(2))", 9)
+        self.yvalue.Insert("ln(y*x^(4))", 10)
+        self.yvalue.Insert("log10(y*x^(4))", 11)
         # type of view or model used
         self.view.SetValue("--")
 …
         self.Centre()
+    def viewChanged(self, event):
+        event.Skip()
+        view = self.view.GetValue()
+        if view == "Linear y vs x":
+            self.xvalue.SetValue("x")
+            self.yvalue.SetValue("y")
+        elif view == "Guinier lny vs x^(2)":
+            self.xvalue.SetValue("x^(2)")
+            self.yvalue.SetValue("ln(y)")
+        elif view == "XS Guinier ln(y*x) vs x^(2)":
+            self.xvalue.SetValue("x^(2)")
+            self.yvalue.SetValue("ln(y*x)")
+        elif view == "Porod y*x^(4) vs x^(4)":
+            self.xvalue.SetValue("x^(4)")
+            self.yvalue.SetValue("y*x^(4)")
+        elif view == "Kratky y*x^(2) vs x":
+            self.xvalue.SetValue("x")
+            self.yvalue.SetValue("y*x^(2)")
     def setValues(self, x, y, view):
         """

src/sas/sasgui/plottools/fitDialog.py

-                      rd7bb526
+                      rdd5bf63
 def format_number(value, high=False):
     """
+    Return a float in a standardized, human-readable formatted string
+    Return a float in a standardized, human-readable formatted string.
+    This is used to output readable (e.g. x.xxxe-y) values to the panel.
     """
     try:
 …
         """
         Dialog window pops- up when select Linear fit on Context menu
+        Displays fitting parameters
+        Displays fitting parameters. This class handles the linearized
+        fitting and derives and displays specialized output parameters based
+        on the scale choice of the plot calling it.
+        :note1: The fitting is currently a bit convoluted as besides using
+        plottools.transform.py to handle all the conversions, it uses
+        LineModel to define a linear model and calculate a number of
+        things like residuals etc as well as the function itself given an x
+        value. It also uses fittings.py to set up the defined LineModel for
+        fitting and then send it to the SciPy NLLSQ method.  As these are by
+        definition "linear nodels" it would make more sense to just call
+        a linear solver such as scipy.stats.linregress or bumps.wsolve directly.
+        This would considerably simplify the code and remove the need I think
+        for LineModel.py and possibly fittins.py altogether.   -PDB 7/10/16
+        :note2: The linearized fits do not take resolution into account. This
+        means that for poor resolution such as slit smearing the answers will
+        be completely wrong --- Rg would be OK but I0 would be orders of
+        magnitude off.  Eventually we should fix this to account properly for
+        resolution.   -PDB  7/10/16
         """
         wx.Dialog.__init__(self, parent, title=title,
 …
         # Registered owner for close event
         self._registered_close = None
         # dialog panel self call function to plot the fitting function
+        # calls the calling PlotPanel method onFitDisplay
         self.push_data = push_data
+        # dialog self plottable
+        # dialog self plottable - basically the plot we are working with
+        # passed in by the caller
         self.plottable = plottable
+        # is this a Guinier fit
         self.rg_on = False
+        # Receive transformations of x and y
+        # Receive transformations of x and y - basically transform is passed
+        # as caller method that returns its current value for these
         self.xLabel, self.yLabel, self.Avalue, self.Bvalue, \
                self.ErrAvalue, self.ErrBvalue, self.Chivalue = self.transform()
+        # Dialog interface
+        # Now set up the dialog interface
+        self.layout()
+        # Receives the type of model for the fitting
+        from LineModel import LineModel
+        self.model = LineModel()
+        # Display the fittings values
+        self.default_A = self.model.getParam('A')
+        self.default_B = self.model.getParam('B')
+        self.cstA = fittings.Parameter(self.model, 'A', self.default_A)
+        self.cstB = fittings.Parameter(self.model, 'B', self.default_B)
+        # Set default value of parameter in the dialog panel
+        if self.Avalue == None:
+            self.tcA.SetValue(format_number(self.default_A))
+        else:
+            self.tcA.SetLabel(format_number(self.Avalue))
+        if self.Bvalue == None:
+            self.tcB.SetValue(format_number(self.default_B))
+        else:
+            self.tcB.SetLabel(format_number(self.Bvalue))
+        if self.ErrAvalue == None:
+            self.tcErrA.SetLabel(format_number(0.0))
+        else:
+            self.tcErrA.SetLabel(format_number(self.ErrAvalue))
+        if self.ErrBvalue == None:
+            self.tcErrB.SetLabel(format_number(0.0))
+        else:
+            self.tcErrB.SetLabel(format_number(self.ErrBvalue))
+        if self.Chivalue == None:
+            self.tcChi.SetLabel(format_number(0.0))
+        else:
+            self.tcChi.SetLabel(format_number(self.Chivalue))
+        if self.plottable.x != []:
+            # store the values of View in self.x,self.y,self.dx,self.dy
+            self.x, self.y, self.dx, \
+                     self.dy = self.plottable.returnValuesOfView()
+            try:
+                self.mini = self.floatForwardTransform(min(self.x))
+            except:
+                self.mini = "Invalid"
+            try:
+                self.maxi = self.floatForwardTransform(max(self.x))
+            except:
+                self.maxi = "Invalid"
+            self.initXmin.SetValue(format_number(min(self.plottable.x)))
+            self.initXmax.SetValue(format_number(max(self.plottable.x)))
+            self.mini = min(self.x)
+            self.maxi = max(self.x)
+            self.xminFit.SetValue(format_number(self.mini))
+            self.xmaxFit.SetValue(format_number(self.maxi))
+    def layout(self):
+        """
+        Sets up the panel layout for the linear fit including all the
+        labels, text entry boxes, and buttons.
+        """
+        # set up sizers first.
+        # vbox is the panel sizer and is a vertical sizer
+        # The first element of the panel is sizer which is a gridbagsizer
+        # and contains most of the text fields
+        # this is followed by a line separator added to vbox
+        # and finally the sizer_button (a horizontal sizer) adds the buttons
         vbox = wx.BoxSizer(wx.VERTICAL)
         sizer = wx.GridBagSizer(5, 5)
+        sizer_button = wx.BoxSizer(wx.HORIZONTAL)
+        #size of string boxes in pixels
         _BOX_WIDTH = 100
+        self.tcA = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, 20))
+        _BOX_HEIGHT = 20
+        #now set up all the text fields
+        self.tcA = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, _BOX_HEIGHT))
         self.tcA.SetToolTipString("Fit value for the slope parameter.")
         self.tcErrA = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, 20))
+        self.tcErrA = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, _BOX_HEIGHT))
         self.tcErrA.SetToolTipString("Error on the slope parameter.")
         self.tcB = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, 20))
+        self.tcB = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, _BOX_HEIGHT))
         self.tcA.SetToolTipString("Fit value for the constant parameter.")
         self.tcErrB = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, 20))
+        self.tcErrB = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, _BOX_HEIGHT))
         self.tcErrB.SetToolTipString("Error on the constant parameter.")
         self.tcChi = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, 20))
+        self.tcChi = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, _BOX_HEIGHT))
         self.tcChi.SetToolTipString("Chi^2 over degrees of freedom.")
         self.xminFit = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, 20))
+        self.xminFit = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, _BOX_HEIGHT))
         msg = "Enter the minimum value on "
         msg += "the x-axis to be included in the fit."
         self.xminFit.SetToolTipString(msg)
         self.xmaxFit = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, 20))
+        self.xmaxFit = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, _BOX_HEIGHT))
         msg = "Enter the maximum value on "
         msg += " the x-axis to be included in the fit."
         self.xmaxFit.SetToolTipString(msg)
         self.initXmin = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, 20))
+        self.initXmin = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, _BOX_HEIGHT))
         msg = "Minimum value on the x-axis for the plotted data."
         self.initXmin.SetToolTipString(msg)
         self.initXmax = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, 20))
+        self.initXmax = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, _BOX_HEIGHT))
         msg = "Maximum value on the x-axis for the plotted data."
         self.initXmax.SetToolTipString(msg)
 …
         self.initXmax.SetBackgroundColour(_BACKGROUND_COLOR)
+        # Buttons on the bottom
+        #set some flags for specific types of fits like Guinier (Rg) and
+        #Porod (bg) -- this will determine WHAT boxes show up in the
+        #sizer layout and depends on the active axis transform
         self.bg_on = False
-        self.static_line_1 = wx.StaticLine(self, -1)
-        self.btFit = wx.Button(self, -1, 'Fit')
-        self.btFit.Bind(wx.EVT_BUTTON, self._onFit)
-        self.btFit.SetToolTipString("Perform fit.")
-        self.btClose = wx.Button(self, wx.ID_CANCEL, 'Close')
-        self.btClose.Bind(wx.EVT_BUTTON, self._on_close)
         if RG_ON:
             if (self.yLabel == "ln(y)" or self.yLabel == "ln(y*x)") and \
 …
             if (self.xLabel == "x^(4)") and (self.yLabel == "y*x^(4)"):
                 self.bg_on = True
+        # Intro
+        explanation = "Perform fit for y(x) = ax + b"
+        # Finally set up static text strings
+        warning = "WARNING! Resolution is NOT accounted for. \n"
+        warning += "Thus slit smeared data will give very wrong answers!"
+        self.textwarn = wx.StaticText(self, -1, warning)
+        self.textwarn.SetForegroundColour(wx.RED)
+        explanation = "Perform fit for y(x) = ax + b \n"
         if self.bg_on:
             param_a = 'Background (= Parameter a)'
         else:
             param_a = 'Parameter a'
+        vbox.Add(sizer)
+        #Now set this all up in the GridBagSizer sizer
         ix = 0
+        iy = 1
+        iy = 0
+        sizer.Add(self.textwarn, (iy, ix),
+                  (2, 3), wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
+        iy += 2
         sizer.Add(wx.StaticText(self, -1, explanation), (iy, ix),
                   (1, 1), wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
         iy += 2
+        iy += 1
         sizer.Add(wx.StaticText(self, -1, param_a), (iy, ix),
                   (1, 1), wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
 …
                       wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 0)
+        #Now add some space before the separation line
         iy += 1
+        ix = 1
+        vbox.Add(self.static_line_1, 0, wx.EXPAND, 0)
+        sizer_button = wx.BoxSizer(wx.HORIZONTAL)
+        ix = 0
+        sizer.Add((20,20), (iy, ix), (1, 1),
+                      wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 0)
+        # Buttons on the bottom
+        self.btFit = wx.Button(self, -1, 'Fit')
+        self.btFit.Bind(wx.EVT_BUTTON, self._onFit)
+        self.btFit.SetToolTipString("Perform fit.")
+        self.btClose = wx.Button(self, wx.ID_CANCEL, 'Close')
+        self.btClose.Bind(wx.EVT_BUTTON, self._on_close)
         sizer_button.Add((20, 20), 1, wx.EXPAND | wx.ADJUST_MINSIZE, 0)
+        sizer_button.Add(self.btFit, 0, wx.LEFT | wx.RIGHT | wx.ADJUST_MINSIZE, 10)
+        sizer_button.Add(self.btFit, 0,
+                         wx.LEFT | wx.RIGHT | wx.ADJUST_MINSIZE, 10)
         sizer_button.Add(self.btClose, 0,
                          wx.LEFT | wx.RIGHT | wx.ADJUST_MINSIZE, 10)
+        vbox.Add(sizer)
+        self.static_line_1 = wx.StaticLine(self, -1)
+        vbox.Add(self.static_line_1, 0, wx.EXPAND, 0)
         vbox.Add(sizer_button, 0, wx.EXPAND | wx.BOTTOM | wx.TOP, 10)
-        sizer.Add(self.btFit, (iy, ix), (1, 1), wx.LEFT | wx.ADJUST_MINSIZE, 0)
         # panel.SetSizer(sizer)
         self.SetSizer(vbox)
         self.Centre()
-        # Receives the type of model for the fitting
-        from LineModel import LineModel
-        self.model = LineModel()
-        # Display the fittings values
-        self.default_A = self.model.getParam('A')
-        self.default_B = self.model.getParam('B')
-        self.cstA = fittings.Parameter(self.model, 'A', self.default_A)
-        self.cstB = fittings.Parameter(self.model, 'B', self.default_B)
-        # Set default value of parameter in fit dialog
-        if self.Avalue == None:
-            self.tcA.SetValue(format_number(self.default_A))
-        else:
-            self.tcA.SetLabel(format_number(self.Avalue))
-        if self.Bvalue == None:
-            self.tcB.SetValue(format_number(self.default_B))
-        else:
-            self.tcB.SetLabel(format_number(self.Bvalue))
-        if self.ErrAvalue == None:
-            self.tcErrA.SetLabel(format_number(0.0))
-        else:
-            self.tcErrA.SetLabel(format_number(self.ErrAvalue))
-        if self.ErrBvalue == None:
-            self.tcErrB.SetLabel(format_number(0.0))
-        else:
-            self.tcErrB.SetLabel(format_number(self.ErrBvalue))
-        if self.Chivalue == None:
-            self.tcChi.SetLabel(format_number(0.0))
-        else:
-            self.tcChi.SetLabel(format_number(self.Chivalue))
-        if self.plottable.x != []:
-            # store the values of View in self.x,self.y,self.dx,self.dy
-            self.x, self.y, self.dx, \
-                     self.dy = self.plottable.returnValuesOfView()
-            try:
-                self.mini = self.floatForwardTransform(min(self.x))
-            except:
-                self.mini = "Invalid"
-            try:
-                self.maxi = self.floatForwardTransform(max(self.x))
-            except:
-                self.maxi = "Invalid"
-            self.initXmin.SetValue(format_number(min(self.plottable.x)))
-            self.initXmax.SetValue(format_number(max(self.plottable.x)))
-            self.mini = min(self.x)
-            self.maxi = max(self.x)
-            self.xminFit.SetValue(format_number(self.mini))
-            self.xmaxFit.SetValue(format_number(self.maxi))
     def register_close(self, owner):
 …
         the button Fit.Computes chisqr ,
         A and B parameters of the best linear fit y=Ax +B
         Push a plottable to
+        Push a plottable to the caller
         """
         tempx = []
 …
                 xmin = xminView
                 xmax = xmaxView
+                # Set the qmin and qmax in the panel that matches the
+                # transformed min and max
+                self.initXmin.SetValue(format_number(self.floatInvTransform(xmin)))
+                self.initXmax.SetValue(format_number(self.floatInvTransform(xmax)))
                 # Store the transformed values of view x, y,dy
                 # in variables  before the fit
 …
                     tempy.append(y_model)
                 # Set the fit parameter display when  FitDialog is opened again
                 self.Avalue = cstB
                 self.Bvalue = cstA
+                self.Avalue = cstA
+                self.Bvalue = cstB
                 self.ErrAvalue = errA
                 self.ErrBvalue = errB
 …
                 # Display the fitting value on the Fit Dialog
                 self._onsetValues(cstB, cstA, errA, errB, chisqr)
+                self._onsetValues(cstA, cstB, errA, errB, chisqr)
     def _onsetValues(self, cstA, cstB, errA, errB, Chi):
 …
         """
         rg = None
+        _diam = None
         self.tcA.SetValue(format_number(cstA))
         self.tcB.SetValue(format_number(cstB))
 …
             if self.Rgerr_tctr.IsShown():
                 if rg != None and rg != 0:
                     value = format_number(3 * float(cstA) / (2 * rg))
+                    value = format_number(3 * float(errA) / (2 * rg))
                 else:
                     value = ''
                 self.Rgerr_tctr.SetValue(value)
                 if self.I0err_tctr.IsShown():
                     val = numpy.abs(numpy.exp(cstB) - numpy.exp(cstB + errB))
+                    val = numpy.abs(numpy.exp(cstB) * errB)
                     self.I0err_tctr.SetValue(format_number(val))
             if self.Diameter_tctr.IsShown():
+                rg = 4 * numpy.sqrt(-float(cstA))
+                value = format_number(rg)
+                rg = numpy.sqrt(-2 * float(cstA))
+                _diam = 4 * numpy.sqrt(-float(cstA))
+                value = format_number(_diam)
                 self.Diameter_tctr.SetValue(value)
             if self.Diametererr_tctr.IsShown():
                 if rg != None and rg != 0:
                     value = format_number(8 * float(cstA) / rg)
+                    value = format_number(8 * float(errA) / _diam)
                 else:
                     value = ''
                 self.Diametererr_tctr.SetValue(value)
             if self.RgQmin_tctr.IsShown():
                 value = format_number(rg * self.mini)
+                value = format_number(rg * self.floatInvTransform(self.mini))
                 self.RgQmin_tctr.SetValue(value)
             if self.RgQmax_tctr.IsShown():
                 value = format_number(rg * self.maxi)
+                value = format_number(rg * self.floatInvTransform(self.maxi))
                 self.RgQmax_tctr.SetValue(value)
 …
     def floatInvTransform(self, x):
         """
+        transform a float.It is use to determine the x.View min and x.View
+        max for values not in x
+        transform a float.It is used to determine the x.View min and x.View
+        max for values not in x.  Also used to properly calculate RgQmin,
+        RgQmax and to update qmin and qmax in the linear range boxes on the
+        panel.
         """
 …
         # functionality work without rewritting the whole code
         # with good design (which really should be done...).
+        if self.xLabel == "x^(2)":
+        if self.xLabel == "x":
+            return x
+        elif self.xLabel == "x^(2)":
             return math.sqrt(x)
+        elif self.xLabel == "x^(4)":
+            return math.sqrt(math.sqrt(x))
         elif self.xLabel == "log10(x)":
             return math.pow(10, x)
         elif self.xLabel == "ln(x)":
             return math.exp(x)
+        elif self.xLabel == "log10(x^(4))":
+            return math.sqrt(math.sqrt(math.pow(10, x)))
         return x

src/sas/sasgui/plottools/fittings.py

-                      rd7bb526
+                      rdd5bf63
 """
+This module is used to fit a set of x,y data to a model passed to it. It is
+used to calculate the slope and intercepts for the linearized fits.  Two things
+should be noted:
+First, this fitting module uses the NLLSQ module of SciPy rather than a linear
+fit.  This along with a few other modules could probably be removed if we
+move to a linear regression approach.
+Second, this infrastructure does not allow for resolution smearing of the
+the models.  Hence the results are not that accurate even for pinhole
+collimation of SANS but may be good for SAXS.  It is completely wrong for
+slit smeared data.
 """
 from scipy import optimize
 …
 class Parameter(object):
     """
+    Class to handle model parameters
+    Class to handle model parameters - sets the parameters and their
+    initial value from the model based to it.
     """
     def __init__(self, model, name, value=None):

src/sas/sasgui/plottools/transform.py

-                      rd7bb526
+                      r8abd96d
 def errToYX2(x, y, dx=None, dy=None):
+def errToYX2(y, x, dy=None, dx=None):
     """
     """
 …
 def errToLogYX2(x, y, dx=None, dy=None):
+def errToLogYX2(y, x, dy=None, dx=None):
     """
     calculate error of Log(yx**2)
 …
 def errToLogYX4(x, y=None, dx=None, dy=None):
+def errToLogYX4(y, x, dy=None, dx=None):
     """
     error for ln(y*x^(4))
 …
 def errToYX4(x, y=None, dx=None, dy=None):
+def errToYX4(y, x, dy=None, dx=None):
     """
     error for (y*x^(4))

SasView

Changeset dceff6e in sasview for src/sas/sasgui

Legend:

src/sas/sasgui/guiframe/data_panel.py

src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter1D.py

src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter2D.py

src/sas/sasgui/guiframe/local_perspectives/plotting/SimplePlot.py

src/sas/sasgui/guiframe/local_perspectives/plotting/detector_dialog.py

src/sas/sasgui/guiframe/media/data_explorer_help.rst

src/sas/sasgui/guiframe/media/graph_help.rst

src/sas/sasgui/guiframe/report_dialog.py

src/sas/sasgui/perspectives/calculator/data_operator.py

src/sas/sasgui/perspectives/calculator/image_viewer.py

src/sas/sasgui/perspectives/calculator/model_editor.py

src/sas/sasgui/perspectives/calculator/pyconsole.py

src/sas/sasgui/perspectives/fitting/basepage.py

src/sas/sasgui/perspectives/fitting/batchfitpage.py

src/sas/sasgui/perspectives/fitting/fitpage.py

src/sas/sasgui/perspectives/fitting/fitting.py

src/sas/sasgui/perspectives/fitting/media/fitting_help.rst

src/sas/sasgui/perspectives/fitting/media/pd_help.rst

src/sas/sasgui/perspectives/fitting/models.py

src/sas/sasgui/perspectives/fitting/pagestate.py

src/sas/sasgui/perspectives/invariant/invariant_panel.py

src/sas/sasgui/perspectives/invariant/invariant_state.py

src/sas/sasgui/perspectives/invariant/media/invariant_help.rst

src/sas/sasgui/perspectives/pr/media/pr_help.rst

src/sas/sasgui/plottools/LineModel.py

src/sas/sasgui/plottools/PlotPanel.py

src/sas/sasgui/plottools/PropertyDialog.py

src/sas/sasgui/plottools/fitDialog.py

src/sas/sasgui/plottools/fittings.py

src/sas/sasgui/plottools/transform.py

Download in other formats: