source: sasview/src/sas/sasgui/perspectives/fitting/basepage.py @ 5156918

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.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 5156918 was 5156918, checked in by wojciech, 3 years ago

Merge branch 'master' of https://github.com/SasView/sasview into ticket-854

  • Property mode set to 100644
File size: 141.9 KB
Line 
1"""
2Base Page for fitting
3"""
4import sys
5import os
6import wx
7import numpy
8import time
9import copy
10import math
11import json
12import logging
13import traceback
14
15from collections import defaultdict
16from wx.lib.scrolledpanel import ScrolledPanel
17
18from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
19
20from sas.sasgui.guiframe.panel_base import PanelBase
21from sas.sasgui.guiframe.utils import format_number, check_float, IdList, \
22    check_int
23from sas.sasgui.guiframe.events import PanelOnFocusEvent
24from sas.sasgui.guiframe.events import StatusEvent
25from sas.sasgui.guiframe.events import AppendBookmarkEvent
26from sas.sasgui.guiframe.dataFitting import Data2D
27from sas.sasgui.guiframe.dataFitting import Data1D
28from sas.sasgui.guiframe.dataFitting import check_data_validity
29from sas.sasgui.guiframe.gui_style import GUIFRAME_ID
30from sas.sascalc.dataloader.data_info import Detector
31from sas.sascalc.dataloader.data_info import Source
32from sas.sasgui.perspectives.fitting.pagestate import PageState
33from sas.sasgui.guiframe.CategoryInstaller import CategoryInstaller
34from sas.sasgui.guiframe.documentation_window import DocumentationWindow
35
36
37(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent()
38(PreviousStateEvent, EVT_PREVIOUS_STATE) = wx.lib.newevent.NewEvent()
39(NextStateEvent, EVT_NEXT_STATE) = wx.lib.newevent.NewEvent()
40
41_BOX_WIDTH = 76
42_QMIN_DEFAULT = 0.0005
43_QMAX_DEFAULT = 0.5
44_NPTS_DEFAULT = 50
45# Control panel width
46if sys.platform.count("win32") > 0:
47    PANEL_WIDTH = 450
48    FONT_VARIANT = 0
49    ON_MAC = False
50else:
51    PANEL_WIDTH = 500
52    FONT_VARIANT = 1
53    ON_MAC = True
54
55CUSTOM_MODEL = 'Plugin Models'
56
57class BasicPage(ScrolledPanel, PanelBase):
58    """
59    This class provide general structure of the fitpanel page
60    """
61    # Internal name for the AUI manager
62    window_name = "Fit Page"
63    # Title to appear on top of the window
64    window_caption = "Fit Page "
65
66    # These two buttons have specific IDs since they seem to be created more
67    # frequently than they need to.  In particular, set_dispers_sizer() is
68    # called by _on_select_model
69    ID_BOOKMARK = wx.NewId()
70    ID_DISPERSER_HELP = wx.NewId()
71    _id_pool = IdList()
72
73    def __init__(self, parent, color='blue', **kwargs):
74        """
75        """
76        ScrolledPanel.__init__(self, parent, **kwargs)
77        PanelBase.__init__(self, parent)
78        self.SetupScrolling()
79        # Set window's font size
80        self.SetWindowVariant(variant=FONT_VARIANT)
81        self.SetBackgroundColour(color)
82
83        self._ids = iter(self._id_pool)
84        # parent of the page
85        self.parent = parent
86        # manager is the fitting plugin
87        # owner of the page (fitting plugin)
88        self.event_owner = None
89        # current model
90        self.model = None
91        self.m_name = None
92        self.index_model = None
93        self.panel = None
94        # data
95        self.data = None
96        # list of available data
97        self.data_list = []
98        self.mask = None
99        self.uid = wx.NewId()
100        self.graph_id = None
101        # Q range for data set
102        self.qmin_data_set = numpy.inf
103        self.qmax_data_set = None
104        self.npts_data_set = 0
105        # Q range
106        self.qmin = None
107        self.qmax = None
108        self.qmax_x = _QMAX_DEFAULT
109        self.qmin_x = _QMIN_DEFAULT
110        self.npts_x = _NPTS_DEFAULT
111        # total number of point: float
112        self.npts = None
113        self.num_points = None
114        # smear default
115        self.current_smearer = None
116        # 2D smear accuracy default
117        self.smear2d_accuracy = 'Low'
118        # slit smear:
119        self.dxl = None
120        self.dxw = None
121        # pinhole smear
122        self.dx_percent = None
123        # smear attrbs
124        self.enable_smearer = None
125        self.disable_smearer = None
126        self.pinhole_smearer = None
127        self.slit_smearer = None
128        # weight attrbs
129        self.dI_noweight = None
130        self.dI_didata = None
131        self.dI_sqrdata = None
132        self.dI_idata = None
133        # other attrbs
134        self.dq_l = None
135        self.dq_r = None
136        self.tcChi = None
137        self.disp_box = None
138        self.model_disp = None
139        self.Npts_fit = None
140        self.Npts_total = None
141        self.theory_qmin = None
142        self.theory_qmax = None
143        self.theory_qmin_x = None
144        self.theory_qmax_x = None
145        self.btEditMask = None
146        self.btFit = None
147        self.sld_axes = None
148        self.multi_factor = None
149
150        self.disp_cb_dict = {}
151
152        # self.state = PageState(parent=parent)
153        # dictionary containing list of models
154        self.model_list_box = {}
155
156        # Data member to store the dispersion object created
157        self._disp_obj_dict = {}
158        # selected parameters to apply dispersion
159        self.disp_cb_dict = {}
160        # smearer object
161        self.enable2D = False
162        self._has_magnetic = False
163        self.magnetic_on = False
164        self.is_mac = ON_MAC
165        self.formfactorbox = None
166        self.structurebox = None
167        self.categorybox = None
168        # list of model parameters. each item must have same length
169        # each item related to a given parameters
170        # [cb state, name, value, "+/-", error of fit, min, max , units]
171        self.parameters = []
172        # non-fittable parameter whose value is astring
173        self.str_parameters = []
174        # list of parameters to fit , must be like self.parameters
175        self.param_toFit = []
176        # list of looking like parameters but with non fittable parameters info
177        self.fixed_param = []
178        # list of looking like parameters but with  fittable parameters info
179        self.fittable_param = []
180        # list of dispersion parameters
181        self.disp_list = []
182        self.disp_name = ""
183
184        # list of orientation parameters
185        self.orientation_params = []
186        self.orientation_params_disp = []
187#       Self.model should ALWAYS be None here.  It was set to none above in
188#       this long init setting.  no obvious function call in between setting
189#       and this - commenting out on 4/8/2014 by PDB.  Remove once clear
190#       it is pointless.
191#        if self.model is not None:
192#            self.disp_list = self.model.getDispParamList()
193        self.temp_multi_functional = False
194        # enable model 2D draw
195        self.enable2D = False
196        # check that the fit range is correct to plot the model again
197        self.fitrange = True
198        # Create memento to save the current state
199        self.state = PageState(parent=self.parent,
200                               model=self.model, data=self.data)
201        # flag to determine if state has change
202        self.state_change = False
203        # save customized array
204        self.values = {}   # type: Dict[str, List[float, ...]]
205        self.weights = {}   # type: Dict[str, List[float, ...]]
206        # retrieve saved state
207        self.number_saved_state = 0
208        # dictionary of saved state
209        self.saved_states = {}
210        # Create context menu for page
211        self.popUpMenu = wx.Menu()
212
213        wx_id = self._ids.next()
214        self._keep = wx.MenuItem(self.popUpMenu, wx_id, "Add bookmark",
215                                 " Keep the panel status to recall it later")
216        self.popUpMenu.AppendItem(self._keep)
217        self._keep.Enable(False)
218        self._set_bookmark_flag(False)
219        self._set_save_flag(False)
220        wx.EVT_MENU(self, wx_id, self.on_bookmark)
221        self.popUpMenu.AppendSeparator()
222
223        # Default locations
224        self._default_save_location = os.getcwd()
225        # save initial state on context menu
226        # self.onSave(event=None)
227        self.Bind(wx.EVT_CONTEXT_MENU, self.onContextMenu)
228
229        # bind key event
230        self.Bind(wx.EVT_LEFT_DOWN, self.on_left_down)
231
232        # create the basic structure of the panel with empty sizer
233        self.define_page_structure()
234        # drawing Initial dispersion parameters sizer
235        self.set_dispers_sizer()
236
237        # layout
238        self.set_layout()
239
240    def set_index_model(self, index):
241        """
242        Index related to this page
243        """
244        self.index_model = index
245
246    def create_default_data(self):
247        """
248        Given the user selection, creates a 1D or 2D data
249        Only when the page is on theory mode.
250        """
251        if not hasattr(self, "model_view"):
252            return
253        toggle_mode_on = self.model_view.IsEnabled()
254        if toggle_mode_on:
255            if self.enable2D and not check_data_validity(self.data):
256                self._create_default_2d_data()
257            else:
258                if self.pointsbox.GetValue():
259                    self._create_log_1d_data()
260                else:
261                    self._create_default_1d_data()
262
263            if self.model is not None:
264                if not self.data.is_data:
265                    self._manager.page_finder[self.uid].set_fit_data(
266                        data=[self.data])
267            self.on_smear_helper(update=True)
268            self.state.enable_smearer = self.enable_smearer.GetValue()
269            self.state.disable_smearer = self.disable_smearer.GetValue()
270            self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
271            self.state.slit_smearer = self.slit_smearer.GetValue()
272
273    def _create_default_1d_data(self):
274        """
275        Create default data for fitting perspective
276        Only when the page is on theory mode.
277        :warning: This data is never plotted.
278
279        """
280        x = numpy.linspace(start=self.qmin_x, stop=self.qmax_x,
281                           num=self.npts_x, endpoint=True)
282        self.data = Data1D(x=x)
283        self.data.xaxis('\\rm{Q}', "A^{-1}")
284        self.data.yaxis('\\rm{Intensity}', "cm^{-1}")
285        self.data.is_data = False
286        self.data.id = str(self.uid) + " data"
287        self.data.group_id = str(self.uid) + " Model1D"
288
289    def _create_log_1d_data(self):
290        """
291        Create log-spaced data for fitting perspective
292        Only when the page is on theory mode.
293        :warning: This data is never plotted.
294
295        """
296        if self.qmin_x >= 1.e-10:
297            qmin = numpy.log10(self.qmin_x)
298        else:
299            qmin = -10.
300
301        if self.qmax_x <= 1.e10:
302            qmax = numpy.log10(self.qmax_x)
303        else:
304            qmax = 10.
305
306        x = numpy.logspace(start=qmin, stop=qmax,
307                           num=self.npts_x, endpoint=True, base=10.0)
308        self.data = Data1D(x=x)
309        self.data.xaxis('\\rm{Q}', "A^{-1}")
310        self.data.yaxis('\\rm{Intensity}', "cm^{-1}")
311        self.data.is_data = False
312        self.data.id = str(self.uid) + " data"
313        self.data.group_id = str(self.uid) + " Model1D"
314
315    def _create_default_2d_data(self):
316        """
317        Create 2D data by default
318        Only when the page is on theory mode.
319        :warning: This data is never plotted.
320        """
321        self.data = Data2D()
322        qmax = self.qmax_x / math.sqrt(2)
323        self.data.xaxis('\\rm{Q_{x}}', 'A^{-1}')
324        self.data.yaxis('\\rm{Q_{y}}', 'A^{-1}')
325        self.data.is_data = False
326        self.data.id = str(self.uid) + " data"
327        self.data.group_id = str(self.uid) + " Model2D"
328        # Default values
329        self.data.detector.append(Detector())
330        index = len(self.data.detector) - 1
331        self.data.detector[index].distance = 8000   # mm
332        self.data.source.wavelength = 6             # A
333        self.data.detector[index].pixel_size.x = 5  # mm
334        self.data.detector[index].pixel_size.y = 5  # mm
335        self.data.detector[index].beam_center.x = qmax
336        self.data.detector[index].beam_center.y = qmax
337        xmax = qmax
338        xmin = -qmax
339        ymax = qmax
340        ymin = -qmax
341        qstep = self.npts_x
342
343        x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
344        y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
345        # use data info instead
346        new_x = numpy.tile(x, (len(y), 1))
347        new_y = numpy.tile(y, (len(x), 1))
348        new_y = new_y.swapaxes(0, 1)
349        # all data reuire now in 1d array
350        qx_data = new_x.flatten()
351        qy_data = new_y.flatten()
352        q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
353        # set all True (standing for unmasked) as default
354        mask = numpy.ones(len(qx_data), dtype=bool)
355        # store x and y bin centers in q space
356        x_bins = x
357        y_bins = y
358
359        self.data.source = Source()
360        self.data.data = numpy.ones(len(mask))
361        self.data.err_data = numpy.ones(len(mask))
362        self.data.qx_data = qx_data
363        self.data.qy_data = qy_data
364        self.data.q_data = q_data
365        self.data.mask = mask
366        self.data.x_bins = x_bins
367        self.data.y_bins = y_bins
368        # max and min taking account of the bin sizes
369        self.data.xmin = xmin
370        self.data.xmax = xmax
371        self.data.ymin = ymin
372        self.data.ymax = ymax
373
374    def on_set_focus(self, event):
375        """
376        On Set Focus, update guimanger and menu
377        """
378        if self._manager is not None:
379            wx.PostEvent(self._manager.parent, PanelOnFocusEvent(panel=self))
380            self.on_tap_focus()
381
382    def on_tap_focus(self):
383        """
384        Update menu1 on cliking the page tap
385        """
386        if self._manager.menu1 is not None:
387            chain_menu = self._manager.menu1.FindItemById(
388                                                   self._manager.id_reset_flag)
389            chain_menu.Enable(self.batch_on)
390            sim_menu = self._manager.menu1.FindItemById(self._manager.id_simfit)
391            flag = self.data.is_data\
392                            and (self.model is not None)
393            sim_menu.Enable(not self.batch_on and flag)
394            batch_menu = \
395                    self._manager.menu1.FindItemById(self._manager.id_batchfit)
396            batch_menu.Enable(self.batch_on and flag)
397
398    def onContextMenu(self, event):
399        """
400        Retrieve the state selected state
401        """
402        pos = event.GetPosition()
403        pos = self.ScreenToClient(pos)
404        self.PopupMenu(self.popUpMenu, pos)
405
406    def onUndo(self, event):
407        """
408        Cancel the previous action
409        """
410        event = PreviousStateEvent(page=self)
411        wx.PostEvent(self.parent, event)
412
413    def onRedo(self, event):
414        """
415        Restore the previous action cancelled
416        """
417        event = NextStateEvent(page=self)
418        wx.PostEvent(self.parent, event)
419
420    def define_page_structure(self):
421        """
422        Create empty sizer for a panel
423        """
424        self.vbox = wx.BoxSizer(wx.VERTICAL)
425        self.sizer0 = wx.BoxSizer(wx.VERTICAL)
426        self.sizer1 = wx.BoxSizer(wx.VERTICAL)
427        self.sizer2 = wx.BoxSizer(wx.VERTICAL)
428        self.sizer3 = wx.BoxSizer(wx.VERTICAL)
429        self.sizer4 = wx.BoxSizer(wx.VERTICAL)
430        self.sizer5 = wx.BoxSizer(wx.VERTICAL)
431        self.sizer6 = wx.BoxSizer(wx.VERTICAL)
432
433        self.sizer0.SetMinSize((PANEL_WIDTH, -1))
434        self.sizer1.SetMinSize((PANEL_WIDTH, -1))
435        self.sizer2.SetMinSize((PANEL_WIDTH, -1))
436        self.sizer3.SetMinSize((PANEL_WIDTH, -1))
437        self.sizer4.SetMinSize((PANEL_WIDTH, -1))
438        self.sizer5.SetMinSize((PANEL_WIDTH, -1))
439        self.sizer6.SetMinSize((PANEL_WIDTH, -1))
440
441        self.vbox.Add(self.sizer0)
442        self.vbox.Add(self.sizer1)
443        self.vbox.Add(self.sizer2)
444        self.vbox.Add(self.sizer3)
445        self.vbox.Add(self.sizer4)
446        self.vbox.Add(self.sizer5)
447        self.vbox.Add(self.sizer6)
448
449    def set_layout(self):
450        """
451        layout
452        """
453        self.vbox.Layout()
454        self.vbox.Fit(self)
455        self.SetSizer(self.vbox)
456        self.Centre()
457
458    def set_owner(self, owner):
459        """
460        set owner of fitpage
461
462        :param owner: the class responsible of plotting
463
464        """
465        self.event_owner = owner
466        self.state.event_owner = owner
467
468    def get_state(self):
469        """
470        return the current page state
471        """
472        return self.state
473
474    def get_data(self):
475        """
476        return the current data
477        """
478        return self.data
479
480    def get_data_list(self):
481        """
482        return the current data
483        """
484        return self.data_list
485
486    def set_manager(self, manager):
487        """
488        set panel manager
489
490        :param manager: instance of plugin fitting
491
492        """
493        self._manager = manager
494        self.state.manager = manager
495
496    def populate_box(self, model_dict):
497        """
498        Store list of model
499
500        :param model_dict: dictionary containing list of models
501
502        """
503        self.model_list_box = model_dict
504        self.state.model_list_box = self.model_list_box
505        self.initialize_combox()
506
507    def set_model_dictionary(self, model_dict):
508        """
509        Store a dictionary linking model name -> model object
510
511        :param model_dict: dictionary containing list of models
512        """
513        self.model_dict = model_dict
514
515    def initialize_combox(self):
516        """
517        put default value in the combo box
518        """
519        if self.model_list_box is not None and len(self.model_list_box) > 0:
520            self._populate_box(self.structurebox,
521                               self.model_list_box["Structure Factors"])
522            self.structurebox.Insert("None", 0, None)
523            self.structurebox.SetSelection(0)
524            self.structurebox.Hide()
525            self.text2.Hide()
526            self.structurebox.Disable()
527            self.text2.Disable()
528
529    def set_dispers_sizer(self):
530        """
531        fill sizer containing dispersity info
532        """
533        # print "==== entering set_dispers_sizer ==="
534        self.sizer4.Clear(True)
535        name = "Polydispersity and Orientational Distribution"
536        box_description = wx.StaticBox(self, wx.ID_ANY, name)
537        box_description.SetForegroundColour(wx.BLUE)
538        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
539        # ----------------------------------------------------
540        self.disable_disp = wx.RadioButton(self, wx.ID_ANY, 'Off', (10, 10),
541                                           style=wx.RB_GROUP)
542        self.enable_disp = wx.RadioButton(self, wx.ID_ANY, 'On', (10, 30))
543        # best size for MAC and PC
544        if ON_MAC:
545            size_q = (30, 20)
546        else:
547            size_q = (20, 15)
548        self.disp_help_bt = wx.Button(self, self.ID_DISPERSER_HELP, '?',
549                                      style=wx.BU_EXACTFIT,
550                                      size=size_q)
551        self.disp_help_bt.Bind(wx.EVT_BUTTON, self.on_pd_help_clicked,
552                               id=self.disp_help_bt.GetId())
553        self.disp_help_bt.SetToolTipString("Help for polydispersion.")
554
555        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,
556                  id=self.disable_disp.GetId())
557        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,
558                  id=self.enable_disp.GetId())
559        # MAC needs SetValue
560        self.disable_disp.SetValue(True)
561        sizer_dispersion = wx.BoxSizer(wx.HORIZONTAL)
562        sizer_dispersion.Add((20, 20))
563        name = ""  # Polydispersity and \nOrientational Distribution "
564        sizer_dispersion.Add(wx.StaticText(self, wx.ID_ANY, name))
565        sizer_dispersion.Add(self.enable_disp)
566        sizer_dispersion.Add((20, 20))
567        sizer_dispersion.Add(self.disable_disp)
568        sizer_dispersion.Add((25, 20))
569        sizer_dispersion.Add(self.disp_help_bt)
570
571        # fill a sizer for dispersion
572        boxsizer1.Add(sizer_dispersion, 0,
573                      wx.TOP|wx.BOTTOM|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE,
574                      border=5)
575        self.sizer4_4 = wx.GridBagSizer(6, 5)
576
577        boxsizer1.Add(self.sizer4_4)
578        # -----------------------------------------------------
579        self.sizer4.Add(boxsizer1, 0, wx.EXPAND | wx.ALL, 10)
580        self.sizer4_4.Layout()
581        self.sizer4.Layout()
582        self.Layout()
583
584        self.Refresh()
585        # saving the state of enable dispersity button
586        self.state.enable_disp = self.enable_disp.GetValue()
587        self.state.disable_disp = self.disable_disp.GetValue()
588        self.SetupScrolling()
589
590    def onResetModel(self, event):
591        """
592        Reset model state
593        """
594        menu = event.GetEventObject()
595        # post help message for the selected model
596        msg = menu.GetHelpString(event.GetId())
597        msg += " reloaded"
598        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
599        self.Show(False)
600        name = menu.GetLabel(event.GetId())
601        self._on_select_model_helper()
602        if self.model is not None:
603            self.m_name = self.model.name
604        if name in self.saved_states.keys():
605            previous_state = self.saved_states[name]
606            # reset state of checkbox,textcrtl  and  regular parameters value
607
608            self.reset_page(previous_state)
609        self.state.m_name = self.m_name
610        self.Show(True)
611
612    def on_preview(self, event):
613        """
614        Report the current fit results
615        """
616        # Get plot image from plotpanel
617        images, canvases = self.get_images()
618        # get the report dialog
619        self.state.report(images, canvases)
620
621    def on_save(self, event):
622        """
623        Save the current state into file
624        """
625        self.save_current_state()
626        new_state = self.state.clone()
627        # Ask the user the location of the file to write to.
628        path = None
629        if self.parent is not None:
630            self._default_save_location = \
631                        self._manager.parent._default_save_location
632        dlg = wx.FileDialog(self, "Choose a file", self._default_save_location,
633                            self.window_caption, "*.fitv", wx.SAVE)
634
635        if dlg.ShowModal() == wx.ID_OK:
636            path = dlg.GetPath()
637            self._default_save_location = os.path.dirname(path)
638            self._manager.parent._default_save_location = \
639                self._default_save_location
640        else:
641            return None
642        # MAC always needs the extension for saving
643        extens = ".fitv"
644        # Make sure the ext included in the file name
645        fName = os.path.splitext(path)[0] + extens
646        # the manager write the state into file
647        self._manager.save_fit_state(filepath=fName, fitstate=new_state)
648        return new_state
649
650    def on_copy(self, event):
651        """
652        Copy Parameter values to the clipboad
653        """
654        if event is not None:
655            event.Skip()
656        # It seems MAC needs wxCallAfter
657        if event.GetId() == GUIFRAME_ID.COPYEX_ID:
658            print "copy excel"
659            wx.CallAfter(self.get_copy_excel)
660        elif event.GetId() == GUIFRAME_ID.COPYLAT_ID:
661            print "copy latex"
662            wx.CallAfter(self.get_copy_latex)
663        else:
664            wx.CallAfter(self.get_copy)
665
666    def on_paste(self, event):
667        """
668        Paste Parameter values to the panel if possible
669        """
670        # if event is not None:
671        #    event.Skip()
672        # It seems MAC needs wxCallAfter for the setvalues
673        # for multiple textctrl items, otherwise it tends to crash once a while
674        wx.CallAfter(self.get_paste)
675        # messages depending on the flag
676        # self._copy_info(True)
677
678    def _copy_info(self, flag):
679        """
680        Send event depending on flag
681
682        : Param flag: flag that distinguishes the event
683        """
684        # messages depending on the flag
685        if flag is None:
686            msg = " Parameter values are copied to the clipboard..."
687            infor = 'warning'
688        elif flag:
689            msg = " Parameter values are pasted from the clipboard..."
690            infor = "warning"
691        else:
692            msg = "Error occurred: "
693            msg += "No valid parameter values to paste from the clipboard..."
694            infor = "warning"
695        # inform msg to wx
696        wx.PostEvent(self._manager.parent,
697                     StatusEvent(status=msg, info=infor))
698
699    def _get_time_stamp(self):
700        """
701        return time and date stings
702        """
703        # date and time
704        year, month, day, hour, minute, second, _, _, _ = time.localtime()
705        current_time = str(hour) + ":" + str(minute) + ":" + str(second)
706        current_date = str(month) + "/" + str(day) + "/" + str(year)
707        return current_time, current_date
708
709    def on_bookmark(self, event):
710        """
711        save history of the data and model
712        """
713        if self.model is None:
714            msg = "Can not bookmark; Please select Data and Model first..."
715            wx.MessageBox(msg, 'Info')
716            return
717        self.save_current_state()
718        new_state = self.state.clone()
719        # Add model state on context menu
720        self.number_saved_state += 1
721        current_time, current_date = self._get_time_stamp()
722        # name= self.model.name+"[%g]"%self.number_saved_state
723        name = "Fitting: %g]" % self.number_saved_state
724        name += self.model.__class__.__name__
725        name += "bookmarked at %s on %s" % (current_time, current_date)
726        self.saved_states[name] = new_state
727
728        # Add item in the context menu
729        msg = "Model saved at %s on %s" % (current_time, current_date)
730        # post help message for the selected model
731        msg += " Saved! right click on this page to retrieve this model"
732        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
733
734        self.popUpMenu.Append(self.ID_BOOKMARK, name, str(msg))
735        wx.EVT_MENU(self, self.ID_BOOKMARK, self.onResetModel)
736        wx.PostEvent(self._manager.parent,
737                     AppendBookmarkEvent(title=name,
738                                         hint=str(msg),
739                                         handler=self._back_to_bookmark))
740
741    def _back_to_bookmark(self, event):
742        """
743        Back to bookmark
744        """
745        self._manager.on_perspective(event)
746        self.onResetModel(event)
747        self._draw_model()
748
749    def onSetFocus(self, evt):
750        """
751        highlight the current textcrtl and hide the error text control shown
752        after fitting
753        """
754        return
755
756    def read_file(self, path):
757        """
758        Read two columns file
759
760        :param path: the path to the file to read
761
762        """
763        try:
764            if path is None:
765                status = " Selected Distribution was not loaded: %s" % path
766                wx.PostEvent(self._manager.parent,
767                             StatusEvent(status=status))
768                return None, None
769            input_f = open(path, 'r')
770            buff = input_f.read()
771            lines = buff.split('\n')
772            input_f.close()
773            angles = []
774            weights = []
775            for line in lines:
776                toks = line.split()
777                try:
778                    angle = float(toks[0])
779                    weight = float(toks[1])
780                    angles.append(angle)
781                    weights.append(weight)
782                except Exception:
783                    # Skip non-data lines
784                    logging.error(traceback.format_exc())
785            return numpy.array(angles), numpy.array(weights)
786        except:
787            raise
788
789    def createMemento(self):
790        """
791        return the current state of the page
792        """
793        return self.state.clone()
794
795    def save_current_state(self):
796        """
797        Store current state
798        """
799        # save model option
800        if self.model is not None:
801            self.disp_list = self.model.getDispParamList()
802            self.state.disp_list = copy.deepcopy(self.disp_list)
803            self.state.model = self.model.clone()
804
805            # model combobox: complex code because of mac's silent error
806            if self.structurebox is not None:
807                if self.structurebox.IsShown():
808                    self.state.structurecombobox = 'None'
809                    s_select = self.structurebox.GetSelection()
810                    if s_select > 0:
811                        self.state.structurecombobox = \
812                            self.structurebox.GetString(s_select)
813            if self.formfactorbox is not None:
814                f_select = self.formfactorbox.GetSelection()
815                if f_select > 0:
816                    self.state.formfactorcombobox = \
817                        self.formfactorbox.GetString(f_select)
818        if self.categorybox is not None:
819            cb_select = self.categorybox.GetSelection()
820            if cb_select > 0:
821                self.state.categorycombobox = \
822                    self.categorybox.GetString(cb_select)
823
824        self.state.enable2D = copy.deepcopy(self.enable2D)
825        self.state.values = copy.deepcopy(self.values)
826        self.state.weights = copy.deepcopy(self.weights)
827        # save data
828        self.state.data = copy.deepcopy(self.data)
829        self.state.qmax_x = self.qmax_x
830        self.state.qmin_x = self.qmin_x
831        self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
832        self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
833        self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
834        self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
835        self.state.dq_l = self.dq_l
836        self.state.dq_r = self.dq_r
837        if hasattr(self, "enable_disp"):
838            self.state.enable_disp = self.enable_disp.GetValue()
839            self.state.disable_disp = self.disable_disp.GetValue()
840
841        self.state.smearer = copy.deepcopy(self.current_smearer)
842        if hasattr(self, "enable_smearer"):
843            self.state.enable_smearer = \
844                                copy.deepcopy(self.enable_smearer.GetValue())
845            self.state.disable_smearer = \
846                                copy.deepcopy(self.disable_smearer.GetValue())
847
848        self.state.pinhole_smearer = \
849                                copy.deepcopy(self.pinhole_smearer.GetValue())
850        self.state.dx_percent = copy.deepcopy(self.dx_percent)
851        self.state.dxl = copy.deepcopy(self.dxl)
852        self.state.dxw = copy.deepcopy(self.dxw)
853        self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
854
855        if len(self._disp_obj_dict) > 0:
856            for k, v in self._disp_obj_dict.iteritems():
857                self.state._disp_obj_dict[k] = v.type
858
859            self.state.values = copy.deepcopy(self.values)
860            self.state.weights = copy.deepcopy(self.weights)
861        # save plotting range
862        self._save_plotting_range()
863
864        self.state.orientation_params = []
865        self.state.orientation_params_disp = []
866        self.state.parameters = []
867        self.state.fittable_param = []
868        self.state.fixed_param = []
869        self.state.str_parameters = []
870
871        # save checkbutton state and txtcrtl values
872        self._copy_parameters_state(self.str_parameters,
873                                    self.state.str_parameters)
874        self._copy_parameters_state(self.orientation_params,
875                                     self.state.orientation_params)
876        self._copy_parameters_state(self.orientation_params_disp,
877                                    self.state.orientation_params_disp)
878
879        self._copy_parameters_state(self.parameters, self.state.parameters)
880        self._copy_parameters_state(self.fittable_param,
881                                    self.state.fittable_param)
882        self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
883        # save chisqr
884        self.state.tcChi = self.tcChi.GetValue()
885
886    def save_current_state_fit(self):
887        """
888        Store current state for fit_page
889        """
890        # save model option
891        if self.model is not None:
892            self.disp_list = self.model.getDispParamList()
893            self.state.disp_list = copy.deepcopy(self.disp_list)
894            self.state.model = self.model.clone()
895
896        self.state.enable2D = copy.deepcopy(self.enable2D)
897        self.state.values = copy.deepcopy(self.values)
898        self.state.weights = copy.deepcopy(self.weights)
899        # save data
900        self.state.data = copy.deepcopy(self.data)
901
902        if hasattr(self, "enable_disp"):
903            self.state.enable_disp = self.enable_disp.GetValue()
904            self.state.disable_disp = self.disable_disp.GetValue()
905
906        self.state.smearer = copy.deepcopy(self.current_smearer)
907        if hasattr(self, "enable_smearer"):
908            self.state.enable_smearer = \
909                                copy.deepcopy(self.enable_smearer.GetValue())
910            self.state.disable_smearer = \
911                                copy.deepcopy(self.disable_smearer.GetValue())
912
913        self.state.pinhole_smearer = \
914                                copy.deepcopy(self.pinhole_smearer.GetValue())
915        self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
916        self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
917        self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
918        self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
919        self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
920        if hasattr(self, "disp_box") and self.disp_box is not None:
921            self.state.disp_box = self.disp_box.GetCurrentSelection()
922
923            if len(self.disp_cb_dict) > 0:
924                for k, v in self.disp_cb_dict.iteritems():
925                    if v is None:
926                        self.state.disp_cb_dict[k] = v
927                    else:
928                        try:
929                            self.state.disp_cb_dict[k] = v.GetValue()
930                        except:
931                            self.state.disp_cb_dict[k] = None
932            if len(self._disp_obj_dict) > 0:
933                for k, v in self._disp_obj_dict.iteritems():
934                    self.state._disp_obj_dict[k] = v.type
935
936            self.state.values = copy.deepcopy(self.values)
937            self.state.weights = copy.deepcopy(self.weights)
938
939        # save plotting range
940        self._save_plotting_range()
941
942        # save checkbutton state and txtcrtl values
943        self._copy_parameters_state(self.orientation_params,
944                                    self.state.orientation_params)
945        self._copy_parameters_state(self.orientation_params_disp,
946                                    self.state.orientation_params_disp)
947        self._copy_parameters_state(self.parameters, self.state.parameters)
948        self._copy_parameters_state(self.fittable_param,
949                                    self.state.fittable_param)
950        self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
951
952    def check_invalid_panel(self):
953        """
954        check if the user can already perform some action with this panel
955        """
956        if self.data is None:
957            self.disable_smearer.SetValue(True)
958            self.disable_disp.SetValue(True)
959            msg = "Please load Data and select Model to start..."
960            wx.MessageBox(msg, 'Info')
961            return True
962
963    def set_model_state(self, state):
964        """
965        reset page given a model state
966        """
967        self.disp_cb_dict = state.disp_cb_dict
968        self.disp_list = state.disp_list
969
970        # fill model combobox
971        self._show_combox_helper()
972        # select the current model
973        try:
974            # to support older version
975            category_pos = int(state.categorycombobox)
976        except:
977            category_pos = 0
978            for ind_cat in range(self.categorybox.GetCount()):
979                if self.categorycombobox.GetString(ind_cat) == \
980                                        state.categorycombobox:
981                    category_pos = int(ind_cat)
982                    break
983
984        self.categorybox.Select(category_pos)
985        try:
986            # to support older version
987            formfactor_pos = int(state.formfactorcombobox)
988        except:
989            formfactor_pos = 0
990            for ind_form in range(self.formfactorbox.GetCount()):
991                if self.formfactorbox.GetString(ind_form) == \
992                                        state.formfactorcombobox:
993                    formfactor_pos = int(ind_form)
994                    break
995
996        self.formfactorbox.Select(formfactor_pos)
997
998        try:
999            # to support older version
1000            structfactor_pos = int(state.structurecombobox)
1001        except:
1002            structfactor_pos = 0
1003            for ind_struct in range(self.structurebox.GetCount()):
1004                if self.structurebox.GetString(ind_struct) == \
1005                                        state.structurecombobox:
1006                    structfactor_pos = int(ind_struct)
1007                    break
1008
1009        self.structurebox.SetSelection(structfactor_pos)
1010
1011        if state.multi_factor is not None:
1012            self.multifactorbox.SetSelection(state.multi_factor)
1013
1014        # reset state of checkbox,textcrtl  and  regular parameters value
1015        self._reset_parameters_state(self.orientation_params_disp,
1016                                     state.orientation_params_disp)
1017        self._reset_parameters_state(self.orientation_params,
1018                                     state.orientation_params)
1019        self._reset_parameters_state(self.str_parameters,
1020                                     state.str_parameters)
1021        self._reset_parameters_state(self.parameters, state.parameters)
1022        # display dispersion info layer
1023        self.enable_disp.SetValue(state.enable_disp)
1024        self.disable_disp.SetValue(state.disable_disp)
1025
1026        if hasattr(self, "disp_box") and self.disp_box is not None:
1027            self.disp_box.SetSelection(state.disp_box)
1028            n = self.disp_box.GetCurrentSelection()
1029            dispersity = self.disp_box.GetClientData(n)
1030            name = dispersity.__name__
1031            self._set_dipers_Param(event=None)
1032
1033            if name == "ArrayDispersion":
1034
1035                for item in self.disp_cb_dict.keys():
1036
1037                    if hasattr(self.disp_cb_dict[item], "SetValue"):
1038                        self.disp_cb_dict[item].SetValue(
1039                                                    state.disp_cb_dict[item])
1040                        # Create the dispersion objects
1041                        disp_model = POLYDISPERSITY_MODELS['array']()
1042                        if hasattr(state, "values") and \
1043                                 self.disp_cb_dict[item].GetValue():
1044                            if len(state.values) > 0:
1045                                self.values = state.values
1046                                self.weights = state.weights
1047                                disp_model.set_weights(self.values,
1048                                                       state.weights)
1049                            else:
1050                                self._reset_dispersity()
1051
1052                        self._disp_obj_dict[item] = disp_model
1053                        # Set the new model as the dispersion object
1054                        # for the selected parameter
1055                        self.model.set_dispersion(item, disp_model)
1056
1057                        self.model._persistency_dict[item] = \
1058                                                [state.values, state.weights]
1059
1060            else:
1061                keys = self.model.getParamList()
1062                for item in keys:
1063                    if item in self.disp_list and \
1064                            item not in self.model.details:
1065                        self.model.details[item] = ["", None, None]
1066                self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1067                self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1068        # smearing info  restore
1069        if hasattr(self, "enable_smearer"):
1070            # set smearing value whether or not the data
1071            # contain the smearing info
1072            self.enable_smearer.SetValue(state.enable_smearer)
1073            self.disable_smearer.SetValue(state.disable_smearer)
1074            self.onSmear(event=None)
1075        self.pinhole_smearer.SetValue(state.pinhole_smearer)
1076        self.slit_smearer.SetValue(state.slit_smearer)
1077
1078        self.dI_noweight.SetValue(state.dI_noweight)
1079        self.dI_didata.SetValue(state.dI_didata)
1080        self.dI_sqrdata.SetValue(state.dI_sqrdata)
1081        self.dI_idata.SetValue(state.dI_idata)
1082
1083        # we have two more options for smearing
1084        if self.pinhole_smearer.GetValue():
1085            self.onPinholeSmear(event=None)
1086        elif self.slit_smearer.GetValue():
1087            self.onSlitSmear(event=None)
1088
1089        # reset state of checkbox,textcrtl  and dispersity parameters value
1090        self._reset_parameters_state(self.fittable_param, state.fittable_param)
1091        self._reset_parameters_state(self.fixed_param, state.fixed_param)
1092
1093        # draw the model with previous parameters value
1094        self._onparamEnter_helper()
1095        self.select_param(event=None)
1096        # Save state_fit
1097        self.save_current_state_fit()
1098        self._lay_out()
1099        self.Refresh()
1100
1101    def get_cat_combo_box_pos(self, state):
1102        """
1103        Iterate through the categories to find the structurefactor
1104        :return: combo_box_position
1105        """
1106        for key, value in self.master_category_dict.iteritems():
1107            formfactor = state.formfactorcombobox.split(":")
1108            if isinstance(formfactor, list):
1109                formfactor = formfactor[0]
1110            for list_item in value:
1111                if formfactor in list_item:
1112                    return self.categorybox.Items.index(key)
1113        return 0
1114
1115    def reset_page_helper(self, state):
1116        """
1117        Use page_state and change the state of existing page
1118
1119        :precondition: the page is already drawn or created
1120
1121        :postcondition: the state of the underlying data changes as well as the
1122            state of the graphic interface
1123        """
1124        if state is None:
1125            return
1126        # set data, etc. from the state
1127        # reset page between theory and fitting from bookmarking
1128        data = state.data
1129
1130        if data is None:
1131            data_min = state.qmin
1132            data_max = state.qmax
1133            self.qmin_x = data_min
1134            self.qmax_x = data_max
1135            self.qmin.SetValue(str(data_min))
1136            self.qmax.SetValue(str(data_max))
1137
1138            self.state.data = data
1139            self.state.qmin = self.qmin_x
1140            self.state.qmax = self.qmax_x
1141        else:
1142            self.set_data(data)
1143
1144        self.enable2D = state.enable2D
1145        try:
1146            self.magnetic_on = state.magnetic_on
1147        except:
1148            # Backward compatibility (for older state files)
1149            self.magnetic_on = False
1150
1151        self.disp_cb_dict = state.disp_cb_dict
1152        self.disp_list = state.disp_list
1153
1154        # fill model combobox
1155        self._show_combox_helper()
1156        # select the current model
1157        state._convert_to_sasmodels()
1158        state.categorycombobox = unicode(state.categorycombobox)
1159        if state.categorycombobox in self.categorybox.Items:
1160            category_pos = self.categorybox.Items.index(
1161                state.categorycombobox)
1162        else:
1163            # Look in master list for model name (model.lower)
1164            category_pos = self.get_cat_combo_box_pos(state)
1165
1166        self.categorybox.Select(category_pos)
1167        self._show_combox(None)
1168        from models import PLUGIN_NAME_BASE
1169        if self.categorybox.GetValue() == CUSTOM_MODEL \
1170                and PLUGIN_NAME_BASE not in state.formfactorcombobox:
1171            state.formfactorcombobox = \
1172                PLUGIN_NAME_BASE + state.formfactorcombobox
1173        formfactor_pos = 0
1174        for ind_form in range(self.formfactorbox.GetCount()):
1175            if self.formfactorbox.GetString(ind_form) == \
1176                                                (state.formfactorcombobox):
1177                formfactor_pos = int(ind_form)
1178                break
1179
1180        self.formfactorbox.Select(formfactor_pos)
1181
1182        structfactor_pos = 0
1183        if state.structurecombobox is not None:
1184            state.structurecombobox = unicode(state.structurecombobox)
1185            for ind_struct in range(self.structurebox.GetCount()):
1186                if self.structurebox.GetString(ind_struct) == \
1187                                                (state.structurecombobox):
1188                    structfactor_pos = int(ind_struct)
1189                    break
1190
1191        self.structurebox.SetSelection(structfactor_pos)
1192
1193        if state.multi_factor is not None:
1194            self.multifactorbox.SetSelection(state.multi_factor)
1195
1196        # draw the panel according to the new model parameter
1197        self._on_select_model(event=None)
1198
1199        # take care of 2D button
1200        if data is None and self.model_view.IsEnabled():
1201            if self.enable2D:
1202                self.model_view.SetLabel("2D Mode")
1203            else:
1204                self.model_view.SetLabel("1D Mode")
1205
1206        # reset state of checkbox,textcrtl  and  regular parameters value
1207        self._reset_parameters_state(self.orientation_params_disp,
1208                                     state.orientation_params_disp)
1209        self._reset_parameters_state(self.orientation_params,
1210                                     state.orientation_params)
1211        self._reset_parameters_state(self.str_parameters,
1212                                     state.str_parameters)
1213        self._reset_parameters_state(self.parameters, state.parameters)
1214        # display dispersion info layer
1215        self.enable_disp.SetValue(state.enable_disp)
1216        self.disable_disp.SetValue(state.disable_disp)
1217        # If the polydispersion is ON
1218        if state.enable_disp:
1219            # reset dispersion according the state
1220            self._set_dipers_Param(event=None)
1221            self._reset_page_disp_helper(state)
1222        # plotting range restore
1223        self._reset_plotting_range(state)
1224        # smearing info  restore
1225        if hasattr(self, "enable_smearer"):
1226            # set smearing value whether or not the data
1227            # contain the smearing info
1228            self.enable_smearer.SetValue(state.enable_smearer)
1229            self.disable_smearer.SetValue(state.disable_smearer)
1230            self.onSmear(event=None)
1231        self.pinhole_smearer.SetValue(state.pinhole_smearer)
1232        self.slit_smearer.SetValue(state.slit_smearer)
1233        try:
1234            self.dI_noweight.SetValue(state.dI_noweight)
1235            self.dI_didata.SetValue(state.dI_didata)
1236            self.dI_sqrdata.SetValue(state.dI_sqrdata)
1237            self.dI_idata.SetValue(state.dI_idata)
1238        except:
1239            # to support older state file formats
1240            self.dI_noweight.SetValue(False)
1241            self.dI_didata.SetValue(True)
1242            self.dI_sqrdata.SetValue(False)
1243            self.dI_idata.SetValue(False)
1244
1245        # we have two more options for smearing
1246        if self.pinhole_smearer.GetValue():
1247            self.dx_percent = state.dx_percent
1248            if self.dx_percent is not None:
1249                if state.dx_old:
1250                    self.dx_percent = 100 * (self.dx_percent / self.data.x[0])
1251                self.smear_pinhole_percent.SetValue("%.2f" % self.dx_percent)
1252            self.onPinholeSmear(event=None)
1253        elif self.slit_smearer.GetValue():
1254            self.dxl = state.dxl
1255            self.dxw = state.dxw
1256            if self.dxl is not None:
1257                self.smear_slit_height.SetValue(str(self.dxl))
1258            if self.dxw is not None:
1259                self.smear_slit_width.SetValue(str(self.dxw))
1260            else:
1261                self.smear_slit_width.SetValue('')
1262            self.onSlitSmear(event=None)
1263
1264        # reset state of checkbox,textcrtl  and dispersity parameters value
1265        self._reset_parameters_state(self.fittable_param, state.fittable_param)
1266        self._reset_parameters_state(self.fixed_param, state.fixed_param)
1267
1268        # draw the model with previous parameters value
1269        self._onparamEnter_helper()
1270        # reset the value of chisqr when not consistent with the value computed
1271        self.tcChi.SetValue(str(self.state.tcChi))
1272        # reset context menu items
1273        self._reset_context_menu()
1274
1275        # set the value of the current state to the state given as parameter
1276        self.state = state.clone()
1277        self.state.m_name = self.m_name
1278
1279    def _reset_page_disp_helper(self, state):
1280        """
1281        Help to rest page for dispersions
1282        """
1283        keys = self.model.getParamList()
1284        for item in keys:
1285            if item in self.disp_list and \
1286                            item not in self.model.details:
1287                self.model.details[item] = ["", None, None]
1288        # for k,v in self.state.disp_cb_dict.iteritems():
1289        self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1290        self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1291        self.values = copy.deepcopy(state.values)
1292        self.weights = copy.deepcopy(state.weights)
1293
1294        for key, disp_type in state._disp_obj_dict.iteritems():
1295            # disp_model = disp
1296            disp_model = POLYDISPERSITY_MODELS[disp_type]()
1297            self._disp_obj_dict[key] = disp_model
1298            param_name = key.split('.')[0]
1299            # Try to set dispersion only when available
1300            # for eg., pass the orient. angles for 1D Cal
1301            try:
1302                self.model.set_dispersion(param_name, disp_model)
1303                self.model._persistency_dict[key] = \
1304                    [state.values, state.weights]
1305            except Exception:
1306                logging.error(traceback.format_exc())
1307            selection = self._find_polyfunc_selection(disp_model)
1308            for list in self.fittable_param:
1309                if list[1] == key and list[7] is not None:
1310                    list[7].SetSelection(selection)
1311                    # For the array disp_model, set the values and weights
1312                    if selection == 1:
1313                        disp_model.set_weights(self.values[key],
1314                                               self.weights[key])
1315                        try:
1316                            # Diables all fittable params for array
1317                            list[0].SetValue(False)
1318                            list[0].Disable()
1319                            list[2].Disable()
1320                            list[5].Disable()
1321                            list[6].Disable()
1322                        except Exception:
1323                            logging.error(traceback.format_exc())
1324            # For array, disable all fixed params
1325            if selection == 1:
1326                for item in self.fixed_param:
1327                    if item[1].split(".")[0] == key.split(".")[0]:
1328                        # try it and pass it for the orientation for 1D
1329                        try:
1330                            item[2].Disable()
1331                        except Exception:
1332                            logging.error(traceback.format_exc())
1333
1334    def _selectDlg(self):
1335        """
1336        open a dialog file to select the customized polydispersity function
1337        """
1338        if self.parent is not None:
1339            self._default_save_location = \
1340                        self._manager.parent.get_save_location()
1341        dlg = wx.FileDialog(self, "Choose a weight file",
1342                            self._default_save_location, "",
1343                            "*.*", wx.OPEN)
1344        path = None
1345        if dlg.ShowModal() == wx.ID_OK:
1346            path = dlg.GetPath()
1347        dlg.Destroy()
1348        return path
1349
1350    def _reset_context_menu(self):
1351        """
1352        reset the context menu
1353        """
1354        ids = iter(self._id_pool)  # Reusing ids for context menu
1355        for name, _ in self.state.saved_states.iteritems():
1356            self.number_saved_state += 1
1357            # Add item in the context menu
1358            wx_id = ids.next()
1359            msg = 'Save model and state %g' % self.number_saved_state
1360            self.popUpMenu.Append(wx_id, name, msg)
1361            wx.EVT_MENU(self, wx_id, self.onResetModel)
1362
1363    def _reset_plotting_range(self, state):
1364        """
1365        Reset the plotting range to a given state
1366        """
1367        self.qmin.SetValue(str(state.qmin))
1368        self.qmax.SetValue(str(state.qmax))
1369
1370    def _save_typeOfmodel(self):
1371        """
1372        save radiobutton containing the type model that can be selected
1373        """
1374        # self.state.shape_rbutton = self.shape_rbutton.GetValue()
1375        # self.state.shape_indep_rbutton = self.shape_indep_rbutton.GetValue()
1376        # self.state.struct_rbutton = self.struct_rbutton.GetValue()
1377        # self.state.plugin_rbutton = self.plugin_rbutton.GetValue()
1378        self.state.structurecombobox = self.structurebox.GetValue()
1379        self.state.formfactorcombobox = self.formfactorbox.GetValue()
1380        self.state.categorycombobox = self.categorybox.GetValue()
1381
1382        # post state to fit panel
1383        event = PageInfoEvent(page=self)
1384        wx.PostEvent(self.parent, event)
1385
1386    def _save_plotting_range(self):
1387        """
1388        save the state of plotting range
1389        """
1390        self.state.qmin = self.qmin_x
1391        self.state.qmax = self.qmax_x
1392        self.state.npts = self.npts_x
1393
1394    def _onparamEnter_helper(self, is_modified=False):
1395        """
1396        check if values entered by the user are changed and valid to replot
1397        model
1398        """
1399        # Flag to register when a parameter has changed.
1400        # is_modified = False
1401        self.fitrange = True
1402        is_2Ddata = False
1403        # self._undo.Enable(True)
1404        # check if 2d data
1405        if self.data.__class__.__name__ == "Data2D":
1406            is_2Ddata = True
1407        if self.model is not None:
1408            # Either we get a is_modified = True passed in because
1409            # _update_paramv_on_fit() has been called already or
1410            # we need to check here ourselves.
1411            if not is_modified:
1412                is_modified = (self._check_value_enter(self.fittable_param)
1413                               or self._check_value_enter(self.fixed_param)
1414                               or self._check_value_enter(self.parameters))
1415
1416            # Here we should check whether the boundaries have been modified.
1417            # If qmin and qmax have been modified, update qmin and qmax and
1418            # set the is_modified flag to True
1419            if self._validate_qrange(self.qmin, self.qmax):
1420                tempmin = float(self.qmin.GetValue())
1421                if tempmin != self.qmin_x:
1422                    self.qmin_x = tempmin
1423                    is_modified = True
1424                tempmax = float(self.qmax.GetValue())
1425                if tempmax != self.qmax_x:
1426                    self.qmax_x = tempmax
1427                    is_modified = True
1428                if is_2Ddata:
1429                    is_modified = self._validate_Npts()
1430                else:
1431                    is_modified = self._validate_Npts_1D()
1432            else:
1433                self.fitrange = False
1434
1435            # if any value is modify draw model with new value
1436            if not self.fitrange:
1437                # self.btFit.Disable()
1438                if is_2Ddata:
1439                    self.btEditMask.Disable()
1440            else:
1441                if is_2Ddata and self.data.is_data and not self.batch_on:
1442                    self.btEditMask.Enable(True)
1443            if is_modified and self.fitrange:
1444                # Theory case: need to get npts value to draw
1445                self.npts_x = float(self.Npts_total.GetValue())
1446                self.Npts_fit.SetValue(str(self.Npts_total.GetValue()))
1447                self._save_plotting_range()
1448                self.create_default_data()
1449                self.state_change = True
1450                self._draw_model()
1451                self.Refresh()
1452
1453        # logging.info("is_modified flag set to %g",is_modified)
1454        return is_modified
1455
1456    def _update_paramv_on_fit(self):
1457        """
1458        make sure that update param values just before the fitting
1459        """
1460        # flag for qmin qmax check values
1461        flag = True
1462        self.fitrange = True
1463        is_modified = False
1464
1465        # wx.PostEvent(self._manager.parent, StatusEvent(status=" \
1466        # updating ... ",type="update"))
1467
1468        # So make sure that update param values on_Fit.
1469        # self._undo.Enable(True)
1470        if self.model is not None:
1471            if self.Npts_total.GetValue() != self.Npts_fit.GetValue():
1472                if not self.data.is_data:
1473                    self._manager.page_finder[self.uid].set_fit_data(
1474                        data=[self.data])
1475            # Check the values
1476            is_modified = (self._check_value_enter(self.fittable_param)
1477                           or self._check_value_enter(self.fixed_param)
1478                           or self._check_value_enter(self.parameters))
1479
1480            # If qmin and qmax have been modified, update qmin and qmax and
1481            # Here we should check whether the boundaries have been modified.
1482            # If qmin and qmax have been modified, update qmin and qmax and
1483            # set the is_modified flag to True
1484            self.fitrange = self._validate_qrange(self.qmin, self.qmax)
1485            if self.fitrange:
1486                tempmin = float(self.qmin.GetValue())
1487                if tempmin != self.qmin_x:
1488                    self.qmin_x = tempmin
1489                tempmax = float(self.qmax.GetValue())
1490                if tempmax != self.qmax_x:
1491                    self.qmax_x = tempmax
1492                if tempmax == tempmin:
1493                    flag = False
1494                temp_smearer = None
1495                if not self.disable_smearer.GetValue():
1496                    temp_smearer = self.current_smearer
1497                    if self.slit_smearer.GetValue():
1498                        flag = self.update_slit_smear()
1499                    elif self.pinhole_smearer.GetValue():
1500                        flag = self.update_pinhole_smear()
1501                    else:
1502                        enable_smearer = not self.disable_smearer.GetValue()
1503                        self._manager.set_smearer(smearer=temp_smearer,
1504                                                  uid=self.uid,
1505                                                  fid=self.data.id,
1506                                                  qmin=float(self.qmin_x),
1507                                                  qmax=float(self.qmax_x),
1508                                                  enable_smearer=enable_smearer,
1509                                                  draw=False)
1510                elif not self._is_2D():
1511                    enable_smearer = not self.disable_smearer.GetValue()
1512                    self._manager.set_smearer(smearer=temp_smearer,
1513                                              qmin=float(self.qmin_x),
1514                                              uid=self.uid,
1515                                              fid=self.data.id,
1516                                              qmax=float(self.qmax_x),
1517                                              enable_smearer=enable_smearer,
1518                                              draw=False)
1519                    if self.data is not None:
1520                        index_data = ((self.qmin_x <= self.data.x) &
1521                                      (self.data.x <= self.qmax_x))
1522                        val = str(len(self.data.x[index_data]))
1523                        self.Npts_fit.SetValue(val)
1524                    else:
1525                        # No data in the panel
1526                        try:
1527                            self.npts_x = float(self.Npts_total.GetValue())
1528                        except:
1529                            flag = False
1530                            return flag
1531                    flag = True
1532                if self._is_2D():
1533                    # only 2D case set mask
1534                    flag = self._validate_Npts()
1535                    if not flag:
1536                        return flag
1537            else:
1538                flag = False
1539        else:
1540            flag = False
1541
1542        # For invalid q range, disable the mask editor and fit button, vs.
1543        if not self.fitrange:
1544            if self._is_2D():
1545                self.btEditMask.Disable()
1546        else:
1547            if self._is_2D() and self.data.is_data and not self.batch_on:
1548                self.btEditMask.Enable(True)
1549
1550        if not flag:
1551            msg = "Cannot Plot or Fit :Must select a "
1552            msg += " model or Fitting range is not valid!!!  "
1553            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1554
1555        try:
1556            self.save_current_state()
1557        except Exception:
1558            logging.error(traceback.format_exc())
1559
1560        return flag, is_modified
1561
1562    def _reset_parameters_state(self, listtorestore, statelist):
1563        """
1564        Reset the parameters at the given state
1565        """
1566        if len(statelist) == 0 or len(listtorestore) == 0:
1567            return
1568
1569        for j in range(len(listtorestore)):
1570            for param in statelist:
1571                if param[1] == listtorestore[j][1]:
1572                    item_page = listtorestore[j]
1573                    item_page_info = param
1574                    if (item_page_info[1] == "theta" or item_page_info[1] ==
1575                            "phi") and not self._is_2D():
1576                        break
1577                    # change the state of the check box for simple parameters
1578                    if item_page[0] is not None:
1579                        item_page[0].SetValue(item_page_info[0])
1580                    if item_page[2] is not None:
1581                        item_page[2].SetValue(item_page_info[2])
1582                        if item_page[2].__class__.__name__ == "ComboBox":
1583                            if item_page_info[2] in self.model.fun_list:
1584                                fun_val = self.model.fun_list[item_page_info[2]]
1585                                self.model.setParam(item_page_info[1], fun_val)
1586                    if item_page[3] is not None:
1587                        # show or hide text +/-
1588                        if item_page_info[2]:
1589                            item_page[3].Show(True)
1590                        else:
1591                            item_page[3].Hide()
1592                    if item_page[4] is not None:
1593                        # show of hide the text crtl for fitting error
1594                        if item_page_info[4][0]:
1595                            item_page[4].Show(True)
1596                            item_page[4].SetValue(str(item_page_info[4][1]))
1597                        else:
1598                            item_page[3].Hide()
1599                    if item_page[5] is not None:
1600                        # show of hide the text crtl for fitting error
1601                        item_page[5].Show(True)
1602                        item_page[5].SetValue(str(item_page_info[5][1]))
1603                    if item_page[6] is not None:
1604                        # show of hide the text crtl for fitting error
1605                        item_page[6].Show(True)
1606                        item_page[6].SetValue(str(item_page_info[6][1]))
1607                    break
1608
1609    def _reset_strparam_state(self, listtorestore, statelist):
1610        """
1611        Reset the string parameters at the given state
1612        """
1613        if len(statelist) == 0:
1614            return
1615
1616        listtorestore = copy.deepcopy(statelist)
1617
1618        for j in range(len(listtorestore)):
1619            item_page = listtorestore[j]
1620            item_page_info = statelist[j]
1621            # change the state of the check box for simple parameters
1622
1623            if item_page[0] is not None:
1624                item_page[0].SetValue(format_number(item_page_info[0], True))
1625
1626            if item_page[2] is not None:
1627                param_name = item_page_info[1]
1628                value = item_page_info[2]
1629                selection = value
1630                if value in self.model.fun_list:
1631                    selection = self.model.fun_list[value]
1632                item_page[2].SetValue(selection)
1633                self.model.setParam(param_name, selection)
1634
1635    def _copy_parameters_state(self, listtocopy, statelist):
1636        """
1637        copy the state of button
1638
1639        :param listtocopy: the list of check button to copy
1640        :param statelist: list of state object to store the current state
1641
1642        """
1643        if len(listtocopy) == 0:
1644            return
1645
1646        for item in listtocopy:
1647
1648            checkbox_state = None
1649            if item[0] is not None:
1650                checkbox_state = item[0].GetValue()
1651            parameter_name = item[1]
1652            parameter_value = None
1653            if item[2] is not None:
1654                parameter_value = item[2].GetValue()
1655            static_text = None
1656            if item[3] is not None:
1657                static_text = item[3].IsShown()
1658            error_value = None
1659            error_state = None
1660            if item[4] is not None:
1661                error_value = item[4].GetValue()
1662                error_state = item[4].IsShown()
1663
1664            min_value = None
1665            min_state = None
1666            if item[5] is not None:
1667                min_value = item[5].GetValue()
1668                min_state = item[5].IsShown()
1669
1670            max_value = None
1671            max_state = None
1672            if item[6] is not None:
1673                max_value = item[6].GetValue()
1674                max_state = item[6].IsShown()
1675            unit = None
1676            if item[7] is not None:
1677                unit = item[7].GetLabel()
1678
1679            statelist.append([checkbox_state, parameter_name, parameter_value,
1680                              static_text, [error_state, error_value],
1681                              [min_state, min_value],
1682                              [max_state, max_value], unit])
1683
1684    def _draw_model(self, update_chisqr=True, source='model'):
1685        """
1686        Method to draw or refresh a plotted model.
1687        The method will use the data member from the model page
1688        to build a call to the fitting perspective manager.
1689
1690        :param chisqr: update chisqr value [bool]
1691        """
1692        wx.CallAfter(self._draw_model_after, update_chisqr, source)
1693
1694    def _draw_model_after(self, update_chisqr=True, source='model'):
1695        """
1696        Method to draw or refresh a plotted model.
1697        The method will use the data member from the model page
1698        to build a call to the fitting perspective manager.
1699
1700        :param chisqr: update chisqr value [bool]
1701        """
1702        # if self.check_invalid_panel():
1703        #    return
1704        if self.model is not None:
1705            temp_smear = None
1706            if hasattr(self, "enable_smearer"):
1707                if not self.disable_smearer.GetValue():
1708                    temp_smear = self.current_smearer
1709            # compute weight for the current data
1710            from sas.sasgui.perspectives.fitting.utils import get_weight
1711            flag = self.get_weight_flag()
1712            weight = get_weight(data=self.data, is2d=self._is_2D(), flag=flag)
1713            toggle_mode_on = self.model_view.IsEnabled()
1714            is_2d = self._is_2D()
1715            self._manager.draw_model(self.model,
1716                                     data=self.data,
1717                                     smearer=temp_smear,
1718                                     qmin=float(self.qmin_x),
1719                                     qmax=float(self.qmax_x),
1720                                     page_id=self.uid,
1721                                     toggle_mode_on=toggle_mode_on,
1722                                     state=self.state,
1723                                     enable2D=is_2d,
1724                                     update_chisqr=update_chisqr,
1725                                     source='model',
1726                                     weight=weight)
1727
1728    def _on_show_sld(self, event=None):
1729        """
1730        Plot SLD profile
1731        """
1732        # get profile data
1733        x, y = self.model.getProfile()
1734
1735        from sas.sasgui.plottools import Data1D as pf_data1d
1736        # from sas.sasgui.perspectives.theory.profile_dialog import SLDPanel
1737        from sas.sasgui.guiframe.local_perspectives.plotting.profile_dialog \
1738            import SLDPanel
1739        sld_data = pf_data1d(x, y)
1740        sld_data.name = 'SLD'
1741        sld_data.axes = self.sld_axes
1742        self.panel = SLDPanel(self, data=sld_data, axes=self.sld_axes,
1743                              id=wx.ID_ANY)
1744        self.panel.ShowModal()
1745
1746    def _set_multfactor_combobox(self, multiplicity=10):
1747        """
1748        Set comboBox for multitfactor of CoreMultiShellModel
1749        :param multiplicit: no. of multi-functionality
1750        """
1751        # build content of the combobox
1752        for idx in range(0, multiplicity):
1753            self.multifactorbox.Append(str(idx), int(idx))
1754        self._hide_multfactor_combobox()
1755
1756    def _show_multfactor_combobox(self):
1757        """
1758        Show the comboBox of muitfactor of CoreMultiShellModel
1759        """
1760        if not self.mutifactor_text.IsShown():
1761            self.mutifactor_text.Show(True)
1762            self.mutifactor_text1.Show(True)
1763        if not self.multifactorbox.IsShown():
1764            self.multifactorbox.Show(True)
1765
1766    def _hide_multfactor_combobox(self):
1767        """
1768        Hide the comboBox of muitfactor of CoreMultiShellModel
1769        """
1770        if self.mutifactor_text.IsShown():
1771            self.mutifactor_text.Hide()
1772            self.mutifactor_text1.Hide()
1773        if self.multifactorbox.IsShown():
1774            self.multifactorbox.Hide()
1775
1776    def formfactor_combo_init(self):
1777        """
1778        First time calls _show_combox_helper
1779        """
1780        self._show_combox(None)
1781
1782    def _show_combox_helper(self):
1783        """
1784        Fill panel's combo box according to the type of model selected
1785        """
1786
1787        mod_cat = self.categorybox.GetStringSelection()
1788        self.structurebox.SetSelection(0)
1789        self.structurebox.Disable()
1790        self.formfactorbox.Clear()
1791        if mod_cat is None:
1792            return
1793        m_list = []
1794        try:
1795            if mod_cat == CUSTOM_MODEL:
1796                for model in self.model_list_box[mod_cat]:
1797                    m_list.append(self.model_dict[model.name])
1798            else:
1799                cat_dic = self.master_category_dict[mod_cat]
1800                for (model, enabled) in cat_dic:
1801                    if enabled:
1802                        m_list.append(self.model_dict[model])
1803        except Exception:
1804            msg = traceback.format_exc()
1805            wx.PostEvent(self._manager.parent,
1806                         StatusEvent(status=msg, info="error"))
1807        self._populate_box(self.formfactorbox, m_list)
1808
1809    def _on_modify_cat(self, event=None):
1810        """
1811        Called when category manager is opened
1812        """
1813        self._manager.parent.on_category_panel(event)
1814
1815    def _show_combox(self, event=None):
1816        """
1817        Show combox box associate with type of model selected
1818        """
1819        self.Show(False)
1820        self._show_combox_helper()
1821        self._on_select_model(event=None)
1822        self.Show(True)
1823        self._save_typeOfmodel()
1824        self.sizer4_4.Layout()
1825        self.sizer4.Layout()
1826        self.Layout()
1827        self.Refresh()
1828
1829    def _populate_box(self, combobox, list):
1830        """
1831        fill combox box with dict item
1832
1833        :param list: contains item to fill the combox
1834            item must model class
1835        """
1836        mlist = []
1837        for models in list:
1838            if models.name != "NoStructure":
1839                mlist.append((models.name, models))
1840
1841        # Sort the models
1842        mlist_sorted = sorted(mlist)
1843        for item in mlist_sorted:
1844            combobox.Append(item[0], item[1])
1845        return 0
1846
1847    def _onQrangeEnter(self, event):
1848        """
1849        Check validity of value enter in the Q range field
1850
1851        """
1852        tcrtl = event.GetEventObject()
1853        # Clear msg if previously shown.
1854        msg = ""
1855        wx.PostEvent(self.parent, StatusEvent(status=msg))
1856        # Flag to register when a parameter has changed.
1857        if tcrtl.GetValue().lstrip().rstrip() != "":
1858            try:
1859                float(tcrtl.GetValue())
1860                tcrtl.SetBackgroundColour(wx.WHITE)
1861                # If qmin and qmax have been modified, update qmin and qmax
1862                if self._validate_qrange(self.qmin, self.qmax):
1863                    tempmin = float(self.qmin.GetValue())
1864                    if tempmin != self.qmin_x:
1865                        self.qmin_x = tempmin
1866                    tempmax = float(self.qmax.GetValue())
1867                    if tempmax != self.qmax_x:
1868                        self.qmax_x = tempmax
1869                else:
1870                    tcrtl.SetBackgroundColour("pink")
1871                    msg = "Model Error: wrong value entered: %s" % \
1872                          sys.exc_info()[1]
1873                    wx.PostEvent(self.parent, StatusEvent(status=msg))
1874                    return
1875            except:
1876                tcrtl.SetBackgroundColour("pink")
1877                msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
1878                wx.PostEvent(self.parent, StatusEvent(status=msg))
1879                return
1880            # Check if # of points for theory model are valid(>0).
1881            if self.npts is not None:
1882                if check_float(self.npts):
1883                    temp_npts = float(self.npts.GetValue())
1884                    if temp_npts != self.num_points:
1885                        self.num_points = temp_npts
1886                else:
1887                    msg = "Cannot plot: No points in Q range!!!  "
1888                    wx.PostEvent(self.parent, StatusEvent(status=msg))
1889        else:
1890            tcrtl.SetBackgroundColour("pink")
1891            msg = "Model Error: wrong value entered!!!"
1892            wx.PostEvent(self.parent, StatusEvent(status=msg))
1893        self.save_current_state()
1894        event = PageInfoEvent(page=self)
1895        wx.PostEvent(self.parent, event)
1896        self.state_change = False
1897        # Draw the model for a different range
1898        if not self.data.is_data:
1899            self.create_default_data()
1900        self._draw_model()
1901
1902    def _theory_qrange_enter(self, event):
1903        """
1904        Check validity of value enter in the Q range field
1905        """
1906
1907        tcrtl = event.GetEventObject()
1908        # Clear msg if previously shown.
1909        msg = ""
1910        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1911        # Flag to register when a parameter has changed.
1912        is_modified = False
1913        if tcrtl.GetValue().lstrip().rstrip() != "":
1914            try:
1915                value = float(tcrtl.GetValue())
1916                tcrtl.SetBackgroundColour(wx.WHITE)
1917
1918                # If qmin and qmax have been modified, update qmin and qmax
1919                if self._validate_qrange(self.theory_qmin, self.theory_qmax):
1920                    tempmin = float(self.theory_qmin.GetValue())
1921                    if tempmin != self.theory_qmin_x:
1922                        self.theory_qmin_x = tempmin
1923                    tempmax = float(self.theory_qmax.GetValue())
1924                    if tempmax != self.qmax_x:
1925                        self.theory_qmax_x = tempmax
1926                else:
1927                    tcrtl.SetBackgroundColour("pink")
1928                    msg = "Model Error: wrong value entered: %s" % \
1929                          sys.exc_info()[1]
1930                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1931                    return
1932            except:
1933                tcrtl.SetBackgroundColour("pink")
1934                msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
1935                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1936                return
1937            # Check if # of points for theory model are valid(>0).
1938            if self.Npts_total.IsEditable():
1939                if check_float(self.Npts_total):
1940                    temp_npts = float(self.Npts_total.GetValue())
1941                    if temp_npts != self.num_points:
1942                        self.num_points = temp_npts
1943                        is_modified = True
1944                else:
1945                    msg = "Cannot Plot: No points in Q range!!!  "
1946                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1947        else:
1948            tcrtl.SetBackgroundColour("pink")
1949            msg = "Model Error: wrong value entered!!!"
1950            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1951        self.save_current_state()
1952        event = PageInfoEvent(page=self)
1953        wx.PostEvent(self.parent, event)
1954        self.state_change = False
1955        # Draw the model for a different range
1956        self.create_default_data()
1957        self._draw_model()
1958
1959    def _on_select_model_helper(self):
1960        """
1961        call back for model selection
1962        """
1963        # reset dictionary containing reference to dispersion
1964        self._disp_obj_dict = {}
1965        self.disp_cb_dict = {}
1966        self.temp_multi_functional = False
1967        f_id = self.formfactorbox.GetCurrentSelection()
1968        # For MAC
1969        form_factor = None
1970        if f_id >= 0:
1971            form_factor = self.formfactorbox.GetClientData(f_id)
1972
1973        if form_factor is None or \
1974            not hasattr(form_factor, 'is_form_factor') or \
1975                not form_factor.is_form_factor:
1976            self.structurebox.Hide()
1977            self.text2.Hide()
1978            self.structurebox.Disable()
1979            self.structurebox.SetSelection(0)
1980            self.text2.Disable()
1981        else:
1982            self.structurebox.Show()
1983            self.text2.Show()
1984            self.structurebox.Enable()
1985            self.text2.Enable()
1986
1987        if form_factor is not None:
1988            # set multifactor for Mutifunctional models
1989            if form_factor.is_multiplicity_model:
1990                m_id = self.multifactorbox.GetCurrentSelection()
1991                multiplicity = form_factor.multiplicity_info[0]
1992                self.multifactorbox.Clear()
1993                self._set_multfactor_combobox(multiplicity)
1994                self._show_multfactor_combobox()
1995                # ToDo: this info should be called directly from the model
1996                text = form_factor.multiplicity_info[1]  # 'No. of Shells: '
1997
1998                self.mutifactor_text.SetLabel(text)
1999                if m_id > multiplicity - 1:
2000                    # default value
2001                    m_id = 1
2002
2003                self.multi_factor = self.multifactorbox.GetClientData(m_id)
2004                if self.multi_factor is None:
2005                    self.multi_factor = 0
2006                self.multifactorbox.SetSelection(m_id)
2007                # Check len of the text1 and max_multiplicity
2008                text = ''
2009                if form_factor.multiplicity_info[0] == \
2010                        len(form_factor.multiplicity_info[2]):
2011                    text = form_factor.multiplicity_info[2][self.multi_factor]
2012                self.mutifactor_text1.SetLabel(text)
2013                # Check if model has  get sld profile.
2014                if len(form_factor.multiplicity_info[3]) > 0:
2015                    self.sld_axes = form_factor.multiplicity_info[3]
2016                    self.show_sld_button.Show(True)
2017                else:
2018                    self.sld_axes = ""
2019            else:
2020                self._hide_multfactor_combobox()
2021                self.show_sld_button.Hide()
2022                self.multi_factor = None
2023        else:
2024            self._hide_multfactor_combobox()
2025            self.show_sld_button.Hide()
2026            self.multi_factor = None
2027
2028        s_id = self.structurebox.GetCurrentSelection()
2029        struct_factor = self.structurebox.GetClientData(s_id)
2030
2031        if struct_factor is not None:
2032            from sasmodels.sasview_model import MultiplicationModel
2033            self.model = MultiplicationModel(form_factor(self.multi_factor),
2034                                             struct_factor())
2035            # multifunctional form factor
2036            if len(form_factor.non_fittable) > 0:
2037                self.temp_multi_functional = True
2038        elif form_factor is not None:
2039            if self.multi_factor is not None:
2040                self.model = form_factor(self.multi_factor)
2041            else:
2042                # old style plugin models do not accept a multiplicity argument
2043                self.model = form_factor()
2044        else:
2045            self.model = None
2046            return
2047
2048        # check if model has magnetic parameters
2049        if len(self.model.magnetic_params) > 0:
2050            self._has_magnetic = True
2051        else:
2052            self._has_magnetic = False
2053        # post state to fit panel
2054        self.state.parameters = []
2055        self.state.model = self.model
2056        self.state.qmin = self.qmin_x
2057        self.state.multi_factor = self.multi_factor
2058        self.disp_list = self.model.getDispParamList()
2059        self.state.disp_list = self.disp_list
2060        self.on_set_focus(None)
2061        self.Layout()
2062
2063    def _validate_qrange(self, qmin_ctrl, qmax_ctrl):
2064        """
2065        Verify that the Q range controls have valid values
2066        and that Qmin < Qmax.
2067
2068        :param qmin_ctrl: text control for Qmin
2069        :param qmax_ctrl: text control for Qmax
2070
2071        :return: True is the Q range is value, False otherwise
2072
2073        """
2074        qmin_validity = check_float(qmin_ctrl)
2075        qmax_validity = check_float(qmax_ctrl)
2076        if not (qmin_validity and qmax_validity):
2077            return False
2078        else:
2079            qmin = float(qmin_ctrl.GetValue())
2080            qmax = float(qmax_ctrl.GetValue())
2081            if qmin < qmax:
2082                # Make sure to set both colours white.
2083                qmin_ctrl.SetBackgroundColour(wx.WHITE)
2084                qmin_ctrl.Refresh()
2085                qmax_ctrl.SetBackgroundColour(wx.WHITE)
2086                qmax_ctrl.Refresh()
2087            else:
2088                qmin_ctrl.SetBackgroundColour("pink")
2089                qmin_ctrl.Refresh()
2090                qmax_ctrl.SetBackgroundColour("pink")
2091                qmax_ctrl.Refresh()
2092                msg = "Invalid Q range: Q min must be smaller than Q max"
2093                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2094                return False
2095        return True
2096
2097    def _validate_Npts(self):
2098        """
2099        Validate the number of points for fitting is more than 10 points.
2100        If valid, setvalues Npts_fit otherwise post msg.
2101        """
2102        # default flag
2103        flag = True
2104        # Theory
2105        if self.data is None and self.enable2D:
2106            return flag
2107        for data in self.data_list:
2108            # q value from qx and qy
2109            radius = numpy.sqrt(data.qx_data * data.qx_data +
2110                                data.qy_data * data.qy_data)
2111            # get unmasked index
2112            index_data = (float(self.qmin.GetValue()) <= radius) & \
2113                         (radius <= float(self.qmax.GetValue()))
2114            index_data = (index_data) & (data.mask)
2115            index_data = (index_data) & (numpy.isfinite(data.data))
2116
2117            if len(index_data[index_data]) < 10:
2118                # change the color pink.
2119                self.qmin.SetBackgroundColour("pink")
2120                self.qmin.Refresh()
2121                self.qmax.SetBackgroundColour("pink")
2122                self.qmax.Refresh()
2123                msg = "Data Error: "
2124                msg += "Too few points in %s." % data.name
2125                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2126                self.fitrange = False
2127                flag = False
2128            else:
2129                self.Npts_fit.SetValue(str(len(index_data[index_data])))
2130                self.fitrange = True
2131
2132        return flag
2133
2134    def _validate_Npts_1D(self):
2135        """
2136        Validate the number of points for fitting is more than 5 points.
2137        If valid, setvalues Npts_fit otherwise post msg.
2138        """
2139        # default flag
2140        flag = True
2141        # Theory
2142        if self.data is None:
2143            return flag
2144        for data in self.data_list:
2145            # q value from qx and qy
2146            radius = data.x
2147            # get unmasked index
2148            index_data = (float(self.qmin.GetValue()) <= radius) & \
2149                         (radius <= float(self.qmax.GetValue()))
2150            index_data = (index_data) & (numpy.isfinite(data.y))
2151
2152            if len(index_data[index_data]) < 5:
2153                # change the color pink.
2154                self.qmin.SetBackgroundColour("pink")
2155                self.qmin.Refresh()
2156                self.qmax.SetBackgroundColour("pink")
2157                self.qmax.Refresh()
2158                msg = "Data Error: "
2159                msg += "Too few points in %s." % data.name
2160                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2161                self.fitrange = False
2162                flag = False
2163            else:
2164                self.Npts_fit.SetValue(str(len(index_data[index_data])))
2165                self.fitrange = True
2166
2167        return flag
2168
2169    def _check_value_enter(self, list):
2170        """
2171        :param list: model parameter and panel info
2172        :Note: each item of the list should be as follow:
2173            item=[check button state, parameter's name,
2174                paramater's value, string="+/-",
2175                parameter's error of fit,
2176                parameter's minimum value,
2177                parameter's maximum value ,
2178                parameter's units]
2179
2180        Returns True if the model parameters have changed.
2181        """
2182        is_modified = False
2183        for item in list:
2184            # skip angle parameters for 1D
2185            if not self.enable2D and item in self.orientation_params:
2186                continue
2187
2188            value_ctrl = item[2]
2189            if not value_ctrl.IsEnabled():
2190                # ArrayDispersion disables PD, Min, Max, Npts, Nsigs
2191                continue
2192
2193            name = item[1]
2194            value_str = value_ctrl.GetValue().strip()
2195            if name.endswith(".npts"):
2196                validity = check_int(value_ctrl)
2197                if not validity:
2198                    continue
2199                value = int(value_str)
2200
2201            elif name.endswith(".nsigmas"):
2202                validity = check_float(value_ctrl)
2203                if not validity:
2204                    continue
2205                value = float(value_str)
2206
2207            else:  # value or polydispersity
2208
2209                # Check that min, max and value are floats
2210                min_ctrl, max_ctrl = item[5], item[6]
2211                min_str = min_ctrl.GetValue().strip()
2212                max_str = max_ctrl.GetValue().strip()
2213                validity = check_float(value_ctrl)
2214                if min_str != "":
2215                    validity = validity and check_float(min_ctrl)
2216                if max_str != "":
2217                    validity = validity and check_float(max_ctrl)
2218                if not validity:
2219                    continue
2220
2221                # Check that min is less than max
2222                low = -numpy.inf if min_str == "" else float(min_str)
2223                high = numpy.inf if max_str == "" else float(max_str)
2224                if high < low:
2225                    min_ctrl.SetBackgroundColour("pink")
2226                    min_ctrl.Refresh()
2227                    max_ctrl.SetBackgroundColour("pink")
2228                    max_ctrl.Refresh()
2229                    # msg = "Invalid fit range for %s: min must be smaller
2230                    # than max"%name
2231                    # wx.PostEvent(self._manager.parent,
2232                    # StatusEvent(status=msg))
2233                    continue
2234
2235                # Force value between min and max
2236                value = float(value_str)
2237                if value < low:
2238                    value = low
2239                    value_ctrl.SetValue(format_number(value))
2240                elif value > high:
2241                    value = high
2242                    value_ctrl.SetValue(format_number(value))
2243
2244                if name not in self.model.details.keys():
2245                    self.model.details[name] = ["", None, None]
2246                old_low, old_high = self.model.details[name][1:3]
2247                if old_low != low or old_high != high:
2248                    # The configuration has changed but it won't change the
2249                    # computed curve so no need to set is_modified to True
2250                    # is_modified = True
2251                    self.model.details[name][1:3] = low, high
2252
2253            # Update value in model if it has changed
2254            if value != self.model.getParam(name):
2255                self.model.setParam(name, value)
2256                is_modified = True
2257
2258        return is_modified
2259
2260    def _set_dipers_Param(self, event):
2261        """
2262        respond to self.enable_disp and self.disable_disp radio box.
2263        The dispersity object is reset inside the model into Gaussian.
2264        When the user select yes , this method display a combo box for
2265        more selection when the user selects No,the combo box disappears.
2266        Redraw the model with the default dispersity (Gaussian)
2267        """
2268        # On selction if no model exists.
2269        if self.model is None:
2270            self.disable_disp.SetValue(True)
2271            msg = "Please select a Model first..."
2272            wx.MessageBox(msg, 'Info')
2273            wx.PostEvent(self._manager.parent,
2274                         StatusEvent(status="Polydispersion: %s" % msg))
2275            return
2276
2277        self._reset_dispersity()
2278
2279        if self.model is None:
2280            self.model_disp.Hide()
2281            self.sizer4_4.Clear(True)
2282            return
2283
2284        if self.enable_disp.GetValue():
2285            # layout for model containing no dispersity parameters
2286
2287            self.disp_list = self.model.getDispParamList()
2288
2289            if len(self.disp_list) == 0 and len(self.disp_cb_dict) == 0:
2290                self._layout_sizer_noDipers()
2291            else:
2292                # set gaussian sizer
2293                self._on_select_Disp(event=None)
2294        else:
2295            self.sizer4_4.Clear(True)
2296
2297        # post state to fit panel
2298        self.save_current_state()
2299        if event is not None:
2300            event = PageInfoEvent(page=self)
2301            wx.PostEvent(self.parent, event)
2302        # draw the model with the current dispersity
2303
2304        # Wojtek P, Oct 8, 2016: Calling draw_model seems to be unessecary.
2305        # By comenting it we save an extra Iq calculation
2306        # self._draw_model()
2307
2308        # Need to use FitInside again here to replace the next four lines.
2309        # Otherwised polydispersity off does not resize the scrollwindow.
2310        # PDB Nov 28, 2015
2311        self.FitInside()
2312#        self.sizer4_4.Layout()
2313#        self.sizer5.Layout()
2314#        self.Layout()
2315#        self.Refresh()
2316
2317    def _layout_sizer_noDipers(self):
2318        """
2319        Draw a sizer with no dispersity info
2320        """
2321        ix = 0
2322        iy = 1
2323        self.fittable_param = []
2324        self.fixed_param = []
2325        self.orientation_params_disp = []
2326
2327        self.sizer4_4.Clear(True)
2328        text = "No polydispersity available for this model"
2329        model_disp = wx.StaticText(self, wx.ID_ANY, text)
2330        self.sizer4_4.Add(model_disp, (iy, ix), (1, 1),
2331                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 10)
2332        self.sizer4_4.Layout()
2333        self.sizer4.Layout()
2334
2335    def _reset_dispersity(self):
2336        """
2337        put gaussian dispersity into current model
2338        """
2339        if len(self.param_toFit) > 0:
2340            for item in self.fittable_param:
2341                if item in self.param_toFit:
2342                    self.param_toFit.remove(item)
2343
2344            for item in self.orientation_params_disp:
2345                if item in self.param_toFit:
2346                    self.param_toFit.remove(item)
2347
2348        self.fittable_param = []
2349        self.fixed_param = []
2350        self.orientation_params_disp = []
2351        self.values = {}
2352        self.weights = {}
2353
2354        # from sas.models.dispersion_models import GaussianDispersion
2355        from sasmodels.weights import GaussianDispersion
2356        if len(self.disp_cb_dict) == 0:
2357            self.save_current_state()
2358            self.sizer4_4.Clear(True)
2359            self.Layout()
2360            return
2361        if (len(self.disp_cb_dict) > 0):
2362            for p in self.disp_cb_dict:
2363                # The parameter was un-selected.
2364                # Go back to Gaussian model (with 0 pts)
2365                disp_model = GaussianDispersion()
2366
2367                self._disp_obj_dict[p] = disp_model
2368                # Set the new model as the dispersion object
2369                # for the selected parameter
2370                try:
2371                    self.model.set_dispersion(p, disp_model)
2372                except Exception:
2373                    logging.error(traceback.format_exc())
2374
2375        # save state into
2376        self.save_current_state()
2377        self.Layout()
2378        self.Refresh()
2379
2380    def _on_select_Disp(self, event):
2381        """
2382        allow selecting different dispersion
2383        self.disp_list should change type later .now only gaussian
2384        """
2385        self._set_sizer_dispersion()
2386
2387        # Redraw the model
2388        #  Wojtek P. Nov 7, 2016: Redrawing seems to be unnecessary here
2389        # self._draw_model()
2390        # self._undo.Enable(True)
2391        event = PageInfoEvent(page=self)
2392        wx.PostEvent(self.parent, event)
2393
2394        self.sizer4_4.Layout()
2395        self.sizer4.Layout()
2396        self.SetupScrolling()
2397
2398    def _on_disp_func(self, event=None):
2399        """
2400        Select a distribution function for the polydispersion
2401
2402        :Param event: ComboBox event
2403        """
2404        # get ready for new event
2405        if event is not None:
2406            event.Skip()
2407        # Get event object
2408        disp_box = event.GetEventObject()
2409
2410        # Try to select a Distr. function
2411        try:
2412            disp_box.SetBackgroundColour("white")
2413            selection = disp_box.GetCurrentSelection()
2414            param_name = disp_box.Name.split('.')[0]
2415            disp_name = disp_box.GetValue()
2416            dispersity = disp_box.GetClientData(selection)
2417
2418            # disp_model =  GaussianDispersion()
2419            disp_model = dispersity()
2420            # Get param names to reset the values of the param
2421            name1 = param_name + ".width"
2422            name2 = param_name + ".npts"
2423            name3 = param_name + ".nsigmas"
2424            # Check Disp. function whether or not it is 'array'
2425            if disp_name.lower() == "array":
2426                value2 = ""
2427                value3 = ""
2428                value1 = self._set_array_disp(name=name1, disp=disp_model)
2429            else:
2430                self._del_array_values(name1)
2431                # self._reset_array_disp(param_name)
2432                self._disp_obj_dict[name1] = disp_model
2433                self.model.set_dispersion(param_name, disp_model)
2434                self.state._disp_obj_dict[name1] = disp_model.type
2435
2436                value1 = str(format_number(self.model.getParam(name1), True))
2437                value2 = str(format_number(self.model.getParam(name2)))
2438                value3 = str(format_number(self.model.getParam(name3)))
2439            # Reset fittable polydispersin parameter value
2440            for item in self.fittable_param:
2441                if item[1] == name1:
2442                    item[2].SetValue(value1)
2443                    item[5].SetValue("")
2444                    item[6].SetValue("")
2445                    # Disable for array
2446                    if disp_name.lower() == "array":
2447                        item[0].SetValue(False)
2448                        item[0].Disable()
2449                        item[2].Disable()
2450                        item[3].Show(False)
2451                        item[4].Show(False)
2452                        item[5].Disable()
2453                        item[6].Disable()
2454                    else:
2455                        item[0].Enable()
2456                        item[2].Enable()
2457                        item[3].Show(True)
2458                        item[4].Show(True)
2459                        item[5].Enable()
2460                        item[6].Enable()
2461                    break
2462            # Reset fixed polydispersion params
2463            for item in self.fixed_param:
2464                if item[1] == name2:
2465                    item[2].SetValue(value2)
2466                    # Disable Npts for array
2467                    if disp_name.lower() == "array":
2468                        item[2].Disable()
2469                    else:
2470                        item[2].Enable()
2471                if item[1] == name3:
2472                    item[2].SetValue(value3)
2473                    # Disable Nsigs for array
2474                    if disp_name.lower() == "array":
2475                        item[2].Disable()
2476                    else:
2477                        item[2].Enable()
2478
2479            # Make sure the check box updated
2480            self.get_all_checked_params()
2481
2482            # update params
2483            self._update_paramv_on_fit()
2484            # draw
2485            self._draw_model()
2486            self.Refresh()
2487        except Exception:
2488            logging.error(traceback.format_exc())
2489            # Error msg
2490            msg = "Error occurred:"
2491            msg += " Could not select the distribution function..."
2492            msg += " Please select another distribution function."
2493            disp_box.SetBackgroundColour("pink")
2494            # Focus on Fit button so that users can see the pinky box
2495            self.btFit.SetFocus()
2496            wx.PostEvent(self._manager.parent,
2497                         StatusEvent(status=msg, info="error"))
2498
2499    def _set_array_disp(self, name=None, disp=None):
2500        """
2501        Set array dispersion
2502
2503        :param name: name of the parameter for the dispersion to be set
2504        :param disp: the polydisperion object
2505        """
2506        # The user wants this parameter to be averaged.
2507        # Pop up the file selection dialog.
2508        path = self._selectDlg()
2509        # Array data
2510        values = []
2511        weights = []
2512        # If nothing was selected, just return
2513        if path is None:
2514            self.disp_cb_dict[name].SetValue(False)
2515            # self.noDisper_rbox.SetValue(True)
2516            return
2517        self._default_save_location = os.path.dirname(path)
2518        if self._manager is not None:
2519            self._manager.parent._default_save_location = \
2520                             self._default_save_location
2521
2522        basename = os.path.basename(path)
2523        values, weights = self.read_file(path)
2524
2525        # If any of the two arrays is empty, notify the user that we won't
2526        # proceed
2527        if len(self.param_toFit) > 0:
2528            if name in self.param_toFit:
2529                self.param_toFit.remove(name)
2530
2531        # Tell the user that we are about to apply the distribution
2532        msg = "Applying loaded %s distribution: %s" % (name, path)
2533        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2534        self._set_array_disp_model(name=name, disp=disp,
2535                                   values=values, weights=weights)
2536        return basename
2537
2538    def _set_array_disp_model(self, name=None, disp=None,
2539                              values=[], weights=[]):
2540        """
2541        Set array dispersion model
2542
2543        :param name: name of the parameter for the dispersion to be set
2544        :param disp: the polydisperion object
2545        """
2546        disp.set_weights(values, weights)
2547        self._disp_obj_dict[name] = disp
2548        self.model.set_dispersion(name.split('.')[0], disp)
2549        self.state._disp_obj_dict[name] = disp.type
2550        self.values[name] = values
2551        self.weights[name] = weights
2552        # Store the object to make it persist outside the
2553        # scope of this method
2554        # TODO: refactor model to clean this up?
2555        self.state.values = {}
2556        self.state.weights = {}
2557        self.state.values = copy.deepcopy(self.values)
2558        self.state.weights = copy.deepcopy(self.weights)
2559
2560        # Set the new model as the dispersion object for the
2561        # selected parameter
2562        # self.model.set_dispersion(p, disp_model)
2563        # Store a reference to the weights in the model object
2564        # so that
2565        # it's not lost when we use the model within another thread.
2566        self.state.model = self.model.clone()
2567        self.model._persistency_dict[name.split('.')[0]] = \
2568            [values, weights]
2569        self.state.model._persistency_dict[name.split('.')[0]] = \
2570            [values, weights]
2571
2572    def _del_array_values(self, name=None):
2573        """
2574        Reset array dispersion
2575
2576        :param name: name of the parameter for the dispersion to be set
2577        """
2578        # Try to delete values and weight of the names array dic if exists
2579        try:
2580            if name in self.values:
2581                del self.values[name]
2582                del self.weights[name]
2583                # delete all other dic
2584                del self.state.values[name]
2585                del self.state.weights[name]
2586                del self.model._persistency_dict[name.split('.')[0]]
2587                del self.state.model._persistency_dict[name.split('.')[0]]
2588        except Exception:
2589            logging.error(traceback.format_exc())
2590
2591    def _lay_out(self):
2592        """
2593        returns self.Layout
2594
2595        :Note: Mac seems to like this better when self.
2596            Layout is called after fitting.
2597        """
2598        self.Layout()
2599        return
2600
2601    def _find_polyfunc_selection(self, disp_func=None):
2602        """
2603        FInd Comboox selection from disp_func
2604
2605        :param disp_function: dispersion distr. function
2606        """
2607        # Find the selection
2608        if disp_func is not None:
2609            try:
2610                return POLYDISPERSITY_MODELS.values().index(disp_func.__class__)
2611            except ValueError:
2612                pass  # Fall through to default class
2613        return POLYDISPERSITY_MODELS.keys().index('gaussian')
2614
2615    def on_reset_clicked(self, event):
2616        """
2617        On 'Reset' button  for Q range clicked
2618        """
2619        flag = True
2620        # For 3 different cases: Data2D, Data1D, and theory
2621        if self.model is None:
2622            msg = "Please select a model first..."
2623            wx.MessageBox(msg, 'Info')
2624            flag = False
2625            return
2626
2627        elif self.data.__class__.__name__ == "Data2D":
2628            data_min = 0
2629            x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))
2630            y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax))
2631            self.qmin_x = data_min
2632            self.qmax_x = math.sqrt(x * x + y * y)
2633            # self.data.mask = numpy.ones(len(self.data.data),dtype=bool)
2634            # check smearing
2635            if not self.disable_smearer.GetValue():
2636                # set smearing value whether or
2637                # not the data contain the smearing info
2638                if self.pinhole_smearer.GetValue():
2639                    flag = self.update_pinhole_smear()
2640                else:
2641                    flag = True
2642
2643        elif self.data is None:
2644            self.qmin_x = _QMIN_DEFAULT
2645            self.qmax_x = _QMAX_DEFAULT
2646            self.num_points = _NPTS_DEFAULT
2647            self.state.npts = self.num_points
2648
2649        elif self.data.__class__.__name__ != "Data2D":
2650            self.qmin_x = min(self.data.x)
2651            self.qmax_x = max(self.data.x)
2652            # check smearing
2653            if not self.disable_smearer.GetValue():
2654                # set smearing value whether or
2655                # not the data contain the smearing info
2656                if self.slit_smearer.GetValue():
2657                    flag = self.update_slit_smear()
2658                elif self.pinhole_smearer.GetValue():
2659                    flag = self.update_pinhole_smear()
2660                else:
2661                    flag = True
2662        else:
2663            flag = False
2664
2665        if flag is False:
2666            msg = "Cannot Plot :Must enter a number!!!  "
2667            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2668        else:
2669            # set relative text ctrs.
2670            self.qmin.SetValue(str(self.qmin_x))
2671            self.qmax.SetValue(str(self.qmax_x))
2672            self.show_npts2fit()
2673            # At this point, some button and variables satatus (disabled?)
2674            # should be checked such as color that should be reset to
2675            # white in case that it was pink.
2676            self._onparamEnter_helper()
2677
2678        self.save_current_state()
2679        self.state.qmin = self.qmin_x
2680        self.state.qmax = self.qmax_x
2681
2682        # reset the q range values
2683        self._reset_plotting_range(self.state)
2684        self._draw_model()
2685
2686    def select_log(self, event):
2687        """
2688        Log checked to generate log spaced points for theory model
2689        """
2690
2691    def get_images(self):
2692        """
2693        Get the images of the plots corresponding this panel for report
2694
2695        : return graphs: list of figures
2696        : Need Move to guiframe
2697        """
2698        # set list of graphs
2699        graphs = []
2700        canvases = []
2701        res_item = None
2702        # call gui_manager
2703        gui_manager = self._manager.parent
2704        # loops through the panels [dic]
2705        for _, item2 in gui_manager.plot_panels.iteritems():
2706            data_title = self.data.group_id
2707            # try to get all plots belonging to this control panel
2708            try:
2709                g_id = item2.group_id
2710                if g_id == data_title or \
2711                        str(g_id).count("res" + str(self.graph_id)) or \
2712                        str(g_id).count(str(self.uid)) > 0:
2713                    if str(g_id).count("res" + str(self.graph_id)) > 0:
2714                        res_item = [item2.figure, item2.canvas]
2715                    else:
2716                        # append to the list
2717                        graphs.append(item2.figure)
2718                        canvases.append(item2.canvas)
2719            except Exception:
2720                # Not for control panels
2721                logging.error(traceback.format_exc())
2722        # Make sure the resduals plot goes to the last
2723        if res_item is not None:
2724            graphs.append(res_item[0])
2725            canvases.append(res_item[1])
2726        # return the list of graphs
2727        return graphs, canvases
2728
2729    def on_function_help_clicked(self, event):
2730        """
2731        Function called when 'Help' button is pressed next to model
2732        of interest.  This calls DocumentationWindow from
2733        documentation_window.py. It will load the top level of the model
2734        help documenation sphinx generated html if no model is presented.
2735        If a model IS present then if documention for that model exists
2736        it will load to that  point otherwise again it will go to the top.
2737        For Wx2.8 and below is used (i.e. non-released through installer)
2738        a browser is loaded and the top of the model documentation only is
2739        accessible because webbrowser module does not pass anything after
2740        the # to the browser.
2741
2742        :param event: on Help Button pressed event
2743        """
2744
2745        if self.model is not None:
2746            name = self.formfactorbox.GetValue()
2747            _TreeLocation = 'user/models/' + name.lower()+'.html'
2748            _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2749                                              "", name + " Help")
2750        else:
2751            _TreeLocation = 'user/index.html'
2752            _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2753                                              "", "General Model Help")
2754
2755    def on_model_help_clicked(self, event):
2756        """
2757        Function called when 'Description' button is pressed next to model
2758        of interest.  This calls the Description embedded in the model. This
2759        should work with either Wx2.8 and lower or higher. If no model is
2760        selected it will give the message that a model must be chosen first
2761        in the box that would normally contain the description.  If a badly
2762        behaved model is encountered which has no description then it will
2763        give the message that none is available.
2764
2765        :param event: on Description Button pressed event
2766        """
2767
2768        if self.model is None:
2769            name = 'index.html'
2770        else:
2771            name = self.formfactorbox.GetValue()
2772
2773        msg = 'Model description:\n'
2774        info = "Info"
2775        if self.model is not None:
2776            # frame.Destroy()
2777            if str(self.model.description).rstrip().lstrip() == '':
2778                msg += "Sorry, no information is available for this model."
2779            else:
2780                msg += self.model.description + '\n'
2781            wx.MessageBox(msg, info)
2782        else:
2783            msg += "You must select a model to get information on this"
2784            wx.MessageBox(msg, info)
2785
2786    def _on_mag_angle_help(self, event):
2787        """
2788        Bring up Magnetic Angle definition bmp image whenever the ? button
2789        is clicked. Calls DocumentationWindow with the path of the location
2790        within the documentation tree (after /doc/ ....". When using old
2791        versions of Wx (i.e. before 2.9 and therefore not part of release
2792        versions distributed via installer) it brings up an image viewer
2793        box which allows the user to click through the rest of the images in
2794        the directory.  Not ideal but probably better than alternative which
2795        would bring up the entire discussion of how magnetic models work?
2796        Specially since it is not likely to be accessed.  The normal release
2797        versions bring up the normal image box.
2798
2799        :param evt: Triggers on clicking ? in Magnetic Angles? box
2800        """
2801
2802        _TreeLocation = "_images/M_angles_pic.bmp"
2803        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
2804                                          "Magnetic Angle Defintions")
2805
2806    def _on_mag_help(self, event):
2807        """
2808        Bring up Magnetic Angle definition bmp image whenever the ? button
2809        is clicked. Calls DocumentationWindow with the path of the location
2810        within the documentation tree (after /doc/ ....". When using old
2811        versions of Wx (i.e. before 2.9 and therefore not part of release
2812        versions distributed via installer) it brings up an image viewer
2813        box which allows the user to click through the rest of the images in
2814        the directory.  Not ideal but probably better than alternative which
2815        would bring up the entire discussion of how magnetic models work?
2816        Specially since it is not likely to be accessed.  The normal release
2817        versions bring up the normal image box.
2818
2819        :param evt: Triggers on clicking ? in Magnetic Angles? box
2820        """
2821
2822        _TreeLocation = "user/magnetism.html"
2823        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
2824                                          "Polarized Beam/Magnetc Help")
2825
2826    def _on_mag_on(self, event):
2827        """
2828        Magnetic Parameters ON/OFF
2829        """
2830        button = event.GetEventObject()
2831
2832        if button.GetLabel().count('ON') > 0:
2833            self.magnetic_on = True
2834            button.SetLabel("Magnetic OFF")
2835            m_value = 1.0e-06
2836            for key in self.model.magnetic_params:
2837                if key.count('M0') > 0:
2838                    self.model.setParam(key, m_value)
2839                    m_value += 0.5e-06
2840        else:
2841            self.magnetic_on = False
2842            button.SetLabel("Magnetic ON")
2843            for key in self.model.magnetic_params:
2844                if key.count('M0') > 0:
2845                    # reset mag value to zero fo safety
2846                    self.model.setParam(key, 0.0)
2847
2848        self.Show(False)
2849        self.set_model_param_sizer(self.model)
2850        # self._set_sizer_dispersion()
2851        self.state.magnetic_on = self.magnetic_on
2852        self.SetupScrolling()
2853        self.Show(True)
2854
2855    def on_pd_help_clicked(self, event):
2856        """
2857        Bring up Polydispersity Documentation whenever the ? button is clicked.
2858        Calls DocumentationWindow with the path of the location within the
2859        documentation tree (after /doc/ ....".  Note that when using old
2860        versions of Wx (before 2.9) and thus not the release version of
2861        istallers, the help comes up at the top level of the file as
2862        webbrowser does not pass anything past the # to the browser when it is
2863        running "file:///...."
2864
2865        :param event: Triggers on clicking ? in polydispersity box
2866        """
2867
2868        _TreeLocation = "user/sasgui/perspectives/fitting/pd_help.html"
2869        _PageAnchor = ""
2870        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2871                                          _PageAnchor, "Polydispersity Help")
2872
2873    def on_left_down(self, event):
2874        """
2875        Get key stroke event
2876        """
2877        # Figuring out key combo: Cmd for copy, Alt for paste
2878        if event.CmdDown() and event.ShiftDown():
2879            self.get_paste()
2880        elif event.CmdDown():
2881            self.get_copy()
2882        else:
2883            event.Skip()
2884            return
2885        # make event free
2886        event.Skip()
2887
2888    def get_copy(self):
2889        """
2890        Get copy params to clipboard
2891        """
2892        content = self.get_copy_params()
2893        flag = self.set_clipboard(content)
2894        self._copy_info(flag)
2895        return flag
2896
2897    def get_copy_params(self):
2898        """
2899        Get the string copies of the param names and values in the tap
2900        """
2901        content = 'sasview_parameter_values:'
2902        # Do it if params exist
2903        if self.parameters:
2904
2905            # go through the parameters
2906            strings = self._get_copy_helper(self.parameters,
2907                                           self.orientation_params)
2908            content += strings
2909
2910            # go through the fittables
2911            strings = self._get_copy_helper(self.fittable_param,
2912                                           self.orientation_params_disp)
2913            content += strings
2914
2915            # go through the fixed params
2916            strings = self._get_copy_helper(self.fixed_param,
2917                                           self.orientation_params_disp)
2918            content += strings
2919
2920            # go through the str params
2921            strings = self._get_copy_helper(self.str_parameters,
2922                                           self.orientation_params)
2923            content += strings
2924            return content
2925        else:
2926            return False
2927
2928    def get_copy_excel(self):
2929        """
2930        Get copy params to clipboard
2931        """
2932        content = self.get_copy_params_excel()
2933        flag = self.set_clipboard(content)
2934        self._copy_info(flag)
2935        return flag
2936
2937    def get_copy_params_excel(self):
2938        """
2939        Get the string copies of the param names and values in the tap
2940        """
2941        content = ''
2942
2943        crlf = chr(13) + chr(10)
2944        tab = chr(9)
2945
2946        # Do it if params exist
2947        if self.parameters:
2948
2949            for param in self.parameters:
2950                content += param[1]  # parameter name
2951                content += tab
2952                content += param[1] + "_err"
2953                content += tab
2954
2955            content += crlf
2956
2957            # row of values and errors...
2958            for param in self.parameters:
2959                content += param[2].GetValue()  # value
2960                content += tab
2961                content += param[4].GetValue()  # error
2962                content += tab
2963
2964            return content
2965        else:
2966            return False
2967
2968    def get_copy_latex(self):
2969        """
2970        Get copy params to clipboard
2971        """
2972        content = self.get_copy_params_latex()
2973        flag = self.set_clipboard(content)
2974        self._copy_info(flag)
2975        return flag
2976
2977    def get_copy_params_latex(self):
2978        """
2979        Get the string copies of the param names and values in the tap
2980        """
2981        content = '\\begin{table}'
2982        content += '\\begin{tabular}[h]'
2983
2984        crlf = chr(13) + chr(10)
2985        tab = chr(9)
2986
2987        # Do it if params exist
2988        if self.parameters:
2989
2990            content += '{|'
2991            for param in self.parameters:
2992                content += 'l|l|'
2993            content += '}\hline'
2994            content += crlf
2995
2996            for index, param in enumerate(self.parameters):
2997                content += param[1].replace('_', '\_')  # parameter name
2998                content += ' & '
2999                content += param[1].replace('_', '\_') + "\_err"
3000                if index < len(self.parameters) - 1:
3001                    content += ' & '
3002            content += '\\\\ \\hline'
3003            content += crlf
3004
3005            # row of values and errors...
3006            for index, param in enumerate(self.parameters):
3007                content += param[2].GetValue()  # parameter value
3008                content += ' & '
3009                content += param[4].GetValue()  # parameter error
3010                if index < len(self.parameters) - 1:
3011                    content += ' & '
3012            content += '\\\\ \\hline'
3013            content += crlf
3014
3015            content += '\\end{tabular}'
3016            content += '\\end{table}'
3017            return content
3018        else:
3019            return False
3020
3021    def set_clipboard(self, content=None):
3022        """
3023        Put the string to the clipboard
3024        """
3025        if not content:
3026            return False
3027        if wx.TheClipboard.Open():
3028            wx.TheClipboard.SetData(wx.TextDataObject(str(content)))
3029            wx.TheClipboard.Close()
3030            return True
3031        return None
3032
3033    def _get_copy_helper(self, param, orient_param):
3034        """
3035        Helping get value and name of the params
3036
3037        : param param:  parameters
3038        : param orient_param = oritational params
3039        : return content: strings [list] [name,value:....]
3040        """
3041        content = ''
3042        bound_hi = ''
3043        bound_lo = ''
3044        # go through the str params
3045        for item in param:
3046            # copy only the params shown
3047            if not item[2].IsShown():
3048                continue
3049            disfunc = ''
3050            try:
3051                if item[7].__class__.__name__ == 'ComboBox':
3052                    disfunc = str(item[7].GetValue())
3053            except Exception:
3054                logging.error(traceback.format_exc())
3055
3056            # 2D
3057            if self.data.__class__.__name__ == "Data2D":
3058                try:
3059                    check = item[0].GetValue()
3060                except Exception:
3061                    check = None
3062                name = item[1]
3063                value = item[2].GetValue()
3064            # 1D
3065            else:
3066                # for 1D all parameters except orientation
3067                if not item[1] in orient_param:
3068                    try:
3069                        check = item[0].GetValue()
3070                    except:
3071                        check = None
3072                    name = item[1]
3073                    value = item[2].GetValue()
3074
3075            # Bounds
3076            try:
3077                bound_lo = item[5].GetValue()
3078                bound_hi = item[6].GetValue()
3079            except Exception:
3080                # harmless - need to just pass
3081                pass
3082
3083            # add to the content
3084            if disfunc != '':
3085
3086                disfunc = ',' + disfunc
3087            # Need to support array func for copy/paste
3088            try:
3089                if disfunc.count('array') > 0:
3090                    disfunc += ','
3091                    for val in self.values[name]:
3092                        disfunc += ' ' + str(val)
3093                    disfunc += ','
3094                    for weight in self.weights[name]:
3095                        disfunc += ' ' + str(weight)
3096            except Exception:
3097                logging.error(traceback.format_exc())
3098            content += name + ',' + str(check) + ',' + value + disfunc + ',' + \
3099                       bound_lo + ',' + bound_hi + ':'
3100
3101        return content
3102
3103    def get_clipboard(self):
3104        """
3105        Get strings in the clipboard
3106        """
3107        text = ""
3108        # Get text from the clip board
3109        if wx.TheClipboard.Open():
3110            if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)):
3111                data = wx.TextDataObject()
3112                # get wx dataobject
3113                success = wx.TheClipboard.GetData(data)
3114                # get text
3115                if success:
3116                    text = data.GetText()
3117                else:
3118                    text = ''
3119            # close clipboard
3120            wx.TheClipboard.Close()
3121        return text
3122
3123    def get_paste(self):
3124        """
3125        Paste params from the clipboard
3126        """
3127        text = self.get_clipboard()
3128        flag = self.get_paste_params(text)
3129        self._copy_info(flag)
3130        return flag
3131
3132    def get_paste_params(self, text=''):
3133        """
3134        Get the string copies of the param names and values in the tap
3135        """
3136        context = {}
3137        # put the text into dictionary
3138        lines = text.split(':')
3139        if lines[0] != 'sasview_parameter_values':
3140            self._copy_info(False)
3141            return False
3142        for line in lines[1:-1]:
3143            if len(line) != 0:
3144                item = line.split(',')
3145                check = item[1]
3146                name = item[0]
3147                value = item[2]
3148                # Transfer the text to content[dictionary]
3149                context[name] = [check, value]
3150
3151                # limits
3152                limit_lo = item[3]
3153                context[name].append(limit_lo)
3154                limit_hi = item[4]
3155                context[name].append(limit_hi)
3156
3157            # ToDo: PlugIn this poly disp function for pasting
3158            try:
3159                poly_func = item[5]
3160                context[name].append(poly_func)
3161                try:
3162                    # take the vals and weights for  array
3163                    array_values = item[6].split(' ')
3164                    array_weights = item[7].split(' ')
3165                    val = [float(a_val) for a_val in array_values[1:]]
3166                    weit = [float(a_weit) for a_weit in array_weights[1:]]
3167
3168                    context[name].append(val)
3169                    context[name].append(weit)
3170                except:
3171                    raise
3172            except:
3173                poly_func = ''
3174                context[name].append(poly_func)
3175
3176        # Do it if params exist
3177        if self.parameters:
3178            # go through the parameters
3179            self._get_paste_helper(self.parameters,
3180                                   self.orientation_params, context)
3181
3182            # go through the fittables
3183            self._get_paste_helper(self.fittable_param,
3184                                   self.orientation_params_disp,
3185                                   context)
3186
3187            # go through the fixed params
3188            self._get_paste_helper(self.fixed_param,
3189                                   self.orientation_params_disp, context)
3190
3191            # go through the str params
3192            self._get_paste_helper(self.str_parameters,
3193                                   self.orientation_params, context)
3194
3195            return True
3196        return None
3197
3198    def _get_paste_helper(self, param, orient_param, content):
3199        """
3200        Helping set values of the params
3201
3202        : param param:  parameters
3203        : param orient_param: oritational params
3204        : param content: dictionary [ name, value: name1.value1,...]
3205        """
3206        # go through the str params
3207        for item in param:
3208            # 2D
3209            if self.data.__class__.__name__ == "Data2D":
3210                name = item[1]
3211                if name in content.keys():
3212                    values = content[name]
3213                    check = values[0]
3214                    pd = values[1]
3215
3216                    if name.count('.') > 0:
3217                        # If this is parameter.width, then pd may be a floating
3218                        # point value or it may be an array distribution.
3219                        # Nothing to do for parameter.npts or parameter.nsigmas.
3220                        try:
3221                            float(pd)
3222                            if name.endswith('.npts'):
3223                                pd = int(pd)
3224                        except Exception:
3225                            # continue
3226                            if not pd and pd != '':
3227                                continue
3228                    item[2].SetValue(str(pd))
3229                    if item in self.fixed_param and pd == '':
3230                        # Only array func has pd == '' case.
3231                        item[2].Enable(False)
3232                    else:
3233                        item[2].Enable(True)
3234                    if item[2].__class__.__name__ == "ComboBox":
3235                        if content[name][1] in self.model.fun_list:
3236                            fun_val = self.model.fun_list[content[name][1]]
3237                            self.model.setParam(name, fun_val)
3238                    try:
3239                        item[5].SetValue(str(values[-3]))
3240                        item[6].SetValue(str(values[-2]))
3241                    except Exception:
3242                        # passing as harmless non-update
3243                        pass
3244
3245                    value = content[name][1:]
3246                    self._paste_poly_help(item, value)
3247                    if check == 'True':
3248                        is_true = True
3249                    elif check == 'False':
3250                        is_true = False
3251                    else:
3252                        is_true = None
3253                    if is_true is not None:
3254                        item[0].SetValue(is_true)
3255            # 1D
3256            else:
3257                # for 1D all parameters except orientation
3258                if not item[1] in orient_param:
3259                    name = item[1]
3260                    if name in content.keys():
3261                        check = content[name][0]
3262                        # Avoid changing combox content
3263                        value = content[name][1:]
3264                        pd = value[0]
3265                        if name.count('.') > 0:
3266                            # If this is parameter.width, then pd may be a
3267                            # floating point value or it may be an array
3268                            # distribution. Nothing to do for parameter.npts or
3269                            # parameter.nsigmas.
3270                            try:
3271                                pd = float(pd)
3272                                if name.endswith('.npts'):
3273                                    pd = int(pd)
3274                            except:
3275                                # continue
3276                                if not pd and pd != '':
3277                                    continue
3278                        item[2].SetValue(str(pd))
3279                        if item in self.fixed_param and pd == '':
3280                            # Only array func has pd == '' case.
3281                            item[2].Enable(False)
3282                        else:
3283                            item[2].Enable(True)
3284                        if item[2].__class__.__name__ == "ComboBox":
3285                            if value[0] in self.model.fun_list:
3286                                fun_val = self.model.fun_list[value[0]]
3287                                self.model.setParam(name, fun_val)
3288                                # save state
3289                        try:
3290                            item[5].SetValue(str(value[-3]))
3291                            item[6].SetValue(str(value[-2]))
3292                        except Exception:
3293                            # passing as harmless non-update
3294                            pass
3295
3296                        self._paste_poly_help(item, value)
3297                        if check == 'True':
3298                            is_true = True
3299                        elif check == 'False':
3300                            is_true = False
3301                        else:
3302                            is_true = None
3303                        if is_true is not None:
3304                            item[0].SetValue(is_true)
3305
3306        self.select_param(event=None)
3307        self.Refresh()
3308
3309    def _paste_poly_help(self, item, value):
3310        """
3311        Helps get paste for poly function
3312
3313        *item* is the parameter name
3314
3315        *value* depends on which parameter is being processed, and whether it
3316        has array polydispersity.
3317
3318        For parameters without array polydispersity:
3319
3320            parameter => ['FLOAT', '']
3321            parameter.width => ['FLOAT', 'DISTRIBUTION', '']
3322            parameter.npts => ['FLOAT', '']
3323            parameter.nsigmas => ['FLOAT', '']
3324
3325        For parameters with array polydispersity:
3326
3327            parameter => ['FLOAT', '']
3328            parameter.width => ['FILENAME', 'array', [x1, ...], [w1, ...]]
3329            parameter.npts => ['FLOAT', '']
3330            parameter.nsigmas => ['FLOAT', '']
3331        """
3332        # Do nothing if not setting polydispersity
3333        if len(value[3]) == 0:
3334            return
3335
3336        try:
3337            name = item[7].Name
3338            param_name = name.split('.')[0]
3339            item[7].SetValue(value[1])
3340            selection = item[7].GetCurrentSelection()
3341            dispersity = item[7].GetClientData(selection)
3342            disp_model = dispersity()
3343
3344            if value[1] == 'array':
3345                pd_vals = numpy.array(value[2])
3346                pd_weights = numpy.array(value[3])
3347                if len(pd_vals) == 0 or len(pd_vals) != len(pd_weights):
3348                    msg = ("bad array distribution parameters for %s"
3349                           % param_name)
3350                    raise ValueError(msg)
3351                self._set_disp_cb(True, item=item)
3352                self._set_array_disp_model(name=name,
3353                                           disp=disp_model,
3354                                           values=pd_vals,
3355                                           weights=pd_weights)
3356            else:
3357                self._set_disp_cb(False, item=item)
3358                self._disp_obj_dict[name] = disp_model
3359                self.model.set_dispersion(param_name, disp_model)
3360                self.state._disp_obj_dict[name] = disp_model.type
3361                # TODO: It's not an array, why update values and weights?
3362                self.model._persistency_dict[param_name] = \
3363                    [self.values, self.weights]
3364                self.state.values = self.values
3365                self.state.weights = self.weights
3366
3367        except Exception:
3368            logging.error(traceback.format_exc())
3369            print "Error in BasePage._paste_poly_help: %s" % \
3370                  sys.exc_info()[1]
3371
3372    def _set_disp_cb(self, isarray, item):
3373        """
3374        Set cb for array disp
3375        """
3376        if isarray:
3377            item[0].SetValue(False)
3378            item[0].Enable(False)
3379            item[2].Enable(False)
3380            item[3].Show(False)
3381            item[4].Show(False)
3382            item[5].SetValue('')
3383            item[5].Enable(False)
3384            item[6].SetValue('')
3385            item[6].Enable(False)
3386        else:
3387            item[0].Enable()
3388            item[2].Enable()
3389            item[3].Show(True)
3390            item[4].Show(True)
3391            item[5].Enable()
3392            item[6].Enable()
3393
3394    def update_pinhole_smear(self):
3395        """
3396            Method to be called by sub-classes
3397            Moveit; This method doesn't belong here
3398        """
3399        print "BasicPage.update_pinhole_smear was called: skipping"
3400        return
3401
3402    def _read_category_info(self):
3403        """
3404        Reads the categories in from file
3405        """
3406        # # ILL mod starts here - July 2012 kieranrcampbell@gmail.com
3407        self.master_category_dict = defaultdict(list)
3408        self.by_model_dict = defaultdict(list)
3409        self.model_enabled_dict = defaultdict(bool)
3410        categorization_file = CategoryInstaller.get_user_file()
3411        with open(categorization_file, 'rb') as f:
3412            self.master_category_dict = json.load(f)
3413        self._regenerate_model_dict()
3414
3415    def _regenerate_model_dict(self):
3416        """
3417        regenerates self.by_model_dict which has each model name as the
3418        key and the list of categories belonging to that model
3419        along with the enabled mapping
3420        """
3421        self.by_model_dict = defaultdict(list)
3422        for category in self.master_category_dict:
3423            for (model, enabled) in self.master_category_dict[category]:
3424                self.by_model_dict[model].append(category)
3425                self.model_enabled_dict[model] = enabled
3426
3427    def _populate_listbox(self):
3428        """
3429        fills out the category list box
3430        """
3431        uncat_str = 'Plugin Models'
3432        self._read_category_info()
3433
3434        self.categorybox.Clear()
3435        cat_list = sorted(self.master_category_dict.keys())
3436        if uncat_str not in cat_list:
3437            cat_list.append(uncat_str)
3438
3439        for category in cat_list:
3440            if category != '':
3441                self.categorybox.Append(category)
3442
3443        if self.categorybox.GetSelection() == wx.NOT_FOUND:
3444            self.categorybox.SetSelection(0)
3445        else:
3446            self.categorybox.SetSelection(
3447                self.categorybox.GetSelection())
3448        # self._on_change_cat(None)
3449
3450    def _on_change_cat(self, event):
3451        """
3452        Callback for category change action
3453        """
3454        self.model_name = None
3455        category = self.categorybox.GetStringSelection()
3456        if category is None:
3457            return
3458        self.model_box.Clear()
3459
3460        if category == 'Plugin Models':
3461            for model in self.model_list_box[category]:
3462                str_m = str(model).split(".")[0]
3463                self.model_box.Append(str_m)
3464
3465        else:
3466            for (model, enabled) in sorted(self.master_category_dict[category],
3467                                           key=lambda name: name[0]):
3468                if(enabled):
3469                    self.model_box.Append(model)
3470
3471    def _fill_model_sizer(self, sizer):
3472        """
3473        fill sizer containing model info
3474        """
3475        # This should only be called once per fit tab
3476        # print "==== Entering _fill_model_sizer"
3477        # Add model function Details button in fitpanel.
3478        # The following 3 lines are for Mac. Let JHC know before modifying...
3479        title = "Model"
3480        self.formfactorbox = None
3481        self.multifactorbox = None
3482        self.mbox_description = wx.StaticBox(self, wx.ID_ANY, str(title))
3483        boxsizer1 = wx.StaticBoxSizer(self.mbox_description, wx.VERTICAL)
3484        sizer_cat = wx.BoxSizer(wx.HORIZONTAL)
3485        self.mbox_description.SetForegroundColour(wx.RED)
3486        wx_id = self._ids.next()
3487        self.model_func = wx.Button(self, wx_id, 'Help', size=(80, 23))
3488        self.model_func.Bind(wx.EVT_BUTTON, self.on_function_help_clicked,
3489                             id=wx_id)
3490        self.model_func.SetToolTipString("Full Model Function Help")
3491        wx_id = self._ids.next()
3492        self.model_help = wx.Button(self, wx_id, 'Description', size=(80, 23))
3493        self.model_help.Bind(wx.EVT_BUTTON, self.on_model_help_clicked,
3494                             id=wx_id)
3495        self.model_help.SetToolTipString("Short Model Function Description")
3496        wx_id = self._ids.next()
3497        self.model_view = wx.Button(self, wx_id, "Show 2D", size=(80, 23))
3498        self.model_view.Bind(wx.EVT_BUTTON, self._onModel2D, id=wx_id)
3499        hint = "toggle view of model from 1D to 2D  or 2D to 1D"
3500        self.model_view.SetToolTipString(hint)
3501
3502        cat_set_box = wx.StaticBox(self, wx.ID_ANY, 'Category')
3503        sizer_cat_box = wx.StaticBoxSizer(cat_set_box, wx.HORIZONTAL)
3504        sizer_cat_box.SetMinSize((200, 50))
3505        self.categorybox = wx.ComboBox(self, wx.ID_ANY,
3506                                       style=wx.CB_READONLY)
3507        self.categorybox.SetToolTip(wx.ToolTip("Select a Category/Type"))
3508        self._populate_listbox()
3509        wx.EVT_COMBOBOX(self.categorybox, wx.ID_ANY, self._show_combox)
3510        # self.shape_rbutton = wx.RadioButton(self, wx.ID_ANY, 'Shapes',
3511        #                                     style=wx.RB_GROUP)
3512        # self.shape_indep_rbutton = wx.RadioButton(self, wx.ID_ANY,
3513        #                                          "Shape-Independent")
3514        # self.struct_rbutton = wx.RadioButton(self, wx.ID_ANY,
3515        #                                     "Structure Factor ")
3516        # self.plugin_rbutton = wx.RadioButton(self, wx.ID_ANY,
3517        #                                     "Uncategorized")
3518
3519        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3520        #                   id=self.shape_rbutton.GetId())
3521        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3522        #                    id=self.shape_indep_rbutton.GetId())
3523        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3524        #                    id=self.struct_rbutton.GetId())
3525        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3526        #                    id=self.plugin_rbutton.GetId())
3527        # MAC needs SetValue
3528
3529        show_cat_button = wx.Button(self, wx.ID_ANY, "Modify")
3530        cat_tip = "Modify model categories \n"
3531        cat_tip += "(also accessible from the menu bar)."
3532        show_cat_button.SetToolTip(wx.ToolTip(cat_tip))
3533        show_cat_button.Bind(wx.EVT_BUTTON, self._on_modify_cat)
3534        sizer_cat_box.Add(self.categorybox, 1, wx.RIGHT, 3)
3535        sizer_cat_box.Add((10, 10))
3536        sizer_cat_box.Add(show_cat_button)
3537        # self.shape_rbutton.SetValue(True)
3538
3539        sizer_radiobutton = wx.GridSizer(2, 2, 5, 5)
3540        # sizer_radiobutton.Add(self.shape_rbutton)
3541        # sizer_radiobutton.Add(self.shape_indep_rbutton)
3542        sizer_radiobutton.Add((5, 5))
3543        sizer_radiobutton.Add(self.model_view, 1, wx.RIGHT, 5)
3544        # sizer_radiobutton.Add(self.plugin_rbutton)
3545        # sizer_radiobutton.Add(self.struct_rbutton)
3546        # sizer_radiobutton.Add((5,5))
3547        sizer_radiobutton.Add(self.model_help, 1, wx.RIGHT | wx.LEFT, 5)
3548        # sizer_radiobutton.Add((5,5))
3549        sizer_radiobutton.Add(self.model_func, 1, wx.RIGHT, 5)
3550        sizer_cat.Add(sizer_cat_box, 1, wx.LEFT, 2.5)
3551        sizer_cat.Add(sizer_radiobutton)
3552        sizer_selection = wx.BoxSizer(wx.HORIZONTAL)
3553        mutifactor_selection = wx.BoxSizer(wx.HORIZONTAL)
3554
3555        self.text1 = wx.StaticText(self, wx.ID_ANY, "")
3556        self.text2 = wx.StaticText(self, wx.ID_ANY, "P(Q)*S(Q)")
3557        self.mutifactor_text = wx.StaticText(self, wx.ID_ANY, "No. of Shells: ")
3558        self.mutifactor_text1 = wx.StaticText(self, wx.ID_ANY, "")
3559        self.show_sld_button = wx.Button(self, wx.ID_ANY, "Show SLD Profile")
3560        self.show_sld_button.Bind(wx.EVT_BUTTON, self._on_show_sld)
3561
3562        self.formfactorbox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3563        self.formfactorbox.SetToolTip(wx.ToolTip("Select a Model"))
3564        if self.model is not None:
3565            self.formfactorbox.SetValue(self.model.name)
3566        self.structurebox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3567        self.multifactorbox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3568        self.initialize_combox()
3569        wx.EVT_COMBOBOX(self.formfactorbox, wx.ID_ANY, self._on_select_model)
3570
3571        wx.EVT_COMBOBOX(self.structurebox, wx.ID_ANY, self._on_select_model)
3572        wx.EVT_COMBOBOX(self.multifactorbox, wx.ID_ANY, self._on_select_model)
3573        # check model type to show sizer
3574        if self.model is not None:
3575            print "_set_model_sizer_selection: disabled."
3576            # self._set_model_sizer_selection(self.model)
3577
3578        sizer_selection.Add(self.text1)
3579        sizer_selection.Add((10, 5))
3580        sizer_selection.Add(self.formfactorbox)
3581        sizer_selection.Add((5, 5))
3582        sizer_selection.Add(self.text2)
3583        sizer_selection.Add((5, 5))
3584        sizer_selection.Add(self.structurebox)
3585
3586        mutifactor_selection.Add((13, 5))
3587        mutifactor_selection.Add(self.mutifactor_text)
3588        mutifactor_selection.Add(self.multifactorbox)
3589        mutifactor_selection.Add((5, 5))
3590        mutifactor_selection.Add(self.mutifactor_text1)
3591        mutifactor_selection.Add((10, 5))
3592        mutifactor_selection.Add(self.show_sld_button)
3593
3594        boxsizer1.Add(sizer_cat)
3595        boxsizer1.Add((10, 10))
3596        boxsizer1.Add(sizer_selection)
3597        boxsizer1.Add((10, 10))
3598        boxsizer1.Add(mutifactor_selection)
3599
3600        self._set_multfactor_combobox()
3601        self.multifactorbox.SetSelection(1)
3602        self.show_sld_button.Hide()
3603        sizer.Add(boxsizer1, 0, wx.EXPAND | wx.ALL, 10)
3604        sizer.Layout()
3605
3606    def on_smear_helper(self, update=False):
3607        """
3608        Help for onSmear if implemented
3609
3610        :param update: force or not to update
3611        """
3612    def reset_page(self, state, first=False):
3613        """
3614        reset the state  if implemented
3615        """
3616    def onSmear(self, event):
3617        """
3618        Create a smear object if implemented
3619        """
3620    def onPinholeSmear(self, event):
3621        """
3622        Create a custom pinhole smear object if implemented
3623        """
3624    def onSlitSmear(self, event):
3625        """
3626        Create a custom slit smear object if implemented
3627        """
3628    def update_slit_smear(self):
3629        """
3630        called by kill_focus on pinhole TextCntrl
3631        to update the changes if implemented
3632        """
3633    def select_param(self, event):
3634        """
3635        Select TextCtrl  checked if implemented
3636        """
3637    def set_data(self, data=None):
3638        """
3639        Sets data if implemented
3640        """
3641    def _is_2D(self):
3642        """
3643        Check if data_name is Data2D if implemented
3644        """
3645    def _on_select_model(self, event=None):
3646        """
3647        call back for model selection if implemented
3648        """
3649    def get_weight_flag(self):
3650        """
3651        Get flag corresponding to a given weighting dI data if implemented
3652        """
3653    def _set_sizer_dispersion(self):
3654        """
3655        draw sizer for dispersity if implemented
3656        """
3657    def get_all_checked_params(self):
3658        """
3659        Found all parameters current check and add them to list of parameters
3660        to fit if implemented
3661        """
3662    def show_npts2fit(self):
3663        """
3664        setValue Npts for fitting if implemented
3665        """
3666    def _onModel2D(self, event):
3667        """
3668        toggle view of model from 1D to 2D  or 2D from 1D if implemented
3669        """
3670
3671
3672class ModelTextCtrl(wx.TextCtrl):
3673    """
3674    Text control for model and fit parameters.
3675    Binds the appropriate events for user interactions.
3676    Default callback methods can be overwritten on initialization
3677
3678    :param kill_focus_callback: callback method for EVT_KILL_FOCUS event
3679    :param set_focus_callback:  callback method for EVT_SET_FOCUS event
3680    :param mouse_up_callback:   callback method for EVT_LEFT_UP event
3681    :param text_enter_callback: callback method for EVT_TEXT_ENTER event
3682
3683    """
3684    # Set to True when the mouse is clicked while whole string is selected
3685    full_selection = False
3686    # Call back for EVT_SET_FOCUS events
3687    _on_set_focus_callback = None
3688
3689    def __init__(self, parent, id=-1,
3690                 value=wx.EmptyString,
3691                 pos=wx.DefaultPosition,
3692                 size=wx.DefaultSize,
3693                 style=0,
3694                 validator=wx.DefaultValidator,
3695                 name=wx.TextCtrlNameStr,
3696                 kill_focus_callback=None,
3697                 set_focus_callback=None,
3698                 mouse_up_callback=None,
3699                 text_enter_callback=None):
3700
3701        wx.TextCtrl.__init__(self, parent, id, value, pos,
3702                             size, style, validator, name)
3703
3704        # Bind appropriate events
3705        self._on_set_focus_callback = parent.onSetFocus \
3706            if set_focus_callback is None else set_focus_callback
3707        self.Bind(wx.EVT_SET_FOCUS, self._on_set_focus)
3708        self.Bind(wx.EVT_KILL_FOCUS, self._silent_kill_focus
3709        if kill_focus_callback is None else kill_focus_callback)
3710        self.Bind(wx.EVT_TEXT_ENTER, parent._onparamEnter
3711        if text_enter_callback is None else text_enter_callback)
3712        if not ON_MAC:
3713            self.Bind(wx.EVT_LEFT_UP, self._highlight_text
3714            if mouse_up_callback is None else mouse_up_callback)
3715
3716    def _on_set_focus(self, event):
3717        """
3718        Catch when the text control is set in focus to highlight the whole
3719        text if necessary
3720
3721        :param event: mouse event
3722
3723        """
3724        event.Skip()
3725        self.full_selection = True
3726        return self._on_set_focus_callback(event)
3727
3728    def _highlight_text(self, event):
3729        """
3730        Highlight text of a TextCtrl only of no text has be selected
3731
3732        :param event: mouse event
3733
3734        """
3735        # Make sure the mouse event is available to other listeners
3736        event.Skip()
3737        control = event.GetEventObject()
3738        if self.full_selection:
3739            self.full_selection = False
3740            # Check that we have a TextCtrl
3741            if issubclass(control.__class__, wx.TextCtrl):
3742                # Check whether text has been selected,
3743                # if not, select the whole string
3744                (start, end) = control.GetSelection()
3745                if start == end:
3746                    control.SetSelection(-1, -1)
3747
3748    def _silent_kill_focus(self, event):
3749        """
3750        Save the state of the page
3751        """
3752
3753        event.Skip()
3754        # pass
Note: See TracBrowser for help on using the repository browser.