source: sasview/sansguiframe/src/sans/guiframe/data_panel.py @ 3912db5

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 3912db5 was bf39777, checked in by Gervaise Alina <gervyh@…>, 13 years ago

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