def __init__ ( self, parent = None, **traits ): super( MFnChacoEditorToolbar, self ).__init__( **traits ) factory = self.editor.factory actions = [ self.save_data, self.save_fig ] toolbar = ToolBar( image_size = ( 16, 16 ), show_tool_names = False, show_divider = False, *actions ) self.control = toolbar.create_tool_bar( parent, self ) self.control.SetBackgroundColour( parent.GetBackgroundColour() ) # fixme: Why do we have to explictly set the size of the toolbar? # Is there some method that needs to be called to do the # layout? self.control.SetSize( wx.Size( 23 * len( actions ), 16 ) )
def traits_view(self): file_menu = Menu( ActionGroup( Action(id="open", name=u"打开", action="open_file"), Action(id="save", name=u"保存", action="save_file"), ), ActionGroup( Action(id="exit_app", name=u"退出", action="exit_app"), ), name = u"文件" ) about_menu = Menu( Action(id="about", name=u"关于", action="about_dialog"), name = u"帮助" ) tool_bar = ToolBar( Action( image = ImageResource("folder_page.png", search_path = ["img"]), tooltip = u"打开文档", action = "open_file" ), Action( image = ImageResource("disk.png", search_path = ["img"]), tooltip = u"保存文档", action = "save_file" ), ) return View( Item("text", style="custom", show_label=False, editor=CodeEditor(line="current_line")), menubar = MenuBar(file_menu, about_menu), toolbar = tool_bar, statusbar = ["status_info"], resizable = True, width = 500, height = 300, title = u"程序编辑器", handler = MenuDemoHandler() )
def __init__(self, avl=None, **traits): """Initializes the object. """ super(AVLTreeBrowser, self).__init__(**traits) self.ui = None self.view = None if avl: self.avl = avl menu = Menu(Action(name='Refresh', action='editor.update_editor'), Action(name='Expand all', action='editor.expand_all')) self.menu = menu self._root_object_changed(self.root_object) nodes = self.tree_generator.get_nodes(menu) self.tree_editor = TreeEditor(nodes=nodes, orientation='vertical', hide_root=True, on_dclick=self._on_dclick, selected='selected') self.view = View(Group(Item(name='_root', editor=self.tree_editor, resizable=True), show_labels=False, show_border=False, orientation='vertical'), title='pyAVL', help=False, resizable=True, undo=False, revert=False, width=.3, height=.3, handler=self.avlhandler, toolbar=ToolBar(*self.avlhandler.toolbar_actions))
def _toolbar_default(self): toolbar = ToolBar(*self.actions) toolbar.image_size = (16, 16) toolbar.show_tool_names = False toolbar.show_divider = False return toolbar
help_menu = Menu( "|", #help_action, "_", about_action, name="&Help") menubar = MenuBar(file_menu, edit_menu, view_menu, graph_menu, help_menu) #------------------------------------------------------------------------------ # Godot "ToolBar" instance: #------------------------------------------------------------------------------ toolbar = ToolBar( "|", #close_action, "_", new_action, open_action, save_action, save_as_action, "_", undo_action, redo_action, "_", node_action, edge_action, configure_graph_action, configure_nodes_action, configure_edges_action, show_tool_names=False, #show_divider=False ) # EOF -------------------------------------------------------------------------
class tcWindow(HasTraits): project = tcProject plot = tcPlot def __init__(self, project): self.project = project self.plot = create_timechart_container(project) self.plot_range_tools = self.plot.range_tools self.plot_range_tools.on_trait_change(self._selection_time_changed, "time") self.trait_view().title = self.get_title() def get_title(self): if self.project.filename == "dummy": return "PyTimechart: Please Open a File" return "PyTimechart:" + self.project.filename # Create an action that exits the application. status = Str("Welcome to PyTimechart") traits_view = View( HSplit( VSplit( Item('project', show_label=False, editor=InstanceEditor(view='process_view'), style='custom', width=150), # Item('plot_range_tools', show_label = False, editor=InstanceEditor(view = 'selection_view'), style='custom',width=150,height=100) ), Item('plot', show_label=False, editor=ComponentEditor()), ), toolbar=ToolBar(*_create_toolbar_actions(), image_size=(24, 24), show_tool_names=False), menubar=MenuBar(*_create_menubar_actions()), statusbar=[ StatusItem(name='status'), ], resizable=True, width=1280, height=1024, handler=tcActionHandler()) def _on_open_trace_file(self): if open_file(None) and self.project.filename == "dummy": self._ui.dispose() def _on_view_properties(self): self.plot.options.edit_traits() def _on_exit(self, n=None): self.close() sys.exit(0) def close(self, n=None): pass def _on_about(self): aboutBox().edit_traits() def _on_doc(self): browse_doc() def _selection_time_changed(self): self.status = "selection time:%s" % (self.plot_range_tools.time)
class ControlTab(HasTraits): """ This object is the core of the traitsUI interface. Its view is the right panel of the application, and it hosts the method for interaction between the objects and the GUI. """ move_step = Enum(1,0.2,0.5,1,2,5,10) scale_step = Enum(10,1,5,10,20,50,100) channels = List() ch_editor = CheckListEditor(values=[],cols=2) num_channels = Int(0) patient_name = Str() select_all = Button("all") select_none = Button("none") select_good = Button("good (db)") mlcount = Int(0) mrcount = Int(0) mucount = Int(0) mdcount = Int(0) #_sls = [0,1100,5] #StartLengthStride #acquisition_thread = Instance(AcquisitionThread) move_left = Action(name = "Left", action = "_trigger_move_left", toolip = "Move to the left", image = ImageResource("images/left_32.png") ) move_right = Action(name = "Right", action = "_trigger_move_right", toolip = "Move to the right", image = ImageResource("images/right_32.png") ) scale_up = Action(name = "Scale up", action = "_trigger_scale_up", toolip = "Move to the right", image = ImageResource("images/up_32.png") ) scale_down = Action(name = "Scale down", action = "_trigger_scale_down", toolip = "Move to the right", image = ImageResource("images/down_32.png") ) toolbar = ToolBar(move_left, move_right,scale_up,scale_down) traits_view = View(VGroup( #Item('do_plot', show_label=False ), VGroup( Item('move_step',label="Move by:"), Item('scale_step',label="Scale by"), ), VGroup( Group( Item('channels', show_label=False, style='custom', editor=ch_editor, #springy=True, #height=-500, ), scrollable=True, springy=True, ), HGroup( spring, Item('select_all',show_label=False), Item('select_none',show_label=False), Item('select_good',show_label=False), spring, ), label = "Choose channels", #height=300, ), #Item('results_string',show_label=False, # springy=True, style='custom' ), #springy=True, #scrollable=True, #height=-500, dock='tab', springy=True #scrollable=True ), toolbar=toolbar, scrollable=True #height=-500, ) #key_bindings=key_bindings, #handler=ControlHandler, def _trigger_move_left(self): #print "Trigger Left" self.mlcount+=1 def _trigger_move_right(self): self.mrcount+=1 #print "Trigger Right" def _trigger_scale_up(self): self.mucount+=1 def _trigger_scale_down(self): self.mdcount+=1 def _select_none_fired(self): self.channels = [] def _select_all_fired(self): self.channels = range(self.num_channels) def _select_good_fired(self): try: gc = schlaf_ged.get_good_channels(self.patient_name) print "Got", gc, "from database" self.channels = gc except ValueError, ve: #Zeige Fehlermeldung print ve print self.patient_name try: short_patient_name = self.patient_name.split("_")[0] gc = schlaf_ged.get_good_channels(short_patient_name) print "Got", gc, "from database" self.channels = gc except ValueError,ve: print ve print short_patient_name message = Message(message="Cannot find good channels for subject %s" % self.patient_name) message.edit_traits()
class RunCase(HasTraits): patterns = {'name':re.compile(r"""Operation of run case (?P<case_num>\d+)/(?P<num_cases>\d+):\s*(?P<case_name>.+?)\ *?\n"""), 'constraint':re.compile(r"""(?P<cmd>[A-Z0-9]+)\s+(?P<pattern>.+?)\s+->\s+(?P<constraint>\S+)\s+=\s+(?P<val>[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?)"""), 'constraint_variable':re.compile(r"""(?P<sel>->)?\s*(?P<cmd>[A-Z0-9]+)\s+(?P<pattern>.+?)\s+=\s+(?P<val>[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?)"""), 'parameter':re.compile(r"""(?P<cmd>[A-Z]+)\s+(?P<pattern>.+?)\s+=\s+(?P<val>[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?)(\ +(?P<unit>\S+))?"""), 'var':re.compile(r"""(?P<name>\S+?)\s*?=\s*?(?P<value>[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?)"""), 'float':re.compile(r'(?P<value>[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?)'), 'mode' :re.compile(r"""mode (\d+?):\s*?(?P<real>[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?)\s+(?P<imag>[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?)"""), 'modeveccomp': re.compile(r"""(?P<name>[a-z]+?)(\s*?):\s*(?P<real>[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?)\s+(?P<imag>[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?)""") } number = Int name = String runoutput = Instance(RunOutput, RunOutput())# Dict(String, Float, {}) #not to be used separately apart from modal gui #trim_runcase = Instance(TrimCase, TrimCase()) set_trim_case_action = Action(name='Set Trim Condition', action='set_trimcase', \ tooltip='Set the runcase conditions for horizontal(+banked) or looping trim condition') parameter_view = Property(List(Parameter), depends_on='parameters[]') constraint_view = Property(List(Constraint), depends_on='constraints[]') @cached_property def _get_parameter_view(self): return sorted(self.parameters.values(), key=lambda x:x.name.upper()) @cached_property def _get_constraint_view(self): return sorted(self.constraints.values(), key=lambda x:x.name.upper()) traits_view = View(Group(Item('number', style='readonly'), Item('name')), Group(Item('parameter_view', editor=Parameter.editor, show_label=False), label='Parameters'), Group(Item('constraint_view', editor=Constraint.editor, show_label=False), label='Constraints'), Item(), # so that groups are not tabbed toolbar=ToolBar(set_trim_case_action) ) # name, value parameters = Dict(String, Instance(Parameter), {}) # pattern:name ; Predefined parameters to have good names parameter_names = Dict(String, String, {}) # constraints are corresponding to to the params in constraint_names # constrained : constraint_name, value constraints = Dict(String, Instance(Constraint), {}) # pattern:name constraint_names = Dict(String, String, {'lpha':'alpha', 'eta':'beta', 'oll rate':'roll rate', 'itch rate':'pitch rate', 'aw rate':'yaw rate'}) constraint_variables = Dict(String, Instance(ConstraintVariable), {}) constraint_variable_names = Dict(String, String, {'CL': 'lift coeff', 'CY': 'side force coeff', 'Cl roll mom': 'roll coeff', 'Cm pitchmom': 'pitch coeff', 'Cn yaw mom': 'yaw coeff', 'alpha': 'alpha', 'beta': 'beta', 'pb/2V': 'roll rate', 'qc/2V': 'pitch rate', 'rb/2V': 'yaw rate'}) trimcase = Instance(TrimCase, TrimCase()) def set_trimcase(self, info=None): #print self self.trimcase = TrimCase(runcase=self) self.trimcase.update_parameters_from_avl() self.trimcase.edit_traits() self.get_parameters_info_from_avl(self.avl) @on_trait_change('trimcase.parameter_view.value,trimcase.type') def on_trimcase_changed(self, object, name, old, new): #print object, name, old, new print 'trimcase_changed' if name == 'value': self.update_trim_case(self.trimcase, object) self.trimcase.update_parameters_from_avl() elif name == 'type': self.trimcase.update_parameters_from_avl() # send changed value of trimcase to avl, parameter is Parameter instance def update_trim_case(self, trimcase, parameter): #print 'update_trim_case' self.get_parameters_info_from_avl(self.avl) self.avl.sendline('oper') self.avl.sendline(trimcase.type_) self.avl.expect(AVL.patterns['/oper/m']) #print self.parameters.keys() #for p, v in trimcase.parameters.iteritems(): self.avl.sendline('%s %f' % (parameter.cmd, parameter.value)) AVL.goto_state(self.avl) @on_trait_change('constraints.value,constraints.constraint_name') def update_constraints(self): print 'constraints changed' #self.avl.sendline('oper') #self.avl.sendline() #self.avl.expect(AVL.patterns['/']) for name, constraint in self.constraints.iteritems(): ccmd = constraint.cmd vcmd = self.constraint_variables[constraint.constraint_name].cmd val = constraint.value self.avl.sendline('oper') self.avl.expect(AVL.patterns['/oper']) self.avl.sendline('%s %s %f' % (ccmd, vcmd, val)) self.avl.expect(AVL.patterns['/oper']) AVL.goto_state(self.avl) @on_trait_change('parameters.value') def update_parameters(self): print 'parameters changed' self.avl.sendline('oper') self.avl.sendline('m') self.avl.expect(AVL.patterns['/oper/m']) #print self.parameters.keys() try: tmpv = self.parameters['velocity'].value if tmpv < 0.00001: tmpv = 1.0 except KeyError: tmpv = 1.0 self.avl.sendline('V %f' % tmpv) for p, v in self.parameters.iteritems(): cmd = self.parameters[p].cmd if cmd != 'V': self.avl.sendline('%s %f' % (cmd, v.value)) AVL.goto_state(self.avl) #returns pattern:cmd @classmethod def get_constraint_variables_from_avl(cls, avl, case_num=1): avl.sendline('oper') avl.expect(AVL.patterns['/oper']) avl.sendline(str(case_num)) avl.expect(AVL.patterns['/oper']) avl.sendline('a') avl.expect(AVL.patterns['/oper/a']) if avl.match.groups('case_num') != str(case_num): #raise Exception('could not get case information for case num %d' % case_num) pass lines = avl.before.splitlines() lines = [line.strip() for line in lines] i1 = lines.index('- - - - - - - - - - - - - - - - -') i2 = lines.index('', i1 + 1) constraint_lines = lines[i1 + 1:i2] groups = [re.search(RunCase.patterns['constraint_variable'], line).groupdict() for line in constraint_lines] params = {} for group in groups: params[group['pattern']] = group['cmd'] avl.sendline() AVL.goto_state(avl) return params # return pattern:cmd,con_pattern,value @classmethod def get_constraints_from_avl(cls, avl, case_num=1): avl.sendline('oper') avl.expect(AVL.patterns['/oper']) avl.sendline(str(case_num)) avl.expect(AVL.patterns['/oper']) if avl.match.groups('case_num') != str(case_num): #raise Exception('could not get case information for case num %d' % case_num) pass lines = avl.before.splitlines() lines = [line.strip() for line in lines] i1 = lines.index('------------ ------------------------') i2 = lines.index('------------ ------------------------', i1 + 1) constraint_lines = lines[i1 + 1:i2] groups = [re.match(RunCase.patterns['constraint'], line).groupdict() for line in constraint_lines] params = {} for group in groups: params[group['pattern']] = (group['cmd'], group['constraint'], group['val']) AVL.goto_state(avl) return params @classmethod def get_case_from_avl(cls, avl, case_num=1): # TODO: parse constraints and parameters from avl avl.sendline('oper') avl.expect(AVL.patterns['/oper']) avl.sendline(str(case_num)) avl.expect(AVL.patterns['/oper']) match = re.search((RunCase.patterns['name']), avl.before) name = match.group('case_name').strip() AVL.goto_state(avl) runcase = RunCase(name=name, number=case_num) runcase.avl = avl constraint_vars = RunCase.get_constraint_variables_from_avl(avl, case_num) for constraint_var in constraint_vars: if constraint_var not in runcase.constraint_variable_names: runcase.constraint_variable_names[constraint_var] = constraint_var constraint_name = runcase.constraint_variable_names[constraint_var] runcase.constraint_variables[constraint_name] = ConstraintVariable( name=constraint_name, pattern=constraint_var, cmd=constraint_vars[constraint_var]) constraints = RunCase.get_constraints_from_avl(avl, case_num) rc_constraints = {} for constraint_pattern, constraint_info in constraints.iteritems(): if constraint_pattern not in runcase.constraint_names: runcase.constraint_names[constraint_pattern] = constraint_pattern constraint_name = runcase.constraint_names[constraint_pattern] rc_constraints[constraint_name] = Constraint(name=constraint_name, pattern=constraint_pattern, cmd=constraint_info[0], constraint_name=runcase.constraint_variable_names[constraint_info[1]], value=float(constraint_info[2]), runcase=runcase) runcase.constraints.update(rc_constraints) RunCase.get_parameters_info_from_avl(runcase, avl) AVL.goto_state(avl) return runcase def get_parameters_info_from_avl(self, avl): avl.sendline('oper') avl.expect(AVL.patterns['/oper']) avl.sendline('m') avl.expect(AVL.patterns['/oper/m']) avl.sendline() lines = avl.before.splitlines() lines = [line.strip() for line in lines if len(line.strip()) > 0] l2 = [line.startswith('Parameters') for line in lines] i1 = l2.index(True) i2 = - 1 constraint_lines = lines[i1 + 1:i2] groups = [re.search(RunCase.patterns['parameter'], line).groupdict() for line in constraint_lines] params = {} AVL.goto_state(avl) #params.update(self.parameters) for group in groups: pattern = group['pattern'] name = self.parameter_names.get(pattern, pattern) unit = group.get('unit', '') unit = unit if unit is not None else '' params[name] = Parameter(name=name, pattern=pattern, cmd=group['cmd'], unit=unit, value=float(group['val'])) #self.parameters[name] = float(group['val']) AVL.goto_state(avl) self.parameters.update(params) #self.parameters = params def get_run_output(self): self.avl.sendline('oper') self.avl.expect(AVL.patterns['/oper']) self.avl.sendline('x') self.avl.expect(AVL.patterns['/oper']) ret = {} #print self.avl.before i1 = re.search(r"""Run case:\s*?.*?\n""", self.avl.before).end() i2 = re.search(r"""---------------------------------------------------------------""", self.avl.before[i1:]).start() text = self.avl.before[i1:i1 + i2] AVL.goto_state(self.avl) for match in re.finditer(RunCase.patterns['var'], text): ret[match.group('name')] = float(match.group('value')) #self.output = ret AVL.goto_state(self.avl) return ret def get_modes(self): self.avl.sendline('mode') self.avl.expect(AVL.patterns['/mode']) self.avl.sendline('n') self.avl.expect(AVL.patterns['/mode']) if re.search(r'Eigenmodes not computed for run case', self.avl.before): print 'Error : \n', self.avl.before AVL.goto_state(avl) return ret = {} i1 = re.search(r"""Run case\s*?\d+?:.*?\n""", self.avl.before).end() i2 = re.search(r"""Run-case parameters for eigenmode analyses""", self.avl.before[i1:]).start() text = self.avl.before[i1 : i1 + i2] modes = [] for mode_eval in re.finditer(RunCase.patterns['mode'], text): eigenvalue = float(mode_eval.group('real')) + 1j * float(mode_eval.group('imag')) mode = EigenMode(eigenvalue=eigenvalue) i = 0 for match in re.finditer(RunCase.patterns['modeveccomp'], text[mode_eval.end():]): i += 1 mode.eigenvector[mode.order.index(match.group('name'))] = float(mode_eval.group('real')) + 1j * float(mode_eval.group('imag')) if i > 11: break modes.append(mode) AVL.goto_state(self.avl) return modes def get_system_matrix(self): self.avl.sendline('mode') self.avl.expect(AVL.patterns['/mode']) self.avl.sendline('n') self.avl.expect(AVL.patterns['/mode']) self.avl.sendline('s') self.avl.expect(AVL.patterns['/mode/s']) lines = [line for line in self.avl.before.splitlines()[3: - 1] if len(line) > 0] lines = [line.replace('**********', ' nan ') for line in lines] #print lines # fortran format to deceode # FORMAT(1X,12F10.4,3X,12G12.4) # 1 space, 12 floats of fixed width 10, 3 spaces 12 exponents of fixed width 12 order = lines[0].replace('|', ' ').split() mat = numpy.empty((12, len(order))) for i, line in enumerate(lines[1:]): l1 = line[1:121] for j in xrange(12): mat[i, j] = float(l1[j * 10:(j + 1) * 10]) l2 = line[124:] for j in xrange(len(l2) / 12): mat[i, 12 + j] = float(l2[j * 12:(j + 1) * 12]) ret = EigenMatrix(order=order, matrix=mat) AVL.goto_state(self.avl) return ret
class MarkerTab(HasTraits): """ Object used to display the results. """ record_mark = Bool(False) name_new = Str("Mark") markers = List(Marker) update_marks = Int(0) active_row = Int(0) remove_f2 = Button("Remove") load_evt = Action(name="Load", action="_load", toolip="Load markers from EventTable", image=ImageResource("images/load_32.png")) save_evt = Action(name="EventTable", action="_save_to", toolip="Save markers as EventTable", image=ImageResource("images/save_32.png")) save_ascii = Action(name="ASCII", action="_save_to_ascii", toolip="Save markers as ASCII-file", image=ImageResource("images/save_32.png")) toolbar = ToolBar(load_evt, save_evt, save_ascii) def __init__(self): HasTraits.__init__(self) #self.markers.append(Marker(t=10,name="Test10")) #self.markers.append(Marker(t=100,name="Test100")) #x = Float(50, label="X", desc="X position of the center") #y = Float(50, label="Y", desc="Y position of the center") def cmp_markers(self, x, y): return x.t - y.t def append(self, t, name=None, notify=True, do_sort=True): if name == None: name = str(self.name_new) self.markers.append(Marker(t=t, name=name)) if do_sort: self.markers.sort(cmp=self.cmp_markers) if notify: self.update_marks += 1 #self.goto_marker = self.markers[-1] def get_marks(self, start, stop): rv = [] for m in self.markers: if m.t >= start and m.t <= stop: rv.append(m) return rv def _load(self): print "Load from EventTable" extension = "evt" wildcard = "EventTable|*.evt|VA MarkerFile|*.vmrk" fileDialog = FileDialog(action='open', title='Load EventTable', wildcard=wildcard) fileDialog.open() if fileDialog.path == '' or fileDialog.return_code == CANCEL: return False else: print "Opening", fileDialog.path #et = eegpy.load(str(fileDialog.path)) et = eegpy.EventTable(str(fileDialog.path)) for k in et.keys(): for t in et[k]: #print k,t self.append(t, k, False, False) self.markers.sort(cmp=self.cmp_markers) def _save_to(self): print "Save to EventTable" extension = "evt" wildcard = "*.evt" fileDialog = FileDialog(action='save as', title='Save As', wildcard=wildcard) fileDialog.open() if fileDialog.path == '' or fileDialog.return_code == CANCEL: return False else: extLen = len(extension) if extLen and fileDialog.path[-extLen - 1:] != '.' + extension: fileDialog.path += '.' + extension #print "fc.fn:", fileDialog.path #TODO: Check if file exists and join EventTables et = EventTable() for m in self.markers: try: et.add_trigger(m.name, m.t) except ValueError, e: et.add_trigger_type(m.name, [m.t]) try: et.save(fileDialog.path) except Exception, e: mb = Message( message="Error while writing EventTable to file.\n%s" % str(e))