Changeset 75fbd17 in sasview for guiframe


Ignore:
Timestamp:
Feb 9, 2011 2:04:24 AM (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:
c83a5af
Parents:
8240eab
Message:

working on save state

Location:
guiframe
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • guiframe/data_manager.py

    r6db811e r75fbd17  
    1717import logging 
    1818from sans.guiframe.data_state import DataState 
     19from sans.guiframe.utils import parse_name 
    1920   
    2021class DataManager(object): 
    … …  
    3334        self.stored_data = {} 
    3435        self.message = "" 
     36        self.data_name_dict = {} 
    3537       
     38    def rename(self, name): 
     39        """ 
     40        rename data 
     41        """ 
     42        ## name of the data allow to differentiate data when plotted 
     43        name = parse_name(name=name, expression="_") 
     44         
     45        max_char = name.find("[") 
     46        if max_char < 0: 
     47            max_char = len(name) 
     48        name = name[0:max_char] 
     49         
     50        if name not in self.data_name_dict: 
     51            self.data_name_dict[name] = 0 
     52        else: 
     53            self.data_name_dict[name] += 1 
     54            name = name + " [" + str(self.data_name_dict[name]) + "]" 
     55        return name 
     56     
    3657    def add_data(self, data_list): 
    3758        """ 

  • guiframe/gui_manager.py

    r1b3a5a9 r75fbd17  
    4747from sans.guiframe.panel_base import PanelBase 
    4848from sans.guiframe.gui_toolbar import GUIToolBar 
    49  
    50 STATE_FILE_EXT = ['.inv', '.fitv', '.prv'] 
    51 DATA_MANAGER = False 
    52 AUTO_PLOT = False 
    53 AUTO_SET_DATA = True 
     49from sans.guiframe.dataFitting import Data1D 
     50from sans.guiframe.dataFitting import Data2D 
     51from DataLoader.loader import Loader 
     52 
     53from DataLoader.loader import Loader 
     54import DataLoader.data_info as DataInfo 
     55 
     56 
    5457PLOPANEL_WIDTH = 400 
    5558PLOPANEL_HEIGTH = 400 
    … …  
    5760GUIFRAME_HEIGHT = 800 
    5861PROG_SPLASH_SCREEN = "images/danse_logo.png"  
     62EXTENSIONS =  ['.inv', '.fitv', '.prv', '.svs'] 
    5963 
    6064class ViewerFrame(wx.Frame): 
    … …  
    130134        #panel on focus 
    131135        self.panel_on_focus = None 
     136        self.loader = Loader()    
    132137         #data manager 
    133138        from data_manager import DataManager 
    … …  
    479484        return ID 
    480485         
    481     def _populate_file_menu(self): 
    482         """ 
    483         Insert menu item under file menu 
    484         """ 
    485         for plugin in self.plugins: 
    486             if len(plugin.populate_file_menu()) > 0: 
    487                 for item in plugin.populate_file_menu(): 
    488                     id = wx.NewId() 
    489                     m_name, m_hint, m_handler = item 
    490                     self._file_menu.Append(id, m_name, m_hint) 
    491                     wx.EVT_MENU(self, id, m_handler) 
    492                 self._file_menu.AppendSeparator() 
    493                  
    494486    def _setup_menus(self): 
    495487        """ 
    … …  
    723715        if style == GUIFRAME.DATALOADER_ON: 
    724716            # some menu of plugin to be seen under file menu 
    725             self._populate_file_menu() 
     717            hint_load_file = "Read state's files and load" 
     718            hint_load_file += " them into the application" 
     719            id = wx.NewId() 
     720            self._save_appl_menu = self._file_menu.Append(id,  
     721                                    '&Open State from File', hint_load_file) 
     722            wx.EVT_MENU(self, id, self._on_open_state) 
    726723            id = wx.NewId() 
    727724            self._save_appl_menu = self._file_menu.Append(id,  
    … …  
    786783        self.enable_edit_menu() 
    787784         
     785    def get_style(self): 
     786        """ 
     787        """ 
     788        return  self.__gui_style 
     789     
    788790    def _add_menu_data(self): 
    789791        """ 
    790792        Add menu item item data to menu bar 
    791793        """ 
    792         # Add menu data  
    793         self._data_menu = wx.Menu() 
    794         #menu for data files 
    795         data_file_id = wx.NewId() 
    796         data_file_hint = "load one or more data in the application" 
    797         self._data_menu.Append(data_file_id,  
    798                          '&Load Data File(s)', data_file_hint) 
    799         wx.EVT_MENU(self, data_file_id, self._load_data) 
    800         style = self.__gui_style & GUIFRAME.MULTIPLE_APPLICATIONS 
    801         style1 = self.__gui_style & GUIFRAME.DATALOADER_ON 
    802         if style == GUIFRAME.MULTIPLE_APPLICATIONS: 
    803             #menu for data from folder 
    804             data_folder_id = wx.NewId() 
    805             data_folder_hint = "load multiple data in the application" 
    806             self._data_menu.Append(data_folder_id,  
    807                              '&Load Data Folder', data_folder_hint) 
    808             wx.EVT_MENU(self, data_folder_id, self._load_folder) 
    809             self._menubar.Append(self._data_menu, '&Data') 
    810         elif style1 == GUIFRAME.DATALOADER_ON: 
    811             self._menubar.Append(self._data_menu, '&Data') 
    812          
    813     def _load_data(self, event): 
    814         """ 
    815         connect menu item load data with the first plugin that can load data 
    816         """ 
    817         for plug in self.plugins: 
    818             if plug.can_load_data(): 
    819                 plug.load_data(event) 
    820         style = self.__gui_style & GUIFRAME.MANAGER_ON 
    821         if style == GUIFRAME.MANAGER_ON: 
    822             self.show_data_panel(event=None) 
    823          
    824     def _load_folder(self, event): 
    825         """ 
    826         connect menu item load data with the first plugin that can load data and 
    827         folder 
    828         """ 
    829         for plug in self.plugins: 
    830             if plug.can_load_data(): 
    831                 plug.load_folder(event) 
    832         style = self.__gui_style & GUIFRAME.MANAGER_ON 
    833         if style == GUIFRAME.MANAGER_ON: 
    834             self.show_data_panel(event=None) 
    835                  
     794        if self._data_plugin is not None: 
     795            menu_list = self._data_plugin.populate_menu(self) 
     796            if menu_list: 
     797                for (menu, name) in menu_list: 
     798                    self._menubar.Append(menu, name) 
     799             
    836800    def _on_hide_toolbar(self, event=None): 
    837801        """ 
    … …  
    911875                self._mgr.GetPane(self.panels["default"].window_name).Hide() 
    912876            self._mgr.Update() 
    913     
    914     def _on_open(self, event): 
    915         """ 
    916         """ 
    917         path = self.choose_file() 
    918         if path is None: 
     877     
     878    def clear_panel(self): 
     879        """ 
     880        """ 
     881        for item in self.panels: 
     882            try: 
     883                self.panels[item].clear_panel() 
     884            except: 
     885                pass 
     886             
     887    def create_gui_data(self, data, path=None): 
     888        """ 
     889        Receive data from loader and create a data to use for guiframe 
     890        """ 
     891         
     892        if issubclass(DataInfo.Data2D, data.__class__): 
     893            new_plot = Data2D(image=None, err_image=None)  
     894        else:  
     895            new_plot = Data1D(x=[], y=[], dx=None, dy=None) 
     896            
     897        new_plot.copy_from_datainfo(data)  
     898        data.clone_without_data(clone=new_plot)   
     899        #creating a name for data 
     900        name = "" 
     901        title = "" 
     902        file_name = "" 
     903        if path is not None: 
     904            file_name = os.path.basename(path) 
     905        if data.run: 
     906            name = data.run[0] 
     907        if name == "": 
     908            name = file_name 
     909        name = self._data_manager.rename(name) 
     910        #find title 
     911        if data.title.strip(): 
     912            title = data.title 
     913        if title.strip() == "": 
     914            title = file_name 
     915         
     916        if new_plot.filename.strip() == "": 
     917            new_plot.filename = file_name 
     918         
     919        new_plot.name = name 
     920        new_plot.title = title 
     921        ## allow to highlight data when plotted 
     922        new_plot.interactive = True 
     923        ## when 2 data have the same id override the 1 st plotted 
     924        new_plot.id = name 
     925        ##group_id specify on which panel to plot this data 
     926        new_plot.group_id = name 
     927        new_plot.is_data = True 
     928        new_plot.path = path 
     929        ##post data to plot 
     930        # plot data 
     931        return new_plot 
     932  
     933    def get_data(self, path, format=None): 
     934        """ 
     935        """ 
     936        message = "" 
     937        log_msg = '' 
     938        output = [] 
     939        error_message = "" 
     940        basename  = os.path.basename(path) 
     941        root, extension = os.path.splitext(basename) 
     942        if extension.lower() not in EXTENSIONS: 
     943            log_msg = "File Loader cannot " 
     944            log_msg += "load: %s\n" % str(basename) 
     945            log_msg += "Try Data opening...." 
     946            logging.info(log_msg) 
     947            self.load_complete(output=output, error_message=error_message, 
     948                   message=log_msg, path=path)     
    919949            return 
    920  
     950        try: 
     951            temp =  self.loader.load(path, extension) 
     952            if temp.__class__.__name__ == "list": 
     953                for item in temp: 
     954                    data = self.create_gui_data(item, path) 
     955                    output.append(data) 
     956            else: 
     957                data = self.create_gui_data(temp, path) 
     958                output.append(data) 
     959            message = "Loading File..." + str(basename) + "\n" 
     960            self.load_update(output=output, message=message) 
     961        except: 
     962            raise 
     963            error_message = "Error while loading: %s\n" % str(p_file) 
     964            error_message += str(sys.exc_value) + "\n" 
     965            self.load_update(output=output, message=error_message) 
     966             
     967        message = "Loading Complete! " 
     968        self.load_complete(output=output, error_message=error_message, 
     969                   message=message, path=path, extension=extension)     
     970         
     971    def load_update(self, output=None, message=""): 
     972        """ 
     973        print update on the status bar 
     974        """ 
     975        if message != "": 
     976            wx.PostEvent(self, StatusEvent(status=message, 
     977                                                  type="progress", 
     978                                                   info="warning")) 
     979         
     980    def load_complete(self, output, message="", error_message="",  
     981                      extension=None, path=None): 
     982        """ 
     983         post message to  status bar and return list of data 
     984        """ 
     985        wx.PostEvent(self, StatusEvent(status=message, 
     986                                              info="warning", 
     987                                              type="stop")) 
     988        if error_message != "": 
     989            self.load_error(error_message) 
     990        #send a list of available data to plotting plugin 
     991        available_data = [] 
     992        if self._data_manager is not None: 
     993            self._data_manager.add_data(output) 
     994            temp = self._data_manager.get_selected_data() 
     995            for data_state in temp.values(): 
     996                available_data.append(data_state.data) 
     997        #reading a state file 
     998        for plug in self.plugins: 
     999            #plug.on_set_state_helper(event=None) 
     1000            _, ext = plug.get_extensions() 
     1001            if extension == ext: 
     1002                plug.set_state(state=None, datainfo=available_data) 
     1003            elif extension == '.svs': 
     1004                plug.set_state(state=None, datainfo=available_data) 
     1005                 
     1006        style = self.__gui_style & GUIFRAME.MANAGER_ON 
     1007        if style == GUIFRAME.MANAGER_ON: 
     1008            if self._data_panel is not None: 
     1009                data_state = self._data_manager.get_selected_data() 
     1010                self._data_panel.load_data_list(data_state) 
     1011                self._mgr.GetPane(self._data_panel.window_name).Show(True) 
     1012         
     1013    def _on_open_state(self, event): 
     1014        """ 
     1015        """ 
     1016        path = None 
     1017        if self._default_save_location == None: 
     1018            self._default_save_location = os.getcwd() 
     1019  
     1020        wlist = ['SansView files (*.svs)|*.svs', 
     1021                  'P(r) files (*.prv)|*.prv', 
     1022                  'Fitting files (*.fitv)|*.fitv', 
     1023                  'Invariant files (*.inv)|*.inv'] 
     1024        wlist = '|'.join(wlist) 
     1025        dlg = wx.FileDialog(self,  
     1026                            "Choose a file",  
     1027                            self._default_save_location, "", 
     1028                             wlist) 
     1029        if dlg.ShowModal() == wx.ID_OK: 
     1030            path = dlg.GetPath() 
     1031            if path is not None: 
     1032                self._default_save_location = os.path.dirname(path) 
     1033        dlg.Destroy() 
    9211034        if path and os.path.isfile(path): 
    9221035            basename  = os.path.basename(path) 
    … …  
    9281041                    except: 
    9291042                        pass 
    930                 #reset states and plot data  
    931                 for item in STATE_FILE_EXT: 
    932                     exec "plot_data(self, path,'%s')" % str(item) 
    933             else: 
    934                 plot_data(self, path) 
     1043            self.get_data(path) 
     1044                 
    9351045        if self.defaultPanel is not None and \ 
    9361046            self._mgr.GetPane(self.panels["default"].window_name).IsShown(): 
    9371047            self.on_close_welcome_panel() 
    938              
     1048     
    9391049    def _on_save_application(self, event): 
    9401050        """ 
    … …  
    9541064        reader, ext = self._current_perspective.get_extensions() 
    9551065        path = None 
    956         dlg = wx.FileDialog(self, "Choose a file", 
     1066        dlg = wx.FileDialog(self, "Save Project file", 
    9571067                            self._default_save_location, "", '.svs', wx.SAVE) 
    9581068        if dlg.ShowModal() == wx.ID_OK: 
    … …  
    11441254        show the data panel 
    11451255        """ 
    1146         pane = self._mgr.GetPane(self.panels["data_panel"].window_name) 
    1147         #if not pane.IsShown(): 
    1148         pane.Show(True) 
    1149         self._mgr.Update() 
    1150    
    1151     def add_data(self, data_list, flag=False): 
     1256        style = self.__gui_style & GUIFRAME.MANAGER_ON 
     1257        if style == GUIFRAME.MANAGER_ON: 
     1258            pane = self._mgr.GetPane(self.panels["data_panel"].window_name) 
     1259            #if not pane.IsShown(): 
     1260            pane.Show(True) 
     1261            self._mgr.Update() 
     1262  
     1263    def add_data(self, data_list): 
    11521264        """ 
    11531265        receive a list of data . store them its data manager if possible 
    … …  
    11591271            self._data_manager.add_data(data_list) 
    11601272            avalaible_data = self._data_manager.get_all_data() 
    1161              
    1162         if True: 
    1163             #reading a state file 
    1164             for plug in self.plugins: 
    1165                 plug.on_set_state_helper(event=None) 
     1273 
    11661274        style = self.__gui_style & GUIFRAME.MANAGER_ON 
    11671275        if style == GUIFRAME.MANAGER_ON: 
    … …  
    12591367        set the current active perspective  
    12601368        """ 
    1261          
     1369        print "set_current_perspective", perspective 
    12621370        self._current_perspective = perspective 
    12631371        name = "No current Application selected" 

  • guiframe/local_perspectives/data_loader/data_loader.py

    rec489f5 r75fbd17  
    1616from sans.guiframe.dataFitting import Data2D 
    1717from sans.guiframe.utils import parse_name 
     18from sans.guiframe.gui_style import GUIFRAME 
    1819 
    19 STATE_FILE_EXT = ['SansView files (*.svs)|*.svs', 
    20                   'P(r) files (*.prv)|*.prv', 
    21                   'Fitting files (*.fitv)|*.fitv', 
    22                   'Invariant files (*.inv)|*.inv'] 
    2320EXTENSIONS = ['.svs', '.prv','.fitv', '.inv'] 
    2421 
    … …  
    3027        self._default_save_location = None   
    3128        self.data_name_dict = {} 
    32         self.loader = Loader()    
     29        self.loader = Loader()   
     30        self._data_menu = None  
    3331         
    34     def populate_file_menu(self): 
     32    def populate_menu(self, parent): 
    3533        """ 
    36         get a menu item and append it under file menu of the application 
    37         add load file menu item and load folder item 
    3834        """ 
    39          
    40         hint_load_file = "Read state's files and load them into the application" 
    41         return [["Open State from File", hint_load_file, self.load_file]] 
    42    
    43     def load_data(self, event): 
     35         # Add menu data  
     36        self._data_menu = wx.Menu() 
     37        #menu for data files 
     38        data_file_id = wx.NewId() 
     39        data_file_hint = "load one or more data in the application" 
     40        self._data_menu.Append(data_file_id,  
     41                         '&Load Data File(s)', data_file_hint) 
     42        wx.EVT_MENU(self.parent, data_file_id, self._load_data) 
     43        gui_style = self.parent.get_style() 
     44        style = gui_style & GUIFRAME.MULTIPLE_APPLICATIONS 
     45        style1 = gui_style & GUIFRAME.DATALOADER_ON 
     46        if style == GUIFRAME.MULTIPLE_APPLICATIONS: 
     47            #menu for data from folder 
     48            data_folder_id = wx.NewId() 
     49            data_folder_hint = "load multiple data in the application" 
     50            self._data_menu.Append(data_folder_id,  
     51                             '&Load Data Folder', data_folder_hint) 
     52            wx.EVT_MENU(self.parent, data_folder_id, self._load_folder) 
     53             
     54        return [(self._data_menu, 'Data')] 
     55 
     56    def _load_data(self, event): 
    4457        """ 
    4558        Load data 
    4659        """ 
    47         flag = True 
    48         file_list = self.choose_data_file(flag) 
     60        if self._default_save_location == None: 
     61            self._default_save_location = os.getcwd() 
     62         
     63        cards = self.loader.get_wildcards() 
     64        wlist =  '|'.join(cards) 
     65        style = wx.OPEN|wx.FD_MULTIPLE 
     66        dlg = wx.FileDialog(self.parent,  
     67                            "Choose a file",  
     68                            self._default_save_location, "", 
     69                             wlist, 
     70                             style=style) 
     71        if dlg.ShowModal() == wx.ID_OK: 
     72            file_list = dlg.GetPaths() 
     73            if len(file_list) >= 0 and not(file_list[0]is None): 
     74                self._default_save_location = os.path.dirname(file_list[0]) 
     75        dlg.Destroy() 
     76         
    4977        if not file_list or file_list[0] is None: 
    5078            return 
    51         self.get_data(file_list, flag=flag) 
     79        self.get_data(file_list) 
     80        self.parent.show_data_panel(event=None) 
    5281         
    5382    def can_load_data(self): 
    … …  
    5685        """ 
    5786        return True 
    58      
    59     def load_file(self, event): 
    60         """ 
    61         Load  sansview defined files 
    62         """ 
    63         flag = False 
    64         file_list = self.choose_data_file(flag) 
    65         if not file_list or file_list[0] is None: 
    66             return 
    67         self.get_state(file_list) 
     87  
    6888        
    69     def load_folder(self, event): 
     89    def _load_folder(self, event): 
    7090        """ 
    7191        Load entire folder 
    7292        """ 
    73         flag = True 
    74         path = self.choose_data_folder(flag) 
    75         if path is None: 
    76             return 
    77         file_list = self.get_file_path(path) 
    78         self.get_data(file_list, flag=flag) 
    79         
    80     def get_wild_card(self, flag=True): 
    81         """ 
    82         :param flag: is True load only data file, else load state file 
    83          return wild cards 
    84         """ 
    85         if flag: 
    86             cards = self.loader.get_wildcards() 
    87             for item in STATE_FILE_EXT: 
    88                 if item in cards: 
    89                     cards.remove(item) 
    90         else: 
    91             cards = STATE_FILE_EXT 
    92         return '|'.join(cards) 
    93          
    94          
    95     def choose_data_file(self, flag=True): 
    96         """ 
    97         Open the file dialog to load file(s) 
    98         """ 
    99         path = None 
    10093        if self._default_save_location == None: 
    10194            self._default_save_location = os.getcwd() 
    102          
    103         cards = self.loader.get_wildcards() 
    104         wlist = self.get_wild_card(flag) 
    105         if flag: 
    106             style = wx.OPEN|wx.FD_MULTIPLE 
    107         else: 
    108             style = wx.OPEN|wx.FD_DEFAULT_STYLE 
    109              
    110         dlg = wx.FileDialog(self.parent,  
    111                             "Choose a file",  
    112                             self._default_save_location, "", 
    113                              wlist, 
    114                              style=style) 
    115         if dlg.ShowModal() == wx.ID_OK: 
    116             path = dlg.GetPaths() 
    117             if len(path) >= 0 and not(path[0]is None): 
    118                 self._default_save_location = os.path.dirname(path[0]) 
    119         dlg.Destroy() 
    120         return path 
    121      
    122     def choose_data_folder(self, flag=True): 
    123         """ 
    124         :param flag: is True load only data file, else load state file 
    125         return a list of folder to read 
    126         """ 
    127         path = None 
    128         if self._default_save_location == None: 
    129             self._default_save_location = os.getcwd() 
    130          
    131         wlist = self.get_wild_card(flag) 
    132          
    13395        dlg = wx.DirDialog(self.parent, "Choose a directory",  
    13496                           self._default_save_location, 
    … …  
    138100            self._default_save_location = path 
    139101        dlg.Destroy() 
    140         return path 
    141      
     102        if path is not None: 
     103            self._default_save_location = os.path.dirname(path) 
     104        else: 
     105            return     
     106        file_list = self.get_file_path(path) 
     107        self.get_data(file_list) 
     108        self.parent.show_data_panel(event=None) 
     109    
     110    
    142111    def load_error(self, error=None): 
    143112        """ 
    … …  
    164133            return [os.path.join(os.path.abspath(path), 
    165134                                  file) for file in os.listdir(path)] 
    166      
    167     def get_state(self, path, format=None): 
    168         """ 
    169         read state 
    170         """ 
    171         output = [] 
    172         for p_file in path: 
    173             basename  = os.path.basename(p_file) 
    174             root, extension = os.path.splitext(basename) 
    175             for extension in EXTENSIONS: 
    176                 temp = self.loader.load(p_file, extension) 
    177                 if temp.__class__.__name__ == "list": 
    178                     for item in temp: 
    179                         data = self.create_data(item, p_file) 
    180                 else: 
    181                     data = self.create_data(temp, p_file) 
    182                 output.append(data) 
    183             self.load_complete(output=output, path=path) 
    184                     
    185     def get_data(self, path, format=None, flag=True): 
     135    
     136    def get_data(self, path, format=None): 
    186137        """ 
    187138        """ 
    … …  
    193144            basename  = os.path.basename(p_file) 
    194145            root, extension = os.path.splitext(basename) 
    195             if flag: 
    196                 if extension.lower() in EXTENSIONS: 
    197                     log_msg = "Data Loader cannot " 
    198                     log_msg += "load: %s\n" % str(p_file) 
    199                     log_msg += "Try File -> open ...." 
    200                     logging.info(log_msg) 
    201                     continue 
    202             else: 
    203                 if extension.lower() not in EXTENSIONS: 
    204                     log_msg = "File Loader cannot" 
    205                     log_msg += " load: %s\n" % str(p_file) 
    206                     log_msg += "Try Data -> Load ...." 
    207                     logging.info(log_msg) 
    208                     continue 
     146            if extension.lower() in EXTENSIONS: 
     147                log_msg = "Data Loader cannot " 
     148                log_msg += "load: %s\n" % str(p_file) 
     149                log_msg += "Try File opening ...." 
     150                logging.info(log_msg) 
     151                continue 
     152         
    209153            try: 
    210154                temp =  self.loader.load(p_file, format) 
    211155                if temp.__class__.__name__ == "list": 
    212                     print "list", temp 
    213156                    for item in temp: 
    214                         data = self.create_data(item, p_file) 
     157                        data = self.parent.create_gui_data(item, p_file) 
    215158                        output.append(data) 
    216159                else: 
    217                     print "not list", [temp] 
    218                     data = self.create_data(temp, p_file) 
     160                    data = self.parent.create_gui_data(temp, p_file) 
    219161                    output.append(data) 
    220                 message = "Loading ..." + str(p_file) + "\n" 
     162                message = "Loading Data..." + str(p_file) + "\n" 
    221163                self.load_update(output=output, message=message) 
    222164            except: 
    223                 raise 
    224                 error_message = "Error while loading: %s\n" % str(p_file) 
     165                error_message = "Error while loading Data: %s\n" % str(p_file) 
    225166                error_message += str(sys.exc_value) + "\n" 
    226167                self.load_update(output=output, message=error_message) 
    227168                 
    228         message = "Loading Complete! " 
     169        message = "Loading Data Complete! " 
    229170        message += log_msg 
    230171        self.load_complete(output=output, error_message=error_message, 
    231                        message=message, path=path, flag=flag) 
     172                       message=message, path=path) 
    232173             
    233     
    234174    def load_update(self, output=None, message=""): 
    235175        """ 
    … …  
    240180                                                  type="progress", 
    241181                                                   info="warning")) 
    242          
    243     def load_complete(self, output, message="", error_message="",  
    244                       path=None, flag=True): 
     182    def load_complete(self, output, message="", error_message="", path=None): 
    245183        """ 
    246184         post message to  status bar and return list of data 
    … …  
    251189        if error_message != "": 
    252190            self.load_error(error_message) 
    253         self.parent.add_data(output, flag=flag) 
     191        self.parent.add_data(output) 
     192    
     193     
    254194         
    255     def create_data(self, data, path): 
    256         """ 
    257         Receive data from loader and create a data to use for guiframe 
    258         """ 
    259          
    260         if issubclass(DataInfo.Data2D, data.__class__): 
    261             new_plot = Data2D(image=None, err_image=None)  
    262         else:  
    263             new_plot = Data1D(x=[], y=[], dx=None, dy=None) 
    264             
    265         new_plot.copy_from_datainfo(data)  
    266         data.clone_without_data(clone=new_plot)   
    267         #creating a name for data 
    268         name = "" 
    269         title = "" 
    270         file_name = "" 
    271         if path is not None: 
    272             file_name = os.path.basename(path) 
    273         if data.run: 
    274             name = data.run[0] 
    275         if name == "": 
    276             name = file_name 
    277         ## name of the data allow to differentiate data when plotted 
    278         name = parse_name(name=name, expression="_") 
    279          
    280         max_char = name.find("[") 
    281         if max_char < 0: 
    282             max_char = len(name) 
    283         name = name[0:max_char] 
    284          
    285         if name not in self.data_name_dict: 
    286             self.data_name_dict[name] = 0 
    287         else: 
    288             self.data_name_dict[name] += 1 
    289             name = name + " [" + str(self.data_name_dict[name]) + "]" 
    290         #find title 
    291         if data.title.strip(): 
    292             title = data.title 
    293         if title.strip() == "": 
    294             title = file_name 
    295          
    296         if new_plot.filename.strip() == "": 
    297             new_plot.filename = file_name 
    298          
    299         new_plot.name = name 
    300         new_plot.title = title 
    301         ## allow to highlight data when plotted 
    302         new_plot.interactive = True 
    303         ## when 2 data have the same id override the 1 st plotted 
    304         new_plot.id = name 
    305         ##group_id specify on which panel to plot this data 
    306         new_plot.group_id = name 
    307         new_plot.is_data = True 
    308         new_plot.path = path 
    309         ##post data to plot 
    310         # plot data 
    311         return new_plot 
    312          
    313         
     195    

  • guiframe/panel_base.py

    ra45037aa r75fbd17  
    2424    #window_caption = "Welcome panel" 
    2525    ## Flag to tell the AUI manager to put this panel in the center pane 
    26     #CENTER_PANE = True 
     26    group_id = None 
    2727     
    2828    def __init__(self, parent=None): 

  • guiframe/plugin_base.py

    r52725d6 r75fbd17  
    9494        """ 
    9595        return self._always_active 
    96      
    97     def populate_file_menu(self): 
    98         """ 
    99         get a menu item and append it under file menu of the application 
    100         return [[menu item name, menu_hint, menu handler]] 
    101         """ 
    102         return [] 
    103          
     96 
    10497    def populate_menu(self, parent): 
    10598        """ 
    … …  
    133126        # Return the list of panels 
    134127        return [] 
     128     
     129    def clear_panel(self): 
     130        """ 
     131        reset all panels 
     132        """ 
    135133     
    136134    def get_tools(self): 
    … …  
    171169        return self.perspective 
    172170     
    173     def on_perspective(self, event): 
     171    def on_perspective(self, event=None): 
    174172        """ 
    175173        Call back function for the perspective menu item. 
    … …  
    200198        return False 
    201199     
     200    def set_state(self, state=None, datainfo=None):     
     201        """ 
     202        update state 
     203        """ 
    202204    def set_data(self, data_list): 
    203205        """ 
Note: See TracChangeset for help on using the changeset viewer.