Changeset 75fbd17 in sasview

Timestamp:

Feb 9, 2011 2:04:24 AM (13 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:

c83a5af

Parents:

8240eab

Message:

working on save state

Files:

• guiframe/data_manager.py (modified) (2 diffs)
• guiframe/gui_manager.py (modified) (12 diffs)
• guiframe/local_perspectives/data_loader/data_loader.py (modified) (8 diffs)
• guiframe/panel_base.py (modified) (1 diff)
• guiframe/plugin_base.py (modified) (4 diffs)
• invariantview/perspectives/invariant/invariant.py (modified) (6 diffs)
• invariantview/perspectives/invariant/invariant_state.py (modified) (5 diffs)
• prview/perspectives/pr/inversion_state.py (modified) (3 diffs)
• prview/perspectives/pr/pr.py (modified) (3 diffs)
• sansview/newone.svs (added)
• sansview/perspectives/fitting/fitting.py (modified) (10 diffs)
• sansview/perspectives/fitting/pagestate.py (modified) (2 diffs)
• sansview/sansview.py (modified) (1 diff)

guiframe/data_manager.py

@@ -17 +17 @@
 import logging
 from sans.guiframe.data_state import DataState
+from sans.guiframe.utils import parse_name
   
 class DataManager(object):
@@ -33 +34 @@
         self.stored_data = {}
         self.message = ""
+        self.data_name_dict = {}
       
+    def rename(self, name):
+        """
+        rename data
+        """
+        ## name of the data allow to differentiate data when plotted
+        name = parse_name(name=name, expression="_")
+        
+        max_char = name.find("[")
+        if max_char < 0:
+            max_char = len(name)
+        name = name[0:max_char]
+        
+        if name not in self.data_name_dict:
+            self.data_name_dict[name] = 0
+        else:
+            self.data_name_dict[name] += 1
+            name = name + " [" + str(self.data_name_dict[name]) + "]"
+        return name
+    
     def add_data(self, data_list):
         """

guiframe/gui_manager.py

@@ -47 +47 @@
 from sans.guiframe.panel_base import PanelBase
 from sans.guiframe.gui_toolbar import GUIToolBar
-
-STATE_FILE_EXT = ['.inv', '.fitv', '.prv']
-DATA_MANAGER = False
-AUTO_PLOT = False
-AUTO_SET_DATA = True
+from sans.guiframe.dataFitting import Data1D
+from sans.guiframe.dataFitting import Data2D
+from DataLoader.loader import Loader
+
+from DataLoader.loader import Loader
+import DataLoader.data_info as DataInfo
+
+
 PLOPANEL_WIDTH = 400
 PLOPANEL_HEIGTH = 400
@@ -57 +60 @@
 GUIFRAME_HEIGHT = 800
 PROG_SPLASH_SCREEN = "images/danse_logo.png" 
+EXTENSIONS =  ['.inv', '.fitv', '.prv', '.svs']
 
 class ViewerFrame(wx.Frame):
@@ -130 +134 @@
         #panel on focus
         self.panel_on_focus = None
+        self.loader = Loader()   
          #data manager
         from data_manager import DataManager
@@ -479 +484 @@
         return ID
         
-    def _populate_file_menu(self):
-        """
-        Insert menu item under file menu
-        """
-        for plugin in self.plugins:
-            if len(plugin.populate_file_menu()) > 0:
-                for item in plugin.populate_file_menu():
-                    id = wx.NewId()
-                    m_name, m_hint, m_handler = item
-                    self._file_menu.Append(id, m_name, m_hint)
-                    wx.EVT_MENU(self, id, m_handler)
-                self._file_menu.AppendSeparator()
-                
     def _setup_menus(self):
         """
@@ -723 +715 @@
         if style == GUIFRAME.DATALOADER_ON:
             # some menu of plugin to be seen under file menu
-            self._populate_file_menu()
+            hint_load_file = "Read state's files and load"
+            hint_load_file += " them into the application"
+            id = wx.NewId()
+            self._save_appl_menu = self._file_menu.Append(id, 
+                                    '&Open State from File', hint_load_file)
+            wx.EVT_MENU(self, id, self._on_open_state)
             id = wx.NewId()
             self._save_appl_menu = self._file_menu.Append(id, 
@@ -786 +783 @@
         self.enable_edit_menu()
         
+    def get_style(self):
+        """
+        """
+        return  self.__gui_style
+    
     def _add_menu_data(self):
         """
         Add menu item item data to menu bar
         """
-        # Add menu data 
-        self._data_menu = wx.Menu()
-        #menu for data files
-        data_file_id = wx.NewId()
-        data_file_hint = "load one or more data in the application"
-        self._data_menu.Append(data_file_id, 
-                         '&Load Data File(s)', data_file_hint)
-        wx.EVT_MENU(self, data_file_id, self._load_data)
-        style = self.__gui_style & GUIFRAME.MULTIPLE_APPLICATIONS
-        style1 = self.__gui_style & GUIFRAME.DATALOADER_ON
-        if style == GUIFRAME.MULTIPLE_APPLICATIONS:
-            #menu for data from folder
-            data_folder_id = wx.NewId()
-            data_folder_hint = "load multiple data in the application"
-            self._data_menu.Append(data_folder_id, 
-                             '&Load Data Folder', data_folder_hint)
-            wx.EVT_MENU(self, data_folder_id, self._load_folder)
-            self._menubar.Append(self._data_menu, '&Data')
-        elif style1 == GUIFRAME.DATALOADER_ON:
-            self._menubar.Append(self._data_menu, '&Data')
-        
-    def _load_data(self, event):
-        """
-        connect menu item load data with the first plugin that can load data
-        """
-        for plug in self.plugins:
-            if plug.can_load_data():
-                plug.load_data(event)
-        style = self.__gui_style & GUIFRAME.MANAGER_ON
-        if style == GUIFRAME.MANAGER_ON:
-            self.show_data_panel(event=None)
-        
-    def _load_folder(self, event):
-        """
-        connect menu item load data with the first plugin that can load data and
-        folder
-        """
-        for plug in self.plugins:
-            if plug.can_load_data():
-                plug.load_folder(event)
-        style = self.__gui_style & GUIFRAME.MANAGER_ON
-        if style == GUIFRAME.MANAGER_ON:
-            self.show_data_panel(event=None)
-                
+        if self._data_plugin is not None:
+            menu_list = self._data_plugin.populate_menu(self)
+            if menu_list:
+                for (menu, name) in menu_list:
+                    self._menubar.Append(menu, name)
+            
     def _on_hide_toolbar(self, event=None):
         """
@@ -911 +875 @@
                 self._mgr.GetPane(self.panels["default"].window_name).Hide()
             self._mgr.Update()
-   
-    def _on_open(self, event):
-        """
-        """
-        path = self.choose_file()
-        if path is None:
+    
+    def clear_panel(self):
+        """
+        """
+        for item in self.panels:
+            try:
+                self.panels[item].clear_panel()
+            except:
+                pass
+            
+    def create_gui_data(self, data, path=None):
+        """
+        Receive data from loader and create a data to use for guiframe
+        """
+        
+        if issubclass(DataInfo.Data2D, data.__class__):
+            new_plot = Data2D(image=None, err_image=None) 
+        else: 
+            new_plot = Data1D(x=[], y=[], dx=None, dy=None)
+           
+        new_plot.copy_from_datainfo(data) 
+        data.clone_without_data(clone=new_plot)  
+        #creating a name for data
+        name = ""
+        title = ""
+        file_name = ""
+        if path is not None:
+            file_name = os.path.basename(path)
+        if data.run:
+            name = data.run[0]
+        if name == "":
+            name = file_name
+        name = self._data_manager.rename(name)
+        #find title
+        if data.title.strip():
+            title = data.title
+        if title.strip() == "":
+            title = file_name
+        
+        if new_plot.filename.strip() == "":
+            new_plot.filename = file_name
+        
+        new_plot.name = name
+        new_plot.title = title
+        ## allow to highlight data when plotted
+        new_plot.interactive = True
+        ## when 2 data have the same id override the 1 st plotted
+        new_plot.id = name
+        ##group_id specify on which panel to plot this data
+        new_plot.group_id = name
+        new_plot.is_data = True
+        new_plot.path = path
+        ##post data to plot
+        # plot data
+        return new_plot
+ 
+    def get_data(self, path, format=None):
+        """
+        """
+        message = ""
+        log_msg = ''
+        output = []
+        error_message = ""
+        basename  = os.path.basename(path)
+        root, extension = os.path.splitext(basename)
+        if extension.lower() not in EXTENSIONS:
+            log_msg = "File Loader cannot "
+            log_msg += "load: %s\n" % str(basename)
+            log_msg += "Try Data opening...."
+            logging.info(log_msg)
+            self.load_complete(output=output, error_message=error_message,
+                   message=log_msg, path=path)    
             return
-
+        try:
+            temp =  self.loader.load(path, extension)
+            if temp.__class__.__name__ == "list":
+                for item in temp:
+                    data = self.create_gui_data(item, path)
+                    output.append(data)
+            else:
+                data = self.create_gui_data(temp, path)
+                output.append(data)
+            message = "Loading File..." + str(basename) + "\n"
+            self.load_update(output=output, message=message)
+        except:
+            raise
+            error_message = "Error while loading: %s\n" % str(p_file)
+            error_message += str(sys.exc_value) + "\n"
+            self.load_update(output=output, message=error_message)
+            
+        message = "Loading Complete! "
+        self.load_complete(output=output, error_message=error_message,
+                   message=message, path=path, extension=extension)    
+        
+    def load_update(self, output=None, message=""):
+        """
+        print update on the status bar
+        """
+        if message != "":
+            wx.PostEvent(self, StatusEvent(status=message,
+                                                  type="progress",
+                                                   info="warning"))
+        
+    def load_complete(self, output, message="", error_message="", 
+                      extension=None, path=None):
+        """
+         post message to  status bar and return list of data
+        """
+        wx.PostEvent(self, StatusEvent(status=message,
+                                              info="warning",
+                                              type="stop"))
+        if error_message != "":
+            self.load_error(error_message)
+        #send a list of available data to plotting plugin
+        available_data = []
+        if self._data_manager is not None:
+            self._data_manager.add_data(output)
+            temp = self._data_manager.get_selected_data()
+            for data_state in temp.values():
+                available_data.append(data_state.data)
+        #reading a state file
+        for plug in self.plugins:
+            #plug.on_set_state_helper(event=None)
+            _, ext = plug.get_extensions()
+            if extension == ext:
+                plug.set_state(state=None, datainfo=available_data)
+            elif extension == '.svs':
+                plug.set_state(state=None, datainfo=available_data)
+                
+        style = self.__gui_style & GUIFRAME.MANAGER_ON
+        if style == GUIFRAME.MANAGER_ON:
+            if self._data_panel is not None:
+                data_state = self._data_manager.get_selected_data()
+                self._data_panel.load_data_list(data_state)
+                self._mgr.GetPane(self._data_panel.window_name).Show(True)
+        
+    def _on_open_state(self, event):
+        """
+        """
+        path = None
+        if self._default_save_location == None:
+            self._default_save_location = os.getcwd()
+ 
+        wlist = ['SansView files (*.svs)|*.svs',
+                  'P(r) files (*.prv)|*.prv',
+                  'Fitting files (*.fitv)|*.fitv',
+                  'Invariant files (*.inv)|*.inv']
+        wlist = '|'.join(wlist)
+        dlg = wx.FileDialog(self, 
+                            "Choose a file", 
+                            self._default_save_location, "",
+                             wlist)
+        if dlg.ShowModal() == wx.ID_OK:
+            path = dlg.GetPath()
+            if path is not None:
+                self._default_save_location = os.path.dirname(path)
+        dlg.Destroy()
         if path and os.path.isfile(path):
             basename  = os.path.basename(path)
@@ -928 +1041 @@
                     except:
                         pass
-                #reset states and plot data 
-                for item in STATE_FILE_EXT:
-                    exec "plot_data(self, path,'%s')" % str(item)
-            else:
-                plot_data(self, path)
+            self.get_data(path)
+                
         if self.defaultPanel is not None and \
             self._mgr.GetPane(self.panels["default"].window_name).IsShown():
             self.on_close_welcome_panel()
-            
+    
     def _on_save_application(self, event):
         """
@@ -954 +1064 @@
         reader, ext = self._current_perspective.get_extensions()
         path = None
-        dlg = wx.FileDialog(self, "Choose a file",
+        dlg = wx.FileDialog(self, "Save Project file",
                             self._default_save_location, "", '.svs', wx.SAVE)
         if dlg.ShowModal() == wx.ID_OK:
@@ -1144 +1254 @@
         show the data panel
         """
-        pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
-        #if not pane.IsShown():
-        pane.Show(True)
-        self._mgr.Update()
-  
-    def add_data(self, data_list, flag=False):
+        style = self.__gui_style & GUIFRAME.MANAGER_ON
+        if style == GUIFRAME.MANAGER_ON:
+            pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
+            #if not pane.IsShown():
+            pane.Show(True)
+            self._mgr.Update()
+ 
+    def add_data(self, data_list):
         """
         receive a list of data . store them its data manager if possible
@@ -1159 +1271 @@
             self._data_manager.add_data(data_list)
             avalaible_data = self._data_manager.get_all_data()
-            
-        if True:
-            #reading a state file
-            for plug in self.plugins:
-                plug.on_set_state_helper(event=None)
+
         style = self.__gui_style & GUIFRAME.MANAGER_ON
         if style == GUIFRAME.MANAGER_ON:
@@ -1259 +1367 @@
         set the current active perspective 
         """
-        
+        print "set_current_perspective", perspective
         self._current_perspective = perspective
         name = "No current Application selected"

guiframe/local_perspectives/data_loader/data_loader.py

@@ -16 +16 @@
 from sans.guiframe.dataFitting import Data2D
 from sans.guiframe.utils import parse_name
+from sans.guiframe.gui_style import GUIFRAME
 
-STATE_FILE_EXT = ['SansView files (*.svs)|*.svs',
-                  'P(r) files (*.prv)|*.prv',
-                  'Fitting files (*.fitv)|*.fitv',
-                  'Invariant files (*.inv)|*.inv']
 EXTENSIONS = ['.svs', '.prv','.fitv', '.inv']
 
@@ -30 +27 @@
         self._default_save_location = None  
         self.data_name_dict = {}
-        self.loader = Loader()   
+        self.loader = Loader()  
+        self._data_menu = None 
         
-    def populate_file_menu(self):
+    def populate_menu(self, parent):
         """
-        get a menu item and append it under file menu of the application
-        add load file menu item and load folder item
         """
-        
-        hint_load_file = "Read state's files and load them into the application"
-        return [["Open State from File", hint_load_file, self.load_file]]
-  
-    def load_data(self, event):
+         # Add menu data 
+        self._data_menu = wx.Menu()
+        #menu for data files
+        data_file_id = wx.NewId()
+        data_file_hint = "load one or more data in the application"
+        self._data_menu.Append(data_file_id, 
+                         '&Load Data File(s)', data_file_hint)
+        wx.EVT_MENU(self.parent, data_file_id, self._load_data)
+        gui_style = self.parent.get_style()
+        style = gui_style & GUIFRAME.MULTIPLE_APPLICATIONS
+        style1 = gui_style & GUIFRAME.DATALOADER_ON
+        if style == GUIFRAME.MULTIPLE_APPLICATIONS:
+            #menu for data from folder
+            data_folder_id = wx.NewId()
+            data_folder_hint = "load multiple data in the application"
+            self._data_menu.Append(data_folder_id, 
+                             '&Load Data Folder', data_folder_hint)
+            wx.EVT_MENU(self.parent, data_folder_id, self._load_folder)
+            
+        return [(self._data_menu, 'Data')]
+
+    def _load_data(self, event):
         """
         Load data
         """
-        flag = True
-        file_list = self.choose_data_file(flag)
+        if self._default_save_location == None:
+            self._default_save_location = os.getcwd()
+        
+        cards = self.loader.get_wildcards()
+        wlist =  '|'.join(cards)
+        style = wx.OPEN|wx.FD_MULTIPLE
+        dlg = wx.FileDialog(self.parent, 
+                            "Choose a file", 
+                            self._default_save_location, "",
+                             wlist,
+                             style=style)
+        if dlg.ShowModal() == wx.ID_OK:
+            file_list = dlg.GetPaths()
+            if len(file_list) >= 0 and not(file_list[0]is None):
+                self._default_save_location = os.path.dirname(file_list[0])
+        dlg.Destroy()
+        
         if not file_list or file_list[0] is None:
             return
-        self.get_data(file_list, flag=flag)
+        self.get_data(file_list)
+        self.parent.show_data_panel(event=None)
         
     def can_load_data(self):
@@ -56 +85 @@
         """
         return True
-    
-    def load_file(self, event):
-        """
-        Load  sansview defined files
-        """
-        flag = False
-        file_list = self.choose_data_file(flag)
-        if not file_list or file_list[0] is None:
-            return
-        self.get_state(file_list)
+ 
        
-    def load_folder(self, event):
+    def _load_folder(self, event):
         """
         Load entire folder
         """
-        flag = True
-        path = self.choose_data_folder(flag)
-        if path is None:
-            return
-        file_list = self.get_file_path(path)
-        self.get_data(file_list, flag=flag)
-       
-    def get_wild_card(self, flag=True):
-        """
-        :param flag: is True load only data file, else load state file
-         return wild cards
-        """
-        if flag:
-            cards = self.loader.get_wildcards()
-            for item in STATE_FILE_EXT:
-                if item in cards:
-                    cards.remove(item)
-        else:
-            cards = STATE_FILE_EXT
-        return '|'.join(cards)
-        
-        
-    def choose_data_file(self, flag=True):
-        """
-        Open the file dialog to load file(s)
-        """
-        path = None
         if self._default_save_location == None:
             self._default_save_location = os.getcwd()
-        
-        cards = self.loader.get_wildcards()
-        wlist = self.get_wild_card(flag)
-        if flag:
-            style = wx.OPEN|wx.FD_MULTIPLE
-        else:
-            style = wx.OPEN|wx.FD_DEFAULT_STYLE
-            
-        dlg = wx.FileDialog(self.parent, 
-                            "Choose a file", 
-                            self._default_save_location, "",
-                             wlist,
-                             style=style)
-        if dlg.ShowModal() == wx.ID_OK:
-            path = dlg.GetPaths()
-            if len(path) >= 0 and not(path[0]is None):
-                self._default_save_location = os.path.dirname(path[0])
-        dlg.Destroy()
-        return path
-    
-    def choose_data_folder(self, flag=True):
-        """
-        :param flag: is True load only data file, else load state file
-        return a list of folder to read
-        """
-        path = None
-        if self._default_save_location == None:
-            self._default_save_location = os.getcwd()
-        
-        wlist = self.get_wild_card(flag)
-        
         dlg = wx.DirDialog(self.parent, "Choose a directory", 
                            self._default_save_location,
@@ -138 +100 @@
             self._default_save_location = path
         dlg.Destroy()
-        return path
-    
+        if path is not None:
+            self._default_save_location = os.path.dirname(path)
+        else:
+            return    
+        file_list = self.get_file_path(path)
+        self.get_data(file_list)
+        self.parent.show_data_panel(event=None)
+   
+   
     def load_error(self, error=None):
         """
@@ -164 +133 @@
             return [os.path.join(os.path.abspath(path),
                                   file) for file in os.listdir(path)]
-    
-    def get_state(self, path, format=None):
-        """
-        read state
-        """
-        output = []
-        for p_file in path:
-            basename  = os.path.basename(p_file)
-            root, extension = os.path.splitext(basename)
-            for extension in EXTENSIONS:
-                temp = self.loader.load(p_file, extension)
-                if temp.__class__.__name__ == "list":
-                    for item in temp:
-                        data = self.create_data(item, p_file)
-                else:
-                    data = self.create_data(temp, p_file)
-                output.append(data)
-            self.load_complete(output=output, path=path)
-                   
-    def get_data(self, path, format=None, flag=True):
+   
+    def get_data(self, path, format=None):
         """
         """
@@ -193 +144 @@
             basename  = os.path.basename(p_file)
             root, extension = os.path.splitext(basename)
-            if flag:
-                if extension.lower() in EXTENSIONS:
-                    log_msg = "Data Loader cannot "
-                    log_msg += "load: %s\n" % str(p_file)
-                    log_msg += "Try File -> open ...."
-                    logging.info(log_msg)
-                    continue
-            else:
-                if extension.lower() not in EXTENSIONS:
-                    log_msg = "File Loader cannot"
-                    log_msg += " load: %s\n" % str(p_file)
-                    log_msg += "Try Data -> Load ...."
-                    logging.info(log_msg)
-                    continue
+            if extension.lower() in EXTENSIONS:
+                log_msg = "Data Loader cannot "
+                log_msg += "load: %s\n" % str(p_file)
+                log_msg += "Try File opening ...."
+                logging.info(log_msg)
+                continue
+        
             try:
                 temp =  self.loader.load(p_file, format)
                 if temp.__class__.__name__ == "list":
-                    print "list", temp
                     for item in temp:
-                        data = self.create_data(item, p_file)
+                        data = self.parent.create_gui_data(item, p_file)
                         output.append(data)
                 else:
-                    print "not list", [temp]
-                    data = self.create_data(temp, p_file)
+                    data = self.parent.create_gui_data(temp, p_file)
                     output.append(data)
-                message = "Loading ..." + str(p_file) + "\n"
+                message = "Loading Data..." + str(p_file) + "\n"
                 self.load_update(output=output, message=message)
             except:
-                raise
-                error_message = "Error while loading: %s\n" % str(p_file)
+                error_message = "Error while loading Data: %s\n" % str(p_file)
                 error_message += str(sys.exc_value) + "\n"
                 self.load_update(output=output, message=error_message)
                 
-        message = "Loading Complete! "
+        message = "Loading Data Complete! "
         message += log_msg
         self.load_complete(output=output, error_message=error_message,
-                       message=message, path=path, flag=flag)
+                       message=message, path=path)
             
-   
     def load_update(self, output=None, message=""):
         """
@@ -240 +180 @@
                                                   type="progress",
                                                    info="warning"))
-        
-    def load_complete(self, output, message="", error_message="", 
-                      path=None, flag=True):
+    def load_complete(self, output, message="", error_message="", path=None):
         """
          post message to  status bar and return list of data
@@ -251 +189 @@
         if error_message != "":
             self.load_error(error_message)
-        self.parent.add_data(output, flag=flag)
+        self.parent.add_data(output)
+   
+    
         
-    def create_data(self, data, path):
-        """
-        Receive data from loader and create a data to use for guiframe
-        """
-        
-        if issubclass(DataInfo.Data2D, data.__class__):
-            new_plot = Data2D(image=None, err_image=None) 
-        else: 
-            new_plot = Data1D(x=[], y=[], dx=None, dy=None)
-           
-        new_plot.copy_from_datainfo(data) 
-        data.clone_without_data(clone=new_plot)  
-        #creating a name for data
-        name = ""
-        title = ""
-        file_name = ""
-        if path is not None:
-            file_name = os.path.basename(path)
-        if data.run:
-            name = data.run[0]
-        if name == "":
-            name = file_name
-        ## name of the data allow to differentiate data when plotted
-        name = parse_name(name=name, expression="_")
-        
-        max_char = name.find("[")
-        if max_char < 0:
-            max_char = len(name)
-        name = name[0:max_char]
-        
-        if name not in self.data_name_dict:
-            self.data_name_dict[name] = 0
-        else:
-            self.data_name_dict[name] += 1
-            name = name + " [" + str(self.data_name_dict[name]) + "]"
-        #find title
-        if data.title.strip():
-            title = data.title
-        if title.strip() == "":
-            title = file_name
-        
-        if new_plot.filename.strip() == "":
-            new_plot.filename = file_name
-        
-        new_plot.name = name
-        new_plot.title = title
-        ## allow to highlight data when plotted
-        new_plot.interactive = True
-        ## when 2 data have the same id override the 1 st plotted
-        new_plot.id = name
-        ##group_id specify on which panel to plot this data
-        new_plot.group_id = name
-        new_plot.is_data = True
-        new_plot.path = path
-        ##post data to plot
-        # plot data
-        return new_plot
-        
-       
+   

guiframe/panel_base.py

@@ -24 +24 @@
     #window_caption = "Welcome panel"
     ## Flag to tell the AUI manager to put this panel in the center pane
-    #CENTER_PANE = True
+    group_id = None
     
     def __init__(self, parent=None):

guiframe/plugin_base.py

@@ -94 +94 @@
         """
         return self._always_active
-    
-    def populate_file_menu(self):
-        """
-        get a menu item and append it under file menu of the application
-        return [[menu item name, menu_hint, menu handler]]
-        """
-        return []
-        
+
     def populate_menu(self, parent):
         """
@@ -133 +126 @@
         # Return the list of panels
         return []
+    
+    def clear_panel(self):
+        """
+        reset all panels
+        """
     
     def get_tools(self):
@@ -171 +169 @@
         return self.perspective
     
-    def on_perspective(self, event):
+    def on_perspective(self, event=None):
         """
         Call back function for the perspective menu item.
@@ -200 +198 @@
         return False
     
+    def set_state(self, state=None, datainfo=None):    
+        """
+        update state
+        """
     def set_data(self, data_list):
         """

invariantview/perspectives/invariant/invariant.py

@@ -27 +27 @@
 from DataLoader.loader import Loader
 from .invariant_panel import InvariantPanel
-from sans.guiframe.events import EVT_INVSTATE_UPDATE
+#from sans.guiframe.events import EVT_INVSTATE_UPDATE
 
 from sans.guiframe.plugin_base import PluginBase
@@ -82 +82 @@
         #add error back to the data
         self.parent.Bind(ERR_DATA, self._on_data_error)
-        self.parent.Bind(EVT_INVSTATE_UPDATE, self.on_set_state_helper)
+        #self.parent.Bind(EVT_INVSTATE_UPDATE, self.on_set_state_helper)
         
         self.invariant_panel = InvariantPanel(parent=self.parent)
@@ -195 +195 @@
                 data = dlg.get_data()
                 if issubclass(data.__class__, LoaderData1D):
-                    self.compute_helper(data_list[0])
                     wx.PostEvent(self.parent, NewPlotEvent(plot=data_list[0],
                                                title=data_list[0].title))
+                    self.compute_helper(data_list[0])
                 else:    
                     msg = "invariant cannot be computed for data of "
@@ -205 +205 @@
         elif len(data_list) == 1:
             if issubclass(data_list[0].__class__, LoaderData1D):
-                self.compute_helper(data_list[0])
                 wx.PostEvent(self.parent, NewPlotEvent(plot=data_list[0],
                                                title=data_list[0].title))
+                self.compute_helper(data_list[0])
             else:
                 msg = "invariant cannot be computed for"
@@ -245 +245 @@
             raise RuntimeError, msg
 
-    def set_state(self, state, datainfo=None):    
+    def set_state(self, state=None, datainfo=None):    
         """
         Call-back method for the state reader.
@@ -254 +254 @@
         self.temp_state = None
         try:
-            
-            if datainfo is None:
+            if datainfo.__class__.__name__ == 'list':
+                data = datainfo[0]
+            if data is None:
                 msg = "invariant.set_state: datainfo parameter cannot"
                 msg += " be None in standalone mode"
                 raise RuntimeError, msg
             
-            name = datainfo.meta_data['invstate'].file
-            datainfo.meta_data['invstate'].file = name
-            datainfo.name = name
-            datainfo.filename = name
-            self.__data = datainfo
-            self.__data.group_id = datainfo.filename
-            self.__data.id = datainfo.filename
-
-            temp_state = copy.deepcopy(state)
+            name = data.meta_data['invstate'].file
+            data.meta_data['invstate'].file = name
+            data.name = name
+            data.filename = name
+            #datainfo = self.parent.create_gui_data(datainfo,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,
+                                        reset=True, title=self.__data.title))
+            #temp_state = copy.deepcopy(state)
+            temp_state = self.state_reader.get_state()
             # set state
             self.invariant_panel.is_state_data = True
             
             # Make sure the user sees the invariant panel after loading
-            self.parent.set_perspective(self.perspective)
+            #self.parent.set_perspective(self.perspective)
+            self.on_perspective(event=None)
             # Load the invariant states
             self.temp_state = temp_state
-            #self.invariant_panel.set_state(state=temp_state,data=self.__data)         
-            
-        except:
+            self.invariant_panel.set_state(state=temp_state,data=self.__data)         
+           
+        except: 
             logging.error("invariant.set_state: %s" % sys.exc_value)
             

invariantview/perspectives/invariant/invariant_state.py

@@ -2 +2 @@
 """
 
-import time
+#import time
 import os
 import sys
@@ -252 +252 @@
         """
         from xml.dom.minidom import getDOMImplementation
+        import time
         timestamp = time.time()
         # Check whether we have to write a standalone XML file
@@ -319 +320 @@
         for name, value_list in self.bookmark_list.iteritems():
             element = newdoc.createElement('mark_'+ str(name))
-            _,date,state,comp_state = value_list
+            time,date,state,comp_state = value_list
             time_element = newdoc.createElement('time')
             time_element.appendChild(newdoc.createTextNode(str(value_list[0])))
@@ -643 +644 @@
         ## CanSAS format flag
         self.cansas = cansas
+        self.state = None
 
     def read(self, path):
@@ -742 +744 @@
         elif len(output) == 1:
             # Call back to post the new state
-
-            self.call_back(state=output[0].meta_data['invstate'],
-                           datainfo = output[0])
+            self.state = output[0].meta_data['invstate']
+            #self.call_back(state=output[0].meta_data['invstate'],
+            #               datainfo = output[0])
             return output[0]
         else:
             return output                
     
+    def get_state(self):
+        return self.state
     
     def write(self, filename, datainfo=None, invstate=None):

prview/perspectives/pr/inversion_state.py

@@ -374 +374 @@
         ## CanSAS format flag
         self.cansas = cansas
+        self.state = None
         
     def read(self, path):
@@ -404 +405 @@
         
         # Call back to post the new state
-        self.call_back(state)
+        self.state = state
+        #self.call_back(state)
         return None
     
+    def get_state(self):
+        return self.state
     def _parse_prstate(self, entry):
         """
@@ -482 +486 @@
         elif len(output) == 1:
             # Call back to post the new state
-            self.call_back(output[0].meta_data['prstate'], datainfo = output[0])
+            #self.call_back(output[0].meta_data['prstate'], datainfo = output[0])
+            self.state = output[0].meta_data['prstate']
             return output[0]
         else:

prview/perspectives/pr/pr.py

@@ -121 +121 @@
         return self.current_plottable
     
-    def set_state(self, state, datainfo=None):
+    def set_state(self, state=None, datainfo=None):
         """
         Call-back method for the inversion state reader.
@@ -131 +131 @@
         """
         try:
-            if datainfo is None:
+            if datainfo.__class__.__name__ == 'list':
+                if len(datainfo) == 1:
+                    data = datainfo[0]
+            if data is None:
                 raise RuntimeError, "Pr.set_state: datainfo parameter cannot be None in standalone mode"
-
+            """
             # Ensuring that plots are coordinated correctly
-            t = time.localtime(datainfo.meta_data['prstate'].timestamp)
+            t = time.localtime(data.meta_data['prstate'].timestamp)
             time_str = time.strftime("%b %d %H:%M", t)
             
             # Check that no time stamp is already appended
-            max_char = datainfo.meta_data['prstate'].file.find("[")
+            max_char = data.meta_data['prstate'].file.find("[")
             if max_char < 0:
-                max_char = len(datainfo.meta_data['prstate'].file)
-            
-            datainfo.meta_data['prstate'].file = datainfo.meta_data['prstate'].file[0:max_char] +' [' + time_str + ']'
-            datainfo.filename = datainfo.meta_data['prstate'].file
-                
-            self.current_plottable = datainfo
-            self.current_plottable.group_id = datainfo.meta_data['prstate'].file
+                max_char = len(data.meta_data['prstate'].file)
+            
+            data.meta_data['prstate'].file = data.meta_data['prstate'].file[0:max_char] +' [' + time_str + ']'
+            data.filename = data.meta_data['prstate'].file
+             """   
+            self.current_plottable = data
+            # self.current_plottable.group_id = data.meta_data['prstate'].file
+            
+            # Make sure the user sees the P(r) panel after loading
+            #self.parent.set_perspective(self.perspective)  
+            self.on_perspective(event=None)   
             
             # Load the P(r) results
+            state = self.state_reader.get_state()
+            wx.PostEvent(self.parent, NewPlotEvent(plot=self.current_plottable,
+                                        title=self.current_plottable.title))
             self.control_panel.set_state(state)
-                        
-            # Make sure the user sees the P(r) panel after loading
-            self.parent.set_perspective(self.perspective)            
-
         except:
-            logging.error("prview.set_state: %s" % sys.exc_value)
+            raise
+            #logging.error("prview.set_state: %s" % sys.exc_value)
 
   
@@ -391 +398 @@
         new_plot.title = "P(r) fit"
         # Make sure that the plot is linear
-        new_plot.xtransform="x"
-        new_plot.ytransform="y"                 
+        new_plot.xtransform = "x"
+        new_plot.ytransform = "y"                 
         wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title="P(r) fit"))
         

sansview/perspectives/fitting/fitting.py

@@ -131 +131 @@
         #Menu for fitting
         self.menu1 = wx.Menu()
-           #menu for model
-        menu2 = wx.Menu()
-        self.menu_mng.populate_menu(menu2, owner)
-        id2 = wx.NewId()
-        owner.Bind(models.EVT_MODEL,self._on_model_menu)
+        
         #Set park engine
         id3 = wx.NewId()
@@ -156 +152 @@
         wx.EVT_MENU(owner, id1, self.on_add_sim_page)
        
+        #menu for model
+        menu2 = wx.Menu()
+        self.menu_mng.populate_menu(menu2, owner)
+        id2 = wx.NewId()
+        owner.Bind(models.EVT_MODEL,self._on_model_menu)
+      
         self.fit_panel.set_owner(owner)
         self.fit_panel.set_model_list(self.menu_mng.get_model_list())
@@ -231 +233 @@
         """
         self.parent = parent
-        self.parent.Bind(EVT_FITSTATE_UPDATE, self.on_set_state_helper)
+        #self.parent.Bind(EVT_FITSTATE_UPDATE, self.on_set_state_helper)
         # Creation of the fit panel
         self.fit_panel = FitPanel(self.parent, -1)
@@ -251 +253 @@
         #Create reader when fitting panel are created
         self.state_reader = Reader(self.set_state)   
-       
         #append that reader to list of available reader 
         loader = Loader()
         loader.associate_file_reader(".fitv", self.state_reader)
         loader.associate_file_reader(".svs", self.state_reader)
+        from sans.perspectives.calculator.sld_panel import SldPanel
         #Send the fitting panel to guiframe
         self.mypanels.append(self.fit_panel) 
-      
+        self.mypanels.append(SldPanel(parent=self.parent, base=self.parent))
         return self.mypanels
     
@@ -286 +288 @@
             wx.PostEvent(self.parent, NewPlotEvent(plot=data, 
                                                    title=str(data.title)))
-   
             
     def set_state(self, state=None, datainfo=None, format=None):
@@ -296 +297 @@
         : param datainfo: data
         """
+        state = self.state_reader.get_state()
         if state != None:
             # store fitting state in temp_state
@@ -305 +307 @@
         # state file format
         self.sfile_ext = format
-
-    def on_set_state_helper(self,event=None):
+        
+        self.on_set_state_helper(event=None)
+
+    def  on_set_state_helper(self,event=None):
         """
         Set_state_helper. This actually sets state after plotting data from state file.
@@ -325 +329 @@
             if state.formfactorcombobox != None:
                 #set state
+                data = self.parent.create_gui_data(state.data)
+                data.group_id = state.data.group_id
+                wx.PostEvent(self.parent, NewPlotEvent(plot=data,
+                                        title=data.title))
                 page = self.fit_panel.set_state(state)   
             else:
+                wx.PostEvent(self.parent, NewPlotEvent(plot=data,
+                                        title=data.title))
                 #just set data because set_state won't work
-                page_info = self.fit_panel.get_page_info(data=state.data)
+                data = self.parent.create_gui_data(state.data)
+                data.group_id = state.data.group_id
+                page_info = self.fit_panel.get_page_info(data=data)
                 panel = self.fit_panel.add_page(page_info)
-                self.store_page(page=panel, data=state.data)
+                self.store_page(page=panel, data=data)
                 self.mypanels.append(panel) 
                 
+               
             # get ready for the next set_state
             self.state_index += 1
@@ -342 +355 @@
                 #self.state_index = 0
                 # Make sure the user sees the fitting panel after loading
-                self.parent.set_perspective(self.perspective) 
+                #self.parent.set_perspective(self.perspective) 
+                self.on_perspective(event=None)
         except:
             self.state_index==0
@@ -1382 +1396 @@
                 return
             x = data.x
-            
-            if qmin == None :
-                qmin == DEFAULT_QMIN
-
-            if qmax == None:
-                qmax == DEFAULT_QMAX 
-                
+            if qmin == DEFAULT_QMIN :
+                qmin = min(data.x)
+            if qmax == DEFAULT_QMAX:
+                qmax = max(data.x) 
         if not enable1D:
             return 

sansview/perspectives/fitting/pagestate.py

@@ -631 +631 @@
         ## CanSAS format flag
         self.cansas = cansas
+        self.state = None
+    def get_state(self):
+        return self.state
         
     def read(self, path):
@@ -1170 +1173 @@
                     state.data.group_id = name
                     #store state in fitting
-                    self.call_back(state=state, datainfo=output[ind],format=ext)
+                    #self.call_back(state=state, datainfo=output[ind],format=ext)
+                    self.state= state
                 return output
               
         except:
-            self.call_back(format=ext)
+            #self.call_back(format=ext)
+            self.state= state
             raise
            

sansview/sansview.py

@@ -64 +64 @@
             self.gui.add_perspective(pr_plug)
         except:
-            logging.error("SansView: could not find P(r) plug-in module") 
-            logging.error(sys.exc_value)  
+            raise
+            #logging.error("SansView: could not find P(r) plug-in module") 
+            #logging.error(sys.exc_value)  
         
         #Invariant perspective