################################################################################ #This software was developed by the University of Tennessee as part of the #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) #project funded by the US National Science Foundation. # #See the license text in license.txt # #copyright 2010, University of Tennessee ################################################################################ """ This module provides Graphic interface for the data_manager module. """ import wx from wx.build import build_options # Check version toks = str(wx.__version__).split('.') if int(toks[1]) < 9: if int(toks[2]) < 12: wx_version = 811 else: wx_version = 812 else: wx_version = 900 import sys from wx.lib.scrolledpanel import ScrolledPanel import wx.lib.agw.customtreectrl as CT from sas.guiframe.dataFitting import Data1D from sas.guiframe.dataFitting import Data2D from sas.guiframe.panel_base import PanelBase from sas.guiframe.events import StatusEvent from sas.guiframe.events import EVT_DELETE_PLOTPANEL from sas.guiframe.events import NewLoadDataEvent from sas.guiframe.events import NewPlotEvent from sas.guiframe.gui_style import GUIFRAME from sas.guiframe.events import NewBatchEvent from sas.dataloader.loader import Loader #from sas.guiframe.local_perspectives.plotting.masking \ # import FloatPanel as QucikPlotDialog from sas.guiframe.local_perspectives.plotting.SimplePlot import PlotFrame \ as QucikPlotDialog import sas.guiframe.config as config extension_list = [] if config.APPLICATION_STATE_EXTENSION is not None: extension_list.append(config.APPLICATION_STATE_EXTENSION) EXTENSIONS = config.PLUGIN_STATE_EXTENSIONS + extension_list PLUGINS_WLIST = config.PLUGINS_WLIST APPLICATION_WLIST = config.APPLICATION_WLIST #Control panel width if sys.platform.count("win32") > 0: PANEL_WIDTH = 235 PANEL_HEIGHT = 700 CBOX_WIDTH = 140 BUTTON_WIDTH = 80 FONT_VARIANT = 0 IS_MAC = False else: PANEL_WIDTH = 255 PANEL_HEIGHT = 750 CBOX_WIDTH = 155 BUTTON_WIDTH = 100 FONT_VARIANT = 1 IS_MAC = True STYLE_FLAG = wx.RAISED_BORDER|CT.TR_HAS_BUTTONS| CT.TR_HIDE_ROOT|\ wx.WANTS_CHARS|CT.TR_HAS_VARIABLE_ROW_HEIGHT class DataTreeCtrl(CT.CustomTreeCtrl): """ Check list control to be used for Data Panel """ def __init__(self, parent, *args, **kwds): #agwstyle is introduced in wx.2.8.11 but is not working for mac if IS_MAC and wx_version < 812: try: kwds['style'] = STYLE_FLAG CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds) except: del kwds['style'] CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds) else: # agwstyle is introduced in wx.2.8.11 # argument working only for windows try: kwds['agwStyle'] = STYLE_FLAG CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds) except: try: del kwds['agwStyle'] kwds['style'] = STYLE_FLAG CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds) except: del kwds['style'] CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds) self.root = self.AddRoot("Available Data") def OnCompareItems(self, item1, item2): """ Overrides OnCompareItems in wx.TreeCtrl. Used by the SortChildren method. """ # Get the item data data_1 = self.GetItemText(item1) data_2 = self.GetItemText(item2) # Compare the item data if data_1 < data_2: return -1 elif data_1 > data_2: return 1 else: return 0 class DataPanel(ScrolledPanel, PanelBase): """ This panel displays data available in the application and widgets to interact with data. """ ## Internal name for the AUI manager window_name = "Data Panel" ## Title to appear on top of the window window_caption = "Data Explorer" #type of window window_type = "Data Panel" ## Flag to tell the GUI manager that this panel is not # tied to any perspective #ALWAYS_ON = True def __init__(self, parent, list=None, size=(PANEL_WIDTH, PANEL_HEIGHT), id=-1, list_of_perspective=None, manager=None, *args, **kwds): #kwds['size'] = size #kwds['style'] = STYLE_FLAG ScrolledPanel.__init__(self, parent=parent, id=id, *args, **kwds) PanelBase.__init__(self, parent) self.SetupScrolling() #Set window's font size self.SetWindowVariant(variant=FONT_VARIANT) self.loader = Loader() #Default location self._default_save_location = None self.all_data1d = True self.parent = parent.parent self._manager = manager self.frame = parent if list is None: list = [] self.list_of_data = list if list_of_perspective is None: list_of_perspective = [] self.list_of_perspective = list_of_perspective self.list_rb_perspectives = [] self.list_cb_data = {} self.list_cb_theory = {} self.tree_ctrl = None self.tree_ctrl_theory = None self.perspective_cbox = None ## Create context menu for page self.data_menu = None self.popUpMenu = None self.plot3d_id = None self.editmask_id = None # Default attr self.vbox = None self.sizer1 = None self.sizer2 = None self.sizer3 = None self.sizer4 = None self.sizer5 = None self.selection_cbox = None self.bt_add = None self.bt_remove = None self.bt_import = None self.bt_append_plot = None self.bt_plot = None self.bt_freeze = None self.cb_plotpanel = None self.rb_single_mode = None self.rb_batch_mode = None self.owner = None self.do_layout() self.fill_cbox_analysis(self.list_of_perspective) self.Bind(wx.EVT_SHOW, self.on_close_page) if self.parent is not None: self.parent.Bind(EVT_DELETE_PLOTPANEL, self._on_delete_plot_panel) def do_layout(self): """ Create the panel layout """ self.define_panel_structure() self.layout_selection() self.layout_data_list() self.layout_batch() self.layout_button() def disable_app_combo(self, enable): """ Disable app combo box """ self.perspective_cbox.Enable(enable) def define_panel_structure(self): """ Define the skeleton of the panel """ w, h = self.parent.GetSize() self.vbox = wx.BoxSizer(wx.VERTICAL) self.sizer1 = wx.BoxSizer(wx.VERTICAL) self.sizer1.SetMinSize(wx.Size(w/13, h*2/5)) self.sizer2 = wx.BoxSizer(wx.VERTICAL) self.sizer3 = wx.FlexGridSizer(9, 2, 4, 1) self.sizer4 = wx.BoxSizer(wx.VERTICAL) self.sizer5 = wx.BoxSizer(wx.VERTICAL) self.vbox.Add(self.sizer5, 0, wx.EXPAND|wx.ALL, 1) self.vbox.Add(self.sizer1, 1, wx.EXPAND|wx.ALL, 0) self.vbox.Add(self.sizer2, 0, wx.EXPAND|wx.ALL, 1) self.vbox.Add(self.sizer3, 0, wx.EXPAND|wx.ALL, 10) #self.vbox.Add(self.sizer4, 0, wx.EXPAND|wx.ALL,5) self.SetSizer(self.vbox) def layout_selection(self): """ Create selection option combo box """ select_txt = wx.StaticText(self, -1, 'Selection Options') select_txt.SetForegroundColour('blue') self.selection_cbox = wx.ComboBox(self, -1, style=wx.CB_READONLY) list_of_options = ['Select all Data', 'Unselect all Data', 'Select all Data 1D', 'Unselect all Data 1D', 'Select all Data 2D', 'Unselect all Data 2D' ] for option in list_of_options: self.selection_cbox.Append(str(option)) self.selection_cbox.SetValue('Select all Data') wx.EVT_COMBOBOX(self.selection_cbox, -1, self._on_selection_type) self.sizer5.AddMany([(select_txt, 0, wx.ALL, 5), (self.selection_cbox, 0, wx.ALL,5)]) self.enable_selection() def _on_selection_type(self, event): """ Select data according to patterns :param event: UI event """ option = self.selection_cbox.GetValue() pos = self.selection_cbox.GetSelection() if pos == wx.NOT_FOUND: return option = self.selection_cbox.GetString(pos) for item in self.list_cb_data.values(): data_ctrl, _, _, _, _, _, _, _ = item _, data_class, _ = self.tree_ctrl.GetItemPyData(data_ctrl) if option == 'Select all Data': self.tree_ctrl.CheckItem(data_ctrl, True) elif option == 'Unselect all Data': self.tree_ctrl.CheckItem(data_ctrl, False) elif option == 'Select all Data 1D': if data_class == 'Data1D': self.tree_ctrl.CheckItem(data_ctrl, True) elif option == 'Unselect all Data 1D': if data_class == 'Data1D': self.tree_ctrl.CheckItem(data_ctrl, False) elif option == 'Select all Data 1D': if data_class == 'Data1D': self.tree_ctrl.CheckItem(data_ctrl, True) elif option == 'Select all Data 2D': if data_class == 'Data2D': self.tree_ctrl.CheckItem(data_ctrl, True) elif option == 'Unselect all Data 2D': if data_class == 'Data2D': self.tree_ctrl.CheckItem(data_ctrl, False) self.enable_append() self.enable_freeze() self.enable_plot() self.enable_import() self.enable_remove() def layout_button(self): """ Layout widgets related to buttons """ self.bt_add = wx.Button(self, wx.NewId(), "Load Data", size=(BUTTON_WIDTH, -1)) self.bt_add.SetToolTipString("Load data files") wx.EVT_BUTTON(self, self.bt_add.GetId(), self._load_data) self.bt_remove = wx.Button(self, wx.NewId(), "Delete Data", size=(BUTTON_WIDTH, -1)) self.bt_remove.SetToolTipString("Delete data from the application") wx.EVT_BUTTON(self, self.bt_remove.GetId(), self.on_remove) self.bt_import = wx.Button(self, wx.NewId(), "Send To", size=(BUTTON_WIDTH, -1)) self.bt_import.SetToolTipString("Send Data set to active perspective") wx.EVT_BUTTON(self, self.bt_import.GetId(), self.on_import) self.perspective_cbox = wx.ComboBox(self, -1, style=wx.CB_READONLY) if not IS_MAC: self.perspective_cbox.SetMinSize((BUTTON_WIDTH*1.6, -1)) wx.EVT_COMBOBOX(self.perspective_cbox, -1, self._on_perspective_selection) self.bt_append_plot = wx.Button(self, wx.NewId(), "Append Plot To", size=(BUTTON_WIDTH, -1)) self.bt_append_plot.SetToolTipString( \ "Plot the selected data in the active panel") wx.EVT_BUTTON(self, self.bt_append_plot.GetId(), self.on_append_plot) self.bt_plot = wx.Button(self, wx.NewId(), "New Plot", size=(BUTTON_WIDTH, -1)) self.bt_plot.SetToolTipString("To trigger plotting") wx.EVT_BUTTON(self, self.bt_plot.GetId(), self.on_plot) self.bt_freeze = wx.Button(self, wx.NewId(), "Freeze Theory", size=(BUTTON_WIDTH, -1)) freeze_tip = "To trigger freeze a theory: making a copy\n" freeze_tip += "of the theory checked to Data box,\n" freeze_tip += " so that it can act like a real data set." self.bt_freeze.SetToolTipString(freeze_tip) wx.EVT_BUTTON(self, self.bt_freeze.GetId(), self.on_freeze) if sys.platform == 'darwin': self.cb_plotpanel = wx.ComboBox(self, -1, style=wx.CB_READONLY) else: self.cb_plotpanel = wx.ComboBox(self, -1, style=wx.CB_READONLY|wx.CB_SORT) wx.EVT_COMBOBOX(self.cb_plotpanel, -1, self._on_plot_selection) self.cb_plotpanel.Disable() self.sizer3.AddMany([(self.bt_add), ((10, 10)), (self.bt_remove), ((10, 10)), (self.bt_freeze), ((10, 10)), (self.bt_plot), ((10, 10)), (self.bt_append_plot), (self.cb_plotpanel, wx.EXPAND|wx.ADJUST_MINSIZE, 5), ((5, 5)), ((5, 5)), (self.bt_import, 0, wx.EXPAND|wx.RIGHT, 5), (self.perspective_cbox, wx.EXPAND|wx.ADJUST_MINSIZE, 5), ((10, 10)), (self.sizer4), ((10, 40)), ((10, 40))]) self.sizer3.AddGrowableCol(1, 1) self.show_data_button() self.enable_remove() self.enable_import() self.enable_plot() self.enable_append() self.enable_freeze() self.enable_remove_plot() def layout_batch(self): """ Set up batch mode options """ self.rb_single_mode = wx.RadioButton(self, -1, 'Single Mode', style=wx.RB_GROUP) self.rb_batch_mode = wx.RadioButton(self, -1, 'Batch Mode') self.Bind(wx.EVT_RADIOBUTTON, self.on_single_mode, id=self.rb_single_mode.GetId()) self.Bind(wx.EVT_RADIOBUTTON, self.on_batch_mode, id=self.rb_batch_mode.GetId()) self.rb_single_mode.SetValue(not self.parent.batch_on) self.rb_batch_mode.SetValue(self.parent.batch_on) self.sizer4.AddMany([(self.rb_single_mode, 0, wx.ALL, 4), (self.rb_batch_mode, 0, wx.ALL, 4)]) def on_single_mode(self, event): """ Change to single mode :param event: UI event """ if self.parent is not None: wx.PostEvent(self.parent, NewBatchEvent(enable=False)) def on_batch_mode(self, event): """ Change to batch mode :param event: UI event """ if self.parent is not None: wx.PostEvent(self.parent, NewBatchEvent(enable=True)) def _get_data_selection(self, event): """ Get data selection from the right click :param event: UI event """ data = None #selection = event.GetSelection() id, _, _ = self.FindFocus().GetSelection().GetData() data_list, theory_list = \ self.parent.get_data_manager().get_by_id(id_list=[id]) if data_list: data = data_list.values()[0] if data == None: data = theory_list.values()[0][0] return data def on_edit_data(self, event): """ Pop Up Data Editor """ data = self._get_data_selection(event) from sas.guiframe.local_perspectives.plotting.masking \ import MaskPanel as MaskDialog panel = MaskDialog(parent=self.parent, base=self, data=data, id=wx.NewId()) panel.ShowModal() def on_plot_3d(self, event): """ Frozen image of 3D """ data = self._get_data_selection(event) from sas.guiframe.local_perspectives.plotting.masking \ import FloatPanel as Float3dDialog panel = Float3dDialog(base=self, data=data, dimension=3, id=wx.NewId()) panel.ShowModal() def on_quick_plot(self, event): """ Frozen plot """ data = self._get_data_selection(event) if data.__class__.__name__ == "Data2D": dimension = 2 else: dimension = 1 #panel = QucikPlotDialog(base=self, data=data, # dimension=dimension, id=wx.NewId()) frame = QucikPlotDialog(self, -1, "Plot " + data.name, 'log_{10}') self.parent.put_icon(frame) frame.add_plot(data) #frame.SetTitle(title) frame.Show(True) frame.SetFocus() #panel.ShowModal() def on_data_info(self, event): """ Data Info panel """ data = self._get_data_selection(event) if data.__class__.__name__ == "Data2D": self.parent.show_data2d(data, data.name) else: self.parent.show_data1d(data, data.name) def on_save_as(self, event): """ Save data as a file """ data = self._get_data_selection(event) #path = None default_name = data.name if default_name.count('.') > 0: default_name = default_name.split('.')[0] default_name += "_out" if self.parent != None: if issubclass(data.__class__, Data1D): self.parent.save_data1d(data, default_name) elif issubclass(data.__class__, Data2D): self.parent.save_data2d(data, default_name) else: print "unable to save this type of data" def layout_data_list(self): """ Add a listcrtl in the panel """ tree_ctrl_label = wx.StaticText(self, -1, "Data") tree_ctrl_label.SetForegroundColour('blue') self.tree_ctrl = DataTreeCtrl(parent=self, style=wx.SUNKEN_BORDER) self.tree_ctrl.Bind(CT.EVT_TREE_ITEM_CHECKING, self.on_check_item) self.tree_ctrl.Bind(CT.EVT_TREE_ITEM_MENU, self.on_right_click_data) ## Create context menu for page self.data_menu = wx.Menu() id = wx.NewId() name = "Data Info" msg = "Show Data Info" self.data_menu.Append(id, name, msg) wx.EVT_MENU(self, id, self.on_data_info) id = wx.NewId() name = "Save As" msg = "Save Theory/Data as a file" self.data_menu.Append(id, name, msg) wx.EVT_MENU(self, id, self.on_save_as) quickplot_id = wx.NewId() name = "Quick Plot" msg = "Plot the current Data" self.data_menu.Append(quickplot_id, name, msg) wx.EVT_MENU(self, quickplot_id, self.on_quick_plot) self.plot3d_id = wx.NewId() name = "Quick 3DPlot (Slow)" msg = "Plot3D the current 2D Data" self.data_menu.Append(self.plot3d_id, name, msg) wx.EVT_MENU(self, self.plot3d_id, self.on_plot_3d) self.editmask_id = wx.NewId() name = "Edit Mask" msg = "Edit Mask for the current 2D Data" self.data_menu.Append(self.editmask_id, name, msg) wx.EVT_MENU(self, self.editmask_id, self.on_edit_data) tree_ctrl_theory_label = wx.StaticText(self, -1, "Theory") tree_ctrl_theory_label.SetForegroundColour('blue') self.tree_ctrl_theory = DataTreeCtrl(parent=self, style=wx.SUNKEN_BORDER) self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_CHECKING, self.on_check_item) self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_MENU, self.on_right_click_theory) self.sizer1.Add(tree_ctrl_label, 0, wx.LEFT, 10) self.sizer1.Add(self.tree_ctrl, 1, wx.EXPAND|wx.ALL, 10) self.sizer1.Add(tree_ctrl_theory_label, 0, wx.LEFT, 10) self.sizer1.Add(self.tree_ctrl_theory, 1, wx.EXPAND|wx.ALL, 10) def on_right_click_theory(self, event): """ On click theory data """ try: id, data_class_name, _ = \ self.tree_ctrl_theory.GetSelection().GetData() _, _ = self.parent.get_data_manager().get_by_id(id_list=[id]) except: return if self.data_menu is not None: menu_enable = (data_class_name == "Data2D") self.data_menu.Enable(self.editmask_id, False) self.data_menu.Enable(self.plot3d_id, menu_enable) self.PopupMenu(self.data_menu) def on_right_click_data(self, event): """ Allow Editing Data """ #selection = event.GetSelection() is_data = True try: id, data_class_name, _ = self.tree_ctrl.GetSelection().GetData() data_list, _ = \ self.parent.get_data_manager().get_by_id(id_list=[id]) if not data_list: is_data = False except: return if self.data_menu is not None: menu_enable = (data_class_name == "Data2D") maskmenu_enable = (menu_enable and is_data) self.data_menu.Enable(self.editmask_id, maskmenu_enable) self.data_menu.Enable(self.plot3d_id, menu_enable) self.PopupMenu(self.data_menu) def onContextMenu(self, event): """ Retrieve the state selected state """ # Skipping the save state functionality for release 0.9.0 #return pos = event.GetPosition() pos = self.ScreenToClient(pos) self.PopupMenu(self.popUpMenu, pos) def on_check_item(self, event): """ On check item """ item = event.GetItem() item.Check(not item.IsChecked()) self.enable_append() self.enable_freeze() self.enable_plot() self.enable_import() self.enable_remove() event.Skip() def fill_cbox_analysis(self, plugin): """ fill the combobox with analysis name """ self.list_of_perspective = plugin if self.parent is None or \ not hasattr(self.parent, "get_current_perspective") or \ len(self.list_of_perspective) == 0: return if self.parent is not None and self.perspective_cbox is not None: for plug in self.list_of_perspective: if plug.get_perspective(): self.perspective_cbox.Append(plug.sub_menu, plug) curr_pers = self.parent.get_current_perspective() if curr_pers: self.perspective_cbox.SetStringSelection(curr_pers.sub_menu) self.enable_import() def load_data_list(self, list): """ add need data with its theory under the tree """ if list: for state_id, dstate in list.iteritems(): data = dstate.get_data() theory_list = dstate.get_theory() if data is not None: data_name = str(data.name) data_title = str(data.title) data_run = str(data.run) data_class = data.__class__.__name__ path = dstate.get_path() process_list = data.process data_id = data.id s_path = str(path) if state_id not in self.list_cb_data: #new state data_c = self.tree_ctrl.InsertItem(self.tree_ctrl.root, 0, data_name, ct_type=1, data=(data_id, data_class, state_id)) data_c.Check(True) d_i_c = self.tree_ctrl.AppendItem(data_c, 'Info') d_t_c = self.tree_ctrl.AppendItem(d_i_c, 'Title: %s' % data_title) r_n_c = self.tree_ctrl.AppendItem(d_i_c, 'Run: %s' % data_run) i_c_c = self.tree_ctrl.AppendItem(d_i_c, 'Type: %s' % data_class) p_c_c = self.tree_ctrl.AppendItem(d_i_c, "Path: '%s'" % s_path) d_p_c = self.tree_ctrl.AppendItem(d_i_c, 'Process') for process in process_list: process_str = str(process).replace('\n',' ') if len(process_str)>20: process_str = process_str[:20]+' [...]' self.tree_ctrl.AppendItem(d_p_c, process_str) theory_child = self.tree_ctrl.AppendItem(data_c, "THEORIES") self.list_cb_data[state_id] = [data_c, d_i_c, d_t_c, r_n_c, i_c_c, p_c_c, d_p_c, theory_child] else: data_ctrl_list = self.list_cb_data[state_id] #This state is already display replace it contains data_c, d_i_c, d_t_c, r_n_c, i_c_c, p_c_c, d_p_c, _ \ = data_ctrl_list self.tree_ctrl.SetItemText(data_c, data_name) temp = (data_id, data_class, state_id) self.tree_ctrl.SetItemPyData(data_c, temp) self.tree_ctrl.SetItemText(i_c_c, 'Type: %s' % data_class) self.tree_ctrl.SetItemText(p_c_c, 'Path: %s' % s_path) self.tree_ctrl.DeleteChildren(d_p_c) for process in process_list: if not process.is_empty(): _ = self.tree_ctrl.AppendItem(d_p_c, process.single_line_desc()) wx.CallAfter(self.append_theory, state_id, theory_list) # Sort by data name if self.tree_ctrl.root: self.tree_ctrl.SortChildren(self.tree_ctrl.root) self.enable_remove() self.enable_import() self.enable_plot() self.enable_freeze() self.enable_selection() def _uncheck_all(self): """ Uncheck all check boxes """ for item in self.list_cb_data.values(): data_ctrl, _, _, _, _, _, _, _ = item self.tree_ctrl.CheckItem(data_ctrl, False) self.enable_append() self.enable_freeze() self.enable_plot() self.enable_import() self.enable_remove() def append_theory(self, state_id, theory_list): """ append theory object under data from a state of id = state_id replace that theory if already displayed """ if not theory_list: return if state_id not in self.list_cb_data.keys(): root = self.tree_ctrl_theory.root tree = self.tree_ctrl_theory else: item = self.list_cb_data[state_id] data_c, _, _, _, _, _, _, _ = item root = data_c tree = self.tree_ctrl if root is not None: wx.CallAfter(self.append_theory_helper, tree=tree, root=root, state_id=state_id, theory_list=theory_list) def append_theory_helper(self, tree, root, state_id, theory_list): """ Append theory helper """ if state_id in self.list_cb_theory.keys(): #update current list of theory for this data theory_list_ctrl = self.list_cb_theory[state_id] for theory_id, item in theory_list.iteritems(): theory_data, _ = item if theory_data is None: name = "Unknown" theory_class = "Unknown" theory_id = "Unknown" temp = (None, None, None) else: name = theory_data.name theory_class = theory_data.__class__.__name__ theory_id = theory_data.id #if theory_state is not None: # name = theory_state.model.name temp = (theory_id, theory_class, state_id) if theory_id not in theory_list_ctrl: #add new theory t_child = tree.AppendItem(root, name, ct_type=1, data=temp) t_i_c = tree.AppendItem(t_child, 'Info') i_c_c = tree.AppendItem(t_i_c, 'Type: %s' % theory_class) t_p_c = tree.AppendItem(t_i_c, 'Process') for process in theory_data.process: tree.AppendItem(t_p_c, process.__str__()) theory_list_ctrl[theory_id] = [t_child, i_c_c, t_p_c] else: #replace theory t_child, i_c_c, t_p_c = theory_list_ctrl[theory_id] tree.SetItemText(t_child, name) tree.SetItemPyData(t_child, temp) tree.SetItemText(i_c_c, 'Type: %s' % theory_class) tree.DeleteChildren(t_p_c) for process in theory_data.process: tree.AppendItem(t_p_c, process.__str__()) else: #data didn't have a theory associated it before theory_list_ctrl = {} for theory_id, item in theory_list.iteritems(): theory_data, _ = item if theory_data is not None: name = theory_data.name theory_class = theory_data.__class__.__name__ theory_id = theory_data.id #if theory_state is not None: # name = theory_state.model.name temp = (theory_id, theory_class, state_id) t_child = tree.AppendItem(root, name, ct_type=1, data=(theory_data.id, theory_class, state_id)) t_i_c = tree.AppendItem(t_child, 'Info') i_c_c = tree.AppendItem(t_i_c, 'Type: %s' % theory_class) t_p_c = tree.AppendItem(t_i_c, 'Process') for process in theory_data.process: tree.AppendItem(t_p_c, process.__str__()) theory_list_ctrl[theory_id] = [t_child, i_c_c, t_p_c] #self.list_cb_theory[data_id] = theory_list_ctrl self.list_cb_theory[state_id] = theory_list_ctrl def set_data_helper(self): """ Set data helper """ data_to_plot = [] state_to_plot = [] theory_to_plot = [] for value in self.list_cb_data.values(): item, _, _, _, _, _, _, _ = value if item.IsChecked(): data_id, _, state_id = self.tree_ctrl.GetItemPyData(item) data_to_plot.append(data_id) if state_id not in state_to_plot: state_to_plot.append(state_id) for theory_dict in self.list_cb_theory.values(): for _, value in theory_dict.iteritems(): item, _, _ = value if item.IsChecked(): theory_id, _, state_id = self.tree_ctrl.GetItemPyData(item) theory_to_plot.append(theory_id) if state_id not in state_to_plot: state_to_plot.append(state_id) return data_to_plot, theory_to_plot, state_to_plot def remove_by_id(self, id): """ Remove_dat by id """ for item in self.list_cb_data.values(): data_c, _, _, _, _, _, _, _ = item data_id, _, state_id = self.tree_ctrl.GetItemPyData(data_c) if id == data_id: self.tree_ctrl.Delete(data_c) del self.list_cb_data[state_id] del self.list_cb_theory[data_id] def load_error(self, error=None): """ Pop up an error message. :param error: details error message to be displayed """ if error is not None or str(error).strip() != "": dial = wx.MessageDialog(self.parent, str(error), 'Error Loading File', wx.OK | wx.ICON_EXCLAMATION) dial.ShowModal() def _load_data(self, event): """ send an event to the parent to trigger load from plugin module """ if self.parent is not None: wx.PostEvent(self.parent, NewLoadDataEvent()) def on_remove(self, event): """ Get a list of item checked and remove them from the treectrl Ask the parent to remove reference to this item """ msg = "This operation will delete the data sets checked " msg += "and all the dependents." msg_box = wx.MessageDialog(None, msg, 'Warning', wx.OK|wx.CANCEL) if msg_box.ShowModal() != wx.ID_OK: return data_to_remove, theory_to_remove, _ = self.set_data_helper() data_key = [] theory_key = [] #remove data from treectrl for d_key, item in self.list_cb_data.iteritems(): data_c, _, _, _, _, _, _, _ = item if data_c.IsChecked(): self.tree_ctrl.Delete(data_c) data_key.append(d_key) if d_key in self.list_cb_theory.keys(): theory_list_ctrl = self.list_cb_theory[d_key] theory_to_remove += theory_list_ctrl.keys() # Remove theory from treectrl for _, theory_dict in self.list_cb_theory.iteritems(): for key, value in theory_dict.iteritems(): item, _, _ = value if item.IsChecked(): try: self.tree_ctrl.Delete(item) except: pass theory_key.append(key) #Remove data and related theory references for key in data_key: del self.list_cb_data[key] if key in theory_key: del self.list_cb_theory[key] #remove theory references independently of data for key in theory_key: for _, theory_dict in self.list_cb_theory.iteritems(): if key in theory_dict: for key, value in theory_dict.iteritems(): item, _, _ = value if item.IsChecked(): try: self.tree_ctrl_theory.Delete(item) except: pass del theory_dict[key] self.parent.remove_data(data_id=data_to_remove, theory_id=theory_to_remove) self.enable_remove() self.enable_freeze() self.enable_remove_plot() def on_import(self, event=None): """ Get all select data and set them to the current active perspetive """ if event != None: event.Skip() data_id, theory_id, state_id = self.set_data_helper() temp = data_id + state_id self.parent.set_data(data_id=temp, theory_id=theory_id) def on_append_plot(self, event=None): """ append plot to plot panel on focus """ self._on_plot_selection() data_id, theory_id, state_id = self.set_data_helper() self.parent.plot_data(data_id=data_id, state_id=state_id, theory_id=theory_id, append=True) def on_plot(self, event=None): """ Send a list of data names to plot """ data_id, theory_id, state_id = self.set_data_helper() self.parent.plot_data(data_id=data_id, state_id=state_id, theory_id=theory_id, append=False) self.enable_remove_plot() def on_close_page(self, event=None): """ On close """ if event != None: event.Skip() # send parent to update menu with no show nor hide action self.parent.show_data_panel(action=False) def on_freeze(self, event): """ On freeze to make a theory to a data set """ _, theory_id, state_id = self.set_data_helper() if len(theory_id) > 0: self.parent.freeze(data_id=state_id, theory_id=theory_id) msg = "Freeze Theory:" msg += " The theory(s) copied to the Data box as a data set." else: msg = "Freeze Theory: Requires at least one theory checked." wx.PostEvent(self.parent, StatusEvent(status=msg)) def set_active_perspective(self, name): """ set the active perspective """ self.perspective_cbox.SetStringSelection(name) self.enable_import() def _on_delete_plot_panel(self, event): """ get an event with attribute name and caption to delete existing name from the combobox of the current panel """ #name = event.name caption = event.caption if self.cb_plotpanel is not None: pos = self.cb_plotpanel.FindString(str(caption)) if pos != wx.NOT_FOUND: self.cb_plotpanel.Delete(pos) self.enable_append() def set_panel_on_focus(self, name=None): """ set the plot panel on focus """ if self.cb_plotpanel and self.cb_plotpanel.IsBeingDeleted(): return for _, value in self.parent.plot_panels.iteritems(): name_plot_panel = str(value.window_caption) if name_plot_panel not in self.cb_plotpanel.GetItems(): self.cb_plotpanel.Append(name_plot_panel, value) if name != None and name == name_plot_panel: self.cb_plotpanel.SetStringSelection(name_plot_panel) break self.enable_append() self.enable_remove_plot() def set_plot_unfocus(self): """ Unfocus plot """ return def _on_perspective_selection(self, event=None): """ select the current perspective for guiframe """ selection = self.perspective_cbox.GetSelection() if self.perspective_cbox.GetValue() != 'None': perspective = self.perspective_cbox.GetClientData(selection) perspective.on_perspective(event=None) self.parent.check_multimode(perspective=perspective) def _on_plot_selection(self, event=None): """ On source combobox selection """ if event != None: combo = event.GetEventObject() event.Skip() else: combo = self.cb_plotpanel selection = combo.GetSelection() if combo.GetValue() != 'None': panel = combo.GetClientData(selection) self.parent.on_set_plot_focus(panel) def on_close_plot(self, event): """ clseo the panel on focus """ self.enable_append() selection = self.cb_plotpanel.GetSelection() if self.cb_plotpanel.GetValue() != 'None': panel = self.cb_plotpanel.GetClientData(selection) if self.parent is not None and panel is not None: wx.PostEvent(self.parent, NewPlotEvent(group_id=panel.group_id, action="delete")) self.enable_remove_plot() def set_frame(self, frame): """ """ self.frame = frame def get_frame(self): """ """ return self.frame def on_close(self, event): """ On close event """ self.parent.show_data_panel(event) def set_schedule_full_draw(self, panel=None, func='del'): """ Send full draw to guimanager """ self.parent.set_schedule_full_draw(panel, func) def enable_remove_plot(self): """ enable remove plot button if there is a plot panel on focus """ pass #if self.cb_plotpanel.GetCount() == 0: # self.bt_close_plot.Disable() #else: # self.bt_close_plot.Enable() def enable_remove(self): """ enable or disable remove button """ n_t = self.tree_ctrl.GetCount() n_t_t = self.tree_ctrl_theory.GetCount() if n_t + n_t_t <= 0: self.bt_remove.Disable() else: self.bt_remove.Enable() def enable_import(self): """ enable or disable send button """ n_t = 0 if self.tree_ctrl != None: n_t = self.tree_ctrl.GetCount() if n_t > 0 and len(self.list_of_perspective) > 0: self.bt_import.Enable() else: self.bt_import.Disable() if len(self.list_of_perspective) <= 0 or \ self.perspective_cbox.GetValue() in ["None", "No Active Application"]: self.perspective_cbox.Disable() else: self.perspective_cbox.Enable() def enable_plot(self): """ enable or disable plot button """ n_t = 0 n_t_t = 0 if self.tree_ctrl != None: n_t = self.tree_ctrl.GetCount() if self.tree_ctrl_theory != None: n_t_t = self.tree_ctrl_theory.GetCount() if n_t + n_t_t <= 0: self.bt_plot.Disable() else: self.bt_plot.Enable() self.enable_append() def enable_append(self): """ enable or disable append button """ n_t = 0 n_t_t = 0 if self.tree_ctrl != None: n_t = self.tree_ctrl.GetCount() if self.tree_ctrl_theory != None: n_t_t = self.tree_ctrl_theory.GetCount() if n_t + n_t_t <= 0: self.bt_append_plot.Disable() self.cb_plotpanel.Disable() elif self.cb_plotpanel.GetCount() <= 0: self.cb_plotpanel.Disable() self.bt_append_plot.Disable() else: self.bt_append_plot.Enable() self.cb_plotpanel.Enable() def check_theory_to_freeze(self): """ Check_theory_to_freeze """ def enable_freeze(self): """ enable or disable the freeze button """ n_t_t = 0 n_l = 0 if self.tree_ctrl_theory != None: n_t_t = self.tree_ctrl_theory.GetCount() n_l = len(self.list_cb_theory) if (n_t_t + n_l > 0): self.bt_freeze.Enable() else: self.bt_freeze.Disable() def enable_selection(self): """ enable or disable combobo box selection """ n_t = 0 n_t_t = 0 if self.tree_ctrl != None: n_t = self.tree_ctrl.GetCount() if self.tree_ctrl_theory != None: n_t_t = self.tree_ctrl_theory.GetCount() if n_t + n_t_t > 0 and self.selection_cbox != None: self.selection_cbox.Enable() else: self.selection_cbox.Disable() def show_data_button(self): """ show load data and remove data button if dataloader on else hide them """ try: gui_style = self.parent.get_style() style = gui_style & GUIFRAME.DATALOADER_ON if style == GUIFRAME.DATALOADER_ON: #self.bt_remove.Show(True) self.bt_add.Show(True) else: #self.bt_remove.Hide() self.bt_add.Hide() except: #self.bt_remove.Hide() self.bt_add.Hide() WIDTH = 400 HEIGHT = 300 class DataDialog(wx.Dialog): """ Allow file selection at loading time """ def __init__(self, data_list, parent=None, text='', *args, **kwds): wx.Dialog.__init__(self, parent, *args, **kwds) self.SetTitle("Data Selection") self.SetSize((WIDTH, HEIGHT)) self.list_of_ctrl = [] if not data_list: return self._sizer_main = wx.BoxSizer(wx.VERTICAL) self._sizer_txt = wx.BoxSizer(wx.VERTICAL) self._sizer_button = wx.BoxSizer(wx.HORIZONTAL) self.sizer = wx.GridBagSizer(5, 5) self._panel = ScrolledPanel(self, style=wx.RAISED_BORDER, size=(WIDTH-20, HEIGHT-50)) self._panel.SetupScrolling() self.__do_layout(data_list, text=text) def __do_layout(self, data_list, text=''): """ layout the dialog """ if not data_list or len(data_list) <= 1: return #add text text = "Deleting these file reset some panels.\n" text += "Do you want to proceed?\n" text_ctrl = wx.StaticText(self, -1, str(text)) self._sizer_txt.Add(text_ctrl) iy = 0 ix = 0 #data_count = 0 for (data_name, in_use, sub_menu) in range(len(data_list)): if in_use == True: ctrl_name = wx.StaticBox(self, -1, str(data_name)) ctrl_in_use = wx.StaticBox(self, -1, " is used by ") plug_name = str(sub_menu) + "\n" #ctrl_sub_menu = wx.StaticBox(self, -1, plug_name) self.sizer.Add(ctrl_name, (iy, ix), (1, 1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) ix += 1 self._sizer_button.Add(ctrl_in_use, 1, wx.EXPAND|wx.ADJUST_MINSIZE, 0) ix += 1 self._sizer_button.Add(plug_name, 1, wx.EXPAND|wx.ADJUST_MINSIZE, 0) iy += 1 self._panel.SetSizer(self.sizer) #add sizer self._sizer_button.Add((20, 20), 1, wx.EXPAND|wx.ADJUST_MINSIZE, 0) button_cancel = wx.Button(self, wx.ID_CANCEL, "Cancel") self._sizer_button.Add(button_cancel, 0, wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10) button_OK = wx.Button(self, wx.ID_OK, "Ok") button_OK.SetFocus() self._sizer_button.Add(button_OK, 0, wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10) static_line = wx.StaticLine(self, -1) self._sizer_txt.Add(self._panel, 1, wx.EXPAND|wx.LEFT|wx.RIGHT, 5) self._sizer_main.Add(self._sizer_txt, 1, wx.EXPAND|wx.ALL, 10) #self._sizer_main.Add(self._data_text_ctrl, 0, # wx.EXPAND|wx.LEFT|wx.RIGHT, 10) self._sizer_main.Add(static_line, 0, wx.EXPAND, 0) self._sizer_main.Add(self._sizer_button, 0, wx.EXPAND|wx.ALL, 10) self.SetSizer(self._sizer_main) self.Layout() def get_data(self): """ return the selected data """ temp = [] for item in self.list_of_ctrl: cb, data = item if cb.GetValue(): temp.append(data) return temp class DataFrame(wx.Frame): """ Data Frame """ ## Internal name for the AUI manager window_name = "Data Panel" ## Title to appear on top of the window window_caption = "Data Panel" ## Flag to tell the GUI manager that this panel is not # tied to any perspective ALWAYS_ON = True def __init__(self, parent=None, owner=None, manager=None, size=(300, 800), list_of_perspective=[], list=[], *args, **kwds): kwds['size'] = size kwds['id'] = -1 kwds['title'] = "Loaded Data" wx.Frame.__init__(self, parent=parent, *args, **kwds) self.parent = parent self.owner = owner self._manager = manager self.panel = DataPanel(parent=self, manager=manager, list_of_perspective=list_of_perspective) def load_data_list(self, list=[]): """ Fill the list inside its panel """ self.panel.load_data_list(list=list) from sas.guiframe.dataFitting import Theory1D from sas.guiframe.data_state import DataState class State(): """ DataPanel State """ def __init__(self): self.msg = "" def __str__(self): self.msg = "model mane : model1\n" self.msg += "params : \n" self.msg += "name value\n" return self.msg def set_data_state(data=None, path=None, theory=None, state=None): """ Set data state """ dstate = DataState(data=data) dstate.set_path(path=path) dstate.set_theory(theory, state) return dstate if __name__ == "__main__": app = wx.App() try: #list_of_perspective = [('perspective2', False), ('perspective1', True)] data_list1 = {} # state 1 data1 = Data2D() data1.name = "data2" data1.id = 1 data1.append_empty_process() process1 = data1.process[len(data1.process)-1] process1.data = "07/01/2010" theory1 = Data2D() theory1.id = 34 theory1.name = "theory1" path1 = "path1" state1 = State() data_list1['1'] = set_data_state(data1, path1, theory1, state1) #state 2 data1 = Data2D() data1.name = "data2" data1.id = 76 theory1 = Data2D() theory1.id = 78 theory1.name = "CoreShell 07/24/25" path1 = "path2" #state3 state1 = State() data_list1['2'] = set_data_state(data1, path1, theory1, state1) data1 = Data1D() data1.id = 3 data1.name = "data2" theory1 = Theory1D() theory1.name = "CoreShell" theory1.id = 4 theory1.append_empty_process() process1 = theory1.process[len(theory1.process)-1] process1.description = "this is my description" path1 = "path3" data1.append_empty_process() process1 = data1.process[len(data1.process)-1] process1.data = "07/22/2010" data_list1['4'] = set_data_state(data1, path1, theory1, state1) #state 4 temp_data_list = {} data1.name = "data5 erasing data2" temp_data_list['4'] = set_data_state(data1, path1, theory1, state1) #state 5 data1 = Data2D() data1.name = "data3" data1.id = 5 data1.append_empty_process() process1 = data1.process[len(data1.process)-1] process1.data = "07/01/2010" theory1 = Theory1D() theory1.name = "Cylinder" path1 = "path2" state1 = State() dstate1 = set_data_state(data1, path1, theory1, state1) theory1 = Theory1D() theory1.id = 6 theory1.name = "CoreShell" dstate1.set_theory(theory1) theory1 = Theory1D() theory1.id = 6 theory1.name = "CoreShell replacing coreshell in data3" dstate1.set_theory(theory1) data_list1['3'] = dstate1 #state 6 data_list1['6'] = set_data_state(None, path1, theory1, state1) data_list1['6'] = set_data_state(theory=theory1, state=None) theory1 = Theory1D() theory1.id = 7 data_list1['6'] = set_data_state(theory=theory1, state=None) data_list1['7'] = set_data_state(theory=theory1, state=None) window = DataFrame(list=data_list1) window.load_data_list(list=data_list1) window.Show(True) window.load_data_list(list=temp_data_list) except: #raise print "error", sys.exc_value app.MainLoop()