class App: def __init__(self,parent): # Create frame, buttons, etc self.f = Frame(parent) self.f.pack(padx=15,pady=15) self.entry = Entry(self.f,text="Enter the search term") self.entry.pack(side= TOP,padx=10,pady=12) self.entry.bind("<Key>", self.key) self.entry.focus_set() self.exit = Button(self.f, text="Exit", command=self.f.quit) self.exit.pack(side=BOTTOM,padx=10,pady=10) self.button = Button(self.f, text="Search",command=self.search) self.button.pack(side=BOTTOM,padx=10,pady=10) def key(self, event): # If ENTER was pressed, search if event.char == '\r': self.search() def search(self): # If there's something to search, search! if self.entry.get() != '': self.button.config(text='Searching...', state=DISABLED) th = SearchThread(self, self.entry.get()) th.start() else: tkMessageBox.showinfo('Hey', 'You should type something in the search. That\'s the point, really...')
def createToolbar( self ): "Create and return our toolbar frame." toolbar = Frame( self ) # Tools for tool in self.tools: cmd = ( lambda t=tool: self.activate( t ) ) b = Button( toolbar, text=tool, font=self.smallFont, command=cmd) if tool in self.images: b.config( height=35, image=self.images[ tool ] ) # b.config( compound='top' ) b.pack( fill='x' ) self.buttons[ tool ] = b self.activate( self.tools[ 0 ] ) # Spacer Label( toolbar, text='' ).pack() # Commands for cmd, color in [ ( 'Stop', 'darkRed' ), ( 'Run', 'darkGreen' ) ]: doCmd = getattr( self, 'do' + cmd ) b = Button( toolbar, text=cmd, font=self.smallFont, fg=color, command=doCmd ) b.pack( fill='x', side='bottom' ) return toolbar
def test_dimensions(self): button = Tkbutton(self.frame,text="dsds") button.config(height=5,width=5) button.pack(side=LEFT) button = Tkbutton(self.frame,height = 1,width=4) button.pack(side=LEFT) button = Tkbutton(self.frame,height = 3,width=10) button.pack(side=LEFT)
class UsernameOverlay(Overlay): def __init__(self, *args, **kwargs): Overlay.__init__(self, *args, **kwargs) self.label = "" self.field = "" self.button = "" self.user = "" self.logger = JPYLogger(self) self.config( background="gold", cursor="arrow" ) self.renderLabel() self.renderField() self.renderButton() def renderLabel(self): self.label = Label(self) self.label.config( text="CHANGE PLAYERNAME", font=Fonts.MONEY_BIG, background="gold" ) self.label.pack() def renderField(self): self.field = Entry(self) self.field.config( relief="solid", bd=2, highlightcolor="black", font=Fonts.USER_LABEL_NAME_BIG ) self.field.pack() def renderButton(self): Label(self, text='\n', background="gold").pack() self.button = Button(self) self.button.config( text="OK", relief="solid", background="black", foreground="gold", font=Fonts.MONEY_MEDIUM, command=self.save ) self.button.pack() def save(self): self.logger.prompt("User " + str(self.user.id) + " changed name from '" + self.user.name.get() + "' to '" + self.field.get() + "'") self.user.name.set(self.field.get()) self.hide(self) self.root.root.inputController.blockBuzzer = False def insert(self, user): self.field.delete(0, END) self.field.insert(0, user.name.get())
class SendGCode(LabelFrame): def __init__(self, root, prtr, settings, log, *arg): LabelFrame.__init__(self, root, *arg, text="Send gcode") self.app = root self.printer = prtr self.settings = settings self.log = log self.entry = Entry(self, width=50) self.entry.grid(row=1, column=1, columnspan=3, sticky=N+E+W) self.bSend = Button(self, text="Send", width=4, command=self.doSend, state=DISABLED) self.bSend.grid(row=1, column=4, padx=2) self.entry.delete(0, END) self.entry.bind('<Return>', self.hitEnter) self.gcv = StringVar(self) gclist = gcoderef.gcKeys() self.gcv.set(gclist[0]) l = Label(self, text="G Code Reference:", justify=LEFT) l.grid(row=2, column=1, columnspan=2, sticky=W) self.gcm = Combobox(self, textvariable=self.gcv) self.gcm['values'] = gclist self.gcm.grid(row=2, column=3, padx=2) self.gcm.bind('<<ComboboxSelected>>', self.gcodeSel) #self.bInfo = Button(self, text="Info", width=9, command=self.doInfo) #self.bInfo.grid(row=2, column=4, padx=2) #def doInfo(self): def gcodeSel(self, *arg): verb = self.gcv.get() self.log.logMsg("%s: %s" % (verb, gcoderef.gcText(verb))) def activate(self, flag): if flag: self.bSend.config(state=NORMAL) else: self.bSend.config(state=DISABLED) def hitEnter(self, e): self.doSend() def doSend(self): cmd = self.entry.get() verb = cmd.split()[0] if self.app.printerAvailable(cmd=verb): self.log.logMsg("Sending: %s" % cmd) self.printer.send_now(cmd)
class SamplerFrame(InstrumentFrame): def __init__(self, master, instrument): InstrumentFrame.__init__(self, master, instrument, text_label="") file_name = os.path.basename(self.instrument.filename) self.load_file_button = Button(self, text=file_name, command=self.load_file, width=_FILE_BUTTON_WIDTH) self.load_file_button.grid(row=0, column=1) def load_file(self): file_path = tkFileDialog.askopenfile(filetypes=[("audio files", ".wav")]) if file_path: file_name = os.path.basename(file_path.name) self.instrument.load_file(file_path.name) self.load_file_button.config(text=file_name)
def new_piece_gui(self, row, col, color): if color == "DimGray": queen = self.white_pieces[3] rook = self.white_pieces[0] bishop = self.white_pieces[2] knight = self.white_pieces[1] else: queen = self.black_pieces[3] rook = self.black_pieces[0] bishop = self.black_pieces[2] knight = self.black_pieces[1] self.piece_window = Toplevel() self.piece_window.title("Pick Your Piece") queen_label = Label(self.piece_window, text="Queen") rook_label = Label(self.piece_window, text="Rook") bishop_label = Label(self.piece_window, text="Bishop") knight_label = Label(self.piece_window, text="Knight") queen_label.grid(row=0, column=0, pady=10, padx=20) rook_label.grid(row=1, column=0, pady=10, padx=20) bishop_label.grid(row=2, column=0, pady=10, padx=20) knight_label.grid(row=3, column=0, pady=10, padx=20) queen_button = Button(self.piece_window, image=queen, width=144, height=90, bg="white") rook_button = Button(self.piece_window, image=rook, width=144, height=90, bg="black") bishop_button = Button(self.piece_window, image=bishop, width=144, height=90, bg="white") knight_button = Button(self.piece_window, image=knight, width=144, height=90, bg="black") queen_button.config(command=lambda e=row, i=row, j=col, k=color: self.place_queen(i, j, k)) rook_button.config(command=lambda e=row, i=row, j=col, k=color: self.place_rook(i, j, k)) bishop_button.config(command=lambda e=row, i=row, j=col, k=color: self.place_bishop(i, j, k)) knight_button.config(command=lambda e=row, i=row, j=col, k=color: self.place_knight(i, j, k)) queen_button.grid(row=0, column=1) rook_button.grid(row=1, column=1) bishop_button.grid(row=2, column=1) knight_button.grid(row=3, column=1)
def test_image(self): photo = PhotoImage(file="../scripts/buildgifs/8:30-9:10-270-68-68-rgb(97,91,92).gif") font = tkFont.Font(family="Monospace", size=20) # slant=tkFont.ITALIC # weight=tkFont.BOLD mycolor = '#%02x%02x%02x' % (97, 91, 92) # #615b5c print mycolor self.master.grid() button = Tkbutton(self.master) button = Tklabel(self.master) button.config(image=photo,width="100",height="100",bg=mycolor) button.grid() #button.pack(side=LEFT, fill=BOTH,expand=1) self.master.mainloop()
class SaveClassifiedImage(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.classified_img = None self.save_button = Button(self, text = 'Save classified image', relief = 'raised', width = 23, command=self._save_classified_image, state = 'disabled') self.save_button.pack() def set_classified_image(self, classified_img): self.classified_img = classified_img self.save_button.config(state = 'normal') def _save_classified_image(self): save_image_file(self, self.classified_img)
def __init__(self, notification_manager, builder, index, x, y, h, v, padx, pady, background=None, on_hide=None): Toplevel.__init__(self) self._notification_manager = notification_manager self.index = index self.on_hide = on_hide # Removes the native window boarder. self.overrideredirect(True) # Disables resizing of the widget. self.resizable(False, False) # Places window above all other windows in the window stack. self.wm_attributes("-topmost", True) notification_frame = Frame(self) notification_frame.pack(expand=True, fill=BOTH, padx=padx, pady=pady) top_row = Frame(notification_frame) top_row.pack(fill=X) if not hasattr(notification_manager, "_close_icon"): notification_manager._close_icon = PhotoImage(data="R0lGODlhEAAQAPeQAIsAAI0AAI4AAI8AAJIAAJUAAJQCApkAAJoAAJ4AAJkJCaAAAKYAAKcAAKcCAKcDA6cGAKgAAKsAAKsCAKwAAK0AAK8AAK4CAK8DAqUJAKULAKwLALAAALEAALIAALMAALMDALQAALUAALYAALcEALoAALsAALsCALwAAL8AALkJAL4NAL8NAKoTAKwbAbEQALMVAL0QAL0RAKsREaodHbkQELMsALg2ALk3ALs+ALE2FbgpKbA1Nbc1Nb44N8AAAMIWAMsvAMUgDMcxAKVABb9NBbVJErFYEq1iMrtoMr5kP8BKAMFLAMxKANBBANFCANJFANFEB9JKAMFcANFZANZcANpfAMJUEMZVEc5hAM5pAMluBdRsANR8AM9YOrdERMpIQs1UVMR5WNt8X8VgYMdlZcxtYtx4YNF/btp9eraNf9qXXNCCZsyLeNSLd8SSecySf82kd9qqc9uBgdyBgd+EhN6JgtSIiNuJieGHhOGLg+GKhOKamty1ste4sNO+ueenp+inp+HHrebGrefKuOPTzejWzera1O7b1vLb2/bl4vTu7fbw7ffx7vnz8f///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAJAALAAAAAAQABAAAAjUACEJHEiwYEEABniQKfNFgQCDkATQwAMokEU+PQgUFDAjjR09e/LUmUNnh8aBCcCgUeRmzBkzie6EeQBAoAAMXuA8ciRGCaJHfXzUMCAQgYooWN48anTokR8dQk4sELggBhQrU9Q8evSHiJQgLCIIfMDCSZUjhbYuQkLFCRAMAiOQGGLE0CNBcZYmaRIDLqQFGF60eTRoSxc5jwjhACFWIAgMLtgUocJFy5orL0IQRHAiQgsbRZYswbEhBIiCCH6EiJAhAwQMKU5DjHCi9gnZEHMTDAgAOw==") close_button = Button(top_row, image=notification_manager._close_icon, highlightthickness=0, borderwidth=0, command=self.close) close_button.pack(side=RIGHT, anchor=E) self.interior = Frame(notification_frame) self.interior.pack(expand=True, fill=BOTH) if builder: builder(self.interior) if background is not None: top_row.config(background=background) notification_frame.config(background=background) self.config(background=background) self.interior.config(background=background) close_button.config(background=background) self.place(x,y, h, v)
def __init__(self,parent,labels,disablesorting=0,**kw): Frame.__init__(self,parent) self.labels=labels self.lists=[] self.disablesorting=disablesorting kw["exportselection"]=0 for i in range(len(labels)): b=Button(self,text=labels[i],anchor=W,height=1,pady=0) b.config(command=lambda s=self,i=i:s.setSort(i)) b.grid(column=i,row=0,sticky=N+E+W) box=apply(Listbox,(self,),kw) box.grid(column=i,row=1,sticky=N+E+S+W) self.lists.append(box) grid_setexpand(self) self.rowconfigure(0,weight=0) self._callall("bind",'<Button-1>',self.Button1) self._callall("bind",'<B1-Motion>',self.Button1) self.bind('<Up>',self.UpKey) self.bind('<Down>',self.DownKey) self.sort=None
def display(self, frame_obj): canvas_popup = Canvas(frame_obj, background=conf.left_nav_background) # canvas_popup.config(x=0, y=0) canvas_popup.place(x=(frame_obj.sw/2), y=(frame_obj.sh/2)-100) if self.title != "": title_label = Label(canvas_popup, text=self.title, fg=conf.main_text_color) title_label.config(highlightbackground=conf.left_nav_background, background=conf.left_nav_background) title_label.grid(row=0, sticky='e,w', padx=10, pady=10) if self.content != "": content_label = Label(canvas_popup, text=self.content, fg=conf.main_text_color) content_label.config(highlightbackground=conf.left_nav_background, background=conf.left_nav_background) content_label.grid(row=1, sticky='e,w', padx=10, pady=10) if self.content != "": action_button = Button(canvas_popup, text="Ok", fg=conf.main_text_color) action_button.config(highlightbackground=conf.left_nav_background, background=conf.left_nav_background) action_button.bind("<Button-1>", self.dismiss) action_button.grid(row=2, sticky='e,w', padx=10, pady=10)
class haltface(Frame): def __init__(self, x): Frame.__init__(self, x) self.config(relief=GROOVE) # self.default_font = tkFont.nametofont("TkDefaultFont") # self.default_font.configure(family="Helvetica",size=10) self.config(borderwidth=2) self.HALTbutton = Button(self) self.HALTbutton.config(text = "HALT") self.HALTbutton.config(fg = "red") self.HALTbutton.config(command = self.quit) self.HALTbutton.grid(row=0, column=0, sticky="wens") self.pack()
class RealtimeVisualiser(Visualiser): """A VTK-powered realtime visualiser which runs in its own thread. In addition to the functions provided by the standard visualiser, the following additional functions are provided: update() - Sync the visualiser to the current state of the model. Should be called inside the evolve loop. evolveFinished() - Clean up synchronisation constructs that tie the visualiser to the evolve loop. Call this after the evolve loop finishes to ensure a clean shutdown. """ def __init__(self, source): """The source parameter is assumed to be a Domain. """ Visualiser.__init__(self, source) self.running = True self.xmin = None self.xmax = None self.ymin = None self.ymax = None self.zmin = None self.zmax = None # Synchronisation Constructs self.sync_idle = Event() self.sync_idle.clear() self.sync_unpaused = Event() self.sync_unpaused.set() self.sync_redrawReady = Event() self.sync_redrawReady.clear() def setup_grid(self): self.vtk_cells = vtkCellArray() triangles = self.source.get_triangles() N_tri = len(self.source) verticies = self.source.get_vertex_coordinates() N_vert = len(verticies) # Also build vert_index - a list of the x & y values of each vertex self.vert_index = num.zeros((N_vert,2), num.float) for n in range(N_tri): self.vtk_cells.InsertNextCell(3) for v in range(3): self.vert_index[n * 3 + v] = verticies[n * 3 + v] self.vtk_cells.InsertCellPoint(n * 3 + v) def update_height_quantity(self, quantityName, dynamic=True): N_vert = len(self.source.get_vertex_coordinates()) qty_index = num.zeros(N_vert, num.float) triangles = self.source.get_triangles() vertex_values, _ = self.source.get_quantity(quantityName).get_vertex_values(xy=False, smooth=False) for n in range(N_vert): qty_index[n] = vertex_values[n] points = vtkPoints() for v in range(N_vert): points.InsertNextPoint(self.vert_index[v][0], self.vert_index[v][1], qty_index[v] * self.height_zScales[quantityName] + self.height_offset[quantityName]) if self.xmin == None or self.xmin > self.vert_index[v][0]: self.xmin = self.vert_index[v][0] if self.xmax == None or self.xmax < self.vert_index[v][0]: self.xmax = self.vert_index[v][0] if self.ymin == None or self.ymin > self.vert_index[v][1]: self.ymin = self.vert_index[v][1] if self.ymax == None or self.ymax < self.vert_index[v][1]: self.ymax = self.vert_index[v][1] if self.zmin == None or self.zmin > qty_index[v] * self.height_zScales[quantityName] + self.height_offset[quantityName]: self.zmin = qty_index[v] * self.height_zScales[quantityName] + self.height_offset[quantityName] if self.zmax == None or self.zmax < qty_index[v] * self.height_zScales[quantityName] + self.height_offset[quantityName]: self.zmax = qty_index[v] * self.height_zScales[quantityName] + self.height_offset[quantityName] polydata = self.vtk_polyData[quantityName] = vtkPolyData() polydata.SetPoints(points) polydata.SetPolys(self.vtk_cells) def get_3d_bounds(self): return [self.xmin, self.xmax, self.ymin, self.ymax, self.zmin, self.zmax] def build_quantity_dict(self): triangles = self.source.get_triangles() quantities = {} for q in self.source.get_quantity_names(): #quantities[q], _ = self.source.get_quantity(q).get_vertex_values(xy=False) quantities[q] = self.source.get_quantity(q).vertex_values.flatten() return quantities def setup_gui(self): Visualiser.setup_gui(self) self.tk_pauseResume = Button(self.tk_controlFrame, text="Pause", command=self.pauseResume) self.tk_pauseResume.grid(row=1, column=0, sticky=E+W) def pauseResume(self): if self.sync_unpaused.isSet(): self.sync_unpaused.clear() self.tk_pauseResume.config(text="Resume") else: self.sync_unpaused.set() self.tk_pauseResume.config(text="Pause") def shutdown(self): Visualiser.shutdown(self) self.running = False self.sync_idle.set() self.sync_unpaused.set() def redraw(self): if self.running and self.sync_unpaused.isSet(): self.sync_redrawReady.wait() self.sync_redrawReady.clear() self.redraw_quantities() self.sync_idle.set() Visualiser.redraw(self) def update(self,pause=False): """Sync the visualiser to the domain. Call this in the evolve loop.""" if self.running: self.sync_redrawReady.set() self.sync_idle.wait() self.sync_idle.clear() self.sync_unpaused.wait() if pause and self.running: if self.sync_unpaused.isSet(): self.sync_unpaused.clear() self.tk_pauseResume.config(text="Resume") self.sync_redrawReady.set() self.sync_idle.wait() self.sync_idle.clear() self.sync_unpaused.wait() return self.running def evolveFinished(self): """Stop the visualiser from waiting on signals from the evolve loop. Call this just after the evolve loop to ensure a clean shutdown.""" self.running = False self.sync_redrawReady.set()
class ChargenColor: def __init__(self, parent): self.colorNegative = [] self.colorNeutral = [] self.colorPositive = [] self.scaleNegative = 0.0 self.scalePositive = 0.0 self.cNegative = '#ff0000' self.cNeutral = '#000000' self.cPositive = '#0000ff' self.minNegativeLbl = Label(rootC, text='Min Found: -') self.maxPositiveLbl = Label(rootC, text='Max Found: -') self.scaleLbl = Label(rootC, text='Scale: - to -') self.sclSelectPositive = Spinbox(rootC) self.sclSelectPositive.insert(0, 0.0) self.sclSelectNegative = Spinbox(rootC) self.sclSelectNegative.insert(0, 0.0) self.buttonNegativeCharge = Button( rootC, text='Negative Charge Color', command=self.chooseNegativeCharge) self.buttonNeutralCharge = Button( rootC, text='Neutral Charge Color', command=self.chooseNeutralCharge) self.buttonPositiveCharge = Button( rootC, text='Positive Charge Color', command=self.choosePositiveCharge) self.buttonBG = Button( rootC, text='Background Color', command=self.chooseBackground) self.buttonUpdateColor = Button( rootC, text='Update', command=self.updateColor) self.title = Label(rootC, text="Select your colors") self.buttonClose = Button(rootC, text="Close", command=rootC.destroy) self.buttonBG.pack() self.title.pack() self.buttonNegativeCharge.pack() self.buttonNeutralCharge.pack() self.buttonPositiveCharge.pack() self.minNegativeLbl.pack() self.maxPositiveLbl.pack() self.scaleLbl.pack() self.sclSelectNegative.pack() self.sclSelectPositive.pack() self.buttonUpdateColor.pack() self.buttonClose.pack() def chooseNegativeCharge(self): self.colorNegative = askcolor( color=self.cNegative, title="Negative Charge Color") self.buttonNegativeCharge.config(fg=self.colorNegative[1]) self.cNegative = self.colorNegative[1] def chooseNeutralCharge(self): self.colorNeutral = askcolor( color=self.cNeutral, title="Neutral Charge Color") self.buttonNeutralCharge.config(fg=self.colorNeutral[1]) self.cNeutral = self.colorNeutral[1] def choosePositiveCharge(self): self.colorPositive = askcolor( color=self.cPositive, title="Positive Charge Color") self.buttonPositiveCharge.config(fg=self.colorPositive[1]) self.cPositive = self.colorPositive[1] def chooseBackground(self): bgcolor = askcolor( color=self.cPositive, title="Positive Charge Color") cmd.set_color("bg_chargy_color", bgcolor[0]) cmd.bg_color("bg_chargy_color") def updateColor(self): selection = 'all' stored.atoms_charge = [] stored.atoms_colors = [] cmd.map_new('chargyc_map', selection="(all)") if not self.colorNeutral: tkMessageBox.showerror("Error", "Set Neutral Color, Please") return if not self.colorNegative: tkMessageBox.showerror("Error", "Set Negative Color, Please") return if not self.colorPositive: tkMessageBox.showerror("Error", "Set Positive Color, Please") return cmd.iterate_state(1, '(' + selection + ')', 'stored.atoms_charge.append(partial_charge)') _i = 0 minValue = None maxValue = None while _i < len(stored.atoms_charge): color = [] if _i == 0: maxValue = stored.atoms_charge[_i] minValue = stored.atoms_charge[_i] if(stored.atoms_charge[_i] > maxValue): maxValue = stored.atoms_charge[_i] if stored.atoms_charge[_i] < minValue: minValue = stored.atoms_charge[_i] _i += 1 self.minNegativeLbl["text"] = 'Min Found: ' + str(round(minValue, 3)) self.maxPositiveLbl["text"] = 'Max Found: ' + str(round(maxValue, 3)) if(self.scaleNegative == 0.0 and self.scalePositive == 0.0): self.scaleNegative = round(minValue, 3) self.scalePositive = round(maxValue, 3) self.sclSelectNegative.delete(0, "end") self.sclSelectPositive.delete(0, "end") self.sclSelectNegative.insert(0, round(minValue, 3)) self.sclSelectPositive.insert(0, round(maxValue, 3)) else: self.scaleNegative = float(self.sclSelectNegative.get()) self.scalePositive = float(self.sclSelectPositive.get()) minValue = float(self.sclSelectNegative.get()) maxValue = float(self.sclSelectPositive.get()) self.scaleLbl["text"] = 'Scale: ' + str( self.scaleNegative) + ' to ' + str(self.scalePositive) middleValue = 0 if(maxValue < 0): maxValue = 0 if(minValue > 0): minValue = 0 _i = 0 while _i < len(stored.atoms_charge): color = [] cmd.set_color("neutral_color", self.colorNeutral[0]) cmd.set_color("positive_color", self.colorPositive[0]) cmd.set_color("negative_color", self.colorNegative[0]) if(stored.atoms_charge[_i] >= middleValue): if(stored.atoms_charge[_i] == middleValue): cmd.set_color(str(_i) + "_color", self.colorNeutral[0]) else: cmd.set_color(str(_i) + "_color", self.getColor( self.colorNeutral[0], self.colorPositive[0], maxValue, stored.atoms_charge[_i] if stored.atoms_charge[_i] < maxValue else maxValue)) else: cmd.set_color(str(_i) + "_color", self.getColor( self.colorNeutral[0], self.colorNegative[0], abs(minValue), abs(stored.atoms_charge[_i]) if abs(stored.atoms_charge[_i]) < abs(minValue) else abs(minValue))) index = cmd.get_color_index(str(_i) + "_color") stored.atoms_colors.append(index) _i += 1 cmd.alter_state(1, '(' + selection + ')', "color=stored.atoms_colors.pop(0)") cmd.ramp_new('chargy_ramp', 'chargyc_map', range=[self.scaleNegative, ((self.scaleNegative+self.scalePositive)/2.0), self.scalePositive], color=['negative_color', 'neutral_color', 'positive_color']) def getColor(self, color, colorMax, step, index): colorStep = [0, 0, 0] colorStep[0] = ((colorMax[0]-color[0])/step) colorStep[1] = ((colorMax[1]-color[1])/step) colorStep[2] = ((colorMax[2]-color[2])/step) return [ 1.0 if (color[0] + (colorStep[0]*index)) / 255.0 >= 1 else (color[0] + (colorStep[0]*index))/255.0, 1.0 if (color[1] + (colorStep[1]*index)) / 255.0 >= 1 else (color[1] + (colorStep[1]*index))/255.0, 1.0 if (color[2] + (colorStep[2]*index)) / 255.0 >= 1 else (color[2] + (colorStep[2]*index))/255.0 ]
class IntroView(Frame): def __init__(self, controller, parent): # formerly init_intro_nav(): ''' using class objects for all these vars now global intro_nav, background_frame, can, button_load_game\ , button_new_game, button_quit, intro_fill_bottom\ , label_version, title_image_res\ , intro_top_padding, intro_btm_padding ''' self.controller = controller self.parent = parent self.app = self.controller.app # declare vars self.background_frame = 0 self.intro_nav = 0 self.intro_top_padding = 0 def build(self): # prev: build_intro_nav # frame setup conf = self.app.conf self.background_frame = Frame(self.parent, height=self.parent.sh, width=self.parent.sw , background=conf.window_background) self.intro_nav = Frame(self.background_frame, height=500, width=500 , background=conf.intro_background) # elements self.intro_top_padding = Canvas(self.intro_nav) self.intro_top_padding.configure(height=conf.intro_padding_height , background=conf.intro_background , highlightbackground=conf.intro_background) self.title_image_resource = Image.open(conf.title_image_path) self.title_image_res = ImageTk.PhotoImage(self.title_image_resource) self.can = Canvas(self.intro_nav, background=conf.intro_background , highlightbackground=conf.intro_background) self.can.title_image_res = self.title_image_res self.can.config(width=self.title_image_res.width(), height=self.title_image_res.height()) self.button_new_game = Button(self.intro_nav, text="New Game" , command=self.controller.event_button_new_game , bg=conf.intro_background) self.button_new_game.config(highlightbackground=conf.intro_background) self.button_load_game = Button(self.intro_nav, text="Load Game" , command=self.controller.event_button_load_game , bg=conf.intro_background) self.button_load_game.config(highlightbackground=conf.intro_background) self.button_load_game.config(state='disabled') self.button_quit = Button(self.intro_nav, text="Quit" , command=self.controller.event_button_quit , bg=conf.intro_background) self.button_quit.config(highlightbackground=conf.intro_background) self.label_version = Label(self.intro_nav, bg=conf.intro_background, text=conf.version) self.intro_btm_padding = Canvas(self.intro_nav) self.intro_btm_padding.configure(height=conf.intro_padding_height , background=conf.intro_background , highlightbackground=conf.intro_background) def hide(self): # formerly hide_intro_nav self.intro_nav.destroy() self.background_frame.destroy() self.can.destroy() self.button_load_game.destroy() self.button_new_game.destroy() self.button_quit.destroy() self.label_version.destroy() self.title_image_res.__del__() self.intro_top_padding.destroy() self.intro_btm_padding.destroy() def draw(self): # formerly draw_intro_nav() # frame setup self.intro_top_padding.pack() self.background_frame.pack(fill='both') self.intro_nav.pack(fill='both', padx=(self.parent.sw/2)-250, pady=(self.parent.sh/2)-250) self.app.debug(("Drew Intro, padding: (", (self.parent.sw/2)-250, ",", (self.parent.sh/2)-250, ")")) # elements self.can.pack(fill='both', side='top', padx=50, pady=50) self.can.create_image(2, 2, image=self.title_image_res, anchor='nw') self.button_new_game.pack(fill="x", padx=50) self.button_load_game.pack(fill="x", padx=50) self.button_quit.pack(fill="x", padx=50) self.label_version.pack(fill='y', padx=10, pady=10) self.intro_btm_padding.pack() '''
def __init__(self, notification_manager, builder, index, x, y, h, v, padx, pady, background=None, on_hide=None): Toplevel.__init__(self) self._notification_manager = notification_manager #self.geometry("1x1") self.index = index self.on_hide = on_hide # Removes the native window boarder. self.overrideredirect(True) # Disables resizing of the widget. self.resizable(False, False) # Places window above all other windows in the window stack. self.wm_attributes("-topmost", True) notification_frame = Frame(self) notification_frame.pack(expand=True, fill=BOTH, padx=padx, pady=pady) top_row = Frame(notification_frame) top_row.pack(fill=X) if not hasattr(notification_manager, "_close_icon"): notification_manager._close_icon = PhotoImage( data= "R0lGODlhEAAQAPeQAIsAAI0AAI4AAI8AAJIAAJUAAJQCApkAAJoAAJ4AAJkJCaAAAKYAAKcAAKcCAKcDA6cGAKgAAKsAAKsCAKwAAK0AAK8AAK4CAK8DAqUJAKULAKwLALAAALEAALIAALMAALMDALQAALUAALYAALcEALoAALsAALsCALwAAL8AALkJAL4NAL8NAKoTAKwbAbEQALMVAL0QAL0RAKsREaodHbkQELMsALg2ALk3ALs+ALE2FbgpKbA1Nbc1Nb44N8AAAMIWAMsvAMUgDMcxAKVABb9NBbVJErFYEq1iMrtoMr5kP8BKAMFLAMxKANBBANFCANJFANFEB9JKAMFcANFZANZcANpfAMJUEMZVEc5hAM5pAMluBdRsANR8AM9YOrdERMpIQs1UVMR5WNt8X8VgYMdlZcxtYtx4YNF/btp9eraNf9qXXNCCZsyLeNSLd8SSecySf82kd9qqc9uBgdyBgd+EhN6JgtSIiNuJieGHhOGLg+GKhOKamty1ste4sNO+ueenp+inp+HHrebGrefKuOPTzejWzera1O7b1vLb2/bl4vTu7fbw7ffx7vnz8f///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAJAALAAAAAAQABAAAAjUACEJHEiwYEEABniQKfNFgQCDkATQwAMokEU+PQgUFDAjjR09e/LUmUNnh8aBCcCgUeRmzBkzie6EeQBAoAAMXuA8ciRGCaJHfXzUMCAQgYooWN48anTokR8dQk4sELggBhQrU9Q8evSHiJQgLCIIfMDCSZUjhbYuQkLFCRAMAiOQGGLE0CNBcZYmaRIDLqQFGF60eTRoSxc5jwjhACFWIAgMLtgUocJFy5orL0IQRHAiQgsbRZYswbEhBIiCCH6EiJAhAwQMKU5DjHCi9gnZEHMTDAgAOw==" ) close_button = Button(top_row, image=notification_manager._close_icon, highlightthickness=0, borderwidth=0, command=self.close) close_button.pack(side=RIGHT, anchor=E) self.interior = Frame(notification_frame) self.interior.pack(expand=True, fill=BOTH) if builder: builder(self.interior) if background is not None: top_row.config(background=background) notification_frame.config(background=background) self.config(background=background) self.interior.config(background=background) close_button.config(background=background) self.place(x, y, h, v)
class ExpSonar: def __init__(self, fileloc, rng=5, sleeptime=2): # experiment with range rng self.rng = rng self.sleeptime = sleeptime self.fileloc = fileloc # list of points and coords of experiments self.pt_dict = {'1': '68,68', '2': '67,136','3': '138,68','4': '138,136','5': '197,68','6': '197,136','7': '259,68','8': '259,136','9': '327,68','10': '327,136','11': '366,25','12': '366,136','13': '353,204','14': '353,272','15': '295,204','16': '295,272','17': '353,348','18': '353,408','19': '353,476','20': '295,348','21': '295,408','22': '295,476'} self.make_pub() self.r = Tk() self.c = Canvas(self.r, width=400, height=600) self.c.pack() self.mv = [] self.smath = s_math.SonarMath() self.pts = [] self.ovals = [] self.run = Button(self.r, text='run', command=self.run) self.run.pack() self.reset = Button(self.r, text='reset', command=self.reset) self.reset.pack() for key in self.pt_dict: a = map(int, self.pt_dict[key].split(',')) self.pts.append(a) self.c.create_oval(a[0] -1, a[1] -1, a[0] + 1, a[1] + 1) self.c.bind("<Button-1>", self.path) self.r.mainloop() def path(self, event): x = event.x y = event.y pe = [x,y] for pt in self.pts: if self.smath.pt_dist(pt, pe) <= 10: self.mv.append(pt) if len(self.mv) > 1: self.c.create_line(self.mv[-2][0], self.mv[-2][1], self.mv[-1][0], self.mv[-1][1], tags='mvline') def reset(self): self.mv = [] self.c.delete('mvline') def run(self): for i, p in enumerate(self.mv): fname = '%s/prc_%d_%d_%d.txt'%(self.fileloc, p[0],p[1], self.rng) data = proc_sonar() try: f = open(fname, 'r') # print '%s/prc_%d_%d_%d.txt'%(self.fileloc, p[0],p[1], self.rng) data.prev = point(self.mv[i - 1][0],self.mv[i - 1][1]) if i != 0 else point(self.mv[i][0], self.mv[i][1]) data.next = point(self.mv[i][0], self.mv[i][1]) data.angle = 0 data.ranges = map(float, f.read().split(' ')) data.actual = point(p[0], p[1]) self.pub.publish(data) except IOError: print 'file %s does not exist'%(fname) rospy.sleep(self.sleeptime) # artificial time an action takes self.run.config(state='disabled') def make_pub(self): self.pub = rospy.Publisher('sonar_sim_readable', proc_sonar) rospy.init_node('experiment_gui')
class ToolBar(Frame): def __init__(self, root, printer, settings, logger, *arg): self.app = root self.printer = printer self.settings = settings self.logger = logger self.app.printing = False self.app.connected = False self.app.paused = False Frame.__init__(self, root, *arg) topBar = Frame(self) topBar.grid(row=1, column=1, columnspan=3, sticky=W) speedBar = Frame(self) speedBar.grid(row=1, column=5, sticky=E) bottomBar = Frame(self) bottomBar.grid(row=2, column=1, columnspan=6, sticky=W+E) self.bPort = Button(topBar, text="Port", width=BWIDTH, command=self.doPort) self.bPort.pack(side=LEFT, padx=2, pady=2) ports = self.scanSerial() self.spPort = Spinbox(topBar, values=ports, state="readonly") self.spPort.pack(side=LEFT, padx=2, pady=2) l = Label(topBar, text=" @ ") l.pack(side=LEFT, padx=2, pady=2) self.spBaud = Spinbox(topBar, values=baudChoices) self.spBaud.pack(side=LEFT, padx=2, pady=2) self.spBaud.delete(0, END) self.spBaud.insert(0, 115200) self.spBaud.config(state="readonly") self.bConnectMode = CM_CONNECT self.bConnect = Button(topBar, text=connectText[CM_CONNECT], width=BWIDTH, command=self.doConnect) self.bConnect.pack(side=LEFT, padx=2, pady=2) if len(ports) == 0: self.bConnect.config(state=DISABLED) else: self.bConnect.config(state=NORMAL) self.bReset = Button(topBar, text="Reset", width=BWIDTH, command=self.doReset, state=DISABLED) self.bReset.pack(side=LEFT, padx=2, pady=2) l = Label(speedBar, text="Speed:", justify=RIGHT) l.grid(row=1, column=1, sticky=E) self._speedJob = None self.currentSpeed = self.app.FeedMultiply self.scSpeed = Scale(speedBar, from_=MINSPEED, to=MAXSPEED, orient=HORIZONTAL, command=self.updateSpeedCommand) self.scSpeed.grid(row=1, column=2) self.scSpeed.set(self.currentSpeed); l = Label(speedBar, text="Fan:", width=10, anchor=E, justify=RIGHT) l.grid(row=1, column=3, sticky=E) self._fanJob = None self.currentFanSpeed = self.app.FanSpeed self.scFan = Scale(speedBar, from_=0, to=255, orient=HORIZONTAL, command=self.updateFanSpeedCommand) self.scFan.grid(row=1, column=4) self.scFan.set(self.currentFanSpeed); if self.settings.speedcommand is not None: self.cbvAssertFan = IntVar() if self.settings.forcefanspeed: self.cbvAssertFan.set(1) else: self.cbvAssertFan.set(0) self.cbAssertFan = Checkbutton(speedBar, text="Force", variable=self.cbvAssertFan, command=self.clickAssertFan) self.cbAssertFan.grid(row=1, column=5) self.bSliceMode = SM_SLICE self.bSlice = Button(bottomBar, text=sliceText[SM_SLICE], width=BWIDTH*2, command=self.doSlice) self.bSlice.pack(side=LEFT, padx=2, pady=2) self.bLoad = Button(bottomBar, text="Load GCode", width=BWIDTH, command=self.doLoad) self.bLoad.pack(side=LEFT, padx=2, pady=2) self.setSliceText() self.bSD = Button(bottomBar, text="SD", width=BWIDTH, command=self.doSD, state=DISABLED) self.bSD.pack(side=LEFT, padx=2, pady=2) self.bPrintMode = PR_PRINT self.bPrint = Button(bottomBar, text=printText[PR_PRINT], width=BWIDTH, command=self.doPrint, state=DISABLED) self.bPrint.pack(side=LEFT, padx=2, pady=2) self.bPauseMode = PM_PAUSE self.bPause = Button(bottomBar, text=pauseText[PM_PAUSE], width=BWIDTH, command=self.doPause, state=DISABLED) self.bPause.pack(side=LEFT, padx=2, pady=2) self.bAbandon = Button(bottomBar, text="Abandon SD Print", width=BWIDTH+8, command=self.doAbandon, state=DISABLED) self.bAbandon.pack(side=LEFT, padx=2, pady=2) self.cbvLiftOnPause = IntVar() if self.settings.liftonpause: self.cbvLiftOnPause.set(1) else: self.cbvLiftOnPause.set(0) self.cbLiftOnPause = Checkbutton(bottomBar, text="Lift Head/Retract on Pause", variable=self.cbvLiftOnPause, command=self.clickLiftOnPause) self.cbLiftOnPause.pack(side=LEFT, padx=2) self.cbvResumeAtPause = IntVar() if self.settings.resumeatpausepoint: self.cbvResumeAtPause.set(1) else: self.cbvResumeAtPause.set(0) self.cbResumeAtPause = Checkbutton(bottomBar, text="Resume print at pause point", variable=self.cbvResumeAtPause, command=self.clickResumeAtPause) self.cbResumeAtPause.pack(side=LEFT, padx=2) def clickAssertFan(self): if self.cbvAssertFan.get() == 1: self.settings.forcefanspeed = True self.settings.setModified() else: self.settings.forcefanspeed = False self.settings.setModified() def clickLiftOnPause(self): if self.cbvLiftOnPause.get() == 1: self.settings.liftonpause = True self.settings.setModified() else: self.settings.liftonpause = False self.settings.setModified() def clickResumeAtPause(self): if self.cbvResumeAtPause.get() == 1: self.settings.resumeatpausepoint = True self.settings.setModified() else: self.settings.resumeatpausepoint = False self.settings.setModified() def setSliceText(self): if self.settings.slicer == SLIC3R: sl = "slic3r:%s" % self.app.slic3r.getProfile() else: sl = "skeinforge:%s" % self.app.skeinforge.getProfile() sliceText[SM_SLICE] = "Slice (%s)" % sl if self.bSliceMode == SM_SLICE: self.bLoad.config(state=NORMAL) self.app.allowLoadGCodeMenu(True) lt = len(sliceText[SM_SLICE])+2 if lt < BWIDTH: lt = BWIDTH self.bSlice.config(text=sliceText[SM_SLICE], width=lt) def updateSpeedCommand(self, *arg): if self._speedJob: self.app.master.after_cancel(self._speedJob) self._speedJob = self.app.master.after(500, self.updateSpeed) def updateSpeed(self, *arg): v = self.scSpeed.get() self.setSpeed(v) def setSpeed(self, v): if v < MINSPEED or v > MAXSPEED: self.logger.logMsg("Attempt to change speed outside of allowable range (%d-%d)" % (MINSPEED, MAXSPEED)) elif int(v) != self.currentSpeed: if self.app.connected: self.currentSpeed = int(v) self.logger.logMsg("changing speed percentage to %d%%" % self.currentSpeed) cmd = "M220 S%d" % self.currentSpeed self.printer.send_now(cmd) else: self.logger.logMsg("Printer is off-line") self.scSpeed.set(self.currentSpeed) def updateFanSpeedCommand(self, *arg): if self._fanJob: self.app.master.after_cancel(self._fanJob) self._fanJob = self.app.master.after(500, self.updateFanSpeed) def updateFanSpeed(self, *arg): v = self.scFan.get() self.setFanSpeed(v) self.app.FanSpeed = v def forceFanSpeed(self, v): self.currentFanSpeed = -1 self.setFanSpeed(v) def setFanSpeed(self, v): if int(v) != self.currentFanSpeed: if self.app.connected: self.currentFanSpeed = int(v) cmd = "M106 S%d" % self.currentFanSpeed self.printer.send_now(cmd) else: self.logger.logMsg("Printer is off-line") self.scFan.set(self.currentFanSpeed) def syncSpeeds(self): self.currentSpeed = self.app.FeedMultiply self.scSpeed.set(self.currentSpeed) self.currentFanSpeed = self.app.FanSpeed self.scFan.set(self.currentFanSpeed) def initializeToolbar(self): self.bReset.config(state=DISABLED) self.bSliceMode = SM_SLICE self.bSlice.config(text=sliceText[SM_SLICE]) self.bLoad.config(state=NORMAL) self.app.allowLoadGCodeMenu(True) if not self.app.sdprinting and not self.app.sdpaused: self.bPrintMode = PR_PRINT self.bPrint.config(text=printText[PR_PRINT], state=DISABLED) self.bPauseMode = PM_PAUSE self.bPause.config(text=pauseText[PM_PAUSE], state=DISABLED) def setSDPrint(self): self.bPause.config(text=pauseText[PM_PAUSE], state=NORMAL) self.bPauseMode = PM_PAUSE self.bPrint.config(text=printText[PR_PRINT], state=DISABLED) self.bPrintMode = PR_PRINT self.bAbandon.config(state=NORMAL) def clearSDPrint(self): self.bPause.config(text=pauseText[PM_PAUSE], state=DISABLED) self.bPauseMode = PM_PAUSE self.bPrint.config(text=printText[PR_PRINT], state=DISABLED) self.bPrintMode = PR_PRINT self.bAbandon.config(state=DISABLED) self.checkAllowPrint() def setCancelMode(self): self.bSliceMode = SM_CANCEL self.bSlice.config(text=sliceText[SM_CANCEL], width=BWIDTH) self.bLoad.config(state=DISABLED) self.app.allowLoadGCodeMenu(False) self.app.allowSliceMenu(False) def setLoading(self, flag): if flag: self.bLoad.config(state=DISABLED) self.bSlice.config(state=DISABLED) self.app.allowLoadGCodeMenu(False) self.app.allowSliceMenu(False) else: self.bLoad.config(state=NORMAL) self.bSlice.config(state=NORMAL) self.app.allowLoadGCodeMenu(True) self.app.allowSliceMenu(True) def clearCancelMode(self): self.bSliceMode = SM_SLICE lt = len(sliceText[SM_SLICE])+2 if lt < BWIDTH: lt = BWIDTH self.bSlice.config(text=sliceText[SM_SLICE], width=lt) self.bLoad.config(state=NORMAL) self.app.allowLoadGCodeMenu(True) self.app.allowSliceMenu(True) def doConnect(self): if self.bConnectMode == CM_CONNECT: port = self.spPort.get() baud = int(self.spBaud.get()) self.printer.onlinecb = self.onlinecb try: self.printer.connect(port, baud) except SerialException: self.logger.logMsg("Unable to open printer port %s" % port) else: if self.app.printing: self.logger.logMsg("Please wait until printing has finished or is paused") else: self.printer.disconnect() self.printer.onlinecb = None self.app.printerConnected(False) # self.app.connected = False self.bConnectMode = CM_CONNECT self.bConnect.config(text=connectText[CM_CONNECT]) self.bReset.config(state=DISABLED) self.bSD.config(state=DISABLED) if self.app.paused: self.bPrint.config(text=printText[PR_PRINT], state=DISABLED) self.bPrintMode = PR_PRINT self.bPause.config(text=pauseText[PM_PAUSE], state=DISABLED) self.bPauseMode = PM_PAUSE self.app.printing = False self.app.paused = False def doReset(self): if tkMessageBox.askyesno("Reset?", "Are you sure you want to reset the printer?", parent=self.app): self.printer.reset() self.printer.printing = 0 self.app.printing = False self.bSlice.config(state=NORMAL) self.bLoad.config(state=NORMAL) self.app.allowLoadGCodeMenu(True) self.app.allowSliceMenu(True) self.bPrintMode = PR_PRINT self.bPrint.config(text=printText[PR_PRINT], state=NORMAL) if self.app.paused: self.printer.paused = 0 self.bPause.config(text=pauseText[PM_PAUSE], state=DISABLED) self.bPauseMode = PM_PAUSE self.app.paused = False def onlinecb(self): self.logger.logMsg("Printer is on-line") self.app.printerConnected(True) # self.app.connected = True self.bConnectMode = CM_DISCONNECT self.bConnect.config(text=connectText[CM_DISCONNECT]) self.bReset.config(state=NORMAL) self.bSD.config(state=NORMAL) self.checkAllowPrint() def checkAllowPrint(self): if self.app.connected and len(self.app.gcode) != 0 and not self.app.printing and not self.app.sdprinting: self.bPrint.config(text=printText[PR_PRINT], state=NORMAL) self.bPrintMode = PR_PRINT def printComplete(self): self.app.endTime = time.time() self.app.elapsedTime = self.app.endTime - self.app.startTime self.logger.logMsg("Printing completed at %s" % time.strftime('%H:%M:%S', time.localtime())) self.logger.logMsg("Total elapsed time: %s" % formatElapsed(self.app.elapsedTime)) self.bPrintMode = PR_PRINT self.bPrint.config(text=printText[PR_PRINT], state=NORMAL) self.bPauseMode = PM_PAUSE self.bPause.config(text=pauseText[PM_PAUSE], state=DISABLED) self.app.printing = False self.bSlice.config(state=NORMAL) self.bLoad.config(state=NORMAL) self.app.allowLoadGCodeMenu(True) self.app.allowSliceMenu(True) self.app.paused = False self.app.gc.updatePrintProgress(0) self.app.closeAllReports() if self.settings.endprintmacro is not None: self.app.doMacro(name=self.settings.endprintmacro, silent=True) def doPause(self): if self.bPauseMode == PM_PAUSE: if self.app.printing: self.app.paused = True self.printer.pause() elif self.app.sdprinting: self.app.sdpaused = True self.printer.send_now("M25") self.app.sdprinting = False self.bPause.config(text=pauseText[PM_RESUME]) self.bPauseMode = PM_RESUME self.bPrint.config(text=printText[PR_RESTART], state=NORMAL) self.bPrintMode = PR_RESTART else: if self.app.sdpaused: self.printer.send_now("M24") self.app.sdpaused = False self.app.sdprinting = True self.bPause.config(text=pauseText[PM_PAUSE]) self.bPauseMode = PM_PAUSE self.bPrint.config(text=printText[PR_PRINT], state=DISABLED) self.bPrintMode = PR_PRINT else: self.hitPrint = False if self.settings.resumeatpausepoint: self.printer.send_now("G1 X%s Y%s F%s" % (self.app.pausePoint[XAxis], self.app.pausePoint[YAxis], self.settings.xyfeed)) self.printer.send_now("G1 Z%s F%s" % (self.app.pausePoint[ZAxis], self.settings.zfeed)) self.printer.send_now("G92 E%s" % self.app.pausePoint[EAxis]) self.printer.send_now("G1 F%s" % self.settings.xyfeed) self.printer.startcb = self.startcb self.printer.resume() def doAbandon(self): self.printer.send_now("M25") self.app.sdpaused = False self.app.sdprinting = False self.clearSDPrint() def doSlice(self): if self.bSliceMode == SM_SLICE: self.bLoad.config(state=DISABLED) self.app.allowLoadGCodeMenu(False) self.app.openSTLFile() else: self.app.slicerCancel = True self.bLoad.config(state=NORMAL) self.app.allowLoadGCodeMenu(True) def doLoad(self): self.app.openGCodeFile() def doPrint(self): if self.app.sdpaused: self.printer.send_now("M26 S0") self.printer.send_now("M24") self.app.sdpaused = False self.app.sdprinting = True self.bPause.config(text=pauseText[PM_PAUSE]) self.bPauseMode = PM_PAUSE self.bPrint.config(text=printText[PR_PRINT], state=DISABLED) self.bPrintMode = PR_PRINT else: if len(self.app.gcode) == 0: self.logger.logMsg("Nothing to print") else: #if not self.app.paused: self.app.gc.updatePrintProgress(0, restart=True) self.bPauseMode = PM_PAUSE self.bPause.config(text=pauseText[PM_PAUSE], state=NORMAL) self.hitPrint = True self.printer.startcb = self.startcb self.printer.startprint(self.app.gcode) def startcb(self): self.printer.startcb = None if not self.app.paused: self.app.startTime = time.time() self.logger.logMsg("Printing Started at %s" % time.strftime('%H:%M:%S', time.localtime(self.app.startTime))) self.app.printing = True self.bSlice.config(state=DISABLED) self.bLoad.config(state=DISABLED) self.app.allowLoadGCodeMenu(False) self.app.allowSliceMenu(False) self.bPrint.config(text=printText[PR_RESTART], state=DISABLED) self.bPrintMode = PR_RESTART self.printer.endcb = self.endcb else: if self.hitPrint: self.app.startTime = time.time() self.logger.logMsg("Printing restarted at %s" % time.strftime('%H:%M:%S', time.localtime())) else: self.logger.logMsg("Printing resumed at %s" % time.strftime('%H:%M:%S', time.localtime())) self.bPause.config(text=pauseText[PM_PAUSE]) self.bPauseMode = PM_PAUSE self.app.printing = True self.bSlice.config(state=DISABLED) self.bLoad.config(state=DISABLED) self.app.allowLoadGCodeMenu(False) self.app.allowSliceMenu(False) self.app.paused = False self.bPrint.config(state=DISABLED) self.printer.endcb = self.endcb def endcb(self): self.printer.endcb = None if not self.app.paused: self.printComplete() if self.app.sduploading: self.app.sduploading = False self.printer.send_now("M29") else: self.app.event_generate(MWM_REQUESTPOSITIONREPORT) # record the current printer position and how many intervals were willing to wait fo the response self.maxWait114 = MAXWAIT114; self.waitPos = self.printer.queueindex self.check114Response() def check114Response(self) : # tick off 1 interval, and make sure we haven't either received the report or we've waited max intervals self.maxWait114 -= 1 if self.app.m114count == 0 or self.maxWait114 <= 0: # one way or the other we're done waiting here if self.maxWait114 <= 0: self.app.m114count = 0 self.logger.logMsg("Location report not received - proceeding") self.app.pausePoint[XAxis] = self.app.location[XAxis] self.app.pausePoint[YAxis] = self.app.location[YAxis] self.app.pausePoint[ZAxis] = self.app.location[ZAxis] self.app.pausePoint[EAxis] = self.app.location[EAxis] self.logger.logMsg("Pause location: X:%f Y:%f Z:%f E:%f" % (self.app.pausePoint[XAxis], self.app.pausePoint[YAxis], self.app.pausePoint[ZAxis], self.app.pausePoint[EAxis])) if self.settings.liftonpause: self.printer.send_now("G1 E%s F%s" % (self.app.pausePoint[EAxis]-2, self.settings.efeed)) self.printer.send_now("G1 Z%s F%s" % (self.app.pausePoint[ZAxis]+10, self.settings.zfeed)) self.bPause.config(text=pauseText[PM_RESUME]) self.bPauseMode = PM_RESUME self.app.printing = False self.bSlice.config(state=NORMAL) self.bLoad.config(state=NORMAL) self.app.allowLoadGCodeMenu(True) self.app.allowSliceMenu(True) if self.app.sduploading: self.bPrint.config(text=printText[PR_PRINT], state=DISABLED) self.bPrintMode = PR_PRINT else: self.bPrint.config(text=printText[PR_RESTART], state=NORMAL) self.bPrintMode = PR_RESTART else: # we still are waiting for the report, but reset everything if the printer is still moving if self.waitPos != self.printer.queueindex: self.waitPos = self.printer.queueindex self.maxWait114 = MAXWAIT114 self.app.master.after(500, self.check114Response) def doPort(self): l = self.scanSerial() self.spPort.config(values=l) if len(l) == 0: self.bConnect.config(state=DISABLED) else: self.bConnect.config(state=NORMAL) def scanSerial(self): """scan for available ports. return a list of device names.""" baselist=[] if os.name=="nt": try: key=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,"HARDWARE\\DEVICEMAP\\SERIALCOMM") i=0 while(1): baselist+=[_winreg.EnumValue(key,i)[1]] i+=1 except: pass return baselist+glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*') +glob.glob("/dev/tty.*")+glob.glob("/dev/cu.*")+glob.glob("/dev/rfcomm*") def doSD(self): self.app.doSD()
class TopoConsole(tk.AppWindow,tk.TkParameterized): """ Main window for the Tk-based GUI. """ def _getmenubar(self): return self.master.menubar menubar = property(_getmenubar) def __getitem__(self,menu_name): """Allow dictionary-style access to the menu bar.""" return self.menubar[menu_name] def __init__(self,root,**params): tk.AppWindow.__init__(self,root,status=True) tk.TkParameterized.__init__(self,root,**params) # Instead of displaying tracebacks on the commandline, try to display # them on the originating window. # CEBALERT: on destroy(), ought to revert this Tkinter.Misc._report_exception=_tkinter_report_exception self.auto_refresh_panels = [] self._init_widgets() self.title(topo.sim.name) # If -g passed *before* scripts on commandline, this is useless. # So topo.misc.commandline sets the title as its last action (if -g) # catch click on the 'x': offers choice to quit or not self.protocol("WM_DELETE_WINDOW",self.quit_topographica) ########## ### Make cascade menus open automatically on linux when the mouse ### is over the menu title. ### [Tkinter-discuss] Cascade menu issue ### http://mail.python.org/pipermail/tkinter-discuss/2006-August/000864.html if topo.tkgui.system_platform is 'linux': activate_cascade = """\ if {[%W cget -type] != {menubar} && [%W type active] == {cascade}} { %W postcascade active } """ self.bind_class("Menu", "<<MenuSelect>>", activate_cascade) ########## # Install warning and message handling from param.parameterized import Parameterized self.__orig_P_warning = Parameterized.warning #self.__orig_P_message = Parameterized.message type.__setattr__(Parameterized,'warning',self.gui_warning) #type.__setattr__(Parameterized,'message',self.gui_message) def gui_warning(self,*args): stat = self.__get_status_bar() s = string.join(args,' ') stat.warn(s) self.__orig_P_warning(self,*args) def gui_message(self,*args): stat = self.__get_status_bar() s = string.join(args,' ') stat.message(s) self.__orig_P_message(self,*args) def title(self,t=None): newtitle = "Topographica" if t: newtitle+=": %s" % t tk.AppWindow.title(self,newtitle) def _init_widgets(self): ## CEBALERT: now we can have multiple operations at the same time, ## status bar could be improved to show all tasks? # CEBALERT self.messageBar = self.status self.some_area = DockManager(self) self.some_area.pack(fill="both", expand=1) ### Balloon, for pop-up help self.balloon = tk.Balloon(self.content) ### Top-level (native) menu bar #self.menubar = tk.ControllableMenu(self.content) self.configure(menu=self.menubar) #self.menu_balloon = Balloon(topo.tkgui.root) # no menubar in tile yet # http://news.hping.org/comp.lang.tcl.archive/4679.html self.__simulation_menu() self.__create_plots_menu() self.refresh_plots_menu() self.__help_menu() ### Running the simulation run_frame = Frame(self.content) run_frame.pack(side='top',fill='x',padx=4,pady=8) self.run_frame = run_frame Label(run_frame,text='Run for: ').pack(side=LEFT) self.run_for_var=DoubleVar() self.run_for_var.set(1.0) run_for = tk.TaggedSlider(run_frame, variable=self.run_for_var, tag_width=11, slider_length=150, bounds=(0,20000)) self.balloon.bind(run_for,"Duration to run the simulation, e.g. 0.0500, 1.0, or 20000.") run_for.pack(side=LEFT,fill='x',expand=YES) run_for.tag.bind("<Return>",self.run_simulation) # When return is pressed, the TaggedSlider updates itself...but we also want to run # the simulation in this case. run_frame.optional_action=self.run_simulation go_button = Button(run_frame,text="Go", command=self.run_simulation) go_button.pack(side=LEFT) self.balloon.bind(go_button,"Run the simulation for the specified duration.") self.step_button = Button(run_frame,text="Step",command=self.run_step) self.balloon.bind(self.step_button,"Run the simulation through the time at which the next events are processed.") self.step_button.pack(side=LEFT) self.sizeright() def __simulation_menu(self): """Add the simulation menu options to the menubar.""" simulation_menu = ControllableMenu(self.menubar,tearoff=0) self.menubar.add_cascade(label='Simulation',menu=simulation_menu) simulation_menu.add_command(label='Run script',command=self.run_script) simulation_menu.add_command(label='Save script',command=self.save_script_repr) simulation_menu.add_command(label='Load snapshot',command=self.load_snapshot) simulation_menu.add_command(label='Save snapshot',command=self.save_snapshot) #simulation_menu.add_command(label='Reset',command=self.reset_network) simulation_menu.add_command(label='Test Pattern',command=self.open_test_pattern) simulation_menu.add_command(label='Model Editor',command=self.open_model_editor) simulation_menu.add_command(label='Quit',command=self.quit_topographica) def open_test_pattern(self): return open_plotgroup_panel(TestPattern) def __create_plots_menu(self): """ Add the plot menu to the menubar, with Basic plots on the menu itself and others in cascades by category (the plots come from plotgroup_templates). """ plots_menu = ControllableMenu(self.menubar,tearoff=0) self.menubar.add_cascade(label='Plots',menu=plots_menu) # CEBALERT: should split other menus in same way as plots (create/refresh) def refresh_plots_menu(self): plots_menu = self['Plots'] plots_menu.delete(0,'end') # create menu entries, and get list of categories entries=KeyedList() # keep the order of plotgroup_templates (which is also KL) categories = [] for label,plotgroup in plotgroups.items(): entries[label] = PlotsMenuEntry(plotgroup) categories.append(plotgroup.category) categories = sorted(set(categories)) # The Basic category items appear on the menu itself. assert 'Basic' in categories, "'Basic' is the category for the standard Plots menu entries." for label,entry in entries: if entry.plotgroup.category=='Basic': plots_menu.add_command(label=label,command=entry.__call__) categories.remove('Basic') plots_menu.add_separator() # Add the other categories to the menu as cascades, and the plots of each category to # their cascades. for category in categories: category_menu = ControllableMenu(plots_menu,tearoff=0) plots_menu.add_cascade(label=category,menu=category_menu) # could probably search more efficiently than this for label,entry in sorted(entries): if entry.plotgroup.category==category: category_menu.add_command(label=label,command=entry.__call__) plots_menu.add_separator() plots_menu.add_command(label="Help",command=(lambda x=plotting_help_locations: self.open_location(x))) def __help_menu(self): """Add the help menu options.""" help_menu = ControllableMenu(self.menubar,tearoff=0,name='help') self.menubar.add_cascade(label='Help',menu=help_menu) help_menu.add_command(label='About',command=self.new_about_window) help_menu.add_command(label="User Manual", command=(lambda x=user_manual_locations: self.open_location(x))) help_menu.add_command(label="Tutorials", command=(lambda x=tutorials_locations: self.open_location(x))) help_menu.add_command(label="Examples", command=self.run_example_script) help_menu.add_command(label="Reference Manual", command=(lambda x=reference_manual_locations: self.open_location(x))) help_menu.add_command(label="Topographica.org", command=(lambda x=topo_www_locations: self.open_location(x))) help_menu.add_command(label="Python documentation", command=(lambda x=python_doc_locations: self.open_location(x))) def quit_topographica(self,check=True,exit_status=0): """Quit topographica.""" if not check or (check and tk.askyesno("Quit Topographica","Really quit?")): self.destroy() # matplotlib's tk backend starts its own Tk instances; we # need to close these ourselves (at least to avoid error # message about 'unusual termination' in Windows). try: # not that there should be an error, but just in case... import matplotlib._pylab_helpers for figman in matplotlib._pylab_helpers.Gcf.get_all_fig_managers(): figman.destroy() except: pass print "Quit selected; exiting" # Workaround for obscure problem on some UNIX systems # as of 4/2007, probably including Fedora Core 5. # On these systems, if Topographica is started from a # bash prompt and then quit from the Tkinter GUI (as # opposed to using Ctrl-D in the terminal), the # terminal would suppress echoing of all future user # input. stty sane restores the terminal to sanity, # but it is not clear why this is necessary. # For more info: # http://groups.google.com/group/comp.lang.python/browse_thread/thread/68d0f33c8eb2e02d if topo.tkgui.system_platform=="linux" and os.getenv('EMACS')!='t': try: os.system("stty sane") except: pass # CEBALERT: re. above. Shouldn't we be able to store the # output of "stty --save" before starting the gui, then # ensure that when the gui exits (however badly it # happens) run "stty saved_settings"? # CEBALERT: there was no call to self.master.destroy() sys.exit(exit_status) def run_script(self): """ Dialog to run a user-selected script The script is exec'd in __main__.__dict__ (i.e. as if it were specified on the commandline.) """ script = askopenfilename(initialdir=normalize_path(),filetypes=SCRIPT_FILETYPES) if script in ('',(),None): # (representing the various ways no script was selected in the dialog) self.messageBar.response('Run canceled') else: execfile(script,__main__.__dict__) self.messageBar.response('Ran ' + script) sim_name_from_filename(script) self.title(topo.sim.name) # CEBALERT: duplicates most of run_script() def run_example_script(self): script = askopenfilename(initialdir=topo.misc.genexamples.find_examples(), filetypes=SCRIPT_FILETYPES) if script in ('',(),None): # (representing the various ways no script was selected in the dialog) self.messageBar.response('No example opened') else: execfile(script,__main__.__dict__) self.messageBar.response('Ran ' + script) sim_name_from_filename(script) self.title(topo.sim.name) def save_script_repr(self): script_name = asksaveasfilename(filetypes=SCRIPT_FILETYPES, initialdir=normalize_path(), initialfile=topo.sim.basename()+"_script_repr.ty") if script_name: topo.command.save_script_repr(script_name) self.messageBar.response('Script saved to ' + script_name) def load_snapshot(self): """ Dialog to load a user-selected snapshot (see topo.command.load_snapshot() ). """ snapshot_name = askopenfilename(initialdir=normalize_path(),filetypes=SAVED_FILETYPES) if snapshot_name in ('',(),None): self.messageBar.response('No snapshot loaded.') else: self.messageBar.dynamicinfo('Loading snapshot (may take some time)...') self.update_idletasks() topo.command.load_snapshot(snapshot_name) self.messageBar.response('Loaded snapshot ' + snapshot_name) self.title(topo.sim.name) self.auto_refresh() def save_snapshot(self): """ Dialog to save a snapshot (see topo.command.save_snapshot() ). Adds the file extension .typ if not already present. """ snapshot_name = asksaveasfilename(filetypes=SAVED_FILETYPES, initialdir=normalize_path(), initialfile=topo.sim.basename()+".typ") if snapshot_name in ('',(),None): self.messageBar.response('No snapshot saved.') else: if not snapshot_name.endswith('.typ'): snapshot_name = snapshot_name + SAVED_FILE_EXTENSION self.messageBar.dynamicinfo('Saving snapshot (may take some time)...') self.update_idletasks() topo.command.save_snapshot(snapshot_name) self.messageBar.response('Snapshot saved to ' + snapshot_name) def auto_refresh(self, update=True): """ Refresh all windows in auto_refresh_panels. Panels can add and remove themselves to the list; those in the list will have their refresh() method called whenever this console's autorefresh() is called. """ for win in self.auto_refresh_panels: win.refresh(update) self.set_step_button_state() self.update_idletasks() ### CEBERRORALERT: why doesn't updatecommand("display=True") for an ### orientation preference map measurement work with the ### hierarchical example? I guess this is the reason I thought the ### updating never worked properly (or I really did break it ### recently - or I'm confused)... def refresh_activity_windows(self): """ Update any windows with a plotgroup_key ending in 'Activity'. Used primarily for debugging long scripts that present a lot of activity patterns. """ for win in self.auto_refresh_panels: if re.match('.*Activity$',win.plotgroup.name): win.refresh() self.update_idletasks() def open_model_editor(self): """Start the Model editor.""" return ModelEditor(self) def new_about_window(self): win = tk.AppWindow(self) win.withdraw() win.title("About Topographica") text = Label(win,text=topo.about(display=False),justify=LEFT) text.pack(side=LEFT) win.deiconify() #self.messageBar.message('state', 'OK') def open_location(self, locations): """ Try to open one of the specified locations in a new window of the default browser. See webbrowser module for more information. locations should be a tuple. """ # CB: could have been a list. This is only here because if locations is set # to a string, it will loop over the characters of the string. assert isinstance(locations,tuple),"locations must be a tuple." for location in locations: try: existing_location = resolve_path(location) webbrowser.open(existing_location,new=2,autoraise=True) self.messageBar.response('Opened local file '+existing_location+' in browser.') return ### except: pass for location in locations: if location.startswith('http'): try: webbrowser.open(location,new=2,autoraise=True) self.messageBar.response('Opened remote location '+location+' in browser.') return ### except: pass self.messageBar.response("Could not open any of %s in a browser."%locations) # CEBALERT: need to take care of removing old messages automatically? # (Otherwise callers might always have to pass 'ok'.) def status_message(self,m): self.messageBar.response(m) def run_simulation(self,event=None): # event=None allows use as callback """ Run the simulation for the duration specified in the 'run for' taggedslider. """ fduration = self.run_for_var.get() self.open_progress_window(timer=topo.sim.timer) topo.sim.run_and_time(fduration) self.auto_refresh() # CEBERRORALERT: Step button does strange things at time==0. # E.g. for lissom_oo_or, nothing appears to happen. For # hierarchical, runs to time==10. def run_step(self): if not topo.sim.events: # JP: step button should be disabled if there are no events, # but just in case... return # JPALERT: This should really use .run_and_time() but it doesn't support # run(until=...) topo.sim.run(until=topo.sim.events[0].time) self.auto_refresh() def set_step_button_state(self): if topo.sim.events: self.step_button.config(state=NORMAL) else: self.step_button.config(state=DISABLED) def __get_status_bar(self,i=2): # Hack to find appropriate status bar: Go back through frames # until a widget with a status bar is found, and return it. try: while True: f = sys._getframe(i) if hasattr(f,'f_locals'): if 'self' in f.f_locals: o = f.f_locals['self'] # (temporary hack til ScrolledFrame cleaned up) if o.__class__.__name__!='ScrolledFrame': if hasattr(o,'messageBar'): return o.messageBar elif hasattr(o,'status'): return o.status i+=1 except: pass #print "GUI INTERNAL WARNING: failed to determine window on which to display message." return self.messageBar def open_progress_window(self,timer,title=None): """ Provide a convenient link to progress bars. """ stat = self.__get_status_bar() return stat.open_progress_window(timer=timer,sim=topo.sim)
class Automation(Frame): """The Automation class is a GUI that provides radio automation.""" _state = None _button_text = None _button = None _meter = None _cart_queue = None _list_time = None _list_track = None _list_artist = None def __init__(self): """Construct an Automation window.""" Frame.__init__(self) # initialize title title = Label(self.master, font=FONT_TITLE, text=TEXT_TITLE) title.grid(row=0, column=0, columnspan=3) # initialize button and state self._state = STATE_STOPPED self._button_text = StringVar() self._button = Button(self.master, textvariable=self._button_text, command=self._update_state, width=16, height=2) self._button.config(bd=2) self._button.grid(row=0, column=3) # initialize the meter self._meter = Meter(self.master, METER_WIDTH, self._get_meter_data) self._meter.grid(row=1, column=0, columnspan=4) # initialize playlist view playlist = Frame(self.master, bd=2, relief=Tkinter.SUNKEN) Label(playlist, font=FONT, anchor=Tkinter.CENTER, width=16, text=TEXT_PLAYLIST_TIME).grid(row=0, column=0) Label(playlist, font=FONT, anchor=Tkinter.CENTER, width=32, text=TEXT_PLAYLIST_TRACK).grid(row=0, column=1) Label(playlist, font=FONT, anchor=Tkinter.CENTER, width=32, text=TEXT_PLAYLIST_ARTIST).grid(row=0, column=2) inner_playlist = Frame(playlist) scroll = Scrollbar(inner_playlist, orient=Tkinter.VERTICAL, command=self._scroll_playlist) self._list_time = Listbox(inner_playlist, selectmode=Tkinter.SINGLE, yscrollcommand=scroll.set, exportselection=0, width=16, height=20) self._list_track = Listbox(inner_playlist, selectmode=Tkinter.SINGLE, yscrollcommand=scroll.set, exportselection=0, width=32, height=20) self._list_artist = Listbox(inner_playlist, selectmode=Tkinter.SINGLE, yscrollcommand=scroll.set, exportselection=0, width=32, height=20) scroll.pack(side=Tkinter.RIGHT, fill=Tkinter.Y) self._list_time.pack(side=Tkinter.LEFT, fill=Tkinter.X, expand=True, padx=2, pady=2) self._list_track.pack(side=Tkinter.LEFT, fill=Tkinter.X, expand=True, padx=2, pady=2) self._list_artist.pack(side=Tkinter.LEFT, fill=Tkinter.X, expand=True, padx=2, pady=2) inner_playlist.grid(row=1, column=0, columnspan=3) playlist.grid(row=4, column=0, columnspan=4) # initialize cart queue self._cart_queue = CartQueue(self._cart_start, self._cart_stop) self._cart_queue.add_tracks() self._update_ui() # begin the event loop self.master.protocol("WM_DELETE_WINDOW", self.master.destroy) self.master.title(TEXT_TITLE) self.master.mainloop() def _scroll_playlist(self, *args): """Scroll the playlist view. :param args """ self._list_time.yview(*args) self._list_track.yview(*args) self._list_artist.yview(*args) def _update_state(self): """Move Automation to the next state. The state machine is as follows: STATE_STOPPED -> STATE_PLAYING -> STATE_STOPPING -> STATE_STOPPED """ if self._state is STATE_STOPPED: print "Starting Automation..." self._cart_queue.start() self._state = STATE_PLAYING elif self._state is STATE_PLAYING: print "Stopping Automation after this track..." self._cart_queue.stop_soft() self._state = STATE_STOPPING elif self._state is STATE_STOPPING: print "Stopping Automation immediately." self._cart_queue.transition() self._state = STATE_STOPPED self._update_ui() def _cart_start(self): """Start the meter when a cart starts.""" self._meter.start() self._update_ui() def _cart_stop(self): """Reset the meter when a cart stops. Also, if a soft stop occured, update the button state. """ self._meter.reset() if self._state is STATE_STOPPING: self._state = STATE_STOPPED self._update_ui() def _update_ui(self): """Update the button and playlist.""" self._button_text.set(TEXT_BUTTON[self._state]) self._button.config(bg=COLOR_BUTTON[self._state], highlightbackground=COLOR_BUTTON[self._state]) self._list_time.delete(0, Tkinter.END) self._list_track.delete(0, Tkinter.END) self._list_artist.delete(0, Tkinter.END) for cart in self._cart_queue.get_queue(): self._list_time.insert(Tkinter.END, cart.start_time.strftime("%I:%M:%S %p")) self._list_track.insert(Tkinter.END, cart.title) self._list_artist.insert(Tkinter.END, cart.issuer) def _get_meter_data(self): """Get meter data for the first track in the queue.""" queue = self._cart_queue.get_queue() if len(queue) > 0: return queue[0].get_meter_data() else: return None
class LintGui(object): """Build and control a window to interact with pylint""" def __init__(self, root=None): """init""" self.root = root or Tk() self.root.title('Pylint') #reporter self.reporter = None #message queue for output from reporter self.msg_queue = Queue.Queue() self.msgs = [] self.visible_msgs = [] self.filenames = [] self.rating = StringVar() self.tabs = {} self.report_stream = BasicStream(self) #gui objects self.lb_messages = None self.showhistory = None self.results = None self.btnRun = None self.information_box = None self.convention_box = None self.refactor_box = None self.warning_box = None self.error_box = None self.fatal_box = None self.txtModule = None self.status = None self.msg_type_dict = None self.init_gui() def init_gui(self): """init helper""" #setting up frames top_frame = Frame(self.root) mid_frame = Frame(self.root) radio_frame = Frame(self.root) res_frame = Frame(self.root) msg_frame = Frame(self.root) check_frame = Frame(self.root) history_frame = Frame(self.root) btn_frame = Frame(self.root) rating_frame = Frame(self.root) top_frame.pack(side=TOP, fill=X) mid_frame.pack(side=TOP, fill=X) history_frame.pack(side=TOP, fill=BOTH, expand=True) radio_frame.pack(side=TOP, fill=BOTH, expand=True) rating_frame.pack(side=TOP, fill=BOTH, expand=True) res_frame.pack(side=TOP, fill=BOTH, expand=True) check_frame.pack(side=TOP, fill=BOTH, expand=True) msg_frame.pack(side=TOP, fill=BOTH, expand=True) btn_frame.pack(side=TOP, fill=X) # Binding F5 application-wide to run lint self.root.bind('<F5>', self.run_lint) #Message ListBox rightscrollbar = Scrollbar(msg_frame) rightscrollbar.pack(side=RIGHT, fill=Y) bottomscrollbar = Scrollbar(msg_frame, orient=HORIZONTAL) bottomscrollbar.pack(side=BOTTOM, fill=X) self.lb_messages = Listbox(msg_frame, yscrollcommand=rightscrollbar.set, xscrollcommand=bottomscrollbar.set, bg="white") self.lb_messages.bind("<Double-Button-1>", self.show_sourcefile) self.lb_messages.pack(expand=True, fill=BOTH) rightscrollbar.config(command=self.lb_messages.yview) bottomscrollbar.config(command=self.lb_messages.xview) #History ListBoxes rightscrollbar2 = Scrollbar(history_frame) rightscrollbar2.pack(side=RIGHT, fill=Y) bottomscrollbar2 = Scrollbar(history_frame, orient=HORIZONTAL) bottomscrollbar2.pack(side=BOTTOM, fill=X) self.showhistory = Listbox(history_frame, yscrollcommand=rightscrollbar2.set, xscrollcommand=bottomscrollbar2.set, bg="white") self.showhistory.pack(expand=True, fill=BOTH) rightscrollbar2.config(command=self.showhistory.yview) bottomscrollbar2.config(command=self.showhistory.xview) self.showhistory.bind('<Double-Button-1>', self.select_recent_file) self.set_history_window() #status bar self.status = Label(self.root, text="", bd=1, relief=SUNKEN, anchor=W) self.status.pack(side=BOTTOM, fill=X) #labelbl_ratingls lbl_rating_label = Label(rating_frame, text='Rating:') lbl_rating_label.pack(side=LEFT) lbl_rating = Label(rating_frame, textvariable=self.rating) lbl_rating.pack(side=LEFT) Label(mid_frame, text='Recently Used:').pack(side=LEFT) Label(top_frame, text='Module or package').pack(side=LEFT) #file textbox self.txt_module = Entry(top_frame, background='white') self.txt_module.bind('<Return>', self.run_lint) self.txt_module.pack(side=LEFT, expand=True, fill=X) #results box rightscrollbar = Scrollbar(res_frame) rightscrollbar.pack(side=RIGHT, fill=Y) bottomscrollbar = Scrollbar(res_frame, orient=HORIZONTAL) bottomscrollbar.pack(side=BOTTOM, fill=X) self.results = Listbox(res_frame, yscrollcommand=rightscrollbar.set, xscrollcommand=bottomscrollbar.set, bg="white", font="Courier") self.results.pack(expand=True, fill=BOTH, side=BOTTOM) rightscrollbar.config(command=self.results.yview) bottomscrollbar.config(command=self.results.xview) #buttons Button(top_frame, text='Open', command=self.file_open).pack(side=LEFT) Button(top_frame, text='Open Package', command=(lambda: self.file_open(package=True))).pack(side=LEFT) self.btnRun = Button(top_frame, text='Run', command=self.run_lint) self.btnRun.pack(side=LEFT) Button(btn_frame, text='Quit', command=self.quit).pack(side=BOTTOM) #radio buttons self.information_box = IntVar() self.convention_box = IntVar() self.refactor_box = IntVar() self.warning_box = IntVar() self.error_box = IntVar() self.fatal_box = IntVar() i = Checkbutton(check_frame, text="Information", fg=COLORS['(I)'], variable=self.information_box, command=self.refresh_msg_window) c = Checkbutton(check_frame, text="Convention", fg=COLORS['(C)'], variable=self.convention_box, command=self.refresh_msg_window) r = Checkbutton(check_frame, text="Refactor", fg=COLORS['(R)'], variable=self.refactor_box, command=self.refresh_msg_window) w = Checkbutton(check_frame, text="Warning", fg=COLORS['(W)'], variable=self.warning_box, command=self.refresh_msg_window) e = Checkbutton(check_frame, text="Error", fg=COLORS['(E)'], variable=self.error_box, command=self.refresh_msg_window) f = Checkbutton(check_frame, text="Fatal", fg=COLORS['(F)'], variable=self.fatal_box, command=self.refresh_msg_window) i.select() c.select() r.select() w.select() e.select() f.select() i.pack(side=LEFT) c.pack(side=LEFT) r.pack(side=LEFT) w.pack(side=LEFT) e.pack(side=LEFT) f.pack(side=LEFT) #check boxes self.box = StringVar() # XXX should be generated report = Radiobutton(radio_frame, text="Report", variable=self.box, value="Report", command=self.refresh_results_window) raw_met = Radiobutton(radio_frame, text="Raw metrics", variable=self.box, value="Raw metrics", command=self.refresh_results_window) dup = Radiobutton(radio_frame, text="Duplication", variable=self.box, value="Duplication", command=self.refresh_results_window) ext = Radiobutton(radio_frame, text="External dependencies", variable=self.box, value="External dependencies", command=self.refresh_results_window) stat = Radiobutton(radio_frame, text="Statistics by type", variable=self.box, value="Statistics by type", command=self.refresh_results_window) msg_cat = Radiobutton(radio_frame, text="Messages by category", variable=self.box, value="Messages by category", command=self.refresh_results_window) msg = Radiobutton(radio_frame, text="Messages", variable=self.box, value="Messages", command=self.refresh_results_window) source_file = Radiobutton(radio_frame, text="Source File", variable=self.box, value="Source File", command=self.refresh_results_window) report.select() report.grid(column=0, row=0, sticky=W) raw_met.grid(column=1, row=0, sticky=W) dup.grid(column=2, row=0, sticky=W) msg.grid(column=3, row=0, sticky=W) stat.grid(column=0, row=1, sticky=W) msg_cat.grid(column=1, row=1, sticky=W) ext.grid(column=2, row=1, sticky=W) source_file.grid(column=3, row=1, sticky=W) #dictionary for check boxes and associated error term self.msg_type_dict = { 'I': lambda: self.information_box.get() == 1, 'C': lambda: self.convention_box.get() == 1, 'R': lambda: self.refactor_box.get() == 1, 'E': lambda: self.error_box.get() == 1, 'W': lambda: self.warning_box.get() == 1, 'F': lambda: self.fatal_box.get() == 1 } self.txt_module.focus_set() def select_recent_file(self, event): """adds the selected file in the history listbox to the Module box""" if not self.showhistory.size(): return selected = self.showhistory.curselection() item = self.showhistory.get(selected) #update module self.txt_module.delete(0, END) self.txt_module.insert(0, item) def refresh_msg_window(self): """refresh the message window with current output""" #clear the window self.lb_messages.delete(0, END) self.visible_msgs = [] for msg in self.msgs: if self.msg_type_dict.get(msg.C)(): self.visible_msgs.append(msg) msg_str = convert_to_string(msg) self.lb_messages.insert(END, msg_str) fg_color = COLORS.get(msg_str[:3], 'black') self.lb_messages.itemconfigure(END, fg=fg_color) def refresh_results_window(self): """refresh the results window with current output""" #clear the window self.results.delete(0, END) try: for res in self.tabs[self.box.get()]: self.results.insert(END, res) except: pass def process_incoming(self): """process the incoming messages from running pylint""" while self.msg_queue.qsize(): try: msg = self.msg_queue.get(0) if msg == "DONE": self.report_stream.output_contents() return False #adding message to list of msgs self.msgs.append(msg) #displaying msg if message type is selected in check box if self.msg_type_dict.get(msg.C)(): self.visible_msgs.append(msg) msg_str = convert_to_string(msg) self.lb_messages.insert(END, msg_str) fg_color = COLORS.get(msg_str[:3], 'black') self.lb_messages.itemconfigure(END, fg=fg_color) except Queue.Empty: pass return True def periodic_call(self): """determine when to unlock the run button""" if self.process_incoming(): self.root.after(100, self.periodic_call) else: #enabling button so it can be run again self.btnRun.config(state=NORMAL) def mainloop(self): """launch the mainloop of the application""" self.root.mainloop() def quit(self, _=None): """quit the application""" self.root.quit() def halt(self): """program halt placeholder""" return def file_open(self, package=False, _=None): """launch a file browser""" if not package: filename = askopenfilename(parent=self.root, filetypes=[('pythonfiles', '*.py'), ('allfiles', '*')], title='Select Module') else: filename = askdirectory(title="Select A Folder", mustexist=1) if filename == (): return self.txt_module.delete(0, END) self.txt_module.insert(0, filename) def update_filenames(self): """update the list of recent filenames""" filename = self.txt_module.get() if not filename: filename = os.getcwd() if filename + '\n' in self.filenames: index = self.filenames.index(filename + '\n') self.filenames.pop(index) #ensure only 10 most recent are stored if len(self.filenames) == 10: self.filenames.pop() self.filenames.insert(0, filename + '\n') def set_history_window(self): """update the history window with info from the history file""" #clear the window self.showhistory.delete(0, END) # keep the last 10 most recent files try: view_history = open(HOME + HISTORY, 'r') for hist in view_history.readlines(): if not hist in self.filenames: self.filenames.append(hist) self.showhistory.insert(END, hist.split('\n')[0]) view_history.close() except IOError: # do nothing since history file will be created later return def run_lint(self, _=None): """launches pylint""" self.update_filenames() self.root.configure(cursor='watch') self.reporter = GUIReporter(self, output=self.report_stream) module = self.txt_module.get() if not module: module = os.getcwd() #cleaning up msgs and windows self.msgs = [] self.visible_msgs = [] self.lb_messages.delete(0, END) self.tabs = {} self.results.delete(0, END) self.btnRun.config(state=DISABLED) #setting up a worker thread to run pylint worker = Thread(target=lint_thread, args=( module, self.reporter, self, )) self.periodic_call() worker.start() # Overwrite the .pylint-gui-history file with all the new recently added files # in order from filenames but only save last 10 files write_history = open(HOME + HISTORY, 'w') write_history.writelines(self.filenames) write_history.close() self.set_history_window() self.root.configure(cursor='') def show_sourcefile(self, event=None): selected = self.lb_messages.curselection() if not selected: return msg = self.visible_msgs[int(selected[0])] scroll = msg.line - 3 if scroll < 0: scroll = 0 self.tabs["Source File"] = open(msg.path, "r").readlines() self.box.set("Source File") self.refresh_results_window() self.results.yview(scroll) self.results.select_set(msg.line - 1)
class OfflineVisualiser(Visualiser): """A VTK-powered offline visualiser which runs in its own thread. In addition to the functions provided by the standard visualiser, the following additional functions are provided: precache_height_quantities() - Precache all the vtkpoints structures for any dynamic height based quantities to render. """ def __init__(self, source, frameDelay=100, frameStep=1): """The source parameter is assumed to be a NetCDF sww file. The frameDelay parameter is the number of milliseconds waited between frames. """ Visualiser.__init__(self, source) self.frameNumber = 0 fin = NetCDFFile(self.source, 'r') self.maxFrameNumber = fin.variables['time'].shape[0] - 1 fin.close() #self.frameNumberTkVariable = StringVar() #self.frameNumberTkVariable.set('Frame - %05g'%self.framNumber) self.frameDelay = frameDelay self.xmin = None self.xmax = None self.ymin = None self.ymax = None self.zmin = None self.zmax = None self.frameStep = frameStep self.vtk_heightQuantityCache = [] for i in range(self.maxFrameNumber + 1): # maxFrameNumber is zero indexed. self.vtk_heightQuantityCache.append({}) self.paused = False self.movie = False def setup_grid(self): fin = NetCDFFile(self.source, 'r') self.vtk_cells = vtkCellArray() N_tri = fin.variables['volumes'].shape[0] for v in range(N_tri): self.vtk_cells.InsertNextCell(3) for i in range(3): self.vtk_cells.InsertCellPoint(fin.variables['volumes'][v][i]) fin.close() def update_height_quantity(self, quantityName, dynamic=True): polydata = self.vtk_polyData[quantityName] = vtkPolyData() if dynamic is True: #print ' - Frame',self.frameNumber,'of',self.maxFrameNumber if not self.vtk_heightQuantityCache[self.frameNumber].has_key( quantityName): self.vtk_heightQuantityCache[self.frameNumber][quantityName]\ = self.read_height_quantity(quantityName, True, self.frameNumber) polydata.SetPoints( self.vtk_heightQuantityCache[self.frameNumber][quantityName]) else: polydata.SetPoints(self.read_height_quantity(quantityName, False)) polydata.SetPolys(self.vtk_cells) def get_3d_bounds(self): return [ self.xmin, self.xmax, self.ymin, self.ymax, self.zmin, self.zmax ] def read_height_quantity(self, quantityName, dynamic=True, frameNumber=0): """Read in a height based quantity from the NetCDF source file and return a vtkPoints object. frameNumber is ignored if dynamic is false.""" fin = NetCDFFile(self.source, 'r') points = vtkPoints() if dynamic is True: N_vert = fin.variables[quantityName].shape[1] else: N_vert = len(fin.variables[quantityName]) x = num.ravel(num.array(fin.variables['x'], num.float)) y = num.ravel(num.array(fin.variables['y'], num.float)) if dynamic is True: q = num.array(fin.variables[quantityName][frameNumber], num.float) else: q = num.ravel(num.array(fin.variables[quantityName], num.float)) q *= self.height_zScales[quantityName] q += self.height_offset[quantityName] for v in range(N_vert): points.InsertNextPoint(x[v], y[v], q[v]) if self.xmin is None or self.xmin > x[v]: self.xmin = x[v] if self.xmax is None or self.xmax < x[v]: self.xmax = x[v] if self.ymin is None or self.ymin > y[v]: self.ymin = y[v] if self.ymax is None or self.ymax < y[v]: self.ymax = y[v] if self.zmin is None or self.zmin > q[v]: self.zmin = q[v] if self.zmax is None or self.zmax < q[v]: self.zmax = q[v] fin.close() return points def precache_height_quantities(self): """Precache any height-based quantities. Call before rendering beigns.""" for q in self.height_quantities: if self.height_dynamic[q] is True: print 'Precaching %s' % q for i in range(self.maxFrameNumber + 1): # maxFrameNumber is zero-indexed print ' - Frame %d of %d' % (i, self.maxFrameNumber) self.vtk_heightQuantityCache[i][q]\ = self.read_height_quantity(q, True, i) def build_quantity_dict(self): quantities = {} fin = NetCDFFile(self.source, 'r') for q in filter( lambda n: n != 'x' and n != 'y' and n != 'z' and n != 'time' and n != 'volumes', fin.variables.keys()): if len(fin.variables[q].shape) == 1: # Not a time-varying quantity quantities[q] = num.ravel( num.array(fin.variables[q], num.float)) else: # Time-varying, get the current timestep data quantities[q] = num.array(fin.variables[q][self.frameNumber], num.float) fin.close() return quantities def setup_gui(self): Visualiser.setup_gui(self) self.tk_quit.grid(row=0, column=0, sticky=W + E) self.tk_movie_toggle = Button(self.tk_controlFrame, text="Movie off", command=self.movie_toggle) self.tk_movie_toggle.grid(row=0, column=6, sticky=W + E) self.tk_restart = Button(self.tk_controlFrame, text="<<<", command=self.restart, width=5) self.tk_restart.grid(row=1, column=0, sticky=W + E) self.tk_back10 = Button(self.tk_controlFrame, text="<<", command=self.back10, width=5) self.tk_back10.grid(row=1, column=1, sticky=W + E) self.tk_back = Button(self.tk_controlFrame, text="<", command=self.back, width=5) self.tk_back.grid(row=1, column=2, sticky=W + E) self.tk_pauseResume = Button(self.tk_controlFrame, text="Pause", command=self.pauseResume, width=15) self.tk_pauseResume.grid(row=1, column=3, sticky=W + E) self.tk_forward = Button(self.tk_controlFrame, text=">", command=self.forward, width=5) self.tk_forward.grid(row=1, column=4, sticky=W + E) self.tk_forward10 = Button(self.tk_controlFrame, text=">>", command=self.forward10, width=5) self.tk_forward10.grid(row=1, column=5, sticky=W + E) self.tk_forwardEnd = Button(self.tk_controlFrame, text=">>>", command=self.forwardEnd, width=5) self.tk_forwardEnd.grid(row=1, column=6, sticky=W + E) self.tk_frameNumber = Label(self.tk_controlFrame, text='Frame') self.tk_frameNumber.grid(row=2, column=0, sticky=W + E) self.tk_gotoFrame = Scale(self.tk_controlFrame, from_=0, to=self.maxFrameNumber, orient=HORIZONTAL) self.tk_gotoFrame.grid(row=2, column=1, columnspan=2, sticky=W + E) self.tk_stepLabel = Label(self.tk_controlFrame, text='Step') self.tk_stepLabel.grid(row=2, column=4, sticky=W + E) self.tk_frameStep = Scale(self.tk_controlFrame, from_=0, to=self.maxFrameNumber, orient=HORIZONTAL) self.tk_frameStep.grid(row=2, column=5, columnspan=2, sticky=W + E) # Make the buttons stretch to fill all available space for i in range(7): self.tk_controlFrame.grid_columnconfigure(i, weight=1) def run(self): self.alter_tkroot(Tk.after, (self.frameDelay, self.animateForward)) Visualiser.run(self) def restart(self): self.frameNumber = 0 self.redraw_quantities() self.update_labels() self.pause() if self.movie: self.save_image() def forwardEnd(self): self.frameNumber = self.maxFrameNumber self.redraw_quantities() self.update_labels() self.pause() def movie_toggle(self): if self.movie == True: self.movie = False self.tk_movie_toggle.config(text='Movie off') else: self.movie = True self.tk_movie_toggle.config(text='Movie on ') def save_image(self): from vtk import vtkJPEGWriter, vtkJPEGWriter, vtkPNGWriter from vtk import vtkPNMWriter, vtkWindowToImageFilter from os import path sourcebase, _ = path.splitext(self.source) fname = sourcebase + '%05g.png' % self.frameNumber #print fname extmap = { '.jpg': vtkJPEGWriter, '.jpeg': vtkJPEGWriter, '.png': vtkPNGWriter, '.pnm': vtkPNMWriter, } basename, ext = path.splitext(fname) try: Writer = extmap[ext.lower()] except KeyError: error_msg("Don't know how to handle %s files" % ext, parent=self) return renWin = self.vtk_renderer.GetRenderWindow() w2i = vtkWindowToImageFilter() writer = Writer() w2i.SetInput(renWin) w2i.Update() writer.SetInput(w2i.GetOutput()) writer.SetFileName(fname) renWin.Render() writer.Write() def back10(self): if self.frameNumber - 10 >= 0: self.frameNumber -= 10 else: self.frameNumber = 0 self.redraw_quantities() self.update_labels() self.pause() def back(self): if self.frameNumber > 0: self.frameNumber -= 1 self.redraw_quantities() self.update_labels() self.pause() def pauseResume(self): if self.paused is True: self.resume() else: self.pause() def pause(self): self.paused = True self.tk_pauseResume.config(text="Resume") def resume(self): self.paused = False self.tk_pauseResume.config(text="Pause") self.frameNumber = self.tk_gotoFrame.get() self.frameStep = self.tk_frameStep.get() self.tk_root.after(self.frameDelay, self.animateForward) def forward(self): if self.frameNumber < self.maxFrameNumber: self.frameNumber += 1 self.redraw_quantities() self.update_labels() self.pause() def forward_step(self): if self.frameNumber + self.frameStep <= self.maxFrameNumber: self.frameNumber += self.frameStep self.redraw_quantities() self.update_labels() else: self.frameNumber = self.maxFrameNumber self.redraw_quantities() self.update_labels() self.pause() if self.movie: self.save_image() def forward10(self): if self.frameNumber + 10 <= self.maxFrameNumber: self.frameNumber += 10 else: self.frameNumber = self.maxFrameNumber self.redraw_quantities() self.update_labels() self.pause() def animateForward(self): if self.paused is not True: self.forward_step() self.tk_root.after(self.frameDelay, self.animateForward) def update_labels(self): #self.tk_frameNumber.config(text='%05g of %05g'%(self.frameNumber,self.maxFrameNumber)) self.tk_gotoFrame.set(self.frameNumber) self.tk_frameStep.set(self.frameStep) def shutdown(self): #self.pause() self.tk_root.withdraw() self.tk_root.destroy()
class App(object): def __init__(self, master): frame = Frame(master) frame.pack(fill=BOTH, expand=True) url_lab = Label(frame, text='URL:', fg='green', font=('Courier New', 16)) url_lab.grid(row=0, column=0, sticky=N + E) self.url_text = Text(frame, width=60, height=3, font=('Courier New', 12)) self.url_text.grid(row=0, column=1) f5_lab = Label(frame, text='F5 Big-Ip:', fg='blue', font=('Courier New', 14)) f5_lab.grid(row=1, column=0, sticky=N) self.f5bigip = StringVar() self.f5bigipEntry = Entry(frame, textvariable=self.f5bigip) self.f5bigipEntry.config(font=('Courier New', 12)) self.f5bigipEntry.config(width=60) self.f5bigipEntry.grid(row=1, column=1) self.testbtn = Button(frame, text='检测', font=('Courier New', 12)) self.testbtn.config(width=25) self.testbtn.config(bg='LightSkyBlue') self.testbtn.grid(row=2, column=1, sticky=W) self.decodebtn = Button(frame, text='解码F5 Big-Ip 值', font=('Courier New', 12)) self.decodebtn.config(width=25) self.decodebtn.config(bg='LightSkyBlue') self.decodebtn.grid(row=2, column=1, sticky=E) self.result_lab = Label(frame, text='执行结果:', fg='blue', font=('Courier New', 14)) self.result_lab.grid(row=3, column=0, sticky=N + E) scroll = Scrollbar(frame) scroll.grid(row=3, column=1, sticky=E + N + S) self.response = Text(frame, width=58, height=18, font=('Courier New', 12)) self.response.grid(row=3, column=1, sticky=W + S) self.response.config(yscrollcommand=scroll.set) scroll.config(command=self.response.yview) self.msg = StringVar() self.msg_lab = Label(frame, textvariable=self.msg, fg='blue', font=('Courier New', 12)) self.msg_lab.grid(row=4, column=0, columnspan=2, sticky=N + S + W + E) self.testbtn.bind('<Button-1>', self.check) self.decodebtn.bind('<Button-1>', self.decode_bigip2) self.url = '' self.pattern = re.compile('^(?:http|https)://(?:\w+\.)+.+') self.headers = { "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36" } def check(self, event): self.msg.set('') self.url = self.url_text.get(1.0, END).strip() chek_url = self.pattern.match(self.url) # print chek_url.group() if not chek_url: # print ('123') self.msg.set('请输入正确的(GET)URL!') else: try: self.msg.set('') self.f5bigip.set('') self.response.delete(1.0, END) response = get(self.url, headers=self.headers) headers = response.headers set_cookie = headers.get('Set-cookie', None) headers = '\n'.join( [':'.join(item) for item in response.headers.iteritems()]) # print headers if set_cookie: bigip_value = self.getBigIPvalue(set_cookie) if bigip_value: self.f5bigip.set(bigip_value) self.msg_lab.config(fg='red') host = self.decode_bigip(bigip_value) self.msg.set( 'F5 BIG-IP Cookie Remote Information Disclosure\n' '存在信息泄露漏洞!\n' '内网地址:' + host) else: self.msg_lab.config(fg='blue') self.msg.set('不存在信息泄露漏洞!') else: self.msg_lab.config(fg='blue') self.msg.set('不存在信息泄露漏洞!') self.response.delete(1.0, END) self.response.insert(END, headers + '\n\n' + response.text) except: self.msg_lab.config(fg='red') self.msg.set('网络资源请求失败,请确保已经接入互联网和网址的有效性!') def getBigIPvalue(self, set_cookie): if set_cookie: lst = set_cookie.split(';') lst = [item.split('=') for item in lst] # print lst for key, value in lst: if re.search('BIGipServer.*?', key): return value return '' def decode_bigip(self, bigip_value): if bigip_value: if re.match('\d+\.\d+\.\d+', bigip_value): host, port, end = bigip_value.split('.') host = [ord(i) for i in struct.pack("<I", int(host))] port = [ord(e) for e in struct.pack("<H", int(port))] host = '.'.join([str(i) for i in host]) port = '0x%02X%02X' % (port[0], port[1]) # print port port = str(int(port, 16)) return ':'.join([host, port]) else: showerror( 'Decode F5 Bigip Error', 'Bigip value is Not a valid value !\n (xxx.xxx.xx)(x代表数字) ' ) return '' return '' def decode_bigip2(self, event): bigip_value = self.f5bigip.get().strip() result = self.decode_bigip(bigip_value) if result: showinfo("Decode F5 Bigip ", "%s : %s" % (bigip_value, result)) else: showerror( 'Decode F5 Bigip Error', 'Bigip value is Not a valid value !\n (xxx.xxx.xx)(x代表数字) ')
class MapUI: def __init__(self, master): def center(win): win.update_idletasks() width = win.winfo_width() height = win.winfo_height() x = (win.winfo_screenwidth() // 4) - (width // 2) + 40 y = (win.winfo_screenheight() // 4) - (height // 2) + 40 win.geometry('{}x{}+{}+{}'.format(width, height, x, y)) def callback(event): event.widget.focus_set() print "clicked at", event.x, event.y if self.add_tasks_flg.get() == 1: # Select number of robots # Define elements of pop up window self.top = Toplevel() self.num_robots = StringVar(self.top) self.num_robots.set("1") # default value w = OptionMenu(self.top, self.num_robots, '1', '2', '3', '4').grid(row=0, column=1) text1 = Message(self.top, text="Number of robots:", width=150).grid(row=0, column=0) self.e = Entry(self.top, width=10) self.e.grid(row=1, column=1) text2 = Message(self.top, text="Task duration:", width=150).grid(row=1, column=0) text3 = Message(self.top, text="(s)", width=60).grid(row=1, column=2) newline = Message(self.top, text=" ").grid(row=2) button = Button(self.top, text='Enter', command=lambda: self.enter_task(event)).grid( row=3, column=1) button_cancel = Button(self.top, text='Cancel', command=self.cancel_task).grid(row=3, column=2) center(self.top) master.title("Map Interface") master.minsize(width=1000, height=750) master.maxsize(width=1000, height=750) master.config(bg=BKG_COLOUR) self.master = master # Canvas for overlaying map self.map_canvas = Canvas(master, width=CANVAS_W, height=CANVAS_H, bg='gray85', highlightthickness=0) self.map_canvas.pack(side='right', padx=50) self.map_canvas.bind("<Button-1>", callback) global CANVAS_PTR CANVAS_PTR = self.map_canvas self.master.update() w = self.map_canvas.winfo_width() h = self.map_canvas.winfo_height() # Overlay a grid for i in range(0, w, SQ_SIZE): if i != 0: self.map_canvas.create_line(i, 0, i, h, dash=1) for i in range(0, h, SQ_SIZE): if i != 0: self.map_canvas.create_line(0, i, w, i, dash=1) # Load in flame icon from flame.gif self.flame_icon = PhotoImage(file="flame.gif") # Load in the drone icon from drone.gif global DRONE_ICON DRONE_ICON = PhotoImage(file="drone.gif") buttons_frame = Canvas(master, width=163, height=230, bg=BUTTONS_BKG_COLOUR, highlightthickness=1, highlightbackground='dim grey') buttons_frame.place(x=40, y=200) # Define UI buttons self.add_tasks_flg = IntVar() self.add_tasks_b = Checkbutton(master, text="Add Tasks", variable=self.add_tasks_flg, highlightbackground=BUTTONS_BKG_COLOUR, background=BUTTONS_BKG_COLOUR) self.add_tasks_b.place(x=77, y=240) self.clear_wp_b = Button(master, text='Clear Tasks', command=self.clear_wp, highlightbackground=BUTTONS_BKG_COLOUR) self.clear_wp_b.config(width=10) self.clear_wp_b.place(x=65, y=270) ''' self.gen_wp_file_b = Button(master, text='Generate Waypoints File', command=self.gen_wp_file, highlightbackground=BKG_COLOUR) self.gen_wp_file_b.config(width=20) self.gen_wp_file_b.place(x=20, y=250) ''' self.land_b = Button(master, text='Land', command=self.land, highlightbackground=BUTTONS_BKG_COLOUR) self.land_b.config(width=10) self.land_b.place(x=65, y=350) # Set up coordinate system conversion and display corners of room: file_obj = open('antenna_locations.txt', 'r') anchors = [] for line in file_obj: cur_anchors = map(float, line.split()) anchors.append(cur_anchors) file_obj.close() anchors = (np.array(anchors)).T # Find largest (abs) x and y values to use a reference for conversion ratio x_vals = anchors[0] largest_x_val = x_vals[np.argmax(abs(x_vals))] y_vals = anchors[1] largest_y_val = y_vals[np.argmax(abs(y_vals))] if largest_x_val > largest_y_val: largest_y_val = largest_x_val else: largest_x_val = largest_y_val global m_per_pixel_x m_per_pixel_x = float(largest_x_val / (CANVAS_W / 2)) global m_per_pixel_y m_per_pixel_y = float(largest_y_val / (CANVAS_H / 2)) # Place antenna (anchors) on UI anchors = anchors.T for cur_anchor in anchors: x_pixel_loc = cur_anchor[0] / m_per_pixel_x + CANVAS_W / 2 y_pixel_loc = -1 * (cur_anchor[1] / m_per_pixel_y) + CANVAS_H / 2 # Draw antenna @ location global ANTENNA_LIST antenna_id = self.map_canvas.create_oval(x_pixel_loc - 15, y_pixel_loc - 15, x_pixel_loc + 15, y_pixel_loc + 15, fill='red') self.master.update() global SQ_SIZE SQ_SIZE = 20 global BKG_COLOUR BKG_COLOUR = 'gray95' global BUTTONS_BKG_COLOUR BUTTONS_BKG_COLOUR = 'grey66' global CANVAS_W CANVAS_W = 700 global CANVAS_H CANVAS_H = 700 global TASK_LIST TASK_LIST = None global m_per_pixel_x m_per_pixel_x = None global m_per_pixel_y m_per_pixel_y = None global NEW_TASK_FLAG NEW_TASK_FLAG = False global ANTENNA_LIST ANTENNA_LIST = None global DRONE_ICON DRONE_ICON = None flame_icon = None ui_wp_list = None #task_list = None add_wp_flag = False task_id = 0 add_tasks_flg = None def add_tasks(self): print "adding tasks" # function imp here self.add_wp_flag = True self.map_canvas.config(cursor='pencil') def clear_wp(self): print "clear tasks" global TASK_LIST TASK_LIST = None for element_id in self.ui_wp_list: self.map_canvas.delete(element_id[0]) self.ui_wp_list = None ''' def gen_wp_file(self): print "generate wp file" # function imp here ''' def land(self): # Send a new task with position (0,0,0) z=0 tells drone to land print("land") def enter_task(self, event): # Determine square (top left corner coords): w_start = event.x - event.x % SQ_SIZE h_start = event.y - event.y % SQ_SIZE #Translate pixel location to physical location x_pixel = event.x y_pixel = event.y # Find out how many pixels from center: x_pixel = x_pixel - CANVAS_W / 2 x_physical = x_pixel * m_per_pixel_x #vertical case, note this is flipped y_pixel = y_pixel - CANVAS_W / 2 y_pixel = -1 * y_pixel y_physical = y_pixel * m_per_pixel_y try: # Add to task list global TASK_LIST if TASK_LIST == None: TASK_LIST = [[ self.task_id, int(self.num_robots.get()), float(self.e.get()), x_physical, y_physical ]] global NEW_TASK_FLAG NEW_TASK_FLAG = True else: TASK_LIST.append([ self.task_id, int(self.num_robots.get()), float(self.e.get()), x_physical, y_physical ]) global NEW_TASK_FLAG NEW_TASK_FLAG = True # Indicate task in UI element_id = self.map_canvas.create_image(event.x, event.y, image=self.flame_icon) if self.ui_wp_list == None: self.ui_wp_list = [[element_id]] else: self.ui_wp_list.append([element_id]) except: print("Invalid Task Entry") self.map_canvas.config(cursor='arrow') self.add_wp_flag = False print(TASK_LIST) self.task_id = self.task_id + 1 self.top.destroy() def cancel_task(self): self.top.destroy()
class You2XBMC(): """ XBMC Object""" def __init__(self): #Initialize GUI self.address=None self.video = None self.ipAddress = None self.home = expanduser("~") self.config_widgets() #Configure Window and Widgets # Test if file exists, and if it does read the ip address if not isfile(self.home+"/"+"xbmcIP.txt"): print "No File :(" self.ipAddress = False elif isfile(self.home+"/"+"xbmcIP.txt"): print "File Exists :)" self.ipAddress = open(self.home+"/"+"xbmcIP.txt", "r").read().splitlines()[0] print self.ipAddress if self.ipAddress != False: self.ipEntry.insert(0, self.ipAddress) #Pack and Mainloop self.grid_everything() self.mainloop() def set_video(self): # Create a thread that sets the video x = Thread(target=self.set_video_callback) x.start() def set_video_callback(self): # This function creates a new file if a file doesn't exist with the ip address of the xbmc # it also sends the video to the JSON server if self.ipAddress == False: self.ipAddress = self.ipEntry.get() xbmcIP = open(self.home+"/"+"xbmcIP.txt", "w") xbmcIP.write(str(self.ipAddress)) xbmcIP.close() # Send video to XBMC self.ipAddress = ("http://"+self.ipEntry.get()+"/jsonrpc") xbmc = XBMC(self.ipAddress) address = self.addressEntry.get() video = pafy.new(address) video = video.getbest() print xbmc.Player.Open(item={"file": video.url}) def get_clipboard(self): # Get a video address fom clipboard string = self.window.clipboard_get() self.addressEntry.delete(0,END) self.addressEntry.insert(0, string) self.set_video() def config_widgets(self): # Create window and widgets self.window = Tk() self.window.title("Send youtube video to XBMC") self.window.resizable(0,0) self.addressEntry = Entry() self.addressEntry.config(width=50) self.addressEntry.config(justify=CENTER) self.addressLabel = Label(text="Insert youtube video address: ") self.ipEntry = Entry() self.ipEntry.config(justify=CENTER) self.ipLabel = Label(text="Ip address of XBMC machine: ") self.sendButton = Button(self.window, text="Play on XBMC", command=self.set_video) self.sendButton.config(width=30) self.clipboardButton = Button(text="Click to get from clipboard", command=self.get_clipboard) def grid_everything(self): # Grid everything up self.addressLabel.grid(row=0, column=0,pady=5, padx=20) self.addressEntry.grid(row=0, column=1, pady=10) self.sendButton.grid(row=3, column=1, pady=5) self.clipboardButton.grid(row=0, column=2, padx=3) self.ipEntry.grid(row=2, column=1, pady=10) self.ipLabel.grid(row=2, column=0,pady=5, padx=20) def mainloop(self): mainloop()
class Window(Frame): RENDER_PROCESSES = 2 def __init__(self, width, height, scene, tracer, calculate=None): Frame.__init__(self, master=None) if calculate is None: calculate = [0, 0] self.d = calculate self.scene = scene self.after_id = 0 self.tracer = tracer self.width = width self.height = height self.__init_window(height, width) self.master.mainloop() def __init_window(self, height, width): self.master.title = "Ray Py" canvas = Canvas(self.master, width=width, height=height) canvas.pack(side=TOP) self.img = PhotoImage(width=width, height=height) canvas.create_image((width / 2, height / 2), image=self.img, state="normal") self.startButton = Button(self.master, text="Render", command=lambda: self.__onStartPressed()) self.startButton.pack(side=RIGHT) self.resetButton = Button(self.master, text="Reset", command=lambda: self.__onResetPressed()) self.resetButton.config(state="disabled") self.resetButton.pack(side=RIGHT) self.listbox = Listbox(self.master, height=5) self.listbox.bind('<<ListboxSelect>>', self.__selectTracer) self.listbox.insert(END, "Simple", "Shadow", "ShadingShadow", "Recursive", "PathTracer") self.listbox.pack(side=LEFT) self.listbox.selection_set(0) self.listbox.activate(0) self.listbox.focus_set() def __selectTracer(self, evt): value = self.listbox.get(self.listbox.curselection()) if value == "Simple": self.tracer = SimpleRayTracer() elif value == "Shadow": self.tracer = SimpleShadowRayTracer() elif value == "ShadingShadow": self.tracer = ShadingShadowRayTracer(self.scene.eye) elif value == "Recursive": self.tracer = RecursiveRayTracer(self.scene.eye) elif value == "PathTracer": self.tracer = PathTracer(self.scene.eye) def __onStartPressed(self): self.startButton.config(state="disabled") self.listbox.config(state="disabled") self.__draw() def __update(self): if self.finishedQueue.qsize() >= self.RENDER_PROCESSES: self.finishedThreads = self.RENDER_PROCESSES while not self.finishedQueue.empty(): self.finishedQueue.get() if not self.dataQueue.empty(): item = self.dataQueue.get() self.img.put(item[1], item[0]) self.master.update() elif self.finishedThreads == self.RENDER_PROCESSES: for t in self.threads: t.join() self.master.after_cancel(self.after_id) self.resetButton.config(state="active") return self.after_id = self.master.after(0, self.__update) def __draw(self): from processes import BlockProcess from multiprocessing import Queue self.finishedQueue = Queue() self.dataQueue = Queue() self.finishedThreads = 0 self.threads = BlockProcess.forCount(self.RENDER_PROCESSES, self.width, self.height, self.tracer, self.scene, self.dataQueue, self.finishedQueue) for t in self.threads: t.start() self.__update() self.after_id = self.master.after(0, self.__update) def __onResetPressed(self): self.img.blank() self.d = [0, 0] self.resetButton.config(state="disabled") self.startButton.config(state="active") self.listbox.config(state="normal")
class GetKeysDialog(Toplevel): def __init__(self,parent,title,action,currentKeySequences,_htest=False): """ action - string, the name of the virtual event these keys will be mapped to currentKeys - list, a list of all key sequence lists currently mapped to virtual events, for overlap checking _htest - bool, change box location when running htest """ Toplevel.__init__(self, parent) self.configure(borderwidth=5) self.resizable(height=FALSE,width=FALSE) self.title(title) self.transient(parent) self.grab_set() self.protocol("WM_DELETE_WINDOW", self.Cancel) self.parent = parent self.action=action self.currentKeySequences=currentKeySequences self.result='' self.keyString=StringVar(self) self.keyString.set('') self.SetModifiersForPlatform() # set self.modifiers, self.modifier_label self.modifier_vars = [] for modifier in self.modifiers: variable = StringVar(self) variable.set('') self.modifier_vars.append(variable) self.advanced = False self.CreateWidgets() self.LoadFinalKeyList() self.withdraw() #hide while setting geometry self.update_idletasks() self.geometry( "+%d+%d" % ( parent.winfo_rootx() + (parent.winfo_width()/2 - self.winfo_reqwidth()/2), parent.winfo_rooty() + ((parent.winfo_height()/2 - self.winfo_reqheight()/2) if not _htest else 150) ) ) #centre dialog over parent (or below htest box) self.deiconify() #geometry set, unhide self.wait_window() def CreateWidgets(self): frameMain = Frame(self,borderwidth=2,relief=SUNKEN) frameMain.pack(side=TOP,expand=TRUE,fill=BOTH) frameButtons=Frame(self) frameButtons.pack(side=BOTTOM,fill=X) self.buttonOK = Button(frameButtons,text='OK', width=8,command=self.OK) self.buttonOK.grid(row=0,column=0,padx=5,pady=5) self.buttonCancel = Button(frameButtons,text='Cancel', width=8,command=self.Cancel) self.buttonCancel.grid(row=0,column=1,padx=5,pady=5) self.frameKeySeqBasic = Frame(frameMain) self.frameKeySeqAdvanced = Frame(frameMain) self.frameControlsBasic = Frame(frameMain) self.frameHelpAdvanced = Frame(frameMain) self.frameKeySeqAdvanced.grid(row=0,column=0,sticky=NSEW,padx=5,pady=5) self.frameKeySeqBasic.grid(row=0,column=0,sticky=NSEW,padx=5,pady=5) self.frameKeySeqBasic.lift() self.frameHelpAdvanced.grid(row=1,column=0,sticky=NSEW,padx=5) self.frameControlsBasic.grid(row=1,column=0,sticky=NSEW,padx=5) self.frameControlsBasic.lift() self.buttonLevel = Button(frameMain,command=self.ToggleLevel, text='Advanced Key Binding Entry >>') self.buttonLevel.grid(row=2,column=0,stick=EW,padx=5,pady=5) labelTitleBasic = Label(self.frameKeySeqBasic, text="New keys for '"+self.action+"' :") labelTitleBasic.pack(anchor=W) labelKeysBasic = Label(self.frameKeySeqBasic,justify=LEFT, textvariable=self.keyString,relief=GROOVE,borderwidth=2) labelKeysBasic.pack(ipadx=5,ipady=5,fill=X) self.modifier_checkbuttons = {} column = 0 for modifier, variable in zip(self.modifiers, self.modifier_vars): label = self.modifier_label.get(modifier, modifier) check=Checkbutton(self.frameControlsBasic, command=self.BuildKeyString, text=label,variable=variable,onvalue=modifier,offvalue='') check.grid(row=0,column=column,padx=2,sticky=W) self.modifier_checkbuttons[modifier] = check column += 1 labelFnAdvice=Label(self.frameControlsBasic,justify=LEFT, text=\ "Select the desired modifier keys\n"+ "above, and the final key from the\n"+ "list on the right.\n\n" + "Use upper case Symbols when using\n" + "the Shift modifier. (Letters will be\n" + "converted automatically.)") labelFnAdvice.grid(row=1,column=0,columnspan=4,padx=2,sticky=W) self.listKeysFinal=Listbox(self.frameControlsBasic,width=15,height=10, selectmode=SINGLE) self.listKeysFinal.bind('<ButtonRelease-1>',self.FinalKeySelected) self.listKeysFinal.grid(row=0,column=4,rowspan=4,sticky=NS) scrollKeysFinal=Scrollbar(self.frameControlsBasic,orient=VERTICAL, command=self.listKeysFinal.yview) self.listKeysFinal.config(yscrollcommand=scrollKeysFinal.set) scrollKeysFinal.grid(row=0,column=5,rowspan=4,sticky=NS) self.buttonClear=Button(self.frameControlsBasic, text='Clear Keys',command=self.ClearKeySeq) self.buttonClear.grid(row=2,column=0,columnspan=4) labelTitleAdvanced = Label(self.frameKeySeqAdvanced,justify=LEFT, text="Enter new binding(s) for '"+self.action+"' :\n"+ "(These bindings will not be checked for validity!)") labelTitleAdvanced.pack(anchor=W) self.entryKeysAdvanced=Entry(self.frameKeySeqAdvanced, textvariable=self.keyString) self.entryKeysAdvanced.pack(fill=X) labelHelpAdvanced=Label(self.frameHelpAdvanced,justify=LEFT, text="Key bindings are specified using Tkinter keysyms as\n"+ "in these samples: <Control-f>, <Shift-F2>, <F12>,\n" "<Control-space>, <Meta-less>, <Control-Alt-Shift-X>.\n" "Upper case is used when the Shift modifier is present!\n\n" + "'Emacs style' multi-keystroke bindings are specified as\n" + "follows: <Control-x><Control-y>, where the first key\n" + "is the 'do-nothing' keybinding.\n\n" + "Multiple separate bindings for one action should be\n"+ "separated by a space, eg., <Alt-v> <Meta-v>." ) labelHelpAdvanced.grid(row=0,column=0,sticky=NSEW) def SetModifiersForPlatform(self): """Determine list of names of key modifiers for this platform. The names are used to build Tk bindings -- it doesn't matter if the keyboard has these keys, it matters if Tk understands them. The order is also important: key binding equality depends on it, so config-keys.def must use the same ordering. """ if sys.platform == "darwin": self.modifiers = ['Shift', 'Control', 'Option', 'Command'] else: self.modifiers = ['Control', 'Alt', 'Shift'] self.modifier_label = {'Control': 'Ctrl'} # short name def ToggleLevel(self): if self.buttonLevel.cget('text')[:8]=='Advanced': self.ClearKeySeq() self.buttonLevel.config(text='<< Basic Key Binding Entry') self.frameKeySeqAdvanced.lift() self.frameHelpAdvanced.lift() self.entryKeysAdvanced.focus_set() self.advanced = True else: self.ClearKeySeq() self.buttonLevel.config(text='Advanced Key Binding Entry >>') self.frameKeySeqBasic.lift() self.frameControlsBasic.lift() self.advanced = False def FinalKeySelected(self,event): self.BuildKeyString() def BuildKeyString(self): keyList = modifiers = self.GetModifiers() finalKey = self.listKeysFinal.get(ANCHOR) if finalKey: finalKey = self.TranslateKey(finalKey, modifiers) keyList.append(finalKey) self.keyString.set('<' + string.join(keyList,'-') + '>') def GetModifiers(self): modList = [variable.get() for variable in self.modifier_vars] return [mod for mod in modList if mod] def ClearKeySeq(self): self.listKeysFinal.select_clear(0,END) self.listKeysFinal.yview(MOVETO, '0.0') for variable in self.modifier_vars: variable.set('') self.keyString.set('') def LoadFinalKeyList(self): #these tuples are also available for use in validity checks self.functionKeys=('F1','F2','F2','F4','F5','F6','F7','F8','F9', 'F10','F11','F12') self.alphanumKeys=tuple(string.ascii_lowercase+string.digits) self.punctuationKeys=tuple('~!@#%^&*()_-+={}[]|;:,.<>/?') self.whitespaceKeys=('Tab','Space','Return') self.editKeys=('BackSpace','Delete','Insert') self.moveKeys=('Home','End','Page Up','Page Down','Left Arrow', 'Right Arrow','Up Arrow','Down Arrow') #make a tuple of most of the useful common 'final' keys keys=(self.alphanumKeys+self.punctuationKeys+self.functionKeys+ self.whitespaceKeys+self.editKeys+self.moveKeys) self.listKeysFinal.insert(END, *keys) def TranslateKey(self, key, modifiers): "Translate from keycap symbol to the Tkinter keysym" translateDict = {'Space':'space', '~':'asciitilde','!':'exclam','@':'at','#':'numbersign', '%':'percent','^':'asciicircum','&':'ampersand','*':'asterisk', '(':'parenleft',')':'parenright','_':'underscore','-':'minus', '+':'plus','=':'equal','{':'braceleft','}':'braceright', '[':'bracketleft',']':'bracketright','|':'bar',';':'semicolon', ':':'colon',',':'comma','.':'period','<':'less','>':'greater', '/':'slash','?':'question','Page Up':'Prior','Page Down':'Next', 'Left Arrow':'Left','Right Arrow':'Right','Up Arrow':'Up', 'Down Arrow': 'Down', 'Tab':'Tab'} if key in translateDict.keys(): key = translateDict[key] if 'Shift' in modifiers and key in string.ascii_lowercase: key = key.upper() key = 'Key-' + key return key def OK(self, event=None): if self.advanced or self.KeysOK(): # doesn't check advanced string yet self.result=self.keyString.get() self.destroy() def Cancel(self, event=None): self.result='' self.destroy() def KeysOK(self): '''Validity check on user's 'basic' keybinding selection. Doesn't check the string produced by the advanced dialog because 'modifiers' isn't set. ''' keys = self.keyString.get() keys.strip() finalKey = self.listKeysFinal.get(ANCHOR) modifiers = self.GetModifiers() # create a key sequence list for overlap check: keySequence = keys.split() keysOK = False title = 'Key Sequence Error' if not keys: tkMessageBox.showerror(title=title, parent=self, message='No keys specified.') elif not keys.endswith('>'): tkMessageBox.showerror(title=title, parent=self, message='Missing the final Key') elif (not modifiers and finalKey not in self.functionKeys + self.moveKeys): tkMessageBox.showerror(title=title, parent=self, message='No modifier key(s) specified.') elif (modifiers == ['Shift']) \ and (finalKey not in self.functionKeys + self.moveKeys + ('Tab', 'Space')): msg = 'The shift modifier by itself may not be used with'\ ' this key symbol.' tkMessageBox.showerror(title=title, parent=self, message=msg) elif keySequence in self.currentKeySequences: msg = 'This key combination is already in use.' tkMessageBox.showerror(title=title, parent=self, message=msg) else: keysOK = True return keysOK
class Interface(): def __init__(self, init, speed): self.init_compt = init self.speed = speed self.window = Tk() self.title = self.window.title('IA Minoïde') self.window.geometry('500x200') self.lbl = Label(self.window) self.btn = Button(self.window) self.reinit() self.window.mainloop() def start(self): net = self.NETWORK.get() chk1 = self.chk_state1.get() try: value0 = int(self.txt1.get()) value1 = int(self.txt2.get()) value2 = int(self.txt3.get()) self.terget = [value0, value1, value2] except: #Messagebox.showinfo('Attention/', #'Les valeurs entrées ne sont pas correctes !') return self.txt1.destroy() self.txt2.destroy() self.txt3.destroy() self.chk0.destroy() self.chk1.destroy() self.res = 'Coordonnées cible: ('\ + str(value0) + ', ' + str(value1)\ +", "+ str(value2) + ')' #robot = VrepPioneerSimulation() robot = Pioneer(rospy) HL_size = 10 # nbre neurons of Hiden layer network = NN(3, HL_size, 2) self.trainer = OnlineTrainer(robot, network) if net: with open('last_w.json') as fp: json_obj = json.load(fp) for i in range(3): for j in range(HL_size): network.wi[i][j] = json_obj["input_weights"][i][j] for i in range(HL_size): for j in range(2): network.wo[i][j] = json_obj["output_weights"][i][j] print('Check 0 True') else: print('Check 0 False') if chk1: print('Check 1 True') thread = threading.Thread(target=self.trainer.train, args=(self.terget, )) thread.start() else: print('Check 1 False') if net: self.window.after(1, self.loop) else: self.window.after(1, self.save_file) def save_file(self): self.txt = Entry(self.window, width=30) self.lbl.config(text='Give a name to the log file (default to last):') self.btn.config(text='Valider', command=self.loop) self.txt.grid(column=0, row=1) self.lbl.grid(column=0, row=0) self.btn.grid(column=0, row=2) try: self.file_name = self.txt.get() except: """Messagebox.showinfo('Attention/', "Le nom de fichier n'est pas correct")""" if self.file_name == '': self.file_name = 'last' with open("logs/" + self.file_name + ".json", 'w') as f: print(self.trainer.log_file) json.dump(self.trainer.log_file, f) f.close() print('Graph values have been saved in ' + self.file_name + '.json file') def loop(self): self.lbl.config(text=self.res) self.btn.config(text='Stop', command=self.stop) try: self.txt.destroy() except: pass if self.arret == 1: self.arret = 0 self.lbl.config(text='Arrêt') self.btn.config(text='Réinitialiser', command=self.reinit) return if self.compt <= 0: self.lbl.config(text='Time is over !') self.btn.config(text='Réinitialiser', command=self.reinit) return self.compt -= self.speed / 100 self.window.after(1, self.loop) def stop(self): self.arret = 1 def reinit(self): self.arret = 0 self.compt = self.init_compt self.lbl.config(text='Saisissez les coordonnées:', bg="blue", fg="white", width=20) self.lbl.grid(column=0, row=0) self.txt1Lbl = Label(self.window) self.txt1 = Entry(self.window, width=3) self.txt2 = Entry(self.window, width=3) self.txt3 = Entry(self.window, width=3) self.txt1Lbl.config(text='X', bg="red", fg="white", width=3) self.txt1Lbl.grid(column=0, row=1) #self.lbl.pack() #self.txt1Lbl.pack() self.txt1.grid(column=1, row=1) self.txt2.grid(column=1, row=2) self.txt3.grid(column=1, row=3) self.NETWORK = BooleanVar() self.chk_state1 = BooleanVar() self.NETWORK.set(False) self.chk_state1.set(False) #set check state self.chk0 = Checkbutton(self.window, text='Load previous network', var=self.NETWORK) self.chk1 = Checkbutton(self.window, text='Learn', var=self.chk_state1) self.chk0.grid(column=2, row=1) self.chk1.grid(column=2, row=2) self.btn.config(text='Lancer', command=self.start) self.btn.grid(column=0, row=4)
class ImagePicker(Frame): """ A custom widget that allows for the selection and preview of a picture Note that in the current format, the image picker is specific to the maze builder project """ def __init__(self, parent, label, default="No File Selected", auto_move=False, move_fold=None): """ Construct the image picker instance :param default: Use to set the image path and inital data loaded :param auto_move: If this is set to true, the image picker will automatically move the image into a defined relative folder in the same relative location """ Frame.__init__(self, parent) self._image_ref = None self._file_name = default if not default == "No File Selected" else None self._file_path = self._file_name self._parent = parent self._auto_move = auto_move if auto_move is True: self._folder = "/" + move_fold + "/" # Text label self._label = Label(self, text=label, anchor=W) self._label.grid(row=0, column=0, sticky=W, padx=2) self._label.config(width=10) # The label that displays the name of the selected file self._img_label = Label(self, text=default) self._img_label.config(width=15) self._img_label.grid(row=0, column=1, sticky=W) # Button that enables the previewing of the loaded picture self._pButton = Button(self, text="Preview", command=self._display_img, padx=5) self._pButton.config(width=8) self._pButton.grid(row=0, column=3, sticky=W) # Button that enables the loading of files self._fButton = Button(self, text="|...|", command=self._load_img_label, padx=5) self._fButton.config(width=4) self._fButton.grid(row=0, column=2) def _display_img(self): """ Display a loaded image in a dialog """ if self._file_path is None: Debug.printi("No picture has been loaded to preview", Debug.Level.ERROR) return photo = self._open_img(self._file_path) ImageViewDialog(self._parent, self._file_name, photo) def _open_img(self, img_name): """ Open an image from its location on disk Retrieves an image in ImageTk form from a given file path and loads it for application use :img_name: The path/name (?) of the image to open """ try: img = Image.open(img_name) photo = ImageTk.PhotoImage(img) return photo except IOError: Debug.printi("Unable to find image " + img_name, Debug.Level.ERROR) def _launch_file_b(self): """ Launch a file selector dialog """ types = [ ("JPG", "*.jpg"), ("Bitmap", "*.bmp"), ("PNG", "*.png"), ("GIF", "*.gif"), ("All files", "*")] dialog = tkFileDialog.Open(self, filetypes = types) self._file_path = dialog.show() self._file_name = self._scrub_name(self._file_path) self._move_img() return self._file_name def _move_img(self): if self._auto_move is False: return # Else, move the image to the given folder that is in the same dir as this module try: src = self._file_path dest = os.path.dirname(os.path.realpath(__file__)) +"/" + self._file_name shutil.copy(src, dest) Debug.printi("Moving file " + self._file_path + " to location " + os.path.dirname(os.path.realpath(__file__)) + self._file_name, Debug.Level.INFO) # eg. src and dest are the same file except shutil.Error as e: print('Error: %s' % e + " " +dest) # eg. source or destination doesn't exist except IOError as e: print('Error: %s' % e.strerror +" "+ dest) def _scrub_name(self, file_path): """ Override: Parse and clean the filename """ split = self._file_path.split("/") if self._auto_move is True: f_name = self._folder[1:] + split[-1] else: f_name = split[-1] return f_name def _load_img_label(self): """ Changes the text in the widget label to the (adjusted) filepath of the image """ name = self._launch_file_b() self._img_label.configure(text=name) def get(self): return self._file_name def set(self, val): self._file_name = val self._img_label.config(text=val)
class Window(Frame): def __init__(self, master=None): if not headless: Frame.__init__(self, master) self.master = master self.init_window() def settrainer(self, n): global power_curve, user_defaults user_defaults["power_curve"] = n power_curve = n if n == "power_calc_factors_imagic.txt": self.PowerCurveVariable.set("I-Magic") elif n == "power_calc_factors_fortius.txt": self.PowerCurveVariable.set("Fortius") elif n == "power_calc_factors_custom.txt": self.PowerCurveVariable.set("Custom") def init_window(self): global user_defaults self.grid() # Setup menu content### self.master.title("Antifier v0.9") self.master.option_add("*tearOff", False) # allowing the widget to take the full space of the root window self.pack(fill=BOTH, expand=1) # creating a menu instance menu = Menu(self.master) self.master.config(menu=menu) # create the Setup object) Setup = Menu(menu) # add commands to the Setup option Setup.add_command(label="Head Unit", command=self.HeadUnit_window) subSetup = Menu(Setup) subSetup.add_command( label="iMagic", command=lambda p="power_calc_factors_imagic.txt": self.settrainer( p), ) subSetup.add_command( label="Fortius", command=lambda p="power_calc_factors_fortius.txt": self.settrainer( p), ) subSetup.add_command( label="Custom Curve", command=lambda p="power_calc_factors_custom.txt": self.settrainer( p), ) Setup.add_cascade(label="Power Curve", menu=subSetup) Setup.add_separator() Setup.add_command(label="Exit", command=self.EXITbutton) # added "Setup" to our menu menu.add_cascade(label="Setup", menu=Setup) # create the Options object) Options = Menu(menu) # add commands to the Options option Options.add_command(label="Debug", command=self.DebugButton) Options.add_command(label="Simulate Trainer", command=self.Simulatebutton) Options.add_command(label="Power Factor", command=self.PowerFactor_Window) # added "Options" to our menu menu.add_cascade(label="Options", menu=Options) # create the Help object Help = Menu(menu) # adds a command to the Help option. Help.add_command(label="Readme", command=self.Readme) Help.add_command(label="Zwift shortcuts", command=self.Zwift_shortcuts) # added "Help" to our menu menu.add_cascade(label="Help", menu=Help) # Setup GUI buttons and labels### self.FindHWbutton = Button(self, height=1, width=15, text=u"1. Locate HW", command=self.ScanForHW) self.FindHWbutton.grid(column=0, row=0) label = Label(self, height=1, width=10, text="Head Unit") label.grid(column=0, row=1, sticky="EW") self.trainerVariable = StringVar() label = Label(self, textvariable=self.trainerVariable, anchor="w", fg="black", bg="grey") label.grid(column=1, row=1, columnspan=2, sticky="EW") label = Label(self, height=1, width=10, text="Power curve") label.grid(column=0, row=2, sticky="EW") self.PowerCurveVariable = StringVar() label = Label( self, textvariable=self.PowerCurveVariable, anchor="w", fg="black", bg="grey", ) label.grid(column=1, row=2, columnspan=2, sticky="EW") if "power_curve" in user_defaults: self.settrainer(user_defaults["power_curve"]) label = Label(self, height=1, width=10, text="ANT+") label.grid(column=0, row=3, sticky="EW") self.ANTVariable = StringVar() label = Label(self, textvariable=self.ANTVariable, anchor="w", fg="black", bg="grey") label.grid(column=1, row=3, columnspan=2, sticky="EW") label = Label(self, text="Power factor") label.grid(column=0, row=4, sticky="EW") self.PowerFactorVariable = StringVar() label = Label( self, textvariable=self.PowerFactorVariable, anchor="w", fg="black", bg="grey", ) label.grid(column=1, row=4, columnspan=2, sticky="EW") self.RunoffButton = Button(self, height=1, width=15, text=u"2. Perform Runoff", command=self.Runoff) self.RunoffButton.grid(column=0, row=5) self.RunoffButton.config(state="disabled") self.runoffVariable = StringVar() label = Label( self, textvariable=self.runoffVariable, anchor="w", fg="black", bg="grey", width=40, ) label.grid(column=1, row=5, columnspan=2, sticky="EW") self.StartAPPbutton = Button(self, height=1, width=15, text=u"3. Start script", command=self.Start) self.StartAPPbutton.grid(column=0, row=6) self.StartAPPbutton.config(state="disabled") self.StopAPPbutton = Button( self, height=1, width=15, text=u"Stop script", command=self.Stop, state="disabled", ) self.StopAPPbutton.grid(column=1, row=6) label = Label(self, text="Speed") label.grid(column=0, row=7, sticky="EW") self.SpeedVariable = StringVar() label = Label(self, textvariable=self.SpeedVariable, anchor="w", fg="black", bg="grey") label.grid(column=1, row=7, columnspan=2, sticky="EW") self.SpeedVariable.set(u"0") label = Label(self, text="Heartrate") label.grid(column=0, row=8, sticky="EW") self.HeartrateVariable = StringVar() label = Label(self, textvariable=self.HeartrateVariable, anchor="w", fg="black", bg="grey") label.grid(column=1, row=8, columnspan=2, sticky="EW") self.HeartrateVariable.set(u"0") label = Label(self, text="Cadence") label.grid(column=0, row=9, sticky="EW") self.CadenceVariable = StringVar() label = Label(self, textvariable=self.CadenceVariable, anchor="w", fg="black", bg="grey") label.grid(column=1, row=9, columnspan=2, sticky="EW") self.CadenceVariable.set(u"0") label = Label(self, text="Power") label.grid(column=0, row=10, sticky="EW") self.PowerVariable = StringVar() label = Label(self, textvariable=self.PowerVariable, anchor="w", fg="black", bg="grey") label.grid(column=1, row=10, columnspan=2, sticky="EW") self.PowerVariable.set(u"0") label = Label(self, text="Slope") label.grid(column=0, row=11, sticky="EW") self.SlopeVariable = StringVar() label = Label(self, textvariable=self.SlopeVariable, anchor="w", fg="black", bg="grey") label.grid(column=1, row=11, columnspan=2, sticky="EW") label = Label(self, text="Target Power") label.grid(column=0, row=12, sticky="EW") self.TargetPowerVariable = StringVar() label = Label( self, textvariable=self.TargetPowerVariable, anchor="w", fg="black", bg="grey", ) label.grid(column=1, row=12, columnspan=2, sticky="EW") label = Label(self, text="Resistance Level") label.grid(column=0, row=13, sticky="EW") self.ResistanceLevelVariable = StringVar() label = Label( self, textvariable=self.ResistanceLevelVariable, anchor="w", fg="black", bg="grey", ) label.grid(column=1, row=13, columnspan=2, sticky="EW") self.ResistanceLevelVariable.set(u"0") def PowerFactor_Window(self): self.PowerFactor_Window = Toplevel(self.master) self.app = PowerFactor_Window(self.PowerFactor_Window) def HeadUnit_window(self): self.HeadUnitWindow = Toplevel(self.master) self.app = HeadUnit_Window(self.HeadUnitWindow) def Runoff(self): global runoff_loop_running def run(): global dev_trainer, runoff_loop_running rolldown = False rolldown_time = 0 speed = 0 # self.InstructionsVariable.set(''' # CALIBRATION TIPS: # 1. Tyre pressure 100psi (unloaded and cold) aim for 7.2s rolloff # 2. Warm up for 2 mins, then cycle 30kph-40kph for 30s # 3. Speed up to above 40kph then stop pedalling and freewheel # 4. Rolldown timer will start automatically when you hit 40kph, so stop pedalling quickly! # ''') while runoff_loop_running: # loop every 100ms last_measured_time = time.time() * 1000 # receive data from trainer speed, pedecho, heart_rate, force_index, cadence = trainer.receive( dev_trainer) # get data from device self.SpeedVariable.set(speed) if speed == "Not found": self.TrainerStatusVariable.set( "Check trainer is powered on") # send data to trainer resistance_level = 6 trainer.send(dev_trainer, resistance_level, pedecho) if speed > 40: # speed above 40, start rolldown self.runoffVariable.set( "Rolldown timer started - STOP PEDALLING!") rolldown = True if speed <= 40 and rolldown: # rolldown timer starts when dips below 40 if rolldown_time == 0: rolldown_time = time.time( ) # set initial rolldown time self.runoffVariable.set( "Rolldown timer started - STOP PEDALLING! %s " % (round((time.time() - rolldown_time), 1))) if speed < 0.1 and rolldown: # wheel stopped runoff_loop_running = False # break loop self.runoffVariable.set( "Rolldown time = %s seconds (aim 7s)" % round( (time.time() - rolldown_time), 1)) time_to_process_loop = time.time() * 1000 - last_measured_time sleep_time = 0.1 - (time_to_process_loop) / 1000 if sleep_time < 0: sleep_time = 0 time.sleep(sleep_time) self.RunoffButton.config( text="2. Perform Runoff") # reset runoff button self.StartAPPbutton.config(state="normal") if self.RunoffButton.cget( "text") == "2. Perform Runoff": # start runoff self.runoffVariable.set("Cycle to above 40kph then stop") self.RunoffButton.config(text="2. Stop Runoff") self.StartAPPbutton.config(state="disabled") runoff_loop_running = True # loop switch t1 = threading.Thread(target=run) t1.start() else: # stop loop runoff_loop_running = False self.runoffVariable.set("Stopped") self.RunoffButton.config(text="2. Perform Runoff") self.StartAPPbutton.config(state="normal") def Readme(self): os.startfile("README.txt") def Zwift_shortcuts(self): os.startfile("Zwift_shortcuts.txt") def EXITbutton(self): self.destroy() exit() def DebugButton(self): global debug if debug: debug = True else: debug = False def Simulatebutton(self): global simulatetrainer simulatetrainer = True def Stop(self): global switch switch = False self.StartAPPbutton.config(state="normal") self.StopAPPbutton.config(state="disabled") def ScanForHW(self): global dev_trainer, dev_ant, simulatetrainer # get ant stick if debug: print("get ant stick") if not dev_ant: dev_ant, msg = ant.get_ant(debug) if not dev_ant: if not headless: self.ANTVariable.set(msg) return False if not headless: self.ANTVariable.set(msg) if not headless: self.PowerFactorVariable.set(powerfactor) if debug: print("get trainer") # find trainer model for Windows and Linux if not dev_trainer: # find trainer if simulatetrainer: if not headless: self.trainerVariable.set(u"Simulated Trainer") else: print("Simulated Trainer") else: dev_trainer = trainer.get_trainer() if not dev_trainer: if not headless: self.trainerVariable.set("Trainer not detected") else: print("Trainer not detected") return False else: if not headless: self.trainerVariable.set("Trainer detected") else: print("Trainer detected") trainer.initialise_trainer( dev_trainer) # initialise trainer if not headless: self.StartAPPbutton.config(state="normal") if not simulatetrainer: self.RunoffButton.config(state="normal") self.FindHWbutton.config(state="disabled") return True def Start(self): def run(): global dev_ant, dev_trainer, simulatetrainer, switch, power_curve if power_curve == "": if not headless: self.PowerCurveVariable.set( "Choose a power curve under setup menu") self.StartAPPbutton.config(state="normal") self.StopAPPbutton.config(state="disabled") return pc_dict = trainer.parse_factors( power_curve) # get power curve dictionary if len(pc_dict) != 14: if not headless: self.PowerCurveVariable.set( "Need 14 levels for power curve") self.StartAPPbutton.config(state="normal") self.StopAPPbutton.config(state="disabled") return pc_sorted_keys = sorted(pc_dict.iterkeys()) # -1,-0,2,3 etc. if debug: print("reset ant stick") ant.antreset(dev_ant, debug) # reset dongle if debug: print("calibrate ant stick") ant.calibrate(dev_ant, debug) # calibrate ANT+ dongle if debug: print("calibrate ant stick FE-C") ant.master_channel_config(dev_ant, debug) # calibrate ANT+ channel FE-C if debug: print("calibrate ant stick HR") ant.second_channel_config(dev_ant, debug) # calibrate ANT+ channel HR if not headless: self.RunoffButton.config(state="disabled") else: print("Ctrl-C to exit") speed, cadence, power, heart_rate = (0, ) * 4 # initialise values grade = False target_power = False accumulated_power = 0 heart_beat_event_time = time.time() * 1000 heart_beat_event_time_start_cycle = time.time() * 1000 heart_toggle = 0 heart_beat_count = 0 switch = True cot_start = time.time() eventcounter = 0 # p.44 [10] general fe data, [19] eqpt type trainer, [89] acc value time since start in 0.25s r/over 64s, [8c] acc value time dist travelled in m r/over 256m, # [8d] [20] speed lsb msb 0.001m/s, [00] hr, [30] capabilities bit field accumulated_time = time.time() * 1000 distance_travelled = 0 last_dist_time = time.time() * 1000 # p.60 [19] specific trainer data, [10] counter rollover 256, [5a] inst cadence, [b0] acc power lsb, [47] acc power msb (r/over 65536W), [1b] inst power lsb, # [01] bits 0-3 inst power MSB bits 4-7 trainer status bit, [30] flags bit field last_measured_time = time.time() * 1000 try: while switch: if debug: print("Running", round(time.time() * 1000 - last_measured_time)) last_measured_time = time.time() * 1000 if eventcounter >= 256: eventcounter = 0 # TRAINER- SHOULD WRITE THEN READ 70MS LATER REALLY # ##################GET DATA FROM TRAINER################## if simulatetrainer: speed, pedecho, heart_rate, force_index, cadence = ( 20, 0, 70, 5, 90, ) else: speed, pedecho, heart_rate, force_index, cadence = trainer.receive( dev_trainer) # get data from device if speed == "Not Found": speed, pedecho, heart_rate, force_index, cadence = 0, 0, 0, 0, 0 if not headless: self.trainerVariable.set( "Cannot read from trainer") else: print("Cannot read from trainer") else: if not headless: self.trainerVariable.set("Trainer detected") # print force_index factors = pc_dict[pc_sorted_keys[force_index]] calc_power = int(speed * factors[0] + factors[1]) if calc_power < 0: calc_power = 0 if debug: print(speed, pedecho, heart_rate, force_index, cadence, calc_power) # ##################SEND DATA TO TRAINER################## # send resistance data to trainer if debug: print( datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S.%f") [:-3], "GRADE", grade, "%") # set resistance level if not grade and not target_power: # if trainer not been been set a grade or target power grade = 0 resistance_level = len( pc_dict) - 1 # set to highest by default if grade is not False: # find resistance for grade for idx, g in enumerate(sorted(pc_dict)): if g >= grade: # find resistance value immediately above grade set by zwift resistance_level = idx break elif target_power: # get resistance closest for power target if speed < 10: speed = 10 # default to at least 10 kph closest = 1000 for idx, g in enumerate(sorted(pc_dict)): # iterate up power_at_level = int(speed * pc_dict[g][0] + pc_dict[g][1]) # print idx,g,power_at_level if (target_power - power_at_level)**2 < closest**2: resistance_level = idx closest = ((target_power - power_at_level)**2)**0.5 # print resistance_level if not simulatetrainer: trainer.send(dev_trainer, resistance_level, pedecho) # time.sleep(0.2)#simulated trainer timeout # ############BROADCAST AND RECEIVE ANT+ data############## if speed == "Not Found": speed, pedecho, calc_power, cadence = 0, 0, 0, 0 if calc_power >= 4094: calc_power = 4093 accumulated_power += calc_power if accumulated_power >= 65536: accumulated_power = 0 if ( eventcounter + 1 ) % 66 == 0 or eventcounter % 66 == 0: # send first and second manufacturer's info packet newdata = "a4 09 4e 00 50 ff ff 01 0f 00 85 83 bb 00 00" elif (eventcounter + 32) % 66 == 0 or ( eventcounter + 33 ) % 66 == 0: # send first and second product info packet newdata = "a4 09 4e 00 51 ff ff 01 01 00 00 00 b2 00 00" elif eventcounter % 3 == 0: # send general fe data every 3 packets accumulated_time_counter = int( (time.time() * 1000 - accumulated_time) / 1000 / 0.25) # time since start in 0.25 seconds if (accumulated_time_counter >= 256 ): # rollover at 64 seconds (256 quarter secs) accumulated_time_counter = 0 accumulated_time = time.time() * 1000 newdata = "{0}{1}{2}".format( "a4 09 4e 00 10 19 ", hex(accumulated_time_counter)[2:].zfill(2), " 8c 8d 20 00 30 72 00 00", ) # set time distance_travelled_since_last_loop = ( (time.time() * 1000 - last_dist_time) / 1000 * speed * 1000 / 3600 ) # speed reported in kph- convert to m/s last_dist_time = time.time( ) * 1000 # reset last loop time distance_travelled += distance_travelled_since_last_loop if distance_travelled >= 256: # reset at 256m distance_travelled = 0 newdata = "{0}{1}{2}".format( newdata[:21], hex(int(distance_travelled))[2:].zfill(2), newdata[23:], ) # set distance travelled hexspeed = hex(int(speed * 1000 * 1000 / 3600))[2:].zfill(4) newdata = "{0}{1}{2}{3}{4}".format( newdata[:24], hexspeed[2:], " ", hexspeed[:2], newdata[29:]) # set speed newdata = "{0}{1}{2}".format( newdata[:36], ant.calc_checksum(newdata), newdata[38:]) # recalculate checksum else: # send specific trainer data newdata = "{0}{1}{2}".format( "a4 09 4e 00 19 ", hex(eventcounter)[2:].zfill(2), " 5a b0 47 1b 01 30 6d 00 00", ) # increment event count if cadence >= 254: cadence = 253 newdata = "{0}{1}{2}".format( newdata[:18], hex(cadence)[2:].zfill(2), newdata[20:]) # instant cadence hexaccumulated_power = hex( int(accumulated_power))[2:].zfill(4) newdata = "{0}{1}{2}{3}{4}".format( newdata[:21], hexaccumulated_power[2:], " ", hexaccumulated_power[:2], newdata[26:], ) # set accumulated power hexinstant_power = hex(int(calc_power))[2:].zfill(4) hexinstant_power_lsb = hexinstant_power[2:] newdata = "{0}{1}{2}".format( newdata[:27], hexinstant_power_lsb, newdata[29:]) # set power lsb byte hexinstant_power_msb = hexinstant_power[:2] bits_0_to_3 = bin(int(hexinstant_power_msb, 16))[2:].zfill(4) power_msb_trainer_status_byte = "0000" + bits_0_to_3 newdata = "{0}{1}{2}".format( newdata[:30], hex(int(power_msb_trainer_status_byte))[2:].zfill( 2), newdata[32:], ) # set mixed trainer data power msb byte newdata = "{0}{1}{2}".format( newdata[:36], ant.calc_checksum(newdata), newdata[38:]) # recalculate checksum if debug: print( datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S.%f") [:-3], "TRAINER DATA", newdata) reply = ant.send_ant([newdata], dev_ant, debug) # reply = [] # if rv[6:8]=="33": # rtn = {'grade' : int(rv[18:20]+rv[16:18],16) * 0.01 - 200} #7% in zwift = 3.5% grade in ANT+ matching = [s for s in reply if "a4094f0033" in s] # target resistance # 0x33 a4094f00 33 ffffffff964fff f7 is gradient message if matching: grade = ( int(matching[0][20:22] + matching[0][18:20], 16) * 0.01 - 200) target_power = False if not headless: self.SlopeVariable.set(round(grade, 1)) if not headless: self.TargetPowerVariable.set("") if debug: print(grade, matching[0]) else: matching = [s for s in reply if "a4094f0031" in s] # target watts # 0x31 a4094f00 31 ffffffffff5c02 72 is target power message in 0.25w 0x025c = 604 = 151W if matching: target_power = (int( matching[0][22:24] + matching[0][20:22], 16) / 4) grade = False if not headless: self.TargetPowerVariable.set(target_power) if not headless: self.SlopeVariable.set("") # ##################HR####################### # HR format # D00000693_-_ANT+_Device_Profile_-_Heart_Rate_Rev_2.1.pdf # [00][FF][FF][FF][55][03][01][48]p. 18 [00] bits 0:6 data page no, bit 7 toggle every 4th message, [ff][ff][ff] (reserved for page 0), [55][03] heart beat event time [lsb][ msb] rollover 64s, [01] heart beat count rollover 256, [instant heart rate]max 256 # [00][FF][FF][FF][55][03][01][48] # [00][FF][FF][FF][AA][06][02][48] # [00][FF][FF][FF][AA][06][02][48] # [80][FF][FF][FF][AA][06][02][48] # [80][FF][FF][FF][AA][06][02][48] # [80][FF][FF][FF][FF][09][03][48] # [80][FF][FF][FF][FF][09][03][48] # [00][FF][FF][FF][FF][09][03][48] # [00][FF][FF][FF][54][0D][04][48] # [00][FF][FF][FF][54][0D][04][48] # [00][FF][FF][FF][54][0D][04][48] # every 65th message send manufacturer and product info -apge 2 and page 3 # [82][0F][01][00][00][3A][12][48] - [82] page 2 with toggle on (repeat 4 times) # [83][01][01][33][4F][3F][13][48] - [83] page 3 with toggle on # if eventcounter > 40: heart_rate = 100 #comment out in production if heart_rate > 0: # i.e. heart rate belt attached if eventcounter % 4 == 0: # toggle bit every 4 counts if heart_toggle == 0: heart_toggle = 128 else: heart_toggle = 0 # check if heart beat has occurred as tacx only reports instanatenous heart rate data # last heart beat is at heart_beat_event_time # if now - heart_beat_event_time > time taken for hr to occur, trigger beat. 70 bpm = beat every 60/70 seconds if (time.time() * 1000 - heart_beat_event_time ) >= (60 / float(heart_rate)) * 1000: heart_beat_count += 1 # increment heart beat count heart_beat_event_time += ( 60 / float(heart_rate) ) * 1000 # reset last time of heart beat if (heart_beat_event_time - heart_beat_event_time_start_cycle >= 64000): # rollover every 64s heart_beat_event_time = ( time.time() * 1000 ) # reset last heart beat event heart_beat_event_time_start_cycle = ( time.time() * 1000) # reset start of cycle if heart_beat_count >= 256: heart_beat_count = 0 if heart_rate >= 256: heart_rate = 255 hex_heart_beat_time = int( (heart_beat_event_time - heart_beat_event_time_start_cycle) * 1.024) # convert ms to 1/1024 of a second hex_heart_beat_time = hex( hex_heart_beat_time)[2:].zfill(4) hr_byte_4 = hex_heart_beat_time[2:] hr_byte_5 = hex_heart_beat_time[:2] hr_byte_6 = hex(heart_beat_count)[2:].zfill(2) hr_byte_7 = hex(heart_rate)[2:].zfill(2) # data page 1,6,7 every 80s if ( eventcounter % 65 == 0 or (eventcounter + 1) % 65 == 0 or (eventcounter + 2) % 65 == 0 or (eventcounter + 3) % 65 == 0 ): # send first and second manufacturer's info packet hr_byte_0 = hex(2 + heart_toggle)[2:].zfill(2) hr_byte_1 = "0f" hr_byte_2 = "01" hr_byte_3 = "00" # [82][0F][01][00][00][3A][12][48] elif ((eventcounter + 31) % 65 == 0 or (eventcounter + 32) % 65 == 0 or (eventcounter + 33) % 65 == 0 or (eventcounter + 34) % 65 == 0 ): # send first and second product info packet hr_byte_0 = hex(3 + heart_toggle)[2:].zfill(2) hr_byte_1 = "01" hr_byte_2 = "01" hr_byte_3 = "33" # [83][01][01][33][4F][3F][13][48] elif ((eventcounter + 11) % 65 == 0 or (eventcounter + 12) % 65 == 0 or (eventcounter + 13) % 65 == 0 or (eventcounter + 44) % 65 == 0 ): # send page 0x01 cumulative operating time cot = int((time.time() - cot_start) / 2) cot_hex = hex(cot)[2:].zfill(6) hr_byte_0 = hex(1 + heart_toggle)[2:].zfill(2) hr_byte_1 = cot_hex[4:6] hr_byte_2 = cot_hex[2:4] hr_byte_3 = cot_hex[0:2] elif ((eventcounter + 21) % 65 == 0 or (eventcounter + 22) % 65 == 0 or (eventcounter + 23) % 65 == 0 or (eventcounter + 24) % 65 == 0): # send page 0x06 capabilities hr_byte_0 = hex(6 + heart_toggle)[2:].zfill(2) hr_byte_1 = "ff" hr_byte_2 = "00" hr_byte_3 = "00" elif ((eventcounter + 41) % 65 == 0 or (eventcounter + 42) % 65 == 0 or (eventcounter + 43) % 65 == 0 or (eventcounter + 44) % 65 == 0): # send page 0x07 battery hr_byte_0 = hex(7 + heart_toggle)[2:].zfill(2) hr_byte_1 = "64" hr_byte_2 = "55" hr_byte_3 = "13" else: # send page 0 hr_byte_0 = hex(0 + heart_toggle)[2:].zfill(2) hr_byte_1 = "ff" hr_byte_2 = "ff" hr_byte_3 = "ff" hrdata = ("a4 09 4e 01 " + hr_byte_0 + " " + hr_byte_1 + " " + hr_byte_2 + " " + hr_byte_3 + " " + hr_byte_4 + " " + hr_byte_5 + " " + hr_byte_6 + " " + hr_byte_7 + " 02 00 00") hrdata = ("a4 09 4e 01 " + hr_byte_0 + " " + hr_byte_1 + " " + hr_byte_2 + " " + hr_byte_3 + " " + hr_byte_4 + " " + hr_byte_5 + " " + hr_byte_6 + " " + hr_byte_7 + " " + ant.calc_checksum(hrdata) + " 00 00") time.sleep(0.125) # sleep for 125ms if debug: print( datetime.utcnow().strftime( "%Y-%m-%d %H:%M:%S.%f")[:-3], "HEART RATE", hrdata) ant.send_ant([hrdata], dev_ant, debug) # ###################wait #################### # add wait so we only send every 250ms time_to_process_loop = time.time( ) * 1000 - last_measured_time sleep_time = 0.25 - (time_to_process_loop) / 1000 if sleep_time < 0: sleep_time = 0 time.sleep(sleep_time) eventcounter += 1 if not headless: self.SpeedVariable.set(speed) self.HeartrateVariable.set(heart_rate) self.CadenceVariable.set(cadence) self.PowerVariable.set(calc_power) self.ResistanceLevelVariable.set(resistance_level) elif eventcounter % 4 == 0: print("Power %sW, HR %s, Cadence %s, Resistance %s" % ( calc_power, heart_rate, cadence, resistance_level, )) except KeyboardInterrupt: print("Stopped") ant.antreset(dev_ant, debug) # reset dongle if os.name == "posix": # close serial port to ANT stick on Linux dev_ant.close() if debug: print("stopped") if not headless: self.RunoffButton.config(state="normal") with open("user_defaults", "wb") as handle: # save defaults pickle.dump(user_defaults, handle, protocol=pickle.HIGHEST_PROTOCOL) if not headless: self.FindHWbutton.config(state="disabled") self.StartAPPbutton.config(state="disabled") self.StopAPPbutton.config(state="normal") thread = threading.Thread(target=run) thread.start() else: run()
class ConditionalsEditor: def __init__(self, my_window, conditionals, close_callback): #Tk.__init__(self) self.my_window = my_window self.my_window.title("Condition Editor") self.close_callback = close_callback self.conditionals = conditionals shared_pad_x = 3 shared_pad_y = 3 main_frame = Frame(self.my_window) main_frame.grid(column=0, row=0, sticky=(N, W, E, S)) image_path = "images" image_files = [ f for f in os.listdir(image_path) if os.path.isfile(os.path.join(image_path, f)) and f.endswith(".png") ] self.icons = {} for image_file in image_files: self.icons[os.path.splitext( os.path.basename(image_file))[0]] = PhotoImage( file=os.path.join(image_path, image_file)) up_down_button_frame = Frame(main_frame) self.up_button = Button(up_down_button_frame, state="disabled", text="Move up", image=self.icons["gtk-go-up"], command=self.up_pressed) self.up_button.grid(column=0, row=0, sticky=(E)) self.down_button = Button(up_down_button_frame, state="disabled", text="Move down", image=self.icons["gtk-go-down"], command=self.down_pressed) self.down_button.grid(column=0, row=1, sticky=(E)) up_down_button_frame.grid(column=0, row=0, sticky=(E)) condition_list = Frame(main_frame, relief=SUNKEN, borderwidth=1) condition_list.grid(column=1, row=0, sticky=(N, S, E, W), padx=shared_pad_x, pady=shared_pad_y, columnspan=1) self.condition_list_scrollbar = Scrollbar(condition_list) self.state_listbox = Listbox(condition_list, relief=FLAT, exportselection=False, borderwidth=0, highlightthickness=0, yscrollcommand=self.state_listbox_scroll, activestyle="none") self.state_listbox.grid(column=0, row=0, padx=0, sticky=(N, S)) self.state_listbox.bind("<<ListboxSelect>>", self.state_listbox_selected) self.condition_listbox = Listbox( condition_list, relief=FLAT, exportselection=False, borderwidth=0, highlightthickness=0, yscrollcommand=self.condition_listbox_scroll, activestyle="none") self.condition_listbox.grid(column=1, row=0, sticky=(N, S, E, W), padx=0) self.condition_listbox.bind("<<ListboxSelect>>", self.condition_listbox_selected) self.execution_target_listbox = Listbox( condition_list, relief=FLAT, exportselection=False, borderwidth=0, highlightthickness=0, yscrollcommand=self.execution_target_listbox_scroll, activestyle="none") self.execution_target_listbox.grid(column=2, row=0, padx=0, sticky=(N, S)) self.execution_target_listbox.bind( "<<ListboxSelect>>", self.execution_target_listbox_selected) self.condition_list_scrollbar.grid(column=3, row=0, sticky=(N, S)) self.condition_list_scrollbar.config( command=self.condition_list_scrollbar_callback) condition_list.grid_rowconfigure(0, weight=1) for conditional in self.conditionals: self.state_listbox.insert(END, conditional[0]) self.condition_listbox.insert(END, conditional[1]) self.execution_target_listbox.insert(END, conditional[2]) #for i in range(5): # self.state_listbox.insert(END, "Foo %d"%i) # self.condition_listbox.insert(END, "Bar %d"%i) # self.execution_target_listbox.insert(END, "Baz %d"%i) if_label = Label(main_frame, text="If:", padx=10) if_label.grid(column=0, row=1, sticky=(N, E)) self.if_text_variable = StringVar() if_entry = Entry(main_frame, textvariable=self.if_text_variable) if_entry.grid( column=1, row=1, sticky=(E, W), padx=shared_pad_x, pady=shared_pad_y, ) then_label = Label(main_frame, text="Then:", padx=10) then_label.grid(column=0, row=2, sticky=(N, E)) self.then_entry = Text(main_frame) self.then_entry.grid( column=1, row=2, sticky=(N, S, E, W), padx=shared_pad_x, rowspan=2, ) option_frame = Frame(main_frame) execution_target_label = Label(option_frame, text="Execution target:") execution_target_label.grid(column=0, row=0, sticky=(N, W), pady=(10, shared_pad_y)) self.execution_target = StringVar() self.execution_target.set("Debugger") debugger_radiobutton = Radiobutton(option_frame, text="Debugger", variable=self.execution_target, value="Debugger") debugger_radiobutton.grid(column=0, row=1, sticky=(N, W)) python_radiobutton = Radiobutton(option_frame, text="Python", variable=self.execution_target, value="Python") python_radiobutton.grid(column=0, row=2, sticky=(N, W)) state_label = Label(option_frame, text="State") state_label.grid(column=0, row=3, sticky=(N, W), pady=(10, shared_pad_y)) self.active_checkbutton = StringVar() self.active_checkbutton.set("Enabled") active_checkbutton = Checkbutton(option_frame, text="Enabled", variable=self.active_checkbutton, onvalue="Enabled", offvalue="Disabled") active_checkbutton.grid(column=0, row=4, sticky=(N, W)) option_frame.grid(column=0, row=3, sticky=(N, S, E, W), pady=5) button_frame = Frame(main_frame) self.add_button = Button(button_frame, state="disabled", text="Add", image=self.icons["gtk-add"], compound=LEFT) self.add_button.grid(column=0, row=0, sticky=(E)) self.update_button = Button(button_frame, state="disabled", text="Update", image=self.icons["gtk-edit"], compound=LEFT) self.update_button.grid(column=1, row=0, sticky=(E)) self.delete_button = Button(button_frame, state="disabled", text="Delete", image=self.icons["gtk-remove"], compound=LEFT) self.delete_button.grid(column=2, row=0, sticky=(E)) button_frame.grid(column=0, row=4, columnspan=2, sticky=(E), padx=shared_pad_x, pady=shared_pad_y) close_frame = Frame(main_frame) close_button = Button(close_frame, text="Close", image=self.icons["gtk-close"], compound=LEFT, command=self.on_closing) close_button.grid(column=0, row=0, sticky=(S, E)) close_frame.grid(column=0, row=5, columnspan=2, sticky=(S, E), padx=shared_pad_x, pady=(15, shared_pad_y)) self.my_window.grid_columnconfigure(0, weight=1) self.my_window.grid_rowconfigure(0, weight=1) main_frame.grid_columnconfigure(1, weight=1) main_frame.grid_rowconfigure(0, weight=1) main_frame.grid_rowconfigure(2, weight=0) main_frame.grid_rowconfigure(3, weight=1) main_frame.grid_rowconfigure(4, weight=1) main_frame.grid_rowconfigure(5, weight=1) condition_list.grid_columnconfigure(1, weight=1) button_frame.grid_rowconfigure(0, weight=1) self.my_window.protocol("WM_DELETE_WINDOW", self.on_closing) def on_closing(self): if self.close_callback is not None: self.close_callback() self.my_window.destroy() def up_pressed(self): index = self.state_listbox.curselection()[0] state_current = self.state_listbox.get(index) condition_current = self.condition_listbox.get(index) execution_target_current = self.execution_target_listbox.get(index) self.state_listbox.delete(index) self.condition_listbox.delete(index) self.execution_target_listbox.delete(index) self.state_listbox.insert(index - 1, state_current) self.condition_listbox.insert(index - 1, condition_current) self.execution_target_listbox.insert(index - 1, execution_target_current) self.conditionals.insert(index - 1, self.conditionals.pop(index)) self.state_listbox.selection_set(index - 1) self.condition_listbox.selection_set(index - 1) self.execution_target_listbox.selection_set(index - 1) self.state_listbox.see(index - 1) if index - 1 == 0: self.up_button.config(state="disabled") self.down_button.config(state="normal") def down_pressed(self): index = self.state_listbox.curselection()[0] state_current = self.state_listbox.get(index) condition_current = self.condition_listbox.get(index) execution_target_current = self.execution_target_listbox.get(index) self.state_listbox.delete(index) self.condition_listbox.delete(index) self.execution_target_listbox.delete(index) self.state_listbox.insert(index + 1, state_current) self.condition_listbox.insert(index + 1, condition_current) self.execution_target_listbox.insert(index + 1, execution_target_current) self.conditionals.insert(index + 1, self.conditionals.pop(index)) self.state_listbox.selection_set(index + 1) self.condition_listbox.selection_set(index + 1) self.execution_target_listbox.selection_set(index + 1) self.state_listbox.see(index + 1) if index + 1 == self.state_listbox.size() - 1: self.down_button.config(state="disabled") self.up_button.config(state="normal") def condition_list_scrollbar_callback(self, *args): self.state_listbox.yview(*args) self.condition_listbox.yview(*args) self.execution_target_listbox.yview(*args) def state_listbox_scroll(self, *args): self.condition_listbox.yview_moveto(args[0]) self.execution_target_listbox.yview_moveto(args[0]) self.condition_list_scrollbar.set(*args) def condition_listbox_scroll(self, *args): self.state_listbox.yview_moveto(args[0]) self.execution_target_listbox.yview_moveto(args[0]) def execution_target_listbox_scroll(self, *args): self.state_listbox.yview_moveto(args[0]) self.condition_listbox.yview_moveto(args[0]) def any_listbox_selected(self): self.up_button.config(state="normal") self.down_button.config(state="normal") if self.state_listbox.curselection( )[0] == self.state_listbox.size() - 1: self.down_button.config(state="disabled") if self.state_listbox.curselection()[0] == 0: self.up_button.config(state="disabled") self.delete_button.config(state="normal") self.then_entry.delete("1.0", END) self.then_entry.insert( END, self.conditionals[self.state_listbox.curselection()[0]][3]) self.if_text_variable.set( self.conditionals[self.state_listbox.curselection()[0]][1]) self.execution_target.set( self.conditionals[self.state_listbox.curselection()[0]][2]) self.active_checkbutton.set( self.conditionals[self.state_listbox.curselection()[0]][0]) def state_listbox_selected(self, event): index = self.state_listbox.curselection()[0] try: self.condition_listbox.selection_clear( self.condition_listbox.curselection()[0]) except IndexError: pass self.condition_listbox.selection_set(index) try: self.execution_target_listbox.selection_clear( self.execution_target_listbox.curselection()[0]) except IndexError: pass self.execution_target_listbox.selection_set(index) self.any_listbox_selected() def condition_listbox_selected(self, event): index = self.condition_listbox.curselection()[0] try: self.state_listbox.selection_clear( self.state_listbox.curselection()[0]) except IndexError: pass self.state_listbox.selection_set(index) try: self.execution_target_listbox.selection_clear( self.execution_target_listbox.curselection()[0]) except IndexError: pass self.execution_target_listbox.selection_set(index) self.any_listbox_selected() def execution_target_listbox_selected(self, event): index = self.execution_target_listbox.curselection()[0] try: self.state_listbox.selection_clear( self.state_listbox.curselection()[0]) except IndexError: pass self.state_listbox.selection_set(index) try: self.condition_listbox.selection_clear( self.condition_listbox.curselection()[0]) except IndexError: pass self.condition_listbox.selection_set(index) self.any_listbox_selected()
class Window(Frame): def __init__(self, master=None): Frame.__init__(self, master) self.master = master self.init_window() def init_window(self): self.grid() self.grid_columnconfigure(1, minsize=200) self.grid_columnconfigure(2, minsize=200) self.StartText = StringVar() self.StartText.set(u"Start") Label(self, text="Step 1: Rundown test").grid(row=1, column=1, sticky="E") Label(self, text="Step 2: Calibrate power meter").grid( row=2, column=1, sticky="E" ) Label(self, text="Step 3: Run power curve").grid(row=3, column=1, sticky="E") Label(self, text="Trainer Status: ").grid(row=4, column=1, sticky="E") Label(self, text="ANT+ Status: ").grid(row=5, column=1, sticky="E") Label(self, text="Calibrated: ").grid(row=6, column=1, sticky="E") Label(self, text="Resistance Level: ").grid(row=7, column=1, sticky="E") Label(self, text="Speed: ").grid(row=8, column=1, sticky="E") Label(self, text="Power: ").grid(row=9, column=1, sticky="E") Label(self, text="Instructions: ").grid(row=10, column=1, sticky="E") self.InstructionsVariable = StringVar() label = Label( self, textvariable=self.InstructionsVariable, anchor=W, justify=LEFT, wraplength=400, ) label.grid(row=11, column=1, sticky=W, columnspan=2) self.RunoffButton = Button( self, height=1, width=15, text="Start Runoff", command=self.StartRunoff ) self.RunoffButton.grid(column=2, row=1) self.CalibrateButton = Button( self, height=1, width=15, text="Calibrate", command=self.Calibrate ) self.CalibrateButton.grid(column=2, row=2) # self.CalibrateButton.config(state="disabled") self.FindHWbutton = Button( self, height=1, width=15, textvariable=self.StartText, command=self.ScanForHW, ) self.FindHWbutton.grid(column=2, row=3) # self.FindHWbutton.config(state="disabled") self.TrainerStatusVariable = StringVar() label = Label(self, textvariable=self.TrainerStatusVariable, anchor="w") label.grid(row=4, column=2, sticky="EW") self.ANTStatusVariable = StringVar() label = Label(self, textvariable=self.ANTStatusVariable, anchor="w") label.grid(row=5, column=2, sticky="EW") self.CalibratedVariable = StringVar() label = Label(self, textvariable=self.CalibratedVariable, anchor="w") label.grid(row=6, column=2, sticky="EW") self.CalibratedVariable.set("False") self.ResistanceVariable = StringVar() label = Label(self, textvariable=self.ResistanceVariable, anchor="w") label.grid(row=7, column=2, sticky="EW") self.SpeedVariable = StringVar() label = Label(self, textvariable=self.SpeedVariable, anchor="w") label.grid(row=8, column=2, sticky="EW") self.PowerVariable = StringVar() label = Label(self, textvariable=self.PowerVariable, anchor="w") label.grid(row=9, column=2, sticky="EW") def StartRunoff(self): def run(): global dev_trainer self.RunoffButton.config(state="disabled") runoff_loop_running = True rolldown = False rolldown_time = 0 speed = 0 self.InstructionsVariable.set( """ CALIBRATION TIPS: 1. Tyre pressure 100psi (unloaded and cold) aim for 7.2s rolloff 2. Warm up for 2 mins, then cycle 30kph-40kph for 30s 3. Speed up to above 40kph then stop pedalling and freewheel 4. Rolldown timer will start automatically when you hit 40kph, so stop pedalling quickly! """ ) if not dev_trainer: # if trainer not already captured dev_trainer = trainer.get_trainer() if not dev_trainer: self.TrainerStatusVariable.set("Trainer not detected") self.RunoffButton.config(state="normal") return else: self.TrainerStatusVariable.set("Trainer detected") trainer.initialise_trainer(dev_trainer) # initialise trainer while runoff_loop_running: # loop every 100ms last_measured_time = time.time() * 1000 # receive data from trainer speed, pedecho, heart_rate, force_index, cadence = trainer.receive( dev_trainer ) # get data from device self.SpeedVariable.set(speed) if speed == "Not found": self.TrainerStatusVariable.set("Check trainer is powered on") # send data to trainer resistance_level = 6 trainer.send(dev_trainer, resistance_level, pedecho) if speed > 40: # speed above 40, start rolldown self.InstructionsVariable.set( "Rolldown timer started - STOP PEDALLING!" ) rolldown = True if speed <= 40 and rolldown: # rolldown timer starts when dips below 40 if rolldown_time == 0: rolldown_time = time.time() # set initial rolldown time self.InstructionsVariable.set( "Rolldown timer started - STOP PEDALLING! %s " % (round((time.time() - rolldown_time), 1)) ) if speed < 0.1 and rolldown: # wheel stopped runoff_loop_running = False # break loop self.InstructionsVariable.set( "Rolldown time = %s seconds (aim 7s)" % round((time.time() - rolldown_time), 1) ) time_to_process_loop = time.time() * 1000 - last_measured_time sleep_time = 0.1 - (time_to_process_loop) / 1000 if sleep_time < 0: sleep_time = 0 time.sleep(sleep_time) self.CalibrateButton.config(state="normal") # if speed > 40 or rolldown == True: # if rolldown_time == 0: # rolldown_time = time.time()#set initial rolldown time # self.InstructionsVariable.set("Rolldown timer started - STOP PEDALLING! %s " % ( round((time.time() - rolldown_time),1) ) ) # rolldown = True # if speed < 0.1:#wheel stopped # running = False#break loop # if time.time() - rolldown_time > 7.5 : # msg = "More pressure from trainer on tyre required" # elif time.time() - rolldown_time < 6.5 : # msg = "Less pressure from trainer on tyre required" # else: # self.CalibrateButton.config(state="normal") # msg = "Pressure on tyre from trainer correct" # self.InstructionsVariable.set("Rolldown time = %s seconds\n%s" % (round((time.time() - rolldown_time),1), msg)) # time_to_process_loop = time.time() * 1000 - last_measured_time # sleep_time = 0.1 - (time_to_process_loop)/1000 # if sleep_time < 0: sleep_time = 0 # time.sleep(sleep_time) self.RunoffButton.config(state="normal") t1 = threading.Thread(target=run) t1.start() def Calibrate(self): def run(): # self.CalibrateButton.config(state="disabled") global dev_ant # find ANT stick self.ANTStatusVariable.set("Looking for ANT dongle") dev_ant, msg = ant.get_ant(False) if not dev_ant: self.ANTStatusVariable.set("ANT dongle not found") return self.ANTStatusVariable.set("Initialising ANT dongle") ant.antreset(dev_ant, False) ant.calibrate(dev_ant, False) # calibrate ANT+ dongle ant.powerdisplay(dev_ant, False) # calibrate as power display self.ANTStatusVariable.set("ANT dongle initialised") self.InstructionsVariable.set( "Place pedals in positions instructed by power meter manufacturer. Calibration will start in 5 seconds" ) time.sleep(5) self.ANTStatusVariable.set("Sending calibration request") ant.send_ant( ["a4 09 4f 00 01 aa ff ff ff ff ff ff 49 00 00"], dev_ant, False ) i = 0 while i < 40: # wait 10 seconds if i % 4 == 0: self.ANTStatusVariable.set( "Sending calibration request %s" % (10 - (i / 4)) ) read_val = ant.read_ant(dev_ant, False) matching = [ s for s in read_val if "a4094f0001" in s ] # calibration response if matching: if matching[0][10:12] == "ac": self.ANTStatusVariable.set("Calibration successful") self.CalibratedVariable.set("True") self.FindHWbutton.config(state="normal") elif matching[0][10:12] == "af": self.ANTStatusVariable.set("Calibration failed") self.CalibratedVariable.set("False") else: self.ANTStatusVariable.set("Unknown calibration response") self.CalibratedVariable.set("False") i = 999 i += 1 time.sleep(0.25) if i == 40: # timeout self.ANTStatusVariable.set("No calibration data received- try again") self.CalibratedVariable.set("False") self.CalibrateButton.config(state="normal") self.InstructionsVariable.set("") t1 = threading.Thread(target=run) t1.start() def ScanForHW(self): # calibration loop def run(): global dev_trainer, dev_ant power = 0 resistance_level = 0 save_data = [] if not dev_trainer: # if trainer not already captured dev_trainer = trainer.get_trainer() if not dev_trainer: self.TrainerStatusVariable.set("Trainer not detected") return else: self.TrainerStatusVariable.set("Trainer detected") trainer.initialise_trainer(dev_trainer) # initialise trainer # find ANT stick if not dev_ant: dev_ant, msg = ant.get_ant(False) if not dev_ant: self.ANTStatusVariable.set(u"no ANT dongle found") return False self.ANTStatusVariable.set(u"ANT dongle found") ant.antreset(dev_ant, False) # reset dongle ant.calibrate(dev_ant, False) # calibrate ANT+ dongle ant.powerdisplay(dev_ant, False) # calibrate as power display iterations = 0 rest = 1 stop_loop = False # ##################DATA LOOP FROM ANT STICK################### while self.StartText.get() == "Stop": # print iterations last_measured_time = time.time() * 1000 if iterations == 240: # inc resistance level every 60s (240 iterations) iterations = 0 rest = 1 # go into rest mode resistance_level += 1 if resistance_level == 14: stop_loop = True if stop_loop: self.StartText.set(u"Start") self.InstructionsVariable.set("Test finished. Please exit") break if rest > 0: rest += 1 self.InstructionsVariable.set( "Rest for %s seconds at a slow spin in an easy gear" % int(round((40 - rest) / 4)) ) if rest == 40: rest = 0 else: iterations += 1 self.InstructionsVariable.set( "Over next %s seconds gradually increase your power from easy to near maximum" % int(round((240 - iterations) / 4)) ) try: read_val = ant.read_ant(dev_ant, False) matching = [ s for s in read_val if "a4094e0010" in s ] # a4094e0010ecff00be4e000010 #10 power page be 4e accumulated power 00 00 iunstant power if matching: power = int(matching[0][22:24], 16) * 256 + int( matching[0][20:22], 16 ) # receive data from trainer speed, pedecho, heart_rate, calc_power, cadence = trainer.receive( dev_trainer ) # get data from device if speed == "Not found": self.TrainerStatusVariable.set("Check trainer is powered on") speed = 0 # send data to trainer trainer.send(dev_trainer, resistance_level, pedecho) self.PowerVariable.set(power) self.SpeedVariable.set(speed) self.ResistanceVariable.set(resistance_level) if rest == 0 and speed > 0: # in calibration mode and moving save_data.append([resistance_level, speed, power]) except usb.core.USBError: # nothing from stick pass time_to_process_loop = time.time() * 1000 - last_measured_time sleep_time = 0.25 - (time_to_process_loop) / 1000 if sleep_time < 0: sleep_time = 0 time.sleep(sleep_time) # ##################END DATA LOOP FROM ANT STICK############### # ant.send(["a4 01 4a 00 ef 00 00"],dev_ant, False)#reset ANT+ dongle with open("calibration.pickle", "wb") as handle: pickle.dump(save_data, handle, protocol=pickle.HIGHEST_PROTOCOL) msg = produce_power_curve_file(save_data) self.InstructionsVariable.set(msg) if self.StartText.get() == "Start": self.StartText.set(u"Stop") t1 = threading.Thread(target=run) t1.start() else: self.StartText.set(u"Start")
class App(Frame): def __init__(self, master=None): self.computing = False self.S = None self.progress_queue = Queue.Queue() self.cancel_event = threading.Event() Frame.__init__(self, master) self.grid() self.master.protocol("WM_DELETE_WINDOW", self.close_handler) w = Label(self,text=" ",fg="red") w.grid(row=0,column=0,pady=10,sticky=W) ## Object parameters w = Label(self,text="Tower parameters:",fg="red") w.grid(row=0,column=1,pady=10,sticky=W) w = Label(self,text="Latitude (deg):") w.grid(row=1,column=1,sticky=W) self.lat_ent = Entry(self,width=36) self.lat_ent.grid(row=1,column=2,sticky=W) self.lat_ent.insert(0, "60") w = Label(self,text="Tower height (m):") w.grid(row=2,column=1,sticky=W) self.height_ent = Entry(self,width=36) self.height_ent.grid(row=2,column=2,sticky=W) self.height_ent.insert(0, "50") w = Label(self,text="Tower diameter (m):") w.grid(row=3,column=1,sticky=W) self.diam_ent = Entry(self,width=36) self.diam_ent.grid(row=3,column=2,sticky=W) self.diam_ent.insert(0, "30") ## Simulation parameters w = Label(self,text="Simulation parameters",fg="red") w.grid(row=4,column=1,pady=10,sticky=SW) w = Label(self,text="Time vector (s):") w.grid(row=5,column=1,sticky=W) self.time_ent = Entry(self,width=36) self.time_ent.grid(row=5,column=2) self.time_ent.insert(0, "arange(0,365*24*3600,10*60)") ## Output parameters w = Label(self,text="Output parameters",fg="red") w.grid(row=6,column=1,pady=10,sticky=SW) w = Label(self,text="East-west grid (m):") w.grid(row=7,column=1,sticky=W) self.gridx_ent = Entry(self,width=36) self.gridx_ent.grid(row=7,column=2) self.gridx_ent.insert(0, "linspace(-4*tower_height,4*tower_height,10)") w = Label(self,text="South-north grid (m):") w.grid(row=8,column=1,sticky=W) self.gridy_ent = Entry(self,width=36) self.gridy_ent.grid(row=8,column=2) self.gridy_ent.insert(0, "linspace(-4*tower_height,4*tower_height,10)") self.compute_btn = Button(self, text="Start computation", width=15, command=self.compute_btn_handler) self.compute_btn.grid(row=9,column=1,pady=10,sticky=E) w = Label(self,text=" ",fg="red") w.grid(row=0,column=3,pady=10,sticky=W) self.periodicCall() def close_handler(self): self.cancel_event.set() self.master.quit() def parse_entries(self): self.phi = 0 self.latitude = float(eval(self.lat_ent.get())) tower_height = float(eval(self.height_ent.get())) self.tower_height = tower_height self.tower_diameter = float(eval(self.diam_ent.get())) self.time_vector = eval(self.time_ent.get()) x = eval(self.gridx_ent.get()) y = eval(self.gridy_ent.get()) X,Y = meshgrid(x,y) self.X = X self.Y = Y def compute_btn_handler(self): if self.computing: self.cancel_event.set() self.thread1.join() self.compute_btn.config(text="Start computation") else: self.cancel_event = threading.Event() self.meter = Meter(self, relief='ridge', bd=3, width=250) self.meter.grid(row=9,column=2) self.parse_entries() self.compute_btn.config(text="Stop computation") self.thread1 = threading.Thread(target=self.worker_thread) self.thread1.start() def periodicCall(self): """ Check every 100 ms if there is something new in the queue. """ while self.progress_queue.qsize(): try: msg = self.progress_queue.get(0) if msg == 1.0: self.meter.set(msg,"Completed successfully") else: self.meter.set(msg) except Queue.Empty: pass if self.computing: self.compute_btn.config(text="Stop computation") else: self.compute_btn.config(text="Start computation") if self.S != None: self.plot_shadow_map() self.S = None self.master.after(100, self.periodicCall) def plot_shadow_map(self): ion() contourf(self.X, self.Y, self.S/3600.,levels=[0.1,5,10,15,30,40,50,100,1e6],cmap=cm.get_cmap(name="gist_heat_r")) clim(0,100) colorbar() CS = contour(self.X, self.Y, self.S/3600.,levels=[0.0001,5,10,15,30,40,50,100],antialiased=True,colors='k') clabel(CS, inline=1, fontsize=8) xlabel('Location west-east (m)') ylabel('Location south-north (m)') show() def worker_thread(self): self.S = None self.computing = True S = shadow.tower_shadow_map(self.phi, \ self.latitude*pi/180., \ self.tower_height, \ self.tower_diameter, \ self.time_vector, \ self.X, \ self.Y, \ self.progress_queue, \ self.cancel_event) self.S = S self.computing = False
class TopLevel(Frame): def __init__(self, parent): Frame.__init__(self, parent, background="gray") self.parent = parent self.init_global_vars() self.init_UI() self.detect_debug_mode() self.set_state_stopped() def init_global_vars(self): self.switch_status = 'none' self.home_result = IntVar() self.move_result = IntVar() self.timer_active = IntVar() self.test_active = False self.test_paused = False self.timer = [0, 0] self.timer_reset_val = [0, 0] #self.active_cycle = 0 #self.active_temp = 'foo' #self.up_motor_res = 2 #self.right_motor_res = 2 self.move_motor_resolution = 2 self.up_full_steps = 3200 self.right_full_steps = 7200 self.debug_mode = False self.event_schedule = [] self.move_total_duration = 0 self.move_direction = '' self.move_started_time = datetime.now() self.pause_time = datetime.now() self.resume_time = datetime.now() self.planned_steps = 0 def init_UI(self): self.parent.title('Liquid Thermal Shock Tester v0.2') self.pack(fill=BOTH, expand=True) options_frame = Frame(self, background='gray', pady=5, padx=5) options_frame.pack(side=LEFT, fill=BOTH, expand=True) options_label = Label(options_frame, text='Test Setup', background='gray', font=('Courier', 22, 'bold'), justify=LEFT) ul_bold_font = Font(options_label, options_label.cget('font')) ul_bold_font.configure(underline=True) options_label.configure(font=ul_bold_font) options_label.pack(anchor=CENTER, side=TOP, padx=5, pady=5) cycles_frame = Frame(options_frame, background='gray', pady=5) cycles_frame.pack(side=TOP, fill=BOTH, expand=True) cycles_label = Label(cycles_frame, text='# of cycles', background='gray', font=('Courier', 12), justify=CENTER) cycles_label.grid(row=0, column=0, rowspan=1, columnspan=2, sticky='news') ul_plain_font = Font(cycles_label, cycles_label.cget('font')) ul_plain_font.configure(underline=True) cycles_label.configure(font=ul_plain_font) self.cycles_select_disp = Label(cycles_frame, text='5', background='white', font=('Courier', 32)) self.cycles_select_disp.grid(row=1, column=0, rowspan=2, columnspan=1, sticky='wens', padx=5, pady=5) self.cycles_increase_button = Button(cycles_frame, text=u'\u25b2', font=('Courier', 18, 'bold'), command=self.cycles_increment) self.cycles_increase_button.grid(row=1, column=1, rowspan=1, columnspan=1, sticky='wens', padx=5, pady=5) self.cycles_decrease_button = Button(cycles_frame, text=u'\u25BC', font=('Courier', 18, 'bold'), command=self.cycles_decrement) self.cycles_decrease_button.grid(row=2, column=1, rowspan=1, columnspan=1, sticky='wens', padx=5, pady=5) self.fix_grid(cycles_frame) soak_time_frame = Frame(options_frame, background='gray', pady=5) soak_time_frame.pack(side=TOP, fill=BOTH, expand=True) soak_time_label = Label(soak_time_frame, text='Minutes per Soak', background='gray', font=('Courier', 12), justify=CENTER) soak_time_label.grid(row=0, column=0, rowspan=1, columnspan=2, sticky='news') soak_time_label.configure(font=ul_plain_font) self.soak_time_disp = Label(soak_time_frame, text='5', background='white', font=('Courier', 32)) self.soak_time_disp.grid(row=1, column=0, rowspan=2, columnspan=1, sticky='wens', padx=5, pady=5) self.soak_time_increment_button = Button( soak_time_frame, text=u'\u25b2', font=('Courier', 18, 'bold'), command=self.soak_time_increment) self.soak_time_increment_button.grid(row=1, column=1, rowspan=1, columnspan=1, sticky='wens', padx=5, pady=5) self.soak_time_decrement_button = Button( soak_time_frame, text=u'\u25BC', font=('Courier', 18, 'bold'), command=self.soak_time_decrement) self.soak_time_decrement_button.grid(row=2, column=1, rowspan=1, columnspan=1, sticky='wens', padx=5, pady=5) self.fix_grid(soak_time_frame) controls_frame = Frame(self, background='gray') controls_frame.pack(side=LEFT, fill=BOTH, expand=True) run_pause_frame = Frame(controls_frame, background='gray') run_pause_frame.pack(side=TOP, fill=BOTH, expand=True, pady=5) self.run_button = Button(run_pause_frame, text='RUN', background='green', activebackground='green', font=('Courier', 30, 'bold'), width=5, command=self.run_init) self.run_button.grid(row=0, column=0, sticky='wens', padx=5, pady=5) self.pause_button = Button(run_pause_frame, text='PAUSE', background='orange', activebackground='orange', font=('Courier', 30, 'bold'), width=5, command=self.pause_button_pressed) self.pause_button.grid(row=0, column=1, sticky='wens', padx=5, pady=5) self.fix_grid(run_pause_frame) stop_button = Button(controls_frame, text='STOP', background='red', activebackground='red', font=('Courier', 36, 'bold'), command=self.stop_test) stop_button.pack(side=TOP, fill=BOTH, expand=True, padx=5) jog_frame = Frame(controls_frame, background='gray') jog_frame.pack(side=TOP, fill=BOTH, expand=True, pady=5) jog_label = Label(jog_frame, text='Motor\rjog', font=('Courier', 12, 'bold'), background='gray') jog_label.grid(row=1, column=1) self.jog_up_button = Button(jog_frame, text=u'\u25b2', font=('Courier', 18, 'bold')) self.jog_up_button.grid(row=0, column=1, rowspan=1, columnspan=1, sticky='wens', padx=5, pady=5) self.jog_up_button.bind("<Button-1>", self.jog_up_on) self.jog_up_button.bind("<ButtonRelease-1>", self.jog_off) self.jog_left_button = Button(jog_frame, text=u'\u25C4', font=('Courier', 18, 'bold')) self.jog_left_button.grid(row=1, column=0, rowspan=1, columnspan=1, sticky='wens', padx=5, pady=5) self.jog_left_button.bind("<Button-1>", self.jog_left_on) self.jog_left_button.bind("<ButtonRelease-1>", self.jog_off) self.jog_right_button = Button(jog_frame, text=u'\u25BA', font=('Courier', 18, 'bold')) self.jog_right_button.grid(row=1, column=2, rowspan=1, columnspan=1, sticky='wens', padx=5, pady=5) self.jog_right_button.bind("<Button-1>", self.jog_right_on) self.jog_right_button.bind("<ButtonRelease-1>", self.jog_off) self.jog_down_button = Button(jog_frame, text=u'\u25BC', font=('Courier', 18, 'bold')) self.jog_down_button.grid(row=2, column=1, rowspan=1, columnspan=1, sticky='wens', padx=5, pady=5) self.jog_down_button.bind("<Button-1>", self.jog_down_on) self.jog_down_button.bind("<ButtonRelease-1>", self.jog_off) self.fix_grid(jog_frame) status_frame = Frame(self, background='gray') status_frame.pack(side=LEFT, fill=BOTH, expand=True, padx=5, pady=5) status_label = Label(status_frame, text='Tester Status', background='gray', font=('Courier', 22, 'bold'), justify=LEFT) status_label.configure(font=ul_bold_font) status_label.pack(anchor=CENTER, side=TOP, padx=5, pady=5) self.status_disp = Text(status_frame) self.status_disp.pack(side=TOP, fill=BOTH, padx=5, pady=5) self.status_disp.configure(state='disabled') self.power_button = Button(status_frame, text='POWER OFF', font=('Courier', 24, 'bold'), background="red", activebackground="red", command=self.shutdown, height=2) self.power_button.pack(side=TOP, fill=BOTH, padx=5, pady=5) def fix_grid(self, target_frame): [columns, rows] = target_frame.grid_size() for i in range(rows): target_frame.rowconfigure(i, weight=1) for j in range(columns): target_frame.columnconfigure(j, weight=1) def detect_debug_mode(self): if str(sys.argv[0]) == 'debug': self.update_status('Tester is in debug mode.', 'newline') self.update_status('', 'newline') self.update_status('The tester will run with a 6 second', 'newline') self.update_status(' soak time regardless of the soak', 'newline') self.update_status(' time selected in the GUI.', 'newline') self.debug_mode = True else: self.update_status('Welcome to the Liquid Thermal Shock', 'newline') self.update_status(' Tester. Select the number of', 'newline') self.update_status(' cycles and the soak time per cycle', 'newline') self.update_status(' to begin testing. Please ensure', 'newline') self.update_status(' that the limit switches are free', 'newline') self.update_status(' from obstructions prior to running', 'newline') self.update_status(' a test.', 'newline') self.debug_mode = False def cycles_increment(self): """ Increments the number of cycles per test. """ str_num_cycles = self.cycles_select_disp.cget('text') num_cycles = int(str_num_cycles) num_cycles += 1 self.cycles_select_disp.configure(text=str(num_cycles)) def cycles_decrement(self): """ Decrements the number of cycles per test. """ str_num_cycles = self.cycles_select_disp.cget('text') num_cycles = int(str_num_cycles) # Check for attempts to set num_cycles < 1. if num_cycles <= 1: self.cycles_select_disp.configure(text=str(num_cycles)) else: num_cycles -= 1 self.cycles_select_disp.configure(text=str(num_cycles)) def soak_time_increment(self): """ Increments the soak time. """ str_soak_time = self.soak_time_disp.cget('text') soak_time = int(str_soak_time) soak_time += 1 self.soak_time_disp.configure(text=str(soak_time)) self.reset_timer() def soak_time_decrement(self): """ Decrements the soak time. """ str_soak_time = self.soak_time_disp.cget('text') soak_time = int(str_soak_time) # Check for attempts to set soak time < 1. if soak_time <= 1: self.soak_time_disp.configure(text=str(soak_time)) else: soak_time -= 1 self.soak_time_disp.configure(text=str(soak_time)) self.reset_timer() def reset_timer(self): """ Resets the timer to whatever is displayed in the soak time window.""" str_soak_time = self.soak_time_disp.cget('text') if self.debug_mode: self.timer = [0, 6] else: self.timer = [int(str_soak_time), 0] # Use line below for tester debugging -- forces a 5 second soak time. # Comment out for normal operations. # self.timer = [0, 5] # Callback functions for manual motor jog def jog_off(self, event): motors_off() def jog_up_on(self, event): jog_motor('up') def jog_down_on(self, event): jog_motor('down') def jog_left_on(self, event): jog_motor('left') def jog_right_on(self, event): jog_motor('right') def shutdown(self): """ Shuts down the tester. """ motors_off() confirm_string = "Do you really want to power down the tester?" confirm = tkMessageBox.askokcancel("Shutdown", confirm_string) if confirm: subprocess.call("sudo poweroff", shell=True) else: pass def update_status(self, new_text, writemode): """ Prints text to the tester status window. """ self.status_disp.configure(state='normal') if writemode == 'overwrite': self.status_disp.delete('end-1c linestart', 'end') self.status_disp.insert('end', '\n' + new_text) self.status_disp.see(END) self.status_disp.configure(state='disabled') def append_event(self, cycle, type, destination, direction, steps, duration): """ Add new event (motor move or temperature soak) to event schedule. """ self.event_schedule.append({ 'Cycle': cycle, 'Event type': type, 'Destination': destination, 'Direction': direction, 'Steps': steps, 'Duration': duration }) def start_homing_move(self, direction): """ Starts the homing procedure in the given direction. """ self.update_status('Finding ' + direction + ' home position...', 'newline') self.status_disp.update() self.home_result.set(0) self.queue = Queue.Queue() Find_Home_Nonblocking(self.queue, direction).start() self.master.after(100, self.process_homing_queue) self.wait_variable(self.home_result) if self.home_result.get() == 0: self.update_status('Homing error. Test aborted.', 'newline') return else: self.update_status( direction.capitalize() + ' home position found.', 'newline') def run_init(self): """ Run button callback. Collects run parameters, creates event schedule, then runs the series of scheduled events. """ self.set_state_running() # Set number of steps for each motor move. Depends on motor resolution # set in static variables section. up_steps = self.up_full_steps * (2**self.move_motor_resolution) right_steps = self.right_full_steps * (2**self.move_motor_resolution) # Get the total number of cycles total_cycles_str = self.cycles_select_disp.cget('text') total_cycles_int = int(total_cycles_str) # Get the soak time in minutes. This is forced to 0.1 minutes when # the GUI is launched in debug mode if self.debug_mode: soak_time_str = '0.1' soak_time_float = 0.1 else: soak_time_str = self.soak_time_disp.cget('text') soak_time_float = float(soak_time_str) # Build event schedule self.event_schedule = [] for i in range(1, total_cycles_int + 1): self.append_event(i, 'move', 'hot', 'down', up_steps, up_steps / 2000.0) self.append_event(i, 'soak', 'hot', '', '', soak_time_float) self.append_event(i, 'move', 'cold', 'up', up_steps, up_steps / 2000.0) self.append_event(i, 'move', 'cold', 'left', right_steps, right_steps / 2000.0) self.append_event(i, 'move', 'cold', 'down', up_steps, up_steps / 2000.0) self.append_event(i, 'soak', 'cold', '', '', soak_time_float) self.append_event(i, 'move', 'hot', 'up', up_steps, up_steps / 2000.0) self.append_event(i, 'move', 'hot', 'right', right_steps, right_steps / 2000.0) # Set the destination to 'complete' for the final 'up' and 'right' moves. # Edit the 'Steps' parameter of the final move to end the test in the # center of the rail. self.event_schedule[-2]['Destination'] = 'complete' self.event_schedule[-1]['Destination'] = 'complete' self.event_schedule[-1]['Steps'] = right_steps / 2 self.event_schedule[-1][ 'Duration'] = self.event_schedule[-1]['Steps'] / 2000.0 self.test_active = True # Print initial runtime message to status window if soak_time_float == 1.0: soak_time_out = '1 minute' else: soak_time_out = soak_time_str + ' minutes' self.update_status('', 'newline') self.update_status('Test started.', 'newline') out_string = 'The tester will run for ' + total_cycles_str + ' cycles, ' self.update_status(out_string, 'newline') out_string = soak_time_out + ' per cycle.' self.update_status(out_string, 'newline') if self.test_active == True: self.start_homing_move('up') if self.test_active == True and self.home_result.get() == 1: self.start_homing_move('right') if self.test_active == True and self.home_result.get() == 1: self.update_status('Moving to hot position...', 'newline') self.run_scheduled_events() def run_scheduled_events(self): """ Runs the series of events listed in self.event_schedule. """ if self.test_active == True: current_event = self.event_schedule.pop(0) if current_event['Event type'] == 'soak': self.set_state_running() self.reset_timer() cycle = str(current_event['Cycle']) temperature = current_event['Destination'] self.timer_active.set(1) self.countdown_timer(cycle, temperature) self.wait_variable(self.timer_active) elif current_event['Event type'] == 'move': if current_event['Direction'] == 'up': self.set_state_running() if current_event['Destination'] == 'complete': out_string = 'Test complete, moving to neutral ' out_string += ' position...' self.update_status(out_string, 'newline') else: out_string = 'Moving to ' + current_event['Destination'] out_string += ' position...' self.update_status(out_string, 'newline') elif current_event['Direction'] == 'down': self.set_state_running() else: self.pause_button.config(state='normal') self.move_direction = current_event['Direction'] self.move_total_duration = current_event['Duration'] self.planned_steps = current_event['Steps'] #self.move_result.set(0) self.queue = Queue.Queue() self.move_started_time = datetime.now() Move_Motor_Nonblocking(self.queue, current_event['Direction'], self.move_motor_resolution, current_event['Steps']).start() self.master.after(100, self.process_move_queue) self.wait_variable(self.move_result) motors_off() # If there are any events left in the schedule, run the next scheduled # event. If there are no events left in the schedule and the last event # was a completed move, then the test is complete and this function should # output the 'test complete' message. If there are no events in the schedule # and the last event was not a completed move, then the test is paused and # this function should do nothing else. if self.event_schedule: self.after(1000, self.run_scheduled_events) elif self.move_result.get() == 1: self.update_status('Test complete.', 'overwrite') self.set_state_stopped() else: pass def set_state_running(self): """ Deactivates cycle time select, soak time select, motor jog and power off buttons. This is to stop users from changing test parameters during a running test, which could result in some difficult to handle undefined states. """ self.cycles_increase_button.config(state='disabled') self.cycles_decrease_button.config(state='disabled') self.soak_time_increment_button.config(state='disabled') self.soak_time_decrement_button.config(state='disabled') self.run_button.config(state='disabled') self.jog_up_button.config(state='disabled') self.jog_down_button.config(state='disabled') self.jog_left_button.config(state='disabled') self.jog_right_button.config(state='disabled') self.power_button.config(state='disabled') self.pause_button.config(state='disabled') # This is absurd, but apparently setting a button to 'disabled' does # not actually disable the button event bindings, so binding the buttons # to a 'do_nothing()' function is required. self.jog_up_button.bind("<Button-1>", self.do_nothing) self.jog_up_button.bind("<ButtonRelease-1>", self.do_nothing) self.jog_down_button.bind("<Button-1>", self.do_nothing) self.jog_down_button.bind("<ButtonRelease-1>", self.do_nothing) self.jog_left_button.bind("<Button-1>", self.do_nothing) self.jog_left_button.bind("<ButtonRelease-1>", self.do_nothing) self.jog_right_button.bind("<Button-1>", self.do_nothing) self.jog_right_button.bind("<ButtonRelease-1>", self.do_nothing) def set_state_stopped(self): """ Reactivates all of the buttons deactivated in the set_state_running function. """ self.test_active = False self.test_paused = False self.cycles_increase_button.config(state='normal') self.cycles_decrease_button.config(state='normal') self.soak_time_increment_button.config(state='normal') self.soak_time_decrement_button.config(state='normal') self.run_button.config(state='normal') self.jog_up_button.config(state='normal') self.jog_down_button.config(state='normal') self.jog_left_button.config(state='normal') self.jog_right_button.config(state='normal') self.power_button.config(state='normal') self.pause_button.config(state='disabled') self.pause_button.config(text='PAUSE', background='orange', activebackground='orange') self.jog_up_button.bind("<Button-1>", self.jog_up_on) self.jog_up_button.bind("<ButtonRelease-1>", self.jog_off) self.jog_down_button.bind("<Button-1>", self.jog_down_on) self.jog_down_button.bind("<ButtonRelease-1>", self.jog_off) self.jog_left_button.bind("<Button-1>", self.jog_left_on) self.jog_left_button.bind("<ButtonRelease-1>", self.jog_off) self.jog_right_button.bind("<Button-1>", self.jog_right_on) self.jog_right_button.bind("<ButtonRelease-1>", self.jog_off) def do_nothing(self, event): """ Does absolutely nothing. This is a workaround for the fact that button event bindings are not disabled when a button's state is set to 'disabled'. """ pass def pause_timer(self): """ Displays the running duration of a test pause. """ if self.test_paused: timer_string = '{0:1d}:{1:02d}'.format(self.timer[0], self.timer[1]) out_string = 'Test paused for ' + timer_string self.update_status(out_string, 'overwrite') self.timer[1] += 1 if self.timer[1] >= 60: self.timer[0] += 1 self.timer[1] -= 60 self.after(1000, self.pause_timer) def countdown_timer(self, cycle, temperature): """ Displays countdown timer and current cycle number/temperature information in status window. This function will only process if the timer_active flag is set to 1. The function will then recursively call itself after a 1 second wait until the timer_active flag is set to zero. The timing is not precise because it will wait 1 full second between function calls, and therefore does not take into account the time necessary to process the function itself. However, over a typical soak time this will only amount to milliseconds, so it's certainly close enough for this application. """ if self.timer_active.get() == 1: timer_string = '{0:1d}:{1:02d}'.format(self.timer[0], self.timer[1]) out_string = 'Cycle ' + cycle + ' of ' out_string += self.cycles_select_disp.cget('text') + ', ' out_string += temperature + '. ' + timer_string + ' remaining.' self.update_status(out_string, 'overwrite') # Decrement 1 second from timer. If this flips the seconds to a # negative value, decrement 1 minute and add 60 seconds self.timer[1] -= 1 if self.timer[1] < 0: # If timer is run down to zero, display soak complete message # and set timer_active flag to zero. if self.timer[0] <= 0: out_string = 'Cycle ' + cycle + ' of ' out_string += self.cycles_select_disp.cget('text') + ', ' out_string += temperature + ' complete.' self.update_status(out_string, 'overwrite') self.timer_active.set(0) else: self.timer[0] -= 1 self.timer[1] += 60 # Have the countdown_timer function recursively call itself # after 1000ms. self.after(1000, self.countdown_timer, cycle, temperature) def stop_test(self): """ Stop button callback. Allows user to abort test sequence. """ # Clear event schedule and toggle home and move result monitoring # variables. This helps prevent errors on restart motors_off() self.event_schedule = [] self.home_result.set(0) self.move_result.set(0) if self.test_active: self.update_status('Test stopped by user.', 'newline') self.test_active = False # Stop and reset timer, reactivate buttons (in case the test # needs to be restarted). self.timer_active.set(0) self.reset_timer() self.set_state_stopped() def pause_button_pressed(self): """ Pause button callback. """ if self.test_paused: self.test_paused = False self.resume_test() else: self.test_paused = True self.timer = [0, 0] self.pause_test() def pause_test(self): """ Pauses a running test """ motors_off() self.pause_time = datetime.now() self.pause_button.config(text='RESUME', background='green', activebackground='green') self.resume_schedule = self.event_schedule self.event_schedule = [] self.move_result.set(0) pause_delta = self.pause_time - self.move_started_time pause_delta_seconds = float(pause_delta.seconds) pause_delta_seconds += pause_delta.microseconds / 1000000.0 steps_prepause = int(pause_delta_seconds * 2000) steps_remaining = self.planned_steps - steps_prepause move_time_remaining = self.move_total_duration - pause_delta_seconds resume_event = { 'Cycle': '', 'Event type': 'move', 'Destination': '', 'Direction': self.move_direction, 'Steps': steps_remaining, 'Duration': move_time_remaining } self.resume_schedule.insert(0, resume_event) self.update_status('', 'newline') self.pause_timer() def resume_test(self): """ Resumes a paused test """ self.pause_button.config(text='PAUSE', background='orange', activebackground='orange') self.resume_time = datetime.now() self.event_schedule = self.resume_schedule pause_duration = self.resume_time - self.pause_time pause_duration_seconds = float(pause_duration.seconds) pause_duration_seconds += pause_duration.microseconds / 1000000.0 self.test_active = True self.update_status('Test resumed.', 'newline') self.run_scheduled_events() def process_homing_queue(self): """ Checks if homing function has returned a value. """ # Try to read the first value in the queue. If nothing is there, then # the homing function has not yet returned a value and must still be # active. In this case, the function recursively calls itself after # 100ms. If there is something in the queue, the value is read into # the self.home_result variable and the function is not called again. try: self.home_result.set(self.queue.get(0)) except Queue.Empty: self.master.after(10, self.process_homing_queue) def process_move_queue(self): """ Checks if motor move queue as returned value. """ # Try to read the first value in the queue. If nothing is there, then # the motor move function has not yet returned a value and must still be # active. In this case, the function recursively calls itself after # 100ms. If there is something in the queue, the value is read into # the self.move_result variable and the function is not called again. try: self.move_result.set(self.queue.get(0)) except Queue.Empty: self.master.after(100, self.process_move_queue)
class GEditor: def __init__(self, parent, gcode, fname): self.textChanged = False self.app = parent self.fname = fname top = self.top = Toplevel(parent) if fname != None: self.top.title(fname) else: self.top.title("Live GCode") self.editBox = Text(top) self.editBox.grid(row=1, column=1, sticky=N+E+W+S) self.sb = Scrollbar(top) self.sb.config(command=self.editBox.yview) self.sb.grid(column=2, row=1, sticky=N+S+E) self.editBox.tag_configure("mymatch",foreground="#ff0000") self.matchStart = None self.matchEnd = None self.editBox.config(yscrollcommand=self.sb.set) self.editBox.delete("1.0", END) for l in gcode: self.editBox.insert(END, l + '\n') self.editBox.mark_set("insert", "1.0") self.editBox.edit_modified(False) self.editBox.bind('<<Modified>>', self.changed) bf = Frame(top) bf.grid(row=2, column=1, columnspan=2) self.bCancel = Button(bf, text='Exit', command=self.doCancel, width=6) self.bCancel.pack(side=LEFT, padx=2, pady=2) self.bSave = Button(bf, text='Save', command=self.doSave, width = 6, state=DISABLED) self.bSave.pack(side=LEFT, padx=2, pady=2) self.bSearch = Button(bf, text="Search", command=self.doSearch, width=6) self.bSearch.pack(side=LEFT, padx=2, pady=2) self.eSearch = Entry(bf, width=30) self.eSearch.pack(side=LEFT, padx=2) self.bReplace = Button(bf, text="Replace", command=self.doReplace, width=6) self.bReplace.pack(side=LEFT, padx=2, pady=2) self.eReplace = Entry(bf, width=30) self.eReplace.pack(side=LEFT, padx=2) self.top.grab_set() self.app.wait_window(self.top) def doCancel(self): if not self.textChanged: self.top.destroy() elif tkMessageBox.askyesno("Cancel?", "Are you sure you want to lose your changes?", parent=self.top): self.top.destroy() def doSave(self): rc = self.app.gEditSave(self.editBox.get("1.0", END).rstrip().split("\n"), self.fname, self.top) if self.fname == None: self.top.destroy() else: if rc: self.editBox.edit_modified(False) self.textChanged = False self.bCancel.config(text="Exit") self.bSave.config(state=DISABLED) def changed(self, evt): if not self.textChanged: self.bSave.config(state=NORMAL) self.bCancel.config(text="Cancel") self.textChanged = True def doSearch(self): sval = self.eSearch.get() if len(sval) == 0: return try: start = self.editBox.index(INSERT + "+1c") except: start = "1.0" pos = self.editBox.search(sval, start, stopindex=END) if not pos: pos = self.editBox.search(sval, "1.0", stopindex=start) if not pos: return e = self.editBox.index(pos + "+%dc" % len(sval)) self.editBox.see(pos) self.editBox.mark_set("insert", pos) if self.matchStart != None: self.editBox.tag_remove("mymatch", self.matchStart, self.matchEnd) self.editBox.tag_add("mymatch", pos, e) self.matchStart = pos self.matchEnd = e self.editBox.focus_force() def doReplace(self): rval = self.eReplace.get() if self.matchStart == None: return self.editBox.delete(self.matchStart, self.matchEnd) self.editBox.insert(self.matchStart, rval) self.editBox.focus_force()
class DirectorySelectButton(object): # %% """ Initializes the DirectorySelectButton. @param fileType string @param openTypes string[] """ def __init__(self, master, frame, directType, width, height, callback=None): self.master = master self.directType = directType self.width = width self.height = height self.button = Button( frame, text="Choose {} Directory".format(self.directType), command=self.callback, width=width, height=self.height) self.directoryName = "" self.extraCallback = callback """ Wrapper function for self.button.grid. """ def grid(self, **args): self.button.grid(**args) """ Sets the state of the button. """ def setState(self, state): self.button.config(state = state) # %% """ Callback for the button. Gets the directoryName from user with tkFileDialog. Updates the display to reflect directory choice. """ def callback(self): directoryName = tkFileDialog.askdirectory(initialdir=self.master.lastFileLoc, \ title = "Select {} File".format(self.directType)) if directoryName == "": return self.directoryName = directoryName self.master.lastFileLoc = self.directoryName #update the Gui directoryRoots = self.directoryName.split("/") displayDirectory = str() while(len(directoryRoots) != 0): currentLine = directoryRoots.pop(0) if len(directoryRoots) != 0: while(len(currentLine) + len(directoryRoots[0]) < self.width): currentLine = "{}\\{}".format(currentLine, directoryRoots.pop(0)) if len(directoryRoots) == 0: break displayDirectory = "{}{}".format(displayDirectory, currentLine) self.button.config( text="{}: {}".format(self.directType, displayDirectory), anchor='w') if self.extraCallback != None: self.extraCallback()
class Application(Frame): def __init__(self, master=None): Frame.__init__(self, master) self.padx = 3 self.pady = 3 self.grid() self.results = [] self.playlists = [] self.vids = [] self.__createWidgets() def __createWidgets(self): self.__searchFields() self.__resultArea() self.__buttons() self.__markdownArea() self.bind('<Return>', self.search_button) def __buttons(self): self.resultSelect = Button(text='OK', state=DISABLED) self.resultSelect.grid(row=5, column=4, sticky=E, padx=self.padx, pady=self.pady) self.status = Label(text="", bd=1, relief=SUNKEN, anchor=W) self.status.grid(row=9, column=0, columnspan=10, sticky=N + E + S + W) self.__vidButtons() self.__rmVidButtons() self.resultSelect.grid_forget() def __searchFields(self): Label(text="User", anchor=E).grid(row=0, column=0, padx=self.padx, pady=self.pady, sticky=W) self.user_entry = Entry() self.user_entry.grid(row=0, column=1, padx=self.padx, pady=self.pady, sticky=W) Label(text="Search terms").grid(row=0, column=3, padx=self.padx, pady=self.pady, sticky=W) self.search_terms = Entry() self.search_terms.grid(row=0, column=4, padx=self.padx, pady=self.pady, sticky=W) Label(text="playlist id").grid(row=1, column=3, padx=self.padx, pady=self.pady, sticky=W) self.playlist_id = Entry() self.playlist_id.grid(row=1, column=4, padx=self.padx, pady=self.pady, sticky=W) self.search_button = Button(text="Search", command=self.__search) self.search_button.grid(row=2, column=4, padx=self.padx, pady=self.pady, sticky=E) def __resultArea(self): self.result_label = Label(text="Results") self.result_label.grid(row=2, column=0, padx=self.padx, pady=self.pady, sticky=W) self.resultshowbut = Button(text="View", command=self.__showResults) self.resultshowbut.grid(row=2, column=1, sticky=W) self.yScroll = Scrollbar(orient=VERTICAL) self.xScroll = Scrollbar(orient=HORIZONTAL) self.listbox = Listbox(xscrollcommand=self.xScroll.set, yscrollcommand=self.yScroll.set, selectmode=SINGLE) self.xScroll.config(command=self.listbox.xview) self.yScroll.config(command=self.listbox.yview) def __showResults(self): self.resultshowbut.config(text="Hide", command=self.__hideResults) self.yScroll.grid(row=3, column=5, sticky=N + S) self.xScroll.grid(row=4, column=0, sticky=E + W, columnspan=5) self.listbox.grid(row=3, column=0, sticky=N + S + E + W, columnspan=5) self.markdownarea.config(height=10) def __hideResults(self): self.resultshowbut.config(text="View", command=self.__showResults) self.yScroll.grid_forget() self.xScroll.grid_forget() self.listbox.grid_forget() self.markdownarea.config(height=30) def __markdownArea(self): self.markdownlabel = Label(text="Markdown") self.mdyScroll = Scrollbar(orient=VERTICAL) self.mdxScroll = Scrollbar(orient=HORIZONTAL) self.markdownarea = Text(wrap=WORD, height=10, yscrollcommand=self.mdyScroll.set, xscrollcommand=self.mdxScroll.set) self.copymarkdown = Button(text="Copy To Clipboard", command=self.__copyMarkdown) self.mdxScroll.config(command=self.markdownarea.xview) self.mdyScroll.config(command=self.markdownarea.yview) def __vidButtons(self): self.modtitle = Button(text='Modify titles', command=self.__modTitles) #self.modtitle.grid(row=5, column=0, sticky=W, columnspan=2, # padx=self.padx, pady=self.pady) self.getcaps = Button(text="Get captions", command=self.__getCaptions) self.getcaps.grid(row=5, column=2, columnspan=3, sticky=E, padx=self.padx, pady=self.pady) def __rmVidButtons(self): self.modtitle.grid_remove() self.getcaps.grid_remove() self.bind('<Return>', self.search_button) def __search(self): user = self.user_entry.get() playlist = self.playlist_id.get() searchterms = self.search_terms.get() self.__showResults() self.resultSelect.config(state=DISABLED) self.__rmVidButtons() self.__rmMarkdown() if not self.__validparams(user, searchterms, playlist): return False if len(playlist) > 0: self.__searchPlaylist(playlist) return self.__searchUser(user, searchterms) def __showMarkdown(self): self.markdownlabel.grid(row=5, column=0, padx=self.padx, pady=self.pady, sticky=W) self.markdownarea.grid(row=6, column=0, columnspan=5, padx=self.padx, pady=self.pady, sticky=N + S + E + W) self.mdyScroll.grid(row=6, column=5, sticky=N + S) self.mdxScroll.grid(row=7, column=0, sticky=E + W, columnspan=5) self.copymarkdown.grid(row=8, column=2, columnspan=3, sticky=E, padx=self.padx, pady=self.pady) def __rmMarkdown(self): self.markdownarea.grid_forget() self.markdownlabel.grid_forget() self.copymarkdown.grid_forget() self.mdyScroll.grid_forget() self.mdxScroll.grid_forget() def __searchPlaylist(self, playlistid): self.__getvids(playlistid) def __searchUser(self, user, searchterms): self.listbox.delete(0, END) self.__status("Searching for%splaylists by user \"%s\"" % ( " \"%s\" " % searchterms if len(searchterms) else " ", user)) self.playlists = [] try: self.playlists = lib.yt.search.PlaylistSearch(user=user, search=searchterms).query() except HTTPError: self.__status("User %s does not exist at youtube" % user) return if self.playlists is None or len(self.playlists) == 0: self.__status("Search returned no results") return self.__populateResults([v['title'] for v in self.playlists]) self.resultSelect.config(command=self.__getVidsFromSelected, state=NORMAL) self.__status("") self.resultSelect.grid(row=5, column=4, sticky=E, padx=self.padx, pady=self.pady) def __populateResults(self, values): self.listbox.delete(0, END) for i, val in enumerate(values): self.listbox.insert(i, val) self.listbox.activate(0) self.listbox.selection_set(0) def __getVidsFromSelected(self): selected = int(self.listbox.curselection()[0]) self.__getvids(self.playlists[selected]['id']) def __getvids(self, playlistid): self.playlist_id.delete(0, END) self.playlist_id.insert(0, playlistid) self.resultSelect.grid_forget() title = playlistid if len(self.playlists) > 0: for playlist in self.playlists: if playlist['id'] == playlistid: title = playlist['title'] break self.__status("Getting videos for %s" % title) self.listbox.delete(0, END) try: self.vids = lib.yt.search.PlaylistVideoSearch( id=playlistid).query() self.__populateResults([v['title'] for v in self.vids]) self.__status("%d Videos found" % len(self.vids)) self.__vidButtons() self.bind('<Return>', self.getcaps) except HTTPError: self.__status("No videos found! is %s a valid playlist?" % playlistid) def __status(self, msg): if len(msg) > 75: msg = msg[:70] + '...' self.status.config(text=msg) self.status.update_idletasks() def __trackSelect(self, vid, tracks, preftrack=None): pref = self.__prefAvailable(preftrack, tracks) if pref is None: sel = lib.trackSelect.TrackSelect(self, vid=vid, tracks=tracks) if sel.result is None: self.__status("skipped") tracks = None else: tracks = [sel.result[0]] if sel.preflang is not None: preftrack['lang'] = sel.preflang if sel.prefname is not None: preftrack['name'] = sel.prefname else: tracks = pref return tracks, preftrack def __getCaptions(self): preftrack = {'name': None, 'lang': None} self.listbox.delete(0, END) self.markdownarea.delete(1.0, END) self.__showMarkdown() for i, vid in enumerate(self.vids): nocapmsg = '[%02d] --NO CAPTIONS-- %s' % (i + 1, vid['title']) tracks = lib.yt.search.CaptionSearch(id=vid['id']).query() self.vids[i]['text'] = '' if len(tracks) == 0: self.__status('No captions available for %s' % self.vids[i]['title']) self.listbox.insert(END, nocapmsg) elif len(tracks) > 1: sel = self.__trackSelect(vid, tracks, preftrack) if sel[0] is None: msg = '[%02d] --SKIPPED-- %s' % (i + 1, vid['title']) self.listbox.insert(END, msg) self.listbox.see(END) continue tracks = sel[0] if len(tracks) == 1: self.__trackCaps(i, tracks, nocapmsg) self.__status('') self.__hideResults() def __trackCaps(self, vidIndex, tracks, nocapmsg): i = vidIndex vid = self.vids[i] msg = '%02d of %02d Getting captions for %s' % ( i + 1, len(self.vids), self.vids[i]['title']) self.__status(msg) self.listbox.insert(END, msg) self.vids[i]['text'] = lib.markdown.heading(vid['title']) captions = lib.yt.search.GetCaptions(id=vid['id'], lang=tracks[0]['lang'], name=tracks[0]['name']) captions.query() captiontext = captions.textOnly() sleep(0.2) msg = nocapmsg if captiontext is not None and len(captiontext) > 0: self.vids[i]['text'] += (lib.markdown.to_utf8(captiontext) + '\n\n') msg = '[%02d] --DONE-- %s' % (i + 1, vid['title']) self.listbox.delete(END, END) self.listbox.insert(END, msg) self.listbox.see(END) self.markdownarea.insert(END, self.vids[i]['text']) self.markdownarea.see(END) def __prefAvailable(self, preftrack, tracks): if preftrack['lang'] is None: return None pref = None for track in tracks: if (track['lang'] == preftrack['lang'] and track['name'] == preftrack['name']): return [track] if track['lang'] == preftrack['lang'] and pref is None: pref = [track] return pref def __modTitles(self): pass def __validparams(self, user, searchterms, playlist): if len(user) == 0 and len(playlist) == 0: msg = "Either a valid youtube user or playlist id must be given." tkMessageBox.showwarning("missing information", msg) return False if len(user) > 0 and not self.__validstring(user): msg = "The user given contains invalid characters" tkMessageBox.showwarning('Bad user', msg) return False if len(playlist) > 0 and not self.__validstring(playlist): msg = "The playlist given contains invalid characters" tkMessageBox.showwarning('Bad playlist', msg) return False if len(searchterms) > 0 and not self.__validstring(searchterms, True): msg = "The search terms given contain invalid characters" tkMessageBox.showwarning('Bad search', msg) return False return True def __validstring(self, s, spacechar=False): validchars = string.letters + string.digits + string.punctuation if spacechar: validchars += ' ' for c in s: if c not in validchars: return False return True def __copyMarkdown(self): self.markdownarea.clipboard_clear() self.markdownarea.clipboard_append(self.markdownarea.get(1.0, END))
class QRReturnMainWindow(Frame): def __init__(self, master): Frame.__init__(self, master) self.serial_num_internal = StringVar() self.master = master self.results = StringVar() self.__initUi() #=========================================================================== # Initialize and reset GUI #=========================================================================== def __initUi(self): self.master.title('Shine Production') self.pack(fill=BOTH, expand=1) Style().configure("TFrame", background="#333") #Status of Test frame self.status_frame = LabelFrame(self, text='Status', relief=RIDGE, width=800, height=500) self.status_frame.place(x=20, y=20) #QR SERIAL # Frame self.path_frame = LabelFrame(self, text='QR Serial Code', relief=RIDGE, height=60, width=235) self.path_frame.place(x=400, y=550) entry = Entry(self.path_frame, bd=5, textvariable=self.serial_num_internal) entry.place(x=50, y=5) #TEST RESULTS LABEL w = Label(self.status_frame, textvariable=self.results) w.place(x=50, y=50) #START Button self.start_button = Button(self, text="Start", command=self.start, height=4, width=20) self.start_button.place(x=100, y=550) # Initialize the DUT initDUT() def start(self): self.start_button.config(state=DISABLED) self.start_button.update() self.results.set("") self.__setStatusLabel(2) uiText = "" self.results.set(uiText) self.serial_num_internal.set("S123Z12345") serial_num_internal = "S123Z12345" # self.serial_num.set("FL11111111") # serial_num = "FL11111111" print "Serial number (internal): %s" % serial_num_internal # Initialize the Agilent 34461 instr = A34461(AGILENT_BASE_ADDRESS, AGILENT_SUB_ADDRESS) instr.setModeToCurrent() results = executeReturnTestSequence(self.serial_num_internal.get(), instr) # self.parseResults(results) self.__setStatusLabel(results) self.serial_num_internal.set("") self.start_button.config(state=ACTIVE) self.start_button.update() def parseResults(self, results): uiText = '' success = 1 print results if results == -1: success = 3 uiText += "Something wrong with connection to source meter." else: if results[SCAN_FAIL] == 1: success = 0 uiText += "Couldn't find Shine \n" if results[CHECK_FW_FAIL] == 1: success = 0 uiText += "Invalid firmware version. \n" if results[ACCEL_STREAM_FAIL] == 1: success = 0 uiText += "Acceleromete data not correct. \n" if results[SN_DEFAULT_FAIL] == 1: success = 0 uiText += "This serial # is 9876543210.\n" if results[SN_MISMATCH_FAIL] == 1: success = 0 uiText += "Serial # scanned does not match internal (bt) serial #. \n" if results[TIMEOUT_FAIL] == 1: success = 0 uiText += "Bluetooth connection timeout. \n" if results[AVG_CURRENT_FAIL] == 1: success = 0 uiText += "Average operating current falls outside accepted range for this firmware. \n" if results[SN_DUPLICATE_FAIL] == 1: success = 0 uiText += "This Shine is a duplicate serial number. \n" if results[RECENTLY_SYNCED_FAIL] == 1: success = 0 uiText += "A Shine with this SN was synced in the past month. \n" if results[BATTERY_PLOT_FAIL] == 1: success = 0 uiText += "Human determined battery plots failed." if success: uiText = "This Shine is in good condition!\n" self.results.set(uiText) self.__setStatusLabel(success) def __setStatusLabel(self, success): if success == 1: self.status_frame.config(text='SUCCESS', bg=STATUS_OK_COLOR) elif success == 2: self.status_frame.config(text='Status', bg='yellow') elif success == 3: self.status_frame.config(text='Something Wrong', bg='blue') else: self.status_frame.config(text='FAIL', bg=STATUS_ERROR_COLOR) self.update()
class ListPage(BasePage): def __init__(self, parent, controller): BasePage.__init__(self, parent, controller) self.mutex = Lock() def prepare(self): self.deviceList.config(state='normal') self.versionList.config(state='disabled') self.engList.config(state='disabled') self.packageList.config(state='disabled') self.ok.config(state='disabled') self.setData(self.controller.data) self.setDeviceList(self.data.keys()) self.controller.setDefault(self, self.controller.loadOptions()) self.deviceList.focus_force() def printErr(self, message): self.errLog.config(text=message) def setData(self, data): self.data = data def setupView(self, title="Select your flash", data=None): if(data): self.setData(data) self.errLog = Label(self, text="") self.errLog.grid(row=4, column=1, columnspan=3, sticky="NWSE") self.desc = Label(self, text=title, font=TITLE_FONT) self.desc.grid(row=0, column=0, columnspan=2) self.ok = Button(self, text='Next', command=lambda: self. confirm()) self.ok.grid(row=4, column=3, sticky="E") self.ok.config(state="disabled") self.deviceLabel = Label(self, text="Device", font=TITLE_FONT) self.deviceLabel.grid(row=1, column=0) self.deviceList = Listbox(self, exportselection=0) self.deviceList.grid(row=2, column=0) self.deviceList.bind('<<ListboxSelect>>', self.deviceOnSelect) self.deviceList.config(state="disabled") self.versionLabel = Label(self, text="Branch", font=TITLE_FONT) self.versionLabel.grid(row=1, column=1) self.versionList = Listbox(self, exportselection=0) self.versionList.grid(row=2, column=1) self.versionList.bind('<<ListboxSelect>>', self.versionOnSelect) self.versionList.config(state="disabled") self.engLabel = Label(self, text="Build Type", font=TITLE_FONT) self.engLabel.grid(row=1, column=2) self.engList = Listbox(self, exportselection=0) self.engList.grid(row=2, column=2) self.engList.bind('<<ListboxSelect>>', self.engOnSelect) self.engList.config(state="disabled") self.packageLabel = Label( self, text="Gecko/Gaia/Full", font=TITLE_FONT) self.packageLabel.grid(row=1, column=3) self.packageList = Listbox(self, exportselection=0) self.packageList.grid(row=2, column=3) self.packageList.bind('<<ListboxSelect>>', self.packageOnSelect) self.packageList.config(state="disabled") self.bidVar = StringVar() Label(self, text="Build ID").grid(row=3, column=0, sticky='E') self.bidInput = Entry( self, textvariable=self.bidVar, width="30") self.bidInput.grid( row=3, column=1, columnspan=2, sticky="W") self.bidVar.set('latest') # binding unfocus for build id field self.bidInput.bind('<FocusOut>', self.updateBuildId) # binding the Return Key to each componments self.deviceList.bind('<Return>', self.pressReturnKey) self.versionList.bind('<Return>', self.pressReturnKey) self.engList.bind('<Return>', self.pressReturnKey) self.packageList.bind('<Return>', self.pressReturnKey) self.bidInput.bind('<Return>', self.pressReturnKey) self.ok.bind('<Return>', self.pressReturnKey) def selection_all_checked(self): result = False if len(self.deviceList.curselection()) == 0: self.logger.log('Please select device.', status_callback=self.printErr) self.ok.config(state="disabled") self.deviceList.focus_set() elif len(self.versionList.curselection()) == 0: self.logger.log('Please select branch.', status_callback=self.printErr) self.ok.config(state="disabled") self.versionList.focus_set() elif len(self.engList.curselection()) == 0: self.logger.log('Please select user or engineer build.', status_callback=self.printErr) self.ok.config(state="disabled") self.engList.focus_set() elif len(self.packageList.curselection()) == 0: self.logger.log('Please select package to flash.', status_callback=self.printErr) self.ok.config(state="disabled") self.packageList.focus_set() elif len(self.bidVar.get()) == 0: self.logger.log('Please enter build ID to flash or use "latest" to get the newest', status_callback=self.printErr) self.bidVar.set('latest') else: result = True return result def updateBuildId(self, event=None): if len(self.engList.curselection()) != 0: self.refreshPackageList() def pressReturnKey(self, event=None): if self.selection_all_checked(): self.ok.config(state="disabled") self.confirm() def deviceOnSelect(self, evt): self.setVersionList() def versionOnSelect(self, evt): self.setEngList() def engOnSelect(self, evt): self.refreshPackageList() # hard coded right now def packageOnSelect(self, evt): self.ok.config(state="normal") def confirm(self): self.mutex.acquire() try: if self.selection_all_checked(): self.ok.config(state="disabled") params = [] package = self.packageList.get(self.packageList.curselection()[0]) self.logger.log('Start to flash [' + package + '].', status_callback=self.printErr) if(PathParser._IMAGES in package): params.append(PathParser._IMAGES) else: if(PathParser._GAIA in package): params.append(PathParser._GAIA) if(PathParser._GECKO in package): params.append(PathParser._GECKO) self.controller.doFlash(params) self.packageList.select_clear(0, END) self.controller.transition(self) finally: self.mutex.release() def setDeviceList(self, device=[]): self.deviceList.delete(0, END) for li in device: self.deviceList.insert(END, li) def setVersionList(self, version=[]): if len(version) == 0: version = self.data[ self.deviceList.get(self.deviceList.curselection()) ] self.versionList.config(state="normal") self.engList.config(state="disabled") self.packageList.config(state="disabled") self.ok.config(state="disabled") self.versionList.delete(0, END) for li in version: self.versionList.insert(END, li) def setEngList(self, eng=[]): if len(eng) == 0: device = self.deviceList.get(self.deviceList.curselection()) version = self.versionList.get(self.versionList.curselection()) eng = self.data[device][version] self.engList.config(state="normal") self.packageList.config(state="disabled") self.ok.config(state="disabled") self.engList.delete(0, END) for li in eng: self.engList.insert(END, li) def refreshPackageList(self): self.mutex.acquire() try: self.packageList.config(state="normal") self.ok.config(state="normal") self.packageList.delete(0, END) device = self.deviceList.get(self.deviceList.curselection()) version = self.versionList.get(self.versionList.curselection()) eng = self.engList.get(self.engList.curselection()) # if the value is '' or 'latest', the set the build_id option as ''. buildId = '' if (len(self.bidVar.get()) == 0 or self.bidVar.get() == 'latest') else self.bidVar.get() package = self.controller.getPackages(self.data[device][version][eng]['src'], build_id=buildId) if len(package) == 0: package = [PathParser._GAIA_GECKO, PathParser._GAIA, PathParser._GECKO, PathParser._IMAGES] for li in package: self.packageList.insert(END, li) finally: self.mutex.release()
def run_a(): """creates an analysis therad""" abortb.grid(row=20) plotb.grid_forget() run.grid_forget() progressbar.grid(row=21) global runpressed runpressed = True global latestThread latestThread = run_thread() latestThread.setDaemon(True) latestThread.start() run.config(command=run_a) #Function and button to plot results def plotting(): """shows plots on interface""" global listbuttons del listbuttons[:] if histograms == []: plots = glob.glob('Output/*.gif') else: plots = [] for i in range(0, len(histograms)): name = imn.ImageDic[histograms[i]] plots.append(glob.glob('Output/' + name + '.gif')) plots = sum(plots, [])
class Home(Frame): ''' Frame for Home Screen. ''' def __init__(self, master): Frame.__init__(self) self.pack() self.Name = 'Welcome ' + str(myname) self.label_1 = Label(self, text=self.Name, justify=Tkinter.LEFT) self.label_1.grid(row=0, pady=5) self.sync = Button(self, text="DLD Files", command=self.DLD) self.sync.grid(row=1, pady=5) self.pref = Button(self, text="Preferences", command=self.pref) self.pref.grid(row=3, pady=5) self.logout = Button(self, text="Logout", command=self.logout) self.logout.grid(row=4, pady=5) self.stop = Button(self, text="Stop DLD", command=self.stopDLD) self.stop.grid(row=2, pady=5) self.stop.config(state='disabled') #Download automatically on launch if auto_download is True: t.log( "Download automatically started. This can be disabled from preferences" ) self.dld() def nfretrieve(self, url, directory, number): ''' Retrieve from News Forum when passed nfurl i.e forum/view.php Passed arguments forum url, directory, course number (as appearing in Preferences) ''' m.update() global t #array of all discussion urls self.urls = [] #array of all downloadables self.nflinks = [] global downloaded global downloadlinks br.open(url) #Read lines from Preferences. Obtain last visited discussion for course at index=number preferences = open("Preferences", "r") lines = preferences.readlines() lasturl = (lines[7 * number + 6])[:lines[7 * number + 6].index("\n")] preferences.close() #Set flag for checking if any new threads have been created since last run flag = 0 #create an array of all discussion links (self.urls) #Newer threads come first in br.links() for link in br.links( url_regex="http://moodle.iitb.ac.in/mod/forum/discuss.php"): if link.url == lasturl: break #breaking loop once last visited discussion/thread is encountered if link.url not in self.urls: flag = 1 self.urls.append(link.url) #iterating through every discussion for url in self.urls: m.update() br.open(url) #create an array of all downloadables for link in br.links( url_regex="http://moodle.iitb.ac.in/pluginfile.php"): self.nflinks.append(link) #Download all downloadables for link in self.nflinks: if stop_DLD: #Set flag 0 so that newlasturl is not updated, as all new threads may not be downloaded when force killed. flag = 0 break else: m.update() br.open(link.url) url_text = br.geturl() if br.geturl().endswith('forcedownload=1'): url_text = br.geturl()[:-16] file_extension = '.' + url_text.rsplit('.', 1)[-1] file_name = (url_text.rsplit('.', 1)[0]).rsplit('/', 1)[-1] file_name = urllib.unquote_plus(file_name) if file_name.endswith(file_extension): file_name = file_name[:-len(file_extension)] if file_extension in [ '.pdf', '.doc', '.ppt', '.pptx', '.docx', '.xls', '.xlsx', '.cpp', '.h', '.html', '.py', '.css', '.tex', '.java' ]: if not os.path.exists(directory + file_name + file_extension): if not link.url in downloadlinks: t.log('Downloading ' + file_name + file_extension + ' to ' + directory) if not os.path.isdir(directory): os.makedirs(directory) br.retrieve( link.url, directory + file_name + file_extension) downloadlinks.append(link.url) #Find newlasturl (last visited disussion/thread) #(Order of threads is in reverse. i.e Newest first) if flag == 1: newlasturl = self.urls[0] + '\n' #Update Preferences with newlasturl lines[number * 7 + 6] = newlasturl preferences = open("Preferences", "w") preferences.writelines(lines) preferences.close() def retrieve(self, url, directory): ''' Retrieve from course main page Arguments are main page url, directory ''' m.update() global t global downloaded global downloadlinks self.links = [] br.open(url) #Find all links inside given url and form array (self.links) for link in br.links(url_regex='.'): if (not link.url.startswith( 'http://moodle.iitb.ac.in/login/logout.php') and not link.url.startswith(br.geturl()) and not link.url.startswith('#') and not link.url.startswith( 'http://moodle.iitb.ac.in/mod/forum') and not link.url.startswith('http://moodle.iitb.ac.in/my') and not link.url.startswith('http://moodle.iitb.ac.in/user') and not link.url.startswith('http://moodle.iitb.ac.in/badges') and not link.url.startswith( 'http://moodle.iitb.ac.in/calendar') and not link.url.startswith('http://moodle.iitb.ac.in/grade') and not link.url.startswith('http://moodle.iitb.ac.in/message') and link.url not in downloaded): self.links.append(link) #Downlod all downloadables from self.links for link in self.links: if stop_DLD: break else: m.update() br.open(link.url) url_text = br.geturl() if br.geturl().endswith('forcedownload=1'): url_text = br.geturl()[:-16] file_extension = '.' + url_text.rsplit('.', 1)[-1] if file_extension in [ '.pdf', '.doc', '.ppt', '.pptx', '.docx', '.xls', '.xlsx', '.cpp', '.h', '.html', '.py', '.css', '.tex', '.java' ]: file_name = "" if ']' in link.text: file_name = link.text[link.text.index(']') + 1:] else: file_name = link.text if file_name.endswith(file_extension): file_name = file_name[:-len(file_extension)] if not os.path.exists(directory + file_name + file_extension): if not link.url in downloadlinks: t.log('Downloading ' + file_name + file_extension + ' to ' + directory) if not os.path.isdir(directory): os.makedirs(directory) br.retrieve(link.url, directory + file_name + file_extension) downloadlinks.append(link.url) else: #Retrieve from folders if (br.geturl().startswith( 'http://moodle.iitb.ac.in/mod/folder') and link.url not in downloaded and link.text.startswith('[IMG]')): foldername = br.title()[br.title().index(':') + 2:] newpath = directory + foldername if not os.path.exists(newpath): os.makedirs(newpath) t.log('Retrieving from ' + foldername + ' at ' + newpath) downloaded.append(link.url) self.retrieve(link.url, newpath + '/') #Retrieve Assignments if br.geturl().startswith('http://moodle.iitb.ac.in/mod/assign') \ and link.url not in downloaded: downloaded.append(link.url) if directory.endswith("Assignments/"): newpath = directory[:-1] else: newpath = directory + "Assignments" if not os.path.exists(newpath): os.makedirs(newpath) self.retrieve(link.url, newpath + '/') #br.back() self.pack() def stopDLD(self): ''' On click of Stop DLD button ''' global t, stop_DLD t.log('Terminating downloads.') stop_DLD = True def DLD(self): ''' On click of DLD Files button ''' global t, stop_DLD t.log('Downloading files, Please do not close until complete!') self.sync.config(state='disabled') self.pref.config(state='disabled') self.logout.config(state='disabled') self.stop.config(state='normal') urls = [] nfurls = [] directories = [] stop_DLD = False #Open Preferences and call retrieve functions if os.path.exists('Preferences'): file_pref = open('Preferences', 'r') lines = file_pref.readlines() n = len(lines) / 7 if len(lines): for number in range(n): if stop_DLD: break else: urls.append(lines[7 * number + 2][:lines[7 * number + 2].index('\n')]) directories.append(lines[7 * number + 3][:lines[7 * number + 3].index('\n')]) nfurls.append(lines[7 * number + 4][:lines[7 * number + 4].index("\n")]) if (lines[7 * number])[:lines[7 * number].index('\n')] == '1': t.log('Retrieving from ' + lines[7 * number + 1][:lines[7 * number + 1].index('\n')] + ' at ' + directories[number]) self.retrieve(urls[number], directories[number]) t.log("Retrieving from " + lines[7 * number + 1][:lines[7 * number + 1].index("\n")] + " News Forum at " + directories[number] + 'News Forum/') self.nfretrieve( nfurls[number], directories[number] + 'News Forum/', number) t.log("Successfully synced with Moodle!") self.sync.config(state='normal') self.pref.config(state='normal') self.logout.config(state='normal') self.stop.config(state='disabled') #If Preferences does not exist take user to Preferences screen else: t.log('Please set Preferences first!') self.sync.config(state='normal') self.pref.config(state='normal') self.logout.config(state='normal') self.destroy() self.newWindow = Pref_Screen(self.master) def pref(self): ''' On Click Preferences button ''' t.log( "Populating list of courses. This may take a while. Please be patient.." ) m.update() self.destroy() self.newWindow = Pref_Screen(self.master) def logout(self): ''' On Click Logout button ''' lines = ["\n", "\n", "\n", "C:/", "\n", "1", "\n"] if os.path.exists("Cred"): file_cred = open('Cred', 'r') lines = file_cred.readlines() file_cred.close() lines[0] = '\n' lines[1] = '\n' lines[2] = '\n' file_cred = open('Cred', 'w') file_cred.writelines(lines) file_cred.close() t.log('Logout successful!') br.close() self.destroy() self.newWindow = LoginFrame(self.master)
def refreshWidget(self): #print "refresh" self.card_win.pack_forget() #Card window self.card_win = PanedWindow(self.card_win.master, orient=VERTICAL) self.card_win.pack(side=TOP, expand=True, fill=BOTH, pady=2, padx=2) #Create the name zone name_zone = PanedWindow(self.card_win, orient=HORIZONTAL) name = StringVar() name.set(self.name) from deck_creation import blocked_creature def modifName(*args): old = self.name in blocked_creature self.name = name.get() if old or self.name in blocked_creature: self.refreshWidget() name.trace("w", modifName) name_wid = Entry(name_zone, width=30, textvariable=name) name_wid.pack() name_zone.add(name_wid) #Create the cost ad star stringvar #print int(floor(self.getCost())) self.cost = StringVar() self.stars = StringVar() cost_wid = Label(None, textvariable=self.cost, background='red', width=5, anchor=W) star_wid = Label(None, textvariable=self.stars, background='blue', anchor=E) self.cost.set(str(int(floor(self.getCost())))) self.stars.set("*" * self.getStars()) #Add them in name zone name_zone.add(cost_wid) name_zone.add(star_wid) #Create an Image Zone image_zone = Button(self.card_win, command=self.choosePhoto) if hasattr(self, "photofile") and self.photofile: print "Image: ", self.photofile try: img = Image.open(self.photofile) except: decomp = self.photofile.split('/') for i in range(1, 6): try: fname = "/".join(decomp[-i:]) print "try to open", fname img = Image.open(fname) self.photofile = fname break except: self.photofile = None if self.photofile: w, h = img.size if w > 300 or h > 200: img = img.resize((w / 2, h / 2), Image.LINEAR) image_zone.image = ImageTk.PhotoImage(img) image_zone.config(image=image_zone.image) #print "IMAGE CHANGED" else: from os import path fname = self.name.replace(" ", "_") if path.isfile("Cards/" + fname + ".png"): image_zone.config(text='image can be taken from\n' + "Cards/" + fname + ".png", background='white', anchor=CENTER) else: image_zone.config(text='clic to choose image', background='white', anchor=CENTER) image_zone.pack # POWER ZONE power_zone = PanedWindow(self.card_win, orient=VERTICAL) #fenetre=self.card_win.master def removePowerCreator(px): def removePower(*args): #print 'avant',list_pow self.bonus.remove(px) #print 'apres',list_pow #self.card_win.pack_forget() self.refreshWidget() return removePower for p in self.bonus: powline = PanedWindow(self.card_win, orient=HORIZONTAL) pow_wid = p.initWidget(powline) powline.add(pow_wid) removepow = Button(powline, text="X", command=removePowerCreator(p), anchor=E) removepow.pack() powline.add(removepow) power_zone.add(powline) def addPower(*args): name = addBonus.get() print "added :", name import cardPowers self.bonus += [eval('cardPowers.' + name + '()')] self.bonus[-1].parent = self.bonus self.bonus[-1].card = self #self.card_win.pack_forget() self.refreshWidget() #Add bonus Option menu addBonus = StringVar(power_zone) addBonus.set("add bonus") # default value if not self.pv: addBonus_wid = getSpellMenu(power_zone, addBonus) else: addBonus_wid = getBonusMenu(power_zone, addBonus) addBonus.trace('w', addPower) if self.pv > 0 or len(self.bonus) == 0: addBonus_wid.pack() #Add this to power zone power_zone.add(addBonus_wid) #Create save zone save_zone = PanedWindow(self.card_win, orient=HORIZONTAL) lv = int(localopen("progression", "r").read()) if self.monster_type != "all" and not (lv < 8 and self.name in blocked_creature): save_wid = Button(save_zone, text="Save", command=self.postAndSave) elif self.monster_type != "all": save_wid = Button(save_zone, text="creature in campaign", command=None) else: save_wid = Button(save_zone, text="nead type", command=None) save_wid.pack() #Create the open button save_zone.pack() if Card.monster_list.keys(): self.opening = StringVar(save_zone) self.opening.set("Open") choice = Card.monster_list.keys() choice.sort() #print all_monsters.keys() open_wid = OptionMenu(save_zone, self.opening, *choice) self.opening.trace('w', self.Open) open_wid.pack() save_zone.add(open_wid) if Card.monster_list.keys(): self.delete = StringVar(save_zone) self.delete.set("Delete") choice = Card.monster_list.keys() choice.sort() delete_wid = OptionMenu(save_zone, self.delete, *choice) self.delete.trace('w', self.clicDelete) delete_wid.pack() save_zone.add(delete_wid) #Create the type button self.category = StringVar(save_zone) self.category.set(self.monster_type) choice = [ file2name(t, "_monsters.sav") for t in glob.glob("CardFiles/*_monsters.sav") ] if "recup" in choice: choice.remove("recup") #print all_monsters.keys() category_wid = OptionMenu(save_zone, self.category, *choice) self.category.trace('w', self.setFile) category_wid.pack() #Add it to save zone save_zone.add(save_wid) save_zone.add(category_wid) #Create a new Strength zone for att and pv strength_zone = PanedWindow(self.card_win, orient=HORIZONTAL) att = StringVar() att.set(str(self.att)) pv = StringVar() pv.set(str(self.pv)) def modifiedAttPv(*args): print "modifiedAttPv" self.pv = int(pv.get()) if self.pv < 1 and self.is_spell == False: if len(self.bonus) == 0: self.is_spell = True self.refreshWidget() else: self.pv = 1 self.refreshWidget() if self.pv > 0 and self.is_spell == True: if len(self.bonus) == 0: self.is_spell = False self.refreshWidget() else: self.pv = 0 self.refreshWidget() self.att = int(att.get()) self.getCost() att_wid = Spinbox(strength_zone, from_=0, to=1000, textvariable=att, command=modifiedAttPv) att_wid.pack() strength_zone.add(att_wid) strength_zone.add( Label(strength_zone, text=' ', background='white', anchor=CENTER)) pv_wid = Spinbox(strength_zone, from_=0, to=1000, textvariable=pv, command=modifiedAttPv) pv_wid.pack() strength_zone.add(pv_wid) #Put it all in window self.card_win.add(name_zone) self.card_win.add(image_zone) self.card_win.add(power_zone) self.card_win.add(strength_zone) self.card_win.add(save_zone) self.card_win.pack()
class Script_GUI(Frame): ''' Script creation graphical user interface. Since this page was crowding the main in order to neat this is a better place for it ''' def __init__(self, master=None, **options): #if not master and options.get('parent'): # master = options['parent'] self.master = master Frame.__init__(self, master) # Just as an extension self._convertdata_ = self.master._convertdata_ self.im_gear = self.master.im_gear self._container_ = self.master._script_ def createWidgets(self): 'create the script gui' # first header row row = Frame(self) TEXT1 = "\nIn this section you can create scripts " Label(row, text=TEXT1, anchor='w').pack(side='top', padx=2, pady=1) row.pack(side='top', fill='x', padx=5) bottom_hline_deco(self) bottom_hline_deco(self, self.create_main_section) self.build_finalbuttons() def createWidgets_n_pack(self): self.createWidgets() self.pack() def create_main_section(self): '''Section for main input values ''' #===================================================================== ''' Create script section ''' row2fill = Frame(self) row2fill_l = Frame(row2fill) self.s_entry_c = [] _mainpage_ = self._container_['mainpage'] _defvals_ = [ '0.5', '1000', '1000', '300:293', '100', '1000', '-1:1', '1000', '293:300', '100' ] _def_dataname_ = './data.gro2lam' if _mainpage_ <> []: _def_dataname_ = _mainpage_[0] _defvals_ = _mainpage_[1:] _aux_c_ = [row2fill_l, 'Lammps data file to work', _def_dataname_] self.s_entry_c.append(self.master.createfileentry(*_aux_c_)) _entries_ = [ 'Timestep [fs]', '-', 'NVE steps [#ts]', '-', 'NVT steps [#ts]', 'Temperature at start:end [K]', 'Temperature damping [fs]', '-', 'NPT steps [#ts]', 'Presure at start:end [atm]', 'Presure damping [fs]', 'Temperature at start:end [K]', 'Temperature damping [fs]' ] entr_maxlen = int(len(max(_entries_, key=len)) * 2.5 / 3) c = 0 for e in range(len(_entries_)): if _entries_[e] == '-': bottom_hline_deco(row2fill_l) c += 1 else: self.s_entry_c.append( create_entry(row2fill_l, _entries_[e], _defvals_[e - c], entr_maxlen)) row2fill_l.pack(side="left") # ==================== row2fill.pack(side="top", padx=1, pady=5) def build_finalbuttons(self): ''' Final Buttons ''' row = Frame(self) ######## ADVANCED OPTIONS ################# if self._container_['advanced'] == []: # advanced _init_ self._container_['advanced'] = [[], []] self._container_['advanced'][0] = [ '10', 'array', 'lj/cut/coul/long', '8.5', '10', '1.9', 'pppm', '1e-4', '0.0:0.0:0.0', '1', '1', 'aniso', 'No', 'NVE-NVT-NPT-NVT-R', '300' ] self.fcb = Button(row, text='Advanced settings', compound='left', image=self.im_gear, bg='gray86', height=15, width=145, command=self.further_config_script) self.fcb.pack(side='left', padx=10, pady=0) ###### RESTRAIN GROUP ############## self.resb = Button(row, text='Restrain', command=self.config_restrain) self.resb.pack(side='left', padx=10, pady=0) self.b1 = Button( row, text='Create', # height=8, command=self.write_script) self.b1.pack(side='right', padx=2, pady=4) b2 = Button(row, text='Quit', command=self.quit) b2.pack(side='right', padx=20, pady=4) row.pack(side='top', fill='both', padx=5) def write_script(self): print 'Writing the lammps script' _mainpage_ = get_entriesvalue(self.s_entry_c) _flag_ = True # data ok flag _entries_ = [ 'float', 'int', 'int', 'float:', 'float', 'int', 'float:', 'float', 'float:', 'float' ] _flag_ *= self.check_datafile(bool) _flag_ *= min(check_vars(_mainpage_[1:], _entries_)) if _flag_: self._container_['mainpage'] = _mainpage_ _script_setup_ = [ _mainpage_, self._container_['advanced'][0], self._container_['restrain'] ] self.master._script_ = self._container_ _flag_ = write_lammps_input(_script_setup_, self._convertdata_) if _flag_: print_dec_g('Lammps script done!') self.master.swapbody(3) def further_config_script(self): defvals = [] title_txt = ' ' * 3 + '+ Simulation Parameters' instructions = 'Input further simulation parameters' askfor = [ 'Thermo output every [#ts]', 'Atom mapping', 'Pairwise interactions', "L-J/Buck rcutoff [" + u'\u00c5' + "]", "Coulomb rcutoff [" + u'\u00c5' + "]", "Neighbor skin distance [" + u'\u00c5' + "]", 'Long-range solver', 'Long-range relative error', 'Interaction 1-2:1-3:1-4', 'Neighbor delay [#ts]', 'Neighbor update [#ts]', 'Pressure control', 'Force mixing rule', 'Simulation order', 'Velocity creation Temp [K]', ] _pair_style_ = [ 'lj/cut/coul/long', 'lj/cut/coul/cut', 'lj/cut', 'buck/coul/long', 'buck', 'buck/coul/cut', #'lj/cut/tip4p/cut', 'lj/cut/tip4p/long', #'lj/gromacs', 'lj/gromacs/coul/gromacs', 'zero', 'none' ] if self._convertdata_ <> None: buckorlj = int(self._convertdata_['defaults'][0]) if buckorlj == 1: _pair_style_ = _pair_style_[:3] + _pair_style_[-2:] else: _pair_style_ = _pair_style_[3:] self._container_['advanced'][0][2] = _pair_style_[3] _kspace_ = [ 'pppm', 'pppm/cg', 'ewald', 'pppm/disp', 'ewald/disp', #'pppm/tip4p', 'pppm/disp/tip4p' ] _comb_rule_ = ['No', 'geometric', 'arithmetic', 'sixthpower'] self._container_['advanced'][1] = [ '', ['array', 'hash'], _pair_style_, '', '', '', _kspace_, '', '', '', '', ['aniso', 'iso', 'tri'], _comb_rule_, '', '' ] _defvals_ = [] for _ad_ in range(len(self._container_['advanced'][0])): if self._container_['advanced'][1][_ad_] <> '': _def_ = self._container_['advanced'][0][_ad_] _dfli_ = self._container_['advanced'][1][_ad_] _defvals_.append([_def_, _dfli_]) else: _defvals_.append(self._container_['advanced'][0][_ad_]) self.fcb.config(bg='gray70') #, width = 155) #cyan') self.master._aux_ = [] pop = PromptPopUp(master=self.master, title=title_txt, briefing=instructions, entries_txt=askfor, entries_val=_defvals_, width=400, height=565) pop.wait_window() if self.master._aux_ <> []: _advanced_ = self.master._aux_ _entries_ = [ 'int', '', '', 'float', 'float', 'float', '', 'float', 'float::', 'int', 'int', '', '', [list, '-', 'NVE', 'NVT', 'NPT', 'R'], 'float' ] _flag_ = min( check_vars(_advanced_, _entries_, 'Advanced settings not saved!')) if _flag_: self._container_['advanced'][0] = _advanced_ print_dec_g('Advanced settings saved') self.fcb.config(bg='gray86') #, width = 145) def config_restrain(self): title_txt = ' ' * 28 + '+ Restrain Goups' instructions = 'Select the group to restrain' #============ grouping ================ max_index = self.check_datafile() if max_index: _defvals_ = self._container_['restrain'] if _defvals_ == []: g_names = ['all_group'] d_ids = ['{}:{}'.format(1, max_index)] kxyz_c = ['1:xyz'] rest_ens = ['1-2'] #restrained_ensembles ck_init = [0] second_c = None if self._convertdata_ <> None: _mol_niifi_ = self._convertdata_['atomsdata'][1] for mt in range(len(_mol_niifi_)): g_names.append(_mol_niifi_[mt][0]) d_ids.append('{}:{}'.format(*_mol_niifi_[mt][1:])) kxyz_c += ['1:xyz'] rest_ens += ['1-2'] ck_init += [0] else: g_names, d_ids, kxyz_c, rest_ens, ck_init = _defvals_[0] #print g_names,'\n', d_ids,'\n', kxyz_c,'\n', ck_init if _defvals_[1] <> None: second_c = _defvals_[1] else: second_c = None self.resb.config(bg='gray70') #, width = 45) #cyan') self.master._aux_ = [] pop = PromptPopUp_wck( master=self.master, title=title_txt, briefing=instructions, entries_txt=g_names, entries_val=kxyz_c, width=530, #height = 365, range_id=d_ids, res_ens=rest_ens, chck_init=ck_init, extra_but=second_c, ) pop.wait_window() if self.master._aux_ <> []: sim_len = 0 for x in self._container_['advanced'][0][-2].split('-'): if x.strip(' ') <> 'R': sim_len += 1 _res_flag_ = [[], []] _restrain_ = self.master._aux_[:] _, _d_ids, _kxyz_c, _runs_c, _res_flag_[0] = _restrain_[0] if _restrain_[1] <> None: _, au2, au3, au4, au5 = _restrain_[1][:] _restrain_aux = _d_ids + au2 + _kxyz_c + au3 + _runs_c + au4 _res_flag_[1] = au5 else: _restrain_aux = _d_ids + _kxyz_c + _runs_c _multi_ = len(_restrain_aux) / 3 _entries_ = ([['<int:int<', 1, max_index]] * _multi_ + ['float:xyz'] * _multi_ + [['<int-x-int<:0', 1, sim_len]] * _multi_) _aux_ = check_vars(_restrain_aux, _entries_, 'Restrain groups not saved!') #print _aux_ _flag_ = min(_aux_) if _flag_: if max(max(_res_flag_)): self._container_['restrain'] = _restrain_ print_dec_g('Restrain data saved') else: print('Creating 0 groups, Restraining 0 atoms') self.resb.config(bg='gray86') #, width = 45) def check_datafile(self, _bflag_=None): ''' function to get the max atom number also is used in case of no gromacs direct data conversion to somehow make a check if that file is ok ''' max_index = 0 _flag_ = True if self._convertdata_ <> None: max_index = len(self._convertdata_['atomsdata'][0]) else: _filename_ = self.s_entry_c[0].get() try: with open(_filename_, 'r') as indata: for k_line in indata: if not k_line.startswith('#'): line_c = k_line.split() if 'atoms' in line_c: max_index = line_c[0] break except IOError: pop_wrg_1('Data file not found!') print('Try performing a conversion first!') _flag_ = False if _bflag_ <> None: return _flag_ return max_index
class App: def __init__(self, master): self.master = master column0_padx = 24 row_pady = 40 self.imgck = IntVar() self.latck = IntVar() self.lonck = IntVar() self.timeck = IntVar() self.dateck = IntVar() self.datestate = int() self.imgval = StringVar() self.latval = StringVar() self.lonval = StringVar() self.timeval = StringVar() self.dateval = StringVar() self.headerVal = IntVar() self.rbv = IntVar() vcmd = (master.register(self.validate), '%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W') self.entryExif = Entry(master, relief="sunken") self.entryExif.insert(0, "EXIF csv file") self.entryExif.grid(row=0, columnspan=4, sticky='EW', padx=5, pady=10) exifbtn = Button(master, text="OPEN CSV file", command=self.getEXIFfile) exifbtn.grid(row=1, column=0, padx=5, sticky='w') ##added to allow header line self.headerOpt = Checkbutton(master, text="Select if CSV file has header line", variable=self.headerVal) self.headerOpt.grid(row=2, column=0, padx=5, sticky='w') self.entryJPGS = Entry(master, relief="sunken") self.entryJPGS.insert(0, "JPEG folder") self.entryJPGS.grid(row=3, columnspan=4, sticky='EW', padx=5, pady=10) JPGbtn = Button(master, text="OPEN JPEG folder", command=self.getJPEGFolder) JPGbtn.grid(row=4, column=0, padx=5, sticky='w') self.paramFile = Entry(master, relief="sunken") self.paramFile.insert(0, "Param file") self.paramFile.grid(row=5, columnspan=4, sticky='EW', padx=5, pady=10) parambtn = Button(master, text="OPEN PARAM file", command=self.getParamfile) parambtn.grid(row=6, column=0, padx=5, sticky='w') lbl_exiftag = Label(master, text="EXIF tag", wraplength=100, anchor='w', justify='left') lbl_column = Label(master, text="CSV column (zero based)", wraplength=100, anchor='w', justify='left') cbImage = Checkbutton(master, text='Image name', variable=self.imgck, command=self.imgcheck) cbLatitude = Checkbutton(master, text='Latitude', variable=self.latck, command=self.latcheck) cbLongitude = Checkbutton(master, text='Longitude', variable=self.lonck, command=self.loncheck) cbTime = Checkbutton(master, text='GPSTime', variable=self.timeck, command=self.timecheck) cbDate = Checkbutton(master, text='GPSDate', variable=self.dateck, command=self.datecheck) lblText = Label(master, text="Free text fields:") lblArtist = Label(master, text="Artist:") ## lbl_analysis = Label(master, text="Analysis Library") self.entryImage = Entry(master, validate='key', validatecommand=vcmd, width=5, state='disabled') self.entryLat = Entry(master, validate='key', validatecommand=vcmd, width=5, state='disabled') self.entryLon = Entry(master, validate='key', validatecommand=vcmd, width=5, state='disabled') self.entryTime = Entry(master, validate='key', validatecommand=vcmd, width=5, state='disabled') self.entryDate = Entry(master, validate='key', validatecommand=vcmd, width=5, state='disabled') self.entryArtist = Entry(master, width=40) #lbl_testcase_exec.grid(row=0, column=2, padx=20, pady=12, sticky='w') lbl_exiftag.grid(row=7, column=0, padx=20, pady=12, sticky='w') lbl_column.grid(row=7, column=1, padx=10, pady=12, sticky='w') cbImage.grid(row=8, column=0, padx=20, sticky='w') cbLatitude.grid(row=9, column=0, padx=20, sticky='w') cbLongitude.grid(row=10, column=0, padx=20, sticky='w') cbTime.grid(row=11, column=0, padx=20, sticky='w') cbDate.grid(row=12, column=0, padx=20, sticky='w') lblText.grid(row=13, column=0, padx=30, sticky='w') lblArtist.grid(row=14, column=0, padx=20, sticky='w') self.entryImage.grid(row=8, column=1, padx=10, sticky='w') self.entryLat.grid(row=9, column=1, padx=10, sticky='w') self.entryLon.grid(row=10, column=1, padx=10, sticky='w') self.entryTime.grid(row=11, column=1, padx=10, sticky='w') self.entryDate.grid(row=12, column=1, padx=10, sticky='w') lbl_datefmt = Label(master, text="Select date format:", wraplength=500, anchor='w', justify='left') lbl_datefmt.grid(row=12, column=1, padx=50, sticky='w') self.entryArtist.grid(row=14, column=1, padx=10, sticky='w') ## ##added to allow header line ## self.dateOpt1 = Checkbutton(master, text="YYYYMMDD", variable=self.headerVal) ## self.dateOpt1.grid(row=10, column=1, padx=160, sticky='w') ## self.dateOpt2 = Checkbutton(master, text="YYYY:MM:DD", variable=self.headerVal) ## self.dateOpt2.grid(row=10, column=1, padx=260, sticky='w') ## self.dateOpt3 = Checkbutton(master, text="MM/DD/YYYY", variable=self.headerVal) ## self.dateOpt3.grid(row=10, column=1, padx=360, sticky='w') #try radio buttons Radiobutton(master, text="YYYYMMDD", variable=self.rbv, value=1, command=self.rdioInvoke).grid(row=10, column=1, padx=190, sticky='w') Radiobutton(master, text="YYYY:MM:DD", variable=self.rbv, value=2, command=self.rdioInvoke).grid(row=11, column=1, padx=190, sticky='w') Radiobutton(master, text="MM/DD/YYYY", variable=self.rbv, value=3, command=self.rdioInvoke).grid(row=12, column=1, padx=190, sticky='w') Radiobutton(master, text="MM/DD/YY", variable=self.rbv, value=4, command=self.rdioInvoke).grid(row=13, column=1, padx=190, sticky='w') # buttons bottom_frame = Frame(master) bottom_frame.grid(row=30, column=1, columnspan=3, sticky='w') #I had to add the self to the prefix, otherwise my rdioInvoke wouldn't work. #I'm guessing the self is sort of the global aspect. #temporarily commenting this out so I can just test reading the param file self.btn_start = Button(bottom_frame, text="Submit", width=7, command=self.MergeExif) #self.btn_start = Button(bottom_frame, text = "Submit", width=7, command=self.readParamfile) self.btn_start.pack(side='left', pady=20) self.btn_start.config(state='disabled') ## btn_commit = Button(bottom_frame, text="Commit", width=7) ## btn_commit.pack(side='left', padx=80) btn_exit = Button(bottom_frame, text="Exit", width=7, command=self.cbtnClick) btn_exit.pack(side='left', padx=10) def rdioInvoke(self): print "rdioInvoke" self.btn_start.configure(state='normal') def cbtnClick(self): print "close button event handler" self.master.destroy() def imgcheck(self): print "check" if self.imgck.get() == 0: self.entryImage.configure(state='disabled') else: self.entryImage.configure(state='normal') def latcheck(self): print "check" if self.latck.get() == 0: self.entryLat.configure(state='disabled') else: self.entryLat.configure(state='normal') def loncheck(self): print "check" if self.lonck.get() == 0: self.entryLon.configure(state='disabled') else: self.entryLon.configure(state='normal') def timecheck(self): print "check" if self.timeck.get() == 0: self.entryTime.configure(state='disabled') else: self.entryTime.configure(state='normal') def datecheck(self): print "check" if self.dateck.get() == 0: self.entryDate.configure(state='disabled') else: self.entryDate.configure(state='normal') #self.datestate == 1 def validate(self, action, index, value_if_allowed, prior_value, text, validation_type, trigger_type, widget_name): if text in '0123456789': return True else: return False def getEXIFfile(self): EXIFcsvfile = tkFileDialog.askopenfilename(title='Image EXIF CSV file') #need to fix the next line self.entryExif.delete(0, END) if len(EXIFcsvfile) > 0: self.entryExif.insert(0, EXIFcsvfile) def getJPEGFolder(self): #by not specifying an intial directory, it starts where the script is located. JPGfolder = tkFileDialog.askdirectory(title='Pick JPEG folder') #need to clear anything that's there self.entryJPGS.delete(0, END) if len(JPGfolder) > 0: #print "now read JPEG folder %s" % JPGfolder #for entry widget self.entryJPGS.insert(0, JPGfolder) def getParamfile(self): PARAMtxtfile = tkFileDialog.askopenfilename(title='Paramter text file') self.paramFile.delete(0, END) if len(PARAMtxtfile) > 0: self.paramFile.insert(0, PARAMtxtfile) def readParamfile(self): params = self.paramFile.get() inputparams = open(params, "r") allparams = inputparams.read() for cmd3 in allparams.splitlines(): if "-comment" in cmd3: ## print cmd3 ## print " " val3 = cmd3 for cmd4 in allparams.splitlines(): if "-sep" in cmd4: ## print cmd4 ## print " " #return cmd4 val4 = cmd4 for cmd6 in allparams.splitlines(): if "-Caption=" in cmd6: ## print cmd6 ## print " " #return cmd6 val6 = cmd6 for cmd9 in allparams.splitlines(): if "-Caption-Abstract" in cmd9: ## print cmd9 ## print " " #return cmd9 val9 = cmd9 for cmd10 in allparams.splitlines(): if "-ImageDescription=" in cmd10: ## print cmd10 ## print " " #return cmd10 val10 = cmd10 ## print "read params" ## print "val3" ## print val3 return (val3, val4, val6, val9, val10) #self.MergeExif() def MergeExif(self): try: test = self.entryExif.get() print test ## print "date format" ## print str(self.rbv.get()) inputfile = open(test, "r") #print "made it here 1" imgval = int(self.entryImage.get()) #print self.entryImage.get() #print str(imgval) if self.latck.get() <> 0: latval = int(self.entryLat.get()) #print "made it here 1a" if self.lonck.get() <> 0: lonval = int(self.entryLon.get()) print "made it here 1b" if self.timeck.get() <> 0: timeval = int(self.entryTime.get()) print "made it here 1c" if self.dateck.get() <> 0: dateval = int(self.entryDate.get()) print "got date" print str(dateval) print "made it here 2" ##add this if statement to deal with header value if self.headerVal.get() == 1: print "have a header value" line = inputfile.readline() else: print "no header value" print "getting return" ## retcmd3, retcmd4, retcmd6, retcmd9, retcmd10 = self.readParamfile() ## print "just cmd3" ## print retcmd3 allreturns = self.readParamfile() print "allreturns" print allreturns ## print "first return" ## print allreturns[0] while 1: line = inputfile.readline() print "made it here 3" values = str.split(line, ",") ## print line ## print "imgval" ## print imgval ##if extension is included in text file img = values[imgval].strip() ##if extension is NOT included in text file ##img = values[imgval].strip() + '.JPG' vlat = values[latval].strip() vlon = values[lonval].strip() ingpsdate = values[dateval].strip() ## #section to read date formats if self.rbv.get() == 1: vyr = str(ingpsdate)[0:4] vmm = str(ingpsdate)[4:6] vdd = str(ingpsdate)[6:8] vgpsdate = vyr + ":" + vmm + ":" + vdd if self.rbv.get() == 2: vgpsdate = ingpsdate if self.rbv.get() == 3: vmm, vdd, vyr = ingpsdate.split("/") if len(vmm) == 1: vmm = "0" + vmm if len(vdd) == 1: vdd = "0" + vdd vgpsdate = vyr + ":" + vmm + ":" + vdd if self.rbv.get() == 4: vmm, vdd, vyr = ingpsdate.split("/") if len(vmm) == 1: vmm = "0" + vmm if len(vdd) == 1: vdd = "0" + vdd if int(vyr) < 50: vyr = "20" + vyr else: vyr = "19" + vyr vgpsdate = vyr + ":" + vmm + ":" + vdd ## if ingpsdate.find(':')==-1: ## vyr=str(ingpsdate)[0:4] ## vmm=str(ingpsdate)[4:6] #### print ingpsdate #### print "year" #### print vyr #### print "month" #### print vmm ## vdd=ingpsdate[6:8] ## vgpsdate=vyr+":"+vmm+":"+vdd ## else: ## vgpsdate=ingpsdate print vgpsdate vgpstime = values[timeval].strip() imagefolder = self.entryJPGS.get() fullimg = os.path.join(imagefolder, img) fullimg = fullimg.replace('\\', '/') vartist = self.entryArtist.get() vartistquotes = '"' + vartist + '"' ## print str(fullimg) ## print str(vlat) ## print str(vlon) ## print str(vgpsdate) ## print str(vgpstime) if (float(vlat)) > 0: print "latref1" vlatref = 'N' else: print "latref2" vlatref = 'S' if (float(vlon)) > 0: vlonref = 'E' else: vlonref = 'W' ## print str(vlatref) ## print str(vlonref) cmd = "exiftool -GPSDateStamp=" + vgpsdate + " -GPSTimeStamp="+vgpstime+" -GPSLatitude="+vlat+" -GPSLatitudeRef="+ vlatref+\ " -GPSLongitude="+vlon+" -GPSLongitudeRef="+vlonref+" "+ " -Artist=" +vartistquotes +" "+fullimg print cmd #print "made it past first os.system" subprocess.check_call(cmd, shell=True) print "executed" cmd2 = """exiftool -Credit="U.S. Geological Survey" -Contact="[email protected] " """ + fullimg subprocess.check_call(cmd2, shell=True) #jpeg comment print "in command 3 section" cmd3 = allreturns[0] cmd3new = cmd3 + " " + fullimg print cmd3new #print cmd3 #cmd3 = """exiftool -comment="Photo from down-looking camera on the USGS SEABOSS deployed from the R/V Rafael during survey 2012-003-FA (http://woodshole.er.usgs.gov/operations/ia/public_ds_info.php?fa=2012-003-FA). Released as part of publication DOI:10.3133/ds937. " """+ fullimg subprocess.check_call(cmd3new, shell=True) #iptc info #cmd4 = """exiftool -sep ", " -keywords="Barnegat Bay, New Jersey, 2012-003-FA, SEABOSS, sea floor, USGS " """+ fullimg cmd4 = allreturns[1] cmd4new = cmd4 + " " + fullimg #subprocess.check_call(cmd4, shell=True) subprocess.check_call(cmd4new, shell=True) #cmd5 unused and skipped #xmp info #cmd6 = """exiftool -Caption="Photograph of the sea floor in Barnegat Bay, New Jersey from survey 2012-003-FA " """+ fullimg cmd6 = allreturns[2] cmd6new = cmd6 + " " + fullimg #subprocess.check_call(cmd6, shell=True) subprocess.check_call(cmd6new, shell=True) print "did caption" #EXIF info cmd7 = """exiftool -Copyright="Public Domain - please credit U.S. Geological Survey " """ + fullimg subprocess.check_call(cmd7, shell=True) print "did copyright" #iptc info cmd8 = """exiftool -CopyrightNotice="Public Domain - please credit U.S. Geological Survey " """ + fullimg subprocess.check_call(cmd8, shell=True) #iptc info #cmd9 = """exiftool -Caption-Abstract="Photograph of the sea floor in Barnegat Bay, New Jersey from survey 2012-003-FA " """+ fullimg cmd9 = allreturns[3] cmd9new = cmd9 + " " + fullimg #subprocess.check_call(cmd9, shell=True) subprocess.check_call(cmd9new, shell=True) #exif info - software such as Picasso use this as the caption #cmd10 = """exiftool -ImageDescription="Photograph of the sea floor in Barnegat Bay, New Jersey from survey 2012-003-FA " """+ fullimg cmd10 = allreturns[4] cmd10new = cmd10 + " " + fullimg #subprocess.check_call(cmd10, shell=True) subprocess.check_call(cmd10new, shell=True) except: print "booboo maybe?" inputfile.close() print "done"
class view(Tk): def mkStringVar(self, s): R = StringVar() R.set(s) return R def mkLabel(self, f, T, r, c, rs=1, cs=1): if isinstance(T, type(StringVar())): R = Label(f, textvariable=T, relief=GROOVE, borderwidth=2) else: R = Label(f, text=T, relief=GROOVE, borderwidth=2) R.grid(row=r, column=c, rowspan=rs, columnspan=cs, sticky="wens") return R def mkLabelList(self, f, SV, r): R = [] for i in range(len(SV)): R.append(self.mkLabel(f, SV[i], r, i + 1)) return R def mkButton(self, f, t, r, c, rs=1, cs=1): R = Button(f, text=t) R.grid(row=r, column=c, rowspan=rs, columnspan=cs, sticky="wens") return R # ===== HALT et cetera ========================================================= def mkHaltArea(self, f): self.HALTframe = Frame(f) self.HALTframe.config(relief=GROOVE) self.HALTframe.config(borderwidth=2) self.HALTbutton = Button(self.HALTframe, text="HALT", width=10) self.READMEbutton = Button(self.HALTframe, text="README", width=10) self.HALTbutton.config(borderwidth=2, relief=GROOVE, fg="red") self.HALTbutton.config(command=self.quit) self.READMEbutton.config(borderwidth=2, relief=GROOVE, fg="red") self.HALTbutton.pack(side=LEFT, fill=BOTH) self.READMEbutton.pack(side=RIGHT, fill=BOTH) self.HALTframe.grid(row=0, column=9, rowspan=1, columnspan=4, sticky="wens") # ============================================================================== def mkProgramControl(self, f): self.PROGRAMCONTROLframe = Frame(f) self.PROGRAMCONTROLframe.config(relief=GROOVE) self.PROGRAMCONTROLframe.config(borderwidth=2) self.runButton = Button(self.PROGRAMCONTROLframe, text="RUN", width=10) self.runButton.grid(row=0, column=0, sticky="wens", padx=29, pady=7) self.stepButton = Button(self.PROGRAMCONTROLframe, text="STEP", width=10) self.stepButton.grid(row=1, column=0, sticky="wens", padx=29, pady=5) self.noStepButton = Button(self.PROGRAMCONTROLframe, text="NOSTEP", width=10) self.noStepButton.grid(row=2, column=0, sticky="wens", padx=29, pady=7) self.PROGRAMCONTROLframe.grid(row=17, column=11, rowspan=6, columnspan=2, sticky="wens") # ============================================================================== def getPGMfileName(self): options = {'filetypes': [('pgm files', '.pgm')]} f = askopenfilename(**options) g = f.split('/') self.filenameVar.set(g[len(g) - 1]) return f def mkProgramLoad(self, f): self.PROGRAMLOADframe = Frame(f) self.PROGRAMLOADframe.config(relief=GROOVE) self.PROGRAMLOADframe.config(borderwidth=2) self.loadPGMbutton = Button(self.PROGRAMLOADframe, text="Load PGM") self.loadPGMbutton.config(width=14) self.loadPGMbutton.pack(side=LEFT, fill=BOTH, padx=20, pady=5) self.filenameVar = StringVar() self.filenameVar.set("*****.pgm") self.fileNameLabel = Label(self.PROGRAMLOADframe, textvariable=self.filenameVar) self.fileNameLabel.config(relief=GROOVE, borderwidth=2, width=17) self.fileNameLabel.pack(side=RIGHT, fill=BOTH, padx=20, pady=5) self.PROGRAMLOADframe.grid(row=15, column=9, rowspan=2, columnspan=4, sticky="wens") # ============================================================================== def mkMemory(self, f): self.MEMORYframe = Frame(f) self.MEMORYframe.config(relief=GROOVE) self.MEMORYframe.config(borderwidth=2) E = Frame(self.MEMORYframe) self.CLEAR = self.mkButton(E, "ClearMem", 0, 0) self.RANDOM = self.mkButton(E, "RandomMem", 0, 1) self.READ = self.mkButton(E, "ReadMem", 1, 0) self.WRITE = self.mkButton(E, "WriteMem", 1, 1) self.BUSTOMEM = self.mkButton(E, "BusToMem", 2, 0, 1, 2) F = Frame(self.MEMORYframe) for i in Range8: L = Label(F, textvariable=self.MEMORY[i]) L.config(relief=GROOVE, borderwidth=2, bg="black", fg="yellow", height=1) L.grid(row=0, column=i, sticky="wens", ipadx=5) E.pack(side=TOP) F.pack(side=BOTTOM) self.MEMORYframe.grid(row=18, column=9, rowspan=5, columnspan=2, sticky="wens") # ============================================================================== def mkDataBus(self, f): self.DBframe = Frame(f) self.DBframe.config(relief=GROOVE) self.DBframe.config(borderwidth=2, bg="red") self.DBframe.grid(row=0, column=0, rowspan=1, \ columnspan=9, sticky="wens") self.databusLabel = Label(self.DBframe, text="Data\nBus", width=10) self.databusLabel.pack(side=LEFT) self.DATABUSbuttons = [] for i in Range8: b = Button(self.DBframe, textvariable=self.DATABUS[i]) b.pack(side=LEFT, fill=BOTH) self.DATABUSbuttons.append(b) def mkAddressBus(self, f): self.ABframe = Frame(f) self.ABframe.config(relief=GROOVE) self.ABframe.config(borderwidth=2, bg="red") self.ABframe.grid(row=26, column=0, rowspan=1, columnspan=13, sticky="wens") self.AddressBusLabel = Label(self.ABframe, text="Address\nBus", width=12) self.AddressBusLabel.pack(side=LEFT) self.ADDRESSBUSbuttons = [] for i in Range16: b = Button(self.ABframe, textvariable=self.ADDRESSBUS[i]) b.pack(side=LEFT, fill=BOTH, ipadx=2) self.ADDRESSBUSbuttons.append(b) # ============================================================================== def mkALU(self, f): self.ALUframe = Frame(f) self.ALUframe.config(relief=GROOVE) self.ALUframe.config(borderwidth=2) self.mkFunctionChoice(self.ALUframe) self.mkStates(self.ALUframe) self.ALUframe.grid(row=23, column=9, rowspan=3, columnspan=4, sticky="wens") def mkFunctionChoice(self, f): self.FUNCTIONframe = Frame(f) self.FUNCTIONframe.config(relief=GROOVE) self.FUNCTIONframe.config(borderwidth=2) self.F0label = Label(self.FUNCTIONframe, text="F0", borderwidth=2, relief=GROOVE) self.F0label.grid(row=0, column=0, sticky="wens", padx=5) self.F1label = Label(self.FUNCTIONframe, text="F1", borderwidth=2, relief=GROOVE) self.F1label.grid(row=0, column=1, sticky="wens", padx=8) self.F2label = Label(self.FUNCTIONframe, text="F2", borderwidth=2, relief=GROOVE) self.F2label.grid(row=0, column=2, sticky="wens", padx=5) self.FUNCTIONbuttons = [] self.F0button = Button(self.FUNCTIONframe) self.F0button.config(textvariable=self.FUNCTION[0], borderwidth=2, relief=GROOVE) self.F1button = Button(self.FUNCTIONframe) self.F1button.config(textvariable=self.FUNCTION[1], borderwidth=2, relief=GROOVE) self.F2button = Button(self.FUNCTIONframe) self.F2button.config(textvariable=self.FUNCTION[2], borderwidth=2, relief=GROOVE) self.FUNCTIONbuttons.append(self.F0button) self.FUNCTIONbuttons.append(self.F1button) self.FUNCTIONbuttons.append(self.F2button) for i in Range3: self.FUNCTIONbuttons[i].grid(row=1, column=i, sticky="wens", padx=5) self.FUNCTIONframe.pack(side=LEFT, padx=8, pady=3) def mkStates(self, f): self.STATESframe = Frame(f) self.STATESframe.config(relief=GROOVE) self.STATESframe.config(borderwidth=2) self.CARRYtag = Label(self.STATESframe, text=" carry ", borderwidth=2, relief=GROOVE) self.CARRYtag.grid(row=0, column=0, padx=5, pady=2, sticky="wens") self.ZEROtag = Label(self.STATESframe, text=" zero ", borderwidth=2, relief=GROOVE) self.ZEROtag.grid(row=0, column=1, padx=5, pady=1, sticky="wens") self.SIGNtag = Label(self.STATESframe, text=" sign ", borderwidth=2, relief=GROOVE) self.SIGNtag.grid(row=0, column=2, padx=5, pady=2, sticky="wens") self.CARRY = self.mkStringVar("0") self.ZERO = self.mkStringVar("0") self.SIGN = self.mkStringVar("0") self.CARRYlabel = Label(self.STATESframe, textvariable=self.CARRY, borderwidth=2, relief=GROOVE) self.CARRYlabel.grid(row=1, column=0, padx=5, pady=2, sticky="wens") self.ZEROlabel = Label(self.STATESframe, textvariable=self.ZERO, borderwidth=2, relief=GROOVE) self.ZEROlabel.grid(row=1, column=1, padx=5, pady=1, sticky="wens") self.SIGNlabel = Label(self.STATESframe, textvariable=self.SIGN, borderwidth=2, relief=GROOVE) self.SIGNlabel.grid(row=1, column=2, padx=5, pady=2, sticky="wens") self.STATESframe.pack(side=RIGHT, padx=8, pady=3) # ============================================================================== def mkTagLabels(self, f): self.ALabel = self.mkLabel(f, "A", 1, 0) self.BLabel = self.mkLabel(f, "B", 2, 0) self.BLabel.config(bg="black", fg="yellow") self.CLabel = self.mkLabel(f, "C", 3, 0) self.CLabel.config(bg="black", fg="yellow") self.DLabel = self.mkLabel(f, "D", 4, 0) self.M1Label = self.mkLabel(f, "M1", 5, 0) self.M2Label = self.mkLabel(f, "M2", 6, 0) self.XLabel = self.mkLabel(f, "X", 7, 0) self.YLabel = self.mkLabel(f, "Y", 8, 0) self.J1Label = self.mkLabel(f, "J1", 9, 0) self.J2Label = self.mkLabel(f, "J2", 10, 0) self.PC1Label = self.mkLabel(f, "PC1", 11, 0) self.PC2Label = self.mkLabel(f, "PC2", 12, 0) self.Inc1Label = self.mkLabel(f, "Inc1", 13, 0) self.Inc2Label = self.mkLabel(f, "Inc2", 14, 0) self.IncUnit1Label = self.mkLabel(f, "IncUnit1", 15, 0) self.IncUnit2Label = self.mkLabel(f, "IncUnit2", 16, 0) self.InstLabel = self.mkLabel(f, "Inst", 17, 0) self.addLabel = self.mkLabel(f, "ADD", 18, 0) self.incLabel = self.mkLabel(f, "INC", 19, 0) self.andLabel = self.mkLabel(f, "AND", 20, 0) self.orLabel = self.mkLabel(f, "OR", 21, 0) self.xorLabel = self.mkLabel(f, "XOR", 22, 0) self.notLabel = self.mkLabel(f, "NOT", 23, 0) self.shlLabel = self.mkLabel(f, "SHL", 24, 0) self.clrLabel = self.mkLabel(f, "CLR", 25, 0) self.functionTagLabelDictionary = { (0,0,0) : self.addLabel, \ (0,0,1) : self.incLabel, \ (0,1,0) : self.andLabel, \ (0,1,1) : self.orLabel, \ (1,0,0) : self.xorLabel, \ (1,0,1) : self.notLabel, \ (1,1,0) : self.shlLabel, \ (1,1,1) : self.clrLabel \ } for i in self.functionTagLabelDictionary.values(): i.config(bg="black", fg="yellow") # ============================================================================== def mkRegisterStringVars(self): self.FUNCTION = [self.mkStringVar("0") for unused_i in Range3] self.DATABUS = [self.mkStringVar("0") for unused_i in Range8] self.Inst = [self.mkStringVar("0") for unused_i in Range8] self.A = [self.mkStringVar("0") for unused_i in Range8] self.B = [self.mkStringVar("0") for unused_i in Range8] self.C = [self.mkStringVar("0") for unused_i in Range8] self.D = [self.mkStringVar("0") for unused_i in Range8] self.M1 = [self.mkStringVar("0") for unused_i in Range8] self.M2 = [self.mkStringVar("0") for unused_i in Range8] self.X = [self.mkStringVar("0") for unused_i in Range8] self.Y = [self.mkStringVar("0") for unused_i in Range8] self.J1 = [self.mkStringVar("0") for unused_i in Range8] self.J2 = [self.mkStringVar("0") for unused_i in Range8] self.PC1 = [self.mkStringVar("0") for unused_i in Range8] self.PC2 = [self.mkStringVar("0") for unused_i in Range8] self.Inc1 = [self.mkStringVar("0") for unused_i in Range8] self.Inc2 = [self.mkStringVar("0") for unused_i in Range8] self.IncUnit1 = [self.mkStringVar("0") for unused_i in Range8] self.IncUnit2 = [self.mkStringVar("0") for unused_i in Range8] self.Add = [self.mkStringVar("0") for unused_i in Range8] self.Inc = [self.mkStringVar("0") for unused_i in Range8] self.And = [self.mkStringVar("0") for unused_i in Range8] self.Or = [self.mkStringVar("0") for unused_i in Range8] self.Xor = [self.mkStringVar("0") for unused_i in Range8] self.Not = [self.mkStringVar("0") for unused_i in Range8] self.Shl = [self.mkStringVar("0") for unused_i in Range8] self.Clr = [self.mkStringVar("0") for unused_i in Range8] self.ADDRESSBUS = [self.mkStringVar("0") for unused_i in Range16] self.MEMORY = [self.mkStringVar("0") for unused_i in Range8] # ============================================================================== def setRegisterLabelColor(self, L, bc, fc="black"): for i in L: i.config(bg=bc, fg=fc) def mkRegisterLabels(self, f): self.Alabels = self.mkLabelList(f, self.A, 1) self.setRegisterLabelColor(self.Alabels, "gray90") self.Blabels = self.mkLabelList(f, self.B, 2) self.setRegisterLabelColor(self.Blabels, "black", "yellow") self.Clabels = self.mkLabelList(f, self.C, 3) self.setRegisterLabelColor(self.Clabels, "black", "yellow") self.Dlabels = self.mkLabelList(f, self.D, 4) self.setRegisterLabelColor(self.Dlabels, "gray90") self.M1labels = self.mkLabelList(f, self.M1, 5) self.setRegisterLabelColor(self.M1labels, "gray90") self.M2labels = self.mkLabelList(f, self.M2, 6) self.setRegisterLabelColor(self.M2labels, "gray90") self.Xlabels = self.mkLabelList(f, self.X, 7) self.setRegisterLabelColor(self.Xlabels, "gray90") self.Ylabels = self.mkLabelList(f, self.Y, 8) self.setRegisterLabelColor(self.Ylabels, "gray90") self.J1labels = self.mkLabelList(f, self.J1, 9) self.J2labels = self.mkLabelList(f, self.J2, 10) self.PC1labels = self.mkLabelList(f, self.PC1, 11) self.PC2labels = self.mkLabelList(f, self.PC2, 12) self.Inc1labels = self.mkLabelList(f, self.Inc1, 13) self.setRegisterLabelColor(self.Inc1labels, "gray95") self.Inc2labels = self.mkLabelList(f, self.Inc2, 14) self.setRegisterLabelColor(self.Inc2labels, "gray95") self.IncUnit1labels = self.mkLabelList(f, self.IncUnit1, 15) self.setRegisterLabelColor(self.IncUnit1labels, "gray95") self.IncUnit2labels = self.mkLabelList(f, self.IncUnit2, 16) self.setRegisterLabelColor(self.IncUnit2labels, "gray95") self.Instlabels = self.mkLabelList(f, self.Inst, 17) self.addlabels = self.mkLabelList(f, self.Add, 18) self.setRegisterLabelColor(self.addlabels, "black", "red") self.inclabels = self.mkLabelList(f, self.Inc, 19) self.setRegisterLabelColor(self.inclabels, "black", "yellow") self.andlabels = self.mkLabelList(f, self.And, 20) self.setRegisterLabelColor(self.andlabels, "black", "yellow") self.orlabels = self.mkLabelList(f, self.Or, 21) self.setRegisterLabelColor(self.orlabels, "black", "yellow") self.xorlabels = self.mkLabelList(f, self.Xor, 22) self.setRegisterLabelColor(self.xorlabels, "black", "yellow") self.notlabels = self.mkLabelList(f, self.Not, 23) self.setRegisterLabelColor(self.notlabels, "black", "yellow") self.shllabels = self.mkLabelList(f, self.Shl, 24) self.setRegisterLabelColor(self.shllabels, "black", "yellow") self.clrlabels = self.mkLabelList(f, self.Clr, 25) self.setRegisterLabelColor(self.clrlabels, "black", "yellow") self.functionLabelsDictionary = { (0,0,0) : self.addlabels, \ (0,0,1) : self.inclabels, \ (0,1,0) : self.andlabels, \ (0,1,1) : self.orlabels, \ (1,0,0) : self.xorlabels, \ (1,0,1) : self.notlabels, \ (1,1,0) : self.shllabels, \ (1,1,1) : self.clrlabels \ } # ===== Load & Select ========================================================== def mkLoad8Buttons(self, f): self.loadA = self.mkButton(f, "load A", 1, 9, 1, 2) self.loadB = self.mkButton(f, "load B", 2, 9, 1, 2) self.loadC = self.mkButton(f, "load C", 3, 9, 1, 2) self.loadD = self.mkButton(f, "load D", 4, 9, 1, 2) self.loadM1 = self.mkButton(f, "load M1", 5, 9, 1, 2) self.loadM2 = self.mkButton(f, "load M2", 6, 9, 1, 2) self.loadX = self.mkButton(f, "load X", 7, 9) self.loadY = self.mkButton(f, "load Y", 8, 9) self.loadJ1 = self.mkButton(f, "load J1", 9, 9, 1, 2) self.loadJ2 = self.mkButton(f, "load J2", 10, 9, 1, 2) self.loadInst = self.mkButton(f, "load Inst", 17, 9, 1, 2) def mkLoad16Buttons(self, f): self.loadXY = self.mkButton(f, "load XY", 7, 10, 2, 1) self.loadPC = self.mkButton(f, "load PC", 11, 9, 2, 2) self.loadINC = self.mkButton(f, "load INC", 13, 9, 2, 2) def mkSelect8Buttons(self, f): self.selectA = self.mkButton(f, "select A", 1, 11, 1, 2) self.selectB = self.mkButton(f, "select B", 2, 11, 1, 2) self.selectC = self.mkButton(f, "select C", 3, 11, 1, 2) self.selectD = self.mkButton(f, "select D", 4, 11, 1, 2) self.selectM1 = self.mkButton(f, "select M1", 5, 11) self.selectM2 = self.mkButton(f, "select M2", 6, 11) self.selectX = self.mkButton(f, "select X", 7, 11) self.selectY = self.mkButton(f, "select Y", 8, 11) def mkSelect16Buttons(self, f): self.selectM = self.mkButton(f, "select M", 5, 12, 2, 1) self.selectXY = self.mkButton(f, "select XY", 7, 12, 2, 1) self.selectJ = self.mkButton(f, "select J", 9, 11, 2, 2) self.selectPC = self.mkButton(f, "select PC", 11, 11, 2, 2) self.selectINC = self.mkButton(f, "select INC", 13, 11, 2, 2) # ===== System Messages ======================================================== def mkMessageArea(self, f): self.text = Text(f, height=36, width=64) self.text.configure(font=("Courier", 11, "bold"), bg="black", fg="green") self.scroll = Scrollbar(f, command=self.text.yview) self.text.configure(yscrollcommand=self.scroll.set) self.text.pack(side=LEFT, padx=3, pady=2) self.scroll.pack(side=RIGHT, fill=Y, padx=3, pady=2) def addText(self, text): self.text.insert(END, text + "\n") self.text.yview(END) # ===== Initialization ========================================================= def __init__(self): Tk.__init__(self) self.title("Virtual Machine") self.config(bg="blue") self.registers = LabelFrame(self, bg="blue") self.registers.config(relief=GROOVE) self.registers.config(borderwidth=2) self.registers.config(text="Virtual Machine: controls and states") self.registers.config(labelanchor="nw") self.registers.pack(side=LEFT, fill=BOTH) self.mkRegisterStringVars() self.mkTagLabels(self.registers) self.mkDataBus(self.registers) self.mkRegisterLabels(self.registers) self.mkLoad8Buttons(self.registers) self.mkLoad16Buttons(self.registers) self.mkSelect8Buttons(self.registers) self.mkSelect16Buttons(self.registers) self.mkAddressBus(self.registers) self.mkALU(self.registers) self.mkMemory(self.registers) self.mkProgramLoad(self.registers) self.mkProgramControl(self.registers) self.mkHaltArea(self.registers) self.messages = LabelFrame(self, bg="blue") self.messages.config(relief=GROOVE) self.messages.config(borderwidth=2) self.messages.config(text="Virtual Machine: system messages") self.messages.config(labelanchor="nw") self.messages.pack(side=RIGHT, fill=BOTH) self.mkMessageArea(self.messages)
class Conversion(Frame): ''' Script creation graphical user interface. Since this page was crowding the main in order to neat this is a better place for it ''' def __init__(self, master=None, **options): #if not master and options.get('parent'): # master = options['parent'] self.master = master Frame.__init__(self, master) self.im_gear = self.master.im_gear # inner class object container self.objt_c = [] def create_conversion_gui(self): # first header row row = Frame(self) TEXT1= "\nSelect the parameters to perform the conversion: " Label(row, text=TEXT1, anchor='w').pack(side='top', padx=2, pady=10) row.pack( side='top', fill='x', padx=5) bottom_hline_deco(self) # file section #======================= DEFAULTS ========================= ex_files=['./Examples/IONP/Original/SPIO_part-water-em.gro', './Examples/IONP/Original/SPIO_part.top', './Examples/IONP/Original/forcefield.itp', './Examples/IONP/Original/ffoplsaaSI_FE_WATnb.itp', './Examples/IONP/Original/ffoplsaaSI_FE_WATbon.itp' ] #ex_files=['conf.gro','topol.top','forcefield.itp','nb.itp','bon.itp'] _atomstyle_ = 'full' _radio_ = 1 data_cont = self.master._convert_['setup'] if data_cont <> []: ex_files = data_cont[:-2] _atomstyle_ = data_cont[-2] _radio_ = data_cont[-1] fi_txt=['Enter the gro file', 'Enter the top file', 'Enter the forcefield file', 'Enter the non bonded file', 'Enter the bonded file' ] for fi in range( len( ex_files)): self.objt_c.append( self.master.createfileentry( self, fi_txt[fi], ex_files[fi], ) ) bottom_hline_deco( self) bottom_hline_deco( self, self.atomstyle) self.objt_c[-1].set( _atomstyle_) self.sol_buffer = _radio_ bottom_hline_deco( self, self.build_solvation_section) self.objt_c[-1].set( _radio_) # Final Buttons self.build_finalbuttons() def build_solvation_section( self): row = Frame(self) self.radio_part( row, 'Solvation atoms', [' yes',' no']) self.solv_b = Button( row, image= self.im_gear, width = 25, height=23, command= self.config_solvation ) self.solv_b.pack( side='right', padx=0) row.pack( side='top', fill='x', pady=3) def radio_part(self, _s_row_, _text_, _desc_=[''], _vals_=[]): _f_labels = format_dec([_s_row_, _text_])#, _pack_=False) radio_var = IntVar() for d in range( len( _desc_)): label_rb = Radiobutton(_s_row_, width=0, text= _desc_[d] ,variable = radio_var , value= len( _desc_)-1-d ,command = self.solvastuff , anchor='w' ) label_rb.pack(side='left', padx=6) self.objt_c.append( radio_var) def solvastuff(self): '''If this point is reached, some button changed ''' _solvation_ = self.objt_c[-1].get() if self.sol_buffer <> _solvation_: self.sol_buffer = _solvation_ if _solvation_: self.solv_b.configure( state = 'normal') else: pop_wrg_1('You are choosing to not consider solvation.' ,' If some solvent molecules are in the' +' .gro file they will be ignored!', _i_=0) self.solv_b.configure( state = 'disabled') def atomstyle( self): ''' in this case just one, but could be modified to be generic, accepting <row>, <text> and <options>''' a_mainrow= Frame( self) row_fst = Frame( a_mainrow) #from self-ttk import Combobox TEXT2= 'Choose an atom style' format_dec([row_fst, TEXT2]) row_fsep = Frame(row_fst) atom_var = StringVar() atom_style_ddl = Drop_Down_List(row_fsep, textvariable = atom_var, #state="readonly" ) atom_style_ddl['values'] = ('full', 'charge', 'molecular', 'angle', 'bond','atomic') atom_style_ddl.bind("<Key>", lambda e: "break") # Magic atom_style_ddl.pack() self.objt_c.append( atom_var) row_fsep.pack(side='left', fill='x', pady=0) # row packing row_fst.pack(side='left', pady=0) a_mainrow.pack(side='top', fill='x', pady=3) def build_finalbuttons(self): Frame(self).pack(side="top", fill='x', pady=20) # Space _row_= self self.b1 = Button(_row_, text='Convert', command = self.getdata_and_convert) self.b1.pack( side = 'right', padx=30, pady=15) b2 = Button(_row_, text = 'Quit', command = self.quit) b2.pack( side = 'right', padx=10, pady=4) def getdata_and_convert(self): _solvatedinfo_ = self.master._convert_['solvation'] if ( self.objt_c[-1].get() and _solvatedinfo_ == []): pop_wrg_1( 'First perform the solvation configuration.' + ' You can do it pressing in solvation settings gears', _i_=0 ) self.solv_b.invoke() elif self.get_entriesvalues(): data_cont = self.master._convert_['setup'] config = data_cont[-2:]+[0] sim_data, flag_done_ = extract_gromacs_data(data_cont[:-2], _solvatedinfo_, config[1:]) if flag_done_: flag_done_ = write_lammps_data( sim_data, 'data.gro2lam', config ) if flag_done_: print_dec_g( 'Data file generated as "data.gro2lam"' ) self._convertdata_ = sim_data self._convertdata_['config'] = config # Returning the values self.master._convertdata_ = self._convertdata_ self.master.swapbody(2) else: pop_wrg_1('The setup needs some further improvements' +'to be runed. Please check your inputs') def get_entriesvalues(self): ''' --- app entry getter ---- mainly to obtain values beside check buttons''' e_values=[] _flag_ = True ent_rang = range(len(self.objt_c)) for ent in ent_rang:#[1:]: e_values.append(self.objt_c[ent].get()) if ent <= 4: _flag_ *= check_file(e_values[-1]) self.master._convert_['setup'] = e_values return _flag_ def createWidgets(self): self.create_conversion_gui() def config_solvation( self): title_txt = ' '*15+'Input Water name' instructions = 'Enter the atom tag letters of:' askfor = ['O in the non bonded file', 'H in the non bonded file', 'O in the .gro file', 'H in the .gro file', 'H - O partial charge' #'Na+ in the .gro file (if are present)', #'Cl- in the .gro file (if are present)' ] _solvatedinfo_ = self.master._convert_['solvation'] if _solvatedinfo_ == []: defaultanswer = ['opls_116','opls_117','OW','HW1, HW2','0.4238' #,'Na','Cl' ] else: defaultanswer = _solvatedinfo_ self.solv_b.config(bg = 'gray40', width = 45) #cyan') self.master._aux_ = [] pop = PromptPopUp(master = self.master, title = title_txt, briefing = instructions, entries_txt = askfor, entries_val = defaultanswer ) pop.wait_window() if self.master._aux_ <> [] and self.get_entriesvalues(): _app_aux_ = self.master._aux_ #============ Check inputs ================= _flag_ = 1 nb_Ox, nbHy, gro_Oxs, gro_Hys, pch= _app_aux_ _gro_f, _, _, _nbn_f, _, _, _= self.master._convert_['setup'] _flags = check_in_file( _nbn_f, nb_Ox, nbHy) print ([nb_Ox, nbHy]) list_aux = [Ox.strip(' ') for Ox in gro_Oxs.split(',')] list_aux += [Ox.strip(' ') for Ox in gro_Hys.split(',')] _flags += check_in_file( _gro_f, *list_aux) print (list_aux) try: x = float(pch) if -10<x<10: _flags += [1] partial_charges = 'Partial charges for H: {} and for O: {}' print partial_charges.format( x, x*-2) else: _flags += [0] except: _flags += [0] list_aux = [nb_Ox, nbHy] + list_aux for v in range(len(_flags)): err_txt = '' if not _flags[v] and v <> (len(_flags)-1): filename = _nbn_f if v>1: filename = _gro_f err_txt = 'Atom tag {} not found in {}' if '/' in filename: filename = filename.split('/')[-1] err_txt = err_txt.format( list_aux[v], filename) _flag_*=0 elif not _flags[v]: err_txt = 'Non valid partial charge {}'.format( pch) _flag_*=0 if err_txt<>'': pop_err_1(err_txt+'\nSetup not saved') #============ Done! ================= if _flag_: self.master._convert_['solvation'] = _app_aux_ print_dec_g('Solvation setup saved!') #self.solv_b.focus() self.solv_b.config(bg = 'lightgrey', width = 28)
class _Hatch_GUI(object): """ create a Hatch object from hatch_supt and to then create a skeleton python project. """ def __init__(self, master): self.initComplete = 0 self.master = master self.x, self.y, self.w, self.h = -1, -1, -1, -1 # bind master to <Configure> in order to handle any resizing, etc. # postpone self.master.bind("<Configure>", self.Master_Configure) self.master.bind('<Enter>', self.bindConfigure) self.master.title("PyHatch GUI") self.master.resizable(0, 0) # Linux may not respect this dialogframe = Frame(master, width=810, height=630) dialogframe.pack() self.Shortdesc_Labelframe = LabelFrame( dialogframe, text="Short Description (1-liner)", height="90", width="718") self.Shortdesc_Labelframe.place(x=60, y=127) helv20 = tkFont.Font(family='Helvetica', size=20, weight='bold') self.Buildproject_Button = Button(dialogframe, text="Build Project", width="15", font=helv20) self.Buildproject_Button.place(x=492, y=10, width=263, height=68) self.Buildproject_Button.bind("<ButtonRelease-1>", self.Buildproject_Button_Click) self.Selectdir_Button = Button(dialogframe, text="<Select Directory>", width="15") self.Selectdir_Button.place(x=72, y=585, width=672, height=31) self.Selectdir_Button.bind("<ButtonRelease-1>", self.Selectdir_Button_Click) self.Author_Entry = Entry(dialogframe, width="15") self.Author_Entry.place(x=228, y=424, width=187, height=21) self.Author_Entry_StringVar = StringVar() self.Author_Entry.configure(textvariable=self.Author_Entry_StringVar) self.Author_Entry_StringVar.set("John Doe") self.Classname_Entry = Entry(dialogframe, width="15") self.Classname_Entry.place(x=192, y=73, width=165, height=21) self.Classname_Entry_StringVar = StringVar() self.Classname_Entry.configure( textvariable=self.Classname_Entry_StringVar) self.Classname_Entry_StringVar.set("MyClass") self.Copyright_Entry = Entry(dialogframe, width="15") self.Copyright_Entry.place(x=228, y=478, width=461, height=21) self.Copyright_Entry_StringVar = StringVar() self.Copyright_Entry.configure( textvariable=self.Copyright_Entry_StringVar) self.Copyright_Entry_StringVar.set("Copyright (c) 2013 John Doe") self.Email_Entry = Entry(dialogframe, relief="sunken", width="15") self.Email_Entry.place(x=228, y=505, width=458, height=21) self.Email_Entry_StringVar = StringVar() self.Email_Entry.configure(textvariable=self.Email_Entry_StringVar) self.Email_Entry_StringVar.set("*****@*****.**") self.GithubUserName_Entry = Entry(dialogframe, relief="sunken", width="15") self.GithubUserName_Entry.place(x=228, y=539, width=458, height=21) self.GithubUserName_Entry_StringVar = StringVar() self.GithubUserName_Entry.configure( textvariable=self.GithubUserName_Entry_StringVar) self.GithubUserName_Entry_StringVar.set("github_user_name") self.Funcname_Entry = Entry(dialogframe, width="15") self.Funcname_Entry.place(x=192, y=100, width=157, height=21) self.Funcname_Entry_StringVar = StringVar() self.Funcname_Entry.configure( textvariable=self.Funcname_Entry_StringVar) self.Funcname_Entry_StringVar.set("my_function") # License values should be correct format LICENSE_OPTIONS = tuple(sorted(CLASSIFIER_D.keys())) self.License_Entry_StringVar = StringVar() self.License_Entry = OptionMenu(dialogframe, self.License_Entry_StringVar, *LICENSE_OPTIONS) self.License_Entry.place(x=552, y=424, width=184, height=21) self.License_Entry_StringVar.set(LICENSE_OPTIONS[0]) self.Mainpyname_Entry = Entry(dialogframe, width="15") self.Mainpyname_Entry.place(x=168, y=37, width=196, height=21) self.Mainpyname_Entry_StringVar = StringVar() self.Mainpyname_Entry.configure( textvariable=self.Mainpyname_Entry_StringVar) self.Mainpyname_Entry_StringVar.set("main.py") self.Projname_Entry = Entry(dialogframe, width="15") self.Projname_Entry.place(x=168, y=10, width=194, height=21) self.Projname_Entry_StringVar = StringVar() self.Projname_Entry.configure( textvariable=self.Projname_Entry_StringVar) self.Projname_Entry_StringVar.set("MyProject") self.Shortdesc_Entry = Entry(dialogframe, width="15") self.Shortdesc_Entry.place(x=72, y=150, width=688, height=48) self.Shortdesc_Entry_StringVar = StringVar() self.Shortdesc_Entry.configure( textvariable=self.Shortdesc_Entry_StringVar) self.Shortdesc_Entry_StringVar.set("My project does this") # Status must be correct format self.Status_Entry_StringVar = StringVar() self.Status_Entry = OptionMenu(dialogframe, self.Status_Entry_StringVar, *DEV_STATUS_OPTIONS) self.Status_Entry.place(x=228, y=451, width=183, height=21) self.Status_Entry_StringVar.set(DEV_STATUS_OPTIONS[0]) self.Version_Entry = Entry(dialogframe, width="15") self.Version_Entry.place(x=552, y=451, width=184, height=21) self.Version_Entry_StringVar = StringVar() self.Version_Entry.configure(textvariable=self.Version_Entry_StringVar) self.Version_Entry_StringVar.set("0.1.1") self.Author_Label = Label(dialogframe, text="Author", width="15") self.Author_Label.place(x=96, y=424, width=112, height=22) self.Classname_Label = Label(dialogframe, text="Class Name", width="15") self.Classname_Label.place(x=60, y=73, width=112, height=22) self.Copyright_Label = Label(dialogframe, text="Copyright", width="15") self.Copyright_Label.place(x=96, y=478, width=113, height=23) self.Email_Label = Label(dialogframe, text="Email", width="15") self.Email_Label.place(x=96, y=505, width=113, height=23) self.GithubUserName_Label = Label(dialogframe, text="GithubUserName", width="15") self.GithubUserName_Label.place(x=96, y=539, width=113, height=23) self.Funcname_Label = Label(dialogframe, text="Function Name", width="15") self.Funcname_Label.place(x=60, y=100, width=112, height=22) self.License_Label = Label(dialogframe, text="License", width="15") self.License_Label.place(x=432, y=424, width=113, height=23) self.Longdesc_Label = Label(dialogframe, text="Paragraph Description", width="15") self.Longdesc_Label.place(x=216, y=220, width=376, height=22) self.Mainpyname_Label = Label(dialogframe, text="Main Python File", width="15") self.Mainpyname_Label.place(x=48, y=37, width=112, height=22) self.Projname_Label = Label(dialogframe, text="Project Name", width="15") self.Projname_Label.place(x=48, y=10, width=112, height=22) self.Selectdir_Label = Label( dialogframe, text="Select the Directory Below Which to Place Your Project", width="15") self.Selectdir_Label.place(x=156, y=567, width=536, height=24) self.Status_Label = Label(dialogframe, text="Status", width="15") self.Status_Label.place(x=96, y=451, width=114, height=24) self.Version_Label = Label(dialogframe, text="Version", width="15") self.Version_Label.place(x=432, y=451, width=113, height=23) self.Isclass_Radiobutton = Radiobutton(dialogframe, text="Class Project", value="Class Project", width="15", anchor=W) self.Isclass_Radiobutton.place(x=320, y=73, width=135, height=27) self.RadioGroup1_StringVar = StringVar() self.RadioGroup1_StringVar.set("Class Project") self.RadioGroup1_StringVar_traceName = \ self.RadioGroup1_StringVar.trace_variable("w", self.RadioGroup1_StringVar_Callback) self.Isclass_Radiobutton.configure(variable=self.RadioGroup1_StringVar) self.Isfunction_Radiobutton = Radiobutton(dialogframe, text="Function Project", value="Function Project", width="15", anchor=W) self.Isfunction_Radiobutton.place(x=320, y=100, width=135, height=27) self.Isfunction_Radiobutton.configure( variable=self.RadioGroup1_StringVar) lbframe = Frame(dialogframe) self.Text_1_frame = lbframe scrollbar = Scrollbar(lbframe, orient=VERTICAL) self.Text_1 = Text(lbframe, width="40", height="6", yscrollcommand=scrollbar.set) scrollbar.config(command=self.Text_1.yview) scrollbar.pack(side=RIGHT, fill=Y) self.Text_1.pack(side=LEFT, fill=BOTH, expand=1) self.Text_1_frame.place(x=72, y=250, width=665, height=160) # >>>>>>insert any user code below this comment for section "top_of_init" self.dirname = '<Select Directory>' self.Funcname_Entry.config(state=DISABLED) h = Hatch(projName='MyProject', mainDefinesClass='N') if h.author: self.Author_Entry_StringVar.set(h.author) if h.proj_license: self.License_Entry_StringVar.set(h.proj_license) if h.proj_copyright: self.Copyright_Entry_StringVar.set(h.proj_copyright) if h.email: self.Email_Entry_StringVar.set(h.email) if h.github_user_name: self.GithubUserName_Entry_StringVar.set(h.github_user_name) del h def build_result_dict(self): """Takes user inputs from GUI and builds a dictionary of results""" # pylint: disable=W0201 self.result = {} # return a dictionary of results self.result["author"] = self.Author_Entry_StringVar.get() self.result["status"] = self.Status_Entry_StringVar.get() self.result["proj_license"] = self.License_Entry_StringVar.get() self.result["version"] = self.Version_Entry_StringVar.get() self.result["proj_copyright"] = self.Copyright_Entry_StringVar.get() self.result["email"] = self.Email_Entry_StringVar.get() self.result[ "github_user_name"] = self.GithubUserName_Entry_StringVar.get() self.result["main_py_name"] = self.Mainpyname_Entry_StringVar.get() self.result["proj_name"] = self.Projname_Entry_StringVar.get() self.result["class_name"] = self.Classname_Entry_StringVar.get() self.result["func_name"] = self.Funcname_Entry_StringVar.get() self.result["short_desc"] = self.Shortdesc_Entry_StringVar.get() self.result["para_desc"] = self.Text_1.get(1.0, END) self.result["parent_dir"] = self.dirname if self.RadioGroup1_StringVar.get() == "Class Project": self.result["is_class_project"] = 'Y' else: self.result["is_class_project"] = 'N' def Buildproject_Button_Click(self, event): """When clicked, this method gathers all the user inputs and builds the project skeleton in the directory specified. """ # tkinter requires arguments, but I don't use them # pylint: disable=W0613 # >>>>>>insert any user code below this comment for section "compID=29" # replace, delete, or comment-out the following #print "executed method Buildproject_Button_Click" if not os.path.isdir(self.dirname): ShowError( title='Need Parent Directory', message= 'You need to choose a directory in which to place your project.' ) else: self.build_result_dict() # builds self.result dict r = self.result h = Hatch(projName=r["proj_name"], mainDefinesClass=r["is_class_project"], mainPyFileName=r["main_py_name"], mainClassName=r["class_name"], mainFunctionName=r["func_name"], author=r["author"], proj_copyright=r["proj_copyright"], proj_license=r["proj_license"], version=r["version"], email=r["email"], status=r["status"], github_user_name=r["github_user_name"], simpleDesc=r["short_desc"], longDesc=r["para_desc"]) call_result = h.save_project_below_this_dir(self.dirname) if call_result == 'Success': if AskYesNo(title='Exit Dialog', message='Do you want to leave this GUI?'): self.master.destroy() else: ShowWarning( title='Project Build Error', message='Project did NOT build properly.\n'+\ 'Warning Message = (%s)'%call_result) # return a string containing directory name def AskDirectory(self, title='Choose Directory', initialdir="."): """Simply wraps the tkinter function of the "same" name.""" dirname = tkFileDialog.askdirectory(parent=self.master, initialdir=initialdir, title=title) return dirname # <-- string def Selectdir_Button_Click(self, event): # I don't care what the exception is, if there's a problem, bail # Also, I want to redefine the dirname attribute here # pylint: disable=W0702, W0201 # tkinter requires arguments, but I don't use them # pylint: disable=W0613 """Selects the directory in which to build project.""" dirname = self.AskDirectory(title='Choose Directory For Nose Tests', initialdir='.') if dirname: try: dirname = os.path.abspath(dirname) except: self.dirname = '<Select Directory>' return # let Alarm force dir selection self.dirname = dirname self.Selectdir_Button.config(text=self.dirname) def RadioGroup1_StringVar_Callback(self, varName, index, mode): # tkinter requires arguments, but I don't use them # pylint: disable=W0613 """Responds to changes in RadioGroup1_StringVar.""" if self.RadioGroup1_StringVar.get() == "Class Project": self.Funcname_Entry.config(state=DISABLED) self.Classname_Entry.config(state=NORMAL) else: self.Classname_Entry.config(state=DISABLED) self.Funcname_Entry.config(state=NORMAL) # tk_happy generated code. DO NOT EDIT THE FOLLOWING. section "Master_Configure" def bindConfigure(self, event): """bindConfigure and Master_Configure help stabilize GUI""" # tkinter requires arguments, but I don't use them # pylint: disable=W0613 if not self.initComplete: self.master.bind("<Configure>", self.Master_Configure) self.initComplete = 1 def Master_Configure(self, event): """bindConfigure and Master_Configure help stabilize GUI""" # >>>>>>insert any user code below this comment for section "Master_Configure" # replace, delete, or comment-out the following if event.widget != self.master: if self.w != -1: return x = int(self.master.winfo_x()) y = int(self.master.winfo_y()) w = int(self.master.winfo_width()) h = int(self.master.winfo_height()) if (self.x, self.y, self.w, self.h) == (-1, -1, -1, -1): self.x, self.y, self.w, self.h = x, y, w, h if self.w != w or self.h != h: print "Master reconfigured... make resize adjustments" self.w = w self.h = h
class QuizLetter(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent # generate the options of buttons keys = shuffle_dictionary(LETTERS) right_answer, answers = generate_letters(keys, NUM_LETTERS) # create window self.create_window() self.create_letter(right_answer) #self.create_button() self.create_play_button(answers) self.create_option_buttons(right_answer, answers) def create_window (self): self.parent.geometry(WINDOW_DIMENSIONS) self.parent.title(TITLE) def create_letter(self, right_answer): self.label = Label(self.parent, text=right_answer, font=("",80)) self.label.pack() def create_play_button(self, answers): # create list of oggs list_oggs = [] i= 0 for i in range(0, NUM_LETTERS): list_oggs.append(LETTERS[answers[i]][1]) i+=1 self.play_image = PhotoImage(file=IMAGES_PATH + 'play.png') # create the button self.play_button = Button(self.parent,width=40,height=30,fg='black', image=self.play_image, command=lambda: play_ogg(list_oggs)).place(x=5,y=102) def right_button(self, button): """ Button right green and sound """ button.config(background = "green") button.config(activebackground="green") pygame.mixer.music.load(SOUNDS_PATH + 'right.ogg') pygame.mixer.music.play() def wrong_button(self, button): """ Button wrong red and sound """ button.config(background = "red") button.config(activebackground="red") pygame.mixer.music.load(SOUNDS_PATH + 'wrong.ogg') pygame.mixer.music.play() def create_option_buttons(self, right_answer, answers): # create buttons self.option_1 = Button(self.parent,width=7,height=3,fg='black', text=LETTERS[answers[0]][0]) self.option_1.place(x=5,y=140) self.option_2 = Button(self.parent,width=7,height=3,fg='black', text=LETTERS[answers[1]][0]) self.option_2.place(x=5,y=200) self.option_3 = Button(self.parent,width=7,height=3,fg='black', text=LETTERS[answers[2]][0]) self.option_3.place(x=95,y=140) self.option_4 = Button(self.parent,width=7,height=3,fg='black', text=LETTERS[answers[3]][0]) self.option_4.place(x=95,y=200) self.option_1.config(command=lambda: self.right_button(self.option_1) if answers[0] == right_answer else self.wrong_button(self.option_1)) self.option_2.config(command=lambda: self.right_button(self.option_2) if answers[1] == right_answer else self.wrong_button(self.option_2)) self.option_3.config(command=lambda: self.right_button(self.option_3) if answers[2] == right_answer else self.wrong_button(self.option_3)) self.option_4.config(command=lambda: self.right_button(self.option_4) if answers[3] == right_answer else self.wrong_button(self.option_4))
class pump_ui(object): def __init__(self): master = Tk() master.style = ttk.Style() master.style.theme_use("default") master.config(bg=background_colour) master.resizable( 0, 0 ) # Disable resizing the UI to prevent having to make widget placing dynamic master.winfo_toplevel().title(frame_title) master.iconbitmap("bitcoin.ico") # Create pumper assistant to store data on the current BTC and alt holdings. self.pumper = pumper() self.create_title(master) self.create_api_info(master, previous_row=0) self.create_auto_sell(master, previous_row=3) self.create_stop_loss(master, previous_row=4) self.create_order_type(master, previous_row=6) self.create_fee_type(master, previous_row=7) self.create_btc_balance_picker(master, previous_row=8) self.create_alt_ticker(master, previous_row=10) self.create_pump_and_sell_buttons(master, previous_row=11) self.create_current_profit(master, previous_row=12) self.create_output_box(master, rightmost_column=1) # Can hardcode API key and Secret #self.api_key_entry.delete(0,END) #self.api_key_entry.insert(0,"KEY") #self.api_key_entry.config(state=DISABLED) #self.api_secret_entry.delete(0, END) #self.api_secret_entry.insert(0, "SECRET") #self.api_secret_entry.config(state=DISABLED) # Display the UI, this can only be called once per program. # Nothing in the main Python script will be run after creating the UI because of this. master.mainloop() def create_title(self, master, previous_row=-1, previous_column=-1): empty = Label(master, text=frame_title) empty.grid(row=previous_row + 1, column=previous_column + 2, columnspan=1) empty.config(bg=background_colour, fg=label_font_colour) def create_api_info(self, master, previous_row=-1, previous_column=-1): api_key_lbl = Label(master, text="API Key:") api_key_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=1, sticky=E, padx=(3, 0)) api_key_lbl.config(bg=background_colour, fg=label_font_colour) self.api_key_entry = Entry(master, highlightthickness=0, bd=0, width=21, show="*") self.api_key_entry.config(borderwidth=2, relief=default_relief) self.api_key_entry.grid(row=previous_row + 1, column=previous_column + 2) api_secret_lbl = Label(master, text="API Secret:") api_secret_lbl.grid(row=previous_row + 2, column=previous_column + 1, columnspan=1, sticky=E, padx=(3, 0)) api_secret_lbl.config(bg=background_colour, fg=label_font_colour) self.api_secret_entry = Entry(master, highlightthickness=0, bd=0, width=21, show="*") self.api_secret_entry.config(borderwidth=2, relief=default_relief) self.api_secret_entry.grid(row=previous_row + 2, column=previous_column + 2) self.api_connect_btn = Button(master, text="Connect To Binance", command=self.on_connect_api) self.api_connect_btn.grid(row=previous_row + 3, column=previous_column + 2, columnspan=1, sticky=W + E, padx=10, pady=(0, 3)) self.api_connect_btn.config(highlightbackground=background_colour) def create_auto_sell(self, master, previous_row=-1, previous_column=-1): auto_sell_lbl = Label(master, text="Auto Sell (%):") auto_sell_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=1, sticky=E, padx=(3, 0)) auto_sell_lbl.config(bg=background_colour, fg=label_font_colour) self.auto_sell_spinbox = Spinbox(master, from_=1.0, to=300.0, increment=1.0, highlightbackground=background_colour) self.auto_sell_spinbox.config(borderwidth=2, relief=default_relief) self.auto_sell_spinbox.grid(row=previous_row + 1, column=previous_column + 2) self.auto_sell_spinbox.delete(0, "end") self.auto_sell_spinbox.insert(0, 50) def create_stop_loss(self, master, previous_row=-1, previous_column=-1): stop_loss_lbl = Label(master, text="Stop Loss (%):") stop_loss_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=1, sticky=E, padx=(3, 0)) stop_loss_lbl.config(bg=background_colour, fg=label_font_colour) self.stop_loss_spinbox = Spinbox(master, from_=-100.0, to=-10.0, increment=1.0, highlightbackground=background_colour) self.stop_loss_spinbox.config(borderwidth=2, relief=default_relief) self.stop_loss_spinbox.grid(row=previous_row + 1, column=previous_column + 2) self.stop_loss_spinbox.delete(0, "end") self.stop_loss_spinbox.insert(0, -10) def create_btc_balance_picker(self, master, previous_row=-1, previous_column=-1): self.btc_balance_str = StringVar() btc_balance_lbl = Label(master, textvar=self.btc_balance_str) btc_balance_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=2, sticky=W + E, padx=(3, 0)) btc_balance_lbl.config(bg=background_colour, fg=label_font_colour) self.set_available_btc_balance(Decimal(0)) btc_to_use_label = Label(master, text="BTC to spend:", bg=background_colour, fg=label_font_colour) btc_to_use_label.grid(row=previous_row + 2, column=previous_column + 1, sticky=E, padx=(3, 0)) self.btc_to_use_spinbox = Spinbox( master, from_=minimum_trade, to=minimum_trade, increment=btc_to_use_increment, highlightbackground=background_colour) self.btc_to_use_spinbox.config(borderwidth=2, relief=default_relief) self.btc_to_use_spinbox.grid(row=previous_row + 2, column=previous_column + 2) def create_order_type(self, master, previous_row=-1, previous_column=-1): order_type_lbl = Label(master, text="Entry Type:") order_type_lbl.grid(row=previous_row + 1, column=previous_column + 1, sticky=E, padx=(3, 0)) order_type_lbl.config(bg=background_colour, fg=label_font_colour) self.is_entry_market = True def change_order_type(*args): self.is_entry_market = (self.order_type.get() == "Market Buy \/") self.order_type = StringVar() self.order_type.trace( "w", change_order_type ) # Reduces how much work is done when the pump starts choices = {"Market Buy \/", "Limit Buy \/"} self.entry_type_option_menu = OptionMenu(master, self.order_type, *choices) self.entry_type_option_menu.grid(row=previous_row + 1, column=previous_column + 2, sticky=W + E, padx=8) self.entry_type_option_menu.config(highlightthickness=0) self.entry_type_option_menu.configure(indicatoron=0) self.order_type.set("Market Buy \/") def create_fee_type(self, master, previous_row=-1, previous_column=-1): fee_type_lbl = Label(master, text="Fee Type:") fee_type_lbl.grid(row=previous_row + 1, column=previous_column + 1, sticky=E, padx=(3, 0)) fee_type_lbl.config(bg=background_colour, fg=label_font_colour) self.is_using_bnb = True def change_fee_type(*args): self.is_using_bnb = ( self.order_type.get() == "Binance Coin (BNB) \/") self.fee_type = StringVar() self.fee_type.trace( "w", change_fee_type ) # Reduces how much work is done when the pump starts choices = {"Binance Coin (BNB) \/", "0.1% Of All Trades \/"} self.fee_type_option_menu = OptionMenu(master, self.fee_type, *choices) self.fee_type_option_menu.grid(row=previous_row + 1, column=previous_column + 2, sticky=W + E, padx=8) self.fee_type_option_menu.config(highlightthickness=0) self.fee_type_option_menu.configure(indicatoron=0) self.fee_type.set("Binance Coin (BNB) \/") def create_pump_and_sell_buttons(self, master, previous_row=-1, previous_column=-1): # Manual sell button can only be activated after initiating a pump. self.manual_sell_btn = Button(master, text="Sell", state=DISABLED, command=self.on_manual_sell) self.manual_sell_btn.grid(row=previous_row + 1, column=previous_column + 1, sticky=W + E, padx=(3, 0)) self.manual_sell_btn.config(highlightbackground=background_colour) self.pump_btn = Button(master, text="Pump", command=self.on_pump) self.pump_btn.grid(row=previous_row + 1, column=previous_column + 2, sticky=W + E, padx=8) self.pump_btn.config(highlightbackground=background_colour, state=DISABLED) def create_alt_ticker(self, master, previous_row=-1, previous_column=-1): ticker_lbl = Label(master, text="Ticker To Pump:") ticker_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=1, sticky=E, padx=(3, 0), pady=(0, 8)) ticker_lbl.config(bg=background_colour, fg=label_font_colour) self.ticker_entry = Entry(master, highlightthickness=0, bd=0, width=21) self.ticker_entry.config(borderwidth=2, relief=default_relief) self.ticker_entry.grid(row=previous_row + 1, column=previous_column + 2, pady=8) self.ticker_entry.bind('<Return>', self.on_pump_shortcut) def create_current_profit(self, master, previous_row=-1, previous_column=-1): self.current_profit_str = StringVar() current_profit_lbl = Label(master, textvar=self.current_profit_str) current_profit_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=2, sticky=W + E, padx=3, pady=(0, 3)) current_profit_lbl.config(bg=background_colour, fg=label_font_colour) self.current_profit_str.set("Current Profit: 0%") def create_output_box(self, master, rightmost_column): self.pump_output = StringVar() console_lbl = Label(master, textvar=self.pump_output, borderwidth=2, relief=default_relief, anchor=N) console_lbl.grid(row=0, column=rightmost_column + 1, columnspan=1, rowspan=14, padx=(10, 0), pady=0) console_lbl.config(width=50, height=22, bg="black", font=Font(family="Courier", size=9), fg="white") self.lines = 0 def disable_pre_pump_options(self): # Change the buttons that can be clicked to prevent the user # from trying to pump multiple coins with one bot. self.manual_sell_btn.config(state=NORMAL) self.pump_btn.config(state=DISABLED) self.btc_to_use_spinbox.config(state=DISABLED) self.ticker_entry.config(state=DISABLED) self.auto_sell_spinbox.config(state=DISABLED) self.stop_loss_spinbox.config(state=DISABLED) self.api_key_entry.config( state=DISABLED) # Comment out if hardcoding key self.api_secret_entry.config( state=DISABLED) # Comment out if hardcoding secret self.api_connect_btn.config(state=DISABLED) self.entry_type_option_menu.config(state=DISABLED) self.fee_type_option_menu.config(state=DISABLED) def enable_pump_options(self): # Change the buttons that can be clicked to prevent the user # from trying to pump multiple coins with one bot. self.manual_sell_btn.config(state=DISABLED) self.pump_btn.config(state=NORMAL) self.btc_to_use_spinbox.config(state=NORMAL) self.ticker_entry.config(state=NORMAL) self.auto_sell_spinbox.config(state=NORMAL) self.stop_loss_spinbox.config(state=NORMAL) self.api_key_entry.config( state=NORMAL) # Comment out if hardcoding key self.api_secret_entry.config( state=NORMAL) # Comment out if hardcoding secret self.api_connect_btn.config(state=NORMAL) self.entry_type_option_menu.config(state=NORMAL) self.fee_type_option_menu.config(state=NORMAL) def set_available_btc_balance(self, btc_balance): self.pumper.btc_balance = btc_balance self.btc_balance_str.set("Available Balance: " + readable_btc_balance(btc_balance)) def set_current_profit(self, current_profit): self.current_profit_str.set( "Current Profit: " + '{0:.3f}'.format(round(current_profit * Decimal(100), 3)) + "%") def write_to_console(self, line): self.lines += 1 if self.lines > max_lines_in_console: i = self.pump_output.get().index('\n') self.pump_output.set(self.pump_output.get()[i + 1:] + "\n" + line) elif self.lines == 1: self.pump_output.set(line) else: self.pump_output.set(self.pump_output.get() + "\n" + line) #### Button Behaviour #### def on_pump(self): try: api = self.api btc_to_use = Decimal(self.btc_to_use_spinbox.get()) except InvalidOperation: # The BTC to spend box is empty. self.write_to_console("Stop!") self.write_to_console("BTC to spend cannot be empty.") return except AttributeError: # There is no API object. self.write_to_console( "You need to connect to Binance before pumping.") return if btc_to_use >= minimum_trade: if btc_to_use <= self.pumper.btc_balance: target_profit_percentage = Decimal( float(self.auto_sell_spinbox.get()) / 100.0) # Validate auto-sell and stop loss if target_profit_percentage <= Decimal(0): self.write_to_console("Auto sell has to be positive.") return if Decimal(self.stop_loss_spinbox.get()) >= Decimal(0): self.write_to_console("Stop loss has to be negative.") return ticker = self.ticker_entry.get().upper() # Empty strings are False in Python if ticker: full_ticker = api.full_ticker_for(ticker) try: alt = self.api.get_ticker(symbol=full_ticker) except BinanceAPIException, e: logging.debug(str(e)) self.write_to_console("Invalid ticker.") return alt_value = Decimal(alt["askPrice"]) # Used in console output decimal_points = minimum_decimals_in_quantity.get( full_ticker, 0) self.pumper.decimal_points_in_alt = decimal_points self.pumper.set_up(btc_to_use, target_profit_percentage, alt_value, ticker) if self.is_entry_market: self.pumper.alt_holdings = api.market_buy( self.pumper.btc_to_use, full_ticker, self.is_using_bnb) self.write_to_console( "Bought " + readable_alt_balance( decimal_points, pumper=self.pumper) + " with " + readable_btc_balance(btc_to_use) + ".") else: highest_bid = Decimal(alt["bidPrice"]) if alt_value - highest_bid <= Decimal(0.00000001): to_bid = highest_bid else: # Bid between the highest bid and the lowest ask for the best odds of being filled. to_bid = (alt_value - highest_bid) / 2 + highest_bid to_bid = Decimal( floor(to_bid * Decimal(100000000.0)) ) / Decimal(100000000.0) self.pumper.starting_alt_value = to_bid expected = api.limit_buy( btc_to_alt(btc_to_use, alt_value), pumper, full_ticker, to_bid, self.is_using_bnb) self.write_to_console("Buying " + readable_alt_balance( decimal_points, alt_amount=expected, ticker=ticker ) + " for " + readable_btc_balance(btc_to_use) + ".") self.write_to_console( "This is a limit order, it may not get filled.") self.disable_pre_pump_options() self.set_stop_loss() self.start_monitoring_orderbook(full_ticker) else: # The user is trying to trade with more than they actually have. self.write_to_console("You did not enter a ticker.") else: # The user is trying to trade with more than they actually have. self.write_to_console("Stop!") self.write_to_console( "You are trying to spend more BTC than you have.") else:
class Visualiser(object): ''' Generic Offline Visualiser. Subclasses need to be used that specify how to handle a data source. ''' ### Public functions ### def __init__(self, title="Visualisation", width=400, height=400, recording=False, recordPattern=None, paused=False, source=None): ''' Constructor. Params: title: string - Title of the visualisation window width: int - Width of the visualisation window height: int - Height of the visualisation window recording: boolean - Start with recording enabled? recordPattern: string - Pattern for recorded images, e.g., cylinders%05g.png paused: boolean - Start with playback paused? source:- The data source to read. What is required here varies by visualiser. ''' # Visualisation options self.vis_features = [] self.vis_frame = 0 self.vis_frameStep = 1 self.vis_jumping = False self.vis_recording = recording self.vis_recordPattern = recordPattern self.vis_paused = paused self.vis_source = source # VTK structures self.vtk_cells = vtkCellArray() self.vtk_renderer = vtkRenderer() # Tk structures self.tk_root = Tk() self.tk_root.title(title) self.tk_root.grid_rowconfigure(0, weight=1) self.tk_root.grid_columnconfigure(0, weight=3) self.tk_root.bind('<Destroy>', self.destroyed) if not self.vis_paused: self.tk_root.after(100, self.animate) self.tk_renderWidget = vtkTkRenderWidget(self.tk_root, width=width, height=height) self.tk_renderWidget.grid(row=0, column=0, sticky=N+S+E+W) self.tk_renderWidget.GetRenderWindow().AddRenderer(self.vtk_renderer) self.tk_featureFrame = Frame(self.tk_root) self.tk_featureFrame.grid(row=0, column=1, rowspan=2) Label(self.tk_featureFrame, text='Features:').grid(row=0, column=0) self.tk_controlFrame = Frame(self.tk_root) self.tk_controlFrame.grid(row=1, column=0) self.tk_quit = Button(self.tk_controlFrame, text="Quit", command=self.shutdown) self.tk_quit.grid(row=0, column=0, columnspan=2) def pause(): if self.vis_paused: self.tk_pause.config(text='Pause') self.tk_root.after(100, self.animate) else: self.tk_pause.config(text='Resume') self.vis_paused ^= True self.tk_pause = Button(self.tk_controlFrame, text="Pause", command=pause) self.tk_pause.grid(row=0, column=2, columnspan=2) if self.vis_recordPattern is not None: def record(): if self.vis_recording: self.tk_record.config(text='Start Recording') else: self.tk_record.config(text='Stop Recording') self.vis_recording ^= True self.tk_record = Button(self.tk_controlFrame, text="Start Recording", command=record) self.tk_record.grid(row=0, column=4, columnspan=2) if self.vis_recording: self.tk_record.config(text="Stop Recording") def make_seek_button(label, column, frame): def jump(): self.jumpTo(frame) b = Button(self.tk_controlFrame, text=label, command=jump) b.grid(row=1, column=column, sticky=W+E) return b self.tk_seek_start = make_seek_button("|<", 0, 0) self.tk_seek_back10 = make_seek_button("<<", 1, lambda: self.vis_frame - 10) self.tk_seek_back1 = make_seek_button("<", 2, lambda: self.vis_frame - 1) self.tk_seek_forward1 = make_seek_button(">", 3, lambda: self.vis_frame + 1) self.tk_seek_forward10 = make_seek_button(">>", 4, lambda: self.vis_frame + 10) self.tk_seek_end = make_seek_button(">|", 5, self.getMaxFrameNumber) Label(self.tk_controlFrame, text='Frame').grid(row=2, column=0, sticky=W+E) def changeFrame(frame): if not self.vis_jumping: self.vis_jumping = True self.jumpTo(self.tk_frame.get()) self.vis_jumping = False self.tk_frame = Scale(self.tk_controlFrame, command=changeFrame, from_=0, to=0, orient=HORIZONTAL) self.tk_frame.grid(row=2, column=1, columnspan=2, sticky=W+E) Label(self.tk_controlFrame, text='Step').grid(row=2, column=3, sticky=W+E) def changeFrameStep(step): self.vis_frameStep = int(step) self.tk_frameStep = Scale(self.tk_controlFrame, command=changeFrameStep, from_=1, to=1, orient=HORIZONTAL) self.tk_frameStep.grid(row=2, column=4, columnspan=2, sticky=W+E) self.setupGrid() def add_feature(self, feature): '''Add a feature to this visualiser''' self.vis_features.append(feature) feature.button(self.tk_featureFrame).grid(row=len(self.vis_features), column=0, sticky=W+E) feature.visualiser = self def run(self): '''Start the visualiser''' self.redraw() self.tk_root.mainloop() ### Private funcitions ### def resetSliders(self): ''' Recalculate the upper bound on the frame and frameStep sliders. ''' maxFrame = self.getMaxFrameNumber() self.tk_frame.config(to=maxFrame) self.tk_frameStep.config(to=maxFrame) def jumpTo(self, frame): ''' Jump to a given frame. If frame is a function, jump to the return value of frame(). ''' oldFrame = self.vis_frame if hasattr(frame, '__call__'): self.vis_frame = frame() else: self.vis_frame = frame maxFrame = self.getMaxFrameNumber() if self.vis_frame < 0: self.vis_frame = 0 elif self.vis_frame > maxFrame: self.vis_frame = maxFrame self.vis_paused = True self.tk_pause.config(text='Resume') self.tk_frame.set(self.vis_frame) self.redraw(oldFrame != self.vis_frame) def redraw(self, update=False): self.resetSliders() for feature in [ f for f in self.vis_features if not f.dynamic ]: feature.draw(self.vtk_renderer) if update: for feature in [ f for f in self.vis_features if f.dynamic]: f.redraw(self.vtk_renderer) self.tk_renderWidget.GetRenderWindow().Render() self.tk_root.update_idletasks() ### Gui events ### def destroyed(self, event): if event.widget == self.tk_root: self.shutdown() def shutdown(self): self.tk_root.withdraw() self.tk_root.destroy() def animate(self): if not self.vis_paused: self.jumpTo(self.vis_frame + self.vis_frameStep) if self.vis_recording and self.vis_recordPattern is not None: self.save_image() self.tk_root.after(100, self.animate) def save_image(self): extmap = {'.jpg' : vtkJPEGWriter, '.jpeg' : vtkJPEGWriter, '.png' : vtkPNGWriter, '.pnm' : vtkPNMWriter} _, ext = splitext(self.vis_recordPattern) try: writer = extmap[ext.lower()]() except KeyError: print 'ERROR: Can\'t handle %s extension. Recording disabled.' % ext self.vis_recordPattern = None return win = self.vtk_renderer.GetRenderWindow() w2i = vtkWindowToImageFilter() w2i.SetInput(win) w2i.Update() writer.SetInput(w2i.GetOutput()) writer.SetFileName(self.vis_recordPattern % self.vis_frame) win.Render() writer.Write() ### Things subclasses need to override ### def setupGrid(self): ''' Populate the vtkCellArray instance at self.vtk_cells. Subclasses are required to override this function to read from their source as appropriate. ''' raise NotImplementedError('Subclass needs to override Visualiser::setupGrid!') def getMaxFrameNumber(self): ''' Return the maximum frame number. This will need to be defined by a subclass. ''' raise NotImplementedError('Subclass needs to override Visualiser::getMaxFrameNumber!') def getQuantityPoints(self, quantityName, dynamic=True, frameNumber=0): ''' Return the points of a quantity at a given frame as a list [float]. Subclasses need to override this. ''' raise NotImplementedError('Subclass needs to override Visualiser::getQuantityPoints!') def getQuantityDict(self): ''' Return the values of all quantities at a given time as a dictionary. Sublclasses need to override this. ''' raise NotImplementedError('Subclass needs to override Visualiser::getQuantityDict!')
class MyPoti(Tkinter.Tk): def __init__(self, master): Tkinter.Tk.__init__(self,master) self.master = master self.initialize() def initialize(self): #create canvas with specified size and add w = Canvas(self, width=700, height=600) w.pack() #Declare two lists, one for front labels, anthoer for answer labels self.flabels = [] self.alabels = [] #Define x and y cordinates for lables self.flblx = 280 self.flbly = 40 self.alblx = 380 self.albly = 40 #Dummy list1 self.my_list = [] #Text to set on front lables self.str_label = ['POTI0', 'POTI1','POTI2','POTI3','POTI4'] #Trigger to check if we want to program or pause self.running = True #Define environment varibales for input text fields #We can change/update this during runtime self.entry_pot_var = Tkinter.StringVar() self.entry_res_var = Tkinter.StringVar() #Define text areas for input onr for poti selection and one for resistence value self.entry_pot = Entry(self,textvariable=self.entry_pot_var, validate="focusout") self.entry_res = Entry(self,textvariable=self.entry_res_var, validate="focusout") #Initial text to display on above text fields self.entry_pot_var.set("Enter Pot selection") self.entry_res_var.set("Enter resistor value - 2000 to 100000") #Set pot selection entry as highlighted self.entry_pot.selection_range(0,Tkinter.END) #self.entry_res.selection_range(0,Tkinter.END) #Set keyboard focus on pot text field self.entry_pot.focus_set() #Add pot text field to canvas self.entry_pot.pack() #ToDO #validate input for pot selection #self.entry_pot["validatecommand"] = (self.register(self.check_pot), "%P") #Add resistence text field to canvas self.entry_res.pack() #Create two text on the canvas with x and y coodrinates w.create_window(120, 40, window=self.entry_pot) w.create_window(120, 70,window=self.entry_res) #We declare 5 front lables and add them to canvas with x and y co ordinates for x in range(5): print self.str_label[x] self.label = Label(self, text=self.str_label[x], fg='white', bg='black') self.label.pack() self.flabels.append(self.label) #We declare 5 answer lables and add them to canvas with x and y co ordinates for x in range(5): self.label = Label(self, text='values', fg='white', bg='blue') self.label.pack() self.alabels.append(self.label) #Create front label in canvas for label in self.flabels: w.create_window(self.flblx,self.flbly,window=label) self.flbly = self.flbly + 19 #Create answer label in cavas for label in self.alabels: w.create_window(self.alblx,self.albly,window=label) self.albly = self.albly + 20 ### #Button definitions ### #Start button, and add callback to start_app function when this button is clicked self.start_button = Button(self, text="Set", height=2, width=10, command=self.start_app) self.start_button.pack() #Clear button, and add callback to clear_app function when this button is clicked self.clear_button = Button(self, text="Clear", height=2, width=10, command=self.clear_app, state="disabled") self.clear_button.pack() #Clear button, and add quit function of tkinter master when this button is clicked self.close_button = Button(self, text="Close", height=2, width=10, command=self.quit) self.close_button.pack() #Add buttons to canvas w.create_window(70, 170, window=self.start_button) w.create_window(190, 170, window=self.close_button) w.create_window(310, 170, window=self.clear_button) #Input validation for pot selection text field def check_pot(self, txt): print("POT validate!") #pot = self.entry_pot_var.get() if int(txt): if txt < 0 or txt > 4 : return False else: return True else: print("Not integer") self.entry_pot.focus_set() self.entry_pot.delete(0, END) return False #Input validation for resistence text field def check_res(self): print("Greetings!") def start_app(self): """ Start the application when start button pressed """ #Disable start button after presed global running self.running = True #self.start_button.config(state="disabled") self.clear_button.config(state="normal") print "Starting app!" #call update values function self.update_values() def clear_app(self): """ Clear the answer lable fields """ print "Clear" global running self.running = False self.start_button.config(state="normal") self.clear_button.config(state="disabled") for i in range(5): self.alabels[i].config(text=str("values")) #Clear the text fields and set default vaule self.entry_pot_var.set("Enter Pot selection") self.entry_res_var.set("Enter resistor value - 2000 to 100000") #set keyboard focus self.entry_pot.focus_set() def stop_app(self): """ Stop the app """ print "Stopping" self.quit() def update_values(self): """ Helper function to trigger label values after reading pot and res values """ #if self.running: # self.after(1000, self.update_values) #Read input value given for pot selection text field pot = self.entry_pot.get() ###if pot < 0 or pot > 4 : ### if int(pot) < 0 or int(pot) > 4 : tkMessageBox.showerror("wrong input","wrong input, pot selection must be 0-4, current selection: %s" % pot) return res = self.entry_res.get() #Read input value given for resistence text field res = self.entry_res.get() #call update text value function which converts values and send data to MCP self.update_text_values(pot, res) def update_text_values(self, pot, res): """ Update the answer lables values with resistence """ #resisitor to data conversion byte = 256 local_pot = 100000 local_res = 125 #rw = int(res) * 1000 #rw = int(rw) - int(local_res) #lev = float((rw * byte) / local_pot) #level =round(lev) #level = int(level) #level = int(res) - int(local_res) if float(res): level = float(res) - int(local_res) else: level = int(res) - int(local_res) level = (level * byte) / local_pot level = int(level) print(level) b = 0 if int(pot) == 0: b = "0001" "0001" "{0:08b}".format(level) if int(pot) == 1: b = "0001" "0001" "{0:08b}" '{0:016b}'.format(level) if int(pot) == 2: b = "0001" "0001" "{0:08b}" '{0:032b}'.format(level) if int(pot) == 3: b = "0001" "0001" "{0:08b}" '{0:048b}'.format(level) if int(pot) == 4: b = "0001" "0001" "{0:08b}" '{0:064b}'.format(level) print b #update answer label based on poti selection self.alabels[int(pot)].config(text=str(level)) for x in b: GPIO.output(SPI_SDI_PIN, int(x)) print(int(x)) GPIO.output(SPI_CLK_PIN, True) GPIO.output(SPI_CLK_PIN, False) GPIO.output(SPI_CS_PIN, True) self.update_idletasks()
class TopoConsole(tk.AppWindow,tk.TkParameterized): """ Main window for the Tk-based GUI. """ def _getmenubar(self): return self.master.menubar menubar = property(_getmenubar) def __getitem__(self,menu_name): """Allow dictionary-style access to the menu bar.""" return self.menubar[menu_name] def __init__(self, root,exit_on_quit=True, **params): tk.AppWindow.__init__(self,root,status=True) tk.TkParameterized.__init__(self,root,**params) # Instead of displaying tracebacks on the commandline, try to display # them on the originating window. # CEBALERT: on destroy(), ought to revert this Tkinter.Misc._report_exception=_tkinter_report_exception self.exit_on_quit = exit_on_quit self.auto_refresh_panels = [] self._init_widgets() self.title(topo.sim.name) # If -g passed *before* scripts on commandline, this is useless. # So topo.misc.commandline sets the title as its last action (if -g) # catch click on the 'x': offers choice to quit or not self.protocol("WM_DELETE_WINDOW",self.quit_topographica) ########## ### Make cascade menus open automatically on linux when the mouse ### is over the menu title. ### [Tkinter-discuss] Cascade menu issue ### http://mail.python.org/pipermail/tkinter-discuss/2006-August/000864.html if topo.tkgui.system_platform is 'linux': activate_cascade = """\ if {[%W cget -type] != {menubar} && [%W type active] == {cascade}} { %W postcascade active } """ self.bind_class("Menu", "<<MenuSelect>>", activate_cascade) ########## # Install warning and message handling from param.parameterized import Parameterized self.__orig_P_warning = Parameterized.warning #self.__orig_P_message = Parameterized.message type.__setattr__(Parameterized,'warning',self.gui_warning) #type.__setattr__(Parameterized,'message',self.gui_message) def gui_warning(self,msg,*args,**kw): stat = self.__get_status_bar() stat.warn(msg%args) self.__orig_P_warning(self,msg,*args,**kw) def gui_message(self,msg,*args,**kw): stat = self.__get_status_bar() stat.message(msg%args) self.__orig_P_message(self,*args) def title(self,t=None): newtitle = "Topographica" if t: newtitle+=": %s" % t tk.AppWindow.title(self,newtitle) def _init_widgets(self): ## CEBALERT: now we can have multiple operations at the same time, ## status bar could be improved to show all tasks? # CEBALERT self.messageBar = self.status self.some_area = DockManager(self) self.some_area.pack(fill="both", expand=1) ### Balloon, for pop-up help self.balloon = tk.Balloon(self.content) ### Top-level (native) menu bar #self.menubar = tk.ControllableMenu(self.content) self.configure(menu=self.menubar) #self.menu_balloon = Balloon(topo.tkgui.root) # no menubar in tile yet # http://news.hping.org/comp.lang.tcl.archive/4679.html self.__simulation_menu() self.__create_plots_menu() self.refresh_plots_menu() self.__help_menu() ### Running the simulation run_frame = Frame(self.content) run_frame.pack(side='top',fill='x',padx=4,pady=8) self.run_frame = run_frame Label(run_frame,text='Run for: ').pack(side=LEFT) self.run_for_var=DoubleVar() self.run_for_var.set(1.0) run_for = tk.TaggedSlider(run_frame, variable=self.run_for_var, tag_width=11, slider_length=150, bounds=(0,20000)) self.balloon.bind(run_for,"Duration to run the simulation, e.g. 0.0500, 1.0, or 20000.") run_for.pack(side=LEFT,fill='x',expand=YES) run_for.tag.bind("<Return>",self.run_simulation) # When return is pressed, the TaggedSlider updates itself...but we also want to run # the simulation in this case. run_frame.optional_action=self.run_simulation go_button = Button(run_frame,text="Go", command=self.run_simulation) go_button.pack(side=LEFT) self.balloon.bind(go_button,"Run the simulation for the specified duration.") self.step_button = Button(run_frame,text="Step",command=self.run_step) self.balloon.bind(self.step_button,"Run the simulation through the time at which the next events are processed.") self.step_button.pack(side=LEFT) self.sizeright() def __simulation_menu(self): """Add the simulation menu options to the menubar.""" simulation_menu = ControllableMenu(self.menubar,tearoff=0) self.menubar.add_cascade(label='Simulation',menu=simulation_menu) simulation_menu.add_command(label='Run script',command=self.run_script) simulation_menu.add_command(label='Save script',command=self.save_script_repr) simulation_menu.add_command(label='Load snapshot',command=self.load_snapshot) simulation_menu.add_command(label='Save snapshot',command=self.save_snapshot) #simulation_menu.add_command(label='Reset',command=self.reset_network) simulation_menu.add_command(label='Test Pattern',command=self.open_test_pattern) simulation_menu.add_command(label='Model Editor',command=self.open_model_editor) simulation_menu.add_command(label='Quit',command=self.quit_topographica) def open_test_pattern(self): return open_plotgroup_panel(TestPattern) def __create_plots_menu(self): """ Add the plot menu to the menubar, with Basic plots on the menu itself and others in cascades by category (the plots come from plotgroup_templates). """ plots_menu = ControllableMenu(self.menubar,tearoff=0) self.menubar.add_cascade(label='Plots',menu=plots_menu) # CEBALERT: should split other menus in same way as plots (create/refresh) def refresh_plots_menu(self): plots_menu = self['Plots'] plots_menu.delete(0,'end') # create menu entries, and get list of categories entries=OrderedDict() # keep the order of plotgroup_templates (which is also KL) categories = [] for label,plotgroup in plotgroups.items(): entries[label] = PlotsMenuEntry(plotgroup) categories.append(plotgroup.category) categories = sorted(set(categories)) # The Basic category items appear on the menu itself. assert 'Basic' in categories, "'Basic' is the category for the standard Plots menu entries." for label,entry in entries.items(): if entry.plotgroup.category=='Basic': plots_menu.add_command(label=label,command=entry.__call__) categories.remove('Basic') plots_menu.add_separator() # Add the other categories to the menu as cascades, and the plots of each category to # their cascades. for category in categories: category_menu = ControllableMenu(plots_menu,tearoff=0) plots_menu.add_cascade(label=category,menu=category_menu) # could probably search more efficiently than this for label,entry in entries.items(): if entry.plotgroup.category==category: category_menu.add_command(label=label,command=entry.__call__) plots_menu.add_separator() plots_menu.add_command(label="Help",command=(lambda x=plotting_help_locations: self.open_location(x))) def __help_menu(self): """Add the help menu options.""" help_menu = ControllableMenu(self.menubar,tearoff=0,name='help') self.menubar.add_cascade(label='Help',menu=help_menu) help_menu.add_command(label='About',command=self.new_about_window) help_menu.add_command(label="User Manual", command=(lambda x=user_manual_locations: self.open_location(x))) help_menu.add_command(label="Tutorials", command=(lambda x=tutorials_locations: self.open_location(x))) help_menu.add_command(label="Examples", command=self.run_example_script) help_menu.add_command(label="Reference Manual", command=(lambda x=reference_manual_locations: self.open_location(x))) help_menu.add_command(label="Topographica.org", command=(lambda x=topo_www_locations: self.open_location(x))) help_menu.add_command(label="Python documentation", command=(lambda x=python_doc_locations: self.open_location(x))) def quit_topographica(self,check=True,exit_status=0): """Quit topographica.""" if not check or (check and tk.askyesno("Quit Topographica","Really quit?")): self.destroy() # matplotlib's tk backend starts its own Tk instances; we # need to close these ourselves (at least to avoid error # message about 'unusual termination' in Windows). try: # not that there should be an error, but just in case... import matplotlib._pylab_helpers for figman in matplotlib._pylab_helpers.Gcf.get_all_fig_managers(): figman.destroy() except: pass self.message("Quit selected%s" % ("; exiting" if self.exit_on_quit else "")) # Workaround for obscure problem on some UNIX systems # as of 4/2007, probably including Fedora Core 5. # On these systems, if Topographica is started from a # bash prompt and then quit from the Tkinter GUI (as # opposed to using Ctrl-D in the terminal), the # terminal would suppress echoing of all future user # input. stty sane restores the terminal to sanity, # but it is not clear why this is necessary. # For more info: # http://groups.google.com/group/comp.lang.python/browse_thread/thread/68d0f33c8eb2e02d if topo.tkgui.system_platform=="linux" and os.getenv('EMACS')!='t': try: os.system("stty sane") except: pass # CEBALERT: re. above. Shouldn't we be able to store the # output of "stty --save" before starting the gui, then # ensure that when the gui exits (however badly it # happens) run "stty saved_settings"? # CEBALERT: there was no call to self.master.destroy() if self.exit_on_quit: sys.exit(exit_status) def run_script(self): """ Dialog to run a user-selected script The script is exec'd in __main__.__dict__ (i.e. as if it were specified on the commandline.) """ script = askopenfilename(initialdir=normalize_path(),filetypes=SCRIPT_FILETYPES) if script in ('',(),None): # (representing the various ways no script was selected in the dialog) self.messageBar.response('Run canceled') else: execfile(script,__main__.__dict__) self.messageBar.response('Ran ' + script) sim_name_from_filename(script) self.title(topo.sim.name) # CEBALERT: duplicates most of run_script() def run_example_script(self): script = askopenfilename(initialdir=topo.misc.genexamples.find_examples(), filetypes=SCRIPT_FILETYPES) if script in ('',(),None): # (representing the various ways no script was selected in the dialog) self.messageBar.response('No example opened') else: execfile(script,__main__.__dict__) self.messageBar.response('Ran ' + script) sim_name_from_filename(script) self.title(topo.sim.name) def save_script_repr(self): script_name = asksaveasfilename(filetypes=SCRIPT_FILETYPES, initialdir=normalize_path(), initialfile=topo.sim.basename()+"_script_repr.ty") if script_name: topo.command.save_script_repr(script_name) self.messageBar.response('Script saved to ' + script_name) def load_snapshot(self): """ Dialog to load a user-selected snapshot (see topo.command.load_snapshot() ). """ snapshot_name = askopenfilename(initialdir=normalize_path(),filetypes=SAVED_FILETYPES) if snapshot_name in ('',(),None): self.messageBar.response('No snapshot loaded.') else: self.messageBar.dynamicinfo('Loading snapshot (may take some time)...') self.update_idletasks() topo.command.load_snapshot(snapshot_name) self.messageBar.response('Loaded snapshot ' + snapshot_name) self.title(topo.sim.name) self.auto_refresh() def save_snapshot(self): """ Dialog to save a snapshot (see topo.command.save_snapshot() ). Adds the file extension .typ if not already present. """ snapshot_name = asksaveasfilename(filetypes=SAVED_FILETYPES, initialdir=normalize_path(), initialfile=topo.sim.basename()+".typ") if snapshot_name in ('',(),None): self.messageBar.response('No snapshot saved.') else: if not snapshot_name.endswith('.typ'): snapshot_name = snapshot_name + SAVED_FILE_EXTENSION self.messageBar.dynamicinfo('Saving snapshot (may take some time)...') self.update_idletasks() topo.command.save_snapshot(snapshot_name) self.messageBar.response('Snapshot saved to ' + snapshot_name) def auto_refresh(self, update=True): """ Refresh all windows in auto_refresh_panels. Panels can add and remove themselves to the list; those in the list will have their refresh() method called whenever this console's autorefresh() is called. """ for win in self.auto_refresh_panels: win.refresh(update) self.set_step_button_state() self.update_idletasks() ### CEBERRORALERT: why doesn't updatecommand("display=True") for an ### orientation preference map measurement work with the ### hierarchical example? I guess this is the reason I thought the ### updating never worked properly (or I really did break it ### recently - or I'm confused)... def refresh_activity_windows(self): """ Update any windows with a plotgroup_key ending in 'Activity'. Used primarily for debugging long scripts that present a lot of activity patterns. """ for win in self.auto_refresh_panels: if re.match('.*Activity$',win.plotgroup.name): win.refresh() self.update_idletasks() def open_model_editor(self): """Start the Model editor.""" return ModelEditor(self) def new_about_window(self): win = tk.AppWindow(self) win.withdraw() win.title("About Topographica") text = Label(win,text=topo.about(display=False),justify=LEFT) text.pack(side=LEFT) win.deiconify() #self.messageBar.message('state', 'OK') def open_location(self, locations): """ Try to open one of the specified locations in a new window of the default browser. See webbrowser module for more information. locations should be a tuple. """ # CB: could have been a list. This is only here because if locations is set # to a string, it will loop over the characters of the string. assert isinstance(locations,tuple),"locations must be a tuple." for location in locations: try: existing_location = resolve_path(location) webbrowser.open(existing_location,new=2,autoraise=True) self.messageBar.response('Opened local file '+existing_location+' in browser.') return ### except: pass for location in locations: if location.startswith('http'): try: webbrowser.open(location,new=2,autoraise=True) self.messageBar.response('Opened remote location '+location+' in browser.') return ### except: pass self.messageBar.response("Could not open any of %s in a browser."%locations) # CEBALERT: need to take care of removing old messages automatically? # (Otherwise callers might always have to pass 'ok'.) def status_message(self,m): self.messageBar.response(m) def run_simulation(self,event=None): # event=None allows use as callback """ Run the simulation for the duration specified in the 'run for' taggedslider. """ fduration = self.run_for_var.get() self.open_progress_window(timer=topo.sim.timer) topo.sim.run_and_time(fduration) self.auto_refresh() # CEBERRORALERT: Step button does strange things at time==0. # E.g. for lissom_oo_or, nothing appears to happen. For # hierarchical, runs to time==10. def run_step(self): if not topo.sim.events: # JP: step button should be disabled if there are no events, # but just in case... return # JPALERT: This should really use .run_and_time() but it doesn't support # run(until=...) topo.sim.run(until=topo.sim.events[0].time) self.auto_refresh() def set_step_button_state(self): if topo.sim.events: self.step_button.config(state=NORMAL) else: self.step_button.config(state=DISABLED) def __get_status_bar(self,i=2): # Hack to find appropriate status bar: Go back through frames # until a widget with a status bar is found, and return it. try: while True: f = sys._getframe(i) if hasattr(f,'f_locals'): if 'self' in f.f_locals: o = f.f_locals['self'] # (temporary hack til ScrolledFrame cleaned up) if o.__class__.__name__!='ScrolledFrame': if hasattr(o,'messageBar'): return o.messageBar elif hasattr(o,'status'): return o.status i+=1 except: pass #print "GUI INTERNAL WARNING: failed to determine window on which to display message." return self.messageBar def open_progress_window(self,timer,title=None): """ Provide a convenient link to progress bars. """ stat = self.__get_status_bar() return stat.open_progress_window(timer=timer,sim=topo.sim)
class wm_seg: """ Simple GUI application If the application inside a container, automatic updates are removed. The application uses two frames (tabs): - training - testing """ def __init__(self, master, container): self.master = master master.title("nicMSlesions") # running on a container self.container = container # gui attributes self.path = os.getcwd() self.default_config = None self.user_config = None self.current_folder = os.getcwd() self.list_train_pretrained_nets = [] self.list_test_nets = [] self.version = __version__ if self.container is False: # version_number self.commit_version = subprocess.check_output( ['git', 'rev-parse', 'HEAD']) # queue and thread parameters. All processes are embedded # inside threads to avoid freezing the application self.train_task = None self.test_task = None self.test_queue = Queue.Queue() self.train_queue = Queue.Queue() # -------------------------------------------------- # parameters. Mostly from the config/*.cfg files # -------------------------------------------------- # data parameters self.param_training_folder = StringVar() self.param_test_folder = StringVar() self.param_FLAIR_tag = StringVar() self.param_T1_tag = StringVar() self.param_MOD3_tag = StringVar() self.param_MOD4_tag = StringVar() self.param_mask_tag = StringVar() self.param_model_tag = StringVar() self.param_register_modalities = BooleanVar() self.param_skull_stripping = BooleanVar() self.param_denoise = BooleanVar() self.param_denoise_iter = IntVar() self.param_save_tmp = BooleanVar() self.param_debug = BooleanVar() # train parameters self.param_net_folder = os.path.join(self.current_folder, 'nets') self.param_use_pretrained_model = BooleanVar() self.param_pretrained_model = StringVar() self.param_inference_model = StringVar() self.param_num_layers = IntVar() self.param_net_name = StringVar() self.param_net_name.set('None') self.param_balanced_dataset = StringVar() self.param_fract_negatives = DoubleVar() # model parameters self.param_pretrained = None self.param_min_th = DoubleVar() self.param_patch_size = IntVar() self.param_weight_paths = StringVar() self.param_load_weights = BooleanVar() self.param_train_split = DoubleVar() self.param_max_epochs = IntVar() self.param_patience = IntVar() self.param_batch_size = IntVar() self.param_net_verbose = IntVar() self.param_t_bin = DoubleVar() self.param_l_min = IntVar() self.param_min_error = DoubleVar() self.param_mode = BooleanVar() self.param_gpu_number = IntVar() # load the default configuration from the conf file self.load_default_configuration() # self frame (tabbed notebook) self.note = Notebook(self.master) self.note.pack() os.system('cls' if platform.system() == 'Windows' else 'clear') print "##################################################" print "# ------------ #" print "# nicMSlesions #" print "# ------------ #" print "# MS WM lesion segmentation #" print "# #" print "# ------------------------------- #" print "# (c) Sergi Valverde 2018 #" print "# Neuroimage Computing Group #" print "# ------------------------------- #" print "##################################################\n" print "Please select options for training or inference in the menu..." # -------------------------------------------------- # training tab # -------------------------------------------------- self.train_frame = Frame() self.note.add(self.train_frame, text="Training") self.test_frame = Frame() self.note.add(self.test_frame, text="Inference") # label frames cl_s = 5 self.tr_frame = LabelFrame(self.train_frame, text="Training images:") self.tr_frame.grid(row=0, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) self.model_frame = LabelFrame(self.train_frame, text="CNN model:") self.model_frame.grid(row=5, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) # training options self.inFolderLbl = Label(self.tr_frame, text="Training folder:") self.inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2) self.inFolderTxt = Entry(self.tr_frame) self.inFolderTxt.grid(row=0, column=1, columnspan=5, sticky="W", pady=3) self.inFileBtn = Button(self.tr_frame, text="Browse ...", command=self.load_training_path) self.inFileBtn.grid(row=0, column=5, columnspan=1, sticky='W', padx=5, pady=1) self.optionsBtn = Button(self.tr_frame, text="Other options", command=self.parameter_window) self.optionsBtn.grid(row=0, column=10, columnspan=1, sticky="W", padx=(100, 1), pady=1) # setting input modalities: FLAIR + T1 are mandatory # Mod 3 / 4 are optional self.flairTagLbl = Label(self.tr_frame, text="FLAIR tag:") self.flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2) self.flairTxt = Entry(self.tr_frame, textvariable=self.param_FLAIR_tag) self.flairTxt.grid(row=1, column=1, columnspan=1, sticky="W", pady=1) self.t1TagLbl = Label(self.tr_frame, text="T1 tag:") self.t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2) self.t1Txt = Entry(self.tr_frame, textvariable=self.param_T1_tag) self.t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1) self.mod3TagLbl = Label(self.tr_frame, text="mod 3 tag:") self.mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2) self.mod3Txt = Entry(self.tr_frame, textvariable=self.param_MOD3_tag) self.mod3Txt.grid(row=3, column=1, columnspan=1, sticky="W", pady=1) self.mod4TagLbl = Label(self.tr_frame, text="mod 4 tag:") self.mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2) self.mod4Txt = Entry(self.tr_frame, textvariable=self.param_MOD4_tag) self.mod4Txt.grid(row=4, column=1, columnspan=1, sticky="W", pady=1) self.maskTagLbl = Label(self.tr_frame, text="MASK tag:") self.maskTagLbl.grid(row=5, column=0, sticky='E', padx=5, pady=2) self.maskTxt = Entry(self.tr_frame, textvariable=self.param_mask_tag) self.maskTxt.grid(row=5, column=1, columnspan=1, sticky="W", pady=1) # model options self.modelTagLbl = Label(self.model_frame, text="Model name:") self.modelTagLbl.grid(row=6, column=0, sticky='E', padx=5, pady=2) self.modelTxt = Entry(self.model_frame, textvariable=self.param_net_name) self.modelTxt.grid(row=6, column=1, columnspan=1, sticky="W", pady=1) self.checkPretrain = Checkbutton(self.model_frame, text="use pretrained", var=self.param_use_pretrained_model) self.checkPretrain.grid(row=6, column=3, padx=5, pady=5) self.update_pretrained_nets() self.pretrainTxt = OptionMenu(self.model_frame, self.param_pretrained_model, *self.list_train_pretrained_nets) self.pretrainTxt.grid(row=6, column=5, sticky='E', padx=5, pady=5) # START button links self.trainingBtn = Button(self.train_frame, state='disabled', text="Start training", command=self.train_net) self.trainingBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1) # -------------------------------------------------- # inference tab # -------------------------------------------------- self.tt_frame = LabelFrame(self.test_frame, text="Inference images:") self.tt_frame.grid(row=0, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) self.test_model_frame = LabelFrame(self.test_frame, text="CNN model:") self.test_model_frame.grid(row=5, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) # testing options self.test_inFolderLbl = Label(self.tt_frame, text="Testing folder:") self.test_inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2) self.test_inFolderTxt = Entry(self.tt_frame) self.test_inFolderTxt.grid(row=0, column=1, columnspan=5, sticky="W", pady=3) self.test_inFileBtn = Button(self.tt_frame, text="Browse ...", command=self.load_testing_path) self.test_inFileBtn.grid(row=0, column=5, columnspan=1, sticky='W', padx=5, pady=1) self.test_optionsBtn = Button(self.tt_frame, text="Other options", command=self.parameter_window) self.test_optionsBtn.grid(row=0, column=10, columnspan=1, sticky="W", padx=(100, 1), pady=1) self.test_flairTagLbl = Label(self.tt_frame, text="FLAIR tag:") self.test_flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2) self.test_flairTxt = Entry(self.tt_frame, textvariable=self.param_FLAIR_tag) self.test_flairTxt.grid(row=1, column=1, columnspan=1, sticky="W", pady=1) self.test_t1TagLbl = Label(self.tt_frame, text="T1 tag:") self.test_t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2) self.test_t1Txt = Entry(self.tt_frame, textvariable=self.param_T1_tag) self.test_t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1) self.test_mod3TagLbl = Label(self.tt_frame, text="mod 3 tag:") self.test_mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2) self.test_mod3Txt = Entry(self.tt_frame, textvariable=self.param_MOD3_tag) self.test_mod3Txt.grid(row=3, column=1, columnspan=1, sticky="W", pady=1) self.test_mod4TagLbl = Label(self.tt_frame, text="mod 4 tag:") self.test_mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2) self.test_mod4Txt = Entry(self.tt_frame, textvariable=self.param_MOD4_tag) self.test_mod4Txt.grid(row=4, column=1, columnspan=1, sticky="W", pady=1) self.test_pretrainTxt = OptionMenu(self.test_model_frame, self.param_inference_model, *self.list_test_nets) self.param_inference_model.set('None') self.test_pretrainTxt.grid(row=5, column=0, sticky='E', padx=5, pady=5) # START button links cto docker task self.inferenceBtn = Button(self.test_frame, state='disabled', text="Start inference", command=self.infer_segmentation) self.inferenceBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1) # train / test ABOUT button self.train_aboutBtn = Button(self.train_frame, text="about", command=self.about_window) self.train_aboutBtn.grid(row=7, column=4, sticky='E', padx=(1, 1), pady=1) self.test_aboutBtn = Button(self.test_frame, text="about", command=self.about_window) self.test_aboutBtn.grid(row=7, column=4, sticky='E', padx=(1, 1), pady=1) # Processing state self.process_indicator = StringVar() self.process_indicator.set(' ') self.label_indicator = Label(master, textvariable=self.process_indicator) self.label_indicator.pack(side="left") # Closing processing events is implemented via # a master protocol self.master.protocol("WM_DELETE_WINDOW", self.close_event) def parameter_window(self): """ Setting other parameters using an emerging window CNN parameters, CUDA device, post-processing.... """ t = Toplevel(self.master) t.wm_title("Other parameters") # data parameters t_data = LabelFrame(t, text="data options:") t_data.grid(row=0, sticky="WE") checkPretrain = Checkbutton(t_data, text="Register modalities", var=self.param_register_modalities) checkPretrain.grid(row=0, sticky='W') checkSkull = Checkbutton(t_data, text="Skull-strip modalities", var=self.param_skull_stripping) checkSkull.grid(row=1, sticky="W") checkDenoise = Checkbutton(t_data, text="Denoise masks", var=self.param_denoise) checkDenoise.grid(row=2, sticky="W") denoise_iter_label = Label(t_data, text=" Denoise iter: ") denoise_iter_label.grid(row=3, sticky="W") denoise_iter_entry = Entry(t_data, textvariable=self.param_denoise_iter) denoise_iter_entry.grid(row=3, column=1, sticky="E") check_tmp = Checkbutton(t_data, text="Save tmp files", var=self.param_save_tmp) check_tmp.grid(row=4, sticky="W") checkdebug = Checkbutton(t_data, text="Debug mode", var=self.param_debug) checkdebug.grid(row=5, sticky="W") # model parameters t_model = LabelFrame(t, text="Model:") t_model.grid(row=5, sticky="EW") maxepochs_label = Label(t_model, text="Max epochs: ") maxepochs_label.grid(row=6, sticky="W") maxepochs_entry = Entry(t_model, textvariable=self.param_max_epochs) maxepochs_entry.grid(row=6, column=1, sticky="E") trainsplit_label = Label(t_model, text="Validation %: ") trainsplit_label.grid(row=7, sticky="W") trainsplit_entry = Entry(t_model, textvariable=self.param_train_split) trainsplit_entry.grid(row=7, column=1, sticky="E") batchsize_label = Label(t_model, text="Test batch size:") batchsize_label.grid(row=8, sticky="W") batchsize_entry = Entry(t_model, textvariable=self.param_batch_size) batchsize_entry.grid(row=8, column=1, sticky="E") mode_label = Label(t_model, text="Verbosity:") mode_label.grid(row=9, sticky="W") mode_entry = Entry(t_model, textvariable=self.param_net_verbose) mode_entry.grid(row=9, column=1, sticky="E") #gpu_mode = Checkbutton(t_model, # text="GPU:", # var=self.param_mode) #gpu_mode.grid(row=10, sticky="W") gpu_number = Label(t_model, text="GPU number:") gpu_number.grid(row=10, sticky="W") gpu_entry = Entry(t_model, textvariable=self.param_gpu_number) gpu_entry.grid(row=10, column=1, sticky="W") # training parameters tr_model = LabelFrame(t, text="Training:") tr_model.grid(row=12, sticky="EW") balanced_label = Label(tr_model, text="Balanced dataset: ") balanced_label.grid(row=13, sticky="W") balanced_entry = Entry(tr_model, textvariable=self.param_balanced_dataset) balanced_entry.grid(row=13, column=1, sticky="E") fraction_label = Label(tr_model, text="Fraction negative/positives: ") fraction_label.grid(row=14, sticky="W") fraction_entry = Entry(tr_model, textvariable=self.param_fract_negatives) fraction_entry.grid(row=14, column=1, sticky="E") # postprocessing parameters t_post = LabelFrame(t, text="Post-processing: ") t_post.grid(row=15, sticky="EW") t_bin_label = Label(t_post, text="Out probability th: ") t_bin_label.grid(row=16, sticky="W") t_bin_entry = Entry(t_post, textvariable=self.param_t_bin) t_bin_entry.grid(row=16, column=1, sticky="E") l_min_label = Label(t_post, text="Min out region size: ") l_min_label.grid(row=17, sticky="W") l_min_entry = Entry(t_post, textvariable=self.param_l_min) l_min_entry.grid(row=17, column=1, sticky="E") vol_min_label = Label(t_post, text="Min vol error (ml): ") vol_min_label.grid(row=18, sticky="W") vol_min_entry = Entry(t_post, textvariable=self.param_min_error) vol_min_entry.grid(row=18, column=1, sticky="E") def load_default_configuration(self): """ load the default configuration from /config/default.cfg This method assign each of the configuration parameters to class attributes """ default_config = ConfigParser.SafeConfigParser() default_config.read(os.path.join(self.path, 'config', 'default.cfg')) # dastaset parameters self.param_training_folder.set( default_config.get('database', 'train_folder')) self.param_test_folder.set( default_config.get('database', 'inference_folder')) self.param_FLAIR_tag.set(default_config.get('database', 'flair_tags')) self.param_T1_tag.set(default_config.get('database', 't1_tags')) self.param_MOD3_tag.set(default_config.get('database', 'mod3_tags')) self.param_MOD4_tag.set(default_config.get('database', 'mod4_tags')) self.param_mask_tag.set(default_config.get('database', 'roi_tags')) self.param_register_modalities.set( default_config.get('database', 'register_modalities')) self.param_denoise.set(default_config.get('database', 'denoise')) self.param_denoise_iter.set( default_config.getint('database', 'denoise_iter')) self.param_skull_stripping.set( default_config.get('database', 'skull_stripping')) self.param_save_tmp.set(default_config.get('database', 'save_tmp')) self.param_debug.set(default_config.get('database', 'debug')) # train parameters self.param_use_pretrained_model.set( default_config.get('train', 'full_train')) self.param_pretrained_model.set( default_config.get('train', 'pretrained_model')) self.param_inference_model.set(" ") self.param_balanced_dataset.set( default_config.get('train', 'balanced_training')) self.param_fract_negatives.set( default_config.getfloat('train', 'fraction_negatives')) # model parameters self.param_net_folder = os.path.join(self.current_folder, 'nets') self.param_net_name.set(default_config.get('model', 'name')) self.param_train_split.set( default_config.getfloat('model', 'train_split')) self.param_max_epochs.set(default_config.getint('model', 'max_epochs')) self.param_patience.set(default_config.getint('model', 'patience')) self.param_batch_size.set(default_config.getint('model', 'batch_size')) self.param_net_verbose.set(default_config.get('model', 'net_verbose')) self.param_gpu_number.set(default_config.getint('model', 'gpu_number')) # self.param_mode.set(default_config.get('model', 'gpu_mode')) # post-processing self.param_l_min.set(default_config.getint('postprocessing', 'l_min')) self.param_t_bin.set(default_config.getfloat('postprocessing', 't_bin')) self.param_min_error.set( default_config.getfloat('postprocessing', 'min_error')) def write_user_configuration(self): """ write the configuration into config/configuration.cfg """ user_config = ConfigParser.RawConfigParser() # dataset parameters user_config.add_section('database') user_config.set('database', 'train_folder', self.param_training_folder.get()) user_config.set('database', 'inference_folder', self.param_test_folder.get()) user_config.set('database', 'flair_tags', self.param_FLAIR_tag.get()) user_config.set('database', 't1_tags', self.param_T1_tag.get()) user_config.set('database', 'mod3_tags', self.param_MOD3_tag.get()) user_config.set('database', 'mod4_tags', self.param_MOD4_tag.get()) user_config.set('database', 'roi_tags', self.param_mask_tag.get()) user_config.set('database', 'register_modalities', self.param_register_modalities.get()) user_config.set('database', 'denoise', self.param_denoise.get()) user_config.set('database', 'denoise_iter', self.param_denoise_iter.get()) user_config.set('database', 'skull_stripping', self.param_skull_stripping.get()) user_config.set('database', 'save_tmp', self.param_save_tmp.get()) user_config.set('database', 'debug', self.param_debug.get()) # train parameters user_config.add_section('train') user_config.set('train', 'full_train', not (self.param_use_pretrained_model.get())) user_config.set('train', 'pretrained_model', self.param_pretrained_model.get()) user_config.set('train', 'balanced_training', self.param_balanced_dataset.get()) user_config.set('train', 'fraction_negatives', self.param_fract_negatives.get()) # model parameters user_config.add_section('model') user_config.set('model', 'name', self.param_net_name.get()) user_config.set('model', 'pretrained', self.param_pretrained) user_config.set('model', 'train_split', self.param_train_split.get()) user_config.set('model', 'max_epochs', self.param_max_epochs.get()) user_config.set('model', 'patience', self.param_patience.get()) user_config.set('model', 'batch_size', self.param_batch_size.get()) user_config.set('model', 'net_verbose', self.param_net_verbose.get()) # user_config.set('model', 'gpu_mode', self.param_mode.get()) user_config.set('model', 'gpu_number', self.param_gpu_number.get()) # postprocessing parameters user_config.add_section('postprocessing') user_config.set('postprocessing', 't_bin', self.param_t_bin.get()) user_config.set('postprocessing', 'l_min', self.param_l_min.get()) user_config.set('postprocessing', 'min_error', self.param_min_error.get()) # Writing our configuration file to 'example.cfg' with open(os.path.join(self.path, 'config', 'configuration.cfg'), 'wb') as configfile: user_config.write(configfile) def load_training_path(self): """ Select training path from disk and write it. If the app is run inside a container, link the iniitaldir with /data """ initialdir = '/data' if self.container else os.getcwd() fname = askdirectory(initialdir=initialdir) if fname: try: self.param_training_folder.set(fname) self.inFolderTxt.delete(0, END) self.inFolderTxt.insert(0, self.param_training_folder.get()) self.trainingBtn['state'] = 'normal' except: pass def load_testing_path(self): """ Selecet the inference path from disk and write it If the app is run inside a container, link the iniitaldir with /data """ initialdir = '/data' if self.container else os.getcwd() fname = askdirectory(initialdir=initialdir) if fname: try: self.param_test_folder.set(fname) self.test_inFolderTxt.delete(0, END) self.test_inFolderTxt.insert(0, self.param_test_folder.get()) self.inferenceBtn['state'] = 'normal' except: pass def update_pretrained_nets(self): """ get a list of the different net configuration present in the system. Each model configuration is represented by a folder containing the network weights for each of the networks. The baseline net config is always included by default """ folders = os.listdir(self.param_net_folder) self.list_train_pretrained_nets = folders self.list_test_nets = folders def write_to_console(self, txt): """ to doc: important method """ self.command_out.insert(END, str(txt)) def write_to_test_console(self, txt): """ to doc: important method """ self.test_command_out.insert(END, str(txt)) def infer_segmentation(self): """ Method implementing the inference process: - Check network selection - write the configuration to disk - Run the process on a new thread """ if self.param_inference_model.get() == 'None': print "ERROR: Please, select a network model before starting...\n" return if self.test_task is None: self.inferenceBtn.config(state='disabled') self.param_net_name.set(self.param_inference_model.get()) self.param_use_pretrained_model.set(False) self.write_user_configuration() print "\n-----------------------" print "Running configuration:" print "-----------------------" print "Inference model:", self.param_model_tag.get() print "Inference folder:", self.param_test_folder.get(), "\n" print "Method info:" print "------------" self.test_task = ThreadedTask(self.write_to_test_console, self.test_queue, mode='testing') self.test_task.start() self.master.after(100, self.process_container_queue) def train_net(self): """ Method implementing the training process: - write the configuration to disk - Run the process on a new thread """ if self.param_net_name.get() == 'None': print "ERROR: Please, define network name before starting...\n" return self.trainingBtn['state'] = 'disable' if self.train_task is None: self.trainingBtn.update() self.write_user_configuration() print "\n-----------------------" print "Running configuration:" print "-----------------------" print "Train model:", self.param_net_name.get() print "Training folder:", self.param_training_folder.get(), "\n" print "Method info:" print "------------" self.train_task = ThreadedTask(self.write_to_console, self.test_queue, mode='training') self.train_task.start() self.master.after(100, self.process_container_queue) def check_update(self): """ check update version and propose to download it if differnt So far, a rudimentary mode is used to check the last version. """ # I have to discard possible local changes :( print "---------------------------------------" print "Updating software" print "current version:", self.commit_version remote_commit = subprocess.check_output(['git', 'stash']) remote_commit = subprocess.check_output(['git', 'fetch']) remote_commit = subprocess.check_output( ['git', 'rev-parse', 'origin/master']) if remote_commit != self.commit_version: proc = subprocess.check_output(['git', 'pull', 'origin', 'master']) self.check_link.config(text="Updated") self.commit_version = remote_commit print "updated version:", self.commit_version else: print "This software is already in the latest version" print "---------------------------------------" def about_window(self): """ Window showing information about the software and version number, including auto-update. If the application is run from a container, then auto-update is disabled """ def callback(event): """ open webbrowser when clicking links """ webbrowser.open_new(event.widget.cget("text")) # main window t = Toplevel(self.master, width=500, height=500) t.wm_title("About") # NIC logo + name title = Label(t, text="nicMSlesions v" + self.version + "\n" "Multiple Sclerosis White Matter Lesion Segmentation") title.grid(row=2, column=1, padx=20, pady=10) img = ImageTk.PhotoImage(Image.open('./logonic.png')) imglabel = Label(t, image=img) imglabel.image = img imglabel.grid(row=1, column=1, padx=10, pady=10) group_name = Label(t, text="Copyright Sergi Valverde (2018-) \n " + "NeuroImage Computing Group") group_name.grid(row=3, column=1) group_link = Label(t, text=r"http://atc.udg.edu/nic", fg="blue", cursor="hand2") group_link.grid(row=4, column=1) group_link.bind("<Button-1>", callback) license_content = "Licensed under the BSD 2-Clause license. \n" + \ "A copy of the license is present in the root directory." license_label = Label(t, text=license_content) license_label.grid(row=5, column=1, padx=20, pady=20) # if self.container is False: # # check version and updates # version_number = Label(t, text="commit: " + self.commit_version) # version_number.grid(row=6, column=1, padx=20, pady=(1, 1)) # # self.check_link = Button(t, # text="Check for updates", # command=self.check_update) # self.check_link.grid(row=7, column=1) def process_container_queue(self): """ Process the threading queue. When the threaded processes are finished, buttons are reset and a message is shown in the app. """ self.process_indicator.set('Running... please wait') try: msg = self.test_queue.get(0) self.process_indicator.set('Done. See log for more details.') self.inferenceBtn['state'] = 'normal' self.trainingBtn['state'] = 'normal' except Queue.Empty: self.master.after(100, self.process_container_queue) def close_event(self): """ Stop the thread processes using OS related calls. """ if self.train_task is not None: self.train_task.stop_process() if self.test_task is not None: self.test_task.stop_process() os.system('cls' if platform.system == "Windows" else 'clear') root.destroy()
class LintGui: """Build and control a window to interact with pylint""" def __init__(self, root=None): """init""" self.root = root or Tk() self.root.title('Pylint') #reporter self.reporter = None #message queue for output from reporter self.msg_queue = Queue.Queue() self.msgs = [] self.filenames = [] self.rating = StringVar() self.tabs = {} self.report_stream = BasicStream(self) #gui objects self.lbMessages = None self.showhistory = None self.results = None self.btnRun = None self.information_box = None self.convention_box = None self.refactor_box = None self.warning_box = None self.error_box = None self.fatal_box = None self.txtModule = None self.status = None self.msg_type_dict = None self.init_gui() def init_gui(self): """init helper""" #setting up frames top_frame = Frame(self.root) mid_frame = Frame(self.root) radio_frame = Frame(self.root) res_frame = Frame(self.root) msg_frame = Frame(self.root) check_frame = Frame(self.root) history_frame = Frame(self.root) btn_frame = Frame(self.root) rating_frame = Frame(self.root) top_frame.pack(side=TOP, fill=X) mid_frame.pack(side=TOP, fill=X) history_frame.pack(side=TOP, fill=BOTH, expand=True) radio_frame.pack(side=TOP, fill=BOTH, expand=True) rating_frame.pack(side=TOP, fill=BOTH, expand=True) res_frame.pack(side=TOP, fill=BOTH, expand=True) check_frame.pack(side=TOP, fill=BOTH, expand=True) msg_frame.pack(side=TOP, fill=BOTH, expand=True) btn_frame.pack(side=TOP, fill=X) #Message ListBox rightscrollbar = Scrollbar(msg_frame) rightscrollbar.pack(side=RIGHT, fill=Y) bottomscrollbar = Scrollbar(msg_frame, orient=HORIZONTAL) bottomscrollbar.pack(side=BOTTOM, fill=X) self.lbMessages = Listbox(msg_frame, yscrollcommand=rightscrollbar.set, xscrollcommand=bottomscrollbar.set, bg="white") self.lbMessages.pack(expand=True, fill=BOTH) rightscrollbar.config(command=self.lbMessages.yview) bottomscrollbar.config(command=self.lbMessages.xview) #History ListBoxes rightscrollbar2 = Scrollbar(history_frame) rightscrollbar2.pack(side=RIGHT, fill=Y) bottomscrollbar2 = Scrollbar(history_frame, orient=HORIZONTAL) bottomscrollbar2.pack(side=BOTTOM, fill=X) self.showhistory = Listbox(history_frame, yscrollcommand=rightscrollbar2.set, xscrollcommand=bottomscrollbar2.set, bg="white") self.showhistory.pack(expand=True, fill=BOTH) rightscrollbar2.config(command=self.showhistory.yview) bottomscrollbar2.config(command=self.showhistory.xview) self.showhistory.bind('<Double-Button-1>', self.select_recent_file) self.set_history_window() #status bar self.status = Label(self.root, text="", bd=1, relief=SUNKEN, anchor=W) self.status.pack(side=BOTTOM, fill=X) #labels self.lblRatingLabel = Label(rating_frame, text='Rating:') self.lblRatingLabel.pack(side=LEFT) self.lblRating = Label(rating_frame, textvariable=self.rating) self.lblRating.pack(side=LEFT) Label(mid_frame, text='Recently Used:').pack(side=LEFT) Label(top_frame, text='Module or package').pack(side=LEFT) #file textbox self.txtModule = Entry(top_frame, background='white') self.txtModule.bind('<Return>', self.run_lint) self.txtModule.pack(side=LEFT, expand=True, fill=X) #results box rightscrollbar = Scrollbar(res_frame) rightscrollbar.pack(side=RIGHT, fill=Y) bottomscrollbar = Scrollbar(res_frame, orient=HORIZONTAL) bottomscrollbar.pack(side=BOTTOM, fill=X) self.results = Listbox(res_frame, yscrollcommand=rightscrollbar.set, xscrollcommand=bottomscrollbar.set, bg="white", font="Courier") self.results.pack(expand=True, fill=BOTH, side=BOTTOM) rightscrollbar.config(command=self.results.yview) bottomscrollbar.config(command=self.results.xview) #buttons Button(top_frame, text='Open', command=self.file_open).pack(side=LEFT) Button(top_frame, text='Open Package', command=(lambda : self.file_open(package=True))).pack(side=LEFT) self.btnRun = Button(top_frame, text='Run', command=self.run_lint) self.btnRun.pack(side=LEFT) Button(btn_frame, text='Quit', command=self.quit).pack(side=BOTTOM) #radio buttons self.information_box = IntVar() self.convention_box = IntVar() self.refactor_box = IntVar() self.warning_box = IntVar() self.error_box = IntVar() self.fatal_box = IntVar() i = Checkbutton(check_frame, text="Information", fg=COLORS['(I)'], variable=self.information_box, command=self.refresh_msg_window) c = Checkbutton(check_frame, text="Convention", fg=COLORS['(C)'], variable=self.convention_box, command=self.refresh_msg_window) r = Checkbutton(check_frame, text="Refactor", fg=COLORS['(R)'], variable=self.refactor_box, command=self.refresh_msg_window) w = Checkbutton(check_frame, text="Warning", fg=COLORS['(W)'], variable=self.warning_box, command=self.refresh_msg_window) e = Checkbutton(check_frame, text="Error", fg=COLORS['(E)'], variable=self.error_box, command=self.refresh_msg_window) f = Checkbutton(check_frame, text="Fatal", fg=COLORS['(F)'], variable=self.fatal_box, command=self.refresh_msg_window) i.select() c.select() r.select() w.select() e.select() f.select() i.pack(side=LEFT) c.pack(side=LEFT) r.pack(side=LEFT) w.pack(side=LEFT) e.pack(side=LEFT) f.pack(side=LEFT) #check boxes self.box = StringVar() # XXX should be generated report = Radiobutton(radio_frame, text="Report", variable=self.box, value="Report", command=self.refresh_results_window) rawMet = Radiobutton(radio_frame, text="Raw metrics", variable=self.box, value="Raw metrics", command=self.refresh_results_window) dup = Radiobutton(radio_frame, text="Duplication", variable=self.box, value="Duplication", command=self.refresh_results_window) ext = Radiobutton(radio_frame, text="External dependencies", variable=self.box, value="External dependencies", command=self.refresh_results_window) stat = Radiobutton(radio_frame, text="Statistics by type", variable=self.box, value="Statistics by type", command=self.refresh_results_window) msgCat = Radiobutton(radio_frame, text="Messages by category", variable=self.box, value="Messages by category", command=self.refresh_results_window) msg = Radiobutton(radio_frame, text="Messages", variable=self.box, value="Messages", command=self.refresh_results_window) report.select() report.grid(column=0, row=0, sticky=W) rawMet.grid(column=1, row=0, sticky=W) dup.grid(column=2, row=0, sticky=W) msg.grid(column=3, row=0, sticky=E) stat.grid(column=0, row=1, sticky=W) msgCat.grid(column=1, row=1, sticky=W) ext.grid(column=2, row=1, columnspan=2, sticky=W) #dictionary for check boxes and associated error term self.msg_type_dict = { 'I' : lambda : self.information_box.get() == 1, 'C' : lambda : self.convention_box.get() == 1, 'R' : lambda : self.refactor_box.get() == 1, 'E' : lambda : self.error_box.get() == 1, 'W' : lambda : self.warning_box.get() == 1, 'F' : lambda : self.fatal_box.get() == 1 } self.txtModule.focus_set() def select_recent_file(self, event): """adds the selected file in the history listbox to the Module box""" if not self.showhistory.size(): return selected = self.showhistory.curselection() item = self.showhistory.get(selected) #update module self.txtModule.delete(0, END) self.txtModule.insert(0, item) def refresh_msg_window(self): """refresh the message window with current output""" #clear the window self.lbMessages.delete(0, END) for msg in self.msgs: if (self.msg_type_dict.get(msg[0])()): msg_str = self.convert_to_string(msg) self.lbMessages.insert(END, msg_str) fg_color = COLORS.get(msg_str[:3], 'black') self.lbMessages.itemconfigure(END, fg=fg_color) def refresh_results_window(self): """refresh the results window with current output""" #clear the window self.results.delete(0, END) try: for res in self.tabs[self.box.get()]: self.results.insert(END, res) except: pass def convert_to_string(self, msg): """make a string representation of a message""" if (msg[2] != ""): return "(" + msg[0] + ") " + msg[1] + "." + msg[2] + " [" + msg[3] + "]: " + msg[4] else: return "(" + msg[0] + ") " + msg[1] + " [" + msg[3] + "]: " + msg[4] def process_incoming(self): """process the incoming messages from running pylint""" while self.msg_queue.qsize(): try: msg = self.msg_queue.get(0) if msg == "DONE": self.report_stream.output_contents() return False #adding message to list of msgs self.msgs.append(msg) #displaying msg if message type is selected in check box if (self.msg_type_dict.get(msg[0])()): msg_str = self.convert_to_string(msg) self.lbMessages.insert(END, msg_str) fg_color = COLORS.get(msg_str[:3], 'black') self.lbMessages.itemconfigure(END, fg=fg_color) except Queue.Empty: pass return True def periodic_call(self): """determine when to unlock the run button""" if self.process_incoming(): self.root.after(100, self.periodic_call) else: #enabling button so it can be run again self.btnRun.config(state=NORMAL) def mainloop(self): """launch the mainloop of the application""" self.root.mainloop() def quit(self, _=None): """quit the application""" self.root.quit() def halt(self): """program halt placeholder""" return def file_open(self, package=False, _=None): """launch a file browser""" if not package: filename = askopenfilename(parent=self.root, filetypes=[('pythonfiles', '*.py'), ('allfiles', '*')], title='Select Module') else: filename = askdirectory(title="Select A Folder", mustexist=1) if filename == (): return self.txtModule.delete(0, END) self.txtModule.insert(0, filename) def update_filenames(self): """update the list of recent filenames""" filename = self.txtModule.get() if not filename: filename = os.getcwd() if filename+'\n' in self.filenames: index = self.filenames.index(filename+'\n') self.filenames.pop(index) #ensure only 10 most recent are stored if len(self.filenames) == 10: self.filenames.pop() self.filenames.insert(0, filename+'\n') def set_history_window(self): """update the history window with info from the history file""" #clear the window self.showhistory.delete(0, END) # keep the last 10 most recent files try: view_history = open(HOME+HISTORY, 'r') for hist in view_history.readlines(): if not hist in self.filenames: self.filenames.append(hist) self.showhistory.insert(END, hist.split('\n')[0]) view_history.close() except IOError: # do nothing since history file will be created later return def run_lint(self, _=None): """launches pylint""" self.update_filenames() self.root.configure(cursor='watch') self.reporter = GUIReporter(self, output=self.report_stream) module = self.txtModule.get() if not module: module = os.getcwd() #cleaning up msgs and windows self.msgs = [] self.lbMessages.delete(0, END) self.tabs = {} self.results.delete(0, END) self.btnRun.config(state=DISABLED) #setting up a worker thread to run pylint worker = Thread(target=lint_thread, args=(module, self.reporter, self,)) self.periodic_call() worker.start() # Overwrite the .pylint-gui-history file with all the new recently added files # in order from filenames but only save last 10 files write_history = open(HOME+HISTORY, 'w') write_history.writelines(self.filenames) write_history.close() self.set_history_window() self.root.configure(cursor='')
class gui: def __init__(self, sonar): self.tk = Tk() self.canvas = Canvas(self.tk, height=800, width=800) self.canvas.pack() self.next = Button(self.tk, text='next', command=self.step) self.next.pack() self.rb = Button(self.tk, text='run', command=self.run) self.rb.pack() self.sonar = sonar self.draw_map() self.draw_move_points() self.delete_old = True #self.tk.after(20,self.redraw) self.tk.mainloop() def run(self): self.next.config(state='disabled') self.rb.config(state='disabled') self.manual = False self.tk.after(50, self.redraw) def step(self): self.manual = True self.redraw() def redraw(self): check = self.sonar.sim_step() if self.delete_old: self.canvas.delete('scan') self.canvas.delete('intersect') self.canvas.delete('particle') self.canvas.delete('mvln') self.draw_sonar_data() self.draw_particle_data() if check is not -1 and self.manual is False: self.tk.after(50, self.redraw) def draw_sonar_data(self): #print 'data' #for line in self.sonar.scan_lines: #draw_line(self.canvas, line, tag='scan') #for point in self.sonar.intersection_points: #draw_point(self.canvas, point, tag='intersect') draw_point(self.canvas, self.sonar.loc, tag='sonar', colour='red') def draw_particle_data(self): particles = self.sonar.particles.list() for particle in particles: draw_point(self.canvas, particle.loc, weight=particle.wt, tag='particle') if particle.move_line: draw_line(self.canvas, particle.move_line, tag='mvln') #for line in particle.scan: # draw_line(self.canvas, line, tag='scan') #for intersect in particle.int: #draw_point(self.canvas, intersect, tag='intersect') def draw_map(self): #print 'map' for line in self.sonar.map.lines: draw_line(self.canvas, line, tag='map') def draw_move_points(self): for point in self.sonar.get_move_list(): draw_point(self.canvas, point[0], tag='mvpt')
class ResultList(Frame): """ Result List widget """ def __init__(self, master=None): Frame.__init__(self, master, padx=3, pady=3) self.columnconfigure(0, weight=1, minsize=50) self.columnconfigure(1, weight=1000) self.columnconfigure(2, weight=1, minsize=10) self.__createWidgets() self.show() def __createWidgets(self): self.lbl = Label(text="") self.lbl.grid(row=1, column=0, columnspan=2, in_=self) self.__hide_button = Button(text="Hide", command=self.hide) self.__hide_button.grid(row=0, column=0, columnspan=2, in_=self) self.__yScroll = Scrollbar(orient=VERTICAL) self.list = Listbox(yscrollcommand=self.__yScroll.set, selectmode=SINGLE) self.__yScroll.config(command=self.list.yview) def show(self): self.__hide_button.config(text="Hide", command=self.hide) self.list.grid(row=2, column=0, columnspan=2, sticky=N + S + E + W, in_=self) self.__yScroll.grid(row=2, column=2, sticky=W + N + S, in_=self) def hide(self): self.__hide_button.config(text="Show", command=self.show) self.list.grid_forget() self.__yScroll.grid_forget() def clear(self): self.list.delete(0, END) def fill(self, valList): self.clear() for v in valList: self.list.insert(END, v) self.list.see(0) self.select(0) def append(self, val): self.list.insert(END, val) self.list.see(END) def select(self, index=0): self.list.selection_set(index) def selected(self): return int(self.list.curselection()[0]) def width(self, width): self.list.config(width=width)