Changeset cfc0913 in sasview for sansview/perspectives


Ignore:
Timestamp:
Apr 6, 2009 4:56:35 PM (16 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:
40f9745
Parents:
ddfcd90
Message:

working on saving page status

Location:
sansview/perspectives/fitting
Files:
5 edited
1 moved

Legend:

Unmodified
Added
Removed

  • sansview/perspectives/fitting/basepage.py

    r87a43fe rcfc0913  
    66from sans.guiframe.utils import format_number 
    77from sans.guicomm.events import StatusEvent    
    8  
     8import pagestate 
     9from pagestate import PageState 
     10(PageInfoEvent, EVT_PAGE_INFO)   = wx.lib.newevent.NewEvent() 
    911_BOX_WIDTH = 80 
    1012 
    … …  
    1315        This class provide general structure of  fitpanel page 
    1416    """ 
    15     ## Internal name for the AUI manager 
    16     window_name = "Fit page" 
    17     ## Title to appear on top of the window 
    18     window_caption = "Fit Page" 
    19      
    20     name="" 
    21      
    22     def __init__(self,parent, pageinfo, name): 
     17     
     18    def __init__(self,parent, page_info): 
    2319        wx.ScrolledWindow.__init__(self, parent) 
    2420        ## store name 
    25         self.name = name 
    26         ## store info of panel 
    27         self.page_info= pageinfo 
    28         self.page_info.page_name = name 
     21        self.name = page_info.name 
     22        ##window_name 
     23        self.window_name = page_info.window_name 
     24        ##window_caption 
     25        self.window_caption = page_info.window_caption 
    2926        ## parent of the page 
    3027        self.parent = parent 
    3128        ## manager is the fitting plugin 
    32         self.manager=None 
     29        self.manager= page_info.manager 
    3330        ## owner of the page (fitting plugin) 
    34         self.event_owner= None 
    35         ## create the basic structure of the panel with empty sizer 
    36         self.define_page_structure() 
     31        self.event_owner= page_info.event_owner 
     32         ## current model 
     33        self.model = page_info.model 
     34        ## data 
     35        self.data = page_info.data 
    3736        ## dictionary containing list of models 
    38         self.model_list_box={} 
     37        self.model_list_box = page_info.model_list_box 
    3938        ## Data member to store the dispersion object created 
    4039        self._disp_obj_dict = {} 
     40        ## selected parameters to apply dispersion 
    4141        self.disp_cb_dict ={} 
    4242        ##list of model parameters. each item must have same length 
    … …  
    5252        ##list of dispersion parameters 
    5353        self.disp_list=[] 
    54          
     54        if self.model !=None: 
     55            self.disp_list= self.model.getDispParamList() 
    5556        ##enable model 2D draw 
    5657        self.enable2D= False 
    5758        ## check that the fit range is correct to plot the model again 
    5859        self.fitrange= True 
    59         ## current model 
    60         self.model= None 
    61         ## data 
    62         self.data=None 
    6360        ## Q range 
    6461        self.qmin_x= 0.001 
    6562        self.qmax_x= 0.1 
    6663        self.num_points= 100 
    67         ## changing initial values given page_info value 
    68         if self.page_info !=None and len(self.page_info.model_list_box) >0: 
    69             self.model_list_box = self.page_info.model_list_box 
    70             ## current model 
    71             self.model=self.page_info.model 
    72             self.data = self.page_info.data 
    73             self.event_owner = self.page_info.event_owner 
    74             self.manager=self.page_info.manager 
    75              
    76             if self.model !=None: 
    77                 self.disp_list= self.model.getDispParamList() 
     64        ## Create memento to save the current state 
     65         
     66        self.state= PageState(parent= self.parent,model=self.model, data=self.data) 
     67        ## create the basic structure of the panel with empty sizer 
     68        self.define_page_structure() 
    7869        ## drawing Initial dispersion parameters sizer  
    7970        self.set_dispers_sizer() 
    8071        self._fill_save_sizer() 
     72         
    8173        ## layout 
    8274        self.set_layout() 
    … …  
    134126        """ 
    135127        self.event_owner = owner     
    136         self.page_info.event_owner = owner 
     128        self.state.event_owner = owner 
    137129   
    138130    def set_manager(self, manager): 
    … …  
    142134        """ 
    143135        self.manager = manager   
    144         self.page_info.manager = manager 
     136        self.state.manager = manager 
    145137         
    146138    def populate_box(self, dict): 
    … …  
    150142        """ 
    151143        self.model_list_box = dict 
    152         if self.page_info!=None: 
    153             self.page_info.model_list_box = self.model_list_box 
     144        self.state.model_list_box = self.model_list_box 
    154145             
    155146     
    … …  
    165156        self.disable_disp = wx.RadioButton(self, -1, 'No', (10, 10), style=wx.RB_GROUP) 
    166157        self.enable_disp = wx.RadioButton(self, -1, 'Yes', (10, 30)) 
     158        ## saving the state of enable dispersity button 
     159        self.state.enable_disp= self.enable_disp.GetValue() 
     160         
    167161        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, id=self.disable_disp.GetId()) 
    168162        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, id=self.enable_disp.GetId()) 
    … …  
    278272            save history of the data and model 
    279273        """ 
    280         self.page_info.model= self.model 
    281         self.page_info.data = self.data 
     274        self.state.model= self.model 
     275        self.state.data = self.data 
    282276        import os 
    283277                  
    … …  
    363357            after fitting 
    364358        """ 
     359         
    365360        if hasattr(self,"text2_3"): 
    366361            self.text2_3.Hide() 
    … …  
    420415        except: 
    421416            raise  
    422       
    423      
     417     
     418     
     419    def createMemento(self): 
     420        """ 
     421            return the current state of the page 
     422        """ 
     423        return self.state.clone() 
     424     
     425     
     426    def save_current_state(self): 
     427        """ 
     428            Store current state 
     429        """ 
     430        self.state.model = self.model.clone() 
     431        self.state.save_data(self.data) 
     432     
     433        if hasattr(self,"cb1"): 
     434            self.state.cb1= self.cb1.GetValue() 
     435             
     436        if hasattr(self,"enable_disp"): 
     437            self.state.enable_disp= self.enable_disp.GetValue() 
     438             
     439        if hasattr(self,"enable_smearer"): 
     440            self.state.enable_smearer = self.enable_smearer.GetValue()    
     441       
     442        ## save checkbutton state and txtcrtl values 
     443        self.state.parameters=[] 
     444        self.state.fittable_param=[] 
     445        self.state.fixed_param=[] 
     446        self._copy_parameters_state(self.parameters, self.state.parameters) 
     447        self._copy_parameters_state(self.fittable_param, self.state.fittable_param) 
     448        self._copy_parameters_state(self.fixed_param, self.state.fixed_param) 
     449         
     450        ## post state to fit panel 
     451        event = PageInfoEvent(page = self) 
     452        wx.PostEvent(self.parent, event) 
     453     
     454    def reset_page(self, state): 
     455        """ 
     456            Use page_info and change the state of existing button 
     457        """ 
     458        self.state = state.clone() 
     459        self.model= self.state.model 
     460        self.data = self.state.data 
     461        self._set_model_sizer_selection( self.model ) 
     462        self.set_model_param_sizer(self.model) 
     463        self._reset_plotting_range() 
     464         
     465        self.enable_disp.SetValue(self.state.enable_disp) 
     466        self._set_dipers_Param(event=None) 
     467         
     468        if hasattr(self,"enable_smearer"): 
     469            self.enable_smearer= self.state.enable_smearer 
     470        if hasattr(self, "cb1"):     
     471            self.cb1.SetValue(self.state.cb1) 
     472        self._reset_parameters_state(self.parameters,state.parameters) 
     473        self._reset_parameters_state(self.fittable_param,state.fittable_param) 
     474        self._reset_parameters_state(self.fixed_param,state.fixed_param) 
     475        self._draw_model() 
     476         
     477         
    424478    def _selectDlg(self): 
    425479        """ 
    … …  
    433487        dlg.Destroy() 
    434488        return path 
    435            
    436      
     489     
     490     
     491    def _reset_plotting_range(self): 
     492        """ 
     493            Reset the plotting range to a given state 
     494        """ 
     495         
     496        self.qmin.SetValue(format_number(self.state.qmin)) 
     497        self.qmax.SetValue(format_number(self.state.qmax))  
     498        if self.state.npts!=None: 
     499            self.npts= self.state.npts 
     500             
     501        self.qmin_x = float(self.qmin.GetValue()) 
     502        self.qmax_x = float(self.qmax.GetValue()) 
     503         
     504         
     505    def _save_plotting_range(self ): 
     506        """ 
     507            save the state of plotting range  
     508        """ 
     509        self.state.qmin = self.qmin.GetValue()    
     510        self.state.qmax = self.qmax.GetValue()    
     511        if self.npts!=None: 
     512            self.state.npts= self.npts.GetValue() 
     513             
     514             
    437515    def _onparamEnter_helper(self): 
    438516        """ 
    … …  
    442520        """ 
    443521        if self.model !=None: 
    444              
     522            self.save_current_state() 
    445523            # Flag to register when a parameter has changed. 
    446524            is_modified = False 
    … …  
    449527            is_modified =self._check_value_enter( self.parameters ,is_modified)         
    450528            
     529             
    451530            self.Layout() 
    452531            # Here we should check whether the boundaries have been modified. 
    … …  
    473552                 
    474553                 
     554    def _reset_parameters_state(self, listtorestore,statelist): 
     555        """ 
     556            Reset the parameters at the given state 
     557        """ 
     558        if len(self.state.parameters)!=  len(listtorestore) : 
     559            return 
     560        for j in range(len(listtorestore)): 
     561            item_page = listtorestore[j] 
     562            item_page_info = statelist[j] 
     563            ##change the state of the check box for simple parameters 
     564            if item_page[0]!=None: 
     565                item_page[0].SetValue(item_page_info[0]) 
     566     
     567            if item_page[2]!=None: 
     568                item_page[2].SetValue(item_page_info[2]) 
     569                 
     570            if item_page[3]!=None: 
     571                ## show or hide text +/- 
     572                if item_page_info[2]: 
     573                    item_page[3].Show(True) 
     574                else: 
     575                    item_page[3].Hide() 
     576            if item_page[4]!=None: 
     577                ## show of hide the text crtl for fitting error 
     578                if item_page_info[4][0]: 
     579                    item_page[4].Show(True) 
     580                    item_page[4].SetValue(item_page_info[4][1]) 
     581                else: 
     582                    item_page[3].Hide() 
     583            if item_page[5]!=None: 
     584                ## show of hide the text crtl for fitting error 
     585                if item_page_info[5][0]: 
     586                    item_page[5].Show(True) 
     587                    item_page[5].SetValue(item_page_info[4][1]) 
     588                else: 
     589                    item_page[5].Hide() 
     590                     
     591            if item_page[6]!=None: 
     592                ## show of hide the text crtl for fitting error 
     593                if item_page_info[6][0]: 
     594                    item_page[6].Show(True) 
     595                    item_page[6].SetValue(item_page_info[6][1]) 
     596                else: 
     597                    item_page[6].Hide() 
     598                             
     599    def _copy_parameters_state(self, listtocopy, statelist): 
     600        """ 
     601            copy the state of button  
     602            @param listtocopy: the list of check button to copy 
     603            @param statelist: list of state object to store the current state 
     604        """ 
     605        if len(listtocopy)==0: 
     606            return 
     607         
     608        for item in listtocopy: 
     609            checkbox_state = None 
     610            if item[0]!= None: 
     611                checkbox_state= item[0].GetValue() 
     612            parameter_name = item[1] 
     613            parameter_value = None 
     614            if item[2]!=None: 
     615                parameter_value = item[2].GetValue() 
     616            static_text = None 
     617            if item[3]!=None: 
     618                static_text = item[3].IsShown() 
     619            error_value = None 
     620            error_state = None 
     621            if item[4]!= None: 
     622                error_value = item[4].GetValue() 
     623                error_state = item[4].IsShown() 
     624                 
     625            min_value = None 
     626            min_state = None 
     627            if item[5]!= None: 
     628                min_value = item[5].GetValue() 
     629                min_state = item[5].IsShown() 
     630                 
     631            max_value = None 
     632            max_state = None 
     633            if item[6]!= None: 
     634                max_value = item[6].GetValue() 
     635                max_state = item[6].IsShown() 
     636                
     637            statelist.append([checkbox_state, parameter_name, parameter_value, 
     638                              static_text ,[error_state,error_value], 
     639                                [min_state,min_value],[max_state , max_value],None]) 
     640            
     641         
     642    
    475643    def _set_model_sizer_selection(self, model): 
    476644        """ 
    … …  
    565733                     
    566734         
    567          
    568735    def _draw_model(self): 
    569736        """ 
    … …  
    606773                            id= self.plugin_rbutton.GetId() )   
    607774        wx.EVT_CHECKBOX(self, self.multip_cb.GetId() , self._show_combox )               
    608         ## store state 
    609         self.page_info.save_radiobox_state( self.shape_rbutton ) 
    610         self.page_info.save_radiobox_state( self.shape_indep_rbutton ) 
    611         self.page_info.save_radiobox_state( self.struct_rbutton ) 
    612         self.page_info.save_radiobox_state( self.plugin_rbutton ) 
    613         
    614          
     775       
    615776        sizer_radiobutton = wx.GridSizer(3, 3,5, 5) 
    616777        sizer_radiobutton.Add(self.shape_rbutton) 
    … …  
    674835            Show combox box associate with type of model selected 
    675836        """ 
    676         self.page_info.save_radiobox_state( self.shape_rbutton ) 
    677         self.page_info.save_radiobox_state( self.shape_indep_rbutton ) 
    678         self.page_info.save_radiobox_state( self.struct_rbutton ) 
    679         self.page_info.save_radiobox_state( self.plugin_rbutton ) 
    680          
    681837        ## Don't want to populate combo box again if the event comes from check box 
    682838        if self.shape_rbutton.GetValue()and\ 
    … …  
    758914         
    759915        self.set_scroll() 
    760          
    761          
    762916    
    763917             
    … …  
    781935        except: 
    782936            pass 
    783         #wx.EVT_COMBOBOX(combobox,-1, self._on_select_model)  
     937     
    784938        return 0 
    785939    
    … …  
    811965        else: 
    812966            self.model= form_factor() 
    813         self.page_info.model= self.model 
     967        
     968        ## post state to fit panel 
     969        self.save_current_state() 
    814970        
    815971         
    … …  
    842998                    if format_number(item[5].GetValue())!="NaN": 
    843999                        param_min = float(item[5].GetValue()) 
    844                     self.model.details[name][1]=param_min 
     1000                     
    8451001                ## check maximum value 
    8461002                if item[6]!= None: 
    … …  
    8541010                        msg+= "name %s of model %s "%(name, self.model.name) 
    8551011                        wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
    856                      
    857                 self.model.details[name][1:]= param_min,param_max 
     1012                if name in self.model.details.keys():    
     1013                    self.model.details[name][1:]= param_min,param_max 
    8581014                 
    8591015                ## hide statictext +/-     
    … …  
    8781034        return is_modified  
    8791035         
    880          
    8811036  
    8821037    def _set_dipers_Param(self, event): 
    … …  
    8891044            return  
    8901045        else: 
     1046            
    8911047            if self.enable_disp.GetValue(): 
    8921048                self.model_disp.Show(True) 
    … …  
    9031059                self.sizer4_4.Clear(True) 
    9041060                self._reset_dispersity() 
     1061                 
     1062           
     1063            ## post state to fit panel 
     1064            self.save_current_state() 
    9051065             
    9061066            self.sizer4.Layout() 
    … …  
    9081068            self.SetScrollbars(20,20,200,100) 
    9091069             
    910     
    9111070         
    9121071    def _layout_sizer_noDipers(self): 
    … …  
    9291088        return  
    9301089     
    931   
    9321090             
    9331091    def _reset_dispersity(self): 
    … …  
    9661124        if  name=="ArrayDispersion": 
    9671125            self._set_sizer_arraydispersion() 
    968              
    969              
     1126         
    9701127             
    9711128     
    … …  
    10381195           boxsizer1.Add((10,10)) 
    10391196        boxsizer1.Add(sizer_horizontal) 
    1040         
     1197        ## save state 
     1198        self.save_current_state() 
    10411199        #---------------------------------------------------------------- 
    10421200        self.sizer5.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10) 
    … …  
    10441202        self.Layout() 
    10451203        self.SetScrollbars(20,20,200,100) 
     1204     
    10461205     
    10471206    def _fill_save_sizer(self): 

  • sansview/perspectives/fitting/fitpage.py

    rdcf29d7 rcfc0913  
    2626   
    2727    """ 
    28     def __init__(self,parent, page_info, name=""): 
    29         BasicPage.__init__(self, parent, page_info,name) 
     28    def __init__(self,parent, page_info): 
     29        BasicPage.__init__(self, parent, page_info) 
    3030        """  
    3131            Initialization of the Panel 
    3232        """ 
    33         self.name= self.data.name 
    34         page_info.page_name= self.data.name 
    35         
     33        self.name = self.data.name 
     34         
    3635        ## fit page does not content npts txtcrtl 
    3736        self.npts=None 
    … …  
    4241         
    4342        self._fill_datainfo_sizer() 
     43         
    4444        self._fill_model_sizer( self.sizer1) 
     45        self._on_select_model(event=None) 
    4546        self._fill_range_sizer()  
    46         self.model = self.formfactorbox.GetClientData(0)() 
    47         self.page_info.model= self.model 
    48         self._on_select_model(event=None) 
     47         
     48        
     49        ## to update the panel according to the fit engine type selected 
    4950        self.Bind(EVT_FITTER_TYPE,self._on_engine_change) 
    5051     
    … …  
    9293        """ 
    9394        ## save state of radiobox 
    94         self.page_info. save_radiobox_state( self.description_hide ) 
    95         self.page_info. save_radiobox_state( self.description_show ) 
     95        #self.page_info. save_radiobox_state( self.description_hide ) 
     96        #self.page_info. save_radiobox_state( self.description_show ) 
    9697        ## Show description 
    9798        if not self.description_show.GetValue(): 
    … …  
    99100             
    100101        else: 
    101             model=self.page_info.model 
     102            #model=self.page_info.model 
     103             
    102104            description="" 
    103             if model!=None: 
    104                 description = self.page_info.model.description 
     105            if self.model!=None: 
     106                description = self.model.description 
     107                #description = self.page_info.model.description 
    105108            self.description = wx.StaticText( self,-1,str(description) ) 
    106109            self.sizer_description.Add( self.description, 1, wx.EXPAND | wx.ALL, 10 ) 
    … …  
    410413        self.compute_chisqr() 
    411414         
     415         
    412416    def get_range(self): 
    413417        """ 
    … …  
    512516                            "Data contains smearing information %s"%msg)) 
    513517            self.manager.set_smearer(smear, qmin= self.qmin_x, qmax= self.qmax_x)    
    514                
     518        ## save the state enable smearing 
     519        self.save_current_state() 
    515520   
    516521    def compute_chisqr2D(self): 
    … …  
    593598        """ 
    594599        self.param_toFit=[] 
     600         
    595601        if  self.parameters !=[]: 
    596602            if  self.cb1.GetValue()==True: 
    … …  
    608614                    item[0].SetValue(False) 
    609615                self.param_toFit=[] 
    610                 
     616        self.save_current_state()   
     617         
    611618                 
    612619                 
    … …  
    640647        else: 
    641648            self.cb1.SetValue(False) 
    642      
     649        ## save current state of the page 
     650        self.save_current_state() 
     651         
    643652     
    644653    def set_model_description(self,description,sizer): 
    … …  
    669678      
    670679         
    671         self.page_info.save_radiobox_state( self.description_hide ) 
    672         self.page_info.save_radiobox_state( self.description_show ) 
     680        #self.page_info.save_radiobox_state( self.description_hide ) 
     681        #self.page_info.save_radiobox_state( self.description_show ) 
    673682         
    674683        sizer_selection.Add( self.description_show ) 
    … …  
    700709        self.sizer3.Clear(True) 
    701710        self.parameters = [] 
     711        #self.page_info.parameters=[] 
    702712        self.param_toFit=[] 
    703713        self.fittable_param=[] 
    … …  
    823833                self.parameters.append([cb,item, ctl1, 
    824834                                        text2,ctl2, ctl3, ctl4,None]) 
     835                #self.page_info.parameters.append([cb.GetValue(),item, ctl1.GetValue(), 
     836                #                        text2.IsShown(),[ctl2.IsShown(),ctl2.GetValue()], 
     837                #[ctl3.IsShown(),ctl3.GetValue()],[ ctl4.IsShown(),ctl4.GetValue()],None]) 
    825838                 
    826839        iy+=1 
    … …  
    855868        data= Data1D(x=[1,2], y=[3,4], dy=[0.1, 0,1]) 
    856869     
    857         from pageInfo import PageInfo 
     870        from fitpanel import PageInfo 
    858871        myinfo = PageInfo(self,  model, data=data ) 
    859872         

  • sansview/perspectives/fitting/fitpanel.py

    rdcf29d7 rcfc0913  
    66#import models 
    77_BOX_WIDTH = 80 
    8 (PageInfoEvent, EVT_PAGE_INFO)   = wx.lib.newevent.NewEvent() 
    9  
     8import basepage 
     9 
     10class PageInfo(object): 
     11    """ 
     12        this class contains the minimum numbers of data members 
     13        a fitpage or model page need to be initialized. 
     14    """ 
     15    data = None 
     16    model= None 
     17    manager= None 
     18    event_owner= None 
     19    model_list_box = None 
     20    name=None 
     21     ## Internal name for the AUI manager 
     22    window_name = "Page" 
     23    ## Title to appear on top of the window 
     24    window_caption = "Page" 
     25     
     26    def __init__(self, model=None,data=None, manager=None, 
     27                  event_owner=None,model_list_box=None , name=None): 
     28        """ 
     29            Initialize data members 
     30        """ 
     31        self.data = data 
     32        self.model= model 
     33        self.manager= manager 
     34        self.event_owner= event_owner 
     35        self.model_list_box = model_list_box 
     36        self.name=None 
     37        self.window_name = "Page" 
     38        self.window_caption = "Page" 
     39     
    1040class FitPanel(wx.aui.AuiNotebook):     
    1141 
    … …  
    4272        ##dictionary of page info 
    4373        self.page_info_dict={} 
    44         # save the title of the last page tab added 
    45         self.fit_page_name=[] 
     74        ## save the title of the last page tab added 
     75        self.fit_page_name={} 
     76        ## list of existing fit page 
     77        self.list_fitpage_name=[] 
    4678        self.draw_model_name=None 
    4779        #model page info 
    … …  
    5082        self.model_page=None 
    5183        self.sim_page=None 
     84        ## get the state of a page 
     85        self.Bind(basepage.EVT_PAGE_INFO, self._onGetstate) 
    5286        # increment number for model name 
    5387        self.count=0 
    … …  
    6195             close page and remove all references to the closed page 
    6296        """ 
    63         page_info = self.get_current_page().page_info.clone() 
    64         page_info.page_name = self.get_current_page().page_info.page_name 
     97        state = self.get_current_page().createMemento() 
     98        page_name = self.get_current_page().name 
    6599        page_finder = self.manager.get_page_finder()  
    66100        fitproblem = None 
    … …  
    69103            fitproblem= page_finder[self.get_current_page()] 
    70104             
    71         self.manager._add_page_onmenu(page_info.page_name, page_info, fitproblem) 
     105        self.manager._add_page_onmenu(page_name, fitproblem) 
    72106         
    73107        selected_page = self.GetPage(self.GetSelection()) 
    … …  
    80114             
    81115            #Delete the page from notebook 
    82             if selected_page.name in self.fit_page_name: 
    83                 self.fit_page_name.remove(selected_page.name) 
     116            if selected_page.name in self.list_fitpage_name: 
     117                self.list_fitpage_name.remove(selected_page.name) 
    84118                 
    85119            if selected_page.name== self.draw_model_name: 
    … …  
    139173        return self.sim_page 
    140174         
    141     def add_fit_page( self,data, page_info=None ): 
     175    def add_fit_page( self,data, reset=False ): 
    142176        """  
    143177            Add a fitting page on the notebook contained by fitpanel 
    … …  
    149183        except: 
    150184            name = 'Fit' 
    151         if page_info==None: 
    152             from pageInfo import  PageInfo 
    153             myinfo = PageInfo( self, data=data ) 
     185        if not name in self.list_fitpage_name: 
     186            myinfo = PageInfo( data=data, name=name ) 
    154187            myinfo.model_list_box = self.model_list_box.get_list() 
    155188            myinfo.event_owner = self.event_owner  
    156189            myinfo.manager = self.manager 
    157         else: 
    158             myinfo = page_info 
    159          
    160         if not name in self.fit_page_name : 
     190            myinfo.window_name = "Fit Page" 
     191            myinfo.window_caption = "Fit Page" 
     192         
     193            #if not name in self.fit_page_name : 
    161194            from fitpage import FitPage 
    162             panel = FitPage(parent= self, page_info=myinfo, name=name ) 
    163             panel.name = name 
    164             panel.window_name= "fitpage" 
     195            panel = FitPage(parent= self, page_info=myinfo) 
    165196            self.AddPage(page=panel,caption=name,select=True) 
    166             self.fit_page_name.append(name) 
    167              
     197            self.list_fitpage_name.append(name) 
     198            if reset: 
     199                if name in self.fit_page_name.keys(): 
     200                    memento= self.fit_page_name[name][0] 
     201                    panel.reset_page(memento) 
     202            else: 
     203                self.fit_page_name[name]=[] 
     204                self.fit_page_name[name].insert(0,panel.createMemento()) 
     205          
    168206            return panel  
    169207        else: 
    … …  
    195233                                         npts=npts, page_info=page_info) 
    196234            
     235    def  _onGetstate(self, event): 
     236        """ 
     237            copy the state of a page 
     238        """ 
     239        page= event.page 
     240        if page.name in self.fit_page_name: 
     241            self.fit_page_name[page.name].insert(0,page.createMemento())  
     242             
    197243                 
    198244    def _help_add_model_page(self,model,page_title, qmin=0,  
    … …  
    218264        ## creating object that contaning info about model  
    219265        if page_info==None: 
    220             from pageInfo import  PageInfo 
    221             myinfo = PageInfo( self, model=model) 
     266             
     267            myinfo = PageInfo(model=model ,name=page_title) 
    222268            myinfo.model_list_box = self.model_list_box.get_list() 
    223269            myinfo.event_owner = self.event_owner  
    224270            myinfo.manager = self.manager 
     271            myinfo.window_name = "Model Page" 
     272            myinfo.window_caption = "Model Page" 
    225273        else: 
    226274            myinfo = page_info 
    227275     
    228276        from modelpage import ModelPage 
    229         panel = ModelPage(self,myinfo,page_title) 
     277        panel = ModelPage(self,myinfo) 
    230278        
    231279        self.AddPage(page=panel,caption="Model",select=True) 
    232280 
    233         panel.name = page_title 
    234281        self.draw_model_name=page_title 
    235282        self.model_page_number=self.GetSelection() 

  • sansview/perspectives/fitting/fitting.py

    r0f5fe6b rcfc0913  
    447447               
    448448               
    449     def _add_page_onmenu(self, name, page_info,fitproblem=None): 
     449    def _add_page_onmenu(self, name,fitproblem=None): 
    450450        """ 
    451451            Add name of a closed page of fitpanel in a menu  
    … …  
    454454        for item in list: 
    455455            if name == item.GetItemLabel(): 
    456                 self.closed_page_dict[name][1:] = page_info, fitproblem 
     456                self.closed_page_dict[name][1] = fitproblem 
    457457                 
    458458        if not name in self.closed_page_dict.keys():     
    … …  
    460460            event_id = wx.NewId() 
    461461            self.menu1.Append(event_id, name, "Show %s fit panel" % name) 
    462             self.closed_page_dict[name]= [event_id,page_info, fitproblem] 
     462            self.closed_page_dict[name]= [event_id, fitproblem] 
    463463            wx.EVT_MENU(self.parent,event_id,  self._open_closed_page) 
    464464         
    … …  
    468468            reopen a closed page 
    469469        """ 
    470         for value in self.closed_page_dict.values(): 
     470        for name, value in self.closed_page_dict.iteritems(): 
    471471            if event.GetId() in value: 
    472                 id, page_info,fitproblem = value 
    473          
    474                 if page_info.page_name !="Model Page": 
    475                     page = self.fit_panel.add_fit_page(data= page_info.data, 
    476                                                         page_info=page_info) 
     472                id,fitproblem = value 
     473                 
     474                if name !="Model Page": 
     475                    data= fitproblem.get_fit_data() 
     476                    page = self.fit_panel.add_fit_page(data= data,reset=True) 
    477477                    if fitproblem != None: 
    478478                        self.page_finder[page]=fitproblem 
    … …  
    591591                        wx.PostEvent(self.parent, StatusEvent(status="Page was already Created")) 
    592592                except: 
    593                     wx.PostEvent(self.parent, StatusEvent(status="Creating Fit page: %s"\ 
    594                     %sys.exc_value)) 
    595                     return 
     593                    raise 
     594                    #wx.PostEvent(self.parent, StatusEvent(status="Creating Fit page: %s"\ 
     595                    #%sys.exc_value)) 
     596                    #return 
    596597     
    597598    def _single_fit_completed(self,result,pars,cpage, elapsed=None): 
    … …  
    605606           
    606607        """ 
    607         #wx.PostEvent(self.parent, StatusEvent(status="Single fit \ 
    608         #complete! " , type="stop")) 
     608        wx.PostEvent(self.parent, StatusEvent(status="Single fit \ 
     609        complete! " , type="stop")) 
    609610        try: 
    610611            for page, value in self.page_finder.iteritems(): 

  • sansview/perspectives/fitting/modelpage.py

    rdcf29d7 rcfc0913  
    2525    """ 
    2626    def __init__(self,parent, page_info, name=""): 
    27         BasicPage.__init__(self, parent, page_info,name) 
     27        BasicPage.__init__(self, parent, page_info) 
    2828        """  
    2929            Initialization of the Panel 
    … …  
    3333        self._fill_model_sizer( self.sizer1)   
    3434        self._fill_range_sizer()  
    35         if hasattr(self.page_info,"model"): 
    36             model=self.page_info.model 
    37             description="" 
    38             if model!=None: 
    39                 description = self.page_info.model.description 
     35        
     36        description="" 
     37        if self.model!=None: 
     38            #description = self.page_info.model.description 
     39            description = self.model.description 
    4040            self.set_model_param_sizer(self.model) 
    4141            self.set_model_description(description,self.sizer2) 
    … …  
    5959        """ 
    6060        ## save state of radiobox 
    61         self.page_info. save_radiobox_state( self.description_hide ) 
    62         self.page_info. save_radiobox_state( self.description_show ) 
     61        #self.page_info. save_radiobox_state( self.description_hide ) 
     62        #self.page_info. save_radiobox_state( self.description_show ) 
    6363        ## Show description 
    6464        if not self.description_show.GetValue(): 
    … …  
    6666             
    6767        else: 
    68             model=self.page_info.model 
     68            #model=self.page_info.model 
    6969            description="" 
    70             if model!=None: 
    71                 description = self.page_info.model.description 
     70            if self.model!=None: 
     71                #description = self.page_info.model.description 
     72                description = self.model.description 
    7273            self.description = wx.StaticText( self,-1,str(description) ) 
    7374            self.sizer_description.Add( self.description, 1, wx.EXPAND | wx.ALL, 10 ) 
    … …  
    9394        sizer_npts.Add(self.npts,1, wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 5)  
    9495        self._set_range_sizer( title="Plotted Q Range", object= sizer_npts) 
     96        
    9597        
    9698    def _on_select_model(self, event):  
    … …  
    291293        self.model_description.SetToolTipString("See more description in help menu.") 
    292294         
    293         self.page_info.save_radiobox_state( self.description_hide ) 
    294         self.page_info.save_radiobox_state( self.description_show ) 
     295        #self.page_info.save_radiobox_state( self.description_hide ) 
     296        #self.page_info.save_radiobox_state( self.description_show ) 
    295297         
    296298        sizer_selection.Add( self.description_show ) 
    … …  
    435437        #from sans.models.LineModel import LineModel 
    436438        #model = LineModel() 
    437         from pageInfo import PageInfo 
     439        from fitpanel import PageInfo 
    438440        myinfo = PageInfo(self,model) 
    439441        from models import ModelList 

  • sansview/perspectives/fitting/pagestate.py

    rdcf29d7 rcfc0913  
    44import copy 
    55 
    6 class PageInfo(object): 
     6class PageState(object): 
    77    """ 
    88        Contains info to reconstruct a page 
    … …  
    1616        ## Data member to store the dispersion object created 
    1717        self._disp_obj_dict = {} 
    18  
     18        ## reset True change the state of exsiting button 
     19        self.reset = False 
    1920        #Data used for fitting  
    2021        self.data = data 
    2122        # flag to allow data2D plot 
    22         self.enable2D=False 
     23        self.enable2D = False 
    2324        # model on which the fit would be performed 
    2425        self.model = model 
    … …  
    3132        self.event_owner = None 
    3233        ##page name 
    33         self.page_name="" 
     34        self.page_name = "" 
    3435        # Contains link between  model ,all its parameters, and panel organization 
    35         self.parameters=[] 
     36        self.parameters =[] 
    3637        # Contains list of parameters that cannot be fitted and reference to  
    3738        #panel objects  
    38         self.fixed_param=[] 
     39        self.fixed_param =[] 
    3940        # Contains list of parameters with dispersity and reference to  
    4041        #panel objects  
    41         self.fittable_param=[] 
     42        self.fittable_param =[] 
    4243        #list of dispersion paramaters 
    43         self.disp_list=[] 
     44        self.disp_list =[] 
    4445        #contains link between a model and selected parameters to fit  
    45         self.param_toFit=[] 
     46        self.param_toFit =[] 
    4647        #dictionary of model type and model class 
    47         self.model_list_box =None 
    48         ## list of check box    
    49         self.list_of_radiobox={}  
     48        self.model_list_box = None 
     49        
    5050        ## save  current value of combobox 
    5151        self.formfactorcombobox = "" 
    5252        self.structurecombobox  = "" 
     53        self.disp_box="" 
    5354        ## Qrange 
    54         self.qmin=None 
    55         self.qmax=None 
    56         self.npts=None 
     55        ## Q range 
     56        self.qmin= 0.001 
     57        self.qmax= 0.1 
     58        self.npts = None 
     59        ## enable smearering state 
     60        self.enable_smearer = False 
     61        ## disperity selection 
     62        self.enable_disp= False 
     63        ## state of selected all check button 
     64        self.cb1 = False 
    5765        
    58          
    59                    
    60     def save_radiobox_state(self, object ): 
     66    
     67    def save_data(self, data): 
    6168        """ 
    62             save  radiobox state  
    63             @param object: radiobox 
    64             self.list_of_check= ["label", id, state] 
    65             
     69            Save data 
    6670        """ 
    67         label = object.GetLabel() 
    68         id = object.GetId() 
    69         state = object.GetValue() 
    70         self.list_of_radiobox[label]=[label, id, state]     
     71        self.data = copy.deepcopy(data) 
    7172     
    7273     
     74         
    7375    def clone(self): 
    7476        model=None 
    … …  
    7678            model = self.model.clone() 
    7779         
    78         obj          = PageInfo( self.parent,model= model ) 
     80        obj          = PageState( self.parent,model= model ) 
    7981        obj.data = copy.deepcopy(self.data) 
    8082        obj.model_list_box = copy.deepcopy(self.model_list_box) 
    8183        obj.manager = self.manager 
    8284        obj.event_owner = self.event_owner 
     85        obj.parameters = copy.deepcopy(self.parameters) 
     86        obj.fixed_param = copy.deepcopy(self.fixed_param) 
     87        obj.fittable_param = copy.deepcopy(self.fittable_param) 
     88        obj.enable_disp= self.enable_disp 
     89        obj.enable_smearer = self.enable_smearer 
     90        obj.disp_box= copy.deepcopy(self.disp_box) 
     91        obj.cb1 = self.cb1 
    8392        return obj 
    8493 
     94class PageMemento(object): 
     95    """ 
     96        Store the state of a fitpage or model page of fitpanel 
     97    """ 
     98    def __init__(self, state): 
     99        """ Initialization""" 
     100        self.state = state 
    85101        
     102    def setState(self,state): 
     103        """ 
     104            set current state 
     105            @param state: new state 
     106        """ 
     107        self.state = state 
     108         
     109    def getState(self): 
     110        """ 
     111            @return state 
     112        """ 
     113        return self.state 
     114        
     115        
     116        
     117        
Note: See TracChangeset for help on using the changeset viewer.