source: sasview/sansview/perspectives/fitting/basepage.py @ 8077fc4

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 8077fc4 was 6d1235b, checked in by Mathieu Doucet <doucetm@…>, 16 years ago

sansview: removing the save state functionality ahead of release 0.9.0
  • Property mode set to 100644
File size: 54.3 KB
Line 
1
2import sys, os
3import wx
4import numpy
5import time
6import copy 
7from sans.guiframe.utils import format_number,check_float
8from sans.guicomm.events import StatusEvent   
9import pagestate
10from pagestate import PageState
11(PageInfoEvent, EVT_PAGE_INFO)   = wx.lib.newevent.NewEvent()
12_BOX_WIDTH = 80
13
14class BasicPage(wx.ScrolledWindow):
15    """
16        This class provide general structure of  fitpanel page
17    """
18     ## Internal name for the AUI manager
19    window_name = "Basic Page"
20    ## Title to appear on top of the window
21    window_caption = "Basic page "
22   
23    def __init__(self,parent, page_info):
24        wx.ScrolledWindow.__init__(self, parent)
25        ##window_name
26        self.window_name = page_info.window_name
27        ##window_caption
28        self.window_caption = page_info.window_caption
29        ## parent of the page
30        self.parent = parent
31        ## manager is the fitting plugin
32        self.manager= page_info.manager
33        ## owner of the page (fitting plugin)
34        self.event_owner= page_info.event_owner
35         ## current model
36        self.model = page_info.model
37        ## data
38        self.data = page_info.data
39        ## dictionary containing list of models
40        self.model_list_box = page_info.model_list_box
41        ## Data member to store the dispersion object created
42        self._disp_obj_dict = {}
43        ## selected parameters to apply dispersion
44        self.disp_cb_dict ={}
45        ## smearer object
46        self.smearer = None
47        ##list of model parameters. each item must have same length
48        ## each item related to a given parameters
49        ##[cb state, name, value, "+/-", error of fit, min, max , units]
50        self.parameters=[]
51        ## list of parameters to fit , must be like self.parameters
52        self.param_toFit=[]
53        ## list of looking like parameters but with non fittable parameters info
54        self.fixed_param=[]
55        ## list of looking like parameters but with  fittable parameters info
56        self.fittable_param=[]
57        ##list of dispersion parameters
58        self.disp_list=[]
59        ## list of orientation parameters
60        self.orientation_params=[]
61        self.orientation_params_disp=[]
62        if self.model !=None:
63            self.disp_list= self.model.getDispParamList()
64        ##enable model 2D draw
65        self.enable2D= False
66        ## check that the fit range is correct to plot the model again
67        self.fitrange= True
68        ## Q range
69        self.qmin_x= 0.001
70        self.qmax_x= 0.13
71        self.num_points= 100
72        ## Create memento to save the current state
73       
74        self.state= PageState(parent= self.parent,model=self.model, data=self.data)
75       
76        ## retrieve saved state
77        self.number_saved_state= 0
78        ## dictionary of saved state
79        self.saved_states={}
80        self.slicerpop = wx.Menu()
81        ## Default locations
82        self._default_save_location = os.getcwd()     
83        ## save initial state on context menu
84        self.onSave(event=None)
85        self.Bind(wx.EVT_CONTEXT_MENU, self.onContextMenu)
86       
87        ## create the basic structure of the panel with empty sizer
88        self.define_page_structure()
89        ## drawing Initial dispersion parameters sizer
90        self.set_dispers_sizer()
91        self._fill_save_sizer()
92        ## layout
93        self.set_layout()
94       
95       
96    def onContextMenu(self, event): 
97        """
98            Retrieve the state selected state
99        """
100        # Skipping the save state functionality for release 0.9.0
101        return
102   
103        pos = event.GetPosition()
104        pos = self.ScreenToClient(pos)
105        #TODO: why is the state menu called "slicerpop"?
106        self.PopupMenu(self.slicerpop, pos) 
107       
108       
109       
110    def define_page_structure(self):
111        """
112            Create empty sizer for a panel
113        """
114        self.vbox  = wx.BoxSizer(wx.VERTICAL)
115        self.sizer0 = wx.BoxSizer(wx.VERTICAL)
116        self.sizer1 = wx.BoxSizer(wx.VERTICAL)
117        self.sizer2 = wx.BoxSizer(wx.VERTICAL)
118        self.sizer3 = wx.BoxSizer(wx.VERTICAL)
119        self.sizer4 = wx.BoxSizer(wx.VERTICAL)
120        self.sizer5 = wx.BoxSizer(wx.VERTICAL)
121        self.sizer6 = wx.BoxSizer(wx.VERTICAL)
122       
123        self.sizer0.SetMinSize((375,-1))
124        self.sizer1.SetMinSize((375,-1))
125        self.sizer2.SetMinSize((375,-1))
126        self.sizer3.SetMinSize((375,-1))
127        self.sizer4.SetMinSize((375,-1))
128        self.sizer5.SetMinSize((375,-1))
129        self.sizer6.SetMinSize((375,-1))
130       
131        self.vbox.Add(self.sizer0)
132        self.vbox.Add(self.sizer1)
133        self.vbox.Add(self.sizer2)
134        self.vbox.Add(self.sizer3)
135        self.vbox.Add(self.sizer4)
136        self.vbox.Add(self.sizer5)
137        self.vbox.Add(self.sizer6)
138       
139       
140    def set_layout(self):
141        """
142             layout
143        """
144        self.vbox.Layout()
145        self.vbox.Fit(self) 
146        self.SetSizer(self.vbox)
147       
148        self.set_scroll()
149        self.Centre()
150       
151       
152    def set_scroll(self):
153        self.SetScrollbars(20,20,200,100)
154        self.Layout()   
155        self.SetAutoLayout(True)
156         
157         
158    def set_owner(self,owner):
159        """
160            set owner of fitpage
161            @param owner: the class responsible of plotting
162        """
163        self.event_owner = owner   
164        self.state.event_owner = owner
165 
166    def set_manager(self, manager):
167        """
168             set panel manager
169             @param manager: instance of plugin fitting
170        """
171        self.manager = manager 
172        self.state.manager = manager
173       
174    def populate_box(self, dict):
175        """
176             Store list of model
177             @param dict: dictionary containing list of models
178        """
179        self.model_list_box = dict
180        self.state.model_list_box = self.model_list_box
181           
182   
183       
184    def set_dispers_sizer(self):
185        """
186            fill sizer containing dispersity info
187        """
188        self.sizer4.Clear(True)
189        name="Polydispersity and Orientational Distribution"
190        box_description= wx.StaticBox(self, -1,name)
191        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
192        #----------------------------------------------------
193        self.disable_disp = wx.RadioButton(self, -1, 'Off', (10, 10), style=wx.RB_GROUP)
194        self.enable_disp = wx.RadioButton(self, -1, 'On', (10, 30))
195        ## saving the state of enable dispersity button
196        self.state.enable_disp= self.enable_disp.GetValue()
197       
198        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, id=self.disable_disp.GetId())
199        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, id=self.enable_disp.GetId())
200       
201        sizer_dispersion = wx.BoxSizer(wx.HORIZONTAL)
202        sizer_dispersion.Add((20,20))
203        name=""#Polydispersity and \nOrientational Distribution "
204        sizer_dispersion.Add(wx.StaticText(self,-1,name))
205        sizer_dispersion.Add(self.enable_disp )
206        sizer_dispersion.Add((20,20))
207        sizer_dispersion.Add(self.disable_disp )
208        sizer_dispersion.Add((10,10))
209       
210        ## fill a sizer with the combobox to select dispersion type
211        sizer_select_dispers = wx.BoxSizer(wx.HORIZONTAL) 
212        self.model_disp = wx.StaticText(self, -1, 'Distribution Function ')
213           
214        import sans.models.dispersion_models 
215        self.polydisp= sans.models.dispersion_models.models
216        self.disp_box = wx.ComboBox(self, -1)
217       
218        for key in self.polydisp.iterkeys():
219            name = str(key.__name__)
220            if name=="ArrayDispersion":
221                # Remove the option until the rest of the code is ready for it
222                self.disp_box.Append("Select customized Model",key)
223               
224            else:
225                self.disp_box.Append(name,key)
226        self.disp_box.SetSelection(0) 
227       
228        wx.EVT_COMBOBOX(self.disp_box,-1, self._on_select_Disp) 
229             
230        sizer_select_dispers.Add((10,10)) 
231        sizer_select_dispers.Add(self.model_disp) 
232        sizer_select_dispers.Add(self.disp_box,0,
233                wx.TOP|wx.BOTTOM|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE,border=5)
234        #sizer_select_dispers.Add((10,10))
235        self.model_disp.Hide()
236        self.disp_box.Hide()
237       
238        boxsizer1.Add( sizer_dispersion,0,
239                wx.TOP|wx.BOTTOM|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE,border=5)
240        #boxsizer1.Add( (10,10) )
241        boxsizer1.Add( sizer_select_dispers )
242        self.sizer4_4 = wx.GridBagSizer(5,5)
243        boxsizer1.Add( self.sizer4_4  )
244        #-----------------------------------------------------
245        self.sizer4.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10)
246        self.sizer4_4.Layout()
247        self.sizer4.Layout()
248        self.Layout()
249        self.SetScrollbars(20,20,200,100)
250        self.Refresh()
251       
252   
253    def select_disp_angle(self, event): 
254        """
255            Event for when a user select a parameter to average over.
256            @param event: check box event
257        """
258       
259       
260        # Go through the list of dispersion check boxes to identify which one has changed
261        for p in self.disp_cb_dict:
262            # Catch which one of the box was just checked or unchecked.
263            if event.GetEventObject() == self.disp_cb_dict[p]:             
264
265               
266                if self.disp_cb_dict[p].GetValue() == True:
267                    # The user wants this parameter to be averaged.
268                    # Pop up the file selection dialog.
269                    path = self._selectDlg()
270                   
271                    # If nothing was selected, just return
272                    if path is None:
273                        self.disp_cb_dict[p].SetValue(False)
274                        return
275                    try:
276                        self._default_save_location = os.path.dirname(path)
277                    except:
278                        pass 
279                    try:
280                        values,weights = self.read_file(path)
281                    except:
282                        msg="Could not read input file"
283                        wx.PostEvent(self.parent.parent, StatusEvent(status= msg))
284                        return
285                   
286                    # If any of the two arrays is empty, notify the user that we won't
287                    # proceed
288                    if values is None or weights is None:
289                        wx.PostEvent(self.parent.parent, StatusEvent(status=\
290                            "The loaded %s distrubtion is corrupted or empty" % p))
291                        return
292                       
293                    # Tell the user that we are about to apply the distribution
294                    wx.PostEvent(self.parent.parent, StatusEvent(status=\
295                            "Applying loaded %s distribution: %s" % (p, path))) 
296                   
297                    # Create the dispersion objects
298                    from sans.models.dispersion_models import ArrayDispersion
299                    disp_model = ArrayDispersion()
300                    disp_model.set_weights(values, weights)
301                    # Store the object to make it persist outside the scope of this method
302                    #TODO: refactor model to clean this up?
303                    self._disp_obj_dict[p] = disp_model
304                    # Set the new model as the dispersion object for the selected parameter
305                    self.model.set_dispersion(p, disp_model)
306                    # Store a reference to the weights in the model object so that
307                    # it's not lost when we use the model within another thread.
308                    #TODO: total hack - fix this
309                    if not hasattr(self.model, "_persistency_dict"):
310                        self.model._persistency_dict = {}
311                    self.model._persistency_dict[p] = [values, weights]
312                else:
313                    # The parameter was un-selected. Go back to Gaussian model (with 0 pts)
314                    self._reset_dispersity()
315                   
316                ## Redraw the model
317                self._draw_model()
318        return
319   
320   
321    def onResetModel(self, event):
322        """
323            Reset model state
324        """
325        ## post help message for the selected model
326        msg = self.slicerpop.GetHelpString(event.GetId())
327        msg +=" reloaded"
328        wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
329       
330        name= self.slicerpop.GetLabel(event.GetId())
331        if name in self.saved_states.keys():
332            previous_state = self.saved_states[name]
333            self.reset_page(previous_state)
334           
335   
336    def onSave(self, event):
337        """
338            save history of the data and model
339        """
340        # Skipping the save state functionality for release 0.9.0
341        return
342   
343        if self.model==None:
344            return 
345        if hasattr(self,"enable_disp"):
346            self.state.enable_disp = copy.deepcopy(self.enable_disp.GetValue())
347        if hasattr(self, "disp_box"):
348            self.state.disp_box = copy.deepcopy(self.disp_box.GetSelection())
349       
350        self.state.model = self.model.clone()
351        new_state = self.state.clone()
352        new_state.enable2D = copy.deepcopy(self.enable2D)
353        ##Add model state on context menu
354        self.number_saved_state += 1
355        name= self.model.name+"[%g]"%self.number_saved_state
356        self.saved_states[name]= new_state
357       
358        ## Add item in the context menu
359       
360        year, month, day,hour,minute,second,tda,ty,tm_isdst= time.localtime()
361        my_time= str(hour)+" : "+str(minute)+" : "+str(second)+" "
362        date= str( month)+"|"+str(day)+"|"+str(year)
363        msg=  "Model saved at %s on %s"%(my_time, date)
364         ## post help message for the selected model
365        msg +=" Saved! right click on this page to retrieve this model"
366        wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
367       
368        id = wx.NewId()
369        self.slicerpop.Append(id,name,str(msg))
370        wx.EVT_MENU(self, id, self.onResetModel)
371       
372    def onSetFocus(self, evt):
373        """
374            highlight the current textcrtl and hide the error text control shown
375            after fitting
376        """
377       
378        if hasattr(self,"text2_3"):
379            self.text2_3.Hide()
380        if len(self.parameters)>0:
381            for item in self.parameters:
382                ## hide statictext +/-   
383                if item[3]!=None:
384                    item[3].Hide()
385                ## hide textcrtl  for error after fit
386                if item[4]!=None:
387                    item[4].Clear()
388                    item[4].Hide()
389        if len(self.fittable_param)>0:
390            for item in self.fittable_param:
391                ## hide statictext +/-   
392                if item[3]!=None:
393                    item[3].Hide()
394                ## hide textcrtl  for error after fit
395                if item[4]!=None:
396                    item[4].Clear()
397                    item[4].Hide()
398        self.Layout()
399        # Get a handle to the TextCtrl
400        widget = evt.GetEventObject()
401        # Select the whole control, after this event resolves
402        wx.CallAfter(widget.SetSelection, -1,-1)
403        return
404   
405   
406    def read_file(self, path):
407        """
408            Read two columns file
409            @param path: the path to the file to read
410        """
411        try:
412            if path==None:
413                wx.PostEvent(self.parent.parent, StatusEvent(status=\
414                            " Selected Distribution was not loaded: %s"%path))
415                return None, None
416            input_f = open(path, 'r')
417            buff = input_f.read()
418            lines = buff.split('\n')
419           
420            angles = []
421            weights=[]
422            for line in lines:
423                toks = line.split()
424                try:
425                    angle = float(toks[0])
426                    weight = float(toks[1])
427                except:
428                    # Skip non-data lines
429                    pass
430                angles.append(angle)
431                weights.append(weight)
432            return numpy.array(angles), numpy.array(weights)
433        except:
434            raise 
435   
436   
437    def createMemento(self):
438        """
439            return the current state of the page
440        """
441        return self.state.clone()
442   
443   
444    def save_current_state(self):
445        """
446            Store current state
447        """
448        if self.model!= None:
449            self.state.model = self.model.clone()
450        self.state.save_data(self.data)
451       
452        self.state.enable2D = copy.deepcopy(self.enable2D)
453       
454        if hasattr(self,"cb1"):
455            self.state.cb1= self.cb1.GetValue()
456           
457        if hasattr(self,"enable_disp"):
458            self.state.enable_disp= self.enable_disp.GetValue()
459            self.state.disable_disp = self.disable_disp.GetValue()
460           
461        self.state.smearer = copy.deepcopy(self.smearer)
462        if hasattr(self,"enable_smearer"):
463            self.state.enable_smearer = copy.deepcopy(self.enable_smearer.GetValue())
464            self.state.disable_smearer = copy.deepcopy(self.disable_smearer.GetValue())
465           
466           
467        if hasattr(self,"disp_box"):
468            self.state.disp_box = self.disp_box.GetCurrentSelection()
469            if len(self.disp_cb_dict)>0:
470                for k , v in self.disp_cb_dict.iteritems():
471                    if v ==None :
472                        self.state.disp_cb_dict[k]= v
473                    else:
474                        try:
475                            self.state.disp_cb_dict[k]=v.GetValue()
476                        except:
477                            self.state.disp_cb_dict[k]= None
478           
479            if len(self._disp_obj_dict)>0:
480                for k , v in self._disp_obj_dict.iteritems():
481                    self.state._disp_obj_dict[k]= v
482           
483        self._save_plotting_range()
484       
485        self.state.orientation_params =[]
486        self.state.orientation_params_disp =[]
487        self.state.parameters =[]
488        self.state.fittable_param =[]
489        self.state.fixed_param =[]
490       
491        ## save checkbutton state and txtcrtl values
492        self._copy_parameters_state(self.orientation_params,
493                                     self.state.orientation_params)
494        self._copy_parameters_state(self.orientation_params_disp,
495                                     self.state.orientation_params_disp)
496        self._copy_parameters_state(self.parameters, self.state.parameters)
497       
498        self._copy_parameters_state(self.fittable_param, self.state.fittable_param)
499        self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
500       
501        ## post state to fit panel
502        event = PageInfoEvent(page = self)
503        wx.PostEvent(self.parent, event)
504   
505   
506    def reset_page_helper(self, state):
507        """
508            Use page_state and change the state of existing page
509        """
510        self.state = state.clone()
511        self.model= self.state.model
512        self.data = self.state.data
513        self.smearer= self.state.smearer
514        self.state.enable_smearer=state.enable_smearer
515       
516        ##model parameter values restore
517        self._set_model_sizer_selection( self.model )
518        self.set_model_param_sizer(self.model)
519     
520        self.enable2D= state.enable2D
521        self.state.enable2D= state.enable2D
522       
523        if hasattr(self,"model_view"):
524            if not self.enable2D:
525                self.model_view.Enable()
526            else:
527                self.model_view.Disable()
528           
529        if hasattr(self, "cb1"):   
530            self.cb1.SetValue(self.state.cb1)
531        ## display dispersion info layer
532        self.enable_disp.SetValue(self.state.enable_disp)
533        self.disable_disp.SetValue(self.state.disable_disp)
534        if hasattr(self, "disp_box"):
535            self.disp_box.SetSelection(self.state.disp_box) 
536           
537            self.disp_cb_dict = {}
538            for k,v in self.state.disp_cb_dict.iteritems():
539                self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
540                self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
541               
542            self._disp_obj_dict={}
543            for k , v in self.state._disp_obj_dict.iteritems():
544                self._disp_obj_dict[k]=v
545     
546        self._set_dipers_Param(event=None)
547        ##plotting range restore   
548        self._reset_plotting_range()
549        ## smearing info  restore
550        if hasattr(self,"enable_smearer"):
551            ## set smearing value whether or not the data contain the smearing info
552            self.enable_smearer.SetValue(state.enable_smearer)
553            self.disable_smearer.SetValue(state.disable_smearer)
554            self.compute_chisqr(smearer= self.smearer) 
555           
556       
557        ## reset state of checkbox,textcrtl  and parameters value
558        self._reset_parameters_state(self.orientation_params_disp,
559                                     state.orientation_params_disp)
560        self._reset_parameters_state(self.orientation_params,
561                                     state.orientation_params)
562        self._reset_parameters_state(self.parameters,state.parameters)
563        self._reset_parameters_state(self.fittable_param,state.fittable_param)
564        self._reset_parameters_state(self.fixed_param,state.fixed_param)
565        self._onparamEnter_helper()
566        ## reset context menu items
567        self._reset_context_menu()
568        ## draw the model with previous parameters value
569        #self._draw_model()
570       
571   
572   
573         
574       
575    def _selectDlg(self):
576        """
577            open a dialog file to selected the customized dispersity
578        """
579        import os
580        dlg = wx.FileDialog(self, "Choose a weight file",
581                                self._default_save_location , "", "*.*", wx.OPEN)
582        path = None
583        if dlg.ShowModal() == wx.ID_OK:
584            path = dlg.GetPath()
585        dlg.Destroy()
586        return path
587   
588   
589    def _reset_context_menu(self):
590        """
591            reset the context menu
592        """
593        for name, state in self.state.saved_states.iteritems():
594            self.number_saved_state += 1
595            ## Add item in the context menu
596            id = wx.NewId()
597            self.slicerpop.Append(id,name, 'Save model and state %g'%self.number_saved_state)
598            wx.EVT_MENU(self, id, self.onResetModel)
599   
600    def _reset_plotting_range(self):
601        """
602            Reset the plotting range to a given state
603        """
604       
605        #self.qmin.SetValue(format_number(self.state.qmin))
606        #self.qmax.SetValue(format_number(self.state.qmax))
607        self.qmin.SetValue(str(self.state.qmin))
608        self.qmax.SetValue(str(self.state.qmax)) 
609        if self.state.npts!=None:
610            self.npts.SetValue(format_number(self.state.npts)) 
611            self.num_points = float(self.state.npts)
612           
613        self.qmin_x = float(self.qmin.GetValue())
614        self.qmax_x = float(self.qmax.GetValue())
615       
616       
617    def _save_plotting_range(self ):
618        """
619            save the state of plotting range
620        """
621        self.state.qmin = self.qmin_x
622        self.state.qmax = self.qmax_x
623        if self.npts!=None:
624            self.state.npts= self.num_points
625           
626           
627    def _onparamEnter_helper(self):
628        """
629             check if values entered by the user are changed and valid to replot
630             model
631             use : _check_value_enter
632        """
633        if self.model !=None:
634            ## save current state
635            self.save_current_state()
636            # Flag to register when a parameter has changed.
637            is_modified = False
638            is_modified =self._check_value_enter( self.fittable_param ,is_modified)
639            is_modified =self._check_value_enter( self.fixed_param ,is_modified)
640            is_modified =self._check_value_enter( self.parameters ,is_modified)       
641           
642            self.Layout()
643            # Here we should check whether the boundaries have been modified.
644            # If qmin and qmax have been modified, update qmin and qmax and
645            # set the is_modified flag to True
646            from sans.guiframe.utils import check_value
647            if check_value( self.qmin, self.qmax):
648                if float(self.qmin.GetValue()) != self.qmin_x:
649                    self.qmin_x = float(self.qmin.GetValue())
650                    is_modified = True
651                if float(self.qmax.GetValue()) != self.qmax_x:
652                    self.qmax_x = float(self.qmax.GetValue())
653                    is_modified = True
654                self.fitrange = True
655            else:
656                self.fitrange = False
657            if self.npts != None:
658                if check_float(self.npts):
659                    if float(self.npts.GetValue()) !=  self.num_points:
660                        self.num_points = float(self.npts.GetValue())
661                        is_modified = True
662                else:
663                    msg= "Cannot Plot :Must enter a number!!!  "
664                    wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
665                   
666           
667            ## if any value is modify draw model with new value
668            if is_modified:
669                self._draw_model() 
670                self.save_current_state()
671               
672               
673    def _reset_parameters_state(self, listtorestore,statelist):
674        """
675            Reset the parameters at the given state
676        """
677        if len(statelist)==0 or  len(listtorestore)==0 :
678            return
679        if len(statelist)!=  len(listtorestore) :
680            return
681        for j in range(len(listtorestore)):
682            item_page = listtorestore[j]
683            item_page_info = statelist[j]
684            ##change the state of the check box for simple parameters
685            if item_page[0]!=None:
686                item_page[0].SetValue(item_page_info[0])
687   
688            if item_page[2]!=None:
689                item_page[2].SetValue(item_page_info[2])
690               
691            if item_page[3]!=None:
692                ## show or hide text +/-
693                if item_page_info[2]:
694                    item_page[3].Show(True)
695                else:
696                    item_page[3].Hide()
697            if item_page[4]!=None:
698                ## show of hide the text crtl for fitting error
699                if item_page_info[4][0]:
700                    item_page[4].Show(True)
701                    item_page[4].SetValue(item_page_info[4][1])
702                else:
703                    item_page[3].Hide()
704            if item_page[5]!=None:
705                ## show of hide the text crtl for fitting error
706                if item_page_info[5][0]:
707                    item_page[5].Show(True)
708                    item_page[5].SetValue(item_page_info[4][1])
709                else:
710                    item_page[5].Hide()
711                   
712            if item_page[6]!=None:
713                ## show of hide the text crtl for fitting error
714                if item_page_info[6][0]:
715                    item_page[6].Show(True)
716                    item_page[6].SetValue(item_page_info[6][1])
717                else:
718                    item_page[6].Hide()
719                           
720                           
721    def _copy_parameters_state(self, listtocopy, statelist):
722        """
723            copy the state of button
724            @param listtocopy: the list of check button to copy
725            @param statelist: list of state object to store the current state
726        """
727       
728        if len(listtocopy)==0:
729            return
730       
731        for item in listtocopy:
732            checkbox_state = None
733            if item[0]!= None:
734                checkbox_state= item[0].GetValue()
735            parameter_name = item[1]
736            parameter_value = None
737            if item[2]!=None:
738                parameter_value = item[2].GetValue()
739            static_text = None
740            if item[3]!=None:
741                static_text = item[3].IsShown()
742            error_value = None
743            error_state = None
744            if item[4]!= None:
745                error_value = item[4].GetValue()
746                error_state = item[4].IsShown()
747               
748            min_value = None
749            min_state = None
750            if item[5]!= None:
751                min_value = item[5].GetValue()
752                min_state = item[5].IsShown()
753               
754            max_value = None
755            max_state = None
756            if item[6]!= None:
757                max_value = item[6].GetValue()
758                max_state = item[6].IsShown()
759               
760            statelist.append([checkbox_state, parameter_name, parameter_value,
761                              static_text ,[error_state,error_value],
762                                [min_state,min_value],[max_state , max_value],None])
763           
764       
765   
766    def _set_model_sizer_selection(self, model):
767        """
768            Display the sizer according to the type of the current model
769        """
770        if hasattr(model ,"model2"):
771           
772            class_name= model.model2.__class__
773            name= model.model2.name
774            flag= name != "NoStructure"
775            if flag and (class_name in self.model_list_box["Structure Factors"]):
776                self.structurebox.Enable()
777                items = self.structurebox.GetItems()
778                self.sizer1.Layout()
779                self.SetScrollbars(20,20,200,100)
780                for i in range(len(items)):
781                    if items[i]== str(name):
782                        self.structurebox.SetSelection(i)
783                        break
784                   
785        if hasattr(model ,"model1"):
786            class_name = model.model1.__class__
787            name = model.model1.name
788            self.formfactorbox.Clear()
789           
790            for k, list in self.model_list_box.iteritems():
791                if k in["P(Q)*S(Q)","Shapes" ] and class_name in self.model_list_box["Shapes"]:
792                    self.shape_rbutton.SetValue(True)
793                    ## fill the form factor list with new model
794                    self._populate_box(self.formfactorbox,self.model_list_box["Shapes"])
795                    items = self.formfactorbox.GetItems()
796                    ## set comboxbox to the selected item
797                    for i in range(len(items)):
798                        if items[i]== str(name):
799                            self.formfactorbox.SetSelection(i)
800                            break
801                    return
802                elif k == "Shape-Independent":
803                    self.shape_indep_rbutton.SetValue(True)
804                elif k == "Structure Factors":
805                     self.struct_rbutton.SetValue(True)
806                else:
807                    self.plugin_rbutton.SetValue(True)
808               
809                if class_name in list:
810                    ## fill the form factor list with new model
811                    self._populate_box(self.formfactorbox, list)
812                    items = self.formfactorbox.GetItems()
813                    ## set comboxbox to the selected item
814                    for i in range(len(items)):
815                        if items[i]== str(name):
816                            self.formfactorbox.SetSelection(i)
817                            break
818                    break
819        else:
820            ## Select the model from the combobox
821            class_name = model.__class__
822            name = model.name
823            self.formfactorbox.Clear()
824            items = self.formfactorbox.GetItems()
825   
826            for k, list in self.model_list_box.iteritems():
827                if k in["P(Q)*S(Q)","Shapes" ] and class_name in self.model_list_box["Shapes"]:
828                   
829                    if class_name in self.model_list_box["P(Q)*S(Q)"]:
830                        self.structurebox.Enable()
831                    else:
832                        self.structurebox.Disable()
833                        self.structurebox.SetSelection(0)
834                       
835                    self.shape_rbutton.SetValue(True)
836                    ## fill the form factor list with new model
837                    self._populate_box(self.formfactorbox,self.model_list_box["Shapes"])
838                    items = self.formfactorbox.GetItems()
839                    ## set comboxbox to the selected item
840                    for i in range(len(items)):
841                        if items[i]== str(name):
842                            self.formfactorbox.SetSelection(i)
843                            break
844                    return
845                elif k == "Shape-Independent":
846                    self.shape_indep_rbutton.SetValue(True)
847                elif k == "Structure Factors":
848                     self.struct_rbutton.SetValue(True)
849                else:
850                    self.plugin_rbutton.SetValue(True)
851                if class_name in list:
852                    self.structurebox.SetSelection(0)
853                    self.structurebox.Disable()
854                    ## fill the form factor list with new model
855                    self._populate_box(self.formfactorbox, list)
856                    items = self.formfactorbox.GetItems()
857                    ## set comboxbox to the selected item
858                    for i in range(len(items)):
859                        if items[i]== str(name):
860                            self.formfactorbox.SetSelection(i)
861                            break
862                    break
863                   
864       
865    def _draw_model(self):
866        """
867            Method to draw or refresh a plotted model.
868            The method will use the data member from the model page
869            to build a call to the fitting perspective manager.
870           
871            [Note to coder: This way future changes will be done in only one place.]
872        """
873        if self.model !=None:
874            temp_smear=None
875            if hasattr(self, "enable_smearer"):
876                if self.enable_smearer.GetValue():
877                    temp_smear= self.smearer
878            self.manager.draw_model(self.model, data=self.data,
879                                    smearer= temp_smear,
880                                    qmin=float(self.qmin_x), qmax=float(self.qmax_x),
881                                    qstep= float(self.num_points),
882                                    enable2D=self.enable2D) 
883       
884    def _set_model_sizer(self, sizer, title="", object=None):
885        """
886            Use lists to fill a sizer for model info
887        """
888       
889        sizer.Clear(True)
890        box_description= wx.StaticBox(self, -1,str(title))
891        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
892        #--------------------------------------------------------
893        self.shape_rbutton = wx.RadioButton(self, -1, 'Shapes', style=wx.RB_GROUP)
894        self.shape_indep_rbutton = wx.RadioButton(self, -1, "Shape-Independent")
895        self.struct_rbutton = wx.RadioButton(self, -1, "Structure Factor ")
896        self.plugin_rbutton = wx.RadioButton(self, -1, "Customized Models")
897       
898        self.Bind( wx.EVT_RADIOBUTTON, self._show_combox,
899                            id= self.shape_rbutton.GetId() ) 
900        self.Bind( wx.EVT_RADIOBUTTON, self._show_combox,
901                            id= self.shape_indep_rbutton.GetId() ) 
902        self.Bind( wx.EVT_RADIOBUTTON, self._show_combox,
903                            id= self.struct_rbutton.GetId() ) 
904        self.Bind( wx.EVT_RADIOBUTTON, self._show_combox,
905                            id= self.plugin_rbutton.GetId() ) 
906       
907     
908        sizer_radiobutton = wx.GridSizer(2, 2,5, 5)
909        sizer_radiobutton.Add(self.shape_rbutton)
910        sizer_radiobutton.Add(self.shape_indep_rbutton)
911        sizer_radiobutton.Add(self.plugin_rbutton)
912        sizer_radiobutton.Add(self.struct_rbutton)
913       
914        sizer_selection = wx.BoxSizer(wx.HORIZONTAL)
915       
916        self.text1 = wx.StaticText( self,-1,"" )
917        self.text2 = wx.StaticText( self,-1,"P(Q)*S(Q)" )
918       
919       
920        self.formfactorbox = wx.ComboBox(self, -1,style=wx.CB_READONLY)
921        if self.model!=None:
922            self.formfactorbox.SetValue(self.model.name)
923           
924           
925        self.structurebox = wx.ComboBox(self, -1,style=wx.CB_READONLY)
926        wx.EVT_COMBOBOX(self.formfactorbox,-1, self._on_select_model)
927        wx.EVT_COMBOBOX(self.structurebox,-1, self._on_select_model)
928       
929       
930       
931        ## fill combox box
932        if len(self.model_list_box)>0:
933            self._populate_box( self.formfactorbox,self.model_list_box["Shapes"])
934       
935        if len(self.model_list_box)>0:
936            self._populate_box( self.structurebox,
937                                self.model_list_box["Structure Factors"])
938            self.structurebox.Insert("None", 0,None)
939            self.structurebox.SetSelection(0)
940            self.structurebox.Disable()
941 
942            if self.model.__class__ in self.model_list_box["P(Q)*S(Q)"]:
943                self.structurebox.Enable()
944           
945       
946        ## check model type to show sizer
947        if self.model !=None:
948            self._set_model_sizer_selection( self.model )
949       
950        sizer_selection.Add(self.text1)
951        sizer_selection.Add((5,5))
952        sizer_selection.Add(self.formfactorbox)
953        sizer_selection.Add((5,5))
954        sizer_selection.Add(self.text2)
955        sizer_selection.Add((5,5))
956        sizer_selection.Add(self.structurebox)
957        sizer_selection.Add((5,5))
958       
959        boxsizer1.Add( sizer_radiobutton )
960        boxsizer1.Add( (20,20))
961        boxsizer1.Add( sizer_selection )
962        if object !=None:
963            boxsizer1.Add( (-72,-72))
964            boxsizer1.Add( object,  0, wx.ALIGN_RIGHT| wx.RIGHT, 10)
965            boxsizer1.Add( (60,60))
966        #--------------------------------------------------------
967        sizer.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10)
968        sizer.Layout()
969        self.SetScrollbars(20,20,200,100)
970       
971       
972    def _show_combox(self, event):
973        """
974            Show combox box associate with type of model selected
975        """
976        ## Don't want to populate combo box again if the event comes from check box
977        if self.shape_rbutton.GetValue()and\
978             event.GetEventObject()==self.shape_rbutton:
979            ##fill the combobox with form factor list
980            self.structurebox.SetSelection(0)
981            self.structurebox.Disable()
982            self.formfactorbox.Clear()
983            self._populate_box( self.formfactorbox,self.model_list_box["Shapes"])
984           
985        if self.shape_indep_rbutton.GetValue()and\
986             event.GetEventObject()==self.shape_indep_rbutton:
987            ##fill the combobox with shape independent  factor list
988            self.structurebox.SetSelection(0)
989            self.structurebox.Disable()
990            self.formfactorbox.Clear()
991            self._populate_box( self.formfactorbox,
992                                self.model_list_box["Shape-Independent"])
993           
994        if self.struct_rbutton.GetValue() and\
995             event.GetEventObject()==self.struct_rbutton:
996            ##fill the combobox with structure factor list
997            self.structurebox.SetSelection(0)
998            self.structurebox.Disable()
999            self.formfactorbox.Clear()
1000            self._populate_box( self.formfactorbox,
1001                                self.model_list_box["Structure Factors"])
1002           
1003        if self.plugin_rbutton.GetValue()and\
1004             event.GetEventObject()==self.plugin_rbutton:
1005           
1006            ##fill the combobox with form factor list
1007            self.structurebox.Disable()
1008            self.formfactorbox.Clear()
1009            self._populate_box( self.formfactorbox,
1010                                self.model_list_box["Customized Models"])
1011       
1012        self._on_select_model(event=None)
1013        self.sizer4_4.Layout()
1014        self.sizer4.Layout()
1015        self.Layout()
1016        self.Refresh()
1017        self.SetScrollbars(20,20,200,100)
1018           
1019    def _populate_box(self, combobox, list):
1020        """
1021            fill combox box with dict item
1022            @param list: contains item to fill the combox
1023            item must model class
1024        """
1025        for models in list:
1026            model= models()
1027            name = model.__class__.__name__
1028            if models.__name__!="NoStructure":
1029                if hasattr(model, "name"):
1030                    name = model.name
1031                combobox.Append(name,models)
1032        try:
1033
1034            combobox.SetSelection(0)
1035           
1036        except:
1037            pass
1038   
1039        return 0
1040   
1041   
1042    def _on_select_model_helper(self): 
1043        """
1044             call back for model selection
1045        """
1046        ## reset dictionary containing reference to dispersion
1047        self._disp_obj_dict = {}
1048        self.disp_cb_dict ={}
1049        f_id = self.formfactorbox.GetCurrentSelection()
1050        form_factor = self.formfactorbox.GetClientData( f_id )
1051        if not form_factor in  self.model_list_box["multiplication"]:
1052            self.structurebox.Disable()
1053            self.structurebox.SetSelection(0)
1054        else:
1055            self.structurebox.Enable()
1056           
1057        s_id = self.structurebox.GetCurrentSelection()
1058        struct_factor = self.structurebox.GetClientData( s_id )
1059       
1060        if  struct_factor !=None:
1061            from sans.models.MultiplicationModel import MultiplicationModel
1062            self.model= MultiplicationModel(form_factor(),struct_factor())
1063        else:
1064            self.model= form_factor()
1065       
1066        ## post state to fit panel
1067        self.state.model =self.model
1068        ## post state to fit panel
1069        event = PageInfoEvent(page = self)
1070        wx.PostEvent(self.parent, event)
1071       
1072        self.sizer4_4.Layout()
1073        self.sizer4.Layout()
1074        self.Layout()
1075        self.SetScrollbars(20,20,200,100)
1076        self.Refresh()
1077       
1078       
1079       
1080    def _onparamEnter(self,event):
1081        """
1082            when enter value on panel redraw model according to changed
1083        """
1084        tcrtl= event.GetEventObject()
1085        if check_float(tcrtl):
1086            self._onparamEnter_helper()
1087        else:
1088            msg= "Cannot Plot :Must enter a number!!!  "
1089            wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
1090            return 
1091       
1092       
1093    def _check_value_enter(self, list, modified):
1094        """
1095            @param list: model parameter and panel info
1096            each item of the list should be as follow:
1097            item=[cb state, name, value, "+/-", error of fit, min, max , units]
1098        """ 
1099        is_modified =  modified
1100        if len(list)==0:
1101            return is_modified
1102        for item in list:
1103            try:
1104                name = str(item[1])
1105                if hasattr(self,"text2_3"):
1106                    self.text2_3.Hide()
1107                ## check model parameters range
1108                ## check minimun value
1109                param_min= None
1110                param_max= None
1111                if item[5]!= None:
1112                    if item[5].GetValue().lstrip().rstrip()!="":
1113                        param_min = float(item[5].GetValue())
1114                   
1115                ## check maximum value
1116                if item[6]!= None:
1117                    if item[6].GetValue().lstrip().rstrip()!="":
1118                        param_max = float(item[6].GetValue())
1119                       
1120                from sans.guiframe.utils import check_value
1121                if param_min != None and param_max !=None:
1122                    if not check_value(item[5], item[6]):
1123                        msg= "Wrong Fit range entered for parameter "
1124                        msg+= "name %s of model %s "%(name, self.model.name)
1125                        wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
1126                if name in self.model.details.keys():   
1127                    self.model.details[name][1:]= param_min,param_max
1128               
1129                ## hide statictext +/-   
1130                if item[3]!=None:
1131                    item[3].Hide()
1132                ## hide textcrtl  for error after fit
1133                if item[4]!=None:
1134                    item[4].Clear()
1135                    item[4].Hide()
1136                   
1137           
1138                value= float(item[2].GetValue())
1139               
1140                # If the value of the parameter has changed,
1141                # +update the model and set the is_modified flag
1142                if value != self.model.getParam(name):
1143                    self.model.setParam(name,value)
1144                    is_modified = True   
1145           
1146            except:
1147                msg= "Model Drawing  Error:wrong value entered : %s"% sys.exc_value
1148                wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
1149                return 
1150       
1151        return is_modified
1152       
1153 
1154    def _set_dipers_Param(self, event):
1155        """
1156            Add more item to select user dispersity
1157        """
1158        self._reset_dispersity()
1159       
1160        if self.enable_disp.GetValue():
1161            self.model_disp.Show(True)
1162            self.disp_box.Show(True)
1163            ## layout for model containing no dispersity parameters
1164            if len(self.disp_list)==0:
1165                self._layout_sizer_noDipers() 
1166            else:
1167                ## set gaussian sizer
1168                self._on_select_Disp(event=None)
1169        else:
1170            self.model_disp.Hide()
1171            self.disp_box.Hide()
1172            self.sizer4_4.Clear(True)
1173            self._reset_dispersity()
1174           
1175     
1176        ## post state to fit panel
1177        self.save_current_state()
1178           
1179         
1180           
1181       
1182    def _layout_sizer_noDipers(self):
1183        """
1184            Draw a sizer with no dispersity info
1185        """
1186        ix=0
1187        iy=1
1188        self.fittable_param=[]
1189        self.fixed_param=[]
1190        self.orientation_params_disp=[]
1191       
1192        self.model_disp.Hide()
1193        self.disp_box.Hide()
1194        self.sizer4_4.Clear(True)
1195        model_disp = wx.StaticText(self, -1, 'No PolyDispersity for this model')
1196        self.sizer4_4.Add(model_disp,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1197        self.sizer4_4.Layout()
1198        self.sizer4.Layout()
1199        self.SetScrollbars(20,20,200,100)
1200     
1201           
1202    def _reset_dispersity(self):
1203        """
1204             put gaussian dispersity into current model
1205        """
1206        if len(self.param_toFit)>0:
1207            for item in self.fittable_param:
1208                if item in self.param_toFit:
1209                    self.param_toFit.remove(item)
1210            for item in self.orientation_params_disp:
1211                if item in self.param_toFit:
1212                    self.param_toFit.remove(item)
1213         
1214        self.fittable_param=[]
1215        self.fixed_param=[]
1216        self.orientation_params_disp=[]
1217       
1218        from sans.models.dispersion_models import GaussianDispersion
1219        if len(self.disp_cb_dict)==0:
1220            self.sizer4_4.Clear(True)
1221            self.sizer4_4.Layout()
1222            self.sizer4.Layout()
1223            self.Layout()
1224            self.Refresh()
1225            self.SetScrollbars(20,20,200,100)   
1226            return 
1227       
1228        for p in self.disp_cb_dict:
1229            # The parameter was un-selected. Go back to Gaussian model (with 0 pts)
1230            disp_model = GaussianDispersion()
1231            # Store the object to make it persist outside the scope of this method
1232            #TODO: refactor model to clean this up?
1233            self._disp_obj_dict[p] = disp_model
1234            # Set the new model as the dispersion object for the selected parameter
1235            self.model.set_dispersion(p, disp_model)
1236            # Redraw the model
1237            self._draw_model()
1238           
1239        self.sizer4_4.Layout()
1240        self.sizer4.Layout()
1241        self.Layout()
1242        self.SetScrollbars(20,20,200,100)   
1243        self.Refresh()
1244       
1245           
1246           
1247    def _on_select_Disp(self,event):
1248        """
1249             allow selecting different dispersion
1250             self.disp_list should change type later .now only gaussian
1251        """
1252       
1253        n = self.disp_box.GetCurrentSelection()
1254        dispersity= self.disp_box.GetClientData(n)
1255        name= dispersity.__name__
1256        if name == "GaussianDispersion":
1257            self._set_sizer_gaussian()
1258           
1259        if  name=="ArrayDispersion":
1260            self._set_sizer_arraydispersion()
1261           
1262        self.state.disp_box= n
1263        ## post state to fit panel
1264        event = PageInfoEvent(page = self)
1265        wx.PostEvent(self.parent, event)
1266       
1267        self.sizer4_4.Layout()
1268        self.sizer4.Layout()
1269        self.Layout()
1270        self.SetScrollbars(20,20,200,100)
1271        self.Refresh()
1272       
1273       
1274       
1275       
1276    def _set_sizer_arraydispersion(self):
1277        """
1278            draw sizer with array dispersity  parameters
1279        """
1280        if len(self.param_toFit)>0:
1281            for item in self.fittable_param:
1282                if item in self.param_toFit:
1283                    self.param_toFit.remove(item)
1284            for item in self.orientation_params_disp:
1285                if item in self.param_toFit:
1286                    self.param_toFit.remove(item)
1287        self.fittable_param=[]
1288        self.fixed_param=[]
1289        self.orientation_params_disp=[]
1290        self.sizer4_4.Clear(True) 
1291        ix=0
1292        iy=1     
1293        disp1 = wx.StaticText(self, -1, 'Array Dispersion')
1294        self.sizer4_4.Add(disp1,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1295       
1296        # Look for model parameters to which we can apply an ArrayDispersion model
1297        # Add a check box for each parameter.
1298        self.disp_cb_dict = {}
1299        for p in self.model.dispersion.keys():
1300            ix+=1 
1301            self.disp_cb_dict[p] = wx.CheckBox(self, -1, p, (10, 10))
1302           
1303            wx.EVT_CHECKBOX(self, self.disp_cb_dict[p].GetId(), self.select_disp_angle)
1304            self.sizer4_4.Add(self.disp_cb_dict[p], (iy, ix), (1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
1305       
1306        ix =0
1307        iy +=1 
1308        self.sizer4_4.Add((20,20),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)       
1309        self.sizer4_4.Layout()
1310        self.sizer4.Layout()
1311        self.SetScrollbars(20,20,200,100)
1312       
1313       
1314    def _set_range_sizer(self, title, object1=None,object=None):
1315        """
1316            Fill the
1317        """
1318        self.sizer5.Clear(True)
1319        box_description= wx.StaticBox(self, -1,str(title))
1320        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
1321        #--------------------------------------------------------------
1322        self.qmin    = wx.TextCtrl(self, -1,size=(_BOX_WIDTH,20))
1323        #For qmin and qmax, do not use format_number.(If do, qmin and max could be different from what is in the data.)
1324        #self.qmin.SetValue(format_number(self.qmin_x))
1325        self.qmin.SetValue(str(self.qmin_x))
1326        self.qmin.SetToolTipString("Minimun value of Q in linear scale.")
1327        self.qmin.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
1328        self.qmin.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
1329        self.qmin.Bind(wx.EVT_TEXT_ENTER, self._onparamEnter)
1330     
1331        self.qmax    = wx.TextCtrl(self, -1,size=(_BOX_WIDTH,20))
1332        #For qmin and qmax, do not use format_number.(If do, qmin and max could be different from what is in the data.)
1333        #self.qmax.SetValue(format_number(self.qmax_x))
1334        self.qmax.SetValue(str(self.qmax_x))
1335        self.qmax.SetToolTipString("Maximum value of Q in linear scale.")
1336        self.qmax.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
1337        self.qmax.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
1338        self.qmax.Bind(wx.EVT_TEXT_ENTER, self._onparamEnter)
1339     
1340        sizer_horizontal=wx.BoxSizer(wx.HORIZONTAL)
1341        sizer= wx.GridSizer(3, 3,5, 5)
1342       
1343        sizer.Add((5,5))
1344        sizer.Add(wx.StaticText(self, -1, 'Min'))
1345        sizer.Add(wx.StaticText(self, -1, 'Max'))
1346        sizer.Add(wx.StaticText(self, -1, 'Q range'))
1347             
1348        sizer.Add(self.qmin)
1349        sizer.Add(self.qmax)
1350        sizer_horizontal.Add(sizer)
1351        if object!=None:
1352            sizer_horizontal.Add(object)
1353       
1354        if object1!=None:
1355           boxsizer1.Add(object1) 
1356           boxsizer1.Add((10,10))
1357        boxsizer1.Add(sizer_horizontal)
1358        ## save state
1359        self.save_current_state()
1360        #----------------------------------------------------------------
1361        self.sizer5.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10)
1362        self.sizer5.Layout()
1363        self.Layout()
1364        self.SetScrollbars(20,20,200,100)
1365   
1366   
1367    def _fill_save_sizer(self):
1368        """
1369            Draw the layout for saving option
1370        """
1371        # Skipping save state functionality for release 0.9.0
1372        return
1373   
1374        self.sizer6.Clear(True)
1375        box_description= wx.StaticBox(self, -1,"Save Status")
1376        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
1377        sizer_save = wx.BoxSizer(wx.HORIZONTAL)
1378       
1379        self.btSave_title = wx.StaticText(self, -1, 'Save the current panel status')
1380        self.btSave = wx.Button(self,wx.NewId(),'Save')
1381        self.btSave.Bind(wx.EVT_BUTTON, self.onSave,id= self.btSave.GetId())
1382        self.btSave.SetToolTipString("Save current panel status")
1383       
1384        sizer_save.Add(self.btSave_title) 
1385        sizer_save.Add((20,20),0, wx.LEFT|wx.RIGHT|wx.EXPAND,45) 
1386             
1387        sizer_save.Add(self.btSave)     
1388       
1389        boxsizer1.Add(sizer_save)
1390        self.sizer6.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10)
1391        self.sizer6.Layout()
1392        self.SetScrollbars(20,20,200,100)
1393       
1394       
1395               
Note: See TracBrowser for help on using the repository browser.