Changeset e88ebfd in sasview

Timestamp:

Mar 11, 2011 4:39:00 PM (14 years ago)

Author:

Gervaise Alina <gervyh@…>

Branches:

master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

ee2b492

Parents:

14cd91b1

Message:

working on guiframe

Files:

• guiframe/dataFitting.py (modified) (3 diffs)
• guiframe/data_manager.py (modified) (9 diffs)
• guiframe/data_panel.py (modified) (7 diffs)
• guiframe/gui_manager.py (modified) (6 diffs)
• guiframe/local_perspectives/data_loader/data_loader.py (modified) (3 diffs)
• guiframe/local_perspectives/plotting/plotting.py (modified) (2 diffs)
• guiframe/plugin_base.py (modified) (1 diff)
• invariantview/perspectives/invariant/invariant.py (modified) (4 diffs)
• prview/perspectives/pr/pr.py (modified) (11 diffs)
• sansview/perspectives/fitting/basepage.py (modified) (1 diff)
• sansview/perspectives/fitting/fitpanel.py (modified) (1 diff)
• sansview/perspectives/fitting/fitproblem.py (modified) (3 diffs)
• sansview/perspectives/fitting/fitting.py (modified) (15 diffs)

guiframe/dataFitting.py

@@ -27 +27 @@
         LoadData1D.__init__(self, x, y, dx, dy)
         self.id = None
-        self.group_id = []
+        self.list_group_id = []
+        self.group_id = None
         self.is_data = True
         self.path = None
@@ -102 +103 @@
         LoadData1D.__init__(self, x, y, dy)
         self.id = None
-        self.group_id = []
+        self.list_group_id = []
+        self.group_id = None
         self.is_data = True
         self.path = None
@@ -178 +180 @@
                             q_data=q_data, mask=mask)
         self.id = None
-        self.group_id = []
+        self.list_group_id = []
+        self.group_id = None
         self.is_data = True
         self.path = None

guiframe/data_manager.py

@@ -39 +39 @@
         perspective
         """
-        self._selected_data = {}
         self.stored_data = {}
         self.message = ""
@@ -123 +122 @@
         receive a list of 
         """
-        self._selected_data = {}
-        for data in data_list:
-            if data.id  in self.stored_data:
+        for id, data in data_list.iteritems():
+            if id  in self.stored_data:
                 msg = "Data manager already stores %s" % str(data.name)
                 msg += ""
                 logging.info(msg)
-                self.stored_data[data.id].data = data
-                data_state = self.stored_data[data.id]
+                data_state = self.stored_data[id]
             else:
                 data_state = DataState(data)
                 data_state.id = wx.NewId()
-                self.stored_data[data.id] = data_state
-            self._selected_data[data.id] = data_state
-  
+                self.stored_data[id] = data_state
+    
         
     def update_data(self, prev_data, new_data):
@@ -150 +146 @@
         return prev_data.id, {new_data.id: self.stored_data[new_data.id]}
     
+    def update_theory(self, data_id, theory, state=None):
+        """
+        """
+        if data_id in self.stored_data.keys():
+            data_state = self.stored_data[data_id] 
+            data_state.set_theory(theory_data=theory, theory_state=state)
+            return {data_id: self.stored_data[data_id]}
+        return {}
+    
     def get_message(self):
         """
@@ -156 +161 @@
         return self.message
     
-    def get_by_id(self, id_list=None):
+    def get_by_id(self, data_id, theory_id=None):
         """
         get a list of data given a list of id
         """
-        self._selected_data = {}
-        for id in id_list:
-            if id in self.stored_data:
-                self._selected_data[id] = self.stored_data[id]
-        return self._selected_data
-    
-    def append_theory(self, data_id, theory, state=None):
-        """
-        """
-        data_state = self.stored_data[data_id]
-        data_state.set_theory(theory_data=theory, 
-                              theory_state=state)
-        return {data_id: self.stored_data[data_id]}
+        _selected_data = []
+        _selected_theory_list = []
+        if data_id is None:
+            return
+        for d_id in data_id:
+            if d_id in self.stored_data:
+                data_state = self.stored_data[d_id]
+                data = data_state.data
+                _selected_data.append(data)
+                theory_list = data_state.get_theory()
+                if theory_id is not None:
+                    for t_id in theory_id:
+                        if t_id in theory_list.keys():
+                            _selected_theory_list.append(theory_list[t_id])
+        return _selected_data, _selected_theory_list
+    
+   
             
     def freeze_theory(self, data_id, theory_id):
@@ -204 +213 @@
                 del self.data_name_dict[data_state.data.name]
             del self.stored_data[data_id]
-        if data_id in self._selected_data.keys():
-            data_state = self._selected_data[data_id]
-            if data_state.data.name in self.data_name_dict:
-                del self.data_name_dict[data_state.data.name]
-            del self._selected_data[data_id]
         
         self.delete_theory(self, data_id, theory_id)
         if delete_all:
-            self._selected_data = {}
             self.stored_data = {}
             self.data_name_dict = {}
@@ -224 +227 @@
             if theory_id in theory_list.key():
                 del theory_list[theory_id]
-        if data_id in self._selected_data:
-            data_state = self._selected_data[data_id]
-            theory_list = data_state.get_theory()
-            if theory_id in theory_list.key():
-                del theory_list[theory_id]
+        
             
     def delete_by_id(self, id_list=None):
@@ -237 +236 @@
             if id in self.stored_data:
                 del self.stored_data[id]
-            if id  in self._selected_data:
-                del self._selected_data[id]
+         
     
     def get_by_name(self, name_list=None):
@@ -244 +242 @@
         return a list of data given a list of data names
         """
-        self._selected_data = {}
+        _selected_data = {}
         for selected_name in name_list:
             for id, data_state in self.stored_data.iteritems():
                 if data_state.data.name == selected_name:
-                    self._selected_data[id] = data_state
-        return self._selected_data
+                    _selected_data[id] = data_state.data
+        return _selected_data
     
     def delete_by_name(self, name_list=None):
@@ -261 +259 @@
                     del self.stored_data[data.id]
 
-    def get_selected_data(self):
+    def get_data_state(self, data_id):
         """
         Send list of selected data
         """
-        return self._selected_data
+        _selected_data_state = {}
+        for id in data_id:
+            if id in self.stored_data.keys():
+                _selected_data_state[id] = self.stored_data[id]
+        return _selected_data_state
     
     def get_all_data(self):

guiframe/data_panel.py

@@ -410 +410 @@
 
             for theory_id, item in theory_list.iteritems():
-                theory_data, _ = item
+                theory_data, theory_state = item
                 if theory_data is None:
                     name = "Unknown"
@@ -420 +420 @@
                     theory_class = theory_data.__class__.__name__
                     theory_id = theory_data.id
+                    if theory_state is not None:
+                        name = theory_state.model.name
                     temp = (theory_id, theory_class, state_id)
                 if theory_id not in theory_list_ctrl:
@@ -451 +453 @@
             theory_list_ctrl = {}
             for theory_id, item in theory_list.iteritems():
-                theory_data, _ = item
+                theory_data, theory_state = item
                 if theory_data is not None:
+                    name = theory_data.name
                     theory_class = theory_data.__class__.__name__
-                    
+                    theory_id = theory_data.id
+                    if theory_state is not None:
+                        name = theory_state.model.name 
+                    temp = (theory_id, theory_class, state_id)
                     t_child = self.tree_ctrl.AppendItem(theory_child,
-                            theory_data.name, ct_type=1, 
+                            name, ct_type=1, 
                             data=(theory_data.id, theory_class, state_id))
                     t_i_c = self.tree_ctrl.AppendItem(t_child, 'Info')
@@ -475 +481 @@
         """
         data_to_plot = []
+        state_to_plot = []
+        theory_to_plot = []
         for value in self.list_cb_data.values():
             item, _, _, _, _, _ = value
             if item.IsChecked():
-               data_id, _, _ = self.tree_ctrl.GetItemPyData(item) 
+               data_id, _, state_id = self.tree_ctrl.GetItemPyData(item) 
                data_to_plot.append(data_id)
-        theory_to_plot = []
+               if state_id not in state_to_plot:
+                   state_to_plot.append(state_id)
         for theory_dict in self.list_cb_theory.values():
             for key, value in theory_dict.iteritems():
                 item, _, _ = value
                 if item.IsChecked():
-                    theory_id, _, _ = self.tree_ctrl.GetItemPyData(item)
+                    theory_id, _, state_id = self.tree_ctrl.GetItemPyData(item)
                     theory_to_plot.append(theory_id)
-        return data_to_plot, theory_to_plot
+                    if state_id not in state_to_plot:
+                        state_to_plot.append(state_id)
+        return data_to_plot, theory_to_plot, state_to_plot
     
     def remove_by_id(self, id):
@@ -524 +535 @@
         Get all select data and set them to the current active perspetive
         """
-        self.post_helper(plot=False)
-       
+        data_id, theory_id, state_id = self.set_data_helper()
+        self.parent.set_data(data_id)
+        self.parent.set_data(state_id=state_id, theory_id=theory_id)
+        
     def on_append_plot(self, event=None):
         """
         append plot to plot panel on focus
         """
-        self.post_helper(plot=True, append=True)
+        data_id, theory_id, state_id = self.set_data_helper()
+        self.parent.plot_data(data_id=data_id,  
+                              state_id=state_id,
+                              theory_id=theory_id,
+                              append=True)
    
     def on_plot(self, event=None):
@@ -536 +553 @@
         Send a list of data names to plot
         """
-        self.post_helper(plot=True)
+        data_id, theory_id, state_id = self.set_data_helper()
+        self.parent.plot_data(data_id=data_id,  
+                              state_id=state_id,
+                              theory_id=theory_id,
+                              append=False)
        
     def on_freeze(self, event):
         """
         """
-        data_to_plot, theory_to_plot = self.set_data_helper()
-        self.parent.freeze(data_id=data_to_plot, theory_id=theory_to_plot)
+        _, theory_id, state_id = self.set_data_helper()
+        self.parent.freeze(state_id=state_id, theory_id=theory_id)
         
     def set_active_perspective(self, name):
@@ -555 +576 @@
         """
         self.tctrl_plotpanel.SetLabel(str(name))
-        
-    def post_helper(self, plot=False, append=False):
-        """
-        """
-        data_to_plot, theory_to_plot = self.set_data_helper()
-        if self.parent is not None:
-            self.parent.get_data_from_panel(data_id=data_to_plot, plot=plot,
-                                            append=append)
-            
+ 
     
 

guiframe/gui_manager.py

@@ -431 +431 @@
                                   Hide())        
       
-    def append_theory(self, data_id, theory, state=None):
-        """
-        """
-        data_state = self._data_manager.append_theory(data_id=data_id, 
-                                                      theory=theory,
-                                                      state=state)
-        self._data_panel.load_data_list(data_state)
-        
     def update_data(self, prev_data, new_data):
         """
@@ -444 +436 @@
         prev_id, data_state = self._data_manager.update_data(prev_data=prev_data, 
                                        new_data=new_data)
+        
         self._data_panel.remove_by_id(prev_id)
         self._data_panel.load_data_list(data_state)
-       
+        
+    def update_theory(self, data_id, theory, state=None):
+        """
+        """ 
+        data_state = self._data_manager.update_theory(data_id=data_id, 
+                                         theory=theory,
+                                         state=state)  
+        self._data_panel.load_data_list(data_state)
         
     def freeze(self, data_id, theory_id):
@@ -1271 +1271 @@
         """
         """
-        self._data_manager.add_data(data_list)
-        
-    def add_data(self, data_list):
-        """
-        receive a list of data . store them its data manager if possible
-        determine if data was be plot of send to data perspectives
-        """
-        #send a list of available data to plotting plugin
-        avalaible_data = []
-        theory_list = []
         if self._data_manager is not None:
             self._data_manager.add_data(data_list)
-            avalaible_data = self._data_manager.get_all_data()
+        
+    def add_data(self, data_list):
+        """
+        receive a dictionary of data from loader
+        store them its data manager if possible
+        send to data the current active perspective if the data panel 
+        is not active. 
+        :param data_list: dictionary of data's ID and value Data
+        """
+        #Store data into manager
+        self.add_data_helper(data_list)
+        # set data in the data panel
+        if self._data_panel is not None:
+            data_state = self._data_manager.get_data_state(data_list.keys())
+            self._data_panel.load_data_list(data_state)
+        #if the data panel is shown wait for the user to press a button 
+        #to send data to the current perspective. if the panel is not
+        #show  automatically send the data to the current perspective
         style = self.__gui_style & GUIFRAME.MANAGER_ON
         if style == GUIFRAME.MANAGER_ON:
@@ -1292 +1299 @@
         else:
             #automatically send that to the current perspective
-            self.set_data(data_list)
+            self.set_data(data_id=data_list.keys())
        
-         # set data in the data panel
-        if self._data_panel is not None:
-            data_state = self._data_manager.get_selected_data()
-            self._data_panel.load_data_list(data_state)
-           
-    def get_data_from_panel(self, data_id, plot=False,append=False):
-        """
-        receive a list of data key retreive the data from data manager and set 
-        then to the current perspective
-        """
-        data_dict = self._data_manager.get_by_id(data_id)
-        data_list = []
-        for data_state in data_dict.values():
-            data_list.append(data_state.data)
-        if plot:
-            self.plot_data(data_list, append=append)
+    def set_data(self, data_id): 
+        """
+        set data to current perspective
+        """
+        list_data, _ = self._data_manager.get_by_id(data_id)
+        if self._current_perspective is not None:
+            self._current_perspective.set_data(list_data)
         else:
-            #sent data to active application
-            self.set_data(data_list=data_list)
-       
-        
-    def set_data(self, data_list):
-        """
-        set data to current perspective
-        """
+            msg = "Guiframe does not have a current perspective"
+            logging.info(msg)
+            
+    def set_theory(self, state_id, theory_id=None):
+        """
+        """
+        _, list_theory = self._data_manager.get_by_id(state_id, theory_id)
         if self._current_perspective is not None:
             try:
-                self._current_perspective.set_data(data_list)
+                self._current_perspective.set_theory(list_theory)
             except:
-                msg = str(sys.exc_value)
+                msg = "Guiframe set_theory: \n" + str(sys.exc_value)
+                logging.info(msg)
                 wx.PostEvent(self, StatusEvent(status=msg, info="error"))
         else:
@@ -1329 +1327 @@
             logging.info(msg)
             
-    def plot_data(self, data_list, append=False):
+    def plot_data(self,  state_id, data_id=None,
+                  theory_id=None, append=False):
         """
         send a list of data to plot
         """
-        if not data_list:
-            message = "Please check data to plot or append"
-            wx.PostEvent(self, StatusEvent(status=message, info='warning'))
-            return 
+        data_list, _ = self._data_manager.get_by_id(data_id)
+        _, temp_list_theory = self._data_manager.get_by_id(state_id, theory_id)
+        for item in temp_list_theory:
+            theory_data, theory_state = item
+            data_list.append(theory_data)
+        GROUP_ID = wx.NewId()
         for new_plot in data_list:
             if append:
@@ -1347 +1348 @@
                     return 
                 else:
-                    if self.enable_add_data(new_plot) and \
-                    hasattr(self.panel_on_focus, 'group_id'):
-                        new_plot.group_id.append(self.panel_on_focus.group_id)
+                    if self.enable_add_data(new_plot):
+                        new_plot.group_id = self.panel_on_focus.group_id
+                    else:
+                        message = "Only 1D Data can be append to plot panel\n"
+                        message += "%s will be plot separetly\n" %str(new_plot.name)
+                        wx.PostEvent(self, StatusEvent(status=message, 
+                                                   info='warning'))
             else:
                 #if not append then new plot
-                new_plot.group_id.append(wx.NewId())
+                new_plot.group_id = GROUP_ID
+            title = "PLOT " + str(new_plot.title)
             wx.PostEvent(self, NewPlotEvent(plot=new_plot,
-                                                  title=str(new_plot.title)))
+                                                  title=title))
             
   

guiframe/local_perspectives/data_loader/data_loader.py

@@ -139 +139 @@
         message = ""
         log_msg = ''
-        output = []
+        output = {}
         error_message = ""
         for p_file in path:
@@ -156 +156 @@
                     for item in temp:
                         data = self.parent.create_gui_data(item, p_file)
-                        output.append(data)
+                        output[data.id] = data
                 else:
                     data = self.parent.create_gui_data(temp, p_file)
-                    output.append(data)
+                    output[data.id] = data
                 message = "Loading Data..." + str(p_file) + "\n"
                 self.load_update(output=output, message=message)
@@ -189 +189 @@
         if error_message != "":
             self.load_error(error_message)
-        self.parent.add_data(output)
+        self.parent.add_data(data_list=output)
    
     

guiframe/local_perspectives/plotting/plotting.py

@@ -108 +108 @@
         new_panel.set_manager(self)
         new_panel.group_id = group_id
+        if group_id not in data.list_group_id:
+            data.list_group_id.append(group_id)
         if title is None:
             title = data.title
@@ -214 +216 @@
                 
         data = event.plot
-        group_id_list = data.group_id
-        group_id = None
-        if group_id_list:
-            group_id = group_id_list[len(group_id_list)-1]
+        group_id = data.group_id
             
         if group_id in self.plot_panels.keys():

guiframe/plugin_base.py

@@ -206 +206 @@
         update state
         """
-    def set_data(self, data_list):
+    def set_data(self, data_list=None):
         """
         receive a list of data and use it in the current perspective
-        """
+       
+        """
+    def set_theory(self, theory_list=None):
+        """
+        :param theory_list: list of information 
+            related to available theory state
+        """
+        msg = "%s plugin: does not support import theory" % str(self.sub_menu)
+        raise ValueError, msg 
+    
     def on_set_state_helper(self, event):
         """

invariantview/perspectives/invariant/invariant.py

@@ -144 +144 @@
         self.compute_helper(data=data)
                 
-    def set_data(self, data_list=None, theory_list=None):
+    def set_data(self, data_list=None):
         """
         receive a list of data and compute invariant
@@ -151 +151 @@
         if data_list is None:
             data_list = []
-        if len(data_list) > 1:
-            msg = "invariant panel does not allow multiple data!\n"
-            msg += "Please select one.\n"
-            from invariant_widgets import DataDialog
-            dlg = DataDialog(data_list=data_list, text=msg)
-            if dlg.ShowModal() == wx.ID_OK:
-                data = dlg.get_data()
-        elif len(data_list) == 1:
-            data = data_list[0]
-        if data is None:
-            return
-        if issubclass(data.__class__, Data1D):
-            wx.PostEvent(self.parent, NewPlotEvent(plot=data,
-                                       title=data.title))
-            self.compute_helper(data)
+        if len(data_list) >= 1:
+            if len(data_list) == 1:
+                data = data_list[0]
+            else:
+                msg = "invariant panel does not allow multiple data!\n"
+                msg += "Please select one.\n"
+                from invariant_widgets import DataDialog
+                dlg = DataDialog(data_list=data_list, text=msg)
+                if dlg.ShowModal() == wx.ID_OK:
+                    data = dlg.get_data()
+            if data is None:
+                return
+            if issubclass(data.__class__, Data1D):
+                wx.PostEvent(self.parent, NewPlotEvent(plot=data,
+                                           title=data.title))
+                try:
+                    self.compute_helper(data)
+                except:
+                    msg = "Prview Set_data: " + str(sys.exc_value)
+                    wx.PostEvent(self.parent, StatusEvent(status=msg,
+                                                                info="error"))
         else:    
             msg = "invariant cannot be computed for data of "
@@ -230 +236 @@
             data.filename = name
             data = self.parent.create_gui_data(data,None)
-            #self.__data = datainfo
-            #self.__data.group_id = data.filename
-            #self.__data.id = datainfo.filename
             self.__data = data
             wx.PostEvent(self.parent, NewPlotEvent(plot=self.__data,
@@ -271 +274 @@
         if data is None:
             id = str(self.__data.id) + name
-            self.__data.group_id
+            group_id = self.__data.group_id
             wx.PostEvent(self.parent, NewPlotEvent(id=id,
                                                group_id=group_id,

prview/perspectives/pr/pr.py

@@ -219 +219 @@
         new_plot.xaxis("\\rm{r}", 'A')
         new_plot.yaxis("\\rm{P(r)} ","cm^{-3}")
-        group_id = "P_{obs}(r)"
-        if group_id not in new_plot.group_id:
-            new_plot.group_id.append(group_id)
+        new_plot.group_id = "P_{obs}(r)"
         new_plot.id = "P_{obs}(r)"
         new_plot.title = title
@@ -255 +253 @@
         new_plot.yaxis("\\rm{P(r)} ","cm^{-3}")
         new_plot.id = "P_{true}(r)"
-        group_id = "P_{true}(r)"
-        if group_id not in new_plot.group_id:
-            new_plot.group_id.append(group_id)
+        new_plot.group_id = "P_{true}(r)"
         self.parent.append_theory(data_id=self.current_plottable.id,
                                        theory=new_plot)
@@ -316 +312 @@
         # If we have a group ID, use it
         if pr.info.has_key("plot_group_id"):
-            if len( pr.info["plot_group_id"]) > 0:
-                index =  len( pr.info["plot_group_id"]) - 1
-                new_plot.group_id.append( pr.info["plot_group_id"][index])
+            new_plot.group_id = pr.info["plot_group_id"]
         new_plot.id = IQ_FIT_LABEL
         self.parent.append_theory(data_id=self.current_plottable.id,
@@ -345 +339 @@
             # If we have a group ID, use it
             if pr.info.has_key("plot_group_id"):
-                if len( pr.info["plot_group_id"]) > 0:
-                    index =  len( pr.info["plot_group_id"]) - 1
-                    new_plot.group_id.append( pr.info["plot_group_id"][index])
-           
+              new_plot.group_id = pr.info["plot_group_id"]
             new_plot.id = IQ_SMEARED_LABEL
             new_plot.title = title
@@ -418 +409 @@
         new_plot.xtransform = "x"
         new_plot.ytransform = "y"  
-        group_id = "P(r) fit"
-        if group_id not in new_plot.group_id:
-            new_plot.group_id.append(group_id)   
+        new_plot.group_id = "P(r) fit"
         self.parent.append_theory(data_id=self.current_plottable.id,
                                        theory=new_plot)            
@@ -674 +663 @@
             new_plot = Data1D(self._added_plots[plot].x, y)
             new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
-            index  = len(self._added_plots[plot].group_id) - 1
-            if group_id not in new_plot.group_id:
-                new_plot.group_id.append(group_id)
+            new_plot.group_id = self._added_plots[plot].group_id
             new_plot.id = self._added_plots[plot].id
             new_plot.title = self._added_plots[plot].title
@@ -888 +875 @@
             new_plot.yaxis("\\rm{Intensity} ","cm^{-1}")
             if pr.info.has_key("plot_group_id"):
-                new_plot.group_id.append(pr.info["plot_group_id"])
+                new_plot.group_id = pr.info["plot_group_id"]
             new_plot.id = IQ_DATA_LABEL
             self.parent.append_theory(data_id=self.current_plottable.id,
@@ -937 +924 @@
         new_plot.yaxis("\\rm{Intensity} ","cm^{-1}")
         new_plot.interactive = True
-        new_plot.group_id.append(IQ_DATA_LABEL)
+        new_plot.group_id = IQ_DATA_LABEL 
         new_plot.id = IQ_DATA_LABEL
         new_plot.title = "I(q)"
@@ -1049 +1036 @@
         # Keep track of the plot window title to ensure that
         # we can overlay the plots
-        if self.current_plottable.group_id:
-            index = len(self.current_plottable.group_id) - 1
-            group_id = self.current_plottable.group_id[index]
-            pr.info["plot_group_id"] = self.current_plottable.group_id
+        pr.info["plot_group_id"] = self.current_plottable.group_id
         
         # Fill in errors if none were provided
@@ -1350 +1334 @@
         return [self.control_panel]
     
-    def set_data(self, data_list=None, theory_list=None):
+    def set_data(self, data_list=None):
         """
         receive a list of data to compute pr
@@ -1356 +1340 @@
         if data_list is None:
             data_list = []
-        if len(data_list) > 1:
-            msg = "Pr panel does not allow multiple Data.\n"
-            msg += "Please select one!\n"
-            from pr_widgets import DataDialog
-            dlg = DataDialog(data_list=data_list, text=msg)
-            if dlg.ShowModal() == wx.ID_OK:
-                data = dlg.get_data()
-                if issubclass(data.__class__, Data1D):
+        if len(data_list) >= 1:
+            if len(data_list) == 1:
+                data = data_list[0]
+            else:
+                msg = "Pr panel does not allow multiple Data.\n"
+                msg += "Please select one!\n"
+                from pr_widgets import DataDialog
+                dlg = DataDialog(data_list=data_list, text=msg)
+                if dlg.ShowModal() == wx.ID_OK:
+                    data = dlg.get_data()
+            if data is None:
+                return
+            if issubclass(data.__class__, Data1D):
+                try:
                     self.control_panel._change_file(evt=None, data=data)
-                else:    
-                    msg = "Pr cannot be computed for data of "
-                    msg += "type %s" % (data_list[0].__class__.__name__)
-                    wx.PostEvent(self.parent, 
-                             StatusEvent(status=msg, info='error'))
-        elif len(data_list) == 1:
-            if issubclass(data_list[0].__class__, Data1D):
-                self.control_panel._change_file(evt=None, data=data_list[0])
-            else:
-                msg = "Pr cannot be computed for"
-                msg += " data of type %s" % (data_list[0].__class__.__name__)
+                except:
+                     msg = "Prview Set_data: " + str(sys.exc_value)
+                     wx.PostEvent(self.parent, StatusEvent(status=msg,
+                                                            info="error"))
+            else:    
+                msg = "Pr cannot be computed for data of "
+                msg += "type %s" % (data_list[0].__class__.__name__)
                 wx.PostEvent(self.parent, 
-                             StatusEvent(status=msg, info='error'))
+                         StatusEvent(status=msg, info='error'))
         else:
             msg = "Pr contain no data"

sansview/perspectives/fitting/basepage.py

@@ -946 +946 @@
             return  True
         
-           
+    def set_model_state(self, state):
+        """
+        reset page given a model state
+        """
+        self.disp_cb_dict = state.disp_cb_dict
+        self.disp_list = state.disp_list
+      
+        ## set the state of the radio box
+        self.shape_rbutton.SetValue(state.shape_rbutton )
+        self.shape_indep_rbutton.SetValue(state.shape_indep_rbutton)
+        self.struct_rbutton.SetValue(state.struct_rbutton)
+        self.plugin_rbutton.SetValue(state.plugin_rbutton)
+        
+        ## fill model combobox
+        self._show_combox_helper()
+        #select the current model
+        self.formfactorbox.Select(int(state.formfactorcombobox))
+        self.structurebox.SetSelection(state.structurecombobox )
+        if state.multi_factor != None:
+            self.multifactorbox.SetSelection(state.multi_factor)
+            
+         ## reset state of checkbox,textcrtl  and  regular parameters value
+        self._reset_parameters_state(self.orientation_params_disp,
+                                     state.orientation_params_disp)
+        self._reset_parameters_state(self.orientation_params,
+                                     state.orientation_params)
+        self._reset_parameters_state(self.str_parameters,
+                                     state.str_parameters)
+        self._reset_parameters_state(self.parameters,state.parameters)
+         ## display dispersion info layer        
+        self.enable_disp.SetValue(state.enable_disp)
+        self.disable_disp.SetValue(state.disable_disp)
+        
+        if hasattr(self, "disp_box"):
+            
+            self.disp_box.SetSelection(state.disp_box) 
+            n= self.disp_box.GetCurrentSelection()
+            dispersity= self.disp_box.GetClientData(n)
+            name = dispersity.__name__     
+
+            self._set_dipers_Param(event=None)
+       
+            if name == "ArrayDispersion":
+                
+                for item in self.disp_cb_dict.keys():
+                    
+                    if hasattr(self.disp_cb_dict[item], "SetValue") :
+                        self.disp_cb_dict[item].SetValue(\
+                                                    state.disp_cb_dict[item])
+                        # Create the dispersion objects
+                        from sans.models.dispersion_models import ArrayDispersion
+                        disp_model = ArrayDispersion()
+                        if hasattr(state,"values")and\
+                                 self.disp_cb_dict[item].GetValue() == True:
+                            if len(state.values)>0:
+                                self.values=state.values
+                                self.weights=state.weights
+                                disp_model.set_weights(self.values,
+                                                        state.weights)
+                            else:
+                                self._reset_dispersity()
+                        
+                        self._disp_obj_dict[item] = disp_model
+                        # Set the new model as the dispersion object 
+                        #for the selected parameter
+                        self.model.set_dispersion(item, disp_model)
+                    
+                        self.model._persistency_dict[item] = \
+                                                [state.values, state.weights]
+                    
+            else:
+                keys = self.model.getParamList()
+                for item in keys:
+                    if item in self.disp_list and \
+                        not self.model.details.has_key(item):
+                        self.model.details[item] = ["", None, None]
+                for k,v in self.state.disp_cb_dict.iteritems():
+                    self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
+                    self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
+         ## smearing info  restore
+        if hasattr(self, "enable_smearer"):
+            ## set smearing value whether or not the data 
+            #contain the smearing info
+            self.enable_smearer.SetValue(state.enable_smearer)
+            self.disable_smearer.SetValue(state.disable_smearer)
+            self.onSmear(event=None)           
+        self.pinhole_smearer.SetValue(state.pinhole_smearer)
+        self.slit_smearer.SetValue(state.slit_smearer)
+        ## we have two more options for smearing
+        if self.pinhole_smearer.GetValue(): self.onPinholeSmear(event=None)
+        elif self.slit_smearer.GetValue(): self.onSlitSmear(event=None)
+       
+        ## reset state of checkbox,textcrtl  and dispersity parameters value
+        self._reset_parameters_state(self.fittable_param,state.fittable_param)
+        self._reset_parameters_state(self.fixed_param,state.fixed_param)
+        
+        ## draw the model with previous parameters value
+        self._onparamEnter_helper()
+        self.select_param(event=None) 
+        #Save state_fit
+        self.save_current_state_fit()
+        self._lay_out()
+        self.Refresh()
+        
     def reset_page_helper(self, state):
         """

sansview/perspectives/fitting/fitpanel.py

@@ -101 +101 @@
             return selected_page.get_data()
     
+    def set_model_state(state):
+        """
+        receive a state to reset the model in the current page
+        """
+        pos = self.GetSelection()
+        if pos != -1:
+            selected_page = self.GetPage(pos)
+            selected_page.set_model_state(state)
+            
     def get_state(self):
         """

sansview/perspectives/fitting/fitproblem.py

@@ +1 @@
+import copy 
 
 class FitProblem:
@@ -32 +33 @@
         copy fitproblem
         """
-        import copy 
+        
         obj          = FitProblem()
         model= None
@@ -110 +111 @@
         
         """
-        self.theory_data = data
-        
-
+        self.theory_data = copy.deepcopy(data)
+      
     def get_theory_data(self):
         """

sansview/perspectives/fitting/fitting.py

@@ -17 +17 @@
 import logging
 import numpy
-#import math
 import string
 import time
-#import thread
 from copy import deepcopy
-
 import models
 import fitpage
@@ -36 +33 @@
 from sans.guiframe.gui_style import GUIFRAME_ID
 from sans.guiframe.plugin_base import PluginBase 
-
 
 from .console import ConsoleUpdate
@@ -256 +252 @@
         return True
     
-    def set_data(self, data_list=None, theory_list=None):
+    def set_data(self, data_list=None):
         """
         receive a list of data to fit
@@ -270 +266 @@
         else:
             selected_data_list = data_list
-        for data in selected_data_list:
-            self.add_fit_page(data=data)
-            wx.PostEvent(self.parent, NewPlotEvent(plot=data, 
-                                                   title=str(data.title)))
+        try:
+            for data in selected_data_list:
+                self.add_fit_page(data=data)
+                wx.PostEvent(self.parent, NewPlotEvent(plot=data, 
+                                                       title=str(data.title)))
+        except:
+            msg = "Fitting Set_data: " + str(sys.exc_value)
+            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
+            
+    def set_theory(self,  theory_list=None):
+        """
+        """
+        #set the model state for a given theory_state:
+        for item in theory_list:
+            try:
+                _, theory_state = item
+                self.fit_panel.set_model_state(theory_state)
+            except:
+                msg = "Fitting: cannot deal with the theory received"
+                logging.error("set_theory " + msg + "\n" + str(sys.exc_value))
+                wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
             
     def set_state(self, state=None, datainfo=None, format=None):
@@ -593 +606 @@
         if theory:
             id = data.id 
-        group_id = data.group_id[len(data.group_id)-1]
+        group_id = data.group_id
         wx.PostEvent(self.parent, NewPlotEvent(id=id,
                                                    group_id=group_id,
@@ -643 +656 @@
         #append Data1D to the panel containing its theory
         #if theory already plotted
-        
         if page.id in self.page_finder:
             theory_data = self.page_finder[page.id].get_theory_data()
-            
             if issubclass(data.__class__, Data2D):
-                data.group_id.append(wx.NewId())
+                data.group_id = wx.NewId()
                 if theory_data is not None:
                     group_id = str(page.id) + " Model1D"
-                    if group_id in theory_data.group_id:
-                        theory_data.group_id.remove(group_id)
                     wx.PostEvent(self.parent, 
                              NewPlotEvent(group_id=group_id,
@@ -660 +669 @@
                 if theory_data is not None:
                     group_id = str(page.id) + " Model2D"
-                    if group_id in theory_data.group_id:
-                        theory_data.group_id.remove(group_id)
-                    data_group_id = theory_data.group_id[len(theory_data.group_id)-1]
-                    if data_group_id not in data.group_id:
-                        data.group_id.append(data_group_id)
+                    data.group_id = theory_data.group_id
                     wx.PostEvent(self.parent, 
                              NewPlotEvent(group_id=group_id,
                                                action="delete"))
-                    self.parent.update_data(prev_data=theory_data, new_data=data)       
+                    self.parent.update_data(prev_data=theory_data, new_data=data)   
+              
         self.store_data(id=page.id, data=data, caption=page.window_name)
         if self.sim_page is not None:
@@ -725 +731 @@
                 if name !="Model":
                     data= fitproblem.get_fit_data()
-                    page = self.fit_panel.add_fit_page(data= data,reset=True)
+                    page = self.fit_panel.add_fit_page(data=data, reset=True)
                     if fitproblem != None:
                         self.page_finder[id] = fitproblem
@@ -1103 +1109 @@
         theory.ymin = ymin 
         theory.ymax = ymax 
-        group_id = str(id) + " Model2D"
-        if group_id not in theory.group_id:
-            theory.group_id.append(group_id)
+        theory.group_id = str(id) + " Model2D"
         theory.id = str(id) + " Model2D"
   
-                
     def _complete1D(self, x,y, id, elapsed,index,model,
                     toggle_mode_on=False,state=None, data=None):
@@ -1126 +1129 @@
                     theory_data = self.page_finder[id].get_theory_data()
                     if theory_data is not None:
-                        group_id = theory_data.group_id[len(theory_data.group_id)-1]
-                        if group_id not in data.group_id:
-                            data.group_id.append(group_id)
+                       data.group_id = theory_data.group_id
                 #data is plotted before the theory, then take its group_id
                 #assign to the new theory
-                group_id = data.group_id[len(data.group_id)-1]
-                if group_id not in new_plot.group_id:
-                    new_plot.group_id.append(group_id)
+                new_plot.group_id = data.group_id
                
             else:
@@ -1140 +1139 @@
                 new_plot.title = "Analytical model 1D "
                 #find a group id to plot theory without data
-                group_id =  str(id) + " Model1D"  
-                if group_id not in new_plot.group_id:
-                    new_plot.group_id.append(group_id)
+                new_plot.group_id =  str(id) + " Model1D"  
                 new_plot.is_data = False 
             new_plot.id =  str(id) + " Model1D"  
@@ -1161 +1158 @@
                              NewPlotEvent(group_id=str(id) + " Model2D",
                                                action="Hide"))
-                
+           
             self.page_finder[id].set_theory_data(new_plot)
+            theory_data = self.page_finder[id].get_theory_data()
             if data is None:
-                theory_data = self.page_finder[id].get_theory_data()
+                name = "Data generates by Fitting "
+                theory_data.name = name
                 self.parent.add_data_helper({theory_data.id:theory_data})
                 data_id = theory_data.id
@@ -1170 +1169 @@
                 data_id = data.id
            
-            self.parent.append_theory(data_id=data_id, 
-                                          theory=new_plot, state=state)
+            self.parent.update_theory(data_id=data_id, 
+                                       theory=theory_data,
+                                       state=state)     
             current_pg = self.fit_panel.get_page_by_id(id)
             title = new_plot.title
@@ -1218 +1218 @@
         else:
             new_plot.id = str(id) + " Model2D"
-            group_id = str(id) + " Model2D"
-            if group_id not in new_plot.group_id:
-                new_plot.group_id.append(group_id)
-         
+            new_plot.group_id = str(id) + " Model2D"
             new_plot.x_bins = data.x_bins
             new_plot.y_bins = data.y_bins
@@ -1247 +1244 @@
                              NewPlotEvent(group_id=str(id) + " Model1D",
                                                action="Hide"))
-        self.page_finder[id].set_theory_data(theory_data)
-        
+        
+        self.page_finder[id].set_theory_data(new_plot)
+        theory_data = self.page_finder[id].get_theory_data()
         if data is None:
-            theory_data = self.page_finder[id].get_theory_data()
+            name = "Data generates by Fitting "
+            theory_data.name = name
             self.parent.add_data_helper({theory_data.id:theory_data})
             data_id = theory_data.id
         else:
             data_id = data.id
-        
-        self.parent.append_theory(data_id=data_id, 
-                                          theory=new_plot, state=state)
+        self.parent.update_theory(data_id=data_id, 
+                                       theory=theory_data,
+                                       state=state)  
         current_pg = self.fit_panel.get_page_by_id(id)
         title = new_plot.title