source: sasview/sansguiframe/src/sans/guiframe/data_panel.py @ 3576dd0

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 3576dd0 was 7360816, checked in by Jae Cho <jhjcho@…>, 13 years ago

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