source: sasview/guiframe/data_panel.py @ db427ec

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since db427ec was c5a769e, checked in by Jae Cho <jhjcho@…>, 14 years ago

more touch: move delete plot to p_panel from data_panel…
  • Property mode set to 100644
File size: 44.8 KB
Line 
1################################################################################
2#This software was developed by the University of Tennessee as part of the
3#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
4#project funded by the US National Science Foundation.
5#
6#See the license text in license.txt
7#
8#copyright 2010, University of Tennessee
9################################################################################
10"""
11This module provides Graphic interface for the data_manager module.
12"""
13import os
14import wx
15import sys
16import warnings
17import logging
18from wx.lib.scrolledpanel import ScrolledPanel
19import  wx.lib.agw.customtreectrl as CT
20from sans.guiframe.dataFitting import Data1D
21from sans.guiframe.dataFitting import Data2D
22from sans.guiframe.panel_base import PanelBase
23from sans.guiframe.events import StatusEvent
24from sans.guiframe.events import EVT_DELETE_PLOTPANEL
25from sans.guiframe.events import NewLoadDataEvent
26from sans.guiframe.events import NewPlotEvent
27from sans.guiframe.gui_style import GUIFRAME
28from DataLoader.loader import Loader
29
30try:
31    # Try to find a local config
32    import imp
33    path = os.getcwd()
34    if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \
35        (os.path.isfile("%s/%s.pyc" % (path, 'local_config'))):
36        fObj, path, descr = imp.find_module('local_config', [path])
37        config = imp.load_module('local_config', fObj, path, descr) 
38    else:
39        # Try simply importing local_config
40        import local_config as config
41except:
42    # Didn't find local config, load the default
43    import config
44 
45extension_list = []
46if config.APPLICATION_STATE_EXTENSION is not None:
47    extension_list.append(config.APPLICATION_STATE_EXTENSION)
48EXTENSIONS = config.PLUGIN_STATE_EXTENSIONS + extension_list   
49PLUGINS_WLIST = config.PLUGINS_WLIST
50APPLICATION_WLIST = config.APPLICATION_WLIST
51
52#Control panel width
53if sys.platform.count("win32") > 0:
54    PANEL_WIDTH = 235
55    PANEL_HEIGHT = 700
56    CBOX_WIDTH = 140
57    BUTTON_WIDTH = 80
58    FONT_VARIANT = 0
59else:
60    PANEL_WIDTH = 255
61    PANEL_HEIGHT = 750
62    CBOX_WIDTH = 155
63    BUTTON_WIDTH = 100
64    FONT_VARIANT = 1
65
66STYLE_FLAG =wx.RAISED_BORDER|CT.TR_HAS_BUTTONS| CT.TR_HIDE_ROOT|\
67                    wx.WANTS_CHARS|CT.TR_HAS_VARIABLE_ROW_HEIGHT
68                   
69                   
70class DataTreeCtrl(CT.CustomTreeCtrl):
71    """
72    Check list control to be used for Data Panel
73    """
74    def __init__(self, parent,*args, **kwds):
75        #agwstyle is introduced in wx.2.8.11 but is not working for mac
76        if sys.platform.count("darwin") != 0:
77            try:
78                kwds['style'] = STYLE_FLAG
79                CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds)
80            except:
81                del kwds['style']
82                CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds)
83        else:
84            #agwstyle is introduced in wx.2.8.11 .argument working only for windows
85            try:
86                kwds['agwStyle'] = STYLE_FLAG
87                CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds)
88            except:
89                try:
90                    del kwds['agwStyle']
91                    kwds['style'] = STYLE_FLAG
92                    CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds)
93                except:
94                    del kwds['style']
95                    CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds)
96        self.root = self.AddRoot("Available Data")
97       
98class DataPanel(ScrolledPanel, PanelBase):
99    """
100    This panel displays data available in the application and widgets to
101    interact with data.
102    """
103    ## Internal name for the AUI manager
104    window_name = "Data Panel"
105    ## Title to appear on top of the window
106    window_caption = "Data Explorer"
107    #type of window
108    window_type = "Data Panel"
109    ## Flag to tell the GUI manager that this panel is not
110    #  tied to any perspective
111    #ALWAYS_ON = True
112    def __init__(self, parent, 
113                 list=None,
114                 size=(PANEL_WIDTH, PANEL_HEIGHT),
115                 list_of_perspective=None, manager=None, *args, **kwds):
116        kwds['size']= size
117        kwds['style'] = STYLE_FLAG
118        ScrolledPanel.__init__(self, parent=parent, *args, **kwds)
119        PanelBase.__init__(self)
120        self.SetupScrolling()
121        #Set window's font size
122        self.SetWindowVariant(variant=FONT_VARIANT)
123        self.loader = Loader() 
124        #Default location
125        self._default_save_location = None 
126        self.all_data1d = True
127        self.parent = parent
128        self.manager = manager
129        if list is None:
130            list = []
131        self.list_of_data = list
132        if list_of_perspective is None:
133            list_of_perspective = []
134        self.list_of_perspective = list_of_perspective
135        self.list_rb_perspectives= []
136        self.list_cb_data = {}
137        self.list_cb_theory = {}
138        self.tree_ctrl = None
139        self.tree_ctrl_theory = None
140        self.perspective_cbox = None
141       
142        self.owner = None
143        self.do_layout()
144        self.fill_cbox_analysis(self.list_of_perspective)
145        self.Bind(wx.EVT_SHOW, self.on_close_page)
146        if self.parent is not None:
147            self.parent.Bind(EVT_DELETE_PLOTPANEL, self._on_delete_plot_panel)
148       
149       
150    def do_layout(self):
151        """
152        """
153        self.define_panel_structure()
154        self.layout_selection()
155        self.layout_data_list()
156        self.layout_button()
157        #self.layout_batch()
158   
159    def define_panel_structure(self):
160        """
161        Define the skeleton of the panel
162        """
163        w, h = self.parent.GetSize()
164        self.vbox  = wx.BoxSizer(wx.VERTICAL)
165        self.sizer1 = wx.BoxSizer(wx.VERTICAL)
166        self.sizer1.SetMinSize((w/13, h*2/5))
167     
168        self.sizer2 = wx.BoxSizer(wx.VERTICAL)
169        self.sizer3 = wx.FlexGridSizer(7, 2, 4, 1)
170        self.sizer4 = wx.BoxSizer(wx.HORIZONTAL)
171        self.sizer5 = wx.BoxSizer(wx.VERTICAL)
172       
173        self.vbox.Add(self.sizer5, 0, wx.EXPAND|wx.ALL,1)
174        self.vbox.Add(self.sizer1, 0, wx.EXPAND|wx.ALL,0)
175        self.vbox.Add(self.sizer2, 0, wx.EXPAND|wx.ALL,1)
176        self.vbox.Add(self.sizer3, 0, wx.EXPAND|wx.ALL,5)
177        self.vbox.Add(self.sizer4, 0, wx.EXPAND|wx.ALL,5)
178       
179        self.SetSizer(self.vbox)
180       
181    def layout_selection(self):
182        """
183        """
184        select_txt = wx.StaticText(self, -1, 'Selection Options')
185        select_txt.SetForegroundColour('blue')
186        self.selection_cbox = wx.ComboBox(self, -1, style=wx.CB_READONLY)
187        list_of_options = ['Select all Data',
188                            'Unselect all Data',
189                           'Select all Data 1D',
190                           'Unselect all Data 1D',
191                           'Select all Data 2D',
192                           'Unselect all Data 2D' ]
193        for option in list_of_options:
194            self.selection_cbox.Append(str(option))
195        self.selection_cbox.SetValue('Select all Data')
196        wx.EVT_COMBOBOX(self.selection_cbox,-1, self._on_selection_type)
197        self.sizer5.AddMany([(select_txt,0, wx.ALL,5),
198                            (self.selection_cbox,0, wx.ALL,5)])
199        self.enable_selection()
200       
201   
202    def _on_selection_type(self, event):
203        """
204        Select data according to patterns
205        """
206       
207        list_of_options = ['Select all Data',
208                            'Unselect all Data',
209                           'Select all Data 1D',
210                           'Unselect all Data 1D',
211                           'Select all Data 2D',
212                           'Unselect all Data 2D' ]
213        option = self.selection_cbox.GetValue()
214       
215        pos = self.selection_cbox.GetSelection()
216        if pos == wx.NOT_FOUND:
217            return 
218        option = self.selection_cbox.GetString(pos)
219        for item in self.list_cb_data.values():
220            data_ctrl, _, _, _,_, _ = item
221            data_id, data_class, _ = self.tree_ctrl.GetItemPyData(data_ctrl) 
222            if option == 'Select all Data':
223                self.tree_ctrl.CheckItem(data_ctrl, True) 
224            elif option == 'Unselect all Data':
225                self.tree_ctrl.CheckItem(data_ctrl, False)
226            elif option == 'Select all Data 1D':
227                if data_class == 'Data1D':
228                    self.tree_ctrl.CheckItem(data_ctrl, True) 
229            elif option == 'Unselect all Data 1D':
230                if data_class == 'Data1D':
231                    self.tree_ctrl.CheckItem(data_ctrl, False) 
232            elif option == 'Select all Data 1D':
233                if data_class == 'Data1D':
234                    self.tree_ctrl.CheckItem(data_ctrl, True) 
235            elif option == 'Select all Data 2D':
236                if data_class == 'Data2D':
237                    self.tree_ctrl.CheckItem(data_ctrl, True) 
238            elif option == 'Unselect all Data 2D':
239                if data_class == 'Data2D':
240                    self.tree_ctrl.CheckItem(data_ctrl, False) 
241        self.enable_append()
242        self.enable_freeze()
243        self.enable_plot()
244        self.enable_import()
245        self.enable_remove()
246               
247    def layout_button(self):
248        """
249        Layout widgets related to buttons
250        """
251        w, _ = self.GetSize()
252       
253        self.bt_add = wx.Button(self, wx.NewId(), "Load Data", 
254                                size=(BUTTON_WIDTH, -1))
255        self.bt_add.SetToolTipString("Load data files")
256        wx.EVT_BUTTON(self, self.bt_add.GetId(), self._load_data)
257        self.bt_remove = wx.Button(self, wx.NewId(), "Delete Data",
258         size=(BUTTON_WIDTH, -1))
259        self.bt_remove.SetToolTipString("Delete data from the application")
260        wx.EVT_BUTTON(self, self.bt_remove.GetId(), self.on_remove)
261        self.bt_import = wx.Button(self, wx.NewId(), "Send To",
262                                    size=(BUTTON_WIDTH, -1))
263        self.bt_import.SetToolTipString("Send set of Data to active perspective")
264        wx.EVT_BUTTON(self, self.bt_import.GetId(), self.on_import)
265        self.perspective_cbox = wx.ComboBox(self, -1,
266                                style=wx.CB_READONLY)
267        #self.perspective_cbox.SetMinSize((CBOX_WIDTH, -1))
268        wx.EVT_COMBOBOX(self.perspective_cbox,-1, 
269                        self._on_perspective_selection)
270   
271        self.bt_append_plot = wx.Button(self, wx.NewId(), "Append Plot To",
272                                        size=(BUTTON_WIDTH, -1))
273        self.bt_append_plot.SetToolTipString("Plot the selected data in the active panel")
274        wx.EVT_BUTTON(self, self.bt_append_plot.GetId(), self.on_append_plot)
275       
276        self.bt_plot = wx.Button(self, wx.NewId(), "New Plot", 
277                                 size=(BUTTON_WIDTH, -1))
278        self.bt_plot.SetToolTipString("To trigger plotting")
279        wx.EVT_BUTTON(self, self.bt_plot.GetId(), self.on_plot)
280       
281        self.bt_freeze = wx.Button(self, wx.NewId(), "Freeze Theory", 
282                                   size=(BUTTON_WIDTH, -1))
283        self.bt_freeze.SetToolTipString("To trigger freeze a theory")
284        wx.EVT_BUTTON(self, self.bt_freeze.GetId(), self.on_freeze)
285        #hide plot
286        #self.bt_close_plot = wx.Button(self, wx.NewId(), "Delete Plot",
287        #                           size=(BUTTON_WIDTH, -1))
288        #self.bt_close_plot.SetToolTipString("Delete the plot panel on focus")
289        #wx.EVT_BUTTON(self, self.bt_close_plot.GetId(), self.on_close_plot)
290       
291        self.cb_plotpanel = wx.ComboBox(self, -1, 
292                                style=wx.CB_READONLY|wx.CB_SORT)
293        #self.cb_plotpanel.SetMinSize((CBOX_WIDTH, -1))
294        wx.EVT_COMBOBOX(self.cb_plotpanel,-1, self._on_plot_selection)
295        self.cb_plotpanel.Disable()
296
297        self.sizer3.AddMany([(self.bt_add),
298                             ((10, 10)),
299                             (self.bt_remove),
300                             ((10, 10)),
301                             (self.bt_import, 0, wx.EXPAND|wx.RIGHT, 5),
302                              (self.perspective_cbox, wx.EXPAND|wx.ADJUST_MINSIZE, 5),
303                              (self.bt_append_plot),
304                              (self.cb_plotpanel, wx.EXPAND|wx.ADJUST_MINSIZE, 5),
305                              (self.bt_plot),
306                              ((10, 10)),
307                              (self.bt_freeze),
308                              #((10, 10)),
309                              #(self.bt_close_plot),
310                              ((10, 10))])
311
312        self.sizer3.AddGrowableCol(1, 1)
313        self.show_data_button()
314        self.enable_remove()
315        self.enable_import()
316        self.enable_plot()
317        self.enable_append()
318        self.enable_freeze()
319        self.enable_remove_plot()
320       
321    def layout_batch(self):
322        """
323        """
324        self.rb_single_mode = wx.RadioButton(self, -1, 'Single Mode',
325                                             style=wx.RB_GROUP)
326        self.rb_batch_mode = wx.RadioButton(self, -1, 'Batch Mode')
327       
328        self.rb_single_mode.SetValue(True)
329        self.rb_batch_mode.SetValue(False)
330        self.sizer4.AddMany([(self.rb_single_mode,0, wx.ALL,5),
331                            (self.rb_batch_mode,0, wx.ALL,5)])
332     
333    def layout_data_list(self):
334        """
335        Add a listcrtl in the panel
336        """
337        tree_ctrl_label = wx.StaticText(self, -1, "Data")
338        tree_ctrl_label.SetForegroundColour('blue')
339        self.tree_ctrl = DataTreeCtrl(parent=self)
340        self.tree_ctrl.Bind(CT.EVT_TREE_ITEM_CHECKING, self.on_check_item)
341        tree_ctrl_theory_label = wx.StaticText(self, -1, "Theory")
342        tree_ctrl_theory_label.SetForegroundColour('blue')
343        self.tree_ctrl_theory = DataTreeCtrl(parent=self)
344        self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_CHECKING, self.on_check_item)
345        self.sizer1.Add(tree_ctrl_label, 0, wx.LEFT, 10)
346        self.sizer1.Add(self.tree_ctrl, 1, wx.EXPAND|wx.ALL, 10)
347        self.sizer1.Add(tree_ctrl_theory_label, 0,  wx.LEFT, 10)
348        self.sizer1.Add(self.tree_ctrl_theory, 1, wx.EXPAND|wx.ALL, 10)
349           
350    def onContextMenu(self, event): 
351        """
352        Retrieve the state selected state
353        """
354        # Skipping the save state functionality for release 0.9.0
355        #return
356        pos = event.GetPosition()
357        pos = self.ScreenToClient(pos)
358        self.PopupMenu(self.popUpMenu, pos) 
359     
360 
361    def on_check_item(self, event):
362        """
363        """
364        item = event.GetItem()
365        item.Check(not item.IsChecked()) 
366        self.enable_append()
367        self.enable_freeze()
368        self.enable_plot()
369        self.enable_import()
370        self.enable_remove()
371        event.Skip()
372       
373    def fill_cbox_analysis(self, plugin):
374        """
375        fill the combobox with analysis name
376        """
377        self.list_of_perspective = plugin
378        if self.parent is None or \
379            not hasattr(self.parent, "get_current_perspective") or \
380            len(self.list_of_perspective) == 0:
381            return
382        if self.parent is not None and self.perspective_cbox  is not None:
383            for plug in self.list_of_perspective:
384                if plug.get_perspective():
385                    self.perspective_cbox.Append(plug.sub_menu, plug)
386           
387            curr_pers = self.parent.get_current_perspective()
388            self.perspective_cbox.SetStringSelection(curr_pers.sub_menu)
389        self.enable_import()
390                       
391    def load_data_list(self, list):
392        """
393        add need data with its theory under the tree
394        """
395        if list:
396            for state_id, dstate in list.iteritems():
397                data = dstate.get_data()
398                theory_list = dstate.get_theory()
399                if data is not None:
400                    data_name = data.name
401                    data_class = data.__class__.__name__
402                    path = dstate.get_path() 
403                    process_list = data.process
404                    data_id = data.id
405                   
406                    if state_id not in self.list_cb_data:
407                        #new state
408                        data_c = self.tree_ctrl.InsertItem(self.tree_ctrl.root,0,
409                                                           data_name, ct_type=1, 
410                                             data=(data_id, data_class, state_id))
411                        data_c.Check(True)
412                        d_i_c = self.tree_ctrl.AppendItem(data_c, 'Info')
413                        i_c_c = self.tree_ctrl.AppendItem(d_i_c, 
414                                                      'Type: %s' % data_class)
415                        p_c_c = self.tree_ctrl.AppendItem(d_i_c,
416                                                      'Path: %s' % str(path))
417                        d_p_c = self.tree_ctrl.AppendItem(d_i_c, 'Process')
418                       
419                        for process in process_list:
420                            i_t_c = self.tree_ctrl.AppendItem(d_p_c,
421                                                              process.__str__())
422                        theory_child = self.tree_ctrl.AppendItem(data_c, "THEORIES")
423                       
424                        self.list_cb_data[state_id] = [data_c, 
425                                                       d_i_c,
426                                                       i_c_c,
427                                                        p_c_c,
428                                                         d_p_c,
429                                                         theory_child]
430                    else:
431                        data_ctrl_list =  self.list_cb_data[state_id]
432                        #This state is already display replace it contains
433                        data_c, d_i_c, i_c_c, p_c_c, d_p_c, t_c = data_ctrl_list
434                        self.tree_ctrl.SetItemText(data_c, data_name) 
435                        temp = (data_id, data_class, state_id)
436                        self.tree_ctrl.SetItemPyData(data_c, temp) 
437                        self.tree_ctrl.SetItemText(i_c_c, 'Type: %s' % data_class)
438                        self.tree_ctrl.SetItemText(p_c_c, 'Path: %s' % str(path)) 
439                        self.tree_ctrl.DeleteChildren(d_p_c) 
440                        for process in process_list:
441                            i_t_c = self.tree_ctrl.AppendItem(d_p_c,
442                                                              process.__str__())
443                self.append_theory(state_id, theory_list)
444        self.enable_remove()
445        self.enable_import()
446        self.enable_plot()
447        self.enable_freeze()
448        self.enable_selection()
449       
450    def _uncheck_all(self):
451        """
452        Uncheck all check boxes
453        """
454        for item in self.list_cb_data.values():
455            data_ctrl, _, _, _,_, _ = item
456            self.tree_ctrl.CheckItem(data_ctrl, False) 
457        self.enable_append()
458        self.enable_freeze()
459        self.enable_plot()
460        self.enable_import()
461        self.enable_remove()
462   
463    def append_theory(self, state_id, theory_list):
464        """
465        append theory object under data from a state of id = state_id
466        replace that theory if  already displayed
467        """
468        if not theory_list:
469            return 
470        if state_id not in self.list_cb_data.keys():
471            root = self.tree_ctrl_theory.root
472            tree = self.tree_ctrl_theory
473        else:
474            item = self.list_cb_data[state_id]
475            data_c, _, _, _, _, _ = item
476            root = data_c
477            tree = self.tree_ctrl
478        if root is not None:
479             self.append_theory_helper(tree=tree, root=root, 
480                                       state_id=state_id, 
481                                       theory_list=theory_list)
482     
483     
484    def append_theory_helper(self, tree, root, state_id, theory_list):
485        """
486        """
487        if state_id in self.list_cb_theory.keys():
488            #update current list of theory for this data
489            theory_list_ctrl = self.list_cb_theory[state_id]
490
491            for theory_id, item in theory_list.iteritems():
492                theory_data, theory_state = item
493                if theory_data is None:
494                    name = "Unknown"
495                    theory_class = "Unknown"
496                    theory_id = "Unknown"
497                    temp = (None, None, None)
498                else:
499                    name = theory_data.name
500                    theory_class = theory_data.__class__.__name__
501                    theory_id = theory_data.id
502                    #if theory_state is not None:
503                    #    name = theory_state.model.name
504                    temp = (theory_id, theory_class, state_id)
505                if theory_id not in theory_list_ctrl:
506                    #add new theory
507                    t_child = tree.AppendItem(root,
508                                                    name, ct_type=1, data=temp)
509                    t_i_c = tree.AppendItem(t_child, 'Info')
510                    i_c_c = tree.AppendItem(t_i_c, 
511                                                  'Type: %s' % theory_class)
512                    t_p_c = tree.AppendItem(t_i_c, 'Process')
513                   
514                    for process in theory_data.process:
515                        i_t_c = tree.AppendItem(t_p_c,
516                                                          process.__str__())
517                    theory_list_ctrl[theory_id] = [t_child, 
518                                                   i_c_c, 
519                                                   t_p_c]
520                else:
521                    #replace theory
522                    t_child, i_c_c, t_p_c = theory_list_ctrl[theory_id]
523                    tree.SetItemText(t_child, name) 
524                    tree.SetItemPyData(t_child, temp) 
525                    tree.SetItemText(i_c_c, 'Type: %s' % theory_class) 
526                    tree.DeleteChildren(t_p_c) 
527                    for process in theory_data.process:
528                        i_t_c = tree.AppendItem(t_p_c,
529                                                          process.__str__())
530             
531        else:
532            #data didn't have a theory associated it before
533            theory_list_ctrl = {}
534            for theory_id, item in theory_list.iteritems():
535                theory_data, theory_state = item
536                if theory_data is not None:
537                    name = theory_data.name
538                    theory_class = theory_data.__class__.__name__
539                    theory_id = theory_data.id
540                    #if theory_state is not None:
541                    #    name = theory_state.model.name
542                    temp = (theory_id, theory_class, state_id)
543                    t_child = tree.AppendItem(root,
544                            name, ct_type=1, 
545                            data=(theory_data.id, theory_class, state_id))
546                    t_i_c = tree.AppendItem(t_child, 'Info')
547                    i_c_c = tree.AppendItem(t_i_c, 
548                                                  'Type: %s' % theory_class)
549                    t_p_c = tree.AppendItem(t_i_c, 'Process')
550                   
551                    for process in theory_data.process:
552                        i_t_c = tree.AppendItem(t_p_c,
553                                                          process.__str__())
554           
555                    theory_list_ctrl[theory_id] = [t_child, i_c_c, t_p_c]
556                #self.list_cb_theory[data_id] = theory_list_ctrl
557                self.list_cb_theory[state_id] = theory_list_ctrl
558       
559           
560   
561    def set_data_helper(self):
562        """
563        """
564        data_to_plot = []
565        state_to_plot = []
566        theory_to_plot = []
567        for value in self.list_cb_data.values():
568            item, _, _, _, _, _ = value
569            if item.IsChecked():
570                data_id, _, state_id = self.tree_ctrl.GetItemPyData(item)
571                data_to_plot.append(data_id)
572                if state_id not in state_to_plot:
573                    state_to_plot.append(state_id)
574           
575        for theory_dict in self.list_cb_theory.values():
576            for key, value in theory_dict.iteritems():
577                item, _, _ = value
578                if item.IsChecked():
579                    theory_id, _, state_id = self.tree_ctrl.GetItemPyData(item)
580                    theory_to_plot.append(theory_id)
581                    if state_id not in state_to_plot:
582                        state_to_plot.append(state_id)
583        return data_to_plot, theory_to_plot, state_to_plot
584   
585    def remove_by_id(self, id):
586        """
587        """
588        for item in self.list_cb_data.values():
589            data_c, _, _, _, _, theory_child = item
590            data_id, _, state_id = self.tree_ctrl.GetItemPyData(data_c) 
591            if id == data_id:
592                self.tree_ctrl.Delete(data_c)
593                del self.list_cb_data[state_id]
594                del self.list_cb_theory[data_id]
595             
596    def load_error(self, error=None):
597        """
598        Pop up an error message.
599       
600        :param error: details error message to be displayed
601        """
602        if error is not None or str(error).strip() != "":
603            dial = wx.MessageDialog(self.parent, str(error), 'Error Loading File',
604                                wx.OK | wx.ICON_EXCLAMATION)
605            dial.ShowModal() 
606       
607    def _load_data(self, event):
608        """
609        send an event to the parent to trigger load from plugin module
610        """
611        if self.parent is not None:
612            wx.PostEvent(self.parent, NewLoadDataEvent())
613           
614
615    def on_remove(self, event):
616        """
617        Get a list of item checked and remove them from the treectrl
618        Ask the parent to remove reference to this item
619        """
620        data_to_remove, theory_to_remove, _ = self.set_data_helper()
621        data_key = []
622        theory_key = []
623        #remove  data from treectrl
624        for d_key, item in self.list_cb_data.iteritems():
625            data_c, d_i_c, i_c_c, p_c_c, d_p_c, t_c = item
626            if data_c.IsChecked():
627                self.tree_ctrl.Delete(data_c)
628                data_key.append(d_key)
629                if d_key in self.list_cb_theory.keys():
630                    theory_list_ctrl = self.list_cb_theory[d_key]
631                    theory_to_remove += theory_list_ctrl.keys()
632        # Remove theory from treectrl       
633        for t_key, theory_dict in self.list_cb_theory.iteritems():
634            for  key, value in theory_dict.iteritems():
635                item, _, _ = value
636                if item.IsChecked():
637                    try:
638                        self.tree_ctrl.Delete(item)
639                    except:
640                        pass
641                    theory_key.append(key)
642                   
643        #Remove data and related theory references
644        for key in data_key:
645            del self.list_cb_data[key]
646            if key in theory_key:
647                del self.list_cb_theory[key]
648        #remove theory  references independently of data
649        for key in theory_key:
650            for t_key, theory_dict in self.list_cb_theory.iteritems():
651                if key in theory_dict:
652                    for  key, value in theory_dict.iteritems():
653                        item, _, _ = value
654                        if item.IsChecked():
655                            try:
656                                self.tree_ctrl_theory.Delete(item)
657                            except:
658                                pass
659                    del theory_dict[key]
660                   
661           
662        self.parent.remove_data(data_id=data_to_remove,
663                                  theory_id=theory_to_remove)
664        self.enable_remove()
665        self.enable_freeze()
666        self.enable_remove_plot()
667       
668    def on_import(self, event=None):
669        """
670        Get all select data and set them to the current active perspetive
671        """
672        data_id, theory_id, state_id = self.set_data_helper()
673        temp = data_id + state_id
674        self.parent.set_data(data_id=temp, theory_id=theory_id)
675       
676    def on_append_plot(self, event=None):
677        """
678        append plot to plot panel on focus
679        """
680        self._on_plot_selection()
681        data_id, theory_id, state_id = self.set_data_helper()
682        self.parent.plot_data(data_id=data_id, 
683                              state_id=state_id,
684                              theory_id=theory_id,
685                              append=True)
686   
687    def on_plot(self, event=None):
688        """
689        Send a list of data names to plot
690        """
691        data_id, theory_id, state_id = self.set_data_helper()
692        self.parent.plot_data(data_id=data_id, 
693                              state_id=state_id,
694                              theory_id=theory_id,
695                              append=False)
696        self.enable_remove_plot()
697         
698    def on_close_page(self, event=None):
699        """
700        On close
701        """
702        if event != None:
703            event.Skip()
704        # send parent to update menu with no show nor hide action
705        self.parent.show_data_panel(action=False)
706   
707    def on_freeze(self, event):
708        """
709        """
710        _, theory_id, state_id = self.set_data_helper()
711        self.parent.freeze(data_id=state_id, theory_id=theory_id)
712       
713    def set_active_perspective(self, name):
714        """
715        set the active perspective
716        """
717        self.perspective_cbox.SetStringSelection(name)
718        self.enable_import()
719       
720    def _on_delete_plot_panel(self, event):
721        """
722        get an event with attribute name and caption to delete existing name
723        from the combobox of the current panel
724        """
725        name = event.name
726        caption = event.caption
727        if self.cb_plotpanel is not None:
728            pos = self.cb_plotpanel.FindString(str(caption)) 
729            if pos != wx.NOT_FOUND:
730                self.cb_plotpanel.Delete(pos)
731        self.enable_append()
732       
733    def set_panel_on_focus(self, name=None):
734        """
735        set the plot panel on focus
736        """
737        for key, value in self.parent.plot_panels.iteritems():
738            name_plot_panel = str(value.window_caption)
739            if name_plot_panel not in self.cb_plotpanel.GetItems():
740                self.cb_plotpanel.Append(name_plot_panel, value)
741            if name != None and name == name_plot_panel:
742                self.cb_plotpanel.SetStringSelection(name_plot_panel)
743                break
744        self.enable_append()
745        self.enable_remove_plot()
746       
747    def _on_perspective_selection(self, event=None):
748        """
749        select the current perspective for guiframe
750        """
751        selection = self.perspective_cbox.GetSelection()
752
753        if self.perspective_cbox.GetValue() != 'None':
754            perspective = self.perspective_cbox.GetClientData(selection)
755            perspective.on_perspective(event=None)
756       
757    def _on_plot_selection(self, event=None):
758        """
759        On source combobox selection
760        """
761        if event != None:
762            combo = event.GetEventObject()
763            event.Skip()
764        else:
765            combo = self.cb_plotpanel
766        selection = combo.GetSelection()
767
768        if combo.GetValue() != 'None':
769            panel = combo.GetClientData(selection)
770            self.parent.on_set_plot_focus(panel)   
771           
772    def on_close_plot(self, event):
773        """
774        clseo the panel on focus
775        """ 
776        self.enable_append()
777        selection = self.cb_plotpanel.GetSelection()
778        if self.cb_plotpanel.GetValue() != 'None':
779            panel = self.cb_plotpanel.GetClientData(selection)
780            if self.parent is not None and panel is not None:
781                wx.PostEvent(self.parent, 
782                             NewPlotEvent(group_id=panel.group_id,
783                                          action="delete"))
784        self.enable_remove_plot()
785       
786    def enable_remove_plot(self):
787        """
788        enable remove plot button if there is a plot panel on focus
789        """
790        pass
791        #if self.cb_plotpanel.GetCount() == 0:
792        #    self.bt_close_plot.Disable()
793        #else:
794        #    self.bt_close_plot.Enable()
795           
796    def enable_remove(self):
797        """
798        enable or disable remove button
799        """
800        n_t = self.tree_ctrl.GetCount()
801        n_t_t = self.tree_ctrl_theory.GetCount()
802        if n_t + n_t_t <= 0:
803            self.bt_remove.Disable()
804        else:
805            self.bt_remove.Enable()
806           
807    def enable_import(self):
808        """
809        enable or disable send button
810        """
811        n_t = 0
812        if self.tree_ctrl != None:
813            n_t = self.tree_ctrl.GetCount()
814        if n_t > 0 and len(self.list_of_perspective) > 0:
815            self.bt_import.Enable()
816        else:
817            self.bt_import.Disable()
818        if len(self.list_of_perspective) <= 0 or \
819            self.perspective_cbox.GetValue()  in ["None",
820                                                "No Active Application"]:
821            self.perspective_cbox.Disable()
822        else:
823            self.perspective_cbox.Enable()
824           
825    def enable_plot(self):
826        """
827        enable or disable plot button
828        """
829        n_t = 0 
830        n_t_t = 0
831        if self.tree_ctrl != None:
832            n_t = self.tree_ctrl.GetCount()
833        if self.tree_ctrl_theory != None:
834            n_t_t = self.tree_ctrl_theory.GetCount()
835        if n_t + n_t_t <= 0:
836            self.bt_plot.Disable()
837        else:
838            self.bt_plot.Enable()
839        self.enable_append()
840       
841    def enable_append(self):
842        """
843        enable or disable append button
844        """
845        n_t = 0 
846        n_t_t = 0
847        if self.tree_ctrl != None:
848            n_t = self.tree_ctrl.GetCount()
849        if self.tree_ctrl_theory != None:
850            n_t_t = self.tree_ctrl_theory.GetCount()
851        if n_t + n_t_t <= 0: 
852            self.bt_append_plot.Disable()
853            self.cb_plotpanel.Disable()
854        elif self.cb_plotpanel.GetCount() <= 0:
855                self.cb_plotpanel.Disable()
856                self.bt_append_plot.Disable()
857        else:
858            self.bt_append_plot.Enable()
859            self.cb_plotpanel.Enable()
860           
861    def check_theory_to_freeze(self):
862        """
863        """
864    def enable_freeze(self):
865        """
866        enable or disable the freeze button
867        """
868        n_t_t = 0
869        n_l = 0
870        if self.tree_ctrl_theory != None:
871            n_t_t = self.tree_ctrl_theory.GetCount()
872        n_l = len(self.list_cb_theory)
873        if (n_t_t + n_l > 0):
874            self.bt_freeze.Enable()
875        else:
876            self.bt_freeze.Disable()
877       
878    def enable_selection(self):
879        """
880        enable or disable combobo box selection
881        """
882        n_t = 0
883        n_t_t = 0
884        if self.tree_ctrl != None:
885            n_t = self.tree_ctrl.GetCount()
886        if self.tree_ctrl_theory != None:
887            n_t_t = self.tree_ctrl_theory.GetCount()
888        if n_t + n_t_t > 0 and self.selection_cbox != None:
889            self.selection_cbox.Enable()
890        else:
891            self.selection_cbox.Disable()
892           
893    def show_data_button(self):
894        """
895        show load data and remove data button if
896        dataloader on else hide them
897        """
898        try:
899            gui_style = self.parent.get_style()
900            style = gui_style & GUIFRAME.DATALOADER_ON
901            if style == GUIFRAME.DATALOADER_ON: 
902                #self.bt_remove.Show(True)
903                self.bt_add.Show(True) 
904            else:
905                #self.bt_remove.Hide()
906                self.bt_add.Hide()
907        except: 
908            #self.bt_remove.Hide()
909            self.bt_add.Hide() 
910   
911
912
913WIDTH = 400
914HEIGHT = 300
915
916
917class DataDialog(wx.Dialog):
918    """
919    Allow file selection at loading time
920    """
921    def __init__(self, data_list, parent=None, text='', *args, **kwds):
922        wx.Dialog.__init__(self, parent, *args, **kwds)
923        self.SetTitle("Data Selection")
924        self.SetSize((WIDTH, HEIGHT))
925        self.list_of_ctrl = []
926        if not data_list:
927            return 
928        self._sizer_main = wx.BoxSizer(wx.VERTICAL)
929        self._sizer_txt = wx.BoxSizer(wx.VERTICAL)
930        self._sizer_button = wx.BoxSizer(wx.HORIZONTAL)
931        self.sizer = wx.GridBagSizer(5, 5)
932        self._panel = ScrolledPanel(self, style=wx.RAISED_BORDER,
933                               size=(WIDTH-20, HEIGHT-50))
934        self._panel.SetupScrolling()
935        self.__do_layout(data_list, text=text)
936       
937    def __do_layout(self, data_list, text=''):
938        """
939        layout the dialog
940        """
941        if not data_list or len(data_list) <= 1:
942            return 
943        #add text
944       
945        text = "Deleting these file reset some panels.\n"
946        text += "Do you want to proceed?\n"
947        text_ctrl = wx.StaticText(self, -1, str(text))
948        self._sizer_txt.Add(text_ctrl)
949        iy = 0
950        ix = 0
951        data_count = 0
952        for (data_name, in_use, sub_menu) in range(len(data_list)):
953            if in_use == True:
954                ctrl_name = wx.StaticBox(self, -1, str(data_name))
955                ctrl_in_use = wx.StaticBox(self, -1, " is used by ")
956                plug_name = str(sub_menu) + "\n"
957                ctrl_sub_menu = wx.StaticBox(self, -1, plug_name)
958                self.sizer.Add(ctrl_name, (iy, ix),
959                           (1, 1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
960                ix += 1
961                self._sizer_button.Add(ctrl_in_use, 1,
962                                        wx.EXPAND|wx.ADJUST_MINSIZE, 0)
963                ix += 1
964                self._sizer_button.Add(plug_name, 1,
965                                        wx.EXPAND|wx.ADJUST_MINSIZE, 0)
966            iy += 1
967        self._panel.SetSizer(self.sizer)
968        #add sizer
969        self._sizer_button.Add((20, 20), 1, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
970        button_cancel = wx.Button(self, wx.ID_CANCEL, "Cancel")
971        self._sizer_button.Add(button_cancel, 0,
972                          wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
973        button_OK = wx.Button(self, wx.ID_OK, "Ok")
974        button_OK.SetFocus()
975        self._sizer_button.Add(button_OK, 0,
976                                wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
977        static_line = wx.StaticLine(self, -1)
978       
979        self._sizer_txt.Add(self._panel, 1, wx.EXPAND|wx.LEFT|wx.RIGHT, 5)
980        self._sizer_main.Add(self._sizer_txt, 1, wx.EXPAND|wx.ALL, 10)
981        self._sizer_main.Add(self._data_text_ctrl, 0, 
982                             wx.EXPAND|wx.LEFT|wx.RIGHT, 10)
983        self._sizer_main.Add(static_line, 0, wx.EXPAND, 0)
984        self._sizer_main.Add(self._sizer_button, 0, wx.EXPAND|wx.ALL, 10)
985        self.SetSizer(self._sizer_main)
986        self.Layout()
987       
988    def get_data(self):
989        """
990        return the selected data
991        """
992        temp = []
993        for item in self.list_of_ctrl:
994            cb, data = item
995            if cb.GetValue():
996                temp.append(data)
997        return temp
998   
999    def _count_selected_data(self, event):
1000        """
1001        count selected data
1002        """
1003        if event.GetEventObject().GetValue():
1004            self._nb_selected_data += 1
1005        else:
1006            self._nb_selected_data -= 1
1007        select_data_text = " %s Data selected.\n" % str(self._nb_selected_data)
1008        self._data_text_ctrl.SetLabel(select_data_text)
1009        if self._nb_selected_data <= self._max_data:
1010            self._data_text_ctrl.SetForegroundColour('blue')
1011        else:
1012            self._data_text_ctrl.SetForegroundColour('red')
1013       
1014                 
1015       
1016class DataFrame(wx.Frame):
1017    ## Internal name for the AUI manager
1018    window_name = "Data Panel"
1019    ## Title to appear on top of the window
1020    window_caption = "Data Panel"
1021    ## Flag to tell the GUI manager that this panel is not
1022    #  tied to any perspective
1023    ALWAYS_ON = True
1024   
1025    def __init__(self, parent=None, owner=None, manager=None,size=(300, 800),
1026                         list_of_perspective=[],list=[], *args, **kwds):
1027        kwds['size'] = size
1028        kwds['id'] = -1
1029        kwds['title']= "Loaded Data"
1030        wx.Frame.__init__(self, parent=parent, *args, **kwds)
1031        self.parent = parent
1032        self.owner = owner
1033        self.manager = manager
1034        self.panel = DataPanel(parent=self, 
1035                               #size=size,
1036                               list_of_perspective=list_of_perspective)
1037     
1038    def load_data_list(self, list=[]):
1039        """
1040        Fill the list inside its panel
1041        """
1042        self.panel.load_data_list(list=list)
1043       
1044   
1045   
1046from dataFitting import Data1D
1047from dataFitting import Data2D, Theory1D
1048from data_state import DataState
1049import sys
1050class State():
1051    def __init__(self):
1052        self.msg = ""
1053    def __str__(self):
1054        self.msg = "model mane : model1\n"
1055        self.msg += "params : \n"
1056        self.msg += "name  value\n"
1057        return msg
1058def set_data_state(data=None, path=None, theory=None, state=None):
1059    dstate = DataState(data=data)
1060    dstate.set_path(path=path)
1061    dstate.set_theory(theory, state)
1062 
1063    return dstate
1064"""'
1065data_list = [1:('Data1', 'Data1D', '07/01/2010', "theory1d", "state1"),
1066            ('Data2', 'Data2D', '07/03/2011', "theory2d", "state1"),
1067            ('Data3', 'Theory1D', '06/01/2010', "theory1d", "state1"),
1068            ('Data4', 'Theory2D', '07/01/2010', "theory2d", "state1"),
1069            ('Data5', 'Theory2D', '07/02/2010', "theory2d", "state1")]
1070"""     
1071if __name__ == "__main__":
1072   
1073    app = wx.App()
1074    try:
1075        list_of_perspective = [('perspective2', False), ('perspective1', True)]
1076        data_list = {}
1077        # state 1
1078        data = Data2D()
1079        data.name = "data2"
1080        data.id = 1
1081        data.append_empty_process()
1082        process = data.process[len(data.process)-1]
1083        process.data = "07/01/2010"
1084        theory = Data2D()
1085        theory.id = 34
1086        theory.name = "theory1"
1087        path = "path1"
1088        state = State()
1089        data_list['1']=set_data_state(data, path,theory, state)
1090        #state 2
1091        data = Data2D()
1092        data.name = "data2"
1093        data.id = 76
1094        theory = Data2D()
1095        theory.id = 78
1096        theory.name = "CoreShell 07/24/25"
1097        path = "path2"
1098        #state3
1099        state = State()
1100        data_list['2']=set_data_state(data, path,theory, state)
1101        data = Data1D()
1102        data.id = 3
1103        data.name = "data2"
1104        theory = Theory1D()
1105        theory.name = "CoreShell"
1106        theory.id = 4
1107        theory.append_empty_process()
1108        process = theory.process[len(theory.process)-1]
1109        process.description = "this is my description"
1110        path = "path3"
1111        data.append_empty_process()
1112        process = data.process[len(data.process)-1]
1113        process.data = "07/22/2010"
1114        data_list['4']=set_data_state(data, path,theory, state)
1115        #state 4
1116        temp_data_list = {}
1117        data.name = "data5 erasing data2"
1118        temp_data_list['4'] = set_data_state(data, path,theory, state)
1119        #state 5
1120        data = Data2D()
1121        data.name = "data3"
1122        data.id = 5
1123        data.append_empty_process()
1124        process = data.process[len(data.process)-1]
1125        process.data = "07/01/2010"
1126        theory = Theory1D()
1127        theory.name = "Cylinder"
1128        path = "path2"
1129        state = State()
1130        dstate= set_data_state(data, path,theory, state)
1131        theory = Theory1D()
1132        theory.id = 6
1133        theory.name = "CoreShell"
1134        dstate.set_theory(theory)
1135        theory = Theory1D()
1136        theory.id = 6
1137        theory.name = "CoreShell replacing coreshell in data3"
1138        dstate.set_theory(theory)
1139        data_list['3'] = dstate
1140        #state 6
1141        data_list['6']=set_data_state(None, path,theory, state)
1142        data_list['6']=set_data_state(theory=theory, state=None)
1143        theory = Theory1D()
1144        theory.id = 7
1145        data_list['6']=set_data_state(theory=theory, state=None)
1146        data_list['7']=set_data_state(theory=theory, state=None)
1147        window = DataFrame(list=data_list)
1148        window.load_data_list(list=data_list)
1149        window.Show(True)
1150        window.load_data_list(list=temp_data_list)
1151    except:
1152        #raise
1153        print "error",sys.exc_value
1154       
1155    app.MainLoop() 
1156   
1157   
Note: See TracBrowser for help on using the repository browser.