source: sasview/sansguiframe/src/sans/guiframe/data_panel.py @ 108470e6

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

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