source: sasview/src/sans/perspectives/invariant/invariant_panel.py @ da6c9847

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 da6c9847 was 5777106, checked in by Mathieu Doucet <doucetm@…>, 11 years ago

Moving things around. Will definitely not build.

  • Property mode set to 100644
File size: 79.4 KB
Line 
1"""
2This module provide GUI for the neutron scattering length density calculator
3
4"""
5import copy
6import time
7import sys
8import os
9import wx
10from wx.lib.scrolledpanel import ScrolledPanel
11from sans.invariant import invariant
12from sans.guiframe.utils import format_number
13from sans.guiframe.utils import check_float
14from sans.guiframe.events import StatusEvent
15from sans.guiframe.events import AppendBookmarkEvent
16from .invariant_details import InvariantDetailsPanel
17from .invariant_details import InvariantContainer
18from .invariant_widgets import OutputTextCtrl
19from .invariant_widgets import InvTextCtrl
20from .invariant_state import InvariantState as IState
21from sans.guiframe.panel_base import PanelBase
22# The minimum q-value to be used when extrapolating
23Q_MINIMUM  = 1e-5
24# The maximum q-value to be used when extrapolating
25Q_MAXIMUM  = 10
26# the ratio of maximum q value/(qmax of data) to plot the theory data
27Q_MAXIMUM_PLOT = 3
28# the number of points to consider during fit
29NPTS = 10
30#Default value for background
31BACKGROUND = 0.0
32#default value for the scale
33SCALE = 1.0
34#default value of the contrast
35CONTRAST = 1.0
36#default value of the power used for power law
37POWER = 4.0
38#Invariant panel size
39_BOX_WIDTH = 76
40
41
42if sys.platform.count("win32") > 0:
43    _STATICBOX_WIDTH = 450
44    PANEL_WIDTH = 500 
45    PANEL_HEIGHT = 700
46    FONT_VARIANT = 0
47else:
48    _STATICBOX_WIDTH = 490
49    PANEL_WIDTH = 530
50    PANEL_HEIGHT = 700
51    FONT_VARIANT = 1
52
53
54class InvariantPanel(ScrolledPanel, PanelBase):
55    """
56    Provides the Invariant GUI.
57    """
58    ## Internal nickname for the window, used by the AUI manager
59    window_name = "Invariant"
60    ## Name to appear on the window title bar
61    window_caption = "Invariant"
62    ## Flag to tell the AUI manager to put this panel in the center pane
63    CENTER_PANE = True
64    def __init__(self, parent, data=None, manager=None, *args, **kwds):
65        kwds["size"] = (PANEL_WIDTH, PANEL_HEIGHT)
66        kwds["style"] = wx.FULL_REPAINT_ON_RESIZE
67        ScrolledPanel.__init__(self, parent=parent, *args, **kwds)
68        PanelBase.__init__(self, parent)
69        self.SetupScrolling()
70        #Font size
71        self.SetWindowVariant(variant=FONT_VARIANT)
72        #Object that receive status event
73        self.parent = parent.parent
74        #plug-in using this panel
75        self._manager = manager
76        #Data uses for computation
77        self._data = data
78        self._scale = SCALE
79        self._background = BACKGROUND
80        self._bmark = None
81        self.bookmark_num = 0
82        self.state = None
83        self.popUpMenu = None
84        self._set_bookmark_menu()
85        #Init state
86        self.set_state()
87        # default flags for state
88        self.new_state = False
89        self.is_state_data = False
90        self.is_power_out = False
91
92        #container of invariant value
93        self.inv_container = None
94        #sizers
95        self.main_sizer = None
96        self.outputs_sizer = None
97        self.data_name_boxsizer = None
98        self.hint_msg_sizer = None
99        self.data_name_sizer = None
100        self.data_range_sizer = None
101        self.sizer_input = None
102        self.inputs_sizer = None
103        self.extrapolation_sizer = None
104        self.extrapolation_range_sizer = None
105        self.extrapolation_low_high_sizer = None
106        self.low_extrapolation_sizer = None
107        self.low_q_sizer = None
108        self.high_extrapolation_sizer = None
109        self.high_q_sizer = None
110        self.volume_surface_sizer = None
111        self.invariant_sizer = None
112        self.button_sizer = None
113        self.save_button_sizer = None
114        self.hint_msg_txt = None
115        self.data_name_tcl = None
116        self.data_min_tcl = None
117        self.data_max_tcl = None
118        #Draw the panel
119        self._do_layout()
120        self.reset_panel()
121        self._reset_state_list()
122        ## Default file location for save
123        self._default_save_location = os.getcwd()       
124        if self.parent is not None:
125            msg = ""
126            wx.PostEvent(self.parent, StatusEvent(status=msg, info="info"))
127            self._default_save_location = \
128                        self.parent.get_save_location()
129       
130        self._set_bookmark_flag(False)
131   
132    def get_data(self):
133        """
134        """
135        return self._manager.get_data()
136   
137    def get_state(self):
138        """
139        """
140        return self.state
141   
142    def set_data(self, data):
143        """
144        Set the data
145        """
146        self._data = data
147        #edit the panel
148        if self._data is not None:
149            self._delete_bookmark_items()
150            self.get_state_by_num(0)
151            data_name = self._data.name
152            data_qmin = min (self._data.x)
153            data_qmax = max (self._data.x)
154            self.data_name_tcl.SetValue(str(data_name))
155            self.data_min_tcl.SetValue(str(data_qmin))
156            self.data_max_tcl.SetValue(str(data_qmax))
157            self.reset_panel()
158            self.compute_invariant(event=None)
159            self.state.file = self._data.name
160            #Reset the list of states
161            self.state.data = copy.deepcopy(data)
162            self._set_save_flag(True)
163            self._set_preview_flag(False)
164            self._reset_state_list()
165            self._set_bookmark_flag(True)
166        return True 
167   
168    def _delete_bookmark_items(self):
169        """
170        Delete bookmark menu items
171        """
172        # delete toolbar menu
173        self.parent.reset_bookmark_menu(self)
174        self.parent._update_toolbar_helper()
175        # delete popUpMenu items
176        pos = 0
177        for item in self.popUpMenu.GetMenuItems():
178            pos += 1
179            if pos < 3:
180                continue
181            self.popUpMenu.DestroyItem(item)
182               
183    def set_message(self):
184        """
185        Display warning message if available
186        """
187        if self.inv_container is not None:
188            if self.inv_container.existing_warning:
189                msg = "Warning! Computations on invariant require your "
190                msg += "attention.\nPlease click on Details button."
191                self.hint_msg_txt.SetForegroundColour("red")
192   
193                wx.PostEvent(self.parent,
194                             StatusEvent(status=msg,info="warning"))
195            else:
196                msg = "For more information, click on Details button."
197                self.hint_msg_txt.SetForegroundColour("black")
198                wx.PostEvent(self.parent,
199                             StatusEvent(status=msg,info="info"))
200            self.hint_msg_txt.SetLabel(msg)
201        self.Layout()
202       
203    def set_manager(self, manager):
204        """
205        set value for the manager
206        """
207        self._manager = manager
208       
209    def save_project(self, doc=None):
210        """
211        return an xml node containing state of the panel
212         that guiframe can write to file
213        """
214        data = self.get_data()
215        state = self.get_state()
216        if data is not None:
217            new_doc = self._manager.state_reader.write_toXML(data, state)
218            if new_doc is not None:
219                if doc is not None and hasattr(doc, "firstChild"):
220                    child = new_doc.firstChild.firstChild
221                    doc.firstChild.appendChild(child) 
222                else:
223                    doc = new_doc
224        return doc   
225
226    def set_state(self, state=None, data=None):
227        """
228        set state when loading it from a .inv/.svs file
229        """
230       
231        if state == None and data == None:
232            self.state = IState()
233        elif state == None or data == None: 
234            return
235        else:
236            new_state = copy.deepcopy(state)
237            self.new_state = True
238            if not self.set_data(data):
239                return
240
241            self.state = new_state
242            self.state.file = data.name   
243
244            num = self.state.saved_state['state_num']
245            if num > 0 :
246                self._set_undo_flag(True)
247            if num < len(state.state_list) - 1:
248                self._set_redo_flag(True)
249               
250            # get bookmarks
251            self.bookmark_num = len(self.state.bookmark_list)
252            total_bookmark_num = self.bookmark_num + 1
253
254            for ind in range(1, total_bookmark_num):
255                #bookmark_num = ind
256                value = self.state.bookmark_list[ind]
257                name = "%d] bookmarked at %s on %s"% (ind, value[0], value[1])
258                # append it to menu
259                id = wx.NewId()
260                self.popUpMenu.Append(id, name, str(''))
261                wx.EVT_MENU(self, id, self._back_to_bookmark) 
262                wx.PostEvent(self.parent, AppendBookmarkEvent(title=name, 
263                                          hint='', 
264                                          handler=self._back_to_bookmark))
265
266            self.get_state_by_num(state_num=str(num))
267           
268            self._get_input_list() 
269            #make sure that the data is reset (especially
270            # when loaded from a inv file)
271            self.state.data = self._data
272            self._set_preview_flag(False)
273            self.new_state = False 
274            self.is_state_data = False
275
276    def clear_panel(self):
277        """
278        Clear panel to defaults, used by set_state of manager
279        """
280       
281        self._data = None
282        # default data testctrl
283        self.hint_msg_txt.SetLabel('')
284        data_name = ''
285        data_qmin = ''
286        data_qmax = ''
287        self.data_name_tcl.SetValue(str(data_name))
288        self.data_min_tcl.SetValue(str(data_qmin))
289        self.data_max_tcl.SetValue(str(data_qmax))
290        #reset output textctrl
291        self._reset_output()
292        #reset panel
293        self.reset_panel()
294        #reset state w/o data
295        self.set_state()
296        # default flags for state
297        self.new_state = False
298        self.is_state_data = False
299        self.is_power_out = False
300
301    def get_background(self):
302        """
303        return the background textcrtl value as a float
304        """
305        background = self.background_tcl.GetValue().lstrip().rstrip()
306        if background == "":
307            raise ValueError, "Need a background"
308        if check_float(self.background_tcl):
309            return float(background)
310        else:
311            msg = "Receive invalid value for background : %s" % (background)
312            raise ValueError, msg
313   
314    def get_scale(self):
315        """
316        return the scale textcrtl value as a float
317        """
318        scale = self.scale_tcl.GetValue().lstrip().rstrip()
319        if scale == "":
320            raise ValueError, "Need a background"
321        if check_float(self.scale_tcl):
322            if float(scale) <= 0.0:
323                self.scale_tcl.SetBackgroundColour("pink")
324                self.scale_tcl.Refresh()
325                msg = "Receive invalid value for scale: %s" % (scale)
326                raise ValueError, msg
327            return float(scale)
328        else:
329            raise ValueError, "Receive invalid value for scale : %s" % (scale)
330       
331    def get_contrast(self):
332        """
333        return the contrast textcrtl value as a float
334        """
335        par_str = self.contrast_tcl.GetValue().strip()
336        contrast = None
337        if par_str !=" " and check_float(self.contrast_tcl):
338            contrast = float(par_str)
339        return contrast
340   
341    def get_extrapolation_type(self, low_q, high_q):
342        """
343        get extrapolation type
344        """
345        extrapolation = None
346        if low_q  and not high_q:
347            extrapolation = "low"
348        elif not low_q  and high_q:
349            extrapolation = "high"
350        elif low_q and high_q:
351            extrapolation = "both"
352        return extrapolation
353           
354    def get_porod_const(self):
355        """
356        return the porod constant textcrtl value as a float
357        """
358        par_str = self.porod_constant_tcl.GetValue().strip()
359        porod_const = None
360        if par_str != "" and check_float(self.porod_constant_tcl):
361            porod_const = float(par_str)
362        return porod_const
363   
364    def get_volume(self, inv, contrast, extrapolation):
365        """
366        get volume fraction
367        """
368        if contrast is not None:
369            try:
370                v, dv = inv.get_volume_fraction_with_error(contrast=contrast, 
371                                                extrapolation=extrapolation)
372                self.volume_tcl.SetValue(format_number(v))
373                self.volume_err_tcl.SetValue(format_number(dv))
374            except:
375                self.volume_tcl.SetValue(format_number(None))
376                self.volume_err_tcl.SetValue(format_number(None))
377                msg = "Error occurred computing volume "
378                msg += " fraction: %s" % sys.exc_value
379                wx.PostEvent(self.parent, StatusEvent(status=msg,
380                                                      info="error",
381                                                      type="stop"))
382               
383    def get_surface(self, inv, contrast, porod_const, extrapolation):
384        """
385        get surface value
386        """
387        if contrast is not None and porod_const is not None:
388            try:
389                s, ds = inv.get_surface_with_error(contrast=contrast,
390                                        porod_const=porod_const,
391                                        extrapolation=extrapolation)
392                self.surface_tcl.SetValue(format_number(s))
393                self.surface_err_tcl.SetValue(format_number(ds))
394            except:
395                self.surface_tcl.SetValue(format_number(None))
396                self.surface_err_tcl.SetValue(format_number(None))
397                msg = "Error occurred computing "
398                msg += "specific surface: %s" % sys.exc_value
399                wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
400                                                       type="stop"))
401               
402    def get_total_qstar(self, inv, extrapolation):
403        """
404        get total qstar
405        """
406        try:
407            qstar_total, qstar_total_err = \
408                                    inv.get_qstar_with_error(extrapolation)
409            self.invariant_total_tcl.SetValue(format_number(qstar_total))
410            self.invariant_total_err_tcl.SetValue(\
411                                    format_number(qstar_total_err))
412            self.inv_container.qstar_total = qstar_total
413            self.inv_container.qstar_total_err = qstar_total_err
414        except:
415            self.inv_container.qstar_total = "Error"
416            self.inv_container.qstar_total_err = "Error"
417            self.invariant_total_tcl.SetValue(format_number(None))
418            self.invariant_total_err_tcl.SetValue(format_number(None))
419            msg = "Error occurred computing invariant using"
420            msg += " extrapolation: %s" % sys.exc_value
421            wx.PostEvent(self.parent, StatusEvent(status= msg, type="stop")) 
422           
423    def get_low_qstar(self, inv, npts_low, low_q=False):
424        """
425        get low qstar
426        """
427        if low_q:
428            try: 
429                qstar_low, qstar_low_err = inv.get_qstar_low()
430                self.inv_container.qstar_low = qstar_low
431                self.inv_container.qstar_low_err = qstar_low_err
432                extrapolated_data = inv.get_extra_data_low(npts_in=npts_low) 
433                power_low = inv.get_extrapolation_power(range='low') 
434                if self.power_law_low.GetValue():
435                    self.power_low_tcl.SetValue(format_number(power_low))
436                self._manager.plot_theory(data=extrapolated_data,
437                                           name="Low-Q extrapolation")
438            except:
439                self.inv_container.qstar_low = "ERROR"
440                self.inv_container.qstar_low_err = "ERROR"
441                self._manager.plot_theory(name="Low-Q extrapolation")
442                msg = "Error occurred computing low-Q "
443                msg += "invariant: %s" % sys.exc_value
444                wx.PostEvent(self.parent,
445                             StatusEvent(status=msg, type="stop"))
446                raise
447        else:
448            try:
449                self._manager.plot_theory(name="Low-Q extrapolation")
450            except: 
451                pass
452           
453    def get_high_qstar(self, inv, high_q=False):
454        """
455        get high qstar
456        """
457        if high_q:
458            try: 
459                qmax_plot = Q_MAXIMUM_PLOT * max(self._data.x)
460                if qmax_plot > Q_MAXIMUM: 
461                    qmax_plot = Q_MAXIMUM
462                qstar_high, qstar_high_err = inv.get_qstar_high()
463                self.inv_container.qstar_high = qstar_high
464                self.inv_container.qstar_high_err = qstar_high_err
465                power_high = inv.get_extrapolation_power(range='high') 
466                self.power_high_tcl.SetValue(format_number(power_high))
467                high_out_data = inv.get_extra_data_high(q_end=qmax_plot,
468                                                        npts=500)
469                self._manager.plot_theory(data=high_out_data,
470                                           name="High-Q extrapolation")
471            except:
472                #raise
473                self.inv_container.qstar_high = "ERROR"
474                self.inv_container.qstar_high_err = "ERROR"
475                self._manager.plot_theory(name="High-Q extrapolation")
476                msg = "Error occurred computing high-Q "
477                msg += "invariant: %s" % sys.exc_value
478                wx.PostEvent(self.parent, StatusEvent(status=msg,
479                                                      type="stop"))
480                raise
481        else:
482            try:
483                self._manager.plot_theory(name="High-Q extrapolation")
484            except: 
485                pass
486
487    def get_qstar(self, inv):
488        """
489        get qstar
490        """
491        qstar, qstar_err = inv.get_qstar_with_error()
492        self.inv_container.qstar = qstar
493        self.inv_container.qstar_err = qstar_err
494             
495    def set_extrapolation_low(self, inv, low_q=False):
496        """
497        return float value necessary to compute invariant a low q
498        """
499        #get funtion
500        if self.guinier.GetValue():
501            function_low = "guinier"
502        # get the function
503        power_low = None #2.0/3.0
504        if self.power_law_low.GetValue():
505            function_low = "power_law"
506            if self.fit_enable_low.GetValue():
507                #set value of power_low to none to allow fitting
508                power_low = None
509            else:
510                power_low = self.power_low_tcl.GetValue().lstrip().rstrip()
511                if check_float(self.power_low_tcl):
512                    power_low = float(power_low)
513                else:
514                    if low_q :
515                        #Raise error only when qstar at low q is requested
516                        msg = "Expect float for power at low q, "
517                        msg += " got %s" % (power_low)
518                        wx.PostEvent(self.parent, StatusEvent(status=msg, 
519                                                  info="error",
520                                                  type="stop"))
521       
522        #Get the number of points to extrapolated
523        npts_low = self.npts_low_tcl.GetValue().lstrip().rstrip()   
524        if check_float(self.npts_low_tcl):
525            npts_low = float(npts_low)
526        else:
527            if low_q:
528                msg = "Expect float for number of points at low q,"
529                msg += " got %s" % (npts_low)
530                wx.PostEvent(self.parent, StatusEvent(status=msg, 
531                                                  info="error",
532                                                  type="stop"))
533        #Set the invariant calculator
534        inv.set_extrapolation(range="low", npts=npts_low,
535                                   function=function_low, power=power_low)   
536        return inv, npts_low 
537   
538
539    def set_extrapolation_high(self, inv, high_q=False):
540        """
541        return float value necessary to compute invariant a high q
542        """
543        power_high = None
544        #if self.power_law_high.GetValue():
545        function_high = "power_law"
546        if self.fit_enable_high.GetValue():
547            #set value of power_high to none to allow fitting
548            power_high = None
549        else:
550            power_high = self.power_high_tcl.GetValue().lstrip().rstrip()
551            if check_float(self.power_high_tcl):
552                power_high = float(power_high)
553            else:
554                if high_q:
555                    #Raise error only when qstar at high q is requested
556                    msg = "Expect float for power at high q,"
557                    msg += " got %s" % (power_high)
558                    wx.PostEvent(self.parent, StatusEvent(status=msg, 
559                                                  info="error",
560                                                  type="stop"))
561                         
562        npts_high = self.npts_high_tcl.GetValue().lstrip().rstrip()   
563        if check_float(self.npts_high_tcl):
564            npts_high = float(npts_high)
565        else:
566            if high_q:
567                msg = "Expect float for number of points at high q,"
568                msg += " got %s" % (npts_high)
569                wx.PostEvent(self.parent, StatusEvent(status=msg, 
570                                                  info="error",
571                                                  type="stop"))
572        inv.set_extrapolation(range="high", npts=npts_high,
573                                   function=function_high, power=power_high)
574        return inv, npts_high
575   
576    def display_details(self, event):
577        """
578        open another panel for more details on invariant calculation
579        """
580        panel = InvariantDetailsPanel(parent=self, 
581                                           qstar_container=self.inv_container)
582        panel.ShowModal()
583        panel.Destroy()
584        self.button_calculate.SetFocus()
585       
586    def compute_invariant(self, event=None):
587        """
588        compute invariant
589        """
590        if self._data == None:
591            msg = "\n\nData must be loaded first in order"
592            msg += " to perform a compution..."
593            wx.PostEvent(self.parent, StatusEvent(status=msg))
594        # set a state for this computation for saving
595        elif event != None: 
596            self._set_compute_state(state='compute')
597            self._set_bookmark_flag(True)
598            msg = "\n\nStarting a new invariant computation..."           
599            wx.PostEvent(self.parent, StatusEvent(status=msg))
600           
601
602        if self._data is None:
603            return
604        self.button_details.Enable()
605        #clear outputs textctrl
606        self._reset_output()
607        try:
608            background = self.get_background()
609            scale = self.get_scale()
610        except:
611            msg = "Invariant Error: %s" % (sys.exc_value)
612            wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
613            return
614       
615        low_q = self.enable_low_cbox.GetValue()
616        high_q = self.enable_high_cbox.GetValue() 
617        temp_data = copy.deepcopy(self._data)
618       
619        #set invariant calculator
620        inv = invariant.InvariantCalculator(data=temp_data,
621                                            background=background,
622                                            scale=scale)
623        try:
624            inv, npts_low = self.set_extrapolation_low(inv=inv, low_q=low_q)
625            inv, npts_high = self.set_extrapolation_high(inv=inv, high_q=high_q)
626        except:
627            msg = "Error occurred computing invariant: %s" % sys.exc_value
628            wx.PostEvent(self.parent, StatusEvent(status=msg,
629                                                 info="warning", type="stop"))
630            return
631        #check the type of extrapolation
632        extrapolation = self.get_extrapolation_type(low_q=low_q, high_q=high_q)
633       
634        #Compute invariant
635        bkg_changed = False
636        scale_changed = False
637        try:
638            self.get_qstar(inv=inv)
639            #if scale_changed or bkg_changed:
640            #self._manager.plot_data(data=inv.get_data())
641           
642        except:
643            msg= "Error occurred computing invariant: %s" % sys.exc_value
644            wx.PostEvent(self.parent, StatusEvent(status=msg, 
645                                                  info="warning",
646                                                  type="stop"))
647            return
648        #self.Show(False)
649        r_msg = ''
650        try:
651            r_msg = 'Low Q: '
652            #Compute qstar extrapolated to low q range
653            self.get_low_qstar(inv=inv, npts_low=npts_low, low_q=low_q)
654            r_msg = 'High Q: '
655            #Compute qstar extrapolated to high q range
656            self.get_high_qstar(inv=inv, high_q=high_q)
657            r_msg = ''
658            #Compute qstar extrapolated to total q range
659            #and set value to txtcrtl
660            self.get_total_qstar(inv=inv, extrapolation=extrapolation)
661            # Parse additional parameters
662            porod_const = self.get_porod_const()       
663            contrast = self.get_contrast()
664        except:
665            msg = r_msg + "Error occurred computing invariant: %s" % \
666                                                            sys.exc_value
667            wx.PostEvent(self.parent, StatusEvent(status=msg, 
668                                                  info="error",
669                                                  type="stop"))
670        try:
671            #Compute volume and set value to txtcrtl
672            self.get_volume(inv=inv, contrast=contrast,
673                            extrapolation=extrapolation)
674            #compute surface and set value to txtcrtl
675        except:
676            msg = "Error occurred computing invariant: %s" % sys.exc_value
677            wx.PostEvent(self.parent, StatusEvent(status=msg,
678                                                  info="warning",
679                                                  type="stop"))
680        try:
681            self.get_surface(inv=inv, contrast=contrast,
682                                    porod_const=porod_const, 
683                                    extrapolation=extrapolation)
684           
685        except:
686            msg = "Error occurred computing invariant: %s" % sys.exc_value
687            wx.PostEvent(self.parent, StatusEvent(status=msg,
688                                                  info="warning",
689                                                  type="stop"))
690           
691        #compute percentage of each invariant
692        self.inv_container.compute_percentage()
693       
694        #display a message
695        self.set_message()
696
697        # reset power_out to default to get ready for another '_on_text'
698        if self.is_power_out == True:
699            self.state.container = copy.deepcopy(self.inv_container)
700            self.state.timestamp = self._get_time_stamp()
701            msg = self.state.__str__()
702            self.state.set_report_string()
703            self.is_power_out = False
704            wx.PostEvent(self.parent, StatusEvent(status = msg ))
705
706        #enable the button_ok for more details
707        self._set_preview_flag(True)
708       
709        if event != None: 
710            self._set_preview_flag(True)
711            self._set_save_flag(True)
712            wx.PostEvent(self.parent,
713                StatusEvent(status='\nFinished invariant computation...'))
714        #self.Show(True)
715        self.Refresh()
716           
717    def on_undo(self, event=None):
718        """
719        Go back to the previous state
720       
721        : param event: undo button event
722        """
723        if self.state.state_num < 0:
724            return
725        self.is_power_out = True
726        # get the previous state_num
727        pre_state_num = int(self.state.saved_state['state_num']) - 1
728
729        self.get_state_by_num(state_num=str(pre_state_num))
730       
731        if float(pre_state_num) <= 0:
732            self._set_undo_flag(False)
733        else:
734            self._set_undo_flag(True)
735        self._set_redo_flag(True)
736        self.is_power_out = False 
737        self._info_state_num()
738
739       
740    def on_redo(self, event=None):
741        """
742        Go forward to the previous state
743       
744        : param event: redo button event
745        """
746        self.is_power_out = True
747        # get the next state_num
748        next_state_num = int(self.state.saved_state['state_num']) + 1
749
750        self.get_state_by_num(state_num=str(next_state_num))
751       
752        if float(next_state_num)+2 > len(self.state.state_list):
753            self._set_redo_flag(False)
754        else:
755            self._set_redo_flag(True)
756   
757        self._set_undo_flag(True)
758        self.is_power_out = False
759        self._info_state_num()
760       
761    def on_preview(self, event=None):
762        """
763        Invoke report dialog panel
764       
765        : param event: report button event
766        """
767        from .report_dialog import ReportDialog
768
769        self.state.set_report_string()
770        report_html_str = self.state.report_str
771        report_text_str = self.state.__str__()
772        report_img = self.state.image
773        report_list = [report_html_str, report_text_str, report_img]
774        dialog = ReportDialog(report_list, None, -1, "")
775        dialog.ShowModal()
776       
777    def get_state_by_num(self, state_num=None):
778        """
779        Get the state given by number
780       
781        : param state_num: the given state number
782        """     
783        if state_num == None:
784            return
785
786        backup_state_list = copy.deepcopy(self.state.state_list)
787       
788        # get the previous state
789        try:
790            current_state = copy.deepcopy(self.state.state_list[str(state_num)])
791            # get the previously computed state number
792            #(computation before the state changes happened)
793            current_compute_num = str(current_state['compute_num'])
794        except :
795            raise
796            #raise ValueError,  "No such state exists in history"
797       
798        # get the state at pre_compute_num
799        comp_state = copy.deepcopy(self.state.state_list[current_compute_num])
800
801        # set the parameters
802        for key in comp_state:
803            value = comp_state[key]
804            try:
805                exec "self.%s.SetValue(str(%s))" % (key, value)
806            except TypeError:
807                exec "self.%s.SetValue(%s)" % (key, value)
808            except:
809                pass
810       
811        self.compute_invariant(event=None)
812       
813        # set the input params at the state at pre_state_num
814        for key in current_state:
815            # set the inputs and boxes
816            value = current_state[key]
817            try:
818                exec 'self.%s.SetValue(str(%s))' % (key, value)
819            except TypeError:
820                exec 'self.%s.SetValue(%s)' % (key, value)
821            except:
822                pass
823
824        self._enable_high_q_section(event=None)
825        self._enable_low_q_section(event=None)
826        self.state.state_list = backup_state_list
827        self.state.saved_state = current_state
828        self.state.state_num = state_num
829
830       
831    def get_bookmark_by_num(self, num=None):
832        """
833        Get the bookmark state given by number
834       
835        : param num: the given bookmark number
836       
837        """
838        current_state = {}
839        comp_state = {}
840        backup_state_list = copy.deepcopy(self.state.state_list)
841
842        # get the previous state
843        try:
844            _, _, current_state,comp_state = self.state.bookmark_list[int(num)] 
845        except :
846            raise ValueError,  "No such bookmark exists"
847
848        # set the parameters
849        for key in comp_state:
850            value = comp_state[key]
851            try:
852                exec "self.%s.SetValue(str(%s))" % (key, value)
853            except TypeError:
854                exec "self.%s.SetValue(%s)" % (key, value)
855            except:
856                pass
857
858        self.compute_invariant(event=None)
859        # set the input params at the state of pre_state_num
860        for key in current_state:
861            value = current_state[key]
862            try:
863                exec 'self.%s.SetValue(str(%s))' % (key, value)
864            except TypeError:
865                exec 'self.%s.SetValue(%s)' % (key, value)
866            except:
867                pass
868        self.state.saved_state = copy.deepcopy(current_state)
869       
870        self._enable_high_q_section(event=None)
871        self._enable_low_q_section(event=None)
872        self.state.state_list = backup_state_list
873        #self.state.saved_state = current_state
874        #self.state.state_num = state_num
875
876    def reset_panel(self):
877        """
878        set the panel at its initial state.
879        """
880        self.background_tcl.SetValue(str(BACKGROUND))
881        self.scale_tcl.SetValue(str(SCALE)) 
882        self.contrast_tcl.SetValue(str(CONTRAST))
883        self.porod_constant_tcl.SetValue('') 
884        self.npts_low_tcl.SetValue(str(NPTS))
885        self.enable_low_cbox.SetValue(False)
886        self.fix_enable_low.SetValue(True)
887        self.power_low_tcl.SetValue(str(POWER))
888        self.guinier.SetValue(True)
889        self.power_low_tcl.Disable()
890        self.enable_high_cbox.SetValue(False)
891        self.fix_enable_high.SetValue(True)
892        self.power_high_tcl.SetValue(str(POWER))
893        self.npts_high_tcl.SetValue(str(NPTS))
894        self.button_details.Disable()
895        #Change the state of txtcrtl to enable/disable
896        self._enable_low_q_section()
897        #Change the state of txtcrtl to enable/disable
898        self._enable_high_q_section()
899        self._reset_output()
900        self._set_undo_flag(False)
901        self._set_redo_flag(False)
902        self._set_bookmark_flag(False)
903        self._set_preview_flag(False)
904        self._set_save_flag(False)
905        self.button_calculate.SetFocus()
906        #self.SetupScrolling()
907       
908    def _set_state(self, event):
909        """
910        Set the state list
911       
912        :param event: rb/cb event
913        """
914        if event == None:
915            return
916        obj = event.GetEventObject()
917        name = str(obj.GetName())
918        value = str(obj.GetValue())
919        rb_list = [['power_law_low', 'guinier'],
920                   ['fit_enable_low', 'fix_enable_low'],
921                   ['fit_enable_high', 'fix_enable_high']]
922
923        try:
924            if value == None or value.lstrip().rstrip() =='':
925                value = 'None'
926            exec 'self.state.%s = %s' % (name, value)
927            exec "self.state.saved_state['%s'] = %s" %  (name, value)
928           
929            # set the count part of radio button clicked
930            #False for the saved_state
931            for title, content in rb_list:
932                if name ==  title:
933                    name = content
934                    value = False     
935                elif name == content:
936                    name = title
937                    value = False 
938            exec "self.state.saved_state['%s'] = %s" %  (name, value)     
939           
940            # Instead of changing the future, create a new future.
941            max_state_num = len(self.state.state_list) - 1   
942            self.state.saved_state['state_num'] = max_state_num   
943           
944            self.state.saved_state['state_num'] += 1
945            self.state.state_num = self.state.saved_state['state_num']
946            self.state.state_list[str(self.state.state_num)] = \
947                    self.state.clone_state()
948        except:           
949            pass
950       
951        self._set_undo_flag(True)
952        self._set_redo_flag(False)
953        #event.Skip()
954                   
955    def _set_compute_state(self, state=None):
956        """
957        Notify the compute_invariant state to self.state
958       
959        : param state: set 'compute' when the computation is
960        activated by the 'compute' button, else None
961       
962        """
963        # reset the default
964        if state != 'compute':
965            self.new_state = False
966            self.is_power_out = False
967        else:
968            self.is_power_out = True
969        # Instead of changing the future, create a new future.
970        max_state_num = len(self.state.state_list) - 1   
971        self.state.saved_state['state_num'] = max_state_num       
972        # A new computation is also A state
973        #copy.deepcopy(self.state.saved_state)
974        temp_saved_states = self.state.clone_state()
975        temp_saved_states['state_num'] += 1
976        self.state.state_num = temp_saved_states['state_num']
977
978               
979        # set the state number of the computation
980        if state == 'compute':
981            temp_saved_states['compute_num'] = self.state.state_num
982        self.state.saved_state = copy.deepcopy(temp_saved_states)
983        #copy.deepcopy(self.state.saved_state)
984        self.state.state_list[str(self.state.state_num)] = \
985                                        self.state.clone_state()
986       
987        # A computation is a new state, so delete the states with any higher
988        # state numbers
989        for i in range(self.state.state_num+1, len(self.state.state_list)):
990            try:
991                del (self.state.state_list[str(i)])
992            except: 
993                pass
994        # Enable the undo button if it was not
995        self._set_undo_flag(True)
996        self._set_redo_flag(False)
997       
998    def _reset_state_list(self, data=None):
999        """
1000        Reset the state_list just before data was loading:
1001        Used in 'set_current_data()'
1002        """
1003        #if data == None: return
1004        #temp_state = self.state.clone_state()
1005        #copy.deepcopy(self.state.saved_state)
1006        # Clear the list
1007        self.state.state_list.clear()
1008        self.state.bookmark_list.clear()
1009        # Set defaults
1010        self.state.saved_state['state_num'] = 0
1011        self.state.saved_state['compute_num'] = 0
1012        if self._data != None:
1013            self.state.saved_state['file'] = str(self._data.name)
1014        else:
1015            self.state.saved_state['file'] = 'None'
1016        self.state.file = self.state.saved_state['file']
1017
1018        self.state.state_num = self.state.saved_state['state_num']
1019        self.state.timestamp = "('00:00:00', '00/00/0000')"
1020
1021        # Put only the current state in the list
1022        #copy.deepcopy(self.state.saved_state)
1023        self.state.state_list[str(self.state.state_num)] = \
1024                                                self.state.clone_state()
1025        self._set_undo_flag(False)
1026        self._set_redo_flag(False)
1027        self._set_bookmark_flag(False)
1028        self._set_preview_flag(False)
1029        self._set_save_flag(False)
1030
1031       
1032    def _on_text(self, event):
1033        """
1034        Catch text change event to add the state to the state_list
1035       
1036        :param event: txtctr event ; assumes not None
1037       
1038        """
1039        if self._data == None: 
1040            return
1041        # check if this event is from do/undo button
1042        if self.state.saved_state['is_time_machine'] or self.new_state:
1043            #event.Skip()
1044            return
1045       
1046        # get the object
1047        obj = event.GetEventObject()
1048        name = str(obj.GetName())
1049        value = str(obj.GetValue())
1050        state_num = self.state.saved_state['state_num']
1051
1052        # text event is a new state, so delete the states with higher state_num
1053        # i.e., change the future
1054        for i in range(int(state_num)+1, len(self.state.state_list)):
1055            try:
1056                del (self.state.state_list[str(i)])
1057            except: 
1058                pass
1059       
1060        # Instead of changing the future, create a new future.
1061        #max_state_num = len(self.state.state_list)-1   
1062        #self.state.saved_state['state_num'] = max_state_num
1063
1064        # try to add new state of the text changes in the state_list
1065        try:
1066            if value.strip() == None: 
1067                value = ''
1068            exec "self.state.%s = '%s'" % (name, value)
1069            exec "self.state.saved_state['%s'] = '%s'" %  (name, value)
1070            exec "self.state.input_list['%s'] = '%s'" % (name, value)
1071            if not self.is_power_out:
1072                if name != 'power_low_tcl' and name != 'power_high_tcl':
1073                    self.state.saved_state['state_num'] += 1
1074            self.state.state_num = self.state.saved_state['state_num']
1075            #copy.deepcopy(self.state.saved_state)
1076            self.state.state_list[str(self.state.state_num)] = \
1077                                        self.state.clone_state()
1078        except:
1079            pass
1080
1081        #event.Skip()
1082        self._set_undo_flag(True)
1083        self._set_redo_flag(False)
1084        self._set_bookmark_flag(True)
1085        self._set_preview_flag(False)
1086       
1087    def _on_out_text(self, event):     
1088        """
1089        Catch ouput text change to add the state
1090       
1091        :param event: txtctr event ; assumes not None
1092       
1093        """   
1094        # get the object
1095        obj = event.GetEventObject()
1096        name = str(obj.GetName())
1097        value = str(obj.GetValue())
1098        try:
1099            exec "self.state.saved_state['%s'] = '%s'" %  (name, value)
1100            self.state.state_list[str(self.state.state_num)] = \
1101                                self.state.clone_state()
1102        except:
1103            pass
1104        #if event != None: event.Skip()
1105
1106    def _get_input_list(self):     
1107        """
1108        get input_list; called by set_state
1109        """   
1110        # get state num of the last compute state
1111        compute_num = self.state.saved_state['compute_num']
1112        # find values and put into the input list
1113        for key1, value1 in self.state.state_list[str(compute_num)].iteritems(): 
1114            for key, _ in self.state.input_list.iteritems(): 
1115                if key == key1:
1116                    self.state.input_list[key] = value1
1117                    break
1118       
1119    def _set_bookmark_menu(self):
1120        """
1121        Setup 'bookmark' context menu
1122        """
1123        ## Create context menu for page
1124        self.popUpMenu = wx.Menu()
1125        id = wx.NewId()
1126        self._bmark = wx.MenuItem(self.popUpMenu, id, "BookMark",
1127                                  " Bookmark the panel to recall it later")
1128        self.popUpMenu.AppendItem(self._bmark)
1129        self._bmark.Enable(True)
1130        wx.EVT_MENU(self, id, self.on_bookmark)
1131        self.popUpMenu.AppendSeparator()
1132        self.Bind(wx.EVT_CONTEXT_MENU, self._on_context_menu)
1133       
1134    def on_bookmark(self, event):
1135        """
1136        Save the panel state in memory and add the list on
1137        the popup menu on bookmark context menu event
1138        """ 
1139        if self._data == None: 
1140            return
1141        if event == None: 
1142            return
1143        self.bookmark_num += 1
1144        # date and time of the event
1145        my_time, date = self._get_time_stamp()
1146        _ = self.state.state_num
1147        compute_num = self.state.saved_state['compute_num']
1148        # name and message of the bookmark list
1149        msg =  "State saved at %s on %s"% (my_time, date)
1150         ## post help message for the selected model
1151        msg += " Right click on the panel to retrieve this state"
1152        #wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
1153        name = "%d] bookmarked at %s on %s"% (self.bookmark_num, my_time, date)
1154       
1155        # append it to menu
1156        id = wx.NewId()
1157        self.popUpMenu.Append(id, name, str(msg))
1158        wx.EVT_MENU(self, id, self._back_to_bookmark)
1159        state = self.state.clone_state()
1160        comp_state = copy.deepcopy(self.state.state_list[str(compute_num)])
1161        self.state.bookmark_list[self.bookmark_num] = [my_time, date,
1162                                                       state,comp_state]
1163        self.state.toXML(self, doc=None, entry_node=None)
1164       
1165        wx.PostEvent(self.parent, StatusEvent(status=msg, info="info"))
1166        wx.PostEvent(self.parent, 
1167                     AppendBookmarkEvent(title=name, 
1168                                         hint=str(msg),
1169                                          handler=self._back_to_bookmark))
1170
1171    def _back_to_bookmark(self, event):
1172        """
1173        Bring the panel back to the state of bookmarked requested by
1174        context menu event
1175        and set it as a new state
1176        """
1177        self._manager.on_perspective(event)
1178        menu = event.GetEventObject()
1179        ## post help message for the selected model
1180        msg = menu.GetHelpString(event.GetId())
1181        msg += " reloaded"
1182        wx.PostEvent(self.parent, StatusEvent(status = msg ))
1183       
1184        name = menu.GetLabel(event.GetId())
1185       
1186        num, time = name.split(']')
1187        current_state_num = self.state.state_num 
1188        self.get_bookmark_by_num(num)
1189        state_num = int(current_state_num) + 1
1190       
1191        self.state.saved_state['state_num'] = state_num
1192        #copy.deepcopy(self.state.saved_state)
1193        self.state.state_list[str(state_num)] = self.state.clone_state()
1194        self.state.state_num = state_num
1195       
1196        self._set_undo_flag(True)
1197        self._info_bookmark_num(event)
1198       
1199    def _info_bookmark_num(self, event=None):
1200        """
1201        print the bookmark number in info
1202       
1203        : event: popUpMenu event
1204        """
1205        if event == None: 
1206            return
1207        # get the object
1208        menu = event.GetEventObject()
1209        item = menu.FindItemById(event.GetId())
1210        text = item.GetText()
1211        num = text.split(']')[0]
1212        msg = "bookmark num = %s "% num
1213       
1214        wx.PostEvent(self.parent, StatusEvent(status = msg ))
1215       
1216    def _info_state_num(self):
1217        """
1218        print the current state number in info
1219        """
1220        msg = "state num = "
1221        msg += self.state.state_num
1222       
1223        wx.PostEvent(self.parent, StatusEvent(status = msg))
1224                         
1225    def _get_time_stamp(self):
1226        """
1227        return time and date stings
1228        """
1229        # date and time
1230        year, month, day, hour, minute, second, _, _, _ = \
1231                                    time.localtime()
1232        my_time = str(hour) + ":" + str(minute) + ":" + str(second)
1233        date = str( month) + "/" + str(day) + "/" + str(year)
1234        return my_time, date
1235   
1236           
1237    def on_save(self, evt=None): 
1238        """
1239        Save invariant state into a file
1240        """
1241        # Ask the user the location of the file to write to.
1242        path = None
1243        if self.parent != None:
1244            self._default_save_location = self.parent.get_save_location()
1245        if self._default_save_location == None:
1246            self._default_save_location = os.getcwd()
1247        dlg = wx.FileDialog(self, "Choose a file",
1248                            self._default_save_location, \
1249                            self.window_caption, "*.inv", wx.SAVE)
1250        if dlg.ShowModal() == wx.ID_OK:
1251            path = dlg.GetPath()
1252            self._default_save_location = os.path.dirname(path)
1253            if self.parent != None:
1254                self.parent._default_save_location = \
1255                    self._default_save_location
1256        else:
1257            return None
1258       
1259        dlg.Destroy()
1260        # MAC always needs the extension for saving
1261        extens = ".inv"
1262        # Make sure the ext included in the file name
1263        fName = os.path.splitext(path)[0] + extens
1264        self._manager.save_file(filepath=fName, state=self.state)
1265       
1266    def _show_message(self, mssg='', msg='Warning'):
1267        """
1268        Show warning message when resetting data
1269        """
1270        # no message for now
1271        return True
1272       
1273    def _reset_output(self):
1274        """
1275        clear outputs textcrtl
1276        """
1277        self.invariant_total_tcl.Clear()
1278        self.invariant_total_err_tcl.Clear()
1279        self.volume_tcl.Clear()
1280        self.volume_err_tcl.Clear()
1281        self.surface_tcl.Clear()
1282        self.surface_err_tcl.Clear()
1283        #prepare a new container to put result of invariant
1284        self.inv_container = InvariantContainer()
1285
1286   
1287    def _on_context_menu(self, event):
1288        """
1289        On context menu
1290        """
1291        pos = event.GetPosition()
1292        pos = self.ScreenToClient(pos)
1293       
1294        self.PopupMenu(self.popUpMenu, pos) 
1295     
1296    def _define_structure(self):
1297        """
1298        Define main sizers needed for this panel
1299        """
1300        ## Box sizers must be defined first before
1301        #defining buttons/textctrls (MAC).
1302        self.main_sizer = wx.BoxSizer(wx.VERTICAL)
1303        #Sizer related to outputs
1304        outputs_box = wx.StaticBox(self, -1, "Outputs")
1305        self.outputs_sizer = wx.StaticBoxSizer(outputs_box, wx.VERTICAL)
1306        self.outputs_sizer.SetMinSize((_STATICBOX_WIDTH, -1))
1307        #Sizer related to data
1308        data_name_box = wx.StaticBox(self, -1, "I(q) Data Source")
1309        self.data_name_boxsizer = wx.StaticBoxSizer(data_name_box, wx.VERTICAL)
1310        self.data_name_boxsizer.SetMinSize((_STATICBOX_WIDTH,-1))
1311        self.hint_msg_sizer = wx.BoxSizer(wx.HORIZONTAL)
1312        self.data_name_sizer = wx.BoxSizer(wx.HORIZONTAL)
1313       
1314        self.data_range_sizer = wx.BoxSizer(wx.HORIZONTAL)
1315        #Sizer related to inputs
1316        self.sizer_input =  wx.FlexGridSizer(2, 6, 0, 0)
1317        #Sizer related to inputs
1318        inputs_box = wx.StaticBox(self, -1, "Customized Inputs")
1319        self.inputs_sizer = wx.StaticBoxSizer(inputs_box, wx.VERTICAL)
1320        self.inputs_sizer.SetMinSize((_STATICBOX_WIDTH, -1))
1321        #Sizer related to extrapolation
1322        extrapolation_box = wx.StaticBox(self, -1, "Extrapolation")
1323        self.extrapolation_sizer = wx.StaticBoxSizer(extrapolation_box,
1324                                                        wx.VERTICAL)
1325        self.extrapolation_sizer.SetMinSize((_STATICBOX_WIDTH, -1))
1326        self.extrapolation_range_sizer = wx.BoxSizer(wx.HORIZONTAL)
1327        self.extrapolation_low_high_sizer = wx.BoxSizer(wx.HORIZONTAL)
1328        #Sizer related to extrapolation at low q range
1329        low_q_box = wx.StaticBox(self, -1, "Low Q")
1330        self.low_extrapolation_sizer = wx.StaticBoxSizer(low_q_box, wx.VERTICAL)
1331     
1332        self.low_q_sizer = wx.GridBagSizer(5, 5)
1333        #Sizer related to extrapolation at low q range
1334        high_q_box = wx.StaticBox(self, -1, "High Q")
1335        self.high_extrapolation_sizer = wx.StaticBoxSizer(high_q_box,
1336                                                          wx.VERTICAL)
1337        self.high_q_sizer = wx.GridBagSizer(5, 5)
1338        #sizer to define outputs
1339        self.volume_surface_sizer = wx.GridBagSizer(5, 5)
1340        #Sizer related to invariant output
1341        self.invariant_sizer = wx.GridBagSizer(5, 5)
1342        #Sizer related to button
1343        self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
1344        self.button_sizer.SetMinSize((_STATICBOX_WIDTH, -1))
1345        #Sizer related to save button
1346        self.save_button_sizer = wx.BoxSizer(wx.HORIZONTAL)
1347       
1348    def _layout_data_name(self):
1349        """
1350        Draw widgets related to data's name
1351        """
1352        #Sizer hint
1353        hint_msg = ""
1354       
1355        self.hint_msg_txt = wx.StaticText(self, -1, hint_msg) 
1356        self.hint_msg_txt.SetForegroundColour("red")
1357        msg = "Highlight = mouse the mouse's cursor on the data until"
1358        msg += " the plot's color changes to yellow"
1359        self.hint_msg_txt.SetToolTipString(msg)
1360        self.hint_msg_sizer.Add(self.hint_msg_txt)
1361        #Data name [string]
1362        data_name_txt = wx.StaticText(self, -1, 'Name:') 
1363       
1364        self.data_name_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH*4, 20),
1365                                            style=0) 
1366        self.data_name_tcl.SetToolTipString("Data's name.")
1367        self.data_name_sizer.AddMany([(data_name_txt, 0, wx.LEFT|wx.RIGHT, 10),
1368                                       (self.data_name_tcl, 0, wx.EXPAND)])
1369        #Data range [string]
1370        data_range_txt = wx.StaticText(self, -1, 'Total Q Range (1/A): ') 
1371        data_min_txt = wx.StaticText(self, -1, 'Min : ') 
1372        self.data_min_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1373                                           style=0, name='data_min_tcl')
1374        self.data_min_tcl.SetToolTipString("The minimum value of q range.")
1375        data_max_txt = wx.StaticText(self, -1, 'Max : ') 
1376        self.data_max_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1377                                           style=0, name='data_max_tcl') 
1378        self.data_max_tcl.SetToolTipString("The maximum value of q range.")
1379        self.data_range_sizer.AddMany([(data_range_txt, 0, wx.RIGHT, 5),
1380                                       (data_min_txt, 0, wx.RIGHT, 5),
1381                                       (self.data_min_tcl, 0, wx.RIGHT, 20),
1382                                       (data_max_txt, 0, wx.RIGHT, 5),
1383                                       (self.data_max_tcl, 0, wx.RIGHT, 10)])
1384        self.data_name_boxsizer.AddMany([(self.hint_msg_sizer, 0 , wx.ALL, 5),
1385                            (self.data_name_sizer, 0 , wx.ALL, 10),
1386                                     (self.data_range_sizer, 0 , wx.ALL, 10)])
1387   
1388    def _enable_fit_power_law_low(self, event=None):
1389        """
1390        Enable and disable the power value editing
1391        """
1392        if event != None: 
1393            self._set_bookmark_flag(True)
1394            self._set_preview_flag(False)
1395   
1396        if self.fix_enable_low.IsEnabled():
1397           
1398            if self.fix_enable_low.GetValue():
1399                self.fit_enable_low.SetValue(False)
1400                self.power_low_tcl.Enable()
1401            else:
1402                self.fit_enable_low.SetValue(True)
1403                self.power_low_tcl.Disable()
1404        self._set_state(event=event)
1405           
1406    def _enable_low_q_section(self, event=None):
1407        """
1408        Disable or enable some button if the user enable low q extrapolation
1409        """
1410        if event != None: 
1411            self._set_bookmark_flag(True)
1412            self._set_preview_flag(False)
1413           
1414        if self.enable_low_cbox.GetValue():
1415            self.npts_low_tcl.Enable()
1416            self.fix_enable_low.Enable()
1417            self.fit_enable_low.Enable()
1418            self.guinier.Enable()
1419            self.power_law_low.Enable()
1420
1421        else:
1422            self.npts_low_tcl.Disable()
1423            self.fix_enable_low.Disable()
1424            self.fit_enable_low.Disable()
1425            self.guinier.Disable()
1426            self.power_law_low.Disable()
1427       
1428        self._enable_power_law_low()
1429        self._enable_fit_power_law_low()
1430        self._set_state(event=event)
1431        self.button_calculate.SetFocus()
1432       
1433    def _enable_power_law_low(self, event=None):
1434        """
1435        Enable editing power law section at low q range
1436        """
1437        if event != None: 
1438            self._set_bookmark_flag(True)
1439            self._set_preview_flag(False)
1440        if self.guinier.GetValue():
1441            self.power_law_low.SetValue(False)
1442            self.fix_enable_low.Disable()
1443            self.fit_enable_low.Disable()
1444            self.power_low_tcl.Disable()
1445        else:
1446            self.power_law_low.SetValue(True)
1447            self.fix_enable_low.Enable()
1448            self.fit_enable_low.Enable()
1449            self.power_low_tcl.Enable()
1450        self._enable_fit_power_law_low()
1451        self._set_state(event=event)
1452           
1453    def _layout_extrapolation_low(self):
1454        """
1455        Draw widgets related to extrapolation at low q range
1456        """
1457        self.enable_low_cbox = wx.CheckBox(self, -1,
1458                                           "Enable Extrapolate Low Q",
1459                                           name='enable_low_cbox')
1460        wx.EVT_CHECKBOX(self, self.enable_low_cbox.GetId(),
1461                                         self._enable_low_q_section)
1462        self.fix_enable_low = wx.RadioButton(self, -1, 'Fix',
1463                                         (10, 10), style=wx.RB_GROUP,
1464                                         name='fix_enable_low')
1465        self.Bind(wx.EVT_RADIOBUTTON, self._enable_fit_power_law_low,
1466                                     id=self.fix_enable_low.GetId())
1467        self.fit_enable_low = wx.RadioButton(self, -1, 'Fit', (10, 10),
1468                                             name='fit_enable_low')
1469        self.Bind(wx.EVT_RADIOBUTTON, self._enable_fit_power_law_low, 
1470                                        id=self.fit_enable_low.GetId())
1471        self.guinier = wx.RadioButton(self, -1, 'Guinier',
1472                                         (10, 10), style=wx.RB_GROUP,
1473                                         name='guinier')
1474        self.Bind(wx.EVT_RADIOBUTTON, self._enable_power_law_low,
1475                                     id=self.guinier.GetId())       
1476        self.power_law_low = wx.RadioButton(self, -1, 'Power Law',
1477                                            (10, 10), name='power_law_low')
1478        self.Bind(wx.EVT_RADIOBUTTON, self._enable_power_law_low, 
1479                                        id=self.power_law_low.GetId())
1480       
1481        npts_low_txt = wx.StaticText(self, -1, 'Npts')
1482        self.npts_low_tcl = InvTextCtrl(self, -1,
1483                                        size=(_BOX_WIDTH*2/3, -1),
1484                                        name='npts_low_tcl')
1485        wx.EVT_TEXT(self, self.npts_low_tcl.GetId(), self._on_text)
1486        msg_hint = "Number of Q points to consider"
1487        msg_hint += "while extrapolating the low-Q region"
1488        self.npts_low_tcl.SetToolTipString(msg_hint)
1489        power_txt = wx.StaticText(self, -1, 'Power')
1490        self.power_low_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH*2/3, -1),
1491                                         name='power_low_tcl')
1492        wx.EVT_TEXT(self, self.power_low_tcl.GetId(), self._on_text)
1493       
1494        power_hint_txt = "Exponent to apply to the Power_law function."
1495        self.power_low_tcl.SetToolTipString(power_hint_txt)
1496        iy = 0
1497        ix = 0
1498        self.low_q_sizer.Add(self.enable_low_cbox, (iy, ix), (1, 5),
1499                            wx.TOP|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1500        iy += 1
1501        ix = 0
1502        self.low_q_sizer.Add(npts_low_txt, (iy, ix), (1, 1),
1503                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1504        ix += 1
1505        self.low_q_sizer.Add(self.npts_low_tcl, (iy, ix), (1,1),
1506                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
1507        iy += 1
1508        ix = 0
1509        self.low_q_sizer.Add(self.guinier, (iy, ix), (1,2),
1510                             wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1511        iy += 1
1512        ix = 0
1513        self.low_q_sizer.Add(self.power_law_low, (iy, ix), (1, 2),
1514                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1515        # Parameter controls for power law
1516        ix = 1
1517        iy += 1
1518        self.low_q_sizer.Add(self.fix_enable_low, (iy, ix), (1, 1),
1519                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
1520        ix += 1
1521        self.low_q_sizer.Add(self.fit_enable_low, (iy, ix),(1,1),
1522                           wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
1523        ix = 1
1524        iy += 1
1525        self.low_q_sizer.Add(power_txt, (iy, ix), (1, 1),
1526                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
1527        ix += 1
1528        self.low_q_sizer.Add(self.power_low_tcl, (iy, ix), (1, 1),
1529                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
1530        self.low_extrapolation_sizer.Add(self.low_q_sizer)
1531       
1532    def _enable_fit_power_law_high(self, event=None):
1533        """
1534        Enable and disable the power value editing
1535        """
1536        if event != None: 
1537            self._set_bookmark_flag(True)
1538   
1539            self._set_preview_flag(False)
1540        if self.fix_enable_high.IsEnabled():
1541            if self.fix_enable_high.GetValue():
1542                self.fit_enable_high.SetValue(False)
1543                self.power_high_tcl.Enable()
1544            else:
1545                self.fit_enable_high.SetValue(True)
1546                self.power_high_tcl.Disable()
1547        self._set_state(event=event)
1548       
1549    def _enable_high_q_section(self, event=None):
1550        """
1551        Disable or enable some button if the user enable high q extrapolation
1552        """
1553        if event != None: 
1554            self._set_bookmark_flag(True)
1555            self._set_preview_flag(False)
1556        if self.enable_high_cbox.GetValue():
1557            self.npts_high_tcl.Enable()
1558            self.power_law_high.Enable()
1559            self.power_high_tcl.Enable()
1560            self.fix_enable_high.Enable()
1561            self.fit_enable_high.Enable()
1562        else:
1563            self.npts_high_tcl.Disable()
1564            self.power_law_high.Disable()
1565            self.power_high_tcl.Disable()
1566            self.fix_enable_high.Disable()
1567            self.fit_enable_high.Disable()
1568        self._enable_fit_power_law_high()
1569        self._set_state(event=event)
1570        self.button_calculate.SetFocus()
1571 
1572    def _layout_extrapolation_high(self):
1573        """
1574        Draw widgets related to extrapolation at high q range
1575        """
1576        self.enable_high_cbox = wx.CheckBox(self, -1,
1577                                            "Enable Extrapolate high-Q",
1578                                            name='enable_high_cbox')
1579        wx.EVT_CHECKBOX(self, self.enable_high_cbox.GetId(),
1580                                         self._enable_high_q_section)
1581        self.fix_enable_high = wx.RadioButton(self, -1, 'Fix',
1582                                         (10, 10), style=wx.RB_GROUP,
1583                                         name='fix_enable_high')
1584        self.Bind(wx.EVT_RADIOBUTTON, self._enable_fit_power_law_high,
1585                                     id=self.fix_enable_high.GetId())
1586        self.fit_enable_high = wx.RadioButton(self, -1, 'Fit', (10, 10),
1587                                              name='fit_enable_high')     
1588        self.Bind(wx.EVT_RADIOBUTTON, self._enable_fit_power_law_high, 
1589                                        id=self.fit_enable_high.GetId())
1590       
1591        self.power_law_high = wx.StaticText(self, -1, 'Power Law')
1592        msg_hint = "Check to extrapolate data at high-Q"
1593        self.power_law_high.SetToolTipString(msg_hint)
1594        npts_high_txt = wx.StaticText(self, -1, 'Npts')
1595        self.npts_high_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH*2/3, -1),
1596                                         name='npts_high_tcl')
1597        wx.EVT_TEXT(self, self.npts_high_tcl.GetId(), self._on_text)
1598        msg_hint = "Number of Q points to consider"
1599        msg_hint += "while extrapolating the high-Q region"
1600        self.npts_high_tcl.SetToolTipString(msg_hint)
1601        power_txt = wx.StaticText(self, -1, 'Power')
1602        self.power_high_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH*2/3, -1),
1603                                          name='power_high_tcl')
1604        wx.EVT_TEXT(self, self.power_high_tcl.GetId(), self._on_text)
1605        power_hint_txt = "Exponent to apply to the Power_law function."
1606        self.power_high_tcl.SetToolTipString(power_hint_txt)
1607        iy = 0
1608        ix = 0
1609        self.high_q_sizer.Add(self.enable_high_cbox, (iy, ix), (1, 5),
1610                            wx.TOP|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1611        iy += 1
1612        ix = 0
1613        self.high_q_sizer.Add(npts_high_txt, (iy, ix), (1, 1),
1614                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1615        ix += 1
1616        self.high_q_sizer.Add(self.npts_high_tcl, (iy, ix), (1, 1),
1617                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
1618        iy += 1
1619        ix = 0
1620        self.high_q_sizer.Add(self.power_law_high, (iy, ix),(1, 2),
1621                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1622       
1623        # Parameter controls for power law
1624        ix = 1
1625        iy += 1
1626        self.high_q_sizer.Add(self.fix_enable_high,(iy, ix), (1, 1),
1627                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
1628        ix += 1
1629        self.high_q_sizer.Add(self.fit_enable_high,(iy, ix), (1, 1),
1630                           wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
1631        ix = 1
1632        iy += 1
1633        self.high_q_sizer.Add(power_txt,(iy, ix), (1, 1),
1634                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1635        ix += 1
1636        self.high_q_sizer.Add(self.power_high_tcl, (iy, ix),  (1, 1),
1637                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
1638        self.high_extrapolation_sizer.Add(self.high_q_sizer, 0, 
1639                                                wx.BOTTOM, 20)
1640       
1641    def _layout_extrapolation(self):
1642        """
1643        Draw widgets related to extrapolation
1644        """
1645        extra_hint = "Extrapolation \nMaximum Q Range [1/A]:"
1646        extra_hint_txt = wx.StaticText(self, -1, extra_hint)
1647        #Extrapolation range [string]
1648        extrapolation_min_txt = wx.StaticText(self, -1, 'Min:') 
1649        self.extrapolation_min_tcl = OutputTextCtrl(self, -1, 
1650                                                size=(_BOX_WIDTH, 20), style=0,
1651                                                name='extrapolation_min_tcl')
1652        self.extrapolation_min_tcl.SetValue(str(Q_MINIMUM))
1653        hint_msg = "The minimum extrapolated q value."
1654        self.extrapolation_min_tcl.SetToolTipString(hint_msg)
1655        extrapolation_max_txt = wx.StaticText(self, -1, 'Max:') 
1656        self.extrapolation_max_tcl = OutputTextCtrl(self, -1,
1657                                                  size=(_BOX_WIDTH, 20),
1658                                                  style=0,
1659                                                  name='extrapolation_max_tcl') 
1660        self.extrapolation_max_tcl.SetValue(str(Q_MAXIMUM))
1661        hint_msg = "The maximum extrapolated q value."
1662        self.extrapolation_max_tcl.SetToolTipString(hint_msg)
1663        self.extrapolation_range_sizer.AddMany([(extra_hint_txt, 0, 
1664                                                 wx.LEFT, 5),
1665                                                (extrapolation_min_txt, 0,
1666                                                 wx.LEFT, 10),
1667                                                (self.extrapolation_min_tcl,
1668                                                            0, wx.LEFT, 5),
1669                                                (extrapolation_max_txt, 0,
1670                                                 wx.LEFT, 20),
1671                                                (self.extrapolation_max_tcl,
1672                                                            0, wx.LEFT, 5)])
1673        self._layout_extrapolation_low()
1674        self._layout_extrapolation_high()
1675        self.extrapolation_low_high_sizer.AddMany(\
1676                                            [(self.low_extrapolation_sizer,
1677                                            0, wx.LEFT|wx.BOTTOM|wx.TOP, 5),
1678                                            (self.high_extrapolation_sizer,
1679                                             0, wx.LEFT|wx.BOTTOM|wx.TOP, 5)])
1680        self.extrapolation_sizer.AddMany([(self.extrapolation_range_sizer),
1681                                        (self.extrapolation_low_high_sizer)])
1682       
1683    def _layout_volume_surface_sizer(self):
1684        """
1685        Draw widgets related to volume and surface
1686        """
1687        unit_volume = ''
1688        unit_surface = '[1/A]'
1689        uncertainty = "+/-" 
1690        volume_txt = wx.StaticText(self, -1, 'Volume Fraction')
1691        self.volume_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, -1),
1692                                         name='volume_tcl')
1693        wx.EVT_TEXT(self, self.volume_tcl.GetId(), self._on_out_text)
1694        self.volume_tcl.SetToolTipString("Volume fraction.")
1695        self.volume_err_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, -1),
1696                                             name='volume_err_tcl')
1697        wx.EVT_TEXT(self, self.volume_err_tcl.GetId(), self._on_out_text)
1698        hint_msg = "Uncertainty on the volume fraction."
1699        self.volume_err_tcl.SetToolTipString(hint_msg)
1700        volume_units_txt = wx.StaticText(self, -1, unit_volume)
1701       
1702        surface_txt = wx.StaticText(self, -1, 'Specific Surface')
1703        self.surface_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, -1),
1704                                          name='surface_tcl')
1705        wx.EVT_TEXT(self, self.surface_tcl.GetId(), self._on_out_text)
1706        self.surface_tcl.SetToolTipString("Specific surface value.")
1707        self.surface_err_tcl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, -1),
1708                                              name='surface_err_tcl')
1709        wx.EVT_TEXT(self, self.surface_err_tcl.GetId(), self._on_out_text)
1710        hint_msg = "Uncertainty on the specific surface."
1711        self.surface_err_tcl.SetToolTipString(hint_msg)
1712        surface_units_txt = wx.StaticText(self, -1, unit_surface)
1713        iy = 0
1714        ix = 0
1715        self.volume_surface_sizer.Add(volume_txt, (iy, ix), (1, 1),
1716                             wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1717        ix += 1
1718        self.volume_surface_sizer.Add(self.volume_tcl, (iy, ix), (1, 1),
1719                            wx.EXPAND|wx.ADJUST_MINSIZE, 20)
1720        ix += 1
1721        self.volume_surface_sizer.Add(wx.StaticText(self, -1, uncertainty),
1722                         (iy, ix),(1,1),wx.EXPAND|wx.ADJUST_MINSIZE, 10) 
1723        ix += 1
1724        self.volume_surface_sizer.Add(self.volume_err_tcl, (iy, ix), (1, 1),
1725                            wx.EXPAND|wx.ADJUST_MINSIZE, 10) 
1726        ix += 1
1727        self.volume_surface_sizer.Add(volume_units_txt, (iy, ix), (1, 1),
1728                             wx.EXPAND|wx.ADJUST_MINSIZE, 10)
1729        iy += 1
1730        ix = 0
1731        self.volume_surface_sizer.Add(surface_txt, (iy, ix), (1, 1),
1732                             wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1733        ix += 1
1734        self.volume_surface_sizer.Add(self.surface_tcl, (iy, ix), (1, 1),
1735                            wx.EXPAND|wx.ADJUST_MINSIZE, 20)
1736        ix += 1
1737        self.volume_surface_sizer.Add(wx.StaticText(self, -1, uncertainty),
1738                         (iy, ix),(1,1),wx.EXPAND|wx.ADJUST_MINSIZE, 10) 
1739        ix += 1
1740        self.volume_surface_sizer.Add(self.surface_err_tcl, (iy, ix), (1, 1),
1741                            wx.EXPAND|wx.ADJUST_MINSIZE, 10) 
1742        ix += 1
1743        self.volume_surface_sizer.Add(surface_units_txt, (iy, ix), (1, 1),
1744                            wx.EXPAND|wx.ADJUST_MINSIZE, 10)
1745        static_line = wx.StaticLine(self, -1)
1746        iy += 1
1747        ix = 0
1748       
1749    def _layout_invariant_sizer(self):
1750        """
1751        Draw widgets related to invariant
1752        """
1753        uncertainty = "+/-" 
1754        unit_invariant = '[1/(cm*A^3)]'
1755        invariant_total_txt = wx.StaticText(self, -1, 'Invariant Total [Q*]')
1756        self.invariant_total_tcl = OutputTextCtrl(self, -1,
1757                                                  size=(_BOX_WIDTH, -1),
1758                                                  name='invariant_total_tcl')
1759        msg_hint = "Total invariant [Q*], including extrapolated regions."
1760        self.invariant_total_tcl.SetToolTipString(msg_hint)
1761        self.invariant_total_err_tcl = OutputTextCtrl(self, -1,
1762                                                      size=(_BOX_WIDTH, -1),
1763                                                name='invariant_total_err_tcl')
1764        hint_msg = "Uncertainty on invariant."
1765        self.invariant_total_err_tcl.SetToolTipString(hint_msg)
1766        invariant_total_units_txt = wx.StaticText(self, -1, unit_invariant, 
1767                                                  size=(80,-1))
1768   
1769        #Invariant total
1770        iy = 0
1771        ix = 0
1772        self.invariant_sizer.Add(invariant_total_txt, (iy, ix), (1, 1),
1773                             wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1774        ix += 1
1775        self.invariant_sizer.Add(self.invariant_total_tcl, (iy, ix), (1, 1),
1776                          wx.EXPAND|wx.ADJUST_MINSIZE, 10)
1777        ix += 1
1778        self.invariant_sizer.Add( wx.StaticText(self, -1, uncertainty),
1779                         (iy, ix),(1,1),wx.EXPAND|wx.ADJUST_MINSIZE, 10) 
1780        ix += 1
1781        self.invariant_sizer.Add(self.invariant_total_err_tcl, (iy, ix), (1, 1),
1782                             wx.EXPAND|wx.ADJUST_MINSIZE, 10)
1783        ix += 1
1784        self.invariant_sizer.Add(invariant_total_units_txt,(iy, ix), (1, 1),
1785                          wx.EXPAND|wx.ADJUST_MINSIZE, 10)
1786 
1787    def _layout_inputs_sizer(self):
1788        """
1789        Draw widgets related to inputs
1790        """
1791        contrast_txt = wx.StaticText(self, -1, 'Contrast:') 
1792        self.contrast_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1793                                        style=0, name='contrast_tcl')
1794        wx.EVT_TEXT(self, self.contrast_tcl.GetId(), self._on_text)
1795        contrast_hint_txt = "Contrast"
1796        self.contrast_tcl.SetToolTipString(contrast_hint_txt)
1797        contrast_unit_txt = wx.StaticText(self, -1, '[1/A^2]', size=(40,-1)) 
1798        porod_const_txt = wx.StaticText(self, -1, 
1799                                        'Porod\nConstant:\n(optional)\n') 
1800        porod_unit_txt = wx.StaticText(self, -1, '[1/(cm*A^4)]', size=(80,-1)) 
1801        self.porod_constant_tcl = InvTextCtrl(self, -1, 
1802                                              size=(_BOX_WIDTH, 20), style=0,
1803                                              name='porod_constant_tcl') 
1804        wx.EVT_TEXT(self, self.porod_constant_tcl.GetId(), self._on_text)
1805        porod_const_hint_txt = "Porod Constant"
1806        self.porod_constant_tcl.SetToolTipString(porod_const_hint_txt)
1807       
1808        background_txt = wx.StaticText(self, -1, 'Background:') 
1809        self.background_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1810                                          style=0, name='background_tcl') 
1811        wx.EVT_TEXT(self, self.background_tcl.GetId(), self._on_text)
1812        background_hint_txt = "Background"
1813        self.background_tcl.SetToolTipString(background_hint_txt)
1814        background_unit_txt = wx.StaticText(self, -1, '[1/cm]') 
1815        scale_txt = wx.StaticText(self, -1, 'Scale:') 
1816        self.scale_tcl = InvTextCtrl(self, -1, size=(_BOX_WIDTH, 20), style=0,
1817                                     name='scale_tcl')
1818        wx.EVT_TEXT(self, self.scale_tcl.GetId(), self._on_text)
1819        scale_hint_txt = "Scale"
1820        self.scale_tcl.SetToolTipString(scale_hint_txt)
1821        self.sizer_input.AddMany([(background_txt, 0, wx.LEFT|wx.BOTTOM, 5),
1822                            (self.background_tcl, 0, wx.LEFT|wx.BOTTOM, 5),
1823                            (background_unit_txt, 0, wx.LEFT|wx.BOTTOM, 5),
1824                            (scale_txt, 0, wx.LEFT|wx.BOTTOM, 10),
1825                            (self.scale_tcl, 0, wx.LEFT|wx.BOTTOM|wx.RIGHT, 5),
1826                            (10, 10),
1827                            (contrast_txt, 0, wx.LEFT|wx.BOTTOM, 5),
1828                            (self.contrast_tcl, 0, wx.LEFT|wx.BOTTOM, 5),
1829                            (contrast_unit_txt, 0, wx.LEFT|wx.BOTTOM, 5),
1830                            (porod_const_txt, 0, wx.LEFT, 10),
1831                (self.porod_constant_tcl, 0, wx.LEFT|wx.BOTTOM|wx.RIGHT, 5),
1832                (porod_unit_txt, 0, wx.LEFT|wx.BOTTOM, 5)])
1833        self.inputs_sizer.Add(self.sizer_input)
1834       
1835    def _layout_outputs_sizer(self):
1836        """
1837        Draw widgets related to outputs
1838        """
1839        self._layout_volume_surface_sizer()
1840        self._layout_invariant_sizer()
1841        static_line = wx.StaticLine(self, -1)
1842        self.outputs_sizer.AddMany([(self.volume_surface_sizer,
1843                                      0, wx.TOP|wx.BOTTOM, 10),
1844                                    (static_line, 0, wx.EXPAND, 0),
1845                         (self.invariant_sizer, 0, wx.TOP|wx.BOTTOM, 10)])
1846    def _layout_button(self): 
1847        """
1848        Do the layout for the button widgets
1849        """ 
1850        #compute button
1851        id = wx.NewId()
1852        self.button_calculate = wx.Button(self, id, "Compute",
1853                                          name='compute_invariant')
1854        self.button_calculate.SetToolTipString("Compute invariant")
1855        self.Bind(wx.EVT_BUTTON, self.compute_invariant, id=id)   
1856        #detail button
1857        id = wx.NewId()
1858        self.button_details = wx.Button(self, id, "Details?")
1859        hint_msg = "Details about the results of the computation"
1860        self.button_details.SetToolTipString(hint_msg)
1861        self.Bind(wx.EVT_BUTTON, self.display_details, id=id)
1862        details = "Details on Invariant Total Calculations"
1863        details_txt = wx.StaticText(self, -1, details)
1864        self.button_sizer.AddMany([(details_txt, 0 , 
1865                                    wx.RIGHT|wx.BOTTOM|wx.TOP, 10),
1866                                   (self.button_details, 0 , wx.ALL, 10),
1867                        (self.button_calculate, 0 ,
1868                         wx.RIGHT|wx.TOP|wx.BOTTOM, 10)])
1869    def _do_layout(self):
1870        """
1871        Draw window content
1872        """
1873        self._define_structure()
1874        self._layout_data_name()
1875        self._layout_extrapolation()
1876        self._layout_inputs_sizer()
1877        self._layout_outputs_sizer()
1878        self._layout_button()
1879        self.main_sizer.AddMany([(self.data_name_boxsizer, 0, wx.ALL, 10),
1880                                  (self.outputs_sizer, 0,
1881                                  wx.LEFT|wx.RIGHT|wx.BOTTOM, 10),
1882                                  (self.button_sizer, 0, wx.LEFT|wx.RIGHT, 15),
1883                                 (self.inputs_sizer, 0,
1884                                  wx.LEFT|wx.RIGHT|wx.BOTTOM, 10),
1885                                  (self.extrapolation_sizer, 0,
1886                                  wx.LEFT|wx.RIGHT|wx.BOTTOM, 10)])
1887        self.SetSizer(self.main_sizer)
1888        self.SetAutoLayout(True)
1889       
1890       
1891class InvariantDialog(wx.Dialog):
1892    """
1893    Invariant Dialog
1894    """
1895    def __init__(self, parent=None, id=1, graph=None,
1896                 data=None, title="Invariant", base=None):
1897        wx.Dialog.__init__(self, parent, id, title, size=(PANEL_WIDTH,
1898                                                             PANEL_HEIGHT))
1899        self.panel = InvariantPanel(self)
1900        self.Centre()
1901        self.Show(True)
1902       
1903class InvariantWindow(wx.Frame):
1904    """
1905    Invariant Window
1906    """
1907    def __init__(self, parent=None, id=1, graph=None, 
1908                 data=None, title="Invariant", base=None):
1909       
1910        wx.Frame.__init__(self, parent, id, title, size=(PANEL_WIDTH +100,
1911                                                             PANEL_HEIGHT+100))
1912        from sans.dataloader.loader import  Loader
1913        self.loader = Loader()
1914        import invariant
1915        path = "C:/ECLPS/workspace/trunk/sansdataloader/test/ascii_test_3.txt"
1916        data = self.loader.load(path)
1917        self.panel = InvariantPanel(self)
1918
1919        data.name = data.filename
1920        self.panel.set_data(data)
1921        self.Centre()
1922        self.Show(True)
1923       
1924class MyApp(wx.App):
1925    """
1926    Test App
1927    """
1928    def OnInit(self):
1929        """
1930        Init
1931        """
1932        wx.InitAllImageHandlers()
1933        frame = InvariantWindow()
1934        frame.Show(True)
1935        self.SetTopWindow(frame)
1936       
1937        return True
1938     
1939# end of class MyApp
1940
1941if __name__ == "__main__":
1942    app = MyApp(0)
1943    app.MainLoop()
Note: See TracBrowser for help on using the repository browser.