Changeset b35d3d1 in sasview


Ignore:
Timestamp:
Aug 6, 2010 7:36:07 PM (15 years ago)
Author:
Jae Cho <jhjcho@…>
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:
028a0e8
Parents:
a93f525
Message:

save state file: working, but more work to do

Files:
10 edited

Legend:

Unmodified
Added
Removed

  • guiframe/data_loader.py

    raf47c8d rb35d3d1  
    150150                                                type="stop")) 
    151151     
    152 def plot_data(parent, path): 
     152def plot_data(parent, path, format=None): 
    153153    """ 
    154154    Use the DataLoader loader to created data to plot. 
    155155     
    156156    :param path: the path of the data to load 
    157      
     157    : param format: file format (as file extension) 
    158158    """ 
    159159    from sans.guicomm.events import NewPlotEvent, StatusEvent 
    … …  
    165165    # Load data  
    166166    try: 
    167         output = L.load(path) 
     167        output = L.load(path, format) 
    168168    except: 
    169169        load_error(sys.exc_value) 
    … …  
    235235        i=1 
    236236        for item in output: 
    237             msg = "Loading 1D data: %s"%str(item.run[0]) 
    238             wx.PostEvent(parent, StatusEvent(status=msg, info="info", type="stop")) 
    239237            try: 
    240                 dx = item.dx 
    241                 dxl = item.dxl 
    242                 dxw = item.dxw 
     238                msg = "Loading 1D data: %s"%str(item.run[0]) 
     239                wx.PostEvent(parent, StatusEvent(status=msg, info="info", type="stop")) 
     240                try: 
     241                    dx = item.dx 
     242                    dxl = item.dxl 
     243                    dxw = item.dxw 
     244                except: 
     245                    dx = None 
     246                    dxl = None 
     247                    dxw = None 
     248     
     249                new_plot = Data1D(x=item.x,y=item.y,dx=dx,dy=item.dy) 
     250                new_plot.copy_from_datainfo(item) 
     251                item.clone_without_data(clone=new_plot) 
     252                new_plot.dxl = dxl 
     253                new_plot.dxw = dxw 
     254                 
     255                name = parse_name(name=str(item.run[0]), expression="_") 
     256                #if not name in parent.indice_load_data.keys(): 
     257                #    parent.indice_load_data[name] = 0 
     258                #else: 
     259                    ## create a copy of the loaded data 
     260                     
     261                    #TODO: this is a very annoying feature. We should make this 
     262                    # an option. Excel doesn't do this. Why should we? 
     263                    # What is the requirement for this feature, and are the 
     264                    # counter arguments stronger? Is this feature developed 
     265                    # to please at least 80% of the users or a special few? 
     266                    #parent.indice_load_data[name] += 1 
     267                    #name = name + "(copy %i)"%parent.indice_load_data[name] 
     268                     
     269                new_plot.name = name 
     270                new_plot.interactive = True 
     271                new_plot.group_id = name 
     272                new_plot.id = name 
     273                new_plot.is_data = True 
     274             
     275                if hasattr(item,"title"): 
     276                    title = item.title.lstrip().rstrip() 
     277                    if title == "": 
     278                        title = str(name) 
     279                else: 
     280                    title = name 
     281                if hasattr(parent, "panel_on_focus") and not(parent.panel_on_focus is None): 
     282                    existing_panel  = parent.panel_on_focus 
     283                    panel_name = existing_panel.window_caption 
     284                    data_name = new_plot.name 
     285                    if enable_add_data(existing_panel, new_plot): 
     286                        if open_dialog_append_data(panel_name, data_name): 
     287                            #add this plot the an existing panel 
     288                            new_plot.group_id = existing_panel.group_id 
     289                wx.PostEvent(parent, NewPlotEvent(plot=new_plot, title=str(title))) 
     290                i+=1 
    243291            except: 
    244                 dx = None 
    245                 dxl = None 
    246                 dxw = None 
    247  
    248             new_plot = Data1D(x=item.x,y=item.y,dx=dx,dy=item.dy) 
    249             new_plot.copy_from_datainfo(item) 
    250             item.clone_without_data(clone=new_plot) 
    251             new_plot.dxl = dxl 
    252             new_plot.dxw = dxw 
    253             
    254             name = parse_name(name=str(item.run[0]), expression="_") 
    255             #if not name in parent.indice_load_data.keys(): 
    256             #    parent.indice_load_data[name] = 0 
    257             #else: 
    258                 ## create a copy of the loaded data 
    259                  
    260                 #TODO: this is a very annoying feature. We should make this 
    261                 # an option. Excel doesn't do this. Why should we? 
    262                 # What is the requirement for this feature, and are the 
    263                 # counter arguments stronger? Is this feature developed 
    264                 # to please at least 80% of the users or a special few? 
    265                 #parent.indice_load_data[name] += 1 
    266                 #name = name + "(copy %i)"%parent.indice_load_data[name] 
    267                  
    268             new_plot.name = name 
    269             new_plot.interactive = True 
    270             new_plot.group_id = name 
    271             new_plot.id = name 
    272             new_plot.is_data = True 
    273          
    274             if hasattr(item,"title"): 
    275                 title = item.title.lstrip().rstrip() 
    276                 if title == "": 
    277                     title = str(name) 
    278             else: 
    279                 title = name 
    280             if hasattr(parent, "panel_on_focus") and not(parent.panel_on_focus is None): 
    281                 existing_panel  = parent.panel_on_focus 
    282                 panel_name = existing_panel.window_caption 
    283                 data_name = new_plot.name 
    284                 if enable_add_data(existing_panel, new_plot): 
    285                     if open_dialog_append_data(panel_name, data_name): 
    286                         #add this plot the an existing panel 
    287                         new_plot.group_id = existing_panel.group_id 
    288             wx.PostEvent(parent, NewPlotEvent(plot=new_plot, title=str(title))) 
    289             i+=1 
    290           
     292                raise 

  • guiframe/gui_manager.py

    raf47c8d rb35d3d1  
    537537         
    538538        id = wx.NewId() 
    539         self.filemenu.Append(id, '&Load Data', 'Load data file into the application') 
     539        self.filemenu.Append(id, '&Open', 'Load data file into the application') 
    540540        wx.EVT_MENU(self, id, self._on_open) 
     541        #self.filemenu.AppendSeparator() 
     542         
     543        id = wx.NewId() 
     544        self.filemenu.Append(id, '&Save', 'Save project as a SanaView (svs) file') 
     545        wx.EVT_MENU(self, id, self._on_save) 
    541546        #self.filemenu.AppendSeparator() 
    542547         
    … …  
    711716        from data_loader import plot_data 
    712717        if path and os.path.isfile(path): 
    713             plot_data(self, path) 
     718             basename  = os.path.basename(path) 
     719             if  basename.endswith('.svs'): 
     720                 plot_data(self, path,'.inv') 
     721                 plot_data(self, path,'.prv') 
     722                 plot_data(self, path,'.fitv') 
     723             else: plot_data(self,path) 
    714724        if self.defaultPanel is not None and \ 
    715725            self._mgr.GetPane(self.panels["default"].window_name).IsShown(): 
    716726            self.on_close_welcome_panel() 
     727             
     728    def _on_save(self, event): 
     729        """ 
     730        Save state into a file 
     731        """ 
     732        # Ask the user the location of the file to write to. 
     733         
     734        ## Default file location for save 
     735        self._default_save_location = os.getcwd() 
     736        path = None 
     737        dlg = wx.FileDialog(self, "Choose a file", self._default_save_location, "", "*.svs", wx.SAVE) 
     738        if dlg.ShowModal() == wx.ID_OK: 
     739            path = dlg.GetPath() 
     740            self._default_save_location = os.path.dirname(path) 
     741        else: 
     742            return None 
     743         
     744        dlg.Destroy() 
     745        if path is None: 
     746            return 
     747        # default cansas xml doc 
     748        doc = None 
     749        for item in self.panels: 
     750            try: 
     751                if self.panels[item].window_name == 'Invariant' or self.panels[item].window_name == 'pr_control' or self.panels[item].window_name == 'Fit panel': 
     752                    if self.panels[item].window_name == 'Invariant': 
     753                        data = self.panels[item]._data 
     754                        state = self.panels[item].state 
     755                        new_doc =self.panels[item]._manager.state_reader.write_toXML(data,state) 
     756                        if hasattr(doc, "firstChild"): 
     757                            doc.firstChild.appendChild (new_doc.firstChild.firstChild)   
     758                        else: 
     759                            doc = new_doc  
     760                    elif self.panels[item].window_name == 'pr_control': 
     761                        data = self.panels[item].manager.current_plottable 
     762                        state = self.panels[item].get_state() 
     763                        new_doc =self.panels[item].manager.state_reader.write_toXML(data,state) 
     764                        if hasattr(doc, "firstChild"): 
     765                            doc.firstChild.appendChild (new_doc.firstChild.firstChild)   
     766                        else: 
     767                            doc = new_doc  
     768                    elif self.panels[item].window_name == 'Fit panel': 
     769                        for index in range(self.panels[item].GetPageCount()): 
     770                            selected_page = self.panels[item].GetPage(index)  
     771                            if hasattr(selected_page,"get_data"): 
     772                                data = selected_page.get_data() 
     773                                state = selected_page.state 
     774                                new_doc =selected_page.manager.state_reader.write_toXML(data,state) 
     775                                if doc != None and hasattr(doc, "firstChild"): 
     776                                    doc.firstChild.appendChild (new_doc.firstChild.firstChild) 
     777                                else: 
     778                                    doc = new_doc 
     779 
     780            except:  
     781                pass 
     782 
     783        # Write the XML document 
     784        if doc != None: 
     785            fd = open(path, 'w') 
     786            fd.write(doc.toprettyxml()) 
     787            fd.close() 
     788        else: 
     789            raise RuntimeError, "%s is not a SansView (.svs) file..." % path 
     790 
    717791        
    718792    def _onClose(self, event): 

  • invariantview/perspectives/invariant/invariant.py

    r210ff4f rb35d3d1  
    105105        loader = Loader() 
    106106        loader.associate_file_reader(".inv", self.state_reader) 
     107        loader.associate_file_reader(".svs", self.state_reader) 
    107108        # Return the list of panels 
    108109        return [self.invariant_panel] 

  • invariantview/perspectives/invariant/invariant_panel.py

    r210ff4f rb35d3d1  
    131131            self.reset_panel() 
    132132            self.compute_invariant(event=None) 
     133            self.state.file = self._data.name 
    133134        return True   
    134135    def set_message(self): 
    … …  
    166167            if not self.set_data(data): 
    167168                return 
    168             self.state = state    
    169              
     169            self.state = state  
     170            self.state.file = data.name    
    170171            num = self.state.saved_state['state_num'] 
    171172             

  • invariantview/perspectives/invariant/invariant_state.py

    r5b03122 rb35d3d1  
    266266        # File name 
    267267        element = newdoc.createElement("filename") 
    268         if self.file is not None: 
     268        if self.file != None and self.file !='': 
    269269            element.appendChild(newdoc.createTextNode(str(self.file))) 
    270270        else: 
    … …  
    353353            entry = get_content('ns:filename', node) 
    354354            if entry is not None: 
    355                 self.file = entry.text.strip() 
    356              
     355                file_name = entry.text.strip() 
     356 
    357357            # Get time stamp 
    358358            entry = get_content('ns:timestamp', node) 
    … …  
    432432                    if input_field is not None: 
    433433                        self.set_saved_state(name=item, value=val) 
    434  
     434                         
     435            self.file = file_name 
     436             
    435437    def set_report_string(self): 
    436438        """ 
    … …  
    606608     
    607609    ## Wildcards 
    608     type = ["Invariant file (*.inv)|*.inv"] 
     610    type = ["Invariant file (*.inv)|*.inv", 
     611            "SANSView file (*.svs)|*.svs"] 
    609612    ## List of allowed extensions 
    610     ext=['.inv', '.INV']   
     613    ext=['.inv', '.INV', '.svs', 'SVS']   
    611614     
    612615    def __init__(self, call_back, cansas=True): 
    … …  
    660663        : return: InvariantState object 
    661664        """ 
    662         # Create an empty state 
    663         state = InvariantState() 
    664  
     665        state = None 
    665666        # Locate the invariant node 
    666667        try: 
    667668            nodes = entry.xpath('ns:%s' % INVNODE_NAME, namespaces={'ns': CANSAS_NS}) 
    668             state.fromXML(node=nodes[0]) 
     669            # Create an empty state 
     670            if nodes !=[]: 
     671                state = InvariantState() 
     672                state.fromXML(node=nodes[0]) 
    669673        except: 
    670674            logging.info("XML document does not contain invariant information.\n %s" % sys.exc_value)   
    … …  
    683687        """ 
    684688        output = [] 
    685          
    686689        if os.path.isfile(path): 
    687690            basename  = os.path.basename(path) 
    … …  
    702705                    sas_entry = self._parse_entry(entry) 
    703706                    invstate = self._parse_state(entry) 
    704                     sas_entry.meta_data['invstate'] = invstate 
    705  
    706                     sas_entry.filename = invstate.file 
    707                     output.append(sas_entry) 
    708                  
     707                     
     708                    #invstate could be None when .svs file is loaded 
     709                    #in this case, skip appending to output 
     710                    if invstate != None: 
     711                        sas_entry.meta_data['invstate'] = invstate 
     712                        sas_entry.filename = invstate.file 
     713                        output.append(sas_entry) 
    709714        else: 
    710715            raise RuntimeError, "%s is not a file" % path 
    … …  
    730735        : param invstate: InvariantState object 
    731736        """ 
    732  
    733737        # Sanity check 
    734738        if self.cansas == True: 
    735             if datainfo is None: 
    736                 datainfo = DataLoader.data_info.Data1D(x=[], y=[])     
    737             elif not issubclass(datainfo.__class__, DataLoader.data_info.Data1D): 
    738                 raise RuntimeError, "The cansas writer expects a Data1D instance: %s" % str(datainfo.__class__.__name__) 
    739          
    740             # Create basic XML document 
    741             doc, sasentry = self._to_xml_doc(datainfo) 
    742          
    743             # Add the invariant information to the XML document 
    744             if invstate is not None: 
    745                 invstate.toXML(doc=doc, entry_node=sasentry) 
    746          
     739            doc = self.write_toXML(datainfo,invstate) 
    747740            # Write the XML document 
    748741            fd = open(filename, 'w') 
    … …  
    752745            invstate.toXML(file=filename) 
    753746         
    754      
    755      
     747    def write_toXML(self, datainfo=None, state=None): 
     748        """ 
     749        Write toXML, a helper for write() 
     750         
     751        : return: xml doc 
     752        """ 
     753        if datainfo is None: 
     754            datainfo = DataLoader.data_info.Data1D(x=[], y=[])     
     755        elif not issubclass(datainfo.__class__, DataLoader.data_info.Data1D): 
     756            raise RuntimeError, "The cansas writer expects a Data1D instance: %s" % str(datainfo.__class__.__name__) 
     757        #make sure title and data run is filled up. 
     758        if datainfo.title == None or datainfo.title=='': datainfo.title = datainfo.name 
     759        if datainfo.run_name == None or datainfo.run_name=={}:  
     760            datainfo.run = [str(datainfo.name)] 
     761            datainfo.run_name[0] = datainfo.name 
     762 
     763        # Create basic XML document 
     764        doc, sasentry = self._to_xml_doc(datainfo) 
     765     
     766        # Add the invariant information to the XML document 
     767        if state is not None: 
     768            state.toXML(doc=doc, entry_node=sasentry) 
     769             
     770        return doc 

  • prview/perspectives/pr/inversion_panel.py

    r0d21ac1 rb35d3d1  
    252252         
    253253        dlg.Destroy() 
    254                  
     254         
     255        state = self.get_state() 
     256             
     257        self.manager.save_data(filepath=path, prstate=state) 
     258         
     259        return state 
     260     
     261    def get_state(self): 
     262        """ 
     263        Get the current state 
     264         
     265        : return: state object 
     266        """ 
    255267        # Construct the state object     
    256268        state = InversionState() 
    … …  
    287299        state.iq0     = self.iq0 
    288300        state.bck     = self.bck 
    289              
    290         self.manager.save_data(filepath=path, prstate=state) 
    291301         
    292302        return state 

  • prview/perspectives/pr/inversion_state.py

    r7116b6e0 rb35d3d1  
    341341     
    342342    ## Wildcards 
    343     type = ["P(r) files (*.prv)|*.prv"] 
     343    type = ["P(r) files (*.prv)|*.prv", 
     344            "SANSView files (*.svs)|*.svs"] 
    344345    ## List of allowed extensions 
    345     ext=['.prv', '.PRV']   
     346    ext=['.prv', '.PRV', '.svs', '.SVS']   
    346347     
    347348    def __init__(self, call_back, cansas=True): 
    … …  
    401402         
    402403        """ 
    403         # Create an empty state 
    404         state = InversionState() 
     404        state = None 
    405405         
    406406        # Locate the P(r) node 
    407407        try: 
    408408            nodes = entry.xpath('ns:%s' % PRNODE_NAME, namespaces={'ns': CANSAS_NS}) 
    409             state.fromXML(node=nodes[0]) 
     409            if nodes !=[]: 
     410                # Create an empty state 
     411                state =  InversionState() 
     412                state.fromXML(node=nodes[0]) 
    410413        except: 
    411414            logging.info("XML document does not contain P(r) information.\n %s" % sys.exc_value) 
    … …  
    447450                    sas_entry = self._parse_entry(entry) 
    448451                    prstate = self._parse_prstate(entry) 
    449                     sas_entry.meta_data['prstate'] = prstate 
    450                     sas_entry.filename = prstate.file 
    451                     output.append(sas_entry) 
     452                    #prstate could be None when .svs file is loaded 
     453                    #in this case, skip appending to output 
     454                    if prstate != None: 
     455                        sas_entry.meta_data['prstate'] = prstate 
     456                        sas_entry.filename = prstate.file 
     457                        output.append(sas_entry) 
    452458        else: 
    453459            raise RuntimeError, "%s is not a file" % path 
    … …  
    475481        # Sanity check 
    476482        if self.cansas == True: 
    477             if datainfo is None: 
    478                 datainfo = DataLoader.data_info.Data1D(x=[], y=[])     
    479             elif not issubclass(datainfo.__class__, DataLoader.data_info.Data1D): 
    480                 raise RuntimeError, "The cansas writer expects a Data1D instance: %s" % str(datainfo.__class__.__name__) 
    481          
    482             # Create basic XML document 
    483             doc, sasentry = self._to_xml_doc(datainfo) 
    484          
    485             # Add the P(r) information to the XML document 
    486             if prstate is not None: 
    487                 prstate.toXML(doc=doc, entry_node=sasentry) 
    488          
     483            doc =self.write_toXML(datainfo, prstate)         
    489484            # Write the XML document 
    490485            fd = open(filename, 'w') 
    … …  
    494489            prstate.toXML(file=filename) 
    495490         
    496      
    497      
     491    def write_toXML(self, datainfo=None, state=None): 
     492        """ 
     493        Write toXML, a helper for write() 
     494         
     495        : return: xml doc 
     496        """ 
     497        if datainfo is None: 
     498            datainfo = DataLoader.data_info.Data1D(x=[], y=[])     
     499        elif not issubclass(datainfo.__class__, DataLoader.data_info.Data1D): 
     500            raise RuntimeError, "The cansas writer expects a Data1D instance: %s" % str(datainfo.__class__.__name__) 
     501     
     502        # Create basic XML document 
     503        doc, sasentry = self._to_xml_doc(datainfo) 
     504     
     505        # Add the invariant information to the XML document 
     506        if state is not None: 
     507            state.toXML(doc=doc, entry_node=sasentry) 
     508             
     509        return doc  
     510     

  • prview/perspectives/pr/pr.py

    red90edb rb35d3d1  
    112112        l = Loader() 
    113113        l.associate_file_reader('.prv', self.state_reader) 
     114        l.associate_file_reader(".sav", self.state_reader) 
    114115                 
    115116        # Log startup 

  • sansview/perspectives/fitting/fitting.py

    r4f81342 rb35d3d1  
    257257        loader = Loader() 
    258258        loader.associate_file_reader(".fitv", self.state_reader) 
     259        loader.associate_file_reader(".svs", self.state_reader) 
    259260        #Send the fitting panel to guiframe 
    260261        self.mypanels.append(self.fit_panel) 

  • sansview/perspectives/fitting/pagestate.py

    r3c44c66 rb35d3d1  
    603603     
    604604    ## Wildcards 
    605     type = ["Fitting files (*.fitv)|*.fitv"] 
     605    type = ["Fitting files (*.fitv)|*.fitv" 
     606            "SANSView file (*.svs)|*.svs"] 
    606607    ## List of allowed extensions 
    607     ext=['.fitv', '.FITV']   
     608    ext=['.fitv', '.FITV', '.svs', 'SVS']    
    608609     
    609610    def __init__(self, call_back=None, cansas=True): 
    … …  
    834835        """ 
    835836        # Create an empty state 
    836         state = PageState() 
     837        state = None    
    837838        # Locate the P(r) node 
    838839        try: 
    839840            nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME, namespaces={'ns': CANSAS_NS}) 
    840             state.fromXML(node=nodes[0]) 
     841            if nodes !=[]: 
     842                # Create an empty state 
     843                state =  PageState() 
     844                state.fromXML(node=nodes[0]) 
    841845        except: 
    842846            logging.info("XML document does not contain fitting information.\n %s" % sys.exc_value) 
    … …  
    11061110                    root = tree.getroot() 
    11071111                    entry_list = root.xpath('ns:SASentry', namespaces={'ns': CANSAS_NS}) 
    1108                     for entry in entry_list: 
     1112                    for entry in entry_list:    
    11091113                        try: 
    11101114                            sas_entry = self._parse_entry(entry) 
    … …  
    11121116                            raise 
    11131117                        fitstate = self._parse_state(entry) 
    1114                         sas_entry.meta_data['fitstate'] = fitstate 
    1115                         sas_entry.filename = fitstate.file 
    1116                         output.append(sas_entry) 
     1118                         
     1119                        #state could be None when .svs file is loaded 
     1120                        #in this case, skip appending to output 
     1121                        if fitstate != None: 
     1122                            sas_entry.meta_data['fitstate'] = fitstate 
     1123                            sas_entry.filename = fitstate.file 
     1124                            output.append(sas_entry) 
    11171125            else: 
    11181126                raise RuntimeError, "%s is not a file" % path 
    1119              
     1127 
    11201128            # Return output consistent with the loader's api 
    11211129            if len(output)==0: 
    11221130                return None 
    1123             elif len(output)==1: 
    1124                 # Call back to post the new state 
    1125                 state = output[0].meta_data['fitstate'] 
    1126                 t = time.localtime(state.timestamp) 
    1127                 time_str = time.strftime("%b %d %H:%M", t) 
    1128                 # Check that no time stamp is already appended 
    1129                 max_char = state.file.find("[") 
    1130                 if max_char < 0: 
    1131                     max_char = len(state.file) 
    1132                 state.file = state.file[0:max_char] +' [' + time_str + ']' 
    1133                 
    1134                      
    1135                 if state is not None and state.is_data is not None: 
    1136                     exec 'output[0].is_data = state.is_data'  
    1137                   
    1138                 output[0].filename = state.file 
    1139                 state.data = output[0] 
    1140                 state.data.name = output[0].filename #state.data_name 
    1141                 state.data.id = state.data_id 
    1142                 state.data.id = state.data_id 
    1143                 if state.is_data is not None: 
    1144                     state.data.is_data = state.is_data 
    1145                 state.data.group_id = output[0].filename 
     1131            else: 
     1132                for ind in range(len(output)): 
     1133                    # Call back to post the new state 
     1134                    state = output[ind].meta_data['fitstate'] 
     1135                    t = time.localtime(state.timestamp) 
     1136                    time_str = time.strftime("%b %d %H:%M", t) 
     1137                    # Check that no time stamp is already appended 
     1138                    max_char = state.file.find("[") 
     1139                    if max_char < 0: 
     1140                        max_char = len(state.file) 
     1141                    state.file = state.file[0:max_char] +' [' + time_str + ']' 
     1142                    
     1143                         
     1144                    if state is not None and state.is_data is not None: 
     1145                        exec 'output[%d].is_data = state.is_data'% ind  
     1146                      
     1147                    output[ind].filename = state.file 
     1148                    state.data = output[ind] 
     1149                    state.data.name = output[ind].filename #state.data_name 
     1150                    state.data.id = state.data_id 
     1151                    state.data.id = state.data_id 
     1152                    if state.is_data is not None: 
     1153                        state.data.is_data = state.is_data 
     1154                    state.data.group_id = output[ind].filename 
     1155                   
     1156                    # make sure to put run name if none 
     1157                    #if output[ind].run == None or output[ind].run ==[]: 
     1158                    #    exec 'output[%d].run = [output[%d].filename]'% (ind,ind) 
     1159                    self.call_back(state=state, datainfo=output[ind]) 
     1160                    return output[ind] 
    11461161               
    1147                 self.call_back(state=state, datainfo=output[0]) 
    1148                 return output[0] 
    1149             else: 
    1150                 return output                 
    11511162        except: 
    11521163            raise 
    … …  
    11541165    def write(self, filename, datainfo=None, fitstate=None): 
    11551166        """ 
    1156         Write the content of a Data1D as a CanSAS XML file 
     1167        Write the content of a Data1D as a CanSAS XML file only for standalone 
    11571168         
    11581169        :param filename: name of the file to write 
    … …  
    11651176             
    11661177            # Add fitting information to the XML document 
    1167             if fitstate is not None: 
    1168                 if fitstate.data is None: 
    1169                     data = DataLoader.data_info.Data1D(x=[], y=[])    
    1170                 elif issubclass(fitstate.data.__class__, DataLoader.data_info.Data1D): 
    1171                     data = fitstate.data 
    1172                     doc, sasentry = self._to_xml_doc(data) 
    1173                 else: 
    1174                     data = fitstate.data 
    1175                     doc, sasentry = self._data2d_to_xml_doc(data) 
    1176                 fitstate.toXML(doc=doc, file=data.name, entry_node=sasentry) 
     1178            self.write_toXML(datainfo, fitstate) 
    11771179            # Write the XML document 
    11781180            fd = open(filename, 'w') 
    … …  
    11821184            fitstate.toXML(file=filename) 
    11831185         
    1184  
     1186    def write_toXML(self, datainfo=None, state=None): 
     1187        """ 
     1188        Write toXML, a helper for write() , could be used by guimanager._on_save() 
     1189         
     1190        : return: xml doc 
     1191        """ 
     1192 
     1193        if state.data is None: 
     1194            data = DataLoader.data_info.Data1D(x=[], y=[])   
     1195        else:   
     1196            #make sure title and data run is filled up. 
     1197            #if state.data.title == None or state.data.title=='': state.data.title = state.data.name 
     1198            #if state.data.run_name == None or state.data.run_name=={}:  
     1199            #    state.data.run = [str(state.data.name)] 
     1200            #    state.data.run_name[0] = state.data.name 
     1201    
     1202            if issubclass(state.data.__class__, DataLoader.data_info.Data1D): 
     1203                data = state.data 
     1204                doc, sasentry = self._to_xml_doc(data) 
     1205            else: 
     1206                data = state.data 
     1207                doc, sasentry = self._data2d_to_xml_doc(data) 
     1208             
     1209 
     1210        if state is not None: 
     1211            state.toXML(doc=doc, file=data.name, entry_node=sasentry) 
     1212             
     1213        return doc  
    11851214   
    11861215if __name__ == "__main__": 
Note: See TracChangeset for help on using the changeset viewer.