Changeset 2f60121 in sasview for theoryview/perspectives


Ignore:
Timestamp:
Jan 10, 2011 2:22:39 PM (14 years ago)
Author:
Gervaise Alina <gervyh@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
015d109
Parents:
340c2b3
Message:

make panel inheriting from PanelBase?

Location:
theoryview/perspectives/theory
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • theoryview/perspectives/theory/basepage.py

    rda9ac4e6 r2f60121  
    11 
    2 import sys, os 
     2import sys 
     3import os 
    34import wx 
    45import numpy 
    … …  
    78import math 
    89import string 
    9 from sans.guiframe.utils import format_number,check_float 
     10from sans.guiframe.utils import format_number 
     11from sans.guiframe.utils import check_float 
    1012from sans.guicomm.events import StatusEvent 
    1113import pagestate 
    1214from pagestate import PageState 
    13 (PageInfoEvent, EVT_PAGE_INFO)   = wx.lib.newevent.NewEvent() 
    14 (PreviousStateEvent, EVT_PREVIOUS_STATE)   = wx.lib.newevent.NewEvent() 
    15 (NextStateEvent, EVT_NEXT_STATE)   = wx.lib.newevent.NewEvent() 
     15 
     16(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent() 
     17(PreviousStateEvent, EVT_PREVIOUS_STATE)= wx.lib.newevent.NewEvent() 
     18(NextStateEvent, EVT_NEXT_STATE) = wx.lib.newevent.NewEvent() 
     19 
    1620_BOX_WIDTH = 76 
    1721_QMIN_DEFAULT = 0.001 
    … …  
    1923_NPTS_DEFAULT = 50 
    2024#Control panel width  
    21 if sys.platform.count("darwin")==0: 
     25if sys.platform.count("darwin") == 0: 
    2226    PANEL_WIDTH = 450 
    2327    FONT_VARIANT = 0 
    … …  
    3842    window_caption = "Basic page " 
    3943     
    40     def __init__(self,parent, page_info= None, model_list_box=None): 
     44    def __init__(self,parent, page_info=None, model_list_box=None): 
    4145        wx.ScrolledWindow.__init__(self, parent, 
    42                  style= wx.FULL_REPAINT_ON_RESIZE ) 
     46                 style=wx.FULL_REPAINT_ON_RESIZE) 
    4347        #Set window's font size  
    4448        self.SetWindowVariant(variant=FONT_VARIANT) 
    45          
    4649        ## parent of the page 
    4750        self.parent = parent 
    … …  
    5255        ## owner of the page (fitting plugin) 
    5356        self.event_owner = None 
    54          
    5557        if page_info is not None: 
    5658            ## manager is the fitting plugin 
    57             self.manager= page_info.manager 
     59            self.manager = page_info.manager 
    5860            ## owner of the page (fitting plugin) 
    59             self.event_owner= page_info.event_owner 
     61            self.event_owner = page_info.event_owner 
    6062             ## current model 
    6163            self.model = page_info.model 
    … …  
    7173        self._disp_obj_dict = {} 
    7274        ## selected parameters to apply dispersion 
    73         self.disp_cb_dict ={} 
    74  
     75        self.disp_cb_dict = {} 
    7576        ## smearer object 
    7677        self.smearer = None 
    77          
    7878        ##list of model parameters. each item must have same length 
    7979        ## each item related to a given parameters 
    8080        ##[cb state, name, value, "+/-", error of fit, min, max , units] 
    81         self.parameters=[] 
     81        self.parameters = [] 
    8282        # non-fittable parameter whose value is astring 
    8383        self.str_parameters = [] 
    8484        ## list of parameters to fit , must be like self.parameters 
    85         self.param_toFit=[] 
     85        self.param_toFit = [] 
    8686        ## list of looking like parameters but with non fittable parameters info 
    87         self.fixed_param=[] 
     87        self.fixed_param = [] 
    8888        ## list of looking like parameters but with  fittable parameters info 
    89         self.fittable_param=[] 
     89        self.fittable_param = [] 
    9090        ##list of dispersion parameters 
    91         self.disp_list=[] 
    92         self.disp_name="" 
     91        self.disp_list = [] 
     92        self.disp_name = "" 
    9393        ## list of orientation parameters 
    94         self.orientation_params=[] 
    95         self.orientation_params_disp=[] 
     94        self.orientation_params = [] 
     95        self.orientation_params_disp = [] 
    9696        if self.model != None: 
    97             self.disp_list= self.model.getDispParamList() 
     97            self.disp_list = self.model.getDispParamList() 
    9898        self.multi_factor = None 
    9999        ##enable model 2D draw 
    100         self.enable2D= False 
     100        self.enable2D = False 
    101101        ## check that the fit range is correct to plot the model again 
    102         self.fitrange= True 
    103  
     102        self.fitrange = True 
    104103        ## Q range 
    105         self.qmin_x= _QMIN_DEFAULT 
    106         self.qmax_x= _QMAX_DEFAULT 
    107         self.num_points= _NPTS_DEFAULT 
    108          
     104        self.qmin_x = _QMIN_DEFAULT 
     105        self.qmax_x = _QMAX_DEFAULT 
     106        self.num_points = _NPTS_DEFAULT 
    109107        ## Create memento to save the current state 
    110         self.state= PageState(parent= self.parent,model=self.model, data=self.data) 
     108        self.state = PageState(parent=self.parent, 
     109                               model=self.model, data=self.data) 
    111110        ## flag to determine if state has change 
    112         self.state_change= False 
     111        self.state_change = False 
    113112        ## save customized array 
    114         self.values=[] 
    115         self.weights=[] 
     113        self.values = [] 
     114        self.weights = [] 
    116115        ## retrieve saved state 
    117         self.number_saved_state= 0 
     116        self.number_saved_state = 0 
    118117        ## dictionary of saved state 
    119         self.saved_states={}  
     118        self.saved_states = {}  
    120119         
    121120        ## Create context menu for page 
    122121        self.popUpMenu = wx.Menu() 
    123122        #id = wx.NewId() 
    124         #self._undo = wx.MenuItem(self.popUpMenu,id, "Undo","cancel the previous action") 
     123        #self._undo = wx.MenuItem(self.popUpMenu,id, "Undo" 
     124        #,"cancel the previous action") 
    125125        #self.popUpMenu.AppendItem(self._undo) 
    126126        #self._undo.Enable(False) 
    … …  
    128128         
    129129        #id = wx.NewId() 
    130         #self._redo = wx.MenuItem(self.popUpMenu,id,"Redo"," Restore the previous action") 
     130        #self._redo = wx.MenuItem(self.popUpMenu,id,"Redo", 
     131        #" Restore the previous action") 
    131132        #self.popUpMenu.AppendItem(self._redo) 
    132133        #self._redo.Enable(False) 
    … …  
    135136        #if sys.platform.count("win32")>0:         
    136137        id = wx.NewId() 
    137         self._keep = wx.MenuItem(self.popUpMenu,id,"BookMark"," Keep the panel status to recall it later") 
     138        self._keep = wx.MenuItem(self.popUpMenu, id, "BookMark", 
     139                                 " Keep the panel status to recall it later") 
    138140        self.popUpMenu.AppendItem(self._keep) 
    139141        self._keep.Enable(True) 
    140142        wx.EVT_MENU(self, id, self.onSave) 
    141143        self.popUpMenu.AppendSeparator() 
    142      
    143144        ## Default locations 
    144145        self._default_save_location = os.getcwd()      
    … …  
    167168         
    168169        """ 
    169         ## Set to True when the mouse is clicked while the whole string is selected 
     170        ## Set to True when the mouse is clicked  
     171        #while the whole string is selected 
    170172        full_selection = False 
    171173        ## Call back for EVT_SET_FOCUS events 
    172174        _on_set_focus_callback = None 
    173175         
    174         def __init__(self, parent, id=-1, value=wx.EmptyString, pos=wx.DefaultPosition,  
    175                      size=wx.DefaultSize, style=0, validator=wx.DefaultValidator, name=wx.TextCtrlNameStr, 
    176                      kill_focus_callback = None, set_focus_callback  = None, 
    177                      mouse_up_callback   = None, text_enter_callback = None): 
     176        def __init__(self, parent, id=-1, value=wx.EmptyString, 
     177                      pos=wx.DefaultPosition,  
     178                     size=wx.DefaultSize, style=0,  
     179                     validator=wx.DefaultValidator, name=wx.TextCtrlNameStr, 
     180                     kill_focus_callback=None, set_focus_callback=None, 
     181                     mouse_up_callback=None, text_enter_callback=None): 
    178182              
    179             wx.TextCtrl.__init__(self, parent, id, value, pos, size, style, validator, name) 
     183            wx.TextCtrl.__init__(self, parent, id, value, pos, size, style, 
     184                                 validator, name) 
    180185             
    181186            # Bind appropriate events 
    … …  
    198203            :param event: mouse event 
    199204            """ 
    200              
    201205            event.Skip() 
    202206            self.full_selection = True 
    203207            return self._on_set_focus_callback(event) 
    204          
    205   
    206              
     208 
    207209        def _highlight_text(self, event): 
    208210            """ 
    … …  
    223225                    (start, end) = control.GetSelection() 
    224226                    if start==end: 
    225                         control.SetSelection(-1,-1) 
     227                        control.SetSelection(-1, -1) 
    226228                  
    227229    def onContextMenu(self, event):  
    … …  
    239241         
    240242        """ 
    241         event = PreviousStateEvent(page = self) 
     243        event = PreviousStateEvent(page=self) 
    242244        wx.PostEvent(self.parent, event) 
    243245     
    … …  
    247249         
    248250        """ 
    249         event = NextStateEvent(page= self) 
     251        event = NextStateEvent(page=self) 
    250252        wx.PostEvent(self.parent, event) 
    251253     
    … …  
    263265        self.sizer5 = wx.BoxSizer(wx.VERTICAL) 
    264266        self.sizer6 = wx.BoxSizer(wx.VERTICAL) 
    265          
    266267        self.sizer0.SetMinSize((PANEL_WIDTH,-1)) 
    267268        self.sizer1.SetMinSize((PANEL_WIDTH,-1)) 
    … …  
    271272        self.sizer5.SetMinSize((PANEL_WIDTH,-1)) 
    272273        #self.sizer6.SetMinSize((375,-1)) 
    273          
    274274        self.vbox.Add(self.sizer0) 
    275275        self.vbox.Add(self.sizer1) 
    … …  
    280280        #self.vbox.Add(self.sizer6) 
    281281         
    282          
    283282    def set_layout(self): 
    284283        """ 
    … …  
    295294        """ 
    296295        """ 
    297         self.SetScrollbars(20,20,25,65) 
     296        self.SetScrollbars(20, 20, 25, 65) 
    298297        self.Layout()    
    299298        self.SetAutoLayout(True) 
    … …  
    333332        self.sizer4.Clear(True) 
    334333        name = "Polydispersity and Orientational Distribution" 
    335         box_description= wx.StaticBox(self, -1,name) 
     334        box_description= wx.StaticBox(self, -1, name) 
    336335        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL) 
    337336        #---------------------------------------------------- 
    338         self.disable_disp = wx.RadioButton(self, -1, 'Off', (10, 10), style=wx.RB_GROUP) 
     337        self.disable_disp = wx.RadioButton(self, -1, 'Off', (10, 10),  
     338                                           style=wx.RB_GROUP) 
    339339        self.enable_disp = wx.RadioButton(self, -1, 'On', (10, 30)) 
    340340        
    341         self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, id=self.disable_disp.GetId()) 
    342         self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, id=self.enable_disp.GetId()) 
     341        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,  
     342                  id=self.disable_disp.GetId()) 
     343        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,  
     344                  id=self.enable_disp.GetId()) 
    343345        #MAC needs SetValue 
    344346        self.disable_disp.SetValue(True) 
    345347        sizer_dispersion = wx.BoxSizer(wx.HORIZONTAL) 
    346         sizer_dispersion.Add((20,20)) 
     348        sizer_dispersion.Add((20, 20)) 
    347349        name=""#Polydispersity and \nOrientational Distribution " 
    348         sizer_dispersion.Add(wx.StaticText(self,-1,name)) 
     350        sizer_dispersion.Add(wx.StaticText(self, -1, name)) 
    349351        sizer_dispersion.Add(self.enable_disp ) 
    350         sizer_dispersion.Add((20,20)) 
    351         sizer_dispersion.Add(self.disable_disp ) 
    352         sizer_dispersion.Add((10,10)) 
     352        sizer_dispersion.Add((20, 20)) 
     353        sizer_dispersion.Add(self.disable_disp) 
     354        sizer_dispersion.Add((10, 10)) 
    353355         
    354356        ## fill a sizer with the combobox to select dispersion type 
    … …  
    364366            self.disp_box.Append(name,value) 
    365367        self.disp_box.SetStringSelection("gaussian")  
    366         wx.EVT_COMBOBOX(self.disp_box,-1, self._on_select_Disp)  
     368        wx.EVT_COMBOBOX(self.disp_box, -1, self._on_select_Disp)  
    367369              
    368         sizer_select_dispers.Add((10,10))  
     370        sizer_select_dispers.Add((10, 10))  
    369371        sizer_select_dispers.Add(self.model_disp)  
    370         sizer_select_dispers.Add(self.disp_box,0, 
    371                 wx.TOP|wx.BOTTOM|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE,border=5) 
    372        
     372        sizer_select_dispers.Add(self.disp_box, 0, 
     373                wx.TOP|wx.BOTTOM|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, border=5) 
    373374        self.model_disp.Hide() 
    374375        self.disp_box.Hide() 
    375          
    376         boxsizer1.Add( sizer_dispersion,0, 
    377                 wx.TOP|wx.BOTTOM|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE,border=5) 
    378         #boxsizer1.Add( (10,10) ) 
    379         boxsizer1.Add( sizer_select_dispers ) 
    380         self.sizer4_4 = wx.GridBagSizer(5,5) 
    381         boxsizer1.Add( self.sizer4_4  ) 
     376        boxsizer1.Add(sizer_dispersion, 0, 
     377                wx.TOP|wx.BOTTOM|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, border=5) 
     378        #boxsizer1.Add((10, 10)) 
     379        boxsizer1.Add(sizer_select_dispers) 
     380        self.sizer4_4 = wx.GridBagSizer(5, 5) 
     381        boxsizer1.Add(self.sizer4_4) 
    382382        #----------------------------------------------------- 
    383         self.sizer4.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10) 
     383        self.sizer4.Add(boxsizer1, 0, wx.EXPAND|wx.ALL, 10) 
    384384        self.sizer4_4.Layout() 
    385385        self.sizer4.Layout() 
    386386        self.Layout() 
    387         self.SetScrollbars(20,20,25,65) 
     387        self.SetScrollbars(20, 20, 25, 65) 
    388388        self.Refresh() 
    389389        ## saving the state of enable dispersity button 
    … …  
    391391        self.state.disable_disp= self.disable_disp.GetValue() 
    392392     
    393      
    394393    def select_disp_angle(self, event):  
    395394        """ 
    … …  
    398397        :param event: radiobutton event 
    399398        """ 
    400         self.values=[] 
    401         self.weights=[] 
    402         if event.GetEventObject()==self.noDisper_rbox: 
     399        self.values = [] 
     400        self.weights = [] 
     401        if event.GetEventObject() == self.noDisper_rbox: 
    403402            if self.noDisper_rbox.GetValue(): 
    404403                #No array dispersity apply yet 
    … …  
    406405                ## Redraw the model ??? 
    407406                self._draw_model() 
    408         # Go through the list of dispersion check boxes to identify which one has changed  
     407        # Go through the list of dispersion check boxes to  
     408        #identify which one has changed  
    409409        for p in self.disp_cb_dict: 
    410             self.state.disp_cb_dict[p]= self.disp_cb_dict[p].GetValue() 
     410            self.state.disp_cb_dict[p] = self.disp_cb_dict[p].GetValue() 
    411411            # Catch which one of the box was just checked or unchecked. 
    412412            if event.GetEventObject() == self.disp_cb_dict[p]:               
    413413                if self.disp_cb_dict[p].GetValue() == True: 
    414                      
    415                     ##Temp. FIX for V1.0 regarding changing checkbox to radiobutton. 
    416                     ##This (self._reset_dispersity) should be removed when the array dispersion is fixed.                 
     414                    ##Temp. FIX for V1.0 regarding changing  
     415                    #checkbox to radiobutton. 
     416                    ##This (self._reset_dispersity) should be removed  
     417                    #when the array dispersion is fixed.                 
    417418                    self._reset_dispersity() 
    418  
    419419                    # The user wants this parameter to be averaged.  
    420420                    # Pop up the file selection dialog. 
    421421                    path = self._selectDlg() 
    422                      
    423422                    # If nothing was selected, just return 
    424423                    if path is None: 
    … …  
    431430                        pass  
    432431                    try: 
    433                         self.values,self.weights = self.read_file(path) 
     432                        self.values, self.weights = self.read_file(path) 
    434433                    except: 
    435                         msg="Could not read input file" 
    436                         wx.PostEvent(self.parent, StatusEvent(status= msg)) 
     434                        msg = "Could not read input file" 
     435                        wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    437436                        return 
    438                      
    439                     # If any of the two arrays is empty, notify the user that we won't 
    440                     # proceed  
     437                    # If any of the two arrays is empty, notify the user  
     438                    # that we won't proceed  
    441439                    if self.values is None or self.weights is None or \ 
    442                          self.values ==[] or self.weights ==[]: 
    443                         wx.PostEvent(self.parent, StatusEvent(status=\ 
    444                             "The loaded %s distrubtion is corrupted or empty" % p)) 
     440                         self.values == [] or self.weights == []: 
     441                        msg = "The loaded %s distrubtion is corrupted" 
     442                        msg += " or empty" % p 
     443                        wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    445444                        return 
    446                          
    447445                    # Tell the user that we are about to apply the distribution 
    448                     wx.PostEvent(self.parent, StatusEvent(status=\ 
    449                             "Applying loaded %s distribution: %s" % (p, path)))   
     446                    msg = "Applying loaded %s distribution: %s" % (p, path) 
     447                    wx.PostEvent(self.parent, StatusEvent(status=msg))   
    450448                     
    451449                    # Create the dispersion objects 
    … …  
    454452                    disp_model.set_weights(self.values, self.weights) 
    455453                    
    456                     # Store the object to make it persist outside the scope of this method 
     454                    # Store the object to make it persist outside the scope  
     455                    #of this method 
    457456                    #TODO: refactor model to clean this up? 
    458457                    self._disp_obj_dict[p] = disp_model 
    459                     self.state._disp_obj_dict [p]= disp_model 
    460                     self.state.values=[] 
    461                     self.state.weights=[] 
     458                    self.state._disp_obj_dict [p] = disp_model 
     459                    self.state.values = [] 
     460                    self.state.weights = [] 
    462461                    self.state.values = copy.deepcopy(self.values) 
    463462                    self.state.weights = copy.deepcopy(self.weights) 
    464                     # Set the new model as the dispersion object for the selected parameter 
     463                    # Set the new model as the dispersion object for the  
     464                    #selected parameter 
    465465                    self.model.set_dispersion(p, disp_model) 
    466                     # Store a reference to the weights in the model object so that 
     466                    # Store a reference to the weights in the model object  
     467                    #so that 
    467468                    # it's not lost when we use the model within another thread. 
    468469                    #TODO: total hack - fix this 
    … …  
    470471 
    471472                    self.model._persistency_dict = {} 
    472                     self.model._persistency_dict[p] = [self.values, self.weights] 
    473                     self.state.model._persistency_dict[p] = [self.values, self.weights] 
     473                    self.model._persistency_dict[p] = [self.values, 
     474                                                       self.weights] 
     475                    self.state.model._persistency_dict[p] = [self.values,  
     476                                                             self.weights] 
    474477                else: 
    475478                    self._reset_dispersity() 
    … …  
    479482         
    480483        ## post state to fit panel 
    481         event = PageInfoEvent(page = self) 
     484        event = PageInfoEvent(page=self) 
    482485        wx.PostEvent(self.parent, event) 
    483486        
    … …  
    489492        ## post help message for the selected model  
    490493        msg = self.popUpMenu.GetHelpString(event.GetId()) 
    491         msg +=" reloaded" 
    492         wx.PostEvent(self.parent, StatusEvent(status = msg )) 
    493          
    494         name= self.popUpMenu.GetLabel(event.GetId()) 
     494        msg += " reloaded" 
     495        wx.PostEvent(self.parent, StatusEvent(status=msg)) 
     496         
     497        name = self.popUpMenu.GetLabel(event.GetId()) 
    495498        self._on_select_model_helper() 
    496499         
    … …  
    500503            self.reset_page(previous_state)       
    501504   
    502                    
    503505    def onSave(self, event): 
    504506        """ 
    … …  
    506508         
    507509        """ 
    508         if self.model==None: 
     510        if self.model == None: 
    509511            return  
    510512        self.save_current_state() 
    … …  
    524526        self.number_saved_state += 1 
    525527        #name= self.model.name+"[%g]"%self.number_saved_state  
    526         name= self.model.__class__.__name__+"[%g]"%self.number_saved_state  
    527         self.saved_states[name]= new_state 
    528          
     528        name = self.model.__class__.__name__ + "[%g]" % self.number_saved_state  
     529        self.saved_states[name] = new_state 
    529530        ## Add item in the context menu 
    530          
    531         year, month, day,hour,minute,second,tda,ty,tm_isdst= time.localtime() 
    532         my_time= str(hour)+" : "+str(minute)+" : "+str(second)+" " 
    533         date= str( month)+"|"+str(day)+"|"+str(year) 
    534         msg=  "Model saved at %s on %s"%(my_time, date) 
     531        year, month, day, hour, minute, second, _, _, _ = time.localtime() 
     532        my_time = str(hour) + " : " + str(minute) + " : " + str(second) + " " 
     533        date = str( month) + "|" + str(day) + "|" + str(year) 
     534        msg = "Model saved at %s on %s" % (my_time, date) 
    535535         ## post help message for the selected model  
    536         msg +=" Saved! right click on this page to retrieve this model" 
    537         wx.PostEvent(self.parent, StatusEvent(status = msg )) 
     536        msg += " Saved! right click on this page to retrieve this model" 
     537        wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    538538         
    539539        id = wx.NewId() 
    540         self.popUpMenu.Append(id,name,str(msg)) 
     540        self.popUpMenu.Append(id, name, str(msg)) 
    541541        wx.EVT_MENU(self, id, self.onResetModel) 
    542542         
    … …  
    556556        """ 
    557557        try: 
    558             if path==None: 
    559                 wx.PostEvent(self.parent, StatusEvent(status=\ 
    560                             " Selected Distribution was not loaded: %s"%path)) 
     558            if path == None: 
     559                msg = " Selected Distribution was not loaded: %s" % path 
     560                wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    561561                return None, None 
    562562            input_f = open(path, 'r') 
    563563            buff = input_f.read() 
    564564            lines = buff.split('\n') 
    565              
    566565            angles = [] 
    567             weights=[] 
     566            weights = [] 
    568567            for line in lines: 
    569568                toks = line.split() 
    … …  
    580579            raise  
    581580     
    582      
    583581    def createMemento(self): 
    584582        """ 
    … …  
    587585        return self.state.clone() 
    588586     
    589      
    590587    def save_current_state(self): 
    591588        """ 
    … …  
    594591        """ 
    595592        ## save model option 
    596         if self.model!= None: 
    597             self.disp_list= self.model.getDispParamList() 
    598             self.state.disp_list= copy.deepcopy(self.disp_list) 
     593        if self.model != None: 
     594            self.disp_list = self.model.getDispParamList() 
     595            self.state.disp_list = copy.deepcopy(self.disp_list) 
    599596            self.state.model = self.model.clone() 
    600  
    601597        self.state.enable2D = copy.deepcopy(self.enable2D) 
    602         self.state.values= copy.deepcopy(self.values) 
     598        self.state.values = copy.deepcopy(self.values) 
    603599        self.state.weights = copy.deepcopy( self.weights) 
    604600        ## save data     
    605         self.state.data= copy.deepcopy(self.data) 
     601        self.state.data = copy.deepcopy(self.data) 
    606602        try: 
    607603            n = self.disp_box.GetCurrentSelection() 
    608604            dispersity= self.disp_box.GetClientData(n) 
    609             name= dispersity.__name__ 
     605            name = dispersity.__name__ 
    610606            self.disp_name = name 
    611             if name == "GaussianDispersion" : 
     607            if name == "GaussianDispersion": 
    612608               if hasattr(self,"cb1"): 
    613                    self.state.cb1= self.cb1.GetValue() 
     609                   self.state.cb1 = self.cb1.GetValue() 
    614610        except: 
    615611            pass 
    616          
    617         if hasattr(self,"enable_disp"): 
    618             self.state.enable_disp= self.enable_disp.GetValue() 
     612        if hasattr(self, "enable_disp"): 
     613            self.state.enable_disp = self.enable_disp.GetValue() 
    619614            self.state.disable_disp = self.disable_disp.GetValue() 
    620              
    621615        self.state.smearer = copy.deepcopy(self.smearer) 
    622         if hasattr(self,"enable_smearer"): 
     616        if hasattr(self, "enable_smearer"): 
    623617            self.state.enable_smearer = copy.deepcopy(self.enable_smearer.GetValue()) 
    624618            self.state.disable_smearer = copy.deepcopy(self.disable_smearer.GetValue()) 
    625              
    626         if hasattr(self,"disp_box"): 
     619        if hasattr(self, "disp_box"): 
    627620            self.state.disp_box = self.disp_box.GetCurrentSelection() 
    628  
    629             if len(self.disp_cb_dict)>0: 
    630                 for k , v in self.disp_cb_dict.iteritems(): 
    631           
    632                     if v ==None : 
    633                         self.state.disp_cb_dict[k]= v 
     621            if len(self.disp_cb_dict) > 0: 
     622                for k, v in self.disp_cb_dict.iteritems(): 
     623                    if v == None : 
     624                        self.state.disp_cb_dict[k] = v 
    634625                    else: 
    635626                        try: 
    636                             self.state.disp_cb_dict[k]=v.GetValue() 
     627                            self.state.disp_cb_dict[k] = v.GetValue() 
    637628                        except: 
    638                             self.state.disp_cb_dict[k]= None 
    639             
    640             if len(self._disp_obj_dict)>0: 
    641                 for k , v in self._disp_obj_dict.iteritems(): 
    642        
    643                     self.state._disp_obj_dict[k]= v 
    644                          
    645              
     629                            self.state.disp_cb_dict[k] = None 
     630            if len(self._disp_obj_dict) > 0: 
     631                for k, v in self._disp_obj_dict.iteritems(): 
     632                    self.state._disp_obj_dict[k] = v 
    646633            self.state.values = copy.deepcopy(self.values) 
    647634            self.state.weights = copy.deepcopy(self.weights) 
    648635        ## save plotting range 
    649636        self._save_plotting_range() 
    650          
    651         self.state.orientation_params =[] 
    652         self.state.orientation_params_disp =[] 
    653         self.state.parameters =[] 
    654         self.state.fittable_param =[] 
    655         self.state.fixed_param =[] 
    656  
    657          
     637        self.state.orientation_params = [] 
     638        self.state.orientation_params_disp = [] 
     639        self.state.parameters = [] 
     640        self.state.fittable_param = [] 
     641        self.state.fixed_param = [] 
    658642        ## save checkbutton state and txtcrtl values 
    659643        self._copy_parameters_state(self.orientation_params, 
    … …  
    661645        self._copy_parameters_state(self.orientation_params_disp, 
    662646                                     self.state.orientation_params_disp) 
    663          
    664647        self._copy_parameters_state(self.parameters, self.state.parameters) 
    665         self._copy_parameters_state(self.fittable_param, self.state.fittable_param) 
     648        self._copy_parameters_state(self.fittable_param,  
     649                                    self.state.fittable_param) 
    666650        self._copy_parameters_state(self.fixed_param, self.state.fixed_param) 
    667651   
    … …  
    675659            state of the graphic interface 
    676660        """ 
    677         if state ==None: 
     661        if state == None: 
    678662            #self._undo.Enable(False) 
    679663            return  
    680         
    681         self.model= state.model 
     664        self.model = state.model 
    682665        self.data = state.data 
    683         if self.data !=None: 
     666        if self.data != None: 
    684667            from DataLoader.qsmearing import smear_selection 
    685             self.smearer= smear_selection( self.data ) 
    686         self.enable2D= state.enable2D 
     668            self.smearer= smear_selection(self.data) 
     669        self.enable2D = state.enable2D 
    687670        self.engine_type = state.engine_type 
    688  
    689671        self.disp_cb_dict = state.disp_cb_dict 
    690672        self.disp_list = state.disp_list 
    691  
    692673        ## set the state of the radio box 
    693         self.shape_rbutton.SetValue(state.shape_rbutton ) 
     674        self.shape_rbutton.SetValue(state.shape_rbutton) 
    694675        self.shape_indep_rbutton.SetValue(state.shape_indep_rbutton) 
    695         self.struct_rbutton.SetValue(state.struct_rbutton ) 
     676        self.struct_rbutton.SetValue(state.struct_rbutton) 
    696677        self.plugin_rbutton.SetValue(state.plugin_rbutton) 
    697678        ##draw sizer containing model parameters value for the current model 
    698         self._set_model_sizer_selection( self.model ) 
     679        self._set_model_sizer_selection(self.model) 
    699680        self.set_model_param_sizer(self.model) 
    700  
    701681        ## reset value of combox box 
    702         self.structurebox.SetSelection(state.structurecombobox ) 
     682        self.structurebox.SetSelection(state.structurecombobox) 
    703683        self.formfactorbox.SetSelection(state.formfactorcombobox) 
    704684        if state.multi_factor != None: 
    … …  
    706686        #draw the pnael according to the new model parameter  
    707687        self._on_select_model(event=None) 
    708         
    709688        ## enable the view 2d button if this is a modelpage type 
    710         if hasattr(self,"model_view"): 
     689        if hasattr(self, "model_view"): 
    711690            if self.enable2D: 
    712691                self.model_view.Disable() 
    … …  
    716695        if hasattr(self, "cb1"):    
    717696            self.cb1.SetValue(state.cb1) 
    718       
    719697        ## reset state of checkbox,textcrtl  and  regular parameters value 
    720              
    721698        self._reset_parameters_state(self.orientation_params_disp, 
    722699                                     state.orientation_params_disp) 
    … …  
    725702        self._reset_parameters_state(self.str_parameters, 
    726703                                     state.str_parameters) 
    727         self._reset_parameters_state(self.parameters,state.parameters)     
     704        self._reset_parameters_state(self.parameters, state.parameters)     
    728705         ## display dispersion info layer         
    729706        self.enable_disp.SetValue(state.enable_disp) 
    730707        self.disable_disp.SetValue(state.disable_disp) 
    731          
    732708        if hasattr(self, "disp_box"): 
    733              
    734709            self.disp_box.SetSelection(state.disp_box)  
    735             n= self.disp_box.GetCurrentSelection() 
    736             dispersity= self.disp_box.GetClientData(n) 
    737             name= dispersity.__name__      
    738  
     710            n = self.disp_box.GetCurrentSelection() 
     711            dispersity = self.disp_box.GetClientData(n) 
     712            name = dispersity.__name__      
    739713            self._set_dipers_Param(event=None) 
    740         
    741             if name=="ArrayDispersion": 
    742                  
     714            if name == "ArrayDispersion": 
    743715                for item in self.disp_cb_dict.keys(): 
    744                      
    745                     if hasattr(self.disp_cb_dict[item],"SetValue") : 
     716                    if hasattr(self.disp_cb_dict[item], "SetValue") : 
    746717                        self.disp_cb_dict[item].SetValue(state.disp_cb_dict[item]) 
    747718                        # Create the dispersion objects 
    748719                        from sans.models.dispersion_models import ArrayDispersion 
    749720                        disp_model = ArrayDispersion() 
    750                         if hasattr(state,"values")and self.disp_cb_dict[item].GetValue()==True: 
    751                             if len(state.values)>0: 
    752                                 self.values=state.values 
    753                                 self.weights=state.weights 
    754                                 disp_model.set_weights(self.values, state.weights) 
     721                        if hasattr(state, "values") and \ 
     722                            self.disp_cb_dict[item].GetValue() == True: 
     723                            if len(state.values) > 0: 
     724                                self.values = state.values 
     725                                self.weights = state.weights 
     726                                disp_model.set_weights(self.values,  
     727                                                       state.weights) 
    755728                            else: 
    756729                                self._reset_dispersity() 
    757                          
    758730                        self._disp_obj_dict[item] = disp_model 
    759                         # Set the new model as the dispersion object for the selected parameter 
     731                        # Set the new model as the dispersion object for  
     732                        #the selected parameter 
    760733                        self.model.set_dispersion(item, disp_model) 
    761                      
    762                         self.model._persistency_dict[item] = [state.values, state.weights] 
    763                      
     734                        self.model._persistency_dict[item] = [state.values,  
     735                                                              state.weights] 
    764736            else: 
    765737                keys = self.model.getParamList() 
    766738                for item in keys: 
    767                     if item in self.disp_list and not self.model.details.has_key(item): 
    768                         self.model.details[item]=["",None,None] 
    769                 for k,v in self.state.disp_cb_dict.iteritems(): 
     739                    if item in self.disp_list and \ 
     740                        not self.model.details.has_key(item): 
     741                        self.model.details[item]=["", None, None] 
     742                for k, v in self.state.disp_cb_dict.iteritems(): 
    770743                    self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)  
    771744                    self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
    772  
    773745        ##plotting range restore     
    774746        self._reset_plotting_range(state) 
    775  
    776747        ## smearing info  restore 
    777         if hasattr(self,"enable_smearer"): 
    778             ## set smearing value whether or not the data contain the smearing info 
     748        if hasattr(self, "enable_smearer"): 
     749            ## set smearing value whether or not the data contain  
     750            #the smearing info 
    779751            self.enable_smearer.SetValue(state.enable_smearer) 
    780752            self.disable_smearer.SetValue(state.disable_smearer) 
    781753            self.onSmear(event=None)            
    782         
    783754        ## reset state of checkbox,textcrtl  and dispersity parameters value 
    784         self._reset_parameters_state(self.fittable_param,state.fittable_param) 
    785         self._reset_parameters_state(self.fixed_param,state.fixed_param) 
    786          
     755        self._reset_parameters_state(self.fittable_param, state.fittable_param) 
     756        self._reset_parameters_state(self.fixed_param, state.fixed_param) 
    787757        ## draw the model with previous parameters value 
    788758        self._onparamEnter_helper() 
    789  
    790759        ## reset context menu items 
    791760        self._reset_context_menu() 
    … …  
    799768         
    800769        """ 
    801         import os 
     770        #import os 
    802771        dlg = wx.FileDialog(self, "Choose a weight file", 
    803                                 self._default_save_location , "", "*.*", wx.OPEN) 
     772                            self._default_save_location, "", "*.*", wx.OPEN) 
    804773        path = None 
    805774        if dlg.ShowModal() == wx.ID_OK: 
    … …  
    817786            ## Add item in the context menu 
    818787            id = wx.NewId() 
    819             self.popUpMenu.Append(id,name, 'Save model and state %g'%self.number_saved_state) 
     788            hint_msg = 'Save model and state %g' % self.number_saved_state 
     789            self.popUpMenu.Append(id, name, hint_msg) 
    820790            wx.EVT_MENU(self, id, self.onResetModel) 
    821      
    822      
     791 
    823792    def _reset_plotting_range(self, state): 
    824793        """ 
    … …  
    828797        self.qmin.SetValue(str(state.qmin)) 
    829798        self.qmax.SetValue(str(state.qmax))  
    830         if self.state.npts!=None: 
     799        if self.state.npts != None: 
    831800            self.npts.SetValue(str(state.npts))  
    832              
    833801             
    834802    def _save_typeOfmodel(self): 
    … …  
    841809        self.state.struct_rbutton = self.struct_rbutton.GetValue() 
    842810        self.state.plugin_rbutton = self.plugin_rbutton.GetValue() 
    843         self.state.structurebox= self.structurebox.GetCurrentSelection() 
     811        self.state.structurebox = self.structurebox.GetCurrentSelection() 
    844812        self.state.formfactorbox = self.formfactorbox.GetCurrentSelection() 
    845         
    846813        #self._undo.Enable(True) 
    847814        ## post state to fit panel 
    848         event = PageInfoEvent(page = self) 
     815        event = PageInfoEvent(page=self) 
    849816        wx.PostEvent(self.parent, event) 
    850817         
    851          
    852     def _save_plotting_range(self ): 
     818    def _save_plotting_range(self): 
    853819        """ 
    854820        save the state of plotting range  
    … …  
    857823        self.state.qmin = self.qmin_x 
    858824        self.state.qmax = self.qmax_x  
    859         if self.npts!=None: 
    860             self.state.npts= self.num_points 
    861              
     825        if self.npts != None: 
     826            self.state.npts = self.num_points 
    862827             
    863828    def _onparamEnter_helper(self): 
    … …  
    871836        is_modified = False 
    872837        #self._undo.Enable(True) 
    873         if self.model !=None: 
     838        if self.model != None: 
    874839            try: 
    875                 is_modified =self._check_value_enter( self.fittable_param ,is_modified) 
    876                 is_modified =self._check_value_enter( self.fixed_param ,is_modified) 
    877                 is_modified =self._check_value_enter( self.parameters ,is_modified)  
     840                is_modified = self._check_value_enter(self.fittable_param, 
     841                                                     is_modified) 
     842                is_modified = self._check_value_enter(self.fixed_param, 
     843                                                     is_modified) 
     844                is_modified = self._check_value_enter(self.parameters, 
     845                                                      is_modified)  
    878846            except: 
    879847                pass 
    … …  
    901869                        is_modified = True 
    902870                else: 
    903                     msg= "Cannot Plot :Must enter a number!!!  " 
    904                     wx.PostEvent(self.parent, StatusEvent(status = msg )) 
    905                  
    906              
     871                    msg = "Cannot Plot :Must enter a number!!!  " 
     872                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    907873            ## if any value is modify draw model with new value 
    908874            if is_modified: 
    909                 self.state_change= True 
     875                self.state_change = True 
    910876                self._draw_model()  
    911877                self.Refresh() 
    912878        return is_modified 
    913879                       
    914                 
    915880    def _is_modified(self, is_modified): 
    916881        """ 
    … …  
    920885        return is_modified 
    921886                        
    922     def _reset_parameters_state(self, listtorestore,statelist): 
     887    def _reset_parameters_state(self, listtorestore, statelist): 
    923888        """ 
    924889        Reset the parameters at the given state 
    925890         
    926891        """ 
    927         if len(statelist)==0 or  len(listtorestore)==0 : 
     892        if len(statelist) == 0 or  len(listtorestore) == 0: 
    928893            return 
    929         if len(statelist)!=  len(listtorestore) : 
     894        if len(statelist) != len(listtorestore): 
    930895            return 
    931896 
    … …  
    934899            item_page_info = statelist[j] 
    935900            ##change the state of the check box for simple parameters 
    936             if item_page[0]!=None:                
     901            if item_page[0] != None:                
    937902                item_page[0].SetValue(item_page_info[0]) 
    938                  
    939             if item_page[2]!=None: 
     903            if item_page[2] != None: 
    940904                item_page[2].SetValue(item_page_info[2]) 
    941                  
    942             if item_page[3]!=None: 
     905            if item_page[3] != None: 
    943906                ## show or hide text +/- 
    944907                if item_page_info[2]: 
    … …  
    946909                else: 
    947910                    item_page[3].Hide() 
    948             if item_page[4]!=None: 
     911            if item_page[4] != None: 
    949912                ## show of hide the text crtl for fitting error 
    950913                if item_page_info[4][0]: 
    … …  
    953916                else: 
    954917                    item_page[3].Hide() 
    955             if item_page[5]!=None: 
     918            if item_page[5] != None: 
    956919                ## show of hide the text crtl for fitting error 
    957920                if item_page_info[5][0]: 
    … …  
    960923                else: 
    961924                    item_page[5].Hide() 
    962                      
    963             if item_page[6]!=None: 
     925            if item_page[6] != None: 
    964926                ## show of hide the text crtl for fitting error 
    965927                if item_page_info[6][0]: 
    … …  
    977939         
    978940        """ 
    979         if len(listtocopy)==0: 
     941        if len(listtocopy) == 0: 
    980942            return 
    981         
    982943        for item in listtocopy: 
    983    
    984944            checkbox_state = None 
    985             if item[0]!= None: 
    986                 checkbox_state= item[0].GetValue() 
     945            if item[0] != None: 
     946                checkbox_state = item[0].GetValue() 
    987947            parameter_name = item[1] 
    988948            parameter_value = None 
    989             if item[2]!=None: 
     949            if item[2] != None: 
    990950                parameter_value = item[2].GetValue() 
    991951            static_text = None 
    992             if item[3]!=None: 
     952            if item[3] != None: 
    993953                static_text = item[3].IsShown() 
    994954            error_value = None 
    995955            error_state = None 
    996             if item[4]!= None: 
     956            if item[4] != None: 
    997957                error_value = item[4].GetValue() 
    998958                error_state = item[4].IsShown() 
    999                  
    1000959            min_value = None 
    1001960            min_state = None 
    1002             if item[5]!= None: 
     961            if item[5] != None: 
    1003962                min_value = item[5].GetValue() 
    1004963                min_state = item[5].IsShown() 
    1005                  
    1006964            max_value = None 
    1007965            max_state = None 
    1008             if item[6]!= None: 
     966            if item[6] != None: 
    1009967                max_value = item[6].GetValue() 
    1010968                max_state = item[6].IsShown() 
    1011             unit=None 
    1012             if item[7]!=None: 
     969            unit = None 
     970            if item[7] != None: 
    1013971                unit = item[7].GetLabel() 
    1014                 
    1015972            statelist.append([checkbox_state, parameter_name, parameter_value, 
    1016                               static_text ,[error_state,error_value], 
    1017                                 [min_state,min_value],[max_state , max_value],unit]) 
     973                              static_text , [error_state, error_value], 
     974                        [min_state, min_value], [max_state, max_value], unit]) 
    1018975            
    1019976    def _set_model_sizer_selection(self, model): 
    … …  
    1022979         
    1023980        """ 
    1024         if model ==None: 
     981        if model == None: 
    1025982            return 
    1026         if hasattr(model ,"s_model"): 
    1027              
    1028             class_name= model.s_model.__class__ 
    1029             name= model.s_model.name 
    1030             flag= name != "NoStructure" 
     983        if hasattr(model, "s_model"): 
     984            class_name = model.s_model.__class__ 
     985            name = model.s_model.name 
     986            flag = (name != "NoStructure") 
    1031987            if flag and (class_name in self.model_list_box["Structure Factors"]): 
    1032988                self.structurebox.Show() 
    … …  
    1036992                items = self.structurebox.GetItems() 
    1037993                self.sizer1.Layout() 
    1038                 self.SetScrollbars(20,20,25,65) 
     994                self.SetScrollbars(20, 20, 25, 65) 
    1039995                for i in range(len(items)): 
    1040                     if items[i]== str(name): 
     996                    if items[i] == str(name): 
    1041997                        self.structurebox.SetSelection(i) 
    1042998                        break 
    1043                      
    1044         if hasattr(model ,"p_model"): 
     999        if hasattr(model, "p_model"): 
    10451000            class_name = model.p_model.__class__ 
    10461001            name = model.p_model.name 
    10471002            self.formfactorbox.Clear() 
    1048              
    10491003            for k, list in self.model_list_box.iteritems(): 
    1050                 if k in["P(Q)*S(Q)","Shapes" ] and class_name in self.model_list_box["Shapes"]: 
     1004                if k in ["P(Q)*S(Q)", "Shapes" ] and \ 
     1005                    class_name in self.model_list_box["Shapes"]: 
    10511006                    self.shape_rbutton.SetValue(True) 
    10521007                    ## fill the form factor list with new model 
    1053                     self._populate_box(self.formfactorbox,self.model_list_box["Shapes"]) 
     1008                    self._populate_box(self.formfactorbox, 
     1009                                       self.model_list_box["Shapes"]) 
    10541010                    items = self.formfactorbox.GetItems() 
    10551011                    ## set comboxbox to the selected item 
    10561012                    for i in range(len(items)): 
    1057                         if items[i]== str(name): 
     1013                        if items[i] == str(name): 
    10581014                            self.formfactorbox.SetSelection(i) 
    10591015                            break 
    … …  
    10671023                else: 
    10681024                    self.plugin_rbutton.SetValue(True) 
    1069                 
    10701025                if class_name in list: 
    10711026                    ## fill the form factor list with new model 
    … …  
    10741029                    ## set comboxbox to the selected item 
    10751030                    for i in range(len(items)): 
    1076                         if items[i]== str(name): 
     1031                        if items[i] == str(name): 
    10771032                            self.formfactorbox.SetSelection(i) 
    10781033                            break 
    … …  
    10871042     
    10881043            for k, list in self.model_list_box.iteritems():           
    1089                 if k in["P(Q)*S(Q)","Shapes" ] and class_name in self.model_list_box["Shapes"]: 
     1044                if k in["P(Q)*S(Q)","Shapes" ] and \ 
     1045                    class_name in self.model_list_box["Shapes"]: 
    10901046                    if class_name in self.model_list_box["P(Q)*S(Q)"]: 
    10911047                        self.structurebox.Show() 
    … …  
    11031059                    self.shape_rbutton.SetValue(True) 
    11041060                    ## fill the form factor list with new model 
    1105                     self._populate_box(self.formfactorbox,self.model_list_box["Shapes"]) 
     1061                    self._populate_box(self.formfactorbox,  
     1062                                       self.model_list_box["Shapes"]) 
    11061063                    items = self.formfactorbox.GetItems() 
    11071064                    ## set comboxbox to the selected item 
    11081065                    for i in range(len(items)): 
    1109                         if items[i]== str(name): 
     1066                        if items[i] == str(name): 
    11101067                            self.formfactorbox.SetSelection(i) 
    11111068                            break 
    … …  
    11281085                    ## set comboxbox to the selected item 
    11291086                    for i in range(len(items)): 
    1130                         if items[i]== str(name): 
     1087                        if items[i] == str(name): 
    11311088                            self.formfactorbox.SetSelection(i) 
    11321089                            break 
    … …  
    11421099          
    11431100        """ 
    1144         if self.model !=None: 
    1145             temp_smear=None 
     1101        if self.model != None: 
     1102            temp_smear = None 
    11461103            if hasattr(self, "enable_smearer"): 
    11471104                if self.enable_smearer.GetValue(): 
    … …  
    11641121        ##For MAC, this should defined here. 
    11651122        if box_sizer == None: 
    1166             box_description= wx.StaticBox(self, -1,str(title)) 
     1123            box_description = wx.StaticBox(self, -1, str(title)) 
    11671124            boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL) 
    11681125        else: 
    … …  
    11701127        sizer_buttons = wx.BoxSizer(wx.HORIZONTAL)         
    11711128        #-------------------------------------------------------- 
    1172         self.shape_rbutton = wx.RadioButton(self, -1, 'Shapes', style=wx.RB_GROUP) 
    1173         self.shape_indep_rbutton = wx.RadioButton(self, -1, "Shape-Independent") 
     1129        self.shape_rbutton = wx.RadioButton(self, -1, 'Shapes',  
     1130                                            style=wx.RB_GROUP) 
     1131        self.shape_indep_rbutton = wx.RadioButton(self, -1,  
     1132                                                  "Shape-Independent") 
    11741133        self.struct_rbutton = wx.RadioButton(self, -1, "Structure Factor ") 
    11751134        self.plugin_rbutton = wx.RadioButton(self, -1, "Customized Models") 
    1176                  
    1177         self.Bind( wx.EVT_RADIOBUTTON, self._show_combox, 
    1178                             id= self.shape_rbutton.GetId() )  
    1179         self.Bind( wx.EVT_RADIOBUTTON, self._show_combox, 
    1180                             id= self.shape_indep_rbutton.GetId() )  
    1181         self.Bind( wx.EVT_RADIOBUTTON, self._show_combox, 
    1182                             id= self.struct_rbutton.GetId() )  
    1183         self.Bind( wx.EVT_RADIOBUTTON, self._show_combox, 
    1184                             id= self.plugin_rbutton.GetId() )   
     1135        self.Bind(wx.EVT_RADIOBUTTON, self._show_combox, 
     1136                            id=self.shape_rbutton.GetId())  
     1137        self.Bind(wx.EVT_RADIOBUTTON, self._show_combox, 
     1138                            id=self.shape_indep_rbutton.GetId())  
     1139        self.Bind(wx.EVT_RADIOBUTTON, self._show_combox, 
     1140                            id=self.struct_rbutton.GetId())  
     1141        self.Bind(wx.EVT_RADIOBUTTON, self._show_combox, 
     1142                            id=self.plugin_rbutton.GetId())   
    11851143        #MAC needs SetValue 
    11861144        self.shape_rbutton.SetValue(True) 
    1187        
    1188         sizer_radiobutton = wx.GridSizer(2, 2,5, 5) 
     1145        sizer_radiobutton = wx.GridSizer(2, 2, 5, 5) 
    11891146        sizer_radiobutton.Add(self.shape_rbutton) 
    11901147        sizer_radiobutton.Add(self.shape_indep_rbutton) 
    11911148        sizer_radiobutton.Add(self.plugin_rbutton) 
    11921149        sizer_radiobutton.Add(self.struct_rbutton) 
    1193          
    11941150        sizer_buttons.Add(sizer_radiobutton) 
    11951151        # detail button 
    1196         if object !=None: 
    1197             sizer_buttons.Add((50,0)) 
     1152        if object != None: 
     1153            sizer_buttons.Add((50, 0)) 
    11981154            sizer_buttons.Add(object) 
    1199              
    12001155        sizer_selection = wx.BoxSizer(wx.HORIZONTAL) 
    12011156        mutifactor_selection = wx.BoxSizer(wx.HORIZONTAL) 
    1202         self.text1 = wx.StaticText( self,-1,"" ) 
    1203         self.text2 = wx.StaticText( self,-1,"P(Q)*S(Q)" ) 
    1204         self.mutifactor_text = wx.StaticText( self,-1,"No. of Shells: " ) 
    1205         self.mutifactor_text1 = wx.StaticText( self,-1,"" ) 
    1206         self.show_sld_button = wx.Button( self,-1,"Show SLD Profile" ) 
     1157        self.text1 = wx.StaticText(self, -1, "") 
     1158        self.text2 = wx.StaticText(self, -1, "P(Q)*S(Q)") 
     1159        self.mutifactor_text = wx.StaticText(self, -1, "No. of Shells: ") 
     1160        self.mutifactor_text1 = wx.StaticText(self, -1, "") 
     1161        self.show_sld_button = wx.Button(self, -1, "Show SLD Profile") 
    12071162        self.show_sld_button.Bind(wx.EVT_BUTTON,self._on_show_sld) 
    1208         self.formfactorbox = wx.ComboBox(self, -1,style=wx.CB_READONLY) 
    1209         if self.model!=None: 
     1163        self.formfactorbox = wx.ComboBox(self, -1, style=wx.CB_READONLY) 
     1164        if self.model!= None: 
    12101165            self.formfactorbox.SetValue(self.model.name) 
    1211              
    1212              
    1213         self.structurebox = wx.ComboBox(self, -1,style=wx.CB_READONLY) 
    1214         self.multifactorbox = wx.ComboBox(self, -1,style=wx.CB_READONLY) 
    1215         wx.EVT_COMBOBOX(self.formfactorbox,-1, self._on_select_model) 
    1216         wx.EVT_COMBOBOX(self.structurebox,-1, self._on_select_model) 
    1217         wx.EVT_COMBOBOX(self.multifactorbox,-1, self._on_select_model) 
    1218      
     1166        self.structurebox = wx.ComboBox(self, -1, style=wx.CB_READONLY) 
     1167        self.multifactorbox = wx.ComboBox(self, -1, style=wx.CB_READONLY) 
     1168        wx.EVT_COMBOBOX(self.formfactorbox, -1, self._on_select_model) 
     1169        wx.EVT_COMBOBOX(self.structurebox, -1, self._on_select_model) 
     1170        wx.EVT_COMBOBOX(self.multifactorbox, -1, self._on_select_model) 
    12191171        ## fill combox box 
    1220         if len(self.model_list_box)>0: 
    1221             self._populate_box( self.formfactorbox,self.model_list_box["Shapes"]) 
    1222         
    1223         if len(self.model_list_box)>0: 
    1224             self._populate_box( self.structurebox, 
     1172        if len(self.model_list_box) > 0: 
     1173            self._populate_box(self.formfactorbox,  
     1174                               self.model_list_box["Shapes"]) 
     1175        if len(self.model_list_box) > 0: 
     1176            self._populate_box(self.structurebox, 
    12251177                                self.model_list_box["Structure Factors"]) 
    1226             self.structurebox.Insert("None", 0,None) 
     1178            self.structurebox.Insert("None", 0, None) 
    12271179            self.structurebox.SetSelection(0) 
    12281180            self.structurebox.Hide() 
    … …  
    12301182            self.structurebox.Disable() 
    12311183            self.text2.Disable() 
    1232               
    12331184            if self.model.__class__ in self.model_list_box["P(Q)*S(Q)"]: 
    12341185                self.structurebox.Show() 
    … …  
    12361187                self.structurebox.Enable() 
    12371188                self.text2.Enable()             
    1238          
    12391189        ## check model type to show sizer 
    1240         if self.model !=None: 
    1241             self._set_model_sizer_selection( self.model ) 
    1242          
     1190        if self.model != None: 
     1191            self._set_model_sizer_selection(self.model) 
    12431192        sizer_selection.Add(self.text1) 
    1244         sizer_selection.Add((5,5)) 
     1193        sizer_selection.Add((5, 5)) 
    12451194        sizer_selection.Add(self.formfactorbox) 
    1246         sizer_selection.Add((5,5)) 
     1195        sizer_selection.Add((5, 5)) 
    12471196        sizer_selection.Add(self.text2) 
    1248         sizer_selection.Add((5,5)) 
     1197        sizer_selection.Add((5, 5)) 
    12491198        sizer_selection.Add(self.structurebox) 
    1250         #sizer_selection.Add((5,5)) 
    1251         mutifactor_selection.Add((10,5)) 
     1199        #sizer_selection.Add((5, 5)) 
     1200        mutifactor_selection.Add((10, 5)) 
    12521201        mutifactor_selection.Add(self.mutifactor_text) 
    12531202        mutifactor_selection.Add(self.multifactorbox) 
    1254         mutifactor_selection.Add((5,5)) 
     1203        mutifactor_selection.Add((5, 5)) 
    12551204        mutifactor_selection.Add(self.mutifactor_text1) 
    1256         mutifactor_selection.Add((10,5)) 
     1205        mutifactor_selection.Add((10, 5)) 
    12571206        mutifactor_selection.Add(self.show_sld_button) 
    1258          
    1259         boxsizer1.Add( sizer_buttons ) 
    1260         boxsizer1.Add( (15,15)) 
    1261         boxsizer1.Add( sizer_selection ) 
    1262         boxsizer1.Add( (10,10)) 
     1207        boxsizer1.Add(sizer_buttons) 
     1208        boxsizer1.Add((15, 15)) 
     1209        boxsizer1.Add(sizer_selection) 
     1210        boxsizer1.Add((10,10)) 
    12631211        boxsizer1.Add(mutifactor_selection) 
    1264          
    12651212        self._set_multfactor_combobox() 
    12661213        self.multifactorbox.SetSelection(1) 
    12671214        self.show_sld_button.Hide() 
    1268          
    12691215        #-------------------------------------------------------- 
    1270         sizer.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10) 
     1216        sizer.Add(boxsizer1, 0, wx.EXPAND|wx.ALL, 10) 
    12711217        sizer.Layout() 
    1272         self.SetScrollbars(20,20,25,65) 
     1218        self.SetScrollbars(20, 20, 25, 65) 
    12731219         
    12741220    def _on_show_sld(self, event=None): 
    … …  
    12771223        """ 
    12781224        # get profile data 
    1279         x,y=self.model.getProfile() 
    1280  
     1225        x, y = self.model.getProfile() 
    12811226        from danse.common.plottools import Data1D 
    12821227        #from profile_dialog import SLDPanel 
    12831228        from sans.guiframe.local_perspectives.plotting.profile_dialog \ 
    12841229        import SLDPanel 
    1285         sld_data = Data1D(x,y) 
     1230        sld_data = Data1D(x, y) 
    12861231        sld_data.name = 'SLD' 
    12871232        sld_data.axes = self.sld_axes 
    1288         self.panel = SLDPanel(self, data=sld_data,axes =self.sld_axes,id =-1 ) 
     1233        self.panel = SLDPanel(self, data=sld_data, axes=self.sld_axes, id=-1) 
    12891234        self.panel.ShowModal() 
    12901235 
    … …  
    12951240        """ 
    12961241        # build content of the combobox 
    1297         for idx in range(0,multiplicity): 
    1298             self.multifactorbox.Append(str(idx),int(idx)) 
     1242        for idx in range(0, multiplicity): 
     1243            self.multifactorbox.Append(str(idx), int(idx)) 
    12991244            #self.multifactorbox.SetSelection(1)  
    13001245        self._hide_multfactor_combobox() 
    … …  
    13201265            self.multifactorbox.Hide()    
    13211266      
    1322          
    13231267    def _show_combox(self, event): 
    13241268        """ 
    … …  
    13271271        """ 
    13281272        ## Don't want to populate combo box again if the event comes from check box 
    1329         if self.shape_rbutton.GetValue()and\ 
    1330              event.GetEventObject()==self.shape_rbutton: 
     1273        if self.shape_rbutton.GetValue() and \ 
     1274             event.GetEventObject() == self.shape_rbutton: 
    13311275            ##fill the combobox with form factor list 
    13321276            self.structurebox.SetSelection(0) 
    13331277            self.structurebox.Disable() 
    13341278            self.formfactorbox.Clear() 
    1335             self._populate_box( self.formfactorbox,self.model_list_box["Shapes"]) 
    1336              
    1337         if self.shape_indep_rbutton.GetValue()and\ 
    1338              event.GetEventObject()==self.shape_indep_rbutton: 
     1279            self._populate_box(self.formfactorbox, 
     1280                               self.model_list_box["Shapes"]) 
     1281        if self.shape_indep_rbutton.GetValue() and \ 
     1282             event.GetEventObject() == self.shape_indep_rbutton: 
    13391283            ##fill the combobox with shape independent  factor list 
    13401284            self.structurebox.SetSelection(0) 
    13411285            self.structurebox.Disable() 
    13421286            self.formfactorbox.Clear() 
    1343             self._populate_box( self.formfactorbox, 
     1287            self._populate_box(self.formfactorbox, 
    13441288                                self.model_list_box["Shape-Independent"]) 
    1345              
    1346         if self.struct_rbutton.GetValue() and\ 
    1347              event.GetEventObject()==self.struct_rbutton: 
     1289        if self.struct_rbutton.GetValue() and \ 
     1290             event.GetEventObject() == self.struct_rbutton: 
    13481291            ##fill the combobox with structure factor list 
    13491292            self.structurebox.SetSelection(0) 
    13501293            self.structurebox.Disable() 
    13511294            self.formfactorbox.Clear() 
    1352             self._populate_box( self.formfactorbox, 
     1295            self._populate_box(self.formfactorbox, 
    13531296                                self.model_list_box["Structure Factors"]) 
    1354             
    1355         if self.plugin_rbutton.GetValue()and\ 
    1356              event.GetEventObject()==self.plugin_rbutton: 
    1357             
     1297        if self.plugin_rbutton.GetValue() and \ 
     1298             event.GetEventObject() == self.plugin_rbutton: 
    13581299            ##fill the combobox with form factor list 
    13591300            self.structurebox.Disable() 
    13601301            self.formfactorbox.Clear() 
    1361             self._populate_box( self.formfactorbox, 
     1302            self._populate_box(self.formfactorbox, 
    13621303                                self.model_list_box["Customized Models"]) 
    1363          
    13641304        self._on_select_model(event=None) 
    13651305        self._save_typeOfmodel() 
    … …  
    13681308        self.Layout() 
    13691309        self.Refresh() 
    1370         self.SetScrollbars(20,20,25,65) 
     1310        self.SetScrollbars(20, 20, 25, 65) 
    13711311             
    13721312    def _populate_box(self, combobox, list): 
    … …  
    13781318        """ 
    13791319        for models in list: 
    1380             model= models() 
     1320            model = models() 
    13811321            name = model.__class__.__name__ 
    13821322            if models.__name__!="NoStructure": 
    13831323                if hasattr(model, "name"): 
    13841324                    name = model.name 
    1385                 combobox.Append(name,models) 
    1386       
     1325                combobox.Append(name, models) 
    13871326        return 0 
    13881327     
    … …  
    13921331         
    13931332        """ 
    1394         tcrtl= event.GetEventObject() 
    1395          
     1333        tcrtl = event.GetEventObject() 
    13961334        #Clear msg if previously shown. 
    1397         msg= "" 
    1398         wx.PostEvent(self.parent, StatusEvent(status = msg )) 
    1399          
     1335        msg = "" 
     1336        wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    14001337        ## save current state 
    14011338        self.save_current_state() 
    1402         if event !=None: 
     1339        if event != None: 
    14031340            #self._undo.Enable(True) 
    1404             event = PageInfoEvent(page = self) 
     1341            event = PageInfoEvent(page=self) 
    14051342            wx.PostEvent(self.parent, event) 
    1406                
    14071343        if check_float(tcrtl): 
    1408              
    14091344            self._onparamEnter_helper() 
    14101345            #event.Skip() 
    14111346        else: 
    1412             msg= "Cannot Plot :Must enter a number!!!  " 
    1413             wx.PostEvent(self.parent, StatusEvent(status = msg )) 
     1347            msg = "Cannot Plot :Must enter a number!!!  " 
     1348            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    14141349            #event.Skip() 
    14151350            return  
    … …  
    14201355         
    14211356        """ 
    1422          
    1423         tcrtl= event.GetEventObject() 
     1357        tcrtl = event.GetEventObject() 
    14241358        #Clear msg if previously shown. 
    1425         msg= "" 
    1426         wx.PostEvent(self.parent, StatusEvent(status = msg )) 
     1359        msg = "" 
     1360        wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    14271361        # Flag to register when a parameter has changed. 
    14281362        is_modified = False 
    1429         if tcrtl.GetValue().lstrip().rstrip()!="": 
     1363        if tcrtl.GetValue().lstrip().rstrip() != "": 
    14301364            try: 
    14311365                value = float(tcrtl.GetValue()) 
    14321366                tcrtl.SetBackgroundColour(wx.WHITE) 
    1433  
    14341367                # If qmin and qmax have been modified, update qmin and qmax 
    1435                 if self._validate_qrange( self.qmin, self.qmax): 
     1368                if self._validate_qrange(self.qmin, self.qmax): 
    14361369                    tempmin = float(self.qmin.GetValue()) 
    14371370                    if tempmin != self.qmin_x: 
    … …  
    14421375                else: 
    14431376                    tcrtl.SetBackgroundColour("pink") 
    1444                     msg= "Model Error:wrong value entered : %s"% sys.exc_value 
    1445                     wx.PostEvent(self.parent, StatusEvent(status = msg )) 
     1377                    msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     1378                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    14461379                    return  
    1447                  
    14481380            except: 
    14491381                tcrtl.SetBackgroundColour("pink") 
    1450                 msg= "Model Error:wrong value entered : %s"% sys.exc_value 
    1451                 wx.PostEvent(self.parent, StatusEvent(status = msg )) 
     1382                msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     1383                wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    14521384                return  
    14531385            #Check if # of points for theory model are valid(>0). 
    … …  
    14591391                        is_modified = True 
    14601392                else: 
    1461                     msg= "Cannot Plot :No npts in that Qrange!!!  " 
    1462                     wx.PostEvent(self.parent, StatusEvent(status = msg )) 
    1463             
     1393                    msg = "Cannot Plot :No npts in that Qrange!!!  " 
     1394                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    14641395        else: 
    14651396           tcrtl.SetBackgroundColour("pink") 
    1466            msg= "Model Error:wrong value entered!!!" 
    1467            wx.PostEvent(self.parent, StatusEvent(status = msg )) 
    1468             
     1397           msg = "Model Error:wrong value entered!!!" 
     1398           wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    14691399        #self._undo.Enable(True) 
    14701400        self.save_current_state() 
    1471         event = PageInfoEvent(page = self) 
     1401        event = PageInfoEvent(page=self) 
    14721402        wx.PostEvent(self.parent, event) 
    1473         self.state_change= False 
     1403        self.state_change = False 
    14741404        #Draw the model for a different range 
    14751405        self._draw_model() 
    … …  
    14821412        ## reset dictionary containing reference to dispersion 
    14831413        self._disp_obj_dict = {} 
    1484         self.disp_cb_dict ={} 
    1485          
     1414        self.disp_cb_dict = {} 
    14861415        f_id = self.formfactorbox.GetCurrentSelection() 
    14871416        #For MAC 
    14881417        form_factor = None 
    14891418        if f_id >= 0: 
    1490             form_factor = self.formfactorbox.GetClientData( f_id ) 
    1491  
     1419            form_factor = self.formfactorbox.GetClientData(f_id) 
    14921420        if not form_factor in  self.model_list_box["multiplication"]: 
    14931421            self.structurebox.Hide() 
    … …  
    15011429            self.structurebox.Enable() 
    15021430            self.text2.Enable() 
    1503  
    15041431        if form_factor != None:     
    15051432            # set multifactor for Mutifunctional models     
    … …  
    15171444 
    15181445                # Check max value 
    1519                 if m_id > multiplicity -1: 
     1446                if m_id > multiplicity - 1: 
    15201447                    # default value 
    15211448                    m_id = 1 
    15221449                self.multi_factor = self.multifactorbox.GetClientData(m_id) 
    1523                 if self.multi_factor == None: self.multi_factor =1 
     1450                if self.multi_factor == None: 
     1451                    self.multi_factor =1 
    15241452                form_factor = form_factor(int(self.multi_factor)) 
    15251453                self.multifactorbox.SetSelection(m_id) 
    … …  
    15441472            self.show_sld_button.Hide() 
    15451473            self.multi_factor = None   
    1546                
    15471474        s_id = self.structurebox.GetCurrentSelection() 
    1548         struct_factor = self.structurebox.GetClientData( s_id ) 
    1549         
    1550         if  struct_factor !=None: 
     1475        struct_factor = self.structurebox.GetClientData(s_id) 
     1476        if struct_factor != None: 
    15511477            from sans.models.MultiplicationModel import MultiplicationModel 
    1552             self.model= MultiplicationModel(form_factor,struct_factor()) 
    1553              
     1478            self.model = MultiplicationModel(form_factor, struct_factor()) 
    15541479        else: 
    15551480            if form_factor != None: 
    1556                 self.model= form_factor 
     1481                self.model = form_factor 
    15571482            else: 
    15581483                self.model = None 
    15591484                return self.model 
    1560          
    15611485        ## post state to fit panel 
    1562         self.state.parameters =[] 
    1563         self.state.model =self.model 
     1486        self.state.parameters = [] 
     1487        self.state.model = self.model 
    15641488        self.state.qmin = self.qmin_x 
    15651489        self.state.multi_factor = self.multi_factor 
    1566         self.disp_list =self.model.getDispParamList() 
     1490        self.disp_list = self.model.getDispParamList() 
    15671491        self.state.disp_list = self.disp_list 
    15681492        self.Layout()      
    … …  
    15981522                qmax_ctrl.Refresh() 
    15991523                msg= "Invalid Q range: Q min must be smaller than Q max" 
    1600                 wx.PostEvent(self.parent, StatusEvent(status = msg)) 
     1524                wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    16011525                return False 
    16021526        return True 
    … …  
    16111535        """   
    16121536        is_modified =  modified 
    1613         if len(list)==0: 
     1537        if len(list) == 0: 
    16141538            return is_modified 
    16151539        for item in list: 
    … …  
    16201544            #try: 
    16211545            name = str(item[1]) 
    1622  
    16231546            try:      
    1624                 value= float(item[2].GetValue()) 
     1547                value = float(item[2].GetValue()) 
    16251548                # If the value of the parameter has changed, 
    16261549                # +update the model and set the is_modified flag 
    … …  
    16301553            except: 
    16311554                msg = "Wrong parameter value entered " 
    1632                 wx.PostEvent(self.parent, StatusEvent(status = msg)) 
    1633                  
     1555                wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    16341556        return is_modified  
    16351557     
    … …  
    16381560        respond to self.enable_disp and self.disable_disp radio box. 
    16391561        The dispersity object is reset inside the model into Gaussian.  
    1640         When the user select yes , this method display a combo box for more selection 
     1562        When the user select yes , this method display a combo box  
     1563        for more selection 
    16411564        when the user selects No,the combo box disappears. 
    16421565        Redraw the model with the default dispersity (Gaussian) 
    16431566         
    16441567        """ 
    1645          
    16461568        self._reset_dispersity() 
    1647      
    1648         if self.model ==None: 
     1569        if self.model == None: 
    16491570            self.model_disp.Hide() 
    16501571            self.disp_box.Hide() 
    16511572            self.sizer4_4.Clear(True) 
    16521573            return 
    1653  
    16541574        if self.enable_disp.GetValue(): 
    16551575            self.model_disp.Show(True) 
    16561576            self.disp_box.Show(True) 
    16571577            ## layout for model containing no dispersity parameters 
    1658              
    1659             self.disp_list= self.model.getDispParamList() 
    1660               
    1661             if len(self.disp_list)==0 and len(self.disp_cb_dict)==0: 
     1578            self.disp_list = self.model.getDispParamList() 
     1579            if len(self.disp_list) == 0 and len(self.disp_cb_dict) == 0: 
    16621580                self._layout_sizer_noDipers()   
    16631581            else: 
    … …  
    16691587            self.disp_box.SetSelection(0)  
    16701588            self.sizer4_4.Clear(True) 
    1671              
    16721589        ## post state to fit panel  
    16731590        self.save_current_state() 
    1674         if event !=None: 
     1591        if event != None: 
    16751592            #self._undo.Enable(True) 
    1676             event = PageInfoEvent(page = self) 
     1593            event = PageInfoEvent(page=self) 
    16771594            wx.PostEvent(self.parent, event) 
    16781595        #draw the model with the current dispersity 
    … …  
    16831600        self.Refresh()       
    16841601           
    1685          
    16861602    def _layout_sizer_noDipers(self): 
    16871603        """ 
    … …  
    16891605         
    16901606        """ 
    1691         ix=0 
    1692         iy=1 
    1693         self.fittable_param=[] 
    1694         self.fixed_param=[] 
    1695         self.orientation_params_disp=[] 
    1696          
     1607        ix = 0 
     1608        iy = 1 
     1609        self.fittable_param = [] 
     1610        self.fixed_param = [] 
     1611        self.orientation_params_disp = [] 
    16971612        self.model_disp.Hide() 
    16981613        self.disp_box.Hide() 
    16991614        self.sizer4_4.Clear(True) 
    17001615        model_disp = wx.StaticText(self, -1, 'No PolyDispersity for this model') 
    1701         self.sizer4_4.Add(model_disp,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
     1616        self.sizer4_4.Add(model_disp,(iy, ix), (1,1),  
     1617                          wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
    17021618        self.sizer4_4.Layout() 
    17031619        self.sizer4.Layout() 
    1704         self.SetScrollbars(20,20,25,65) 
     1620        self.SetScrollbars(20, 20, 25, 65) 
    17051621       
    1706              
    17071622    def _reset_dispersity(self): 
    17081623        """ 
    … …  
    17101625          
    17111626        """ 
    1712         if len(self.param_toFit)>0: 
     1627        if len(self.param_toFit) > 0: 
    17131628            for item in self.fittable_param: 
    17141629                if item in self.param_toFit: 
    17151630                    self.param_toFit.remove(item) 
    1716  
    17171631            for item in self.orientation_params_disp: 
    17181632                if item in self.param_toFit: 
    17191633                    self.param_toFit.remove(item) 
    1720           
    1721         self.fittable_param=[] 
    1722         self.fixed_param=[] 
    1723         self.orientation_params_disp=[] 
    1724         self.values=[] 
    1725         self.weights=[] 
    1726        
    1727         from sans.models.dispersion_models import GaussianDispersion, ArrayDispersion 
    1728         if len(self.disp_cb_dict)==0: 
     1634        self.fittable_param = [] 
     1635        self.fixed_param = [] 
     1636        self.orientation_params_disp = [] 
     1637        self.values = [] 
     1638        self.weights = [] 
     1639        from sans.models.dispersion_models import GaussianDispersion 
     1640        from sans.models.dispersion_models import ArrayDispersion 
     1641        if len(self.disp_cb_dict) == 0: 
    17291642            self.save_current_state() 
    17301643            self.sizer4_4.Clear(True) 
    17311644            self.Layout() 
    1732   
    17331645            return  
    1734         if (len(self.disp_cb_dict)>0) : 
     1646        if (len(self.disp_cb_dict) > 0) : 
    17351647            for p in self.disp_cb_dict: 
    1736                 # The parameter was un-selected. Go back to Gaussian model (with 0 pts)                     
     1648                # The parameter was un-selected. 
     1649                # Go back to Gaussian model (with 0 pts)                     
    17371650                disp_model = GaussianDispersion() 
    1738                 
    17391651                self._disp_obj_dict[p] = disp_model 
    1740                 # Set the new model as the dispersion object for the selected parameter 
     1652                # Set the new model as the dispersion object  
     1653                # for the selected parameter 
    17411654                try: 
    17421655                   self.model.set_dispersion(p, disp_model) 
    17431656                except: 
    1744  
    17451657                    pass 
    1746  
    17471658        ## save state into 
    17481659        self.save_current_state() 
    … …  
    17501661        self.Refresh() 
    17511662                   
    1752              
    1753     def _on_select_Disp(self,event): 
     1663    def _on_select_Disp(self, event): 
    17541664        """ 
    17551665        allow selecting different dispersion 
    … …  
    17591669        n = self.disp_box.GetCurrentSelection() 
    17601670        name = self.disp_box.GetValue() 
    1761         dispersity= self.disp_box.GetClientData(n) 
     1671        dispersity = self.disp_box.GetClientData(n) 
    17621672        self.disp_name = name 
    1763          
    17641673        if name.lower() == "array": 
    17651674            self._set_sizer_arraydispersion() 
    17661675        else: 
    1767             self._set_sizer_dispersion(dispersity= dispersity) 
    1768              
    1769         self.state.disp_box= n 
     1676            self._set_sizer_dispersion(dispersity=dispersity) 
     1677        self.state.disp_box = n 
    17701678        ## Redraw the model 
    17711679        self._draw_model()  
    17721680        #self._undo.Enable(True) 
    1773         event = PageInfoEvent(page = self) 
     1681        event = PageInfoEvent(page=self) 
    17741682        wx.PostEvent(self.parent, event) 
    1775          
    17761683        self.sizer4_4.Layout() 
    17771684        self.sizer4.Layout() 
    1778         self.SetScrollbars(20,20,25,65) 
     1685        self.SetScrollbars(20, 20, 25, 65) 
    17791686         
    17801687    def _set_sizer_arraydispersion(self): 
    17811688        """ 
    17821689        draw sizer with array dispersity  parameters 
    1783          
    1784         """ 
    1785          
    1786         if len(self.param_toFit)>0: 
     1690        """ 
     1691        if len(self.param_toFit) > 0: 
    17871692            for item in self.fittable_param: 
    17881693                if item in self.param_toFit: 
    … …  
    17941699            if item in self.model.fixed: 
    17951700                del self.model.details [item]                            
    1796  
    1797         self.fittable_param=[] 
    1798         self.fixed_param=[] 
    1799         self.orientation_params_disp=[] 
     1701        self.fittable_param = [] 
     1702        self.fixed_param = [] 
     1703        self.orientation_params_disp = [] 
    18001704        self.sizer4_4.Clear(True)  
    18011705        self._reset_dispersity() 
    1802         ix=0 
    1803         iy=1      
     1706        ix = 0 
     1707        iy = 1      
    18041708        disp1 = wx.StaticText(self, -1, 'Array Dispersion') 
    1805         self.sizer4_4.Add(disp1,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
    1806          
    1807         # Look for model parameters to which we can apply an ArrayDispersion model 
     1709        self.sizer4_4.Add(disp1, (iy, ix), (1, 1),   
     1710                          wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
     1711        # Look for model parameters to which we can apply  
     1712        # an ArrayDispersion model 
    18081713        # Add a check box for each parameter. 
    18091714        self.disp_cb_dict = {} 
    18101715        ix+=1  
    1811         self.noDisper_rbox = wx.RadioButton(self, -1,"None", (10, 10),style= wx.RB_GROUP) 
    1812         self.Bind(wx.EVT_RADIOBUTTON,self.select_disp_angle , id=self.noDisper_rbox.GetId()) 
     1716        self.noDisper_rbox = wx.RadioButton(self, -1, "None",  
     1717                                            (10, 10), style=wx.RB_GROUP) 
     1718        self.Bind(wx.EVT_RADIOBUTTON, self.select_disp_angle,  
     1719                  id=self.noDisper_rbox.GetId()) 
    18131720        #MAC needs SetValue 
    18141721        self.noDisper_rbox.SetValue(True) 
    18151722        self.sizer4_4.Add(self.noDisper_rbox, (iy, ix), 
    1816                            (1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    1817          
     1723                           (1, 1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    18181724        for p in self.model.dispersion.keys(): 
    18191725            if not p in self.model.orientation_params: 
    1820                 ix+=1  
     1726                ix += 1  
    18211727                self.disp_cb_dict[p] = wx.RadioButton(self, -1, p, (10, 10)) 
    1822                 self.state.disp_cb_dict[p]=  self.disp_cb_dict[p].GetValue() 
    1823                 self.Bind(wx.EVT_RADIOBUTTON, self.select_disp_angle, id=self.disp_cb_dict[p].GetId()) 
    1824                 self.sizer4_4.Add(self.disp_cb_dict[p], (iy, ix), (1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    1825          
     1728                self.state.disp_cb_dict[p] = self.disp_cb_dict[p].GetValue() 
     1729                self.Bind(wx.EVT_RADIOBUTTON, self.select_disp_angle,  
     1730                          id=self.disp_cb_dict[p].GetId()) 
     1731                self.sizer4_4.Add(self.disp_cb_dict[p], (iy, ix), (1,1),  
     1732                                  wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    18261733        for p in self.model.dispersion.keys(): 
    18271734            if p in self.model.orientation_params: 
    1828                 ix+=1  
     1735                ix += 1  
    18291736                self.disp_cb_dict[p] = wx.RadioButton(self, -1, p, (10, 10)) 
    1830                 self.state.disp_cb_dict[p]=  self.disp_cb_dict[p].GetValue() 
    1831                 if not (self.enable2D or self.data.__class__.__name__ =="Data2D"): 
     1737                self.state.disp_cb_dict[p] = self.disp_cb_dict[p].GetValue() 
     1738                if not (self.enable2D or \ 
     1739                        self.data.__class__.__name__ == "Data2D"): 
    18321740                    self.disp_cb_dict[p].Hide() 
    18331741                else: 
    18341742                    self.disp_cb_dict[p].Show(True) 
    1835                 self.Bind(wx.EVT_RADIOBUTTON, self.select_disp_angle, id=self.disp_cb_dict[p].GetId()) 
    1836                 self.sizer4_4.Add(self.disp_cb_dict[p], (iy, ix), (1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    1837  
    1838  
    1839         ix =0 
    1840         iy +=1  
    1841         self.sizer4_4.Add((20,20),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)         
     1743                self.Bind(wx.EVT_RADIOBUTTON, self.select_disp_angle,  
     1744                          id=self.disp_cb_dict[p].GetId()) 
     1745                self.sizer4_4.Add(self.disp_cb_dict[p], (iy, ix), (1,1), 
     1746                                   wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
     1747        ix = 0 
     1748        iy += 1  
     1749        self.sizer4_4.Add((20, 20), (iy, ix), (1, 1),  
     1750                          wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)         
    18421751        self.Layout() 
    1843  
    1844         self.state.orientation_params =[] 
    1845         self.state.orientation_params_disp =[] 
    1846         self.state.parameters =[] 
    1847         self.state.fittable_param =[] 
    1848         self.state.fixed_param =[] 
    1849          
     1752        self.state.orientation_params = [] 
     1753        self.state.orientation_params_disp = [] 
     1754        self.state.parameters = [] 
     1755        self.state.fittable_param = [] 
     1756        self.state.fixed_param = [] 
    18501757        ## save checkbutton state and txtcrtl values 
    18511758        self._copy_parameters_state(self.orientation_params, 
    18521759                                     self.state.orientation_params) 
    1853  
    18541760        self._copy_parameters_state(self.orientation_params_disp, 
    18551761                                     self.state.orientation_params_disp) 
    1856          
    18571762        self._copy_parameters_state(self.parameters, self.state.parameters) 
    1858         self._copy_parameters_state(self.fittable_param, self.state.fittable_param) 
     1763        self._copy_parameters_state(self.fittable_param,  
     1764                                    self.state.fittable_param) 
    18591765        self._copy_parameters_state(self.fixed_param, self.state.fixed_param) 
    1860      
    18611766        ## post state to fit panel 
    1862         event = PageInfoEvent(page = self) 
     1767        event = PageInfoEvent(page=self) 
    18631768        wx.PostEvent(self.parent, event) 
    18641769         
    … …  
    18711776        #-------------------------------------------------------------- 
    18721777        if box_sizer == None: 
    1873             box_description= wx.StaticBox(self, -1,str(title)) 
     1778            box_description= wx.StaticBox(self, -1, str(title)) 
    18741779            boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL) 
    18751780        else: 
    … …  
    18771782            boxsizer1 = box_sizer 
    18781783 
    1879         self.qmin    = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH,20),style=wx.TE_PROCESS_ENTER, 
    1880                                             kill_focus_callback = self._onQrangeEnter, 
    1881                                             text_enter_callback = self._onQrangeEnter) 
     1784        self.qmin = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH, 20), 
     1785                                       style=wx. TE_PROCESS_ENTER, 
     1786                                    kill_focus_callback=self._onQrangeEnter, 
     1787                                    text_enter_callback=self._onQrangeEnter) 
    18821788        self.qmin.SetValue(str(self.qmin_x)) 
    18831789        self.qmin.SetToolTipString("Minimun value of Q in linear scale.") 
    18841790      
    1885         self.qmax    = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH,20),style=wx.TE_PROCESS_ENTER, 
    1886                                             kill_focus_callback = self._onQrangeEnter, 
    1887                                             text_enter_callback = self._onQrangeEnter) 
     1791        self.qmax = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 20), 
     1792                                       style=wx.TE_PROCESS_ENTER, 
     1793                                    kill_focus_callback=self._onQrangeEnter, 
     1794                                    text_enter_callback=self._onQrangeEnter) 
    18881795        self.qmax.SetValue(str(self.qmax_x)) 
    18891796        self.qmax.SetToolTipString("Maximum value of Q in linear scale.") 
    1890          
    18911797        id = wx.NewId() 
    1892         self.reset_qrange =wx.Button(self,id,'Reset',size=(70,23)) 
    1893        
    1894         self.reset_qrange.Bind(wx.EVT_BUTTON, self.on_reset_clicked,id=id) 
     1798        self.reset_qrange = wx.Button(self, id, 'Reset', size=(70, 23)) 
     1799        self.reset_qrange.Bind(wx.EVT_BUTTON, self.on_reset_clicked, id=id) 
    18951800        self.reset_qrange.SetToolTipString("Reset Q range to the default values") 
    1896       
    1897         sizer_horizontal=wx.BoxSizer(wx.HORIZONTAL) 
    1898         sizer= wx.GridSizer(3, 3,2, 5) 
    1899          
     1801        sizer_horizontal = wx.BoxSizer(wx.HORIZONTAL) 
     1802        sizer = wx.GridSizer(3, 3, 2, 5) 
    19001803        sizer.Add(wx.StaticText(self, -1, '    Q range'))      
    19011804        sizer.Add(wx.StaticText(self, -1, ' Min')) 
    19021805        sizer.Add(wx.StaticText(self, -1, ' Max')) 
    19031806        sizer.Add(self.reset_qrange)    
    1904               
    19051807        sizer.Add(self.qmin) 
    19061808        sizer.Add(self.qmax) 
    19071809        sizer_horizontal.Add(sizer) 
    1908         if object!=None: 
     1810        if object != None: 
    19091811            sizer_horizontal.Add(object) 
    1910          
    1911         if object1!=None: 
     1812        if object1 != None: 
    19121813           boxsizer1.Add(object1)  
    1913            boxsizer1.Add((10,10)) 
     1814           boxsizer1.Add((10, 10)) 
    19141815        boxsizer1.Add(sizer_horizontal) 
    19151816        ## save state 
    19161817        self.save_current_state() 
    19171818        #---------------------------------------------------------------- 
    1918         self.sizer5.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10) 
     1819        self.sizer5.Add(boxsizer1, 0, wx.EXPAND|wx.ALL, 10) 
    19191820        self.sizer5.Layout() 
    19201821 
    … …  
    19261827        # Skipping save state functionality for release 0.9.0 
    19271828        return 
    1928      
    19291829        self.sizer6.Clear(True) 
    1930         box_description= wx.StaticBox(self, -1,"Save Model") 
     1830        box_description= wx.StaticBox(self, -1, "Save Model") 
    19311831        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL) 
    19321832        sizer_save = wx.BoxSizer(wx.HORIZONTAL) 
    … …  
    19341834        self.btSave_title = wx.StaticText(self, -1, 'Save the current Model') 
    19351835        self.btSave = wx.Button(self,wx.NewId(),'Save') 
    1936         self.btSave.Bind(wx.EVT_BUTTON, self.onSave,id= self.btSave.GetId()) 
     1836        self.btSave.Bind(wx.EVT_BUTTON, self.onSave,id=self.btSave.GetId()) 
    19371837        self.btSave.SetToolTipString("Save the current Model") 
    1938          
    19391838        sizer_save.Add(self.btSave_title)   
    1940         sizer_save.Add((20,20),0, wx.LEFT|wx.RIGHT|wx.EXPAND,45)   
    1941               
     1839        sizer_save.Add((20, 20), 0, wx.LEFT|wx.RIGHT|wx.EXPAND, 45)   
    19421840        sizer_save.Add(self.btSave)      
    1943          
    19441841        boxsizer1.Add(sizer_save) 
    1945         self.sizer6.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10) 
     1842        self.sizer6.Add(boxsizer1, 0, wx.EXPAND|wx.ALL, 10) 
    19461843        self.sizer6.Layout() 
    1947         self.SetScrollbars(20,20,25,65) 
     1844        self.SetScrollbars(20, 20, 25, 65) 
    19481845         
    19491846    def _lay_out(self): 
    … …  
    19711868            time.sleep(1) 
    19721869              
    1973     def on_reset_clicked(self,event): 
     1870    def on_reset_clicked(self, event): 
    19741871        """ 
    19751872        On 'Reset' button  for Q range clicked 
    … …  
    19781875        ##For 3 different cases: Data2D, Data1D, and theory 
    19791876        if self.data.__class__.__name__ == "Data2D": 
    1980             data_min= 0 
    1981             x= max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))  
    1982             y= max(math.fabs(self.data.ymin), math.fabs(self.data.ymax)) 
     1877            data_min = 0 
     1878            x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))  
     1879            y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax)) 
    19831880            self.qmin_x = data_min 
    1984             self.qmax_x = math.sqrt(x*x + y*y) 
     1881            self.qmax_x = math.sqrt(x * x + y * y) 
    19851882        elif self.data.__class__.__name__ == "Data1D": 
    19861883            self.qmin_x = min(self.data.x) 
    … …  
    19911888            self.num_points = _NPTS_DEFAULT             
    19921889            self.state.npts = self.num_points 
    1993              
    19941890        self.state.qmin = self.qmin_x 
    19951891        self.state.qmax = self.qmax_x 
    1996          
    19971892        #reset the q range values 
    19981893        self._reset_plotting_range(self.state) 

  • theoryview/perspectives/theory/help_panel.py

    r74755ff r2f60121  
    77 
    88class HelpWindow(wx.Frame): 
    9     def __init__(self, parent, id, title= 'HelpWindow', pageToOpen=None): 
     9    def __init__(self, parent, id, title='HelpWindow', pageToOpen=None): 
    1010        wx.Frame.__init__(self, parent, id, title, size=(850, 500)) 
    1111        """ 
    … …  
    1616        splitter = MultiSplitterWindow(self, style=wx.SP_LIVE_UPDATE) 
    1717        rpanel = wx.Panel(splitter, -1) 
    18         lpanel = wx.Panel(splitter, -1,style=wx.BORDER_SUNKEN) 
     18        lpanel = wx.Panel(splitter, -1, style=wx.BORDER_SUNKEN) 
    1919         
    2020        vbox = wx.BoxSizer(wx.VERTICAL) 
    … …  
    2727        font.SetPointSize(10) 
    2828        st.SetFont(font) 
    29         hbox.Add(st, 1, wx.TOP | wx.BOTTOM | wx.LEFT, 5) 
     29        hbox.Add(st, 1, wx.TOP|wx.BOTTOM|wx.LEFT, 5) 
    3030        header.SetSizer(hbox) 
    3131        vbox.Add(header, 0, wx.EXPAND) 
    … …  
    4141        fontl.SetPointSize(10) 
    4242        lst.SetFont(fontl) 
    43         hboxl.Add(lst, 1, wx.TOP | wx.BOTTOM | wx.LEFT, 5) 
     43        hboxl.Add(lst, 1, wx.TOP|wx.BOTTOM|wx.LEFT, 5) 
    4444        headerl.SetSizer(hboxl) 
    4545        vboxl.Add(headerl, 0, wx.EXPAND) 
    4646        self.lhelp = html.HtmlWindow(lpanel, -1, style=wx.NO_BORDER) 
    47         self.rhelp = html.HtmlWindow(rpanel, -1, style=wx.NO_BORDER, size=(500,-1)) 
    48         page1="""<html> 
     47        self.rhelp = html.HtmlWindow(rpanel, -1,  
     48                                     style=wx.NO_BORDER, size=(500, -1)) 
     49        page1 = """<html> 
    4950            <body> 
    5051             <p>Select topic on Menu</p> 
    5152            </body> 
    5253            </html>""" 
    53         page="""<html> 
     54        page = """<html> 
    5455            <body> 
    5556            <ul> 
    … …  
    6061        self.rhelp.SetPage(page1) 
    6162        self.lhelp.SetPage(page) 
    62         self.lhelp.Bind(wx.html.EVT_HTML_LINK_CLICKED,self.OnLinkClicked ) 
    63          
     63        self.lhelp.Bind(wx.html.EVT_HTML_LINK_CLICKED, self.OnLinkClicked) 
    6464        #open the help frame a the current page 
    65         if  pageToOpen!= None: 
    66             self.rhelp.LoadPage(str( pageToOpen)) 
    67              
    68         vbox.Add(self.rhelp,1, wx.EXPAND) 
     65        if  pageToOpen != None: 
     66            self.rhelp.LoadPage(str(pageToOpen)) 
     67        vbox.Add(self.rhelp, 1, wx.EXPAND) 
    6968        vboxl.Add(self.lhelp, 1, wx.EXPAND) 
    7069        rpanel.SetSizer(vbox) 
    7170        lpanel.SetSizer(vboxl) 
    7271        lpanel.SetFocus() 
    73          
    7472        vbox1 = wx.BoxSizer(wx.HORIZONTAL) 
    75         vbox1.Add(splitter,1,wx.EXPAND) 
     73        vbox1.Add(splitter, 1, wx.EXPAND) 
    7674        splitter.AppendWindow(lpanel, 200) 
    7775        splitter.AppendWindow(rpanel) 
    7876        self.SetSizer(vbox1) 
    79         
    8077        self.Centre() 
    8178        self.Show(True) 

  • theoryview/perspectives/theory/model_panel.py

    rd7b7156 r2f60121  
    55import copy 
    66import math 
    7 from sans.models.dispersion_models import ArrayDispersion, GaussianDispersion 
    8  
     7from sans.guiframe.panel_base import PanelBase 
     8from sans.models.dispersion_models import ArrayDispersion 
     9from sans.models.dispersion_models import GaussianDispersion 
    910from sans.guicomm.events import StatusEvent    
    1011from sans.guiframe.utils import format_number 
    11 (ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent() 
    12 _BOX_WIDTH = 76 
    13  
    1412import basepage 
    1513from basepage import BasicPage 
    1614from basepage import PageInfoEvent 
    17  
    18 class ModelPanel(BasicPage): 
     15(ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent() 
     16 
     17_BOX_WIDTH = 76 
     18 
     19 
     20class ModelPanel(BasicPage, PanelBase): 
    1921    """ 
    2022    FitPanel class contains fields allowing to display results when 
    … …  
    3032    ## Title to appear on top of the window 
    3133    window_caption = "Theory Model" 
    32     def __init__(self,parent, page_info, model_list_box): 
    33         BasicPage.__init__(self, parent, page_info , model_list_box) 
     34     
     35    def __init__(self, parent, page_info, model_list_box): 
     36        BasicPage.__init__(self, parent, page_info, model_list_box) 
     37        PanelBase.__init__(self) 
    3438        """  
    3539        Initialization of the Panel 
    … …  
    3842        self._fill_range_sizer() 
    3943        self.engine_type = None  
    40           
    41         description="" 
    42         if self.model!=None: 
    43              
     44        description = "" 
     45        if self.model != None: 
    4446            description = self.model.description 
    45              
    4647            self.select_model(self.model) 
    47             self.set_model_description(description,self.sizer2) 
     48            self.set_model_description(description, self.sizer2) 
    4849             
    4950    def _on_display_description(self, event): 
    … …  
    5556        """ 
    5657        self._on_display_description_helper() 
    57          
    58         self.SetScrollbars(20,20,25,65) 
     58        self.SetScrollbars(20, 20, 25, 65) 
    5959        self.Refresh() 
    6060 
    … …  
    6969        if self.description_hide.GetValue(): 
    7070            self.sizer_description.Clear(True) 
    71              
    7271        else: 
    7372            description="Model contains no description" 
    74             if self.model!=None: 
     73            if self.model != None: 
    7574                description = self.model.description 
    76             if description.lstrip().rstrip() =="":  
     75            if description.lstrip().rstrip() == "":  
    7776                description="Model contains no description" 
    78             self.description = wx.StaticText( self,-1,str(description) ) 
    79             self.sizer_description.Add( self.description, 1, wx.EXPAND | wx.ALL, 10 ) 
    80             
     77            self.description = wx.StaticText(self, -1, str(description)) 
     78            self.sizer_description.Add(self.description, 1,  
     79                                       wx.EXPAND|wx.ALL, 10) 
    8180        self.Layout() 
    82      
    8381     
    8482    def _fill_range_sizer(self): 
    … …  
    9088        ##The following 3 lines are for Mac. Let JHC know before modifying.. 
    9189        title = "Plotted Q Range" 
    92         box_description= wx.StaticBox(self, -1,str(title)) 
     90        box_description = wx.StaticBox(self, -1, str(title)) 
    9391        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL) 
    9492 
    95         sizer_npts= wx.GridSizer(1, 1,5, 5)     
    96         self.npts    = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH,20), style=wx.TE_PROCESS_ENTER) 
     93        sizer_npts= wx.GridSizer(1, 1, 5, 5)     
     94        self.npts    = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 20),  
     95                                          style=wx.TE_PROCESS_ENTER) 
    9796        self.npts.SetValue(format_number(self.num_points)) 
    9897        self.npts.SetToolTipString("Number of point to plot.") 
    99          
    100         sizer_npts.Add(wx.StaticText(self, -1, 'Npts'),1, wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 13)         
    101  
    102         sizer_npts.Add(self.npts,1,wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 10)  
    103         self._set_range_sizer( title=title, box_sizer=boxsizer1, object= sizer_npts) 
    104         
    105         
     98        sizer_npts.Add(wx.StaticText(self, -1, 'Npts'), 1,  
     99                       wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 13)         
     100        sizer_npts.Add(self.npts, 1, wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 10)  
     101        self._set_range_sizer(title=title, box_sizer=boxsizer1,  
     102                              object=sizer_npts) 
     103     
    106104    def _on_select_model(self, event):  
    107105        """ 
    … …  
    114112        self.select_model(self.model) 
    115113         
    116         
    117114    def _fill_model_sizer(self, sizer): 
    118115        """ 
    … …  
    122119        ##The following 3 lines are for Mac. Let JHC know before modifying.. 
    123120        title = "Model" 
    124         box_description= wx.StaticBox(self, -1,str(title)) 
     121        box_description = wx.StaticBox(self, -1, str(title)) 
    125122        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL) 
    126          
    127123        id = wx.NewId() 
    128         self.model_view =wx.Button(self,id,'View 2D', size=(80,23)) 
    129         self.model_view.Bind(wx.EVT_BUTTON, self._onModel2D,id=id) 
     124        self.model_view = wx.Button(self, id,'View 2D', size=(80, 23)) 
     125        self.model_view.Bind(wx.EVT_BUTTON, self._onModel2D, id=id) 
    130126        self.model_view.SetToolTipString("View model in 2D") 
    131          
    132127        ## class base method  to add view 2d button    
    133         self._set_model_sizer(sizer=sizer,box_sizer=boxsizer1, title=title,object= self.model_view )     
    134      
    135    
     128        self._set_model_sizer(sizer=sizer, box_sizer=boxsizer1,  
     129                              title=title, object=self.model_view)     
     130     
    136131    #def _set_sizer_gaussian(self): 
    137132    def _set_sizer_dispersion(self, dispersity): 
    … …  
    140135         
    141136        """ 
    142         self.fittable_param=[] 
    143         self.fixed_param=[] 
    144         self.orientation_params_disp=[] 
     137        self.fittable_param = [] 
     138        self.fixed_param = [] 
     139        self.orientation_params_disp = [] 
    145140        #self.temp=[] 
    146         
    147141        self.sizer4_4.Clear(True) 
    148         if self.model==None: 
     142        if self.model == None: 
    149143            ##no model is selected 
    150144            return 
    … …  
    159153            self._disp_obj_dict[item] = disp_model 
    160154            self.model.set_dispersion(item, disp_model) 
    161             self.state._disp_obj_dict[item]= disp_model 
    162              
    163              
    164         ix=0 
    165         iy=1 
     155            self.state._disp_obj_dict[item] = disp_model 
     156        ix = 0 
     157        iy = 1 
    166158        disp = wx.StaticText(self, -1, ' ') 
    167         self.sizer4_4.Add(disp,( iy, ix),(1,1),  
     159        self.sizer4_4.Add(disp,(iy, ix), (1, 1),  
    168160                           wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
    169161        ix += 1  
    170162        values = wx.StaticText(self, -1, 'Sigma [A]') 
    171         values.SetToolTipString(\ 
    172         "Sigma(STD) in the A unit; the standard deviation from the mean value.") 
    173  
    174         self.sizer4_4.Add(values,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE,  
    175                           0) 
    176         
     163        hint_msg = "Sigma(STD) in the A unit; the standard " 
     164        hint_msg += "deviation from the mean value." 
     165        values.SetToolTipString(hint_msg) 
     166        self.sizer4_4.Add(values, (iy, ix), (1, 1),  
     167                          wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    177168        ix += 1  
    178169        npts = wx.StaticText(self, -1, 'Npts') 
    179         npts.SetToolTipString("Number of sampling points for the numerical\n\ 
    180         integration over the distribution function.") 
    181         self.sizer4_4.Add(npts,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
     170        hint_msg = "Number of sampling points for the numerical\n" 
     171        hint_msg += "integration over the distribution function." 
     172        npts.SetToolTipString(hint_msg) 
     173        self.sizer4_4.Add(npts, (iy, ix), (1, 1), 
     174                          wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    182175        ix += 1  
    183176        nsigmas = wx.StaticText(self, -1, 'Nsigmas') 
    184         nsigmas.SetToolTipString("   Number of sigmas between which the range\n\ 
    185          of the distribution function will be used for weighting. \n\ 
    186         The value '3' covers 99.5% for Gaussian distribution \n\ 
    187         function.") 
    188         self.sizer4_4.Add(nsigmas,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 
    189                            0) 
    190           
     177        hint_msg = "Number of sigmas between which the range\n" 
     178        hint_msg += "of the distribution function will be used for " 
     179        hint_msg += "weighting.\n The value '3' covers 99.5% for Gaussian " 
     180        hint_msg += "  distribution \n function." 
     181        nsigmas.SetToolTipString(hint_msg) 
     182        self.sizer4_4.Add(nsigmas, (iy, ix),  
     183                          (1, 1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    191184        for item in self.model.dispersion.keys(): 
    192185            if not item in self.model.orientation_params: 
    193                 self.disp_cb_dict[item]= None 
    194                 name0="Distribution of " + item 
    195                 name1=item+".width" 
     186                self.disp_cb_dict[item] = None 
     187                name0 = "Distribution of " + item 
     188                name1 = item + ".width" 
    196189                name2=item+".npts" 
    197190                name3=item+".nsigmas" 
    198191                iy += 1 
    199192                for p in self.model.dispersion[item].keys(): 
    200                     if p=="width": 
     193                    if p == "width": 
    201194                        ix = 0 
    202195                        name = wx.StaticText(self, -1,  name0) 
    … …  
    489482 
    490483        sizer_selection=wx.BoxSizer(wx.HORIZONTAL) 
    491         self.description_hide = wx.RadioButton(self, -1, 'Hide', style=wx.RB_GROUP) 
     484        self.description_hide = wx.RadioButton(self, -1, 'Hide',  
     485                                               style=wx.RB_GROUP) 
    492486        self.description_show = wx.RadioButton(self, -1, 'Show') 
    493487        
    494488         
    495         if description=="": 
     489        if description == "": 
    496490            self.description_hide.SetValue(True) 
    497             description=" Description unavailable. Click for details" 
     491            description = " Description unavailable. Click for details" 
    498492             
    499493        self.description = wx.StaticText( self,-1,str(description) ) 

  • theoryview/perspectives/theory/theory.py

    r9e2cfee r2f60121  
    99import model_panel 
    1010from model_panel import ModelPanel 
    11 from sans.guicomm.events import NewPlotEvent, StatusEvent  
     11from sans.guicomm.events import NewPlotEvent 
     12from sans.guicomm.events import StatusEvent  
    1213from sans.guiframe.dataFitting import Data2D 
    1314from sans.guiframe.dataFitting import Theory1D 
    … …  
    1718DEFAULT_QMAX = 0.13 
    1819DEFAULT_NPTS = 50 
     20 
    1921 
    2022class PlotInfo: 
    … …  
    3234    info= None 
    3335     
    34 class Plugin: 
     36from sans.guiframe.plugin_base import PluginBase   
     37 
     38class Plugin(PluginBase): 
    3539    """ 
    3640    This class defines the interface for a Plugin class 
    … …  
    4044     
    4145    def __init__(self, standalone=True): 
    42         """ 
    43         Abstract class for gui_manager Plugins. 
    44          
    45         """ 
    46         ## Plug-in name. It will appear on the application menu. 
    47         self.sub_menu = "Theory"         
    48          
    49         ## Reference to the parent window. Filled by get_panels() below. 
    50         self.parent = None 
    51          
    52         ## List of panels that you would like to open in AUI windows 
    53         #  for your plug-in. This defines your plug-in "perspective" 
    54         self.perspective = [] 
     46        PluginBase.__init__(self, name="Theory", standalone=standalone) 
     47         
    5548        # Log startup 
    5649        logging.info("Theory plug-in started")    
    … …  
    5952        self.menu_mng = models.ModelManager() 
    6053        # reference to the current running thread 
    61         self.calc_2D= None 
    62         self.calc_1D= None 
    63          
    64     def populate_menu(self, id, owner): 
    65         """ 
    66         Create and return the list of application menu 
    67         items for the plug-in.  
    68          
    69         :param id: deprecated. Un-used. 
    70         :param parent: parent window 
    71          
    72         :return: plug-in menu 
    73         """ 
    74         return [] 
    75        
     54        self.calc_2D = None 
     55        self.calc_1D = None 
     56    
    7657    def get_panels(self, parent): 
    7758        """ 
    … …  
    9980        return [self.model_panel] 
    10081     
    101     def get_context_menu(self, graph=None): 
    102         """ 
    103         This method is optional. 
    104      
    105         When the context menu of a plot is rendered, the  
    106         get_context_menu method will be called to give you a  
    107         chance to add a menu item to the context menu. 
    108          
    109         A ref to a Graph object is passed so that you can 
    110         investigate the plot content and decide whether you 
    111         need to add items to the context menu.   
    112          
    113         This method returns a list of menu items. 
    114         Each item is itself a list defining the text to  
    115         appear in the menu, a tool-tip help text, and a 
    116         call-back method. 
    117          
    118         :param graph: the Graph object to which we attach the context menu 
    119          
    120         :return: a list of menu items with call-back function 
    121          
    122         """ 
    123         return []     
    124      
    125     def get_perspective(self): 
    126         """ 
    127         Get the list of panel names for this perspective 
    128          
    129         """ 
    130         return self.perspective 
    131      
    132     def on_perspective(self, event): 
    133         """ 
    134         Call back function for the perspective menu item. 
    135         We notify the parent window that the perspective 
    136         has changed. 
    137          
    138         :param event: menu event 
    139          
    140         """ 
    141         self.parent.set_perspective(self.perspective) 
    142      
    143     def post_init(self): 
    144         """ 
    145         Post initialization call back to close the loose ends 
    146          
    147         """ 
    148         pass 
    149              
     82    
    15083    def draw_model(self, model, data= None,smearer= None, 
    15184                   enable1D= True, enable2D= False, 
Note: See TracChangeset for help on using the changeset viewer.