def new_label(self): # Creating a new row header self._number_of_labels += 1 frame_button = Frame(self._frame_of_row_numbers, height=self._row_height) frame_button.pack() frame_button.pack_propagate(False) row_label = Label(frame_button, text =self._number_of_labels, **self._labelrow_kwargs) row_label.bind("<1>", lambda event, index=self._number_of_labels-1: self._on_click_label(index)) if self._hover_background: row_label.bind("<Enter>", lambda event, row_label=row_label: row_label.configure(background=self._hover_background)) row_label.bind("<Leave>", lambda event, row_label=row_label: row_label.configure(background=self.cget("background"))) row_label.pack(expand=True, fill=BOTH) width_of_row_numbers= max(row_label.winfo_reqwidth(), self._row_minwidth) if width_of_row_numbers > self._width_of_row_numbers: self._width_of_row_numbers = width_of_row_numbers for slave in self._frame_of_row_numbers.pack_slaves(): slave.configure(width=width_of_row_numbers) else: frame_button.configure(width=width_of_row_numbers) frame_button.update_idletasks() self.config(width=self._frame_of_row_numbers.winfo_reqwidth()) self.config(scrollregion=(0, 0, self._frame_of_row_numbers.winfo_reqwidth(), self._number_of_labels*self._row_height))
class classifier(Tk): def __init__(self, parent): Tk.__init__(self, parent) self.parent = parent self.initialise() def initialise(self): self.grid() self.bind('<Key>', self.key) with open('image_list.txt') as f: self.file_list = f.readlines() self.label = Label(self, image=self.get_image(), width=100, height=100) self.label.pack() def get_image(self): image_name = self.file_list.pop(0).strip() self.filename = image_name self.image = PhotoImage(file=image_name) return self.image def key(self, event): key = event.char if ord(key) >= ord('A') and ord(key) <= ord('z') or key == ' ': print "Recognised as ", key self.label.configure(image=self.get_image()) with open('lists/'+key+'.txt', 'a') as f: f.write(self.filename+"\n")
class classifier(Tk): def __init__(self, parent): Tk.__init__(self, parent) self.parent = parent self.initialise() def initialise(self): self.grid() self.bind('<Key>', self.key) with open('image_list.txt') as f: self.file_list = f.readlines() self.label = Label(self, image=self.get_image(), width=100, height=100) self.label.pack() def get_image(self): image_name = self.file_list.pop(0).strip() self.filename = image_name self.image = PhotoImage(file=image_name) return self.image def key(self, event): key = event.char if ord(key) >= ord('A') and ord(key) <= ord('z') or key == ' ': print "Recognised as ", key self.label.configure(image=self.get_image()) with open('lists/' + key + '.txt', 'a') as f: f.write(self.filename + "\n")
class App: def __init__(self, root): self.root = root self.img = self.readImage('/home/juan/Desktop/[email protected]') frame = Frame(root, width=100, height=100) # Put it in the display window self.label = Label(frame, image=self.img) self.label.pack() button = Button(frame, command=self.changeImage, text='OK') button.pack() frame.pack() def changeImage(self): self.img = self.readImage('/home/juan/Desktop/Bill_Clinton_0002.jpg') self.label.configure(image=self.img) self.label.pack() self.root.update_idletasks() def readImage(self, path): img = cv2.imread(path) # Rearrang the color channel b, g, r = cv2.split(img) img = cv2.merge((r, g, b)) # Convert the Image object into a TkPhoto object im = Image.fromarray(img) return ImageTk.PhotoImage(image=im)
class ImageFrame(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.setup() self.initUI() self.schedule() def setup(self): self.capture = cv2.VideoCapture(0) self.key = StringVar() self.val = DoubleVar() def initUI(self): self.parent.title("Buttons") self.style = Style() self.style.theme_use("default") frame = Frame(self, relief=GROOVE, borderwidth=5) frame.pack(fill=BOTH, expand=1) self.pack(fill = BOTH, expand = 1) self.imageLabel = Label(frame, image = "") self.imageLabel.pack(fill=BOTH, expand=1) closeButton = Button(self, text="Close") closeButton.pack(side=RIGHT) okButton = Button(self, text="OK") okButton.pack(side=RIGHT) options = [item for item in dir(cv2.cv) if item.startswith("CV_CAP_PROP")] option = OptionMenu(self, self.key, *options) self.key.set(options[0]) option.pack(side="left") spin = Spinbox(self, from_=0, to=1, increment=0.05) self.val = spin.get() spin.pack(side="left") def schedule(self): def captureImg(): ret, frame = self.capture.read() # Convert the Image object into a TkPhoto object b,g,r = cv2.split(frame) frame = cv2.merge((r,g,b)) im = Image.fromarray(frame) im = im.resize((640, 480),Image.ANTIALIAS) imgtk = ImageTk.PhotoImage(image=im) # Put it in the display window self.imageLabel.configure(image = imgtk) self.imageLabel.image = imgtk self.after(100, captureImg) self.after(100, captureImg)
def runSim(self): import Tkinter from Tkinter import Tk, Button, Frame, Label root = Tk() root.title('lights simulator') def onNext(): self.nextProgram() pgmName.configure(text=str(self.currentProgramIndex) + ') ' + self.getProgramName()) #print self.getProgramName() def onPrev(): self.prevProgram() pgmName.configure(text=str(self.currentProgramIndex) + ') ' + self.getProgramName()) #print self.getProgramName() pgmFrame = Frame(root) nxt = Button(pgmFrame, text="next", command=onNext) nxt.pack(side=Tkinter.LEFT) prev = Button(pgmFrame, text="prev", command=onPrev) prev.pack(side=Tkinter.LEFT) pgmName = Label(pgmFrame, text=self.getProgramName()) pgmName.configure(text=str(self.currentProgramIndex) + ') ' + self.getProgramName()) pgmName.pack(side=Tkinter.LEFT, fill=Tkinter.X) pgmFrame.pack(fill=Tkinter.X) lightDarkFrame = Frame(root) front = Button(lightDarkFrame, text="front", command=lambda: self.frontBtn()) front.pack(side=Tkinter.LEFT) dark = Button(lightDarkFrame, text="dark", command=lambda: self.darkBtn()) dark.pack(side=Tkinter.LEFT) lightDarkFrame.pack() btnFrame = Frame(root) for i in range(5): b = Button(btnFrame, text=str(i), command=lambda n=i: self.btn(n)) b.pack(side=Tkinter.LEFT) btnFrame.pack() lightFrame = Frame(root, height=400, width=400) lightFrame.pack() for name, l in allLights.items(): w = Label(lightFrame, text=" ", bg="black") l['light'].setSimWidget(w) w.place(x=l['simX'], y=350-l['simY']) def update(): for name, l in allLights.items(): l['light'].update() root.after(10, update) update() root.mainloop()
class TrackingGotoCoordsDialog(Dialog): def __init__(self, parent = None, ): #set up dialog windows Dialog.__init__(self, parent = parent, title = "Tracking Go to Coords", buttons = ('OK',), defaultbutton = 'OK', ) main_frame = self.interior() az_frame = Frame(main_frame) self.az_field = EntryField(az_frame, labelpos = 'w', label_text = " azimuth target:", label_font = FIELD_LABEL_FONT, entry_width = FIELD_ENTRY_WIDTH, #entry_state = 'readonly', ) self.az_field.pack(side='left', anchor="w", expand='no') self.az_limits_label = Label(az_frame, text = "(min=???,max=???)") self.az_limits_label.pack(side='right', anchor='w', expand='no') az_frame.pack(side='top') el_frame = Frame(main_frame) self.el_field = EntryField(el_frame, labelpos = 'w', label_text = "elevation target:", label_font = FIELD_LABEL_FONT, entry_width = FIELD_ENTRY_WIDTH, #entry_state = 'readonly', ) self.el_field.pack(side='left', anchor="w", expand='no') self.el_limits_label = Label(el_frame, text = "(min=???,max=???)") self.el_limits_label.pack(side='right', anchor='w', expand='no') el_frame.pack(side='top') def set_limits(self, az_CW_limit, az_CCW_limit, el_CW_limit, el_CCW_limit): az_min = min(az_CW_limit, az_CCW_limit) az_max = max(az_CW_limit, az_CCW_limit) self.az_field.configure( validate = Validator(_min=az_min,_max=az_max,converter=float)) self.az_limits_label.configure(text="(min=%0.2f,max=%0.2f)" % (az_min,az_max)) el_min = min(el_CW_limit, el_CCW_limit) el_max = max(el_CW_limit, el_CCW_limit) self.el_field.configure(validate = Validator(_min=el_min,_max=el_max,converter=float)) self.el_limits_label.configure(text="(min=%0.2f,max=%0.2f)" % (el_min,el_max)) def activate(self): "override activate to construct and send back the action and the new values" action = Dialog.activate(self) if action == 'OK' and not (self.az_field.valid() and self.el_field.valid()): return self.activate() return action
class image(): def __init__(self, frm): self.frm = frm.frame self.widget = Label(self.frm, image=None) def set_image(self, path): self.bard = Image.open(path) self.bard = self.bard.resize((500, 500)) ba = ImageTk.PhotoImage(self.bard) self.widget.configure(image=ba) self.widget.image = self.ba self.widget.pack()
class image: def __init__(self, frm): self.frm = frm.frame self.widget = Label(self.frm, image=None) def set_image(self, path): self.bard = Image.open(path) self.bard = self.bard.resize((500, 500)) ba = ImageTk.PhotoImage(self.bard) self.widget.configure(image=ba) self.widget.image = self.ba self.widget.pack()
class JoystickFrame(LabelFrame): def __init__(self, master, tracker, text="Joystick", **options): LabelFrame.__init__(self, master, text=text, **options) self.tracker = tracker self.width = 400 self.height = 400 self.canvas = Canvas(self, height=self.height, width=self.width) self.canvas.grid() self.canvas.create_oval((self.width/2 - 3, self.height/2 - 3, self.width/2 + 3, self.height/2 + 3)) self.canvas.bind("<Button-1>", bg_caller(lambda event: self.move_tracker(event))) self.canvas.bind("<Motion>", self.update_label) self.motion_label = Label(self, text="", font=tkFont.Font(family="Courier")) self.motion_label.grid() f = LabelFrame(self, text="Sensitivity") self.sensitivity_scale = Scale(f, from_=0, to=10, resolution=0.01, orient=HORIZONTAL, length=self.width) self.sensitivity_scale.set(5) self.sensitivity_scale.grid() f.grid() @property def sensitivity(self): return self.sensitivity_scale.get() / 2000. def get_delta(self, event): dx = event.x - int(self.canvas['width'])/2. dy = event.y - int(self.canvas['height'])/2. dx_rad = dx*self.sensitivity dy_rad = dy*self.sensitivity dtheta = dy_rad dphi = -dx_rad return (dtheta, dphi) def update_label(self, event): dtheta, dphi = self.get_delta(event) self.motion_label.configure(text="<{:8.5f}, {:8.5f}>".format(dtheta, dphi)) def move_tracker(self, event): dtheta, dphi = self.get_delta(event) self.tracker.move(0, dtheta, dphi) logger.info("Moved tracker by ({}, {})".format(dtheta, dphi))
class DemoWindow(Tk): """ Class to manage the window of the demo """ def __init__(self, fileinput): """ Build the visual interface with images and fields to the images data """ fileinput = realpath(fileinput) self.imgs = ImageManager(fileinput) Tk.__init__(self) self.title("Frame sequence") # width x height + x_offset + y_offset: self.geometry(str(self.imgs.width+20)+"x"+str(self.imgs.height+30)+"+1+1") self.i = 0 self.prev = 0 self.frame = Label(self, text="") self.frame.grid(row=0, column=1, padx=10, pady=2, sticky=N+S+W) self.image = Label(self, image=None) self.image.grid(row=1, column=1, padx=10, pady=2, sticky=N+S+W) self.update_window() def updateImage(self, img): """ Update the Label containing the image """ self.tkimage = ImageTk.PhotoImage(img) self.image.configure(image=self.tkimage) def updateLabelFrame(self, text): """ Update the label containing the number of the frame """ self.frame.configure(text='Frame: '+text) def update_window(self): """ Update the window and its elements every second """ name, fimg = self.imgs.nextImage() self.updateImage(fimg) self.updateLabelFrame(name) self.after(1, self.update_window)
class TasksGui(object): """A small Tkinter GUI that shows the tasks""" def __init__(self): self.root = Tk() self.size = (self.root.winfo_screenwidth(), self.root.winfo_screenheight()) self.root.overrideredirect(1) self.root.geometry("%dx%d+0+0" % self.size) self.image_count = 19 self.task_index = 0 self.task_images = range(self.image_count) self.photo_images = range(self.image_count) for i in range(self.image_count): self.task_images[i] = Image.open("img/" + str(i + 1) + ".png") self.task_images[i] = self.task_images[i].resize( self.size, Image.ANTIALIAS) self.photo_images[i] = ImageTk.PhotoImage(self.task_images[i]) print "Preload img/" + str(i + 1) + ".png" self.panel = Label(self.root, image=self.photo_images[0], background='white') self.panel.pack(side=TOP, fill=BOTH, expand=YES) self.root.update() def next_task(self): """Continues with the next task""" self.task_index = self.task_index + 1 self.panel.configure(image=self.photo_images[self.task_index]) self.panel.image = self.photo_images[self.task_index] self.root.update() def is_finished(self): """Returns the status of the tasks""" if self.task_index >= self.image_count - 1: return True return False def get_task_index(self): """Returns the task index""" return self.task_index def quit(self): """Qit the GUI""" self.root.quit() self.root.update()
def cycle_through_images(self, images, label): image = images.next() size = self.parsegeometry(self.window.geometry()) # Grab screen size window_size = size[0], size[1] image.thumbnail(window_size, Image.ANTIALIAS) # Resize to fit screen tkimage = ImageTk.PhotoImage(image) if not label: label = Label(self.window, image=tkimage) label.pack(fill=BOTH, expand=YES) label.configure(image=tkimage) label.image = tkimage self.window.after(10000, self.cycle_through_images, images, label)
class TkDemoWindow(TkSlidingWindow): def __init__(self, parent): from Tkinter import Tk, Label, Button self.parent = parent self.win = Tk(className='moving') self.win.overrideredirect(1) self.win.tkraise() self.label = Label(self.win, text=' '*25, font='fixed') self.label.pack(padx=20, pady=10) self.button = Button(self.win, text='OK', command=self.parent.hide) self.button.pack(pady=5) tksupport.install(self.win) def demoText(self, text): self.label.configure(text=text) self.win.geometry('+%d+%d'%self.getScreenSize()) self.label.pack()
class _Label(Frame): def __init__(self, master=None, width=0, height=0, **kwargs): self.width = width self.height = height Frame.__init__(self, master, width=self.width, height=self.height) self.label = Label(self, **kwargs) self.label.pack(expand=True, fill='both') self.label.saved_image = None def pack(self, *args, **kwargs): Frame.pack(self, *args, **kwargs) self.pack_propagate(False) def grid(self, *args, **kwargs): Frame.grid(self, *args, **kwargs) self.grid_propagate(False) @property def image(self): return self.label.saved_image def set_img(self, img): # img = Image.open(filename) width = self.width if img.width > self.width else img.width height = self.height if img.height > self.height else img.height if width == self.width or height == self.height: print 'resized' self_ratio = 1.0 * self.width / self.height img_ratio = 1.0 * img.width / img.height height = self.height if self_ratio > img_ratio else img.height width = self.height * img_ratio resized = img.resize((int(width), int(height)), Image.ANTIALIAS) else: resized = img resized = PhotoImage(resized) self.label.configure(image=resized) self.label.image = resized self.label.saved_image = img
def showtip(self, text): self.text = text if self.tipwindow or not self.text: return x, y, cx, cy = self.widget.bbox('insert') x = x + self.widget.winfo_rootx() + 60 y = y + cy + self.widget.winfo_rooty() + 30 self.tipwindow = tw = Toplevel(self.widget) tw.wm_overrideredirect(1) tw.wm_geometry('+%d+%d' % (x, y)) label = Label(tw, text=self.text) label.configure(justify=LEFT) label.configure(relief=SOLID, bd=1) label.configure(bg=GrayScale(60), fg=GrayScale(220), font=MyFonts['Default']) label.pack(ipadx=1)
class Viewer(): def __init__(self, image): self.original = image self.image = image.copy() self.window = Tk() self.genViews() self.currentView = StringVar(self.window) self.currentView.set('Original') options = self.filters.keys();options.sort() self.views = OptionMenu(self.window, self.currentView, *options, command=self.applyFilter) self.views.pack() self.tkImage = ImageTk.PhotoImage(image) self.lblImage = Label(image=self.tkImage) self.lblImage.bind('<Button-1>', self.displayInfos) self.lblImage.bind('<Button-3>', self.save) self.lblImage.image = self.tkImage self.lblImage.pack() self.status = StringVar() self.lblStatus = Label(textvariable=self.status, justify='right') self.lblStatus.pack() self.window.mainloop() def displayInfos(self, event): """ Displays the coordinates in the status bar """ x = int((event.x-0.1)/args.scalefactor) y = int((event.y-0.1)/args.scalefactor) pixel = orig.getpixel((x, y)) self.setStatus("Coordinates : (%s:%s) - Pixel value : %s" % (x, y, str(pixel))) def setStatus(self, text): """ Changes the text in the status bar """ self.status.set(text) def save(self, event): """ Saves the filtered image to a file """ options = {'filetypes':[('PNG','.png'),('GIF','.gif')]} outfile = tkFileDialog.asksaveasfilename(**options) if outfile == '': return else: self.image.save(outfile) return def genViews(self): """ Generates filters based on the source image """ self.filters = {} for plug in viewPlugins: self.filters.update({plug.name:viewPlugins.index(plug)}) def applyFilter(self, view): """ Applies a filter to the image """ view = self.filters[self.currentView.get()] plugin = viewPlugins[view] if plugin.parameters: for param in plugin.parameters.keys(): a = tkSimpleDialog.askinteger( 'Question', plugin.parameters[param]) if a is not None: setattr(viewPlugins[view], param, a) self.image = viewPlugins[view].process(self.original) self.showImage(self.currentView.get(), self.image) self.setStatus("") return def showImage(self, title, image): """ Updates the image in the window """ self.tkImage = ImageTk.PhotoImage(image) self.lblImage.configure(image=self.tkImage) self.lblImage.image = self.tkImage
class Gui: def __init__(self, master, head_title): self.master = master self.head_title = head_title master.title(head_title) # params definition self.n_clusters = 4 self.n_init = 10 self.file_path = 'C:/' self.is_pre_processed = False self.processor = None self.cluster = None # Tkinter gui self.file_path_text = StringVar(value=self.file_path) self.file_path_label = Label(master, text='Data path:') self.file_path_entry = Entry(master, textvariable=self.file_path_text, width=50) self.browse_button = Button(master, text='Browse', command=self.browse) self.n_clusters_text = StringVar(value=self.n_clusters) self.n_clusters_label = Label(master, text='Num of clusters k:') self.n_clusters_entry = Entry(master, textvariable=self.n_clusters_text) self.n_init_text = StringVar(value=self.n_init) self.n_init_label = Label(master, text='Num of runs:') self.n_init_entry = Entry(master, textvariable=self.n_init_text) self.pre_process_button = Button(master, text='Pre-process', command=self.pre_process) self.build_model_button = Button(master, text='Cluster', command=self.build_model) self.scatter_label = Label(self.master) self.horopleth_label = Label(master) # LAYOUT self.file_path_label.grid(row=0, column=0, sticky=W) self.file_path_entry.grid(row=0, column=1, columnspan=2) self.browse_button.grid(row=0, column=2, sticky=E) self.n_clusters_label.grid(row=1, column=0, sticky=W) self.n_clusters_entry.grid(row=1, column=1, columnspan=2, sticky=W+E) self.n_init_label.grid(row=2, column=0, sticky=W) self.n_init_entry.grid(row=2, column=1, columnspan=2, sticky=W+E) self.pre_process_button.grid(row=3, column=1, sticky=W) self.build_model_button.grid(row=4, column=1, sticky=W) self.scatter_label.grid(row=5, column=0, sticky=W) self.horopleth_label.grid(row=5, column=1, sticky=E) def browse(self): # browse method for choosing the data file path = tkFileDialog.askopenfilename() if path is None or path == '': return self.file_path = path self.file_path_text.set(self.file_path) def pre_process(self): # pre process the data to fit into the algorithm if self.processor is not None: # if we already ran this, ask the user if he wants to run it again result = tkMessageBox.askquestion( message="pre-processing has already been made.\nare you sure you want to run it again?'", icon='warning', title=self.head_title) if result != 'yes': return self.processor = None self.is_pre_processed = False try: # verify the file can be pre-processed self.file_path = self.file_path_text.get() processor = PreProcess(self.file_path) if processor.verifications() is False: tkMessageBox.showerror(title=self.head_title, message=processor.error_message) return # process the data processor.pre_process() tkMessageBox.showinfo(title=self.head_title, message='Preprocessing completed successfully') self.processor = processor self.is_pre_processed = True except Exception as err: template = "An exception of type {0} occurred. Arguments:{1}" message = template.format(type(err).__name__, err) print_exc(err, file=stdout) tkMessageBox.showerror(title=self.head_title, message=message) def build_model(self): # build the kmeans model if not self.is_pre_processed: tkMessageBox.showerror(title=self.head_title, message="pre processing is not validated yet") return if self.cluster is not None: # if we already ran the clustering, verify if we really want to run it again result = tkMessageBox.askquestion( message="clustering has already been made.\nare you sure you want to run it again?", icon='warning', title=self.head_title) if result != 'yes': return self.cluster = None try: # create the kmeans model self.n_clusters = self.n_clusters_text.get() self.n_init = self.n_init_text.get() model = BuildCluster(self.n_clusters, self.n_init, self.processor.df) if model.verifications() is False: tkMessageBox.showerror(title=self.head_title, message=model.error_message) return model.build_cluster() self.cluster = model # draw the graphs in the gui self.draw_graphs() tkMessageBox.showinfo(title=self.head_title, message='Clustering Finished successfully!') except Exception as err: template = "An exception of type {0} occurred. Arguments:{1}" message = template.format(type(err).__name__, err) print_exc(err, file=stdout) tkMessageBox.showerror(title=self.head_title, message=message) def draw_graphs(self): # draw scatter graph using matPlotLib and plotly self.draw_scatter() self.draw_horopleth() def draw_scatter(self): # Draw a scatter plot of Generosity vs social support df = self.cluster.df fig_path = 'scatter.png' plt.scatter(x=df['Generosity'], y=df['Social support'], c=df['cluster'], alpha=0.5) plt.xlabel('Generosity') plt.ylabel('Social support') plt.title("Scatter of Generosity vs Social Support, colored by clusters") plt.savefig(fig_path) # convert from png to gif convert_png_to_gif(fig_path) # display in GUI photo = PhotoImage(file=fig_path.replace('png', 'gif')) self.scatter_label.configure(image=photo, width='400px', height='400px') self.scatter_label.image = photo def draw_horopleth(self): # Draw a horopleth of the country clusters df = self.cluster.df py.sign_in('omrikipiki', 'VcDvTak2bEIiyOfiaxMj') data = [dict( type='choropleth', locations=df['country'], z=df['cluster'], text=df['country'], locationmode='country names', colorscale=[[0, "rgb(5, 10, 172)"], [0.35, "rgb(40, 60, 190)"], [0.5, "rgb(70, 100, 245)"], [0.6, "rgb(90, 120, 245)"], [0.7, "rgb(106, 137, 247)"], [1, "rgb(220, 220, 220)"]], autocolorscale=False, reversescale=True, marker=dict( line=dict( color='rgb(180,180,180)', width=0.5 )), colorbar=dict( # autotick=False, title='Cluster Group'), )] layout = dict( title='K-Means Clustering Visualization', geo=dict( showframe=False, showcoastlines=False, projection=dict( type='Mercator' ) ) ) fig = dict(data=data, layout=layout) py.iplot(fig, validate=False, filename='d3-world-map') fig_path = 'choromap.png' py.image.save_as(fig, filename=fig_path) # convert to gif convert_png_to_gif(fig_path) # put in GUI photo = PhotoImage(file=fig_path.replace('png', 'gif')) self.horopleth_label.configure(image=photo, width='600px', height='600px') self.horopleth_label.image = photo
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 BoardConfig(Frame): def __init__(self, master=None, main=None): Frame.__init__(self, master) self.parent = master self.main = main self.parent.geometry("336x424") self.parent.title(os.getenv("NAME") + " - Board Config") self.master.configure(padx=10, pady=10) self.intvar = IntVar() #Arch self.arch_var = IntVar() lf_arch = LabelFrame(self.parent, text="Architecture") lf_arch.pack(fill=X, expand=True, side=TOP) frame_arch = Frame(lf_arch) frame_arch.pack(fill=X, expand=True, side=TOP) frame_left1 = Frame(frame_arch) frame_left1.pack(expand=True, fill=BOTH, side=LEFT) frame_right1 = Frame(frame_arch) frame_right1.pack(expand=True, fill=BOTH, side=RIGHT) self.radioButton_arch_8 = Radiobutton(frame_left1, text="8-bit ", anchor="w", width=10, value=8, variable=self.arch_var, command=self.update_mode) self.radioButton_arch_8.pack(fill=X, side=TOP) self.radioButton_arch_32 = Radiobutton(frame_right1, text="32-bit", anchor="w", width=10, value=32, variable=self.arch_var, command=self.update_mode) self.radioButton_arch_32.pack(fill=X, side=TOP) #Mode self.mode_var = StringVar() lf_mode = LabelFrame(self.parent, text="Programming mode") lf_mode.pack(fill=X, expand=True, side=TOP) frame_mode = Frame(lf_mode) frame_mode.pack(fill=X, expand=True, side=TOP) frame_left2 = Frame(frame_mode) frame_left2.pack(expand=True, fill=BOTH, side=LEFT) frame_right2 = Frame(frame_mode) frame_right2.pack(expand=True, fill=BOTH, side=RIGHT) self.radioButton_mode_icsp = Radiobutton(frame_left2, text="ICSP", anchor="w", width=10, value="icsp", variable=self.mode_var, command=self.update_mode) self.radioButton_mode_icsp.pack(side=TOP, fill=X) self.radioButton_mode_bootloader = Radiobutton(frame_right2, text="Bootloader", anchor="w", width=10, value="bootloader", variable=self.mode_var, command=self.update_mode) self.radioButton_mode_bootloader.pack(side=TOP, fill=X) #Bootloader self.boot_var = StringVar() self.lf_boot = LabelFrame(self.parent, text="Bootloader") self.lf_boot.pack(fill=X, expand=True, side=TOP) frame_boot = Frame(self.lf_boot) frame_boot.pack(fill=X, expand=True, side=TOP) frame_left3 = Frame(frame_boot) frame_left3.pack(expand=True, fill=BOTH, side=LEFT) frame_right3 = Frame(frame_boot) frame_right3.pack(expand=True, fill=BOTH, side=RIGHT) self.radioButton_bootloader_v1_v2 = Radiobutton(frame_left3, text="v1.x or v2.x", anchor="w", width=10, value="v1_v2", variable=self.boot_var) self.radioButton_bootloader_v1_v2.pack(fill=X, side=TOP, expand=True) self.radioButton_bootloader_v4 = Radiobutton(frame_right3, text="v4.x", anchor="w", width=10, value="v4", variable=self.boot_var) self.radioButton_bootloader_v4.pack(fill=X, side=TOP, expand=True) #Devices 8bit self.dev8_var = StringVar() self.lf_dev8 = LabelFrame(self.parent, text="Devices") self.lf_dev8.pack(fill=X, expand=True, side=TOP) self.frame_8b = Frame(self.lf_dev8) self.frame_8b.pack(fill=X, expand=True, side=TOP) #Devices 32bit self.dev32_var = StringVar() self.lf_dev32 = LabelFrame(self.parent, text="Devices") self.lf_dev32.pack(fill=X, expand=True, side=TOP) self.frame_32b = Frame(self.lf_dev32) self.frame_32b.pack(fill=X, expand=True, side=TOP) frame_buttons = Frame(self.parent) Button(frame_buttons, text="Accept", command=self.accept_config).pack(fill=X, expand=True, side=RIGHT) Button(frame_buttons, text="Cancel", command=self.quit).pack(fill=X, expand=True, side=LEFT) frame_buttons.pack(fill=X, expand=True, side=BOTTOM) frame_advance = Frame(self.parent) self.advanceoptions = Button(frame_advance, text="Advance options", command=self.advance) self.advanceoptions.pack(fill=X, expand=True, side=BOTTOM) frame_advance.pack(fill=X, expand=True, side=BOTTOM) frame_warning = Frame(self.parent) self.label_warning = Label(frame_warning, fg="red", text="warning!", anchor="w") self.label_warning.pack(fill=X, expand=True, side=BOTTOM) frame_warning.pack(fill=X, expand=True, side=BOTTOM) self.build_devices_arch() self.load_config() self.init_groups() #---------------------------------------------------------------------- def quit(self): self.master.destroy() #---------------------------------------------------------------------- def build_devices_arch(self): #8bits name_checked = self.main.configIDE.config("Board", "board_8", "Pinguino 2550") arch_8 = filter(lambda board:board.arch==8, self.main.pinguinoAPI._boards_) arch_8.sort() frame_left = Frame(self.frame_8b) frame_left.pack(expand=True, fill=BOTH, side=LEFT) frame_right = Frame(self.frame_8b) frame_right.pack(expand=True, fill=BOTH, side=RIGHT) parent = frame_left #left for board in arch_8: if arch_8.index(board) == (len(arch_8) / 2) + 1: parent = frame_right #rigth radio = Radiobutton(parent, text=board.name, anchor="w", width=10, value=board.name, variable=self.dev8_var, command=lambda :self.set_board_name(board.name, "8")) radio.pack(expand=True, fill=X, side=TOP) #radio = QtGui.QRadioButton(self.board_config.groupBox_devices_8) #self.board_config.gridLayout_device_8.addWidget(radio, count, side, 1, 1) #radio.setText(board.name) #radio.setToolTip(board.proc) if name_checked == board.name: radio.select() #self.connect(radio, QtCore.SIGNAL("clicked()"), self.set_board_name(board.name, "8")) #32bits name_checked = self.main.configIDE.config("Board", "board_32", "PIC32 Pinguino OTG") arch_32 = filter(lambda board:board.arch==32, self.main.pinguinoAPI._boards_) arch_32.sort() frame_left0 = Frame(self.frame_32b) frame_left0.pack(expand=True, fill=BOTH, side=LEFT) frame_right0 = Frame(self.frame_32b) frame_right0.pack(expand=True, fill=BOTH, side=RIGHT) parent = frame_left0 #left for board in arch_32: if arch_32.index(board) == (len(arch_32) / 2) + 1: parent = frame_right0 #rigth radio = Radiobutton(parent, text=board.name, anchor="w", width=10, value=board.name, variable=self.dev32_var, command=lambda :self.set_board_name(board.name, "32")) radio.pack(expand=True, fill=X, side=TOP) #radio = QtGui.QRadioButton(self.board_config.groupBox_devices_32) #self.board_config.gridLayout_device_32.addWidget(radio, count, side, 1, 1) #radio.setText(board.name) #radio.setToolTip(board.proc) if name_checked == board.name: radio.select() #self.connect(radio, QtCore.SIGNAL("clicked()"), self.set_board_name(board.name, "32")) #---------------------------------------------------------------------- def load_config(self): self.main.configIDE.load_config() arch = self.main.configIDE.config("Board", "arch", 8) getattr(self.radioButton_arch_8, "select" if (arch == 8) else "deselect")() getattr(self.radioButton_arch_32, "select" if (arch == 32) else "deselect")() if arch == 32: self.advanceoptions.pack(fill=X, expand=True, side=BOTTOM) else: self.advanceoptions.forget() mode = self.main.configIDE.config("Board", "mode", "bootloader") getattr(self.radioButton_mode_bootloader, "select" if (mode == "bootloader") else "deselect")() getattr(self.radioButton_mode_icsp, "select" if (mode == "icsp") else "deselect")() bootloader = self.main.configIDE.config("Board", "bootloader", "v1_v2") getattr(self.radioButton_bootloader_v1_v2, "select" if (bootloader == "v1_v2") else "deselect")() getattr(self.radioButton_bootloader_v4, "select" if (bootloader == "v4") else "deselect")() self.update_mode() #---------------------------------------------------------------------- def update_mode(self): mode_boot = self.mode_var.get() == "bootloader" arch_8 = self.arch_var.get() == 8 if mode_boot and arch_8: self.lf_boot.pack(fill=X, expand=True, side=TOP) else: self.lf_boot.forget() self.init_groups() if not mode_boot: self.label_warning.configure(text="WARNING!! this mode can overwite the bootloader code.") else: self.label_warning.configure(text="") #---------------------------------------------------------------------- def set_board_name(self, name, arch): def dummy(): self.main.configIDE.set("Board", "board_"+arch, name) return dummy #---------------------------------------------------------------------- def init_groups(self): self.lf_dev32.forget() self.lf_dev8.forget() if self.arch_var.get() == 8: self.lf_dev8.pack(fill=X, expand=True, side=TOP) self.advanceoptions.forget() else: self.lf_dev32.pack(fill=X, expand=True, side=TOP) self.advanceoptions.pack(fill=X, expand=True, side=BOTTOM) #---------------------------------------------------------------------- def save_config(self): #if self.board_config.radioButton_arch_8.isChecked(): arch = 8 #else: arch = 32 self.main.configIDE.set("Board", "arch", self.arch_var.get()) #if self.board_config.radioButton_mode_bootloader.isChecked(): mode = "bootloader" #else: mode = "icsp" self.main.configIDE.set("Board", "mode", self.mode_var.get()) #if self.board_config.radioButton_bootloader_v1_v2.isChecked(): bootloader = "v1_v2" #else: bootloader = "v4" self.main.configIDE.set("Board", "bootloader", self.boot_var.get()) name = self.main.configIDE.config("Board", "board_"+str(self.arch_var.get()), None) self.main.configIDE.set("Board", "board", name) #---------------------------------------------------------------------- def accept_config(self): self.save_config() self.main.configIDE.save_config() self.main.statusbar_ide(self.main.get_status_board()) self.close_advance() self.quit() #---------------------------------------------------------------------- def advance(self): root = Toplevel() self.frame_advance = BoardConfigAdvance(master=root, main=self.main) self.frame_advance.mainloop() #---------------------------------------------------------------------- def close_advance(self): try: assert self.frame_advance except: return self.frame_advance.quit()
class MainWindow(object): def __init__(self, root, data, interval, font_face, font_size, on_top): # GUI display self.root = root frame = Frame(root) frame.pack() font = (font_face, font_size) self.card = Label(frame, font=font) self.card.pack() # Card refresh interval, in seconds self.refresh_interval = interval # Data for tracking self.data = data self.pending = [] self.current = None # Update card tracking self.reset_card() self.update_card() if on_top: self.root.wm_attributes("-topmost", 1) # Bind events self.root.bind("<Button-1>", self.flip_forward) self.root.bind("<Key-Return>", self.flip_forward) self.root.bind("<Key-space>", self.flip_forward) self.root.bind("<Button-3>", self.flip_backward) self.root.bind("<Key-BackSpace>", self.flip_backward) def reset_card(self): """ Resets the pending list of cards. This method will automatically filter out duplicate entries. """ self.pending = list(set(self.data[:])) def pull_next_card(self): """ Pulls the next card from the card list. This method tracks the current card and will avoid pulling the same card two times in a row (unless there's only one card left to pull). Returns the next card. The value is also set as self.current. """ card = self.current if len(self.pending) < 1: raise EmptyList() elif len(self.pending) == 1: index = 0 card = self.pending[0] else: while card == self.current: index = random.randint(0, len(self.pending) - 1) card = self.pending[index] del self.pending[index] if len(self.pending) < 1: self.reset_card() self.current = card self.current_index = 0 return card def update_card(self): """ Pulls the next card and updates the GUI. This is a self-recurring call. It should only be called at the beginning of the application. """ card = self.pull_next_card() self.card.configure(text=card[0]) refresh_ms = int(self.refresh_interval * 1000) self.root.after(refresh_ms, self.update_card) def flip_forward(self, event): self.current_index = (self.current_index + 1) % len(self.current) self.card.configure(text=self.current[self.current_index]) def flip_backward(self, event): self.current_index = (self.current_index - 1) % len(self.current) self.card.configure(text=self.current[self.current_index])
class PinguinoIDE(Frame, PinguinoEvents): def __init__(self, master=None): Frame.__init__(self, master) self.parent = master self.parent.geometry("640x480") self.parent.title(os.getenv("NAME")) icon = os.path.join(os.getcwd(), "tkgui", "resources", "art", "pinguino11.xbm") self.parent.wm_iconbitmap("@"+icon) TkStyles.create_styles() self.Files = {} PinguinoConfig.set_environ_vars() PinguinoConfig.check_user_files() self.pinguinoAPI = Pinguino() self.pinguinoAPI._boards_ = AllBoards self.configIDE = Config() PinguinoConfig.update_pinguino_paths(self.configIDE, self.pinguinoAPI) PinguinoConfig.update_pinguino_extra_options(self.configIDE, self.pinguinoAPI) PinguinoConfig.update_user_libs(self.pinguinoAPI) self.pinguinoAPI.set_os_variables() self.set_board() self.build_menu() self.buil_output() self.build_status_bar() self.buil_toolbar() self.build_notebook() self.connect_events() self.pack(fill=BOTH, expand=True) self.parent.config(menu=self.menuBar) os_name = os.getenv("PINGUINO_OS_NAME") if os_name == "windows": os.environ["PATH"] = os.environ["PATH"] + ";" + self.configIDE.get_path("sdcc_bin") elif os_name == "linux": os.environ["LD_LIBRARY_PATH"]="/usr/lib32:/usr/lib:/usr/lib64" #---------------------------------------------------------------------- def build_status_bar(self): frame_status = Frame(self.parent, height=18) frame_status.pack(side=BOTTOM, expand=False, fill=X) self.label_status_bar = Label(frame_status, anchor="w", text=self.get_status_board()) self.label_status_bar.pack(expand=True, fill=X, side=TOP) #---------------------------------------------------------------------- def statusbar_ide(self, message): self.label_status_bar.configure(text=message) #---------------------------------------------------------------------- def build_notebook(self): banner = os.path.join("tkgui", "resources", "art", "banner.png") tkimage = ImageTk.PhotoImage(file=banner) self.banner = Label(self, image=tkimage, justify = CENTER, height = 400, bg="#afc8e1") self.banner.photo = tkimage self.banner.pack(side=LEFT, fill=BOTH, expand=True) self.noteBook = Notebook(self, style="TNotebook") #self.noteBook.pack(side=LEFT, fill=BOTH, expand=True) #---------------------------------------------------------------------- def build_menu(self): self.menuBar = Menu(self, borderwidth=1, relief=FLAT) filemenu = Menu(self.menuBar, tearoff=0) filemenu.add_command(label="New", command=self.new_file, accelerator="Ctrl+N") filemenu.add_command(label="Open", command=self.open_file, accelerator="Ctrl+O") filemenu.add_separator() filemenu.add_command(label="Save file", command=self.save_file, accelerator="Ctrl+S") filemenu.add_command(label="Save as", command=self.save_as) filemenu.add_separator() filemenu.add_command(label="Close", command=self.close_file, accelerator="Ctrl+W") filemenu.add_command(label="Close all", command=self.close_all) filemenu.add_separator() filemenu.add_command(label="Quit", command=self.close_ide, accelerator="Ctrl+Q") self.menuBar.add_cascade(label="File", menu=filemenu) editmenu = Menu(self.menuBar, tearoff=0) editmenu.add_command(label="Undo", command=self.edit_undo, accelerator="Ctrl+Z") editmenu.add_command(label="Redo", command=self.edit_redo, accelerator="Ctrl+Y") editmenu.add_separator() editmenu.add_command(label="Cut", command=self.edit_cut, accelerator="Ctrl+X") editmenu.add_command(label="Copy", command=self.edit_copy, accelerator="Ctrl+C") editmenu.add_command(label="Paste", command=self.edit_paste, accelerator="Ctrl+V") self.menuBar.add_cascade(label="Edit", menu=editmenu) configmenu = Menu(self.menuBar, tearoff=0) configmenu.add_command(label="Board Settings", command=self.__show_board_config__) configmenu.add_command(label="System paths", command=self.__show_paths__) self.menuBar.add_cascade(label="Configuration", menu=configmenu) pinguinomenu = Menu(self.menuBar, tearoff=0) pinguinomenu.add_command(label="Compile", command=self.pinguino_compile, accelerator="F5") pinguinomenu.add_command(label="Upload", command=self.pinguino_upload, accelerator="F6") pinguinomenu.add_separator() pinguinomenu.add_command(label="Stdout", command=self.__show_stdout__, accelerator="F9") self.menuBar.add_cascade(label="Pinguino", menu=pinguinomenu) self.menuBar.add_cascade(label="Examples", menu=self.examples_view()) helpmenu = Menu(self.menuBar, tearoff=0) links = Menu(helpmenu, tearoff=0) github = Menu(links, tearoff=0) github.add_command(label="IDE", command=lambda :self.open_web_site("https://github.com/PinguinoIDE/pinguino-ide/releases/latest")) github.add_command(label="Libraries", command=lambda :self.open_web_site("https://github.com/PinguinoIDE/pinguino-libraries/releases/latest")) github.add_command(label="Compilers", command=lambda :self.open_web_site("https://github.com/PinguinoIDE/pinguino-compilers/releases/latest")) links.add_cascade(label="GitHub", menu=github) links.add_command(label="Website", command=lambda :self.open_web_site("http://www.pinguino.cc/")) links.add_command(label="Wiki", command=lambda :self.open_web_site("http://wiki.pinguino.cc/")) links.add_command(label="Forum", command=lambda :self.open_web_site("http://forum.pinguino.cc/")) links.add_command(label="Blog", command=lambda :self.open_web_site("http://blog.pinguino.cc/")) links.add_command(label="Group", command=lambda :self.open_web_site("https://groups.google.com/forum/#!forum/pinguinocard")) links.add_command(label="Shop", command=lambda :self.open_web_site("http://shop.pinguino.cc/")) helpmenu.add_cascade(label="Links", menu=links) helpmenu.add_command(label="About...", command=self.__show_about__) self.menuBar.add_cascade(label="Help", menu=helpmenu) self.master.bind_all("<Control-n>", self.new_file) self.master.bind_all("<Control-o>", self.open_file) self.master.bind_all("<Control-s>", self.save_file) self.master.bind_all("<Control-w>", self.close_file) self.master.bind_all("<Control-q>", self.close_ide) self.master.bind_all("<Control-Z>", self.edit_undo) self.master.bind_all("<Control-Y>", self.edit_redo) self.master.bind_all("<Control-X>", self.edit_cut) self.master.bind_all("<Control-C>", self.edit_copy) self.master.bind_all("<Control-V>", self.edit_paste) self.master.bind_all("<F5>", self.pinguino_compile) self.master.bind_all("<F6>", self.pinguino_upload) self.master.bind_all("<F9>", self.__show_stdout__) #---------------------------------------------------------------------- def examples_view(self): examplesmenu = Menu(self.menuBar, tearoff=0) return self.process_directory(examplesmenu, os.path.join(os.getenv("PINGUINO_USER_PATH"), "examples")) #---------------------------------------------------------------------- def process_directory(self, parent, path): menu = Menu(parent, tearoff=0) for p in os.listdir(path): abspath = os.path.join(path, p) if os.path.isfile(abspath): if abspath.endswith(".pde"): label = os.path.split(abspath)[1] #menu.add_command(label=label, command=lambda :self.open_file(abspath)) menu.add_command(label=label, command=self.open_file_example_event(abspath)) if os.path.isdir(abspath): label = os.path.split(abspath)[1] menu.add_cascade(label=label, menu=self.process_directory(menu, abspath)) return menu #---------------------------------------------------------------------- def open_file_example_event(self, filename): def intern_f(): self.open_file(filename) return intern_f #---------------------------------------------------------------------- def buil_toolbar(self): Separator(self, style="TSeparator").pack(side=TOP, fill=X, expand=False) self.toolBar = Frame(self, borderwidth=0, relief=FLAT, highlightthickness=0) self.toolBar.pack(side=TOP, fill=X, expand=False) Frame(self, height=4, bg="#afc8e1").pack(side=TOP, fill=X, expand=False) #---------------------------------------------------------------------- def buil_output(self): self.output = Text(self, bg="#333333", fg="#ffffff", height=10, borderwidth=0, relief=FLAT, highlightthickness=0, font="mono 10") HEAD = os.getenv("NAME") + " " + os.getenv("VERSION") + "\n" self.output.pack(side=BOTTOM, fill=X, expand=False) self.output.insert(END, "\n "+HEAD) self.output.config(state=DISABLED) Frame(self, height=4, bg="#afc8e1").pack(side=BOTTOM, fill=X, expand=False) #---------------------------------------------------------------------- def write_log(self, *args, **kwargs): lines = " " for line in args: lines += line + "\n" for key in kwargs.keys(): line = key + ": " + kwargs[key] lines += line self.output.config(state=NORMAL) self.output.insert(END, lines.replace("\n", "\n ")[:-1]) self.output.see(END) self.output.config(state=DISABLED)
class BoardConfig(Frame): def __init__(self, master=None, main=None): Frame.__init__(self, master) self.parent = master self.main = main self.parent.geometry("336x424") self.parent.title(os.getenv("NAME") + " - Board Config") self.master.configure(padx=10, pady=10) self.intvar = IntVar() #Arch self.arch_var = IntVar() lf_arch = LabelFrame(self.parent, text="Architecture") lf_arch.pack(fill=X, expand=True, side=TOP) frame_arch = Frame(lf_arch) frame_arch.pack(fill=X, expand=True, side=TOP) frame_left1 = Frame(frame_arch) frame_left1.pack(expand=True, fill=BOTH, side=LEFT) frame_right1 = Frame(frame_arch) frame_right1.pack(expand=True, fill=BOTH, side=RIGHT) self.radioButton_arch_8 = Radiobutton(frame_left1, text="8-bit ", anchor="w", width=10, value=8, variable=self.arch_var, command=self.update_mode) self.radioButton_arch_8.pack(fill=X, side=TOP) self.radioButton_arch_32 = Radiobutton(frame_right1, text="32-bit", anchor="w", width=10, value=32, variable=self.arch_var, command=self.update_mode) self.radioButton_arch_32.pack(fill=X, side=TOP) #Mode self.mode_var = StringVar() lf_mode = LabelFrame(self.parent, text="Programming mode") lf_mode.pack(fill=X, expand=True, side=TOP) frame_mode = Frame(lf_mode) frame_mode.pack(fill=X, expand=True, side=TOP) frame_left2 = Frame(frame_mode) frame_left2.pack(expand=True, fill=BOTH, side=LEFT) frame_right2 = Frame(frame_mode) frame_right2.pack(expand=True, fill=BOTH, side=RIGHT) self.radioButton_mode_icsp = Radiobutton(frame_left2, text="ICSP", anchor="w", width=10, value="icsp", variable=self.mode_var, command=self.update_mode) self.radioButton_mode_icsp.pack(side=TOP, fill=X) self.radioButton_mode_bootloader = Radiobutton( frame_right2, text="Bootloader", anchor="w", width=10, value="bootloader", variable=self.mode_var, command=self.update_mode) self.radioButton_mode_bootloader.pack(side=TOP, fill=X) #Bootloader self.boot_var = StringVar() self.lf_boot = LabelFrame(self.parent, text="Bootloader") self.lf_boot.pack(fill=X, expand=True, side=TOP) frame_boot = Frame(self.lf_boot) frame_boot.pack(fill=X, expand=True, side=TOP) frame_left3 = Frame(frame_boot) frame_left3.pack(expand=True, fill=BOTH, side=LEFT) frame_right3 = Frame(frame_boot) frame_right3.pack(expand=True, fill=BOTH, side=RIGHT) self.radioButton_bootloader_v1_v2 = Radiobutton(frame_left3, text="v1.x or v2.x", anchor="w", width=10, value="v1_v2", variable=self.boot_var) self.radioButton_bootloader_v1_v2.pack(fill=X, side=TOP, expand=True) self.radioButton_bootloader_v4 = Radiobutton(frame_right3, text="v4.x", anchor="w", width=10, value="v4", variable=self.boot_var) self.radioButton_bootloader_v4.pack(fill=X, side=TOP, expand=True) #Devices 8bit self.dev8_var = StringVar() self.lf_dev8 = LabelFrame(self.parent, text="Devices") self.lf_dev8.pack(fill=X, expand=True, side=TOP) self.frame_8b = Frame(self.lf_dev8) self.frame_8b.pack(fill=X, expand=True, side=TOP) #Devices 32bit self.dev32_var = StringVar() self.lf_dev32 = LabelFrame(self.parent, text="Devices") self.lf_dev32.pack(fill=X, expand=True, side=TOP) self.frame_32b = Frame(self.lf_dev32) self.frame_32b.pack(fill=X, expand=True, side=TOP) frame_buttons = Frame(self.parent) Button(frame_buttons, text="Accept", command=self.accept_config).pack(fill=X, expand=True, side=RIGHT) Button(frame_buttons, text="Cancel", command=self.quit).pack(fill=X, expand=True, side=LEFT) frame_buttons.pack(fill=X, expand=True, side=BOTTOM) frame_advance = Frame(self.parent) self.advanceoptions = Button(frame_advance, text="Advance options", command=self.advance) self.advanceoptions.pack(fill=X, expand=True, side=BOTTOM) frame_advance.pack(fill=X, expand=True, side=BOTTOM) frame_warning = Frame(self.parent) self.label_warning = Label(frame_warning, fg="red", text="warning!", anchor="w") self.label_warning.pack(fill=X, expand=True, side=BOTTOM) frame_warning.pack(fill=X, expand=True, side=BOTTOM) self.build_devices_arch() self.load_config() self.init_groups() #---------------------------------------------------------------------- def quit(self): self.master.destroy() #---------------------------------------------------------------------- def build_devices_arch(self): #8bits name_checked = self.main.configIDE.config("Board", "board_8", "Pinguino 2550") arch_8 = filter(lambda board: board.arch == 8, self.main.pinguinoAPI._boards_) arch_8.sort() frame_left = Frame(self.frame_8b) frame_left.pack(expand=True, fill=BOTH, side=LEFT) frame_right = Frame(self.frame_8b) frame_right.pack(expand=True, fill=BOTH, side=RIGHT) parent = frame_left #left for board in arch_8: if arch_8.index(board) == (len(arch_8) / 2) + 1: parent = frame_right #rigth radio = Radiobutton( parent, text=board.name, anchor="w", width=10, value=board.name, variable=self.dev8_var, command=lambda: self.set_board_name(board.name, "8")) radio.pack(expand=True, fill=X, side=TOP) #radio = QtGui.QRadioButton(self.board_config.groupBox_devices_8) #self.board_config.gridLayout_device_8.addWidget(radio, count, side, 1, 1) #radio.setText(board.name) #radio.setToolTip(board.proc) if name_checked == board.name: radio.select() #self.connect(radio, QtCore.SIGNAL("clicked()"), self.set_board_name(board.name, "8")) #32bits name_checked = self.main.configIDE.config("Board", "board_32", "PIC32 Pinguino OTG") arch_32 = filter(lambda board: board.arch == 32, self.main.pinguinoAPI._boards_) arch_32.sort() frame_left0 = Frame(self.frame_32b) frame_left0.pack(expand=True, fill=BOTH, side=LEFT) frame_right0 = Frame(self.frame_32b) frame_right0.pack(expand=True, fill=BOTH, side=RIGHT) parent = frame_left0 #left for board in arch_32: if arch_32.index(board) == (len(arch_32) / 2) + 1: parent = frame_right0 #rigth radio = Radiobutton( parent, text=board.name, anchor="w", width=10, value=board.name, variable=self.dev32_var, command=lambda: self.set_board_name(board.name, "32")) radio.pack(expand=True, fill=X, side=TOP) #radio = QtGui.QRadioButton(self.board_config.groupBox_devices_32) #self.board_config.gridLayout_device_32.addWidget(radio, count, side, 1, 1) #radio.setText(board.name) #radio.setToolTip(board.proc) if name_checked == board.name: radio.select() #self.connect(radio, QtCore.SIGNAL("clicked()"), self.set_board_name(board.name, "32")) #---------------------------------------------------------------------- def load_config(self): self.main.configIDE.load_config() arch = self.main.configIDE.config("Board", "arch", 8) getattr(self.radioButton_arch_8, "select" if (arch == 8) else "deselect")() getattr(self.radioButton_arch_32, "select" if (arch == 32) else "deselect")() if arch == 32: self.advanceoptions.pack(fill=X, expand=True, side=BOTTOM) else: self.advanceoptions.forget() mode = self.main.configIDE.config("Board", "mode", "bootloader") getattr(self.radioButton_mode_bootloader, "select" if (mode == "bootloader") else "deselect")() getattr(self.radioButton_mode_icsp, "select" if (mode == "icsp") else "deselect")() bootloader = self.main.configIDE.config("Board", "bootloader", "v1_v2") getattr(self.radioButton_bootloader_v1_v2, "select" if (bootloader == "v1_v2") else "deselect")() getattr(self.radioButton_bootloader_v4, "select" if (bootloader == "v4") else "deselect")() self.update_mode() #---------------------------------------------------------------------- def update_mode(self): mode_boot = self.mode_var.get() == "bootloader" arch_8 = self.arch_var.get() == 8 if mode_boot and arch_8: self.lf_boot.pack(fill=X, expand=True, side=TOP) else: self.lf_boot.forget() self.init_groups() if not mode_boot: self.label_warning.configure( text="WARNING!! this mode can overwite the bootloader code.") else: self.label_warning.configure(text="") #---------------------------------------------------------------------- def set_board_name(self, name, arch): def dummy(): self.main.configIDE.set("Board", "board_" + arch, name) return dummy #---------------------------------------------------------------------- def init_groups(self): self.lf_dev32.forget() self.lf_dev8.forget() if self.arch_var.get() == 8: self.lf_dev8.pack(fill=X, expand=True, side=TOP) self.advanceoptions.forget() else: self.lf_dev32.pack(fill=X, expand=True, side=TOP) self.advanceoptions.pack(fill=X, expand=True, side=BOTTOM) #---------------------------------------------------------------------- def save_config(self): #if self.board_config.radioButton_arch_8.isChecked(): arch = 8 #else: arch = 32 self.main.configIDE.set("Board", "arch", self.arch_var.get()) #if self.board_config.radioButton_mode_bootloader.isChecked(): mode = "bootloader" #else: mode = "icsp" self.main.configIDE.set("Board", "mode", self.mode_var.get()) #if self.board_config.radioButton_bootloader_v1_v2.isChecked(): bootloader = "v1_v2" #else: bootloader = "v4" self.main.configIDE.set("Board", "bootloader", self.boot_var.get()) name = self.main.configIDE.config("Board", "board_" + str(self.arch_var.get()), None) self.main.configIDE.set("Board", "board", name) #---------------------------------------------------------------------- def accept_config(self): self.save_config() self.main.configIDE.save_config() self.main.statusbar_ide(self.main.get_status_board()) self.close_advance() self.quit() #---------------------------------------------------------------------- def advance(self): root = Toplevel() self.frame_advance = BoardConfigAdvance(master=root, main=self.main) self.frame_advance.mainloop() #---------------------------------------------------------------------- def close_advance(self): try: assert self.frame_advance except: return self.frame_advance.quit()
class TreeNode: def __init__(self, canvas, parent, item, menuList = []): self.canvas = canvas self.parent = parent self.item = item self.state = 'collapsed' self.selected = 0 self.children = {} self.kidKeys = [] self.x = self.y = None self.iconimages = {} # cache of PhotoImage instances for icons self.menuList = menuList self.menuVar = IntVar() self.menuVar.set(0) self._popupMenu = None self.image_id = None if self.menuList: if self.menuList[-1] == 'Separator': self.menuList = self.menuList[:-1] self._popupMenu = Menu(self.canvas, tearoff = 0) for i in range(len(self.menuList)): item = self.menuList[i] if item == 'Separator': self._popupMenu.add_separator() else: self._popupMenu.add_radiobutton( label = item, variable = self.menuVar, value = i, indicatoron = 0, command = self.popupMenuCommand) def destroy(self): for key in self.kidKeys: c = self.children[key] del self.children[key] c.destroy() self.parent = None def geticonimage(self, name): try: return self.iconimages[name] except KeyError: pass file, ext = os.path.splitext(name) ext = ext or ".gif" fullname = os.path.join(ICONDIR, file + ext) image = PhotoImage(master=self.canvas, file=fullname) self.iconimages[name] = image return image def select(self, event=None): if self.selected: return self.deselectall() self.selected = 1 if self.parent != None: if self.parent.state == 'expanded': self.canvas.delete(self.image_id) self.drawicon() self.drawtext() self.item.OnSelect(event) def deselect(self, event=None): if not self.selected: return self.selected = 0 if self.parent != None: if self.parent.state == 'expanded': self.canvas.delete(self.image_id) self.drawicon() self.drawtext() def deselectall(self): if self.parent: self.parent.deselectall() else: self.deselecttree() def deselecttree(self): if self.selected: self.deselect() for key in self.kidKeys: child = self.children[key] child.deselecttree() def flip(self, event=None): if self.state == 'expanded': self.collapse() else: self.expand() self.item.OnDoubleClick() return "break" def popupMenu(self, event=None): if self._popupMenu: self._popupMenu.post(event.widget.winfo_pointerx(), event.widget.winfo_pointery()) return "break" def popupMenuCommand(self): command = self.menuList[self.menuVar.get()] self.item.MenuCommand(command) if self.parent and (command != 'Update Explorer'): # Update parent to try to keep explorer up to date self.parent.update() def expand(self, event=None): if not self.item.IsExpandable(): return if self.state != 'expanded': self.state = 'expanded' self.update() self.view() def collapse(self, event=None): if self.state != 'collapsed': self.state = 'collapsed' self.update() def view(self): top = self.y - 2 bottom = self.lastvisiblechild().y + 17 height = bottom - top visible_top = self.canvas.canvasy(0) visible_height = self.canvas.winfo_height() visible_bottom = self.canvas.canvasy(visible_height) if visible_top <= top and bottom <= visible_bottom: return x0, y0, x1, y1 = self.canvas._getints(self.canvas['scrollregion']) if top >= visible_top and height <= visible_height: fraction = top + height - visible_height else: fraction = top fraction = float(fraction) / y1 self.canvas.yview_moveto(fraction) def reveal(self): # Make sure all parent nodes are marked as expanded parent = self.parent while parent: if parent.state == 'collapsed': parent.state = 'expanded' parent = parent.parent else: break # Redraw tree accordingly self.update() # Bring this item into view self.view() def lastvisiblechild(self): if self.kidKeys and self.state == 'expanded': return self.children[self.kidKeys[-1]].lastvisiblechild() else: return self def update(self): if self.parent: self.parent.update() else: oldcursor = self.canvas['cursor'] self.canvas['cursor'] = "watch" self.canvas.update() self.canvas.delete(Tkinter.ALL) # XXX could be more subtle self.draw(7, 2) x0, y0, x1, y1 = self.canvas.bbox(Tkinter.ALL) self.canvas.configure(scrollregion=(0, 0, x1, y1)) self.canvas['cursor'] = oldcursor def draw(self, x, y): # XXX This hard-codes too many geometry constants! self.x, self.y = x, y self.drawicon() self.drawtext() if self.state != 'expanded': return y+17 # draw children sublist = self.item._GetSubList() if not sublist: # IsExpandable() was mistaken; that's allowed return y+17 self.kidKeys = [] for item in sublist: key = item.GetKey() if self.children.has_key(key): child = self.children[key] else: child = TreeNode(self.canvas, self, item, self.menuList) self.children[key] = child self.kidKeys.append(key) # Remove unused children for key in self.children.keys(): if key not in self.kidKeys: del(self.children[key]) cx = x+20 cy = y+17 cylast = 0 for key in self.kidKeys: child = self.children[key] cylast = cy self.canvas.create_line(x+9, cy+7, cx, cy+7, fill="gray50") cy = child.draw(cx, cy) if child.item.IsExpandable(): if child.state == 'expanded': iconname = "minusnode" callback = child.collapse else: iconname = "plusnode" callback = child.expand image = self.geticonimage(iconname) id = self.canvas.create_image(x+9, cylast+7, image=image) # XXX This leaks bindings until canvas is deleted: self.canvas.tag_bind(id, "<1>", callback) self.canvas.tag_bind(id, "<Double-1>", lambda x: None) id = self.canvas.create_line(x+9, y+10, x+9, cylast+7, ##stipple="gray50", # XXX Seems broken in Tk 8.0.x fill="gray50") self.canvas.tag_lower(id) # XXX .lower(id) before Python 1.5.2 return cy def drawicon(self): if self.selected: imagename = (self.item.GetSelectedIconName() or self.item.GetIconName() or "openfolder") else: imagename = self.item.GetIconName() or "folder" image = self.geticonimage(imagename) id = self.canvas.create_image(self.x, self.y, anchor="nw", image=image) self.image_id = id self.canvas.tag_bind(id, "<1>", self.select) self.canvas.tag_bind(id, "<Double-1>", self.flip) self.canvas.tag_bind(id, "<3>", self.popupMenu) def drawtext(self, text=None): textx = self.x+20-1 texty = self.y-1 labeltext = self.item.GetLabelText() if labeltext: id = self.canvas.create_text(textx, texty, anchor="nw", text=labeltext) self.canvas.tag_bind(id, "<1>", self.select) self.canvas.tag_bind(id, "<Double-1>", self.flip) x0, y0, x1, y1 = self.canvas.bbox(id) textx = max(x1, 200) + 10 if text==None: text = self.item.GetText() or "<no text>" try: self.entry except AttributeError: pass else: self.edit_finish() try: label = self.label except AttributeError: # padding carefully selected (on Windows) to match Entry widget: self.label = Label(self.canvas, text=text, bd=0, padx=2, pady=2) if self.selected: self.label.configure(fg="white", bg="darkblue") else: fg = self.item.GetTextFg() self.label.configure(fg=fg, bg="white") id = self.canvas.create_window(textx, texty, anchor="nw", window=self.label) self.label.bind("<1>", self.select_or_edit) self.label.bind("<Double-1>", self.flip) self.label.bind("<3>", self.popupMenu) # Update text if necessary if text != self.label['text']: self.label['text'] = text self.text_id = id def select_or_edit(self, event=None): if self.selected and self.item.IsEditable(): text = self.item.GetTextForEdit() self.label['text'] = text self.drawtext(text) self.edit(event) else: self.select(event) def edit(self, event=None): self.entry = Entry(self.label, bd=0, highlightthickness=1, width=0) self.entry.insert(0, self.label['text']) self.entry.selection_range(0, Tkinter.END) self.entry.pack(ipadx=5) self.entry.focus_set() self.entry.bind("<Return>", self.edit_finish) self.entry.bind("<Escape>", self.edit_cancel) def edit_finish(self, event=None): try: entry = self.entry del self.entry except AttributeError: return text = entry.get() entry.destroy() if text and text != self.item.GetText(): self.item.SetText(text) text = self.item.GetText() self.label['text'] = text self.drawtext() self.canvas.focus_set() def edit_cancel(self, event=None): self.drawtext() self.canvas.focus_set() def find(self, searchKey): # Search for a node who's key matches the given key # Is it this node if searchKey == self.item.GetKey(): return self # Nope, check the children sublist = self.item._GetSubList() for item in sublist: key = item.GetKey() # Use existing child or create new TreeNode if none exists if self.children.has_key(key): child = self.children[key] else: child = TreeNode(self.canvas, self, item, self.menuList) # Update local list of children and keys self.children[key] = child self.kidKeys.append(key) # See if node is child (or one of child's descendants) retVal = child.find(searchKey) if retVal: return retVal # Not here return None
class TreeNode: def __init__(self, canvas, parent, item, menuList=[]): self.canvas = canvas self.parent = parent self.item = item self.state = 'collapsed' self.selected = 0 self.children = {} self.kidKeys = [] self.x = self.y = None self.iconimages = {} # cache of PhotoImage instances for icons self.menuList = menuList self.menuVar = IntVar() self.menuVar.set(0) self._popupMenu = None self.image_id = None if self.menuList: if self.menuList[-1] == 'Separator': self.menuList = self.menuList[:-1] self._popupMenu = Menu(self.canvas, tearoff=0) for i in range(len(self.menuList)): item = self.menuList[i] if item == 'Separator': self._popupMenu.add_separator() else: self._popupMenu.add_radiobutton( label=item, variable=self.menuVar, value=i, indicatoron=0, command=self.popupMenuCommand) def destroy(self): for key in self.kidKeys: c = self.children[key] del self.children[key] c.destroy() self.parent = None def geticonimage(self, name): try: return self.iconimages[name] except KeyError: pass file, ext = os.path.splitext(name) ext = ext or ".gif" fullname = os.path.join(ICONDIR, file + ext) image = PhotoImage(master=self.canvas, file=fullname) self.iconimages[name] = image return image def select(self, event=None): if self.selected: return self.deselectall() self.selected = 1 if self.parent != None: if self.parent.state == 'expanded': self.canvas.delete(self.image_id) self.drawicon() self.drawtext() self.item.OnSelect(event) def deselect(self, event=None): if not self.selected: return self.selected = 0 if self.parent != None: if self.parent.state == 'expanded': self.canvas.delete(self.image_id) self.drawicon() self.drawtext() def deselectall(self): if self.parent: self.parent.deselectall() else: self.deselecttree() def deselecttree(self): if self.selected: self.deselect() for key in self.kidKeys: child = self.children[key] child.deselecttree() def flip(self, event=None): if self.state == 'expanded': self.collapse() else: self.expand() self.item.OnDoubleClick() return "break" def popupMenu(self, event=None): if self._popupMenu: self._popupMenu.post(event.widget.winfo_pointerx(), event.widget.winfo_pointery()) return "break" def popupMenuCommand(self): command = self.menuList[self.menuVar.get()] self.item.MenuCommand(command) if self.parent and (command != 'Update Explorer'): # Update parent to try to keep explorer up to date self.parent.update() def expand(self, event=None): if not self.item.IsExpandable(): return if self.state != 'expanded': self.state = 'expanded' self.update() self.view() def collapse(self, event=None): if self.state != 'collapsed': self.state = 'collapsed' self.update() def view(self): top = self.y - 2 bottom = self.lastvisiblechild().y + 17 height = bottom - top visible_top = self.canvas.canvasy(0) visible_height = self.canvas.winfo_height() visible_bottom = self.canvas.canvasy(visible_height) if visible_top <= top and bottom <= visible_bottom: return x0, y0, x1, y1 = self.canvas._getints(self.canvas['scrollregion']) if top >= visible_top and height <= visible_height: fraction = top + height - visible_height else: fraction = top fraction = float(fraction) / y1 self.canvas.yview_moveto(fraction) def reveal(self): # Make sure all parent nodes are marked as expanded parent = self.parent while parent: if parent.state == 'collapsed': parent.state = 'expanded' parent = parent.parent else: break # Redraw tree accordingly self.update() # Bring this item into view self.view() def lastvisiblechild(self): if self.kidKeys and self.state == 'expanded': return self.children[self.kidKeys[-1]].lastvisiblechild() else: return self def update(self): if self.parent: self.parent.update() else: oldcursor = self.canvas['cursor'] self.canvas['cursor'] = "watch" self.canvas.update() self.canvas.delete(Tkinter.ALL) # XXX could be more subtle self.draw(7, 2) x0, y0, x1, y1 = self.canvas.bbox(Tkinter.ALL) self.canvas.configure(scrollregion=(0, 0, x1, y1)) self.canvas['cursor'] = oldcursor def draw(self, x, y): # XXX This hard-codes too many geometry constants! self.x, self.y = x, y self.drawicon() self.drawtext() if self.state != 'expanded': return y + 17 # draw children sublist = self.item._GetSubList() if not sublist: # IsExpandable() was mistaken; that's allowed return y + 17 self.kidKeys = [] for item in sublist: key = item.GetKey() if self.children.has_key(key): child = self.children[key] else: child = TreeNode(self.canvas, self, item, self.menuList) self.children[key] = child self.kidKeys.append(key) # Remove unused children for key in self.children.keys(): if key not in self.kidKeys: del (self.children[key]) cx = x + 20 cy = y + 17 cylast = 0 for key in self.kidKeys: child = self.children[key] cylast = cy self.canvas.create_line(x + 9, cy + 7, cx, cy + 7, fill="gray50") cy = child.draw(cx, cy) if child.item.IsExpandable(): if child.state == 'expanded': iconname = "minusnode" callback = child.collapse else: iconname = "plusnode" callback = child.expand image = self.geticonimage(iconname) id = self.canvas.create_image(x + 9, cylast + 7, image=image) # XXX This leaks bindings until canvas is deleted: self.canvas.tag_bind(id, "<1>", callback) self.canvas.tag_bind(id, "<Double-1>", lambda x: None) id = self.canvas.create_line( x + 9, y + 10, x + 9, cylast + 7, ##stipple="gray50", # XXX Seems broken in Tk 8.0.x fill="gray50") self.canvas.tag_lower(id) # XXX .lower(id) before Python 1.5.2 return cy def drawicon(self): if self.selected: imagename = (self.item.GetSelectedIconName() or self.item.GetIconName() or "openfolder") else: imagename = self.item.GetIconName() or "folder" image = self.geticonimage(imagename) id = self.canvas.create_image(self.x, self.y, anchor="nw", image=image) self.image_id = id self.canvas.tag_bind(id, "<1>", self.select) self.canvas.tag_bind(id, "<Double-1>", self.flip) self.canvas.tag_bind(id, "<3>", self.popupMenu) def drawtext(self, text=None): textx = self.x + 20 - 1 texty = self.y - 1 labeltext = self.item.GetLabelText() if labeltext: id = self.canvas.create_text(textx, texty, anchor="nw", text=labeltext) self.canvas.tag_bind(id, "<1>", self.select) self.canvas.tag_bind(id, "<Double-1>", self.flip) x0, y0, x1, y1 = self.canvas.bbox(id) textx = max(x1, 200) + 10 if text == None: text = self.item.GetText() or "<no text>" try: self.entry except AttributeError: pass else: self.edit_finish() try: label = self.label except AttributeError: # padding carefully selected (on Windows) to match Entry widget: self.label = Label(self.canvas, text=text, bd=0, padx=2, pady=2) if self.selected: self.label.configure(fg="white", bg="darkblue") else: fg = self.item.GetTextFg() self.label.configure(fg=fg, bg="white") id = self.canvas.create_window(textx, texty, anchor="nw", window=self.label) self.label.bind("<1>", self.select_or_edit) self.label.bind("<Double-1>", self.flip) self.label.bind("<3>", self.popupMenu) # Update text if necessary if text != self.label['text']: self.label['text'] = text self.text_id = id def select_or_edit(self, event=None): if self.selected and self.item.IsEditable(): text = self.item.GetTextForEdit() self.label['text'] = text self.drawtext(text) self.edit(event) else: self.select(event) def edit(self, event=None): self.entry = Entry(self.label, bd=0, highlightthickness=1, width=0) self.entry.insert(0, self.label['text']) self.entry.selection_range(0, Tkinter.END) self.entry.pack(ipadx=5) self.entry.focus_set() self.entry.bind("<Return>", self.edit_finish) self.entry.bind("<Escape>", self.edit_cancel) def edit_finish(self, event=None): try: entry = self.entry del self.entry except AttributeError: return text = entry.get() entry.destroy() if text and text != self.item.GetText(): self.item.SetText(text) text = self.item.GetText() self.label['text'] = text self.drawtext() self.canvas.focus_set() def edit_cancel(self, event=None): self.drawtext() self.canvas.focus_set() def find(self, searchKey): # Search for a node who's key matches the given key # Is it this node if searchKey == self.item.GetKey(): return self # Nope, check the children sublist = self.item._GetSubList() for item in sublist: key = item.GetKey() # Use existing child or create new TreeNode if none exists if self.children.has_key(key): child = self.children[key] else: child = TreeNode(self.canvas, self, item, self.menuList) # Update local list of children and keys self.children[key] = child self.kidKeys.append(key) # See if node is child (or one of child's descendants) retVal = child.find(searchKey) if retVal: return retVal # Not here return None
def modifica_contacte(self): if self.child_toplevel is not None: self.child_toplevel.destroy() element_a_modificar = self.agenda_contactes.focus() valor_usuari = self.agenda_contactes.item( element_a_modificar)['values'] self.cursor.execute("select * from CONTACTES where nom=? and telf=?;", tuple(valor_usuari)) dades = self.cursor.fetchone() t = Toplevel() self.child_toplevel = t label_imatge = Label(t) label_imatge.configure(background='white') label_imatge.pack(side="left", fill="both", expand=True) self.show_image(label_imatge, dades[3]) frame_info = Frame(t) frame_info.pack(side="right", fill="both", expand=False) frame_info.configure(background='white') label_nom = Label(frame_info, text="Nom: ") label_nom.configure(background='white') label_nom.grid(row=0, column=0) entry_nom = Entry(frame_info, textvariable=StringVar(frame_info, value=dades[0]), width=20, state='disabled') entry_nom.grid(row=0, column=1) label_telefon = Label(frame_info, text="Telefon antic: ") label_telefon.configure(background='white') label_telefon.grid(row=1, column=0) text_telefon = StringVar(frame_info, value=dades[1]) entry_telefon = Entry(frame_info, textvariable=text_telefon, width=20, state='disabled') entry_telefon.grid(row=1, column=1) label_telefon_nou = Label(frame_info, text="Telefon nou: ") label_telefon_nou.configure(background='white') label_telefon_nou.grid(row=2, column=0) entry_telefon_nou = Entry(frame_info, width=20) entry_telefon_nou.grid(row=2, column=1) label_email = Label(frame_info, text="Email: ") label_email.configure(background='white') label_email.grid(row=3, column=0) text_email = StringVar(frame_info, value=dades[2]) #----- entry_email = Entry(frame_info, width=20, textvariable=text_email, state='disabled') entry_email.grid(row=3, column=1) label_email_nou = Label(frame_info, text="Email nou:") label_email_nou.configure(background='white') label_email_nou.grid(row=4, column=0) entry_email_nou = Entry(frame_info, width=20) entry_email_nou.grid(row=4, column=1) selecciona_imatge = Button( frame_info, text="Edita foto", command=lambda: self.demana_imatge(label_imatge, dades[0], text_telefon.get())) selecciona_imatge.grid(row=5) button_modifica_contacte = Button( frame_info, text="Modificar contacte", fg="Blue", command=lambda: self.modificar_contacte([ entry_nom, entry_telefon, entry_email, text_telefon, text_email ], [entry_telefon_nou, entry_email_nou], element_a_modificar)) button_modifica_contacte.grid(row=6, column=1, sticky=E)
class PmaConvert: def __init__(self, config): root = Tk() # Root Definition root.geometry('1100x700') root.title('PMA Convert') # Configuration and Variables self.file_selection = '' self.is_converting = False self.options = config['option_definitions'] gui_config = config['gui_config'] # UI ## Frames self.main_frame = Frame(root) self.position_main_frame(gui_config['screen_orientation']) ## Components self.log = Text(self.main_frame, bd=1, relief=SUNKEN, width=140, height=23, state=DISABLED, spacing3=1, wrap=WORD) choose_text = ('1. Choose XLSForm (.xls or .xlsx) file(s) for ' 'conversion.') self.choose_files_label = Label(self.main_frame, text=choose_text) # TODO: Get spacing to work. # self.choose_files_label.grid(row=3, column=3, padx=(50, 50)) # self.choose_files_label.grid(row=3, column=3, pady=(50, 50)) self.choose_files_label.pack() self.choose_files_button = Button(self.main_frame, text='Choose file...', fg='black', command=self.on_open) self.choose_files_button.pack() out_text = 'Choose location for output file(s).' self.output_location_label = Label(self.main_frame, text=out_text) self.output_location_button = Button(self.main_frame, text='Choose location...', fg='black') if gui_config['output_location_on'] is True: self.output_location_label.pack() self.output_location_button.pack() self.choose_options_label = Label(self.main_frame, text='2. Choose conversion options.') self.choose_options_label.pack() ### Create Options Checkboxes # Task: Dynamically generate: http://stackoverflow.com/questions/... # ...553784/can-you-use-a-string-to-instantiate-a-class-in-python self.preexisting = BooleanVar() pre_text = self.options['preexisting']['label'] self.preexisting_opt = Checkbutton(self.main_frame, text=pre_text, variable=self.preexisting) self.preexisting_opt.pack() self.regular = BooleanVar() reg_text = self.options['regular']['label'] self.regular_opt = Checkbutton(self.main_frame, text=reg_text, variable=self.regular) self.regular_opt.pack() self.novalidate = BooleanVar() noval_text = self.options['novalidate']['label'] self.novalidate_opt = Checkbutton(self.main_frame, text=noval_text, variable=self.novalidate) self.novalidate_opt.pack() self.ignore_version = BooleanVar() ig_text = self.options['ignore_version']['label'] self.ignore_version_opt = Checkbutton(self.main_frame, text=ig_text, variable=self.ignore_version) self.ignore_version_opt.pack() self.linking_warn = BooleanVar() link_text = self.options['linking_warn']['label'] self.linking_warn_option = Checkbutton(self.main_frame, text=link_text, variable=self.linking_warn) self.linking_warn_option.pack() self.debug = BooleanVar() debug_text = self.options['debug']['label'] self.debug_option = Checkbutton(self.main_frame, text=debug_text, variable=self.debug) self.debug_option.pack() self.extras = BooleanVar() extras_text = self.options['extras']['label'] self.extras_option = Checkbutton(self.main_frame, text=extras_text, variable=self.extras) self.extras_option.pack() self.convert_label = Label(self.main_frame, text='3. Run conversion.') self.convert_label.pack() # Task: Add xscrollcommand and yscrollcommand. self.convert_button = Button(self.main_frame, text='Convert', fg='black', command=self.convert) self.convert_button.pack() self.log.pack(fill=X, expand=1) self.log_text('PMA Convert allows you to convert .xls or .xlsx form ' 'definition files to files which are compatible with ODK ' 'Collect.\n\nIf you need to copy and paste from this ' 'log, highlight the text and press CTRL+C to copy. Then ' 'press CTRL+V to paste.\n\n' '====================================================\n\n' 'Awaiting file selection.') # Task: Fix menus. They're not working. self.context_menu = Menu(self.main_frame, tearoff=0) self.context_menu.add_command(label="Convert", command=self.convert) self.main_frame.bind("<Button-3>", self.popup) # - Note: Strangely this stopped anchoring to bottom suddenly, for some # reason. So it is temporarily disabled. self.status_bar = Label(self.main_frame, text='Awaiting file selection.', bd=1, relief=SUNKEN, anchor=W) if gui_config['status_bar_on'] is True: self.status_bar.pack(side=BOTTOM, fill=X) # Run root.mainloop() # Functions def popup(self, event): # Note: Currently doesn't work. self.context_menu.post(event.x_root, event.y_root) # display the popup menu try: self.context_menu.tk_popup(event.x_root, event.y_root, 0) finally: # make sure to release the grab (Tk 8.0a1 only) self.context_menu.grab_release() def position_main_frame(self, orientation): if orientation == 'center': x, y, a = .5, .5, 'c' return self.main_frame.place(relx=x, rely=y, anchor=a) elif orientation == 'top': return self.main_frame.pack() else: return self.main_frame.pack() def on_open(self): file_types = [ ('XLS Files', '*.xls'), ('XLSX Files', '*.xlsx'), ('All files', '*') ] try: self.file_selection = tkFileDialog.askopenfilename( filetypes=file_types, title='Open one or more files.', message='Open one or more files', multiple=1 ) except: self.file_selection = tkFileDialog.askopenfilename( filetypes=file_types, title='Open one or more files.', multiple=1 ) if self.file_selection != '': self.set_status('Click on Convert to convert files.') log_output = 'Ready for conversion: \n' for file in self.file_selection: log_output += '* ' + str(file) + '\n' log_output = log_output[:-1] # Removes the last '\n'. self.log.configure(self.log_text(log_output)) def set_status(self, new_status): self.status_bar.configure(text=new_status) def log_text(self, new_text): self.log.configure(state=NORMAL) self.log.insert(END, str(new_text) + '\n\n') self.log.configure(state=DISABLED) self.log.bind("<1>", lambda event: self.log.focus_set()) def convert(self): if self.file_selection != '': f = self.file_selection kwargs = { SUFFIX: u'', PREEXISTING: self.preexisting.get(), PMA: not self.regular.get(), CHECK_VERSIONING: not self.ignore_version.get(), STRICT_LINKING: not self.linking_warn.get(), VALIDATE: not self.novalidate.get(), EXTRAS: self.extras.get(), DEBUG: self.debug.get() } buffer = StringIO.StringIO() if not kwargs[DEBUG]: sys.stdout = buffer sys.stderr = buffer else: self.log_text('--> DEBUG MODE: check console output') try: xlsform_convert(f, **kwargs) except ConvertError as e: print unicode(e) except OSError as e: # Should catch WindowsError, impossible to test on Mac traceback.print_exc() print e if not kwargs[DEBUG]: sys.stdout = sys.__stdout__ sys.stderr = sys.__stderr__ self.log_text(buffer.getvalue())
class WindowExample(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.result = 0 self.master.title("This is a test") self.master.minsize(width = 600, height = 800) #self.master. self.prompt = Label(self, text = "Enter a number:", anchor = "w", fg = "#984301") self.entry = Entry(self, width = 50, highlightcolor = "red") self.submit = Button(self, text = "Submit", command = self.calculate) self.exit = Button(self, text = "Exit", command = parent.destroy, fg = "red") self.output = Label(self, text = "") self.menu = Menu(self, title = "Menu test", bg = "black") self.canvas = Canvas(self, cursor = "circle", highlightcolor = "blue", bg = "#019bf0") self.button1 = Button(self, text = "tast antum", bg = "red", fg = "green", command = self.newWindow, \ activebackground = "red", activeforeground = "blue", relief = "sunken", cursor = "dot") self.newFrame = Frame(self, bg = "green", highlightcolor = "blue") self.button2 = Button(self.newFrame, text = "This is a tast") self.button2.grid() self.scale = Scale(self, from_ = 50, to_ = 60, orient = "horizontal", digits = 3, resolution = 0.25, highlightcolor = "red", command = self.calculate) self.scale.pack() self.open_file_button = Button(self, text = "Open File", command = self.openFile) self.prompt.pack(side = "top", fill = "x") self.entry.pack(side = "top", fill = "x") self.output.pack(side = "top", fill = "x", expand = True) self.submit.pack(side = "right") self.exit.pack(side = "left") self.button1.pack(fill="x") self.newFrame.pack(side="bottom", fill = "x", expand = True) self.button2.grid() self.canvas.pack() self.open_file_button.pack() #self.slider.pack() #self.tk = Tkinter.Tk() #self.tk.withdrow() #self.file_path = Tkinter.filedialog.askopenfilename() #print("test") self.entry.insert(string = "3", index = 0) #self.entry.insert(string = "blahblah", index = 3) def calculate(self, integer): integer = float(integer) #try: # i = int(self.entry.get()) # self.result = "%s*2=%s" % (i, i*2) #except ValueError: # self.result = "Please enter numbers only" self.entry.delete(0, len(self.entry.get())) self.result = "%s*2=%s" % (integer, integer*2) self.entry.insert(0, integer) self.output.configure(text=self.result) def newWindow(self): try: r2 = Tk() r2.mainloop() except ValueError: return None def openFile(self): file_in = tkFileDialog.askopenfilename() self.output.configure(text = file_in)
class TreeNode: def __init__(self, canvas, parent, item): self.canvas = canvas self.parent = parent self.item = item self.state = 'collapsed' self.selected = False self.children = [] self.x = self.y = None self.iconimages = {} # cache of PhotoImage instances for icons def destroy(self): for c in self.children[:]: self.children.remove(c) c.destroy() self.parent = None def geticonimage(self, name): try: return self.iconimages[name] except KeyError: pass file, ext = os.path.splitext(name) ext = ext or ".gif" fullname = os.path.join(ICONDIR, file + ext) image = PhotoImage(master=self.canvas, file=fullname) self.iconimages[name] = image return image def select(self, event=None): if self.selected: return self.deselectall() self.selected = True self.canvas.delete(self.image_id) self.drawicon() self.drawtext() def deselect(self, event=None): if not self.selected: return self.selected = False self.canvas.delete(self.image_id) self.drawicon() self.drawtext() def deselectall(self): if self.parent: self.parent.deselectall() else: self.deselecttree() def deselecttree(self): if self.selected: self.deselect() for child in self.children: child.deselecttree() def flip(self, event=None): if self.state == 'expanded': self.collapse() else: self.expand() self.item.OnDoubleClick() return "break" def expand(self, event=None): if not self.item._IsExpandable(): return if self.state != 'expanded': self.state = 'expanded' self.update() self.view() def collapse(self, event=None): if self.state != 'collapsed': self.state = 'collapsed' self.update() def view(self): top = self.y - 2 bottom = self.lastvisiblechild().y + 17 height = bottom - top visible_top = self.canvas.canvasy(0) visible_height = self.canvas.winfo_height() visible_bottom = self.canvas.canvasy(visible_height) if visible_top <= top and bottom <= visible_bottom: return x0, y0, x1, y1 = self.canvas._getints(self.canvas['scrollregion']) if top >= visible_top and height <= visible_height: fraction = top + height - visible_height else: fraction = top fraction = float(fraction) / y1 self.canvas.yview_moveto(fraction) def lastvisiblechild(self): if self.children and self.state == 'expanded': return self.children[-1].lastvisiblechild() else: return self def update(self): if self.parent: self.parent.update() else: oldcursor = self.canvas['cursor'] self.canvas['cursor'] = "watch" self.canvas.update() self.canvas.delete(ALL) # XXX could be more subtle self.draw(7, 2) x0, y0, x1, y1 = self.canvas.bbox(ALL) self.canvas.configure(scrollregion=(0, 0, x1, y1)) self.canvas['cursor'] = oldcursor def draw(self, x, y): # XXX This hard-codes too many geometry constants! self.x, self.y = x, y self.drawicon() self.drawtext() if self.state != 'expanded': return y + 17 # draw children if not self.children: sublist = self.item._GetSubList() if not sublist: # _IsExpandable() was mistaken; that's allowed return y + 17 for item in sublist: child = self.__class__(self.canvas, self, item) self.children.append(child) cx = x + 20 cy = y + 17 cylast = 0 for child in self.children: cylast = cy self.canvas.create_line(x + 9, cy + 7, cx, cy + 7, fill="gray50") cy = child.draw(cx, cy) if child.item._IsExpandable(): if child.state == 'expanded': iconname = "minusnode" callback = child.collapse else: iconname = "plusnode" callback = child.expand image = self.geticonimage(iconname) id = self.canvas.create_image(x + 9, cylast + 7, image=image) # XXX This leaks bindings until canvas is deleted: self.canvas.tag_bind(id, "<1>", callback) self.canvas.tag_bind(id, "<Double-1>", lambda x: None) id = self.canvas.create_line( x + 9, y + 10, x + 9, cylast + 7, ##stipple="gray50", # XXX Seems broken in Tk 8.0.x fill="gray50") self.canvas.tag_lower(id) # XXX .lower(id) before Python 1.5.2 return cy def drawicon(self): if self.selected: imagename = (self.item.GetSelectedIconName() or self.item.GetIconName() or "openfolder") else: imagename = self.item.GetIconName() or "folder" image = self.geticonimage(imagename) id = self.canvas.create_image(self.x, self.y, anchor="nw", image=image) self.image_id = id self.canvas.tag_bind(id, "<1>", self.select) self.canvas.tag_bind(id, "<Double-1>", self.flip) def drawtext(self): textx = self.x + 20 - 1 texty = self.y - 1 labeltext = self.item.GetLabelText() if labeltext: id = self.canvas.create_text(textx, texty, anchor="nw", text=labeltext) self.canvas.tag_bind(id, "<1>", self.select) self.canvas.tag_bind(id, "<Double-1>", self.flip) x0, y0, x1, y1 = self.canvas.bbox(id) textx = max(x1, 200) + 10 text = self.item.GetText() or "<no text>" try: self.entry except AttributeError: pass else: self.edit_finish() try: label = self.label except AttributeError: # padding carefully selected (on Windows) to match Entry widget: self.label = Label(self.canvas, text=text) if not TTK: self.label.configure(bd=0, padx=2, pady=2) theme = idleConf.GetOption('main', 'Theme', 'name') if self.selected: self.label.configure(idleConf.GetHighlight(theme, 'hilite')) else: self.label.configure(idleConf.GetHighlight(theme, 'normal')) id = self.canvas.create_window(textx, texty, anchor="nw", window=self.label) self.label.bind("<1>", self.select_or_edit) self.label.bind("<Double-1>", self.flip) self.text_id = id def select_or_edit(self, event=None): if self.selected and self.item.IsEditable(): self.edit(event) else: self.select(event) def edit(self, event=None): self.entry = Entry(self.label, bd=0, highlightthickness=1, width=0) self.entry.insert(0, self.label['text']) self.entry.selection_range(0, END) self.entry.pack(ipadx=5) self.entry.focus_set() self.entry.bind("<Return>", self.edit_finish) self.entry.bind("<Escape>", self.edit_cancel) def edit_finish(self, event=None): try: entry = self.entry del self.entry except AttributeError: return text = entry.get() entry.destroy() if text and text != self.item.GetText(): self.item.SetText(text) text = self.item.GetText() self.label['text'] = text self.drawtext() self.canvas.focus_set() def edit_cancel(self, event=None): try: entry = self.entry del self.entry except AttributeError: return entry.destroy() self.drawtext() self.canvas.focus_set()
class GUI: def __init__(self, model, title='PyCX Simulator', interval=0, stepSize=1, param_gui_names=None): self.model = model self.titleText = title self.timeInterval = interval self.stepSize = stepSize self.param_gui_names = param_gui_names if param_gui_names is None: self.param_gui_names = {} self.param_entries = {} self.statusStr = "" self.running = False self.modelFigure = None self.currentStep = 0 self.initGUI() def initGUI(self): #create root window self.rootWindow = Tk() self.statusText = StringVar(value=self.statusStr) self.setStatusStr("Simulation not yet started") self.rootWindow.wm_title(self.titleText) self.rootWindow.protocol('WM_DELETE_WINDOW', self.quitGUI) self.rootWindow.geometry('550x700') self.rootWindow.columnconfigure(0, weight=1) self.rootWindow.rowconfigure(0, weight=1) self.frameSim = Frame(self.rootWindow) self.frameSim.pack(expand=YES, fill=BOTH, padx=5, pady=5, side=TOP) self.status = Label(self.rootWindow, width=40, height=3, relief=SUNKEN, bd=1, textvariable=self.statusText) self.status.pack(side=TOP, fill=X, padx=1, pady=1, expand=NO) self.runPauseString = StringVar() self.runPauseString.set("Run") self.buttonRun = Button(self.frameSim, width=30, height=2, textvariable=self.runPauseString, command=self.runEvent) self.buttonRun.pack(side=TOP, padx=5, pady=5) self.showHelp(self.buttonRun, "Runs the simulation (or pauses the running simulation)") self.buttonStep = Button(self.frameSim, width=30, height=2, text="Step Once", command=self.stepOnce) self.buttonStep.pack(side=TOP, padx=5, pady=5) self.showHelp(self.buttonStep, "Steps the simulation only once") self.buttonReset = Button(self.frameSim, width=30, height=2, text="Reset", command=self.resetModel) self.buttonReset.pack(side=TOP, padx=5, pady=5) self.showHelp(self.buttonReset, "Resets the simulation") for param in self.model.params: var_text = self.param_gui_names.get(param, param) can = Canvas(self.frameSim) lab = Label(can, width=25, height=1 + var_text.count('\n'), text=var_text, anchor=W, takefocus=0) lab.pack(side='left') ent = Entry(can, width=11) val = getattr(self.model, param) if isinstance(val, bool): val = int(val) # Show 0/1 which can convert back to bool ent.insert(0, str(val)) ent.pack(side='left') can.pack(side='top') self.param_entries[param] = ent if self.param_entries: self.buttonSaveParameters = Button(self.frameSim, width=50, height=1, command=self.saveParametersCmd, text="Save parameters to the running model", state=DISABLED) self.showHelp(self.buttonSaveParameters, "Saves the parameter values.\n" + "Not all values may take effect on a running model\n" + "A model reset might be required.") self.buttonSaveParameters.pack(side='top', padx=5, pady=5) self.buttonSaveParametersAndReset = Button(self.frameSim, width=50, height=1, command=self.saveParametersAndResetCmd, text="Save parameters to the model and reset the model") self.showHelp(self.buttonSaveParametersAndReset, "Saves the given parameter values and resets the model") self.buttonSaveParametersAndReset.pack(side='top', padx=5, pady=5) can = Canvas(self.frameSim) lab = Label(can, width=25, height=1, text="Step size ", justify=LEFT, anchor=W, takefocus=0) lab.pack(side='left') self.stepScale = Scale(can, from_=1, to=500, resolution=1, command=self.changeStepSize, orient=HORIZONTAL, width=25, length=150) self.stepScale.set(self.stepSize) self.showHelp(self.stepScale, "Skips model redraw during every [n] simulation steps\n" + "Results in a faster model run.") self.stepScale.pack(side='left') can.pack(side='top') can = Canvas(self.frameSim) lab = Label(can, width=25, height=1, text="Step visualization delay in ms ", justify=LEFT, anchor=W, takefocus=0) lab.pack(side='left') self.stepDelay = Scale(can, from_=0, to=max(2000, self.timeInterval), resolution=10, command=self.changeStepDelay, orient=HORIZONTAL, width=25, length=150) self.stepDelay.set(self.timeInterval) self.showHelp(self.stepDelay, "The visualization of each step is " + "delays by the given number of " + "milliseconds.") self.stepDelay.pack(side='left') can.pack(side='top') def setStatusStr(self, newStatus): self.statusStr = newStatus self.statusText.set(self.statusStr) #model control functions def changeStepSize(self, val): self.stepSize = int(val) def changeStepDelay(self, val): self.timeInterval = int(val) def saveParametersCmd(self): for param, entry in self.param_entries.items(): val = entry.get() if isinstance(getattr(self.model, param), bool): val = bool(int(val)) setattr(self.model, param, val) # See if the model changed the value (e.g. clipping) new_val = getattr(self.model, param) if isinstance(new_val, bool): new_val = int(new_val) entry.delete(0, END) entry.insert(0, str(new_val)) self.setStatusStr("New parameter values have been set") def saveParametersAndResetCmd(self): self.saveParametersCmd() self.resetModel() def runEvent(self): if not self.running: self.running = True self.rootWindow.after(self.timeInterval, self.stepModel) self.runPauseString.set("Pause") self.buttonStep.configure(state=DISABLED) if self.param_entries: self.buttonSaveParameters.configure(state=NORMAL) self.buttonSaveParametersAndReset.configure(state=DISABLED) else: self.stopRunning() def stopRunning(self): self.running = False self.runPauseString.set("Continue Run") self.buttonStep.configure(state=NORMAL) self.drawModel() if self.param_entries: self.buttonSaveParameters.configure(state=NORMAL) self.buttonSaveParametersAndReset.configure(state=NORMAL) def stepModel(self): if self.running: if self.model.step() is True: self.stopRunning() self.currentStep += 1 self.setStatusStr("Step " + str(self.currentStep)) self.status.configure(foreground='black') if (self.currentStep) % self.stepSize == 0: self.drawModel() self.rootWindow.after(int(self.timeInterval * 1.0 / self.stepSize), self.stepModel) def stepOnce(self): self.running = False self.runPauseString.set("Continue Run") self.model.step() self.currentStep += 1 self.setStatusStr("Step " + str(self.currentStep)) self.drawModel() if self.param_entries: self.buttonSaveParameters.configure(state=NORMAL) def resetModel(self): self.running = False self.runPauseString.set("Run") self.model.reset() self.currentStep = 0 self.setStatusStr("Model has been reset") self.drawModel() def drawModel(self): if self.modelFigure is None: self.modelFigure = plt.figure() plt.ion() self.model.draw() # Tell matplotlib to redraw too. The darwin-version works with more # types of matplotlib backends, but seems to fail on some Linux # machines. Hence we use the TkAgg specific method when available. if sys.platform == 'darwin': self.modelFigure.canvas.manager.show() else: self.modelFigure.canvas.manager.window.update() def start(self): if self.model.step.__doc__: self.showHelp(self.buttonStep, self.model.step.__doc__.strip()) self.model.reset() self.drawModel() self.rootWindow.mainloop() def quitGUI(self): plt.close('all') self.rootWindow.quit() self.rootWindow.destroy() def showHelp(self, widget, text): def setText(self): self.statusText.set(text) self.status.configure(foreground='blue') def showHelpLeave(self): self.statusText.set(self.statusStr) self.status.configure(foreground='black') widget.bind("<Enter>", lambda e: setText(self)) widget.bind("<Leave>", lambda e: showHelpLeave(self))
class TilePicker(Frame): def __init__(self, parent, doc, **kw): apply(Frame.__init__, (self, parent), kw) self.doc = doc self.tilePicker = None self.attrPicker = None self.status = None self.curTile = 0 self.setAttribute(0) self.tilePicker = Label(self, image=self.tilePickerPI, width=128, borderwidth=0) self.tilePicker.grid(row=0,column=0) self.tilePicker.bind("<Button-1>", self.tilePickerCallback) self.attrPicker = Label(self, image=self.attrPickerPI, borderwidth=0) self.attrPicker.grid(row=1,column=0) self.attrPicker.bind("<Button-1>", self.attrPickerCallback) self.status = Label(self) self.status.grid(row=2,column=0) self.setStatus() def setAttribute(self, value): self.curAttribute = value & 0x03 self.updateWidgets() def updateWidgets(self): self.tilePickerImage = renderChrFile(self.doc.chrdata, self.doc.clut, self.curAttribute * 4) self.tilePickerPI = ImageTk.PhotoImage(self.tilePickerImage) if self.tilePicker is not None: self.tilePicker.configure(image=self.tilePickerPI) previewTile = self.doc.renderTile(self.curTile, self.curAttribute) self.attrPickerImage = renderAttrPicker(previewTile, self.doc.clut, self.curAttribute) self.attrPickerPI = ImageTk.PhotoImage(self.attrPickerImage) if self.attrPicker is not None: self.attrPicker.configure(image=self.attrPickerPI) self.setStatus() def setTile(self, tile): self.curTile = tile self.setAttribute(self.curAttribute) def setStatus(self): if self.status is None: return label = "tile $%02x attr %d" % (self.curTile, self.curAttribute) self.status.configure(text=label) def tilePickerCallback(self, event): if event.x >= 0 and event.x < 128 and event.y >= 0 and event.y < 128: tileX = event.x // 8 tileY = event.y // 8 newTileNo = tileY * 16 + tileX #print "mouse was clicked on tile", newTileNo self.setTile(newTileNo) return print "mouse was clicked at (%d, %d)" % (event.x, event.y) def attrPickerCallback(self, event): if event.x >= 0 and event.x < 128: attr = event.x // 32 #print "mouse was clicked on attribute", attr self.setAttribute(attr) return print "mouse was clicked at (%d, %d)" % (event.x, event.y)
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 NGA_Window_Config(Frame): com = None sys = None def __init__(self, parent, sys): Frame.__init__(self, parent) self.sys = sys self.sys.c_config_window = self self.parent = parent # get window configurations self.parent.geometry(self.sys.win_cfg.wConfig) self.parent.title(self.sys.win_cfg.sConfig) # draw window self.initUI() # window defaults def initUI(self): self.style = Style().configure("TFrame", background=self.sys.win_cfg.cBackground) self.pack(fill=BOTH, expand=1) # setup labels self.Embedded = Label(self, width=15, background=self.sys.win_cfg.cUnknown, text="LED: COM0") self.Embedded.place(x=15, y=35) self.Stage = Label(self, width=15, background=self.sys.win_cfg.cUnknown, text="Stages: COM0") self.Stage.place(x=15, y=60) # setup buttons configComButton = Button(self, text="COM Port Setup", command=self.com_port_search, width=17) configComButton.place(x=15, y=5) # close buttons closeButton = Button(self, text="Close", command=self.close_window, width=17) closeButton.place(x=15, y=90) def close_window(self): self.parent.destroy() def com_port_search(self): self.Embedded.configure(text="LED: Searching ...") self.Stage.configure(text="Stages: Searching ...") # close stages because we are going to look at all ports self.sys.hw.clear_stage() self.sys.hw.clear_led() self.Embedded.configure(background=self.sys.win_cfg.cBad) self.Stage.configure(background=self.sys.win_cfg.cBad) self.parent.update() self.com = NGA_Config_Serial_Scan() self.update_connections() def update_connections(self): self.Embedded.configure(text="LED: " + self.com.serial_arduino) if (self.com.serial_arduino != "COM0"): self.Embedded.configure(background=self.sys.win_cfg.cGood) else: self.Stage.configure(text="LED: NOT FOUND") self.Embedded.configure(background=self.sys.win_cfg.cBad) if self.com.stage == "mmc100": self.Stage.configure(text="Stages: MMC: " + self.com.serial_MMC100) self.Stage.configure(background=self.sys.win_cfg.cGood) elif self.com.stage == "mfc2000": self.Stage.configure(text="Stages: MFC: " + self.com.serial_MFC2000) self.Stage.configure(background=self.sys.win_cfg.cGood) elif self.com.stage == "smc-pollux": self.Stage.configure(text="Stages: SMC: " + self.com.serial_SMCPOLLUX) self.Stage.configure(background=self.sys.win_cfg.cGood) elif self.com.stage == "mmc_pollux_hybrid": self.Stage.configure(text=self.com.serial_MMC100 + "/" + self.com.serial_SMCPOLLUX) self.Stage.configure(background=self.sys.win_cfg.cGood) elif self.com.stage == "mfc_pollux_hybrid": self.Stage.configure(text=self.com.serial_MFC2000 + "/" + self.com.serial_SMCPOLLUX) self.Stage.configure(background=self.sys.win_cfg.cGood) else: self.Stage.configure(text="Stages: NOT FOUND") self.Stage.configure(background=self.sys.win_cfg.cBad) # reload stages because port may have changed self.sys.c_main_window.reload_leds() self.sys.c_main_window.reload_stages()
class Chatbox(object): def __init__(self, master, my_nick=None, command=None, topic=None, entry_controls=None, maximum_lines=None, timestamp_template=None, scrollbar_background=None, scrollbar_troughcolor=None, history_background=None, history_font=None, history_padx=None, history_pady=None, history_width=None, entry_font=None, entry_background=None, entry_foreground=None, label_template=u"{nick}", label_font=None, logging_file=None, tags=None): self.interior = Frame(master, class_="Chatbox") self._command = command self._is_empty = True self._maximum_lines = maximum_lines self._timestamp_template = timestamp_template self._command = command self._label_template = label_template self._logging_file = logging_file if logging_file is None: self._log = None else: try: self._log = open(logging_file, "r") except: self._log = None top_frame = Frame(self.interior, class_="Top") top_frame.pack(expand=True, fill=BOTH) self._textarea = Text(top_frame, state=DISABLED) self._vsb = Scrollbar(top_frame, takefocus=0, command=self._textarea.yview) self._vsb.pack(side=RIGHT, fill=Y) self._textarea.pack(side=RIGHT, expand=YES, fill=BOTH) self._textarea["yscrollcommand"] = self._vsb.set entry_frame = Frame(self.interior, class_="Chatbox_Entry") entry_frame.pack(fill=X, anchor=N) if entry_controls is not None: controls_frame = Frame(entry_frame, class_="Controls") controls_frame.pack(fill=X) entry_controls(controls_frame, chatbox=self) bottom_of_entry_frame = Frame(entry_frame) self._entry_label = Label(bottom_of_entry_frame) self._entry = Entry(bottom_of_entry_frame) else: self._entry_label = Label(entry_frame) self._entry = Entry(entry_frame) self._entry.pack(side=LEFT, expand=YES, fill=X) self._entry.bind("<Return>", self._on_message_sent) self._entry.focus() if history_background: self._textarea.configure(background=history_background) if history_font: self._textarea.configure(font=history_font) if history_padx: self._textarea.configure(padx=history_padx) if history_width: self._textarea.configure(width=history_width) if history_pady: self._textarea.configure(pady=history_pady) if scrollbar_background: self._vsb.configure(background=scrollbar_background) if scrollbar_troughcolor: self._vsb.configure(troughcolor=scrollbar_troughcolor) if entry_font: self._entry.configure(font=entry_font) if entry_background: self._entry.configure(background=entry_background) if entry_foreground: self._entry.configure(foreground=entry_foreground) if label_font: self._entry_label.configure(font=label_font) if tags: for tag, tag_config in tags.items(): self._textarea.tag_config(tag, **tag_config) self.set_nick(my_nick) @property def topic(self): return @topic.setter def topic(self, topic): return def focus_entry(self): self._entry.focus() def bind_entry(self, event, handler): self._entry.bind(event, handler) def bind_textarea(self, event, handler): self._textarea.bind(event, handler) def bind_tag(self, tagName, sequence, func, add=None): self._textarea.tag_bind(tagName, sequence, func, add=add) def focus(self): self._entry.focus() def user_message(self, nick, content): if self._timestamp_template is None: self._write((u"%s:" % nick, "nick"), " ", (content, "user_message")) else: timestamp = datetime.datetime.now().strftime( self._timestamp_template) self._write((timestamp, "timestamp"), " ", (u"%s:" % nick, "nick"), " ", (content, "user_message")) def notification_message(self, content, tag=None): if tag is None: tag = "notification" self._write((content, tag)) notification = notification_message def notification_of_private_message(self, content, from_, to): if self._timestamp_template is None: self.notification_message( u"{from_} -> {to}: {content}".format(from_=from_, to=to, content=content), "notification_of_private_message") else: timestamp = datetime.datetime.now().strftime( self._timestamp_template) self.notification_message( u"{timestamp} {from_} -> {to}: {content}".format( timestamp=timestamp, from_=from_, to=to, content=content), "notification_of_private_message") def new_message(self, message): if isinstance(message, User_Message): self.user_message(message.content, message.nick) elif isinstance(message, Notification_Message): self.notification(message.content, message.tag) elif isinstance(message, Notification_Of_Private_Message): self.notification_of_private_message(message.from_, message.to, message.content) else: raise Exception("Bad message") def tag(self, tag_name, **kwargs): self._textarea.tag_config(tag_name, **kwargs) def clear(self): self._is_empty = True self._textarea.delete('1.0', END) @property def logging_file(self): return self._logging_file def send(self, content): if self._my_nick is None: raise Exception("Nick not set") self.user_message(self._my_nick, content) def _filter_text(self, text): return "".join(ch for ch in text if ch <= u"\uFFFF") def _write(self, *args): if len(args) == 0: return relative_position_of_scrollbar = self._vsb.get()[1] self._textarea.config(state=NORMAL) if self._is_empty: self._is_empty = False else: self._textarea.insert(END, "\n") if self._log is not None: self._log.write("\n") for arg in args: if isinstance(arg, tuple): text, tag = arg # Parsing not allowed characters text = self._filter_text(text) self._textarea.insert(END, text, tag) else: text = arg text = self._filter_text(text) self._textarea.insert(END, text) if self._log is not None: self._log.write(text) if self._maximum_lines is not None: start_line = int(self._textarea.index('end-1c').split('.') [0]) - self._maximum_lines if lines_to_delete >= 1: self._textarea.delete('%s.0' % start_line, END) self._textarea.config(state=DISABLED) if relative_position_of_scrollbar == 1: self._textarea.yview_moveto(1) def _on_message_sent(self, event): message = self._entry.get() self._entry.delete(0, END) self.send(message) if self._command: self._command(message) def set_nick(self, my_nick): self._my_nick = my_nick if my_nick: text = self._label_template.format(nick=my_nick) self._entry_label["text"] = text self._entry_label.pack(side=LEFT, padx=(5, 5), before=self._entry) else: self._entry_label.pack_forget()
class GeneratorDialog: # The UI to configure the settings by the user def __init__(self, root, ctrl): self.__root = root self.__ctrl = ctrl self.__pluginDir = os.path.dirname( os.path.abspath(inspect.stack()[0][1])) self.__ico = PhotoImage(file=self.__pluginDir + '/pic/ScribusGenerator_logo.gif') root.tk.call('wm', 'iconphoto', root._w, '-default', self.__ico) def show(self): self.__root.title(CONST.APP_NAME) mainFrame = Frame(self.__root) top = mainFrame.winfo_toplevel() top.rowconfigure(0, weight=1) top.columnconfigure(0, weight=1) mainFrame.rowconfigure(0, weight=1) mainFrame.columnconfigure(0, weight=1) mainFrame.grid(sticky='ew') # Three Sections: Input-Settings, Output-Settings and Buttons inputFrame = LabelFrame(mainFrame, text='Input Settings') inputFrame.columnconfigure(2, weight=1) inputFrame.grid(column=0, row=0, padx=5, pady=5, sticky='ew') outputFrame = LabelFrame(mainFrame, text='Output Settings') outputFrame.columnconfigure(2, weight=1) outputFrame.grid(column=0, row=1, padx=5, pady=5, sticky='ew') buttonFrame = Frame(mainFrame) buttonFrame.columnconfigure(3, weight=1) buttonFrame.grid(column=0, row=2, padx=5, pady=5, sticky='ew') # Input-Settings scribusSourceFileLabel = Label(inputFrame, text='Scribus File:', width=15, anchor='w') scribusSourceFileLabel.grid(column=0, row=0, padx=5, pady=5, sticky='w') scribusSourceFileEntry = Entry( inputFrame, textvariable=self.__ctrl.getScribusSourceFileEntryVariable()) scribusSourceFileEntry.grid(column=1, columnspan=3, row=0, padx=5, pady=5, sticky='ew') scribusSourceFileButton = Button( inputFrame, text='⏏', command=self.__ctrl.scribusSourceFileEntryVariableHandler) scribusSourceFileButton.grid(column=4, row=0, padx=5, pady=5, sticky='e') scribusLoadSettingsButton = Button( inputFrame, text='↺', command=self.__ctrl.scribusLoadSettingsHandler) # ⟲ ⟳ ↻ ↺ ⌂ ⌘ ⎗ scribusLoadSettingsButton.grid(column=5, row=0, padx=5, pady=5, sticky='e') dataSourceFileLabel = Label(inputFrame, text='Data File:', width=15, anchor='w') dataSourceFileLabel.grid(column=0, row=1, padx=5, pady=5, sticky='w') dataSourceFileEntry = Entry( inputFrame, textvariable=self.__ctrl.getDataSourceFileEntryVariable()) dataSourceFileEntry.grid(column=1, columnspan=4, row=1, padx=5, pady=5, sticky='ew') dataSourceFileButton = Button( inputFrame, text='⏏', command=self.__ctrl.dataSourceFileEntryVariableHandler) dataSourceFileButton.grid(column=5, row=1, padx=5, pady=5, sticky='e') dataSeparatorLabel = Label(inputFrame, text='Data Field Separator:', width=15, anchor='w') dataSeparatorLabel.grid(column=0, row=2, padx=5, pady=5, sticky='w') dataSeparatorEntry = Entry( inputFrame, width=3, textvariable=self.__ctrl.getDataSeparatorEntryVariable()) dataSeparatorEntry.grid(column=1, row=2, padx=5, pady=5, sticky='w') fromLabel = Label(inputFrame, text='(opt.) use partial data, only from:', anchor='e') fromLabel.grid(column=2, row=2, padx=5, pady=5, sticky='e') fromEntry = Entry(inputFrame, width=3, textvariable=self.__ctrl.getFromVariable()) fromEntry.grid(column=3, row=2, padx=5, pady=5, sticky='w') toLabel = Label(inputFrame, text='to:', width=3, anchor='e') toLabel.grid(column=4, row=2, padx=5, pady=5, sticky='e') toEntry = Entry(inputFrame, width=3, textvariable=self.__ctrl.getToVariable()) toEntry.grid(column=5, row=2, padx=5, pady=5, sticky='w') # Output-Settings outputDirectoryLabel = Label(outputFrame, text='Output Directory:', width=15, anchor='w') outputDirectoryLabel.grid(column=0, row=0, padx=5, pady=5, sticky='w') outputDirectoryEntry = Entry( outputFrame, textvariable=self.__ctrl.getOutputDirectoryEntryVariable()) outputDirectoryEntry.grid(column=1, columnspan=4, row=0, padx=5, pady=5, sticky='ew') outputDirectoryButton = Button( outputFrame, text='⏏', command=self.__ctrl.outputDirectoryEntryVariableHandler) outputDirectoryButton.grid(column=5, row=0, padx=5, pady=5, sticky='e') outputFileNameLabel = Label(outputFrame, text='Output File Name:', width=15, anchor='w') outputFileNameLabel.grid(column=0, row=1, padx=5, pady=5, sticky='w') outputFileNameEntry = Entry( outputFrame, textvariable=self.__ctrl.getOutputFileNameEntryVariable()) outputFileNameEntry.grid(column=1, columnspan=3, row=1, padx=5, pady=5, sticky='ew') saveLabel = Label(outputFrame, text='Save Settings:', width=15, anchor='w') saveLabel.grid(column=4, row=1, padx=5, pady=5, sticky='w') saveCheckbox = Checkbutton( outputFrame, variable=self.__ctrl.getSaveCheckboxVariable()) saveCheckbox.grid(column=5, row=1, padx=5, pady=5, sticky='w') mergeOutputLabel = Label(outputFrame, text='Merge in Single File:', width=15, anchor='w') mergeOutputLabel.grid(column=0, row=2, padx=5, pady=5, sticky='w') mergeOutputCheckbox = Checkbutton( outputFrame, variable=self.__ctrl.getMergeOutputCheckboxVariable()) mergeOutputCheckbox.grid(column=1, row=2, padx=5, pady=5, sticky='w') self.keepGeneratedScribusFilesLabel = Label(outputFrame, text='Keep Scribus Files:', width=15, anchor='e') self.keepGeneratedScribusFilesLabel.grid(column=4, row=2, padx=5, pady=5, sticky='e') self.keepGeneratedScribusFilesCheckbox = Checkbutton( outputFrame, variable=self.__ctrl.getKeepGeneratedScribusFilesCheckboxVariable( ), anchor='w') self.keepGeneratedScribusFilesCheckbox.grid(column=5, row=2, padx=5, pady=5, sticky='w') outputFormatLabel = Label(outputFrame, text='Output Format:', anchor='e') outputFormatLabel.grid(column=2, row=2, padx=5, pady=5, sticky='e') outputFormatListBox = OptionMenu( outputFrame, self.__ctrl.getSelectedOutputFormat(), *self.__ctrl.getOutputFormatList(), command=lambda v=self.__ctrl.getSelectedOutputFormat( ): self.updateState(v)) outputFormatListBox.grid(column=3, row=2, padx=5, pady=5, sticky='w') # Bottom Buttons generateButton = Button(buttonFrame, text='✔\nGenerate', width=10, command=self.__ctrl.buttonOkHandler) generateButton.grid(column=0, row=0, padx=5, pady=5, sticky='w') cancelButton = Button(buttonFrame, text='✘\nCancel', width=10, command=self.__ctrl.buttonCancelHandler) cancelButton.grid(column=1, row=0, padx=5, pady=5, sticky='e') helpButton = Button(buttonFrame, text='❓\nHelp', width=7, command=self.__ctrl.helpButtonHandler) helpButton.grid(column=3, row=0, padx=5, pady=5, sticky='e') # general layout mainFrame.grid() self.__root.grid() def updateState(self, value): if (value == CONST.FORMAT_PDF): self.keepGeneratedScribusFilesLabel.configure(state=NORMAL) self.keepGeneratedScribusFilesCheckbox.configure(state=NORMAL) else: self.keepGeneratedScribusFilesLabel.configure(state=DISABLED) self.keepGeneratedScribusFilesCheckbox.configure(state=DISABLED)
class MyQuestion(object): def __init__(self, parent, question_text, ans1_text, ans2_text, ans3_text, ans4_text, exp1_text, exp2_text, exp3_text, exp4_text, correct_ans): # assigning parameters to attributes self.parent = parent self.qtext = str(question_text) self.text1 = str(ans1_text) self.text2 = str(ans2_text) self.text3 = str(ans3_text) self.text4 = str(ans4_text) self.exp1 = str(exp1_text) self.exp2 = str(exp2_text) self.exp3 = str(exp3_text) self.exp4 = str(exp4_text) self.ans = int(correct_ans) # creating Tkinter variables self.ans_input = IntVar() self.is_correct = BooleanVar() self.efbg = StringVar() self.is_correct_text = StringVar() self.exp_text = StringVar() # developer mode if dev: self.ans_input.set(self.ans) # questionwide bgcolor, fgcolor self.bgcolor = GrayScale(80) self.fgcolor = GrayScale(20) # creating parent frame self.parent_frame() self.question_frame() def parent_frame(self): # creating parent frame self.pf = Frame(self.parent) self.pf.configure(bg=self.bgcolor) self.pf.place(relx=0, rely=0, relwidth=1, relheight=1) def question_frame(self): # creating question frame within parent frame self.qf = Frame(self.pf) self.qf.configure(bg=self.bgcolor) self.qf.place(relx=0, rely=0, relwidth=1, relheight=1) # creating objects within question frame self.title_label() self.radiobutton1() self.radiobutton2() self.radiobutton3() self.radiobutton4() self.check_ans_button() def explanation_frame(self): # creating explanation frame within parent frame self.ef = Frame(self.pf) self.ef.configure(bg=self.efbg.get()) self.ef.place(relx=0, rely=0, relwidth=1, relheight=1) # creating objects within explanation frame self.is_correct_label() self.exp_label() self.next_ques_button() # creating display answer button if answer is wrong if not self.is_correct.get(): self.disp_ans_button() def title_label(self): # creating title label for question frame self.tl = Label(self.qf) self.tl.configure(text=self.qtext) self.tl.configure(font=MyFonts['ExtraLarge']) self.tl.configure(bg=self.bgcolor, fg=self.fgcolor) self.tl.configure(relief=FLAT) self.tl.configure(padx=2, pady=2, anchor=N) self.tl.place(relx=0.05, rely=0.05, relwidth=0.90, relheight=0.10) def radiobutton1(self): # creating radiobuttion1 for question frame self.q1 = Radiobutton(self.qf) self.q1.configure(text='A. ' + self.text1) self.q1.configure(font=MyFonts['Large']) self.q1.configure(bg=self.bgcolor, activebackground=self.bgcolor) self.q1.configure(variable=self.ans_input, value=1) self.q1.place(relx=0.10, rely=0.20) def radiobutton2(self): # creating radiobutton2 for question frame self.q2 = Radiobutton(self.qf) self.q2.configure(text='B. ' + self.text2) self.q2.configure(font=MyFonts['Large']) self.q2.configure(bg=self.bgcolor, activebackground=self.bgcolor) self.q2.configure(variable=self.ans_input, value=2) self.q2.place(relx=0.10, rely=0.35) def radiobutton3(self): # creating radiobutton3 for question frame self.q3 = Radiobutton(self.qf) self.q3.configure(text='C. ' + self.text3) self.q3.configure(font=MyFonts['Large']) self.q3.configure(bg=self.bgcolor, activebackground=self.bgcolor) self.q3.configure(variable=self.ans_input, value=3) self.q3.place(relx=0.10, rely=0.50) def radiobutton4(self): # creating radiobutton4 for question frame self.q4 = Radiobutton(self.qf) self.q4.configure(text='D. ' + self.text4) self.q4.configure(font=MyFonts['Large']) self.q4.configure(bg=self.bgcolor, activebackground=self.bgcolor) self.q4.configure(variable=self.ans_input, value=4) self.q4.place(relx=0.10, rely=0.65) def check_ans_button(self): # creating check answer button for question frame self.cb = MyButton(self.qf, 'Check Answer', self.check_ans, 0.80, 0.85) def is_correct_label(self): # creating is_correct_label for explanation frame self.cl = Label(self.ef) self.cl.configure(text=self.is_correct_text.get()) self.cl.configure(font=MyFonts['ExtraLargeBold']) self.cl.configure(bg=self.efbg.get(), fg=GrayScale(20)) self.cl.configure(relief=FLAT) self.cl.configure(padx=2, pady=2, anchor=N) self.cl.place(relx=0.05, rely=0.05, relwidth=0.90, relheight=0.05) def exp_label(self): # creating exp_label for explanation frame self.el = Label(self.ef) self.el.configure(text=self.exp_text.get()) self.el.configure(font=MyFonts['LargeBold']) self.el.configure(bg=self.efbg.get(), fg=GrayScale(20)) self.el.configure(relief=FLAT) self.el.configure(padx=2, pady=2, anchor=N) self.el.place(relx=0.05, rely=0.10, relwidth=0.90, relheight=0.85) def next_ques_button(self): # creating next question button for explanation frame self.nq = MyButton(self.ef, 'Next Question', self.next_ques, 0.80, 0.85) def disp_ans_button(self): # creating display answer button for explanation frame self.da = MyButton(self.ef, 'Show Answer', self.disp_ans, 0.65, 0.85) def assign_all(self): # assigning correct answer text (ans_text) and explanation attributes (ans_exp) if self.ans == 1: self.ans_text = 'A. ' + self.text1 self.ans_exp = self.exp1 elif self.ans == 2: self.ans_text = 'B. ' + self.text2 self.ans_exp = self.exp2 elif self.ans == 3: self.ans_text = 'C. ' + self.text3 self.ans_exp = self.exp3 elif self.ans == 4: self.ans_text = 'D. ' + self.text4 self.ans_exp = self.exp4 else: self.ans_text = 'invalid correct_ans parameter' self.ans_exp = 'invalid correct_ans parameter' print 'invalid correct_ans parameter, please input between 1 and 4' def check_ans(self): # defining check answer function # is_correct (Boolean conditional) if self.ans_input.get() == self.ans: self.efbg.set(color_green) self.is_correct.set(True) self.is_correct_text.set('Correct Answer! :)') else: self.efbg.set(color_red) self.is_correct.set(False) self.is_correct_text.set('Wrong Answer :(') # only assign values for show answer if user answer is wrong self.assign_all() # appropriate response to selected answer if self.ans_input.get() == 1: self.exp_text.set(self.exp1) self.explanation_frame() self.qf.destroy() elif self.ans_input.get() == 2: self.exp_text.set(self.exp2) self.explanation_frame() self.qf.destroy() elif self.ans_input.get() == 3: self.exp_text.set(self.exp3) self.explanation_frame() self.qf.destroy() elif self.ans_input.get() == 4: self.exp_text.set(self.exp4) self.explanation_frame() self.qf.destroy() else: # no selected answer condition showerror('Error', 'Please select an answer to continue') def disp_ans(self): # defining display answer function tmp_str = self.ans_exp[0].lower() + self.ans_exp[1:] disp_ans_text = 'The correct answer is "' + str( self.ans_text) + '" because ' + str(tmp_str) showinfo('Correct Answer', disp_ans_text) def next_ques(self): # defininf next_question function self.pf.destroy() self.ef.destroy()
class Run(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.initConfig() self.initUI() def initConfig(self): self.run = False self.patternText = np.array(["G", "X", "Y", "Z", "A", "B", "C"]) self.lastText = np.array( ["0", "0.00", "0.00", "0.00", "0.00", "0.00", "0.00"]) self.inputPos = np.array([0., 0., 300.]) self.inputRot = np.array( [np.deg2rad(0.), np.deg2rad(0.), np.deg2rad(0.)]) self.trajectory = np.array([[self.inputPos[0]], [self.inputPos[1]], [self.inputPos[2]]]) self.lastPos = np.zeros(3) self.lastRot = np.zeros(3) self.machineOffset = np.array([0., 0., 800.]) self.toolOffset = ([0, 0, 90]) self.basePos = np.zeros((6, 3)) self.platformPos = np.zeros((6, 3)) self.prisma = np.zeros(3) self.prismaLength = np.zeros(6) self.dataPrismaLength = np.zeros((2, 6)) self.travel = np.zeros(3) self.travelLength = 0 self.travelVel = 0 self.travelTime = 0 self.timeSystem = 0 self.rPlatform = 170. # in mm self.rBase = 350. # in mm self.minLength = 490. # in mm self.maxLength = 740. # in mm self.maxSpeed = 28. # in mm/s self.thetaPlatform = np.array([ np.deg2rad(45), np.deg2rad(75), np.deg2rad(165), np.deg2rad(-165), np.deg2rad(-75), np.deg2rad(-45) ]) self.thetaBase = np.array([ np.deg2rad(10), np.deg2rad(110), np.deg2rad(130), np.deg2rad(-130), np.deg2rad(-110), np.deg2rad(-10) ]) def initUI(self): self.parent.title("5 AXIS STEWART CNC G-CODE READER") self.pack(fill=BOTH, expand=1) self.line = 1.0 self.maxLine = 1.0 self.lineNC = 1.0 menubar = Menu(self.parent) self.parent.config(menu=menubar) fileMenu = Menu(menubar) fileMenu.add_command(label="Open", command=self.onOpen) fileMenu.add_command(label="Clear", command=self.onClear) fileMenu.add_command(label="Save", command=self.onSave) fileMenu.add_command(label="Export", command=self.onExport) fileMenu.add_command(label="Exit", command=self.onExit) menubar.add_cascade(label="File", menu=fileMenu) runMenu = Menu(menubar) runMenu.add_command(label="Initialize", command=self.onInit) runMenu.add_command(label="Run/Pause", command=self.onRun) runMenu.add_command(label="Stop", command=self.onStop) menubar.add_cascade(label="Run", menu=runMenu) self.execButton = Button(self, text="Execute", command=self.onExec) self.execButton.place(x=650, y=20) self.prevButton = Button(self, text="Prev", command=self.onPrev) self.prevButton.place(x=780, y=20) self.nextButton = Button(self, text="Next", command=self.onNext) self.nextButton.place(x=840, y=20) self.notif = "Application Started" self.lblGCode = Label(self, text="G-CODE") self.lblGCode.place(x=10, y=0) self.lblNC = Label(self, text="NC") self.lblNC.place(x=10, y=360) self.lblNotif = Label(self, text="Application Started") self.lblNotif.config(font=("Calibri", 20)) self.lblNotif.place(x=1020, y=100) self.lblG = Label(self, text="G :") self.lblG.place(x=520, y=60) self.lblX = Label(self, text="X :") self.lblX.place(x=520, y=120) self.lblY = Label(self, text="Y :") self.lblY.place(x=520, y=150) self.lblZ = Label(self, text="Z :") self.lblZ.place(x=520, y=180) self.lblA = Label(self, text="A :") self.lblA.place(x=520, y=240) self.lblB = Label(self, text="B :") self.lblB.place(x=520, y=270) self.lblF = Label( self, text="F : Time") self.lblF.place(x=520, y=330) self.lblL = Label(self, text="Link Length - Link Length/sec") self.lblL.place(x=680, y=80) self.lblL1 = Label( self, text= "1 : mm mm/s" ) self.lblL1.place(x=650, y=120) self.lblL2 = Label( self, text= "2 : mm mm/s" ) self.lblL2.place(x=650, y=150) self.lblL3 = Label( self, text= "3 : mm mm/s" ) self.lblL3.place(x=650, y=180) self.lblL4 = Label( self, text= "4 : mm mm/s" ) self.lblL4.place(x=650, y=210) self.lblL5 = Label( self, text= "5 : mm mm/s" ) self.lblL5.place(x=650, y=240) self.lblL6 = Label( self, text= "6 : mm mm/s" ) self.lblL6.place(x=650, y=270) self.txtGCode = Text(self, width=47, height=17) self.txtGCode.place(x=10, y=20) self.txtGCode.tag_configure('highlightline', background="#a9e9e9") self.txtGCode.config(font=("TkTextFont", 12)) self._highlight_current_line() self.txtNC = Text(self, width=105, height=17) self.txtNC.place(x=10, y=380) self.txtNC.config(font=("TkTextFont", 10)) self.txtG = Text(self, width=8, height=1) self.txtG.place(x=550, y=60) self.txtX = Text(self, width=8, height=1) self.txtX.place(x=550, y=120) self.txtY = Text(self, width=8, height=1) self.txtY.place(x=550, y=150) self.txtZ = Text(self, width=8, height=1) self.txtZ.place(x=550, y=180) self.txtA = Text(self, width=8, height=1) self.txtA.place(x=550, y=240) self.txtB = Text(self, width=8, height=1) self.txtB.place(x=550, y=270) self.txtF = Text(self, width=8, height=1) self.txtF.place(x=550, y=330) self.txtL1 = Text(self, width=10, height=1) self.txtL1.place(x=680, y=120) self.txtL2 = Text(self, width=10, height=1) self.txtL2.place(x=680, y=150) self.txtL3 = Text(self, width=10, height=1) self.txtL3.place(x=680, y=180) self.txtL4 = Text(self, width=10, height=1) self.txtL4.place(x=680, y=210) self.txtL5 = Text(self, width=10, height=1) self.txtL5.place(x=680, y=240) self.txtL6 = Text(self, width=10, height=1) self.txtL6.place(x=680, y=270) self.txtL1Dot = Text(self, width=10, height=1) self.txtL1Dot.place(x=840, y=120) self.txtL2Dot = Text(self, width=10, height=1) self.txtL2Dot.place(x=840, y=150) self.txtL3Dot = Text(self, width=10, height=1) self.txtL3Dot.place(x=840, y=180) self.txtL4Dot = Text(self, width=10, height=1) self.txtL4Dot.place(x=840, y=210) self.txtL5Dot = Text(self, width=10, height=1) self.txtL5Dot.place(x=840, y=240) self.txtL6Dot = Text(self, width=10, height=1) self.txtL6Dot.place(x=840, y=270) self.txtTime = Text(self, width=10, height=1) self.txtTime.place(x=760, y=330) self.f = Figure(figsize=(3.5, 3.5), dpi=100) self.canvas = FigureCanvasTkAgg(self.f, self) self.canvas.draw() self.ax = Axes3D(self.f) self.ax.mouse_init() self.set_ax() self.canvas.get_tk_widget().place(x=890, y=320) def _highlight_current_line(self, interval=100): '''Updates the 'current line' highlighting every "interval" milliseconds''' self.txtGCode.tag_remove('highlightline', 1.0, "end") self.txtGCode.tag_add('highlightline', self.line, str(int(self.line)) + '.end+1c') self.after(interval, self._highlight_current_line) def extractG(self): try: posG = self.txtGCode.search("G", self.line, str(int(self.line)) + '.end', 2) textG = self.txtGCode.get(posG + '+1c', posG + '+2c') self.txtG.insert(1.0, textG) self.lastText[0] = textG except: self.txtG.insert(1.0, self.lastText[0]) return (self.txtG.get(1.0, 'end')) def extractX(self): try: posX = self.txtGCode.search("X", self.line, str(int(self.line)) + '.end', 6) textX = self.txtGCode.get(posX + '+1c', posX + '+6c') self.txtX.insert(1.0, textX) self.lastText[1] = textX except: self.txtX.insert(1.0, self.lastText[1]) return (self.txtX.get(1.0, 'end')) def extractY(self): try: posY = self.txtGCode.search("Y", self.line, str(int(self.line)) + '.end', 6) textY = self.txtGCode.get(posY + '+1c', posY + '+6c') self.txtY.insert(1.0, textY) self.lastText[2] = textY except: self.txtY.insert(1.0, self.lastText[2]) return (self.txtY.get(1.0, 'end')) def extractZ(self): try: posZ = self.txtGCode.search("Z", self.line, str(int(self.line)) + '.end', 6) textZ = self.txtGCode.get(posZ + '+1c', posZ + '+6c') self.txtZ.insert(1.0, textZ) self.lastText[3] = textZ except: self.txtZ.insert(1.0, self.lastText[3]) return (self.txtZ.get(1.0, 'end')) def extractA(self): try: posA = self.txtGCode.search("A", self.line, str(int(self.line)) + '.end', 6) textA = self.txtGCode.get(posA + '+1c', posA + '+6c') self.txtA.insert(1.0, textA) self.lastText[4] = textA except: self.txtA.insert(1.0, self.lastText[4]) return (self.txtA.get(1.0, 'end')) def extractB(self): try: posB = self.txtGCode.search("B", self.line, str(int(self.line)) + '.end', 6) textB = self.txtGCode.get(posB + '+1c', posB + '+6c') self.txtB.insert(1.0, textB) self.lastText[5] = textB except: self.txtB.insert(1.0, self.lastText[5]) return (self.txtB.get(1.0, 'end')) def extractF(self): try: posF = self.txtGCode.search("F", self.line, str(int(self.line)) + '.end', 6) textF = self.txtGCode.get(posF + '+1c', posF + '+6c') self.txtF.insert(1.0, textF) self.lastText[6] = textF except: self.txtF.insert(1.0, self.lastText[6]) return (self.txtF.get(1.0, 'end')) def draw(self): basePlate = np.array([ np.append(self.basePos[:, 0], self.basePos[0, 0]), np.append(self.basePos[:, 1], self.basePos[0, 1]), np.append(self.basePos[:, 2], self.basePos[0, 2]) ]) platformPlate = np.array([ np.append(self.platformPos[:, 0], self.platformPos[0, 0]), np.append(self.platformPos[:, 1], self.platformPos[0, 1]), np.append(self.platformPos[:, 2], self.platformPos[0, 2]) ]) self.ax.plot_trisurf(basePlate[0], basePlate[1], basePlate[2], color='gray', alpha=0.5) self.ax.plot_trisurf(platformPlate[0], platformPlate[1], platformPlate[2], color='gray', alpha=0.5) self.ax.plot_surface(basePlate[0], basePlate[1], np.array([basePlate[2], basePlate[2] - 50]), color='gray') for i in range(6): self.ax.scatter(self.basePos[i, 0], self.basePos[i, 1], self.basePos[i, 2], color="g", s=25) self.ax.scatter(self.platformPos[i, 0], self.platformPos[i, 1], self.platformPos[i, 2], color="g", s=25) self.ax.plot3D([self.basePos[i, 0], self.platformPos[i, 0]], [self.basePos[i, 1], self.platformPos[i, 1]], [self.basePos[i, 2], self.platformPos[i, 2]]) self.ax.plot3D([-400, 400], [0, 0], [0, 0], color="r") self.ax.plot3D([0, 0], [-400, 400], [0, 0], color="r") self.ax.plot3D([self.posMatrix[0], self.inputMatrix[0]], [self.posMatrix[1], self.inputMatrix[1]], [self.posMatrix[2], self.inputMatrix[2]]) self.ax.scatter(self.posMatrix[0], self.posMatrix[1], self.posMatrix[2], color="r", s=10) self.ax.scatter(self.inputMatrix[0], self.inputMatrix[1], self.inputMatrix[2], color="b", s=10) self.ax.plot3D(self.trajectory[0, :], self.trajectory[1, :], self.trajectory[2, :], color="g") #self.ax.plot3D(self.trajectoryG1[0,:], self.trajectoryG1[1,:], self.trajectoryG1[2,:], color="g") def writeNC(self): self.txtL1.insert(1.0, "{:.3f}".format(self.prismaLength[0])) self.txtL2.insert(1.0, "{:.3f}".format(self.prismaLength[1])) self.txtL3.insert(1.0, "{:.3f}".format(self.prismaLength[2])) self.txtL4.insert(1.0, "{:.3f}".format(self.prismaLength[3])) self.txtL5.insert(1.0, "{:.3f}".format(self.prismaLength[4])) self.txtL6.insert(1.0, "{:.3f}".format(self.prismaLength[5])) self.txtL1Dot.insert(1.0, "{:.3f}".format(self.dL[0])) self.txtL2Dot.insert(1.0, "{:.3f}".format(self.dL[1])) self.txtL3Dot.insert(1.0, "{:.3f}".format(self.dL[2])) self.txtL4Dot.insert(1.0, "{:.3f}".format(self.dL[3])) self.txtL5Dot.insert(1.0, "{:.3f}".format(self.dL[4])) self.txtL6Dot.insert(1.0, "{:.3f}".format(self.dL[5])) self.txtTime.insert(1.0, "{:.3f}".format(self.travelTime)) def validator(self): if (self.shortPrismatic >= self.minLength) and ( self.longPrismatic <= self.maxLength) and ( self.maxDL <= self.maxSpeed): # check boundaries self.notif = "Executing Move Command" self.lblNotif.configure(text=self.notif, foreground="green") self.ax.cla() self.set_ax() self.draw() self.canvas.draw() ## self.ij_prismaVel() ## print(self.prismaVel) else: self.notif = "Move Command Couldn't Be Executed" self.lblNotif.configure(text=self.notif, foreground="red") self.onStop() def onExec(self): self.resetData() if int(self.extractG()) == 0: self.travelVel = 20.0 self.txtF.insert(1.0, '20.0') self.inputPos = np.array([ float(self.extractX()), float(self.extractY()), float(self.extractZ()) ]) self.inputRot = np.array([ np.deg2rad(0.), np.deg2rad(float(self.extractB())), np.deg2rad(float(self.extractA())) ]) self.trajectory = np.append( self.trajectory, [[self.inputPos[0]], [self.inputPos[1]], [self.inputPos[2]]], axis=1) self.ik_orientation() self.ik_position() self.dataPrismaLength[0, :] = self.ik_prismatic() if self.travelVel > 0: self.travelTime = self.travelLength / self.travelVel #print(self.travelTime) else: self.travelTime = 0.1 if self.travelTime > 0: self.dL = (self.dataPrismaLength[0, :] - self.dataPrismaLength[1, :]) / self.travelTime else: self.dL = np.zeros(6) self.timeSystem = self.timeSystem + self.travelTime self.travel = self.inputPos - self.lastPos self.travelLength = np.sqrt(np.dot(self.travel, self.travel.T)) self.maxDL = np.max(np.abs(self.dL)) self.writeNC() lbl = ["A", "B", "C", "D", "E", "F"] text1 = text2 = "" for i in range(0, 6): text1 += "L" + lbl[i] + "{:.2f} ".format(self.prismaLength[i]) for i in range(0, 6): text2 += "dL" + lbl[i] + "{:.2f} ".format(self.dL[i]) text = text1 + text2 + "T" + "{:.2f}".format( self.timeSystem) + "\n" self.txtNC.insert(self.lineNC, text) self.lineNC += 1 self.lblNotif.update() self.lastPos = self.inputPos self.lastRot = self.inputRot self.dataPrismaLength[1, :] = self.dataPrismaLength[0, :] self.validator() else: self.travelVel = float(self.extractF()) self.inputPos = np.array([ float(self.extractX()), float(self.extractY()), float(self.extractZ()) ]) self.inputRot = np.array([ np.deg2rad(0.), np.deg2rad(float(self.extractB())), np.deg2rad(float(self.extractA())) ]) self.trajectory = np.append( self.trajectory, [[self.inputPos[0]], [self.inputPos[1]], [self.inputPos[2]]], axis=1) self.ik_orientation() self.ik_position() self.dataPrismaLength[0, :] = self.ik_prismatic() if self.travelVel > 0: self.travelTime = self.travelLength / self.travelVel else: self.travelTime = 0.1 if self.travelTime > 0: self.dL = (self.dataPrismaLength[0, :] - self.dataPrismaLength[1, :]) / self.travelTime else: self.dL = np.zeros(6) self.travel = self.inputPos - self.lastPos self.travelLength = np.sqrt(np.dot(self.travel, self.travel.T)) self.maxDL = np.max(np.abs(self.dL)) n = int(self.travelTime / 1.0) #constant time for interpolation tempPosX = np.linspace(self.lastPos[0], self.inputPos[0], n) tempPosY = np.linspace(self.lastPos[1], self.inputPos[1], n) tempPosZ = np.linspace(self.lastPos[2], self.inputPos[2], n) tempRotA = np.linspace(self.lastRot[0], self.inputRot[0], n) tempRotB = np.linspace(self.lastRot[1], self.inputRot[1], n) tempTime = np.linspace(0, self.travelTime, n) for i in range(n): self.inputPos = np.array( [tempPosX[i], tempPosY[i], tempPosZ[i]]) self.inputRot = np.array( [np.deg2rad(0.), tempRotB[i], tempRotA[i]]) self.ik_orientation() self.ik_position() self.dataPrismaLength[0, :] = self.ik_prismatic() self.resetDataInterpolating() self.writeNC() lbl = ["A", "B", "C", "D", "E", "F"] text1 = text2 = "" for j in range(0, 6): text1 += "L" + lbl[j] + "{:.2f} ".format( self.prismaLength[j]) for k in range(0, 6): text2 += "dL" + lbl[k] + "{:.2f} ".format(self.dL[k]) text = text1 + text2 + "T" + "{:.2f}".format( self.timeSystem + tempTime[i]) + "\n" self.txtNC.insert(self.lineNC, text) self.lineNC += 1 self.lblNotif.update() self.lastPos = self.inputPos self.lastRot = self.inputRot self.dataPrismaLength[1, :] = self.dataPrismaLength[0, :] self.timeSystem = self.timeSystem + self.travelTime self.validator() def onPrev(self): if self.line > 1.0: self.line -= 1.0 else: self.line = 1.0 def onNext(self): if self.line < self.maxLine: self.line += 1.0 def onSave(self): name = tkFileDialog.asksaveasfile(mode='w', defaultextension=".gcode") text2save = str(self.txtGCode.get(0.0, END)) name.write(text2save) name.close def onExport(self): name = tkFileDialog.asksaveasfile(mode='w', defaultextension=".spnc") text2save = str(self.txtNC.get(0.0, END)) name.write(text2save) name.close def onClear(self): self.txtGCode.delete(1.0, 'end') self.txtNC.delete(1.0, 'end') self.trajectory = np.array([[self.inputPos[0]], [self.inputPos[1]], [self.inputPos[2]]]) #self.trajectoryG0 = np.array([[self.inputPos[0]], [self.inputPos[1]], [self.inputPos[2]]]) #self.trajectoryG1 = np.array([[self.inputPos[0]], [self.inputPos[1]], [self.inputPos[2]]]) self.draw() self.canvas.draw() def onOpen(self): ftypes = [('G-code files', '*.gcode'), ('All files', '*')] dlg = tkFileDialog.Open(self, filetypes=ftypes) fl = dlg.show() if fl != '': text = self.readFile(fl) self.txtGCode.insert(1.0, text) self.maxLine = math.floor(float(self.txtGCode.index('end-1c'))) def readFile(self, filename): f = open(filename, "r") text = f.read() return text def onInit(self): self.inputPos = np.array([0., 0., 300.]) self.trajectory = np.array([[self.inputPos[0]], [self.inputPos[1]], [self.inputPos[2]]]) #self.trajectoryG1 = np.array([[self.inputPos[0]], [self.inputPos[1]], [self.inputPos[2]]]) self.line = 1.0 self.timeSystem = 0 self.onExec() def onRun(self): self.run = not self.run if self.run: print("Robot Started") self.notif = "Robot Started" self.lblNotif.configure(text=self.notif, foreground="blue") self.trajectory = np.delete(self.trajectory, 0, 1) #self.trajectoryG1 = np.delete(self.trajectoryG1, 0, 1) #time.sleep(5) while self.line <= self.maxLine: self.onExec() t = 0. while t < self.travelTime: t += 0.1 #time.sleep(0.1) # run control here if self.line == self.maxLine: self.notif = "End of Process" self.lblNotif.configure(text=self.notif, foreground="red") self.onStop() if not self.run: break self.notif = "Move Command Executed" self.lblNotif.configure(text=self.notif, foreground="blue") #time.sleep(5) self.onNext() else: print("Robot Paused") self.notif = "Robot Paused" self.lblNotif.configure(text=self.notif, foreground="red") def onStop(self): print("Robot Stopped") self.run = False def onExit(self): self.quit() self.destroy() def ik_prismatic(self): for i in range(6): self.basePos[i] = [ self.rBase * np.cos(self.thetaBase[i]), self.rBase * np.sin(self.thetaBase[i]), 0 ] + self.machineOffset self.platformPos[i] = [ self.rPlatform * np.cos(self.thetaPlatform[i]), self.rPlatform * np.sin(self.thetaPlatform[i]), 0 ] self.platformPos = np.dot(self.orientMatrix, self.platformPos.T) self.platformPos = self.posMatrix + self.platformPos.T self.prisma = self.platformPos - self.basePos for i in range(6): self.prismaLength[i] = np.sqrt( np.dot(self.prisma[i], self.prisma[i].T)) self.shortPrismatic = np.min(self.prismaLength) self.longPrismatic = np.max(self.prismaLength) return self.prismaLength def ik_position(self): self.inputMatrix = np.array( [self.inputPos[0], self.inputPos[1], self.inputPos[2]]) self.posMatrix = self.inputMatrix + np.dot(self.orientMatrix, self.toolOffset) return self.posMatrix def ik_orientation(self): self.orientMatrix = np.array( [[ np.cos(self.inputRot[0]) * np.cos(self.inputRot[1]), (np.cos(self.inputRot[0]) * np.sin(self.inputRot[1]) * np.sin(self.inputRot[2])) - (np.sin(self.inputRot[0]) * np.cos(self.inputRot[2])), (np.cos(self.inputRot[0]) * np.sin(self.inputRot[1]) * np.cos(self.inputRot[2])) + (np.sin(self.inputRot[0]) * np.sin(self.inputRot[2])) ], [ np.sin(self.inputRot[0]) * np.cos(self.inputRot[1]), (np.sin(self.inputRot[0]) * np.sin(self.inputRot[1]) * np.sin(self.inputRot[2])) + (np.cos(self.inputRot[0]) * np.cos(self.inputRot[2])), (np.sin(self.inputRot[0]) * np.sin(self.inputRot[1]) * np.cos(self.inputRot[2])) - (np.cos(self.inputRot[0]) * np.sin(self.inputRot[2])) ], [ -np.sin(self.inputRot[1]), np.cos(self.inputRot[1]) * np.sin(self.inputRot[2]), np.cos(self.inputRot[1]) * np.cos(self.inputRot[2]) ]]) return self.orientMatrix def ij_constant(self): for i in range(6): self.basePos[i] = [ self.rBase * np.cos(self.thetaBase[i]), self.rBase * np.sin(self.thetaBase[i]), 0 ] + self.machineOffset self.platformPos[i] = [ self.rPlatform * np.cos(self.thetaPlatform[i]), self.rPlatform * np.sin(self.thetaPlatform[i]), 0 ] c1 = np.dot(self.orientMatrix, self.platformPos.T) c1T = np.transpose(c1) c2 = np.cross(c1, self.prisma) c2T = np.transpose(c2) c3 = np.dot(c1T, c2T) return c3 def ij_variable(self): dLinear = self.inputPos - self.lastPos dAngular = self.inputRot - self.lastRot self.velocity = np.array([self.dLinear, self.dAngular]) return self.velocity def ij_invDiagLength(self): diag = np.diag(self.prismaLength) invDiag = np.linalg.inv(diag) return invDiag def ij_prismaVel(self): temp = np.dot(self.ij_constant(), self.ij_variable()) prismaVel = np.dot(self.ij_invDiagLength(), temp) return prismaVel def set_ax(self): #ax panel set up self.ax.set_aspect("equal") self.ax.set_xlim3d(-400, 400) self.ax.set_ylim3d(-400, 400) self.ax.set_zlim3d(0, 800) self.ax.set_xlabel('X axis') self.ax.set_ylabel('Y axis') self.ax.set_zlabel('Z axis') self.ax.set_axisbelow(True) #send grid lines to the background def resetData(self): self.txtG.delete(1.0, 'end') self.txtA.delete(1.0, 'end') self.txtB.delete(1.0, 'end') self.txtX.delete(1.0, 'end') self.txtY.delete(1.0, 'end') self.txtZ.delete(1.0, 'end') self.txtF.delete(1.0, 'end') self.txtL1.delete(1.0, 'end') self.txtL2.delete(1.0, 'end') self.txtL3.delete(1.0, 'end') self.txtL4.delete(1.0, 'end') self.txtL5.delete(1.0, 'end') self.txtL6.delete(1.0, 'end') self.txtL1Dot.delete(1.0, 'end') self.txtL2Dot.delete(1.0, 'end') self.txtL3Dot.delete(1.0, 'end') self.txtL4Dot.delete(1.0, 'end') self.txtL5Dot.delete(1.0, 'end') self.txtL6Dot.delete(1.0, 'end') self.txtTime.delete(1.0, 'end') def resetDataInterpolating(self): self.txtL1.delete(1.0, 'end') self.txtL2.delete(1.0, 'end') self.txtL3.delete(1.0, 'end') self.txtL4.delete(1.0, 'end') self.txtL5.delete(1.0, 'end') self.txtL6.delete(1.0, 'end') self.txtL1Dot.delete(1.0, 'end') self.txtL2Dot.delete(1.0, 'end') self.txtL3Dot.delete(1.0, 'end') self.txtL4Dot.delete(1.0, 'end') self.txtL5Dot.delete(1.0, 'end') self.txtL6Dot.delete(1.0, 'end') self.txtTime.delete(1.0, 'end')
top_frame.pack(fill=X) lbl_help = Label(top_frame, bg="#222", fg="#EEE", pady=10, text="Por favor selecione a imagem que deseja converter." "\n\nIMPORTANTE:" "\n -> Os arquivos devem ser em formato bmp, jpg ou png" "\n -> As imagens devem ser simples e com poucos detalhes" "\n -> Os arquivos devem ser menores que 6kB", justify=LEFT) lbl_help.pack(fill=X) # Top Frame End # Middle frame start middle_frame = Frame(master_frame) middle_frame.pack(fill=BOTH, expand=True) tk_image = ImageTk.PhotoImage(Image.open(c_path+'bitmap.gif')) img_label = Label(middle_frame, bg="#999", bd=15, padx=20, pady=20, relief=FLAT) img_label.configure(image=tk_image) img_label.place(relx=0.5, rely=0.5, anchor=CENTER) # Middle Frame end # Frame2 Begin bottom_frame = Frame(master_frame) bottom_frame.pack(fill=X) file_entry = Label(bottom_frame, bg="#222", fg="#EEE", justify=LEFT, relief=SUNKEN) s_btn = Button(bottom_frame, activebackground="#111", bg="#222", fg="#EEE", text="Enviar para impressora", justify=CENTER, command=send_file) # , state=DISABLED) sel_btn = Button(bottom_frame, activebackground="#111", bg="#222", fg="#EEE", text="Selecione o Arquivo", justify=CENTER, command=select_file) file_entry.pack(fill=BOTH, pady=5, padx=5, expand=True) s_btn.pack(side=RIGHT, anchor=N, padx=5, pady=5) sel_btn.pack(side=RIGHT, anchor=N, padx=5, pady=5)
class CollapsibleFrame(Frame): def __init__(self, master, text=None, borderwidth=2, width=0, height=16, interior_padx=0, interior_pady=8, background=None, caption_separation=4, caption_font=None, caption_builder=None, icon_x=5): Frame.__init__(self, master) if background is None: background = self.cget("background") self.configure(background=background) self._is_opened = False self._interior_padx = interior_padx self._interior_pady = interior_pady self._iconOpen = PhotoImage( data= "R0lGODlhEAAQAKIAAP///9TQyICAgEBAQAAAAAAAAAAAAAAAACwAAAAAEAAQAAADNhi63BMgyinFAy0HC3Xj2EJoIEOM32WeaSeeqFK+say+2azUi+5ttx/QJeQIjshkcsBsOp/MBAA7" ) self._iconClose = PhotoImage( data= "R0lGODlhEAAQAKIAAP///9TQyICAgEBAQAAAAAAAAAAAAAAAACwAAAAAEAAQAAADMxi63BMgyinFAy0HC3XjmLeA4ngpRKoSZoeuDLmo38mwtVvKu93rIo5gSCwWB8ikcolMAAA7" ) height_of_icon = max(self._iconOpen.height(), self._iconClose.height()) width_of_icon = max(self._iconOpen.width(), self._iconClose.width()) containerFrame_pady = (height_of_icon // 2) + 1 self._height = height self._width = width self._containerFrame = Frame(self, borderwidth=borderwidth, width=width, height=height, relief=RIDGE, background=background) self._containerFrame.pack(expand=True, fill=X, pady=(containerFrame_pady, 0)) self.interior = Frame(self._containerFrame, background=background) self._collapseButton = Label(self, borderwidth=0, image=self._iconOpen, relief=RAISED) self._collapseButton.place(in_=self._containerFrame, x=icon_x, y=-(height_of_icon // 2), anchor=N + W, bordermode="ignore") self._collapseButton.bind("<Button-1>", lambda event: self.toggle()) if caption_builder is None: self._captionLabel = Label(self, anchor=W, borderwidth=1, text=text) if caption_font is not None: self._captionLabel.configure(font=caption_font) else: self._captionLabel = caption_builder(self) if not isinstance(self._captionLabel, Widget): raise Exception( "'caption_builder' doesn't return a tkinter widget") self.after( 0, lambda: self._place_caption(caption_separation, icon_x, width_of_icon)) def update_width(self, width=None): # Update could be devil # http://wiki.tcl.tk/1255 self.after(0, lambda width=width: self._update_width(width)) def _place_caption(self, caption_separation, icon_x, width_of_icon): self.update() x = caption_separation + icon_x + width_of_icon y = -(self._captionLabel.winfo_reqheight() // 2) self._captionLabel.place(in_=self._containerFrame, x=x, y=y, anchor=N + W, bordermode="ignore") def _update_width(self, width): self.update() if width is None: width = self.interior.winfo_reqwidth() if isinstance(self._interior_pady, (list, tuple)): width += self._interior_pady[0] + self._interior_pady[1] else: width += 2 * self._interior_pady width = max(self._width, width) self._containerFrame.configure(width=width) def open(self): self._collapseButton.configure(image=self._iconClose) self._containerFrame.configure(height=self.interior.winfo_reqheight()) self.interior.pack(expand=True, fill=X, padx=self._interior_padx, pady=self._interior_pady) self._is_opened = True def close(self): self.interior.pack_forget() self._containerFrame.configure(height=self._height) self._collapseButton.configure(image=self._iconOpen) self._is_opened = False def toggle(self): if self._is_opened: self.close() else: self.open()
class MainWindow(Tk): def __init__(self): Tk.__init__(self) self.wm_title("FRCA QBase Reader - Exam Mode") w, h = self.winfo_screenwidth(), self.winfo_screenheight() self.geometry("%dx%d+0+0" % (w, h)) self.bind("<Down>", self.OnSmaller) self.bind("<Up>", self.OnBigger) self.bind("<Right>", self.nextQuestion) self.logic = Logic() self.widgetwraplist = [] self.text = self.logic.prepareQuestion() self.font = tkFont.Font(size=24) self.stmtvar = StringVar() self.stmtvar.set(self.text['question'][0]) self.statement = Label(self, textvariable=self.stmtvar, font=self.font) self.statement.pack(anchor = W) self.widgetwraplist.append(self.statement) self.checkbuttons = {} self.checkbtntext = {} self.checkbuttonvar = {} for i in range(1, 6): self.checkbuttonvar[str(i)] = BooleanVar() self.checkbtntext[str(i)] = StringVar() self.checkbtntext[str(i)].set(self.text['question'][i]) self.checkbuttons['question '+str(i)] = InvokableCheckbutton(self, textvariable = self.checkbtntext[str(i)], variable = self.checkbuttonvar[str(i)], font=self.font) self.checkbuttons['question '+str(i)].pack(anchor = W) self.widgetwraplist.append(self.checkbuttons['question '+str(i)]) self.bind("<Key-"+str(i)+">", self.checkbuttons['question '+str(i)].customInvoke) self.explvar = StringVar() self.explvar.set(' '.join(self.text['question'][6:])) self.explanation = Label(self, textvariable=self.explvar, font=self.font, justify=LEFT) self.widgetwraplist.append(self.explanation) self.buttonNext = Button(self, text = 'Next question', command = lambda: self.nextQuestion(1), font=self.font) self.buttonNext.pack(anchor = S) def nextQuestion(self, event): given_answers = [] self.logic.questioncount += 1 for i in range(1, 6): given_answers.append(self.logic.str2bool(self.checkbuttonvar[str(i)].get())) self.logic.questiondict[self.logic.questionpath]['given answers'] = given_answers if (self.logic.questiondict[self.logic.questionpath]['correct answers'] == self.logic.questiondict[self.logic.questionpath]['given answers']): self.logic.questiondict[self.logic.questionpath]['is correct'] = True else: self.logic.questiondict[self.logic.questionpath]['is correct'] = False if self.logic.questioncount < self.logic.EXAM_END: if self.logic.questioncount == self.logic.EXAM_END-1: self.buttonNext.configure(text='Finish exam') self.text = self.logic.prepareQuestion() self.stmtvar.set(self.text['question'][0]) self.explvar.set(' '.join(self.text['question'][6:])) self.explanation.pack_forget() for i in range(1, 6): self.checkbuttons['question '+str(i)].configure(fg='black') self.checkbuttonvar[str(i)].set(False) self.checkbtntext[str(i)].set(self.text['question'][i]) else: self.stmtvar.set('You scored {}%'.format(str(self.logic.calculateScore()))) if self.logic.calculateScore() >= 80: self.statement.configure(foreground='#009E18') else: self.statement.configure(foreground='red') for i in range(1, 6): self.checkbuttons['question '+str(i)].pack_forget() if self.logic.calculateScore() == 100: self.buttonNext.configure(text='Start a new exam') self.buttonNext.configure(command=lambda: self.startNewExam(1)) self.bind("<Right>", self.startNewExam) else: self.bind("<Right>", self.reviewWindow) self.buttonNext.configure(text='Review wrong answers') self.buttonNext.configure(command= lambda: self.reviewWindow(1)) def reviewWindow(self, event): self.reviewed = 0 self.buttonNext.configure(text='Next') self.buttonNext.pack_forget() for i in range(1, 6): self.checkbuttons['question '+str(i)].pack(anchor = W) self.explanation.pack(anchor = W) self.buttonNext.pack(anchor = S) self.showAnswer(1) def showAnswer(self, event): if self.reviewed == 0: self.bind("<Right>", self.showAnswer) self.buttonNext.configure(command= lambda: self.showAnswer(1)) for q in self.logic.questiondict: if self.logic.questiondict[q]['is correct'] == False: f = open(q, 'r') lines = self.logic.parseQuestion(f) self.stmtvar.set(lines['question'][0]) self.statement.configure(foreground='black') self.explvar.set(' '.join(lines['question'][6:])) for i in range(1, 6): self.checkbtntext[str(i)].set(lines['question'][i]) self.checkbuttonvar[str(i)].set(self.logic.questiondict[q]['given answers'][i-1]) if (self.logic.questiondict[q]['correct answers'][i-1] == self.logic.questiondict[q]['given answers'][i-1]): self.checkbuttons['question '+str(i)].configure(fg='#009E18') else: self.checkbuttons['question '+str(i)].configure(fg='red') del self.logic.questiondict[q] self.reviewed += 1 break if self.reviewed == self.logic.EXAM_END: self.buttonNext.configure(text='Start a new exam') self.buttonNext.configure(command=lambda: self.startNewExam(1)) self.bind("<Right>", self.startNewExam) def startNewExam(self, event): self.logic.questioncount = 0 self.questiondict = {} self.text = self.logic.prepareQuestion() self.stmtvar.set(self.text['question'][0]) for i in range(1, 6): self.checkbuttons['question '+str(i)].configure(fg='black') self.checkbuttonvar[str(i)].set(False) self.checkbtntext[str(i)].set(self.text['question'][i]) self.explanation.pack_forget() self.buttonNext.configure(text='next') self.buttonNext.configure(command=lambda: self.nextQuestion(1)) self.bind("<Right>", self.nextQuestion) def OnBigger(self, event): '''Make the font 2 points bigger''' size = self.font['size'] self.font.configure(size=size+2) def OnSmaller(self, event): '''Make the font 2 points smaller''' size = self.font['size'] self.font.configure(size=size-2) def wrapWidgets(self): self.update() for widget in self.widgetwraplist: widget.configure(wraplength=self.winfo_width())
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)
class Viewer(): def __init__(self, image): self.original = image self.image = image.copy() self.window = Tk() self.genViews() self.currentView = StringVar(self.window) self.currentView.set('Original') options = self.filters.keys() options.sort() self.views = OptionMenu(self.window, self.currentView, *options, command=self.applyFilter) self.views.pack() self.tkImage = ImageTk.PhotoImage(image) self.lblImage = Label(image=self.tkImage) self.lblImage.bind('<Button-1>', self.displayInfos) self.lblImage.bind('<Button-3>', self.save) self.lblImage.image = self.tkImage self.lblImage.pack() self.status = StringVar() self.lblStatus = Label(textvariable=self.status, justify='right') self.lblStatus.pack() self.window.mainloop() def displayInfos(self, event): """ Displays the coordinates in the status bar """ x = int((event.x - 0.1) / args.scalefactor) y = int((event.y - 0.1) / args.scalefactor) pixel = orig.getpixel((x, y)) self.setStatus("Coordinates : (%s:%s) - Pixel value : %s" % (x, y, str(pixel))) def setStatus(self, text): """ Changes the text in the status bar """ self.status.set(text) def save(self, event): """ Saves the filtered image to a file """ options = {'filetypes': [('PNG', '.png'), ('GIF', '.gif')]} outfile = tkFileDialog.asksaveasfilename(**options) if outfile == '': return else: self.image.save(outfile) return def genViews(self): """ Generates filters based on the source image """ self.filters = {} for plug in viewPlugins: self.filters.update({plug.name: viewPlugins.index(plug)}) def applyFilter(self, view): """ Applies a filter to the image """ view = self.filters[self.currentView.get()] plugin = viewPlugins[view] if plugin.parameters: for param in plugin.parameters.keys(): a = tkSimpleDialog.askinteger('Question', plugin.parameters[param]) if a is not None: setattr(viewPlugins[view], param, a) self.image = viewPlugins[view].process(self.original) self.showImage(self.currentView.get(), self.image) self.setStatus("") return def showImage(self, title, image): """ Updates the image in the window """ self.tkImage = ImageTk.PhotoImage(image) self.lblImage.configure(image=self.tkImage) self.lblImage.image = self.tkImage
class VideoSelectionScreen(GuiBaseFrame): def __init__(self, parent, controller, **kw): GuiBaseFrame.__init__(self, parent, controller, **kw) def init_widgets(self): self.content_wrapper = Frame(self) self.init_video_info() self.screen_title_label = Header1Label(self.content_wrapper, text="Video Selection") self.instruction_label = PLabel( self.content_wrapper, text="Please choose your left and right video files. " "Press Next when finished.\n" "(Files must be in MKV format).") self.left_video_filename_preview_label = PLabel( self.content_wrapper, text="No Video Selected") self.left_video_button = Button( self.content_wrapper, text="Choose Left Video", command=lambda: self.select_video_through_button_press(LEFT)) self.right_video_filename_preview_label = PLabel( self.content_wrapper, text="No Video Selected") self.right_video_button = Button( self.content_wrapper, text="Choose Right Video", command=lambda: self.select_video_through_button_press(RIGHT)) self.next_button = Button(self.content_wrapper, text="Next", state=DISABLED, command=lambda: self.next_screen()) self.add_img_previews() def add_widgets_to_frame(self): self.content_wrapper.grid_columnconfigure(0, weight=1) self.content_wrapper.grid_columnconfigure(1, weight=1) self.screen_title_label.grid(row=SCREEN_TITLE_ROW, column=0, columnspan=CENTER_SCREEN_COLSPAN) self.instruction_label.grid(row=INSTRUCTION_ROW, column=LEFT_VIDEO_THUMBNAIL_COL, columnspan=CENTER_SCREEN_COLSPAN) self.left_video_thumbnail.grid(row=THUMBNAIL_ROW, column=LEFT_VIDEO_THUMBNAIL_COL) self.left_video_filename_preview_label.grid( row=FILENAME_PREVIEW_ROW, column=LEFT_VIDEO_THUMBNAIL_COL) self.left_video_button.grid(row=CHOOSE_VIDEO_BUTTON_ROW, column=LEFT_VIDEO_THUMBNAIL_COL) self.right_video_thumbnail.grid(row=THUMBNAIL_ROW, column=RIGHT_VIDEO_THUMBNAIL_COL) self.right_video_filename_preview_label.grid( row=FILENAME_PREVIEW_ROW, column=RIGHT_VIDEO_THUMBNAIL_COL) self.right_video_button.grid(row=CHOOSE_VIDEO_BUTTON_ROW, column=RIGHT_VIDEO_THUMBNAIL_COL) self.next_button.grid(row=NEXT_BUTTON_ROW, column=0, columnspan=CENTER_SCREEN_COLSPAN) self.content_wrapper.place(relx=SCREENS_REL_X, rely=SCREEN_REL_Y_47, anchor=CENTER) def init_video_info(self): self.left_video_selected = False self.right_video_selected = False self.left_video_filename = None self.right_video_filename = None def next_screen(self): self.controller.set_video_filenames(self.left_video_filename, self.right_video_filename) self.controller.show_next_frame() def add_img_previews(self): img_not_available = cv2.imread( get_asset_filename(IMG_NOT_AVAILABLE_FILENAME)) img_not_available = cv2_bgr_image_to_tkinter_with_resize( img_not_available, VIDEO_PREVIEW_WIDTH, VIDEO_PREVIEW_HEIGHT) self.left_video_thumbnail = Label(self.content_wrapper, image=img_not_available) self.left_video_thumbnail.image = img_not_available self.right_video_thumbnail = Label(self.content_wrapper, image=img_not_available) self.right_video_thumbnail.image = img_not_available def select_video_through_button_press(self, video_side=LEFT): selected_video_filename = select_video_filename() self.set_video_thumbnail_based_on_filename(selected_video_filename, video_side) def set_next_button_state(self): if self.left_video_selected and self.right_video_selected: self.next_button.configure(state=NORMAL) def on_show_frame(self): if does_tmp_file_exist_basename(VIDEOS_SELECTED_TMP_FILENAME): video_filenames = read_tmp_file(VIDEOS_SELECTED_TMP_FILENAME) video_filenames = ast.literal_eval(video_filenames) self.set_video_thumbnail_based_on_filename(video_filenames[LEFT], LEFT) self.set_video_thumbnail_based_on_filename(video_filenames[RIGHT], RIGHT) def on_hide_frame(self): video_filenames_used = { LEFT: self.left_video_filename, RIGHT: self.right_video_filename } write_to_tmp_file(VIDEOS_SELECTED_TMP_FILENAME, str(video_filenames_used)) def set_video_thumbnail_based_on_filename(self, video_filename, video_side=LEFT): if os.path.isfile( os.path.join(os.path.dirname(video_filename), os.path.basename(video_filename))): vc_object = cv2.VideoCapture(video_filename) _, img = vc_object.read() vc_object.release() img = cv2_bgr_image_to_tkinter_with_resize(img, VIDEO_PREVIEW_WIDTH, VIDEO_PREVIEW_HEIGHT) self.update_ui(video_filename, img, True, video_side) def update_ui(self, filename, img, video_selected, video_side=LEFT): if video_selected and video_side == LEFT: self.left_video_selected = True self.left_video_filename = filename self.left_video_filename_preview_label.config( text=os.path.basename(os.path.normpath(filename))) self.set_next_button_state() self.left_video_thumbnail.configure(image=img) self.left_video_thumbnail.image = img elif video_selected and video_side == RIGHT: self.right_video_selected = True self.right_video_filename = filename self.right_video_filename_preview_label.config( text=os.path.basename(os.path.normpath(filename))) self.set_next_button_state() self.right_video_thumbnail.configure(image=img) self.right_video_thumbnail.image = img
class KeyboardEntry: """Mixin class that can be used to add the ability to type values for widget. When the cursor enters the widget the focus is set to the widget and the widget that had the focus previousy is saved in .lastFocus. When the cursor leaves the widget focus is restored to self.lastFocus. key_cb(event) is called upon KeyRelease events. If this is the first keytroke an undecorated window is created next to the cursor and handleKeyStroke(event) is called. This method should be subclassed to modify the way the string is typed in (see thumbwheel.py for an example of handling numbers only). When the Return key is pressed, the entry window is destroyed and if the typed striong is not empty self.callSet(self.typedValue) is called. If the cursor moves out of the widget before Rrturn is pressed the value in the entry window is discarded and the entry window is destroyed. """ def __init__(self, widgets, callSet): # callSet is a function taking one argument (string) which will be # when the Returnm key is hit (if the typed string is not empty) # widgets is a list of Tkinter wigets for which <Enter>, <Leave> # <Return> and <KeyRelease> are handled. These widgets has to exist # before thsi constructor can be called assert callable(callSet) self.callSet = callSet for w in widgets: w.bind("<Enter>", self.enter_cb) w.bind("<Leave>", self.leave_cb) w.bind("<Return>", self.return_cb) w.bind("<KeyRelease>", self.key_cb) self.typedValue = '' # string accumulating valuescharacters typed self.lastFocus = None # widget to which the focus will be restored # when the mouse leaves the widget self.topEntry = None # top level for typing values self.typedValueTK = None #Tk label used as entry for value def key_cb(self, event=None): # call back function for keyboard events (except for Return) # handle numbers to set value key = event.keysym if key == 'Return': return #print 'Key:', key if len(self.typedValue) == 0 and self.topEntry is None: # create Tk label showing typed value x = event.x y = event.y #print 'create entry' self.topEntry = Toplevel() self.topEntry.overrideredirect(1) w = event.widget if event.x >= 0: self.topEntry.geometry('+%d+%d' % (w.winfo_rootx() + event.x + 10, w.winfo_rooty() + event.y)) else: self.topEntry.geometry('+%d+%d' % (w.winfo_rootx() + 10, w.winfo_rooty())) self.typedValueTK = Label(master=self.topEntry, text='', relief='sunken', bg='yellow') self.typedValueTK.pack() self.handleKeyStroke(event) def leave_cb(self, event=None): # make sure widget gets keyboard events # print 'leave', event.widget if self.topEntry: self.typedValueTK.destroy() self.topEntry.destroy() self.topEntry = None self.typedValue = '' if self.lastFocus: #print 'restoring focus' if widgetsOnBackWindowsCanGrabFocus is False: lActiveWindow = self.lastFocus.focus_get() if lActiveWindow is not None \ and ( lActiveWindow.winfo_toplevel() != self.lastFocus.winfo_toplevel() ): return self.lastFocus.focus_set() self.lastFocus = None event.widget.config(cursor='') def enter_cb(self, event=None): # make sure widget gets keyboard events #print 'enter', event.widget if widgetsOnBackWindowsCanGrabFocus is False: lActiveWindow = event.widget.focus_get() if lActiveWindow is not None \ and ( lActiveWindow.winfo_toplevel() != event.widget.winfo_toplevel() ): return if self.lastFocus is None: #print 'setting focus' self.lastFocus = self.focus_lastfor() event.widget.focus_set() event.widget.config(cursor='xterm') def return_cb(self, event): # return should destroy the topEntry #print "return_cb" if self.typedValueTK is not None: self.typedValueTK.destroy() if self.topEntry is not None: self.topEntry.destroy() self.topEntry = None if len(self.typedValue): #print 'setting to', self.type(self.typedValue) self.callSet(self.typedValue) self.typedValue = '' ## TO BE SUBCLASSED def handleKeyStroke(self, event): # by default we handle delete character keys key = event.keysym if key == 'BackSpace' or key == 'Delete': self.typedValue = self.typedValue[:-1] self.typedValueTK.configure(text=self.typedValue)
class UIHeap(object): """ Interface object for a heap """ def __init__(self, frame, position, h_center, v_center): self._h_center = h_center self._v_center = v_center # Memorise the frame self.frame = frame self.position = position # Memorise the card in the heap self._heap = None # The image itself self._heap_image = None # The label index self._label_index = None self._init_label() def label_column(self): """ Define the position for the heap """ if self.position == 0 or self.position == 2: # Base column = self._h_center elif self.position == 1 or self.position == 3: # Base column = self._h_center # Small shifting h_shift = 60 if self.position == 1: # Shift it to the right column += h_shift elif self.position == 3: # Shift it to the left column -= h_shift # Don't forget to center it column -= ImageLoader.CARD_WIDTH / 2.0 return column def label_row(self): """ Return the row (pixel) of the heap according to its player position """ row = UIPositioning.first_card_row[self.position] vert_shift = 15 if self.position == 0: # Shift it down row += 1.5*ImageLoader.CARD_HEIGHT # A little higher row -= vert_shift elif self.position == 2: # Shift it up row -= 1.5 * ImageLoader.CARD_HEIGHT # Down down down row += vert_shift return row def _place_label(self): """ Place the label to its position """ # Need to destroy it to place it on top of others cards self._label.destroy() self._init_label() self._set_image() self._label.place(x = self.label_column(), y = self.label_row()) def _init_label(self): """ Init the label """ self._label = Label(self.frame) def _set_image(self): """ Set the image using the current image """ self._label.configure(image = self._heap_image) def _update_heap_image(self): """ Update the card image """ # Remove or update the image ? if self.heap is None: # Remove the image self._label.place_forget() self._heap_image = None else: # Get a new card new_card = UICard.get_card_image(self.heap) # Save it self._heap_image = new_card # Replace it self._place_label() @property def heap(self): return self._heap @heap.setter def heap(self, value): self._heap = value self._update_heap_image()
class EMNN(): def __init__(self, conn): conn.gui = True queue = self.queue = Queue.Queue() conn.queue = queue self.conn = conn def startgui(self): self.root = root = Tk() root.title('SIMAPSE - Simulation Maps for Ecological Niche Modelling') root.geometry('695x445+375+115') root.tk.call('encoding', 'system', 'utf-8') root.configure(bg='#d9d9d9') root.resizable(width='false', height='false') self.gui() self.root.after(100, self.periodicUpdate) root.mainloop() def gui(self): from Tkinter import Button, Entry, Frame, Label, Checkbutton, \ Scrollbar, Text, IntVar, StringVar, OptionMenu self.dir_project = '' self.folds = 0 self.func = "" self.aucfilter = IntVar() self.lightgray = '#d9d9d9' self.darkgray = '#d3d3d3' self.normaltext = ("Helvetica", -10) self.boldtext = ("Helvetica", -10, "bold") self.bigtext = ("Helvetica", -12, "bold") self.smalltext = ("Helvetica", -9) self.butData = Button(self.root) self.butData.place(in_=self.root, x=5, y=5) self.butData.configure(height=1, width=10, text="Data File", font=self.normaltext, highlightbackground=self.lightgray, command=self.dataOpen) self.butRasterFolder = Button(self.root) self.butRasterFolder.place(in_=self.root, x=5, y=35) self.butRasterFolder.configure(height=1, width=10, text="Raster Folder", font=self.normaltext, highlightbackground=self.lightgray, command=self.rasterOpen) self.butOutFolder = Button(self.root) self.butOutFolder.place(in_=self.root, x=5, y=65) self.butOutFolder.configure(height=1, width=10, text="Out Folder", font=self.normaltext, highlightbackground=self.lightgray, command=self.outOpen) self.entData = Entry(self.root) self.entData.place(in_=self.root, x=100, y=9) self.entData.configure(textvariable="file_data", font=self.normaltext, width=97, background=self.darkgray, relief="flat", highlightbackground=self.lightgray) self.entData.insert(0, '') self.entOutFolder = Entry(self.root) self.entOutFolder.place(in_=self.root, x=100, y=69) self.entOutFolder.configure(textvariable="out_dir", font=self.normaltext, width=97, background=self.darkgray, relief="flat", highlightbackground=self.lightgray) self.entOutFolder.insert(0, '') self.entRasterFolder = Entry(self.root) self.entRasterFolder.place(in_=self.root, x=100, y=39) self.entRasterFolder.configure(textvariable="dir_rasters", font=self.normaltext, width=97, background=self.darkgray, relief="flat", highlightbackground=self.lightgray) self.entRasterFolder.insert(0, '') self.activeMethod = StringVar(self.root) self.activeMethod.set("Random repetition") self.butMETHOD = OptionMenu( self.root, self.activeMethod, "Random repetition", "Cross validation", "Bootstrapping", command=lambda x: self.displayMethodFrame(x)) self.butMETHOD.place(in_=self.root, x=4, y=97, height="25", width="120") self.butMETHOD.configure(font=self.smalltext, background=self.lightgray) self.displayMethodFrame(self.activeMethod.get()) self.activeOption = StringVar(self.root) self.activeOption.set("Network structure") self.butOPTION = OptionMenu( self.root, self.activeOption, "Network structure", "Options", command=lambda x: self.displayOptionFrame(x)) self.butOPTION.place(in_=self.root, x=4, y=182, height="25", width="120") self.butOPTION.configure(font=self.smalltext, background=self.lightgray) self.displayOptionFrame(self.activeOption.get()) self.Progress_frame = Frame(self.root) self.Progress_frame.place(in_=self.root, x=5, y=423) self.Progress_frame.configure(borderwidth="2", relief='sunken', height="20", width="105", bg='white') self.Progress_bar = Label(self.Progress_frame) self.Progress_bar.place(x=0, y=0) self.Progress_bar.configure(font=self.smalltext) self.Progress_info = Label(self.root) self.Progress_info.place(x=110, y=425) self.Progress_info.configure(font=self.smalltext, bg=self.lightgray) self.frameButtons = Frame(self.root) self.frameButtons.place(in_=self.root, x=5, y=336) self.frameButtons.configure(borderwidth="2", bg=self.lightgray, relief="raise", height="84", width="260") self.butREAD = Button(self.root) self.butREAD.place(in_=self.frameButtons, x=5, y=5, width=70) self.butREAD.configure(font=self.bigtext, highlightbackground=self.lightgray, text="READ", command=self.read) self.butRUN = Button(self.root) self.butRUN.place(in_=self.frameButtons, x=80, y=5, width=70) self.butRUN.configure(font=self.bigtext, highlightbackground=self.lightgray, text="RUN", command=self.returnVar, state='disabled') self.butRESULTS = Button(self.root) self.butRESULTS.place(in_=self.frameButtons, x=155, y=5, width=80) self.butRESULTS.configure(font=self.bigtext, highlightbackground=self.lightgray, text="RESULTS", command=self.returnResults, state='disabled') self.butPROJECT = Button(self.root) self.butPROJECT.place(in_=self.frameButtons, x=5, y=45, width=70) self.butPROJECT.configure(font=self.boldtext, highlightbackground=self.lightgray, text="PROJECT", command=self.project, state='disabled') self.frameText = Frame(self.root) self.frameText.place(in_=self.root, x=270, y=100) self.frameText.configure(height=320, width=400) self.scrollbar = Scrollbar(self.root) self.textFrame = Text(self.frameText, wrap='word') self.textFrame.configure(font=self.normaltext, height="24", width="65") self.textFrame.place(x=0, y=0) self.textFrame.configure(yscrollcommand=self.scrollbar.set) self.scrollbar.configure(command=self.textFrame.yview, highlightbackground=self.lightgray) self.scrollbar.place(x=675, y=100, height=320) def displayMethodFrame(self, method): ''' Displays individual frames for the subsetting method''' from Tkinter import Button, Entry, Frame, Label if self.__dict__.has_key('frameMethodSelection'): self.frameMethodSelection.destroy() self.varupdate() c = self.conn.simargs self.frameMethodSelection = Frame(self.root) self.frameMethodSelection.place(in_=self.root, x=5, y=122) self.frameMethodSelection.configure(borderwidth="2", relief="raise", height="60", width="260", bg=self.lightgray) if method == "Random repetition": self.labRepetitions = Label(self.root) self.labRepetitions.place(in_=self.frameMethodSelection, x=2, y=10) self.labRepetitions.configure(font=self.normaltext, borderwidth="1", justify='left', anchor='e', bg=self.lightgray, text="Number of repetitions:") self.entRepetitions = Entry(self.root) self.entRepetitions.place(in_=self.frameMethodSelection, x=125, y=10) self.entRepetitions.configure(textvariable="repetitions", width="7", font=self.normaltext, highlightbackground=self.lightgray) self.entRepetitions.delete(0, 'end') self.entRepetitions.insert('end', c['repetitions']) elif method == "Cross validation": self.labRepetitions = Label(self.root) self.labRepetitions.place(in_=self.frameMethodSelection, x=2, y=10) self.labRepetitions.configure(font=self.normaltext, bg=self.lightgray, text="Number of folds:") self.entRepetitions = Entry(self.root) self.entRepetitions.place(in_=self.frameMethodSelection, x=100, y=10) self.entRepetitions.configure(textvariable="repetitions", width="7", highlightbackground=self.lightgray, font=self.normaltext) self.entRepetitions.delete(0, 'end') self.entRepetitions.insert('end', c['repetitions']) elif method == "Bootstrapping": self.labRepetition = Label(self.root) self.labRepetition.place(in_=self.frameMethodSelection, x=2, y=5) self.labRepetition.configure(borderwidth="1", text="Number of Bootstraps:", bg=self.lightgray, font=self.normaltext) self.entRepetitions = Entry(self.root) self.entRepetitions.place(in_=self.frameMethodSelection, x=125, y=5) self.entRepetitions.configure(textvariable="repetitions", width="7", highlightbackground=self.lightgray, font=self.normaltext) self.entRepetitions.delete(0, 'end') self.entRepetitions.insert('end', c['repetitions']) self.labBsize = Label(self.root) self.labBsize.place(in_=self.frameMethodSelection, x=2, y=30) self.labBsize.configure(borderwidth="1", text="Bootstraps Sample Size:", bg=self.lightgray, font=self.normaltext) self.entBsize = Entry(self.root) self.entBsize.place(in_=self.frameMethodSelection, x=125, y=30) self.entBsize.configure(textvariable="Bsize", width="7", highlightbackground=self.lightgray, font=self.normaltext) self.entBsize.delete(0, 'end') self.entBsize.insert('end', c['bsize']) def displayOptionFrame(self, option): ''' Displays individual frames for the subsetting method''' from Tkinter import Button, Entry, Frame, Label, Checkbutton if self.__dict__.has_key('frameOptionSelection'): self.frameOptionSelection.destroy() self.varupdate() c = self.conn.simargs self.frameOptionSelection = Frame(self.root) self.frameOptionSelection.place(in_=self.root, x=5, y=207) self.frameOptionSelection.configure(borderwidth="2", relief="raise", height="125", width="260", bg=self.lightgray) if option == "Network structure": self.labMaxiter = Label(self.root) self.labMaxiter.place(in_=self.frameOptionSelection, x=190, y=5) self.labMaxiter.configure(borderwidth="1", font=self.normaltext, text="Internal", bg=self.lightgray) self.labNNN = Label(self.root) self.labNNN.place(in_=self.frameOptionSelection, x=95, y=5) self.labNNN.configure(borderwidth="1", font=self.normaltext, text="Reported", bg=self.lightgray) self.labTI = Label(self.root) self.labTI.place(in_=self.frameOptionSelection, x=5, y=25) self.labTI.configure(borderwidth="1", font=self.normaltext, text="Total iterations =", bg=self.lightgray) self.entITERReport = Entry(self.root) self.entITERReport.place(in_=self.frameOptionSelection, x=88, y=25) self.entITERReport.configure(textvariable="AUCReport", width="10", font=self.normaltext, highlightbackground=self.lightgray) self.entITERReport.delete(0, 'end') self.entITERReport.insert('end', c['iterreport']) self.times = Label(self.root) self.times.place(in_=self.frameOptionSelection, x=160, y=25) self.times.configure(text="x", font=self.normaltext, bg=self.lightgray) self.entITERInter = Entry(self.root) self.entITERInter.place(in_=self.frameOptionSelection, x=180, y=25) self.entITERInter.configure(textvariable="maxiter", width="10", font=self.normaltext, highlightbackground=self.lightgray) self.entITERInter.delete(0, 'end') self.entITERInter.insert('end', c['iterinter']) self.labEta = Label(self.root) self.labEta.place(in_=self.frameOptionSelection, x=5, y=55) self.labEta.configure(borderwidth="1", font=self.normaltext, text="Learning Rate", bg=self.lightgray) self.butHINT = Button(self.root) self.butHINT.place(in_=self.frameOptionSelection, x=65, y=75, height=23, width=20) self.butHINT.configure(font=self.smalltext, text="H", command=self.hint, state='disabled', highlightbackground=self.lightgray) self.labMomentum = Label(self.root) self.labMomentum.place(in_=self.frameOptionSelection, x=88, y=55) self.labMomentum.configure(borderwidth="1", font=self.normaltext, text="Momentum", bg=self.lightgray) self.entLRATE = Entry(self.root) self.entLRATE.place(in_=self.frameOptionSelection, x=5, y=75) self.entLRATE.configure(textvariable="eta", width="8", font=self.normaltext, highlightbackground=self.lightgray) self.entLRATE.delete(0, 'end') self.entLRATE.insert('end', c['lrate']) self.entMomentum = Entry(self.root) self.entMomentum.place(in_=self.frameOptionSelection, x=90, y=75) self.entMomentum.configure(textvariable="momentum", width="8", font=self.normaltext, highlightbackground=self.lightgray) self.entMomentum.delete(0, 'end') self.entMomentum.insert('end', c['momentum']) self.labNNS = Label(self.root) self.labNNS.place(in_=self.frameOptionSelection, x=165, y=55) self.labNNS.configure(borderwidth="1", font=self.normaltext, text="Hidden Layers", bg=self.lightgray) self.entNNShape = Entry(self.root) self.entNNShape.place(in_=self.frameOptionSelection, x=160, y=75) self.entNNShape.configure(textvariable="HiddenLyr", width="14", font=self.normaltext, highlightbackground=self.lightgray) self.entNNShape.delete(0, 'end') self.entNNShape.insert('end', c['hiddenlyrs']) elif option == "Options": self.labPercentage = Label(self.root) self.labPercentage.place(in_=self.frameOptionSelection, x=2, y=5) self.labPercentage.configure(borderwidth="1", text="Test %:", font=self.normaltext, bg=self.lightgray) self.entPercentage = Entry(self.root) self.entPercentage.place(in_=self.frameOptionSelection, x=45, y=5, width=30) self.entPercentage.configure(textvariable="Percentage", font=self.normaltext, highlightbackground=self.lightgray) self.entPercentage.delete(0, 'end') self.entPercentage.insert('end', c['percentage']) self.labAPRatio = Label(self.root) self.labAPRatio.place(in_=self.frameOptionSelection, x=80, y=5) self.labAPRatio.configure(borderwidth="1", text="Pseudoabsences/Presences:", font=self.normaltext, bg=self.lightgray) self.entAPRatio = Entry(self.root) self.entAPRatio.place(in_=self.frameOptionSelection, x=220, y=5) self.entAPRatio.configure(textvariable="apratio", width="4", font=self.normaltext, highlightbackground=self.lightgray) self.entAPRatio.delete(0, 'end') self.entAPRatio.insert('end', c['apratio']) self.labBurnin = Label(self.root) self.labBurnin.place(in_=self.frameOptionSelection, x=2, y=30) self.labBurnin.configure(borderwidth="1", text="Burn-in iterations:", font=self.normaltext, bg=self.lightgray) self.entBurnin = Entry(self.root) self.entBurnin.place(in_=self.frameOptionSelection, x=90, y=30) self.entBurnin.configure(textvariable="burnin", width="8", font=self.normaltext, highlightbackground=self.lightgray) self.entBurnin.delete(0, 'end') self.entBurnin.insert('end', c['burnin']) self.chkAucFilter = Checkbutton(self.root) self.chkAucFilter.place(in_=self.frameOptionSelection, x=2, y=60) self.chkAucFilter.configure(font=self.normaltext, text="Filter with AUC threshold", variable=self.aucfilter, bg=self.lightgray, command=self.aucstate) self.labAUCTrain = Label(self.root) self.labAUCTrain.place(in_=self.frameOptionSelection, x=5, y=85) self.labAUCTrain.configure(borderwidth="1", font=self.normaltext, text="training data", bg=self.lightgray) self.entAUCTrain = Entry(self.root) self.entAUCTrain.place(in_=self.frameOptionSelection, x=70, y=85) self.entAUCTrain.configure(textvariable="valueAuc", width="8", font=self.normaltext, highlightbackground=self.lightgray) self.entAUCTrain.delete(0, 'end') self.entAUCTrain.insert('end', c['auctrain']) self.labAUCTest = Label(self.root) self.labAUCTest.place(in_=self.frameOptionSelection, x=130, y=85) self.labAUCTest.configure(borderwidth="1", font=self.normaltext, text="testing data", bg=self.lightgray) self.entAUCTest = Entry(self.root) self.entAUCTest.place(in_=self.frameOptionSelection, x=195, y=85) self.entAUCTest.configure(textvariable="valueAucTest", width="8", font=self.normaltext, highlightbackground=self.lightgray) self.entAUCTest.delete(0, 'end') self.entAUCTest.insert('end', c['auctest']) self.aucstate() def varupdate(self): extract = self.extract c = self.conn.simargs c['file_data'] = extract('entData', c['file_data']) c['dir_rasters'] = extract('entRasterFolder', c['dir_rasters']) c['out_dir'] = extract('entOutFolder', c['out_dir']) c['method'] = extract('activeMethod', c['method']) c['iterreport'] = int(extract('entITERReport', c['iterreport'])) c['iterinter'] = int(extract('entITERInter', c['iterinter'])) c['lrate'] = float(extract('entLRATE', c['lrate'])) c['momentum'] = float(extract('entMomentum', c['momentum'])) c['hiddenlyrs'] = extract('entNNShape', c['hiddenlyrs']) c['apratio'] = float(extract('entAPRatio', c['apratio'])) c['percentage'] = int(extract('entPercentage', c['percentage'])) c['burnin'] = int(extract('entBurnin', c['burnin'])) c['auctrain'] = float(extract('entAUCTrain', c['auctrain'])) c['auctest'] = float(extract('entAUCTest', c['auctest'])) c['repetitions'] = int(extract('entRepetitions', c['repetitions'])) c['bsize'] = int(extract('entBsize', c['bsize'])) c['aucfilter'] = bool(extract('aucfilter', int(c['aucfilter']))) def extract(self, test, default): if test in self.__dict__.keys(): value = self.__dict__[test].get() else: value = default return value def read(self): import time self.varupdate() self.conn.processor(self.conn.manager.read_all, 'read') def returnVar(self): # Updates variables self.varupdate() self.conn.processor(self.conn.manager.model, 'run') def returnResults(self): self.varupdate() self.conn.processor(self.conn.manager.results, 'results') def project(self): self.varupdate() project_dir = askdirectory() self.conn.simargs['project_dir'] = project_dir self.conn.processor(self.conn.manager.project, 'project') def hint(self): self.varupdate() self.conn.processor(self.conn.manager.hint, 'hint') def dataOpen(self): self.entData.delete(0, 'end') file_data = askopenfilename(filetypes=[("text files", "*.txt"), ("allfiles", "*")]) self.entData.insert('end', file_data) def rasterOpen(self): self.entRasterFolder.delete(0, 'end') dir_rasters = askdirectory() self.entRasterFolder.insert('end', dir_rasters) def outOpen(self): self.entOutFolder.delete(0, 'end') out_dir = askdirectory() self.entOutFolder.insert('end', out_dir) def update_text(self, string_txt): txt = string_txt + " \n" self.textFrame.insert('end', txt) self.textFrame.yview('end') def processGraph(self, graph_object): '''Just a wraper to call the graphics creation object''' graph_object() def periodicUpdate(self): """Executes periodic checks to GUI: - if there are new messages and displays when true""" try: while 1: code, args, kwargs = self.queue.get_nowait() if code == Connector.CODE_TEXT: self.update_text(*args) elif code == Connector.CODE_PROGRESS: self.progress(*args, **kwargs) elif code == Connector.CODE_MODIFY_BUTTON: self.modify_but(*args) elif code == Connector.CODE_SHOWRESULTS: self.showResults(*args) elif code == Connector.CODE_GRAPHS: self.processGraph(args) else: self.update_text('Unknown message...') self.queue.task_done() self.root.update() except Queue.Empty: pass self.root.after(100, self.periodicUpdate) def modify_but(self, state, buttonlist): if buttonlist == 'all': buttonlist = [ 'READ', 'RUN', 'RESULTS', 'PROJECT', 'HINT', 'METHOD', 'OPTION' ] for button in buttonlist: but = "self.but%s.configure(state=\'%s\')" % (button, state) exec(but) def abundance(self): self.entAUCTrain.configure(state='disabled') self.entAUCTest.configure(state='disabled') def aucstate(self): if self.aucfilter.get(): state = 'normal' else: state = 'disabled' self.entAUCTrain.configure(state=state) self.entAUCTest.configure(state=state) def progress(self, value, maxvalue, **kwargs): '''Shows the progress bar in GUI args are: Value - Value of the current progress MaxValue - Value where progress terminates kwargs are color - Color for the progess bar msg - message to display''' color = 'blue' if 'color' in kwargs: color = kwargs['color'] percent = (value * 100) / maxvalue self.Progress_bar.configure(font=self.smalltext, foreground="white", background=color) #"#0000ff" if percent <> 100: width = int((percent / 100.000) * 20) text = '%s%%' % percent self.Progress_bar.configure(text=text, width=width) if 'msg' in kwargs: self.Progress_info.configure(text=kwargs['msg']) elif percent == 100: self.Progress_bar.configure(text="", width=0, relief="flat", background="#ece9d8") self.Progress_info.configure(text="") def showResults(self, figures): from Tkinter import Button figures = [self.entOutFolder.get() + "/" + x for x in figures] ResultsWindow = mytoplevel(self.root, figures, self) ResultsWindow.title('Results') butRW = Button(ResultsWindow, text='CLOSE', command=ResultsWindow.destroy) butRW.pack() def update_queue(self): try: while self.queue.qsize(): msg = '%s\n' % self.queue.get(0) self.textFrame.insert('end', msg) self.textFrame.yview('end') except Queue.Empty: pass
class Debugger: vstack = vsource = vlocals = vglobals = None def __init__(self, pyshell, idb=None): if idb is None: idb = Idb(self) self.pyshell = pyshell self.idb = idb self.frame = None self.make_gui() self.interacting = 0 self.nesting_level = 0 def run(self, *args): # Deal with the scenario where we've already got a program running # in the debugger and we want to start another. If that is the case, # our second 'run' was invoked from an event dispatched not from # the main event loop, but from the nested event loop in 'interaction' # below. So our stack looks something like this: # outer main event loop # run() # <running program with traces> # callback to debugger's interaction() # nested event loop # run() for second command # # This kind of nesting of event loops causes all kinds of problems # (see e.g. issue #24455) especially when dealing with running as a # subprocess, where there's all kinds of extra stuff happening in # there - insert a traceback.print_stack() to check it out. # # By this point, we've already called restart_subprocess() in # ScriptBinding. However, we also need to unwind the stack back to # that outer event loop. To accomplish this, we: # - return immediately from the nested run() # - abort_loop ensures the nested event loop will terminate # - the debugger's interaction routine completes normally # - the restart_subprocess() will have taken care of stopping # the running program, which will also let the outer run complete # # That leaves us back at the outer main event loop, at which point our # after event can fire, and we'll come back to this routine with a # clean stack. if self.nesting_level > 0: self.abort_loop() self.root.after(100, lambda: self.run(*args)) return try: self.interacting = 1 return self.idb.run(*args) finally: self.interacting = 0 def close(self, event=None): try: self.quit() except Exception: pass if self.interacting: self.top.bell() return if self.stackviewer: self.stackviewer.close() self.stackviewer = None # Clean up pyshell if user clicked debugger control close widget. # (Causes a harmless extra cycle through close_debugger() if user # toggled debugger from pyshell Debug menu) self.pyshell.close_debugger() # Now close the debugger control window.... self.top.destroy() def make_gui(self): pyshell = self.pyshell self.flist = pyshell.flist self.root = root = pyshell.root self.top = top = ListedToplevel(root) self.top.wm_title("Debug Control") self.top.wm_iconname("Debug") top.wm_protocol("WM_DELETE_WINDOW", self.close) self.top.bind("<Escape>", self.close) # self.bframe = bframe = Frame(top) self.bframe.pack(anchor="w") self.buttons = bl = [] # self.bcont = b = Button(bframe, text="Go", command=self.cont) bl.append(b) self.bstep = b = Button(bframe, text="Step", command=self.step) bl.append(b) self.bnext = b = Button(bframe, text="Over", command=self.next) bl.append(b) self.bret = b = Button(bframe, text="Out", command=self.ret) bl.append(b) self.bret = b = Button(bframe, text="Quit", command=self.quit) bl.append(b) # for b in bl: b.configure(state="disabled") b.pack(side="left") # self.cframe = cframe = Frame(bframe) self.cframe.pack(side="left") # if not self.vstack: self.__class__.vstack = BooleanVar(top) self.vstack.set(1) self.bstack = Checkbutton(cframe, text="Stack", command=self.show_stack, variable=self.vstack) self.bstack.grid(row=0, column=0) if not self.vsource: self.__class__.vsource = BooleanVar(top) self.bsource = Checkbutton(cframe, text="Source", command=self.show_source, variable=self.vsource) self.bsource.grid(row=0, column=1) if not self.vlocals: self.__class__.vlocals = BooleanVar(top) self.vlocals.set(1) self.blocals = Checkbutton(cframe, text="Locals", command=self.show_locals, variable=self.vlocals) self.blocals.grid(row=1, column=0) if not self.vglobals: self.__class__.vglobals = BooleanVar(top) self.bglobals = Checkbutton(cframe, text="Globals", command=self.show_globals, variable=self.vglobals) self.bglobals.grid(row=1, column=1) # self.status = Label(top, anchor="w") self.status.pack(anchor="w") self.error = Label(top, anchor="w") self.error.pack(anchor="w", fill="x") self.errorbg = self.error.cget("background") # self.fstack = Frame(top, height=1) self.fstack.pack(expand=1, fill="both") self.flocals = Frame(top) self.flocals.pack(expand=1, fill="both") self.fglobals = Frame(top, height=1) self.fglobals.pack(expand=1, fill="both") # if self.vstack.get(): self.show_stack() if self.vlocals.get(): self.show_locals() if self.vglobals.get(): self.show_globals() def interaction(self, message, frame, info=None): self.frame = frame self.status.configure(text=message) # if info: type, value, tb = info try: m1 = type.__name__ except AttributeError: m1 = "%s" % str(type) if value is not None: try: m1 = "%s: %s" % (m1, str(value)) except: pass bg = "yellow" else: m1 = "" tb = None bg = self.errorbg self.error.configure(text=m1, background=bg) # sv = self.stackviewer if sv: stack, i = self.idb.get_stack(self.frame, tb) sv.load_stack(stack, i) # self.show_variables(1) # if self.vsource.get(): self.sync_source_line() # for b in self.buttons: b.configure(state="normal") # self.top.wakeup() # Nested main loop: Tkinter's main loop is not reentrant, so use # Tcl's vwait facility, which reenters the event loop until an # event handler sets the variable we're waiting on self.nesting_level += 1 self.root.tk.call('vwait', '::idledebugwait') self.nesting_level -= 1 # for b in self.buttons: b.configure(state="disabled") self.status.configure(text="") self.error.configure(text="", background=self.errorbg) self.frame = None def sync_source_line(self): frame = self.frame if not frame: return filename, lineno = self.__frame2fileline(frame) if filename[:1] + filename[-1:] != "<>" and os.path.exists(filename): self.flist.gotofileline(filename, lineno) def __frame2fileline(self, frame): code = frame.f_code filename = code.co_filename lineno = frame.f_lineno return filename, lineno def cont(self): self.idb.set_continue() self.abort_loop() def step(self): self.idb.set_step() self.abort_loop() def next(self): self.idb.set_next(self.frame) self.abort_loop() def ret(self): self.idb.set_return(self.frame) self.abort_loop() def quit(self): self.idb.set_quit() self.abort_loop() def abort_loop(self): self.root.tk.call('set', '::idledebugwait', '1') stackviewer = None def show_stack(self): if not self.stackviewer and self.vstack.get(): self.stackviewer = sv = StackViewer(self.fstack, self.flist, self) if self.frame: stack, i = self.idb.get_stack(self.frame, None) sv.load_stack(stack, i) else: sv = self.stackviewer if sv and not self.vstack.get(): self.stackviewer = None sv.close() self.fstack['height'] = 1 def show_source(self): if self.vsource.get(): self.sync_source_line() def show_frame(self, stackitem): self.frame = stackitem[0] # lineno is stackitem[1] self.show_variables() localsviewer = None globalsviewer = None def show_locals(self): lv = self.localsviewer if self.vlocals.get(): if not lv: self.localsviewer = NamespaceViewer(self.flocals, "Locals") else: if lv: self.localsviewer = None lv.close() self.flocals['height'] = 1 self.show_variables() def show_globals(self): gv = self.globalsviewer if self.vglobals.get(): if not gv: self.globalsviewer = NamespaceViewer(self.fglobals, "Globals") else: if gv: self.globalsviewer = None gv.close() self.fglobals['height'] = 1 self.show_variables() def show_variables(self, force=0): lv = self.localsviewer gv = self.globalsviewer frame = self.frame if not frame: ldict = gdict = None else: ldict = frame.f_locals gdict = frame.f_globals if lv and gv and ldict is gdict: ldict = None if lv: lv.load_dict(ldict, force, self.pyshell.interp.rpcclt) if gv: gv.load_dict(gdict, force, self.pyshell.interp.rpcclt) def set_breakpoint_here(self, filename, lineno): self.idb.set_break(filename, lineno) def clear_breakpoint_here(self, filename, lineno): self.idb.clear_break(filename, lineno) def clear_file_breaks(self, filename): self.idb.clear_all_file_breaks(filename) def load_breakpoints(self): "Load PyShellEditorWindow breakpoints into subprocess debugger" pyshell_edit_windows = self.pyshell.flist.inversedict.keys() for editwin in pyshell_edit_windows: filename = editwin.io.filename try: for lineno in editwin.breakpoints: self.set_breakpoint_here(filename, lineno) except AttributeError: continue
class GetCfgSectionNameDialog(Toplevel): def __init__(self, parent, title, message, usedNames): """ message - string, informational message to display usedNames - list, list of names already in use for validity check """ 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.message = message self.usedNames = usedNames self.result = '' self.CreateWidgets() 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)) )) ) #centre dialog over parent self.deiconify() #geometry set, unhide self.wait_window() def CreateWidgets(self): self.name = StringVar(self) self.fontSize = StringVar(self) self.frameMain = Frame(self, borderwidth=2, relief=SUNKEN) self.messageInfo = Label(self.frameMain, text=self.message) entryName = Entry(self.frameMain, textvariable=self.name, width=30) frameButtons = Frame(self) self.buttonOk = Button(frameButtons, text='Ok', command=self.Ok) self.buttonCancel = Button(frameButtons, text='Cancel', command=self.Cancel) entryName.focus_set() self.frameMain.pack(side=TOP, expand=True, fill=BOTH) self.messageInfo.pack(padx=5, pady=5) entryName.pack(padx=5, pady=5) frameButtons.pack(side=BOTTOM, fill=X) self.buttonOk.pack(padx=1, pady=5, side=RIGHT) self.buttonCancel.pack(pady=5, padx=5, side=RIGHT) if TTK: self.messageInfo['padding'] = 5 frameButtons['style'] = 'RootColor.TFrame' else: self.messageInfo.configure(padx=5, pady=5) def NameOk(self): #simple validity check for a sensible #ConfigParser file section name nameOk = 1 name = self.name.get() name.strip() if not name: #no name specified tkMessageBox.showerror(title='Name Error', message='No name specified.', parent=self) nameOk = 0 elif len(name) > 30: #name too long tkMessageBox.showerror(title='Name Error', message=('Name too long. It should be no more than ' '30 characters.'), parent=self) nameOk=0 elif name in self.usedNames: tkMessageBox.showerror(title='Name Error', message='This name is already in use.', parent=self) nameOk=0 return nameOk def Ok(self, event=None): if self.NameOk(): self.result = self.name.get().strip() self.destroy() def Cancel(self, event=None): self.result = '' self.destroy()
class Sleepy(Frame): clock = None calendar = None weather = None temperature = None def __init__(self, parent): Frame.__init__(self, parent, background=Palette.background) self.parent = parent self.pack(fill=TkC.BOTH, expand=1) # init the clock clock_font = tkFont.Font(family='Droid Sans', size=52, weight='bold') self.clock = Label(self, text="??:??", fg=Palette.primary, bg=Palette.background, font=clock_font) self.clock.place(x=0, y=0) # init the calendar calendar_font = tkFont.Font(family='Droid Sans', size=12) self.calendar = Label(self, text="?? ?????, ???", fg=Palette.secondary, bg=Palette.background, font=calendar_font) self.calendar.place(x=4, y=70) # init the weather self.weather = Weather(self, 320, 82) self.weather.place(x=0, y=(240 - 82)) # init the temperature temperature_font = tkFont.Font(family='Droid Sans', size=12) self.temperature = Label(self, text="?? °C", fg=Palette.secondary, bg=Palette.background, font=temperature_font) self.temperature.place(x=240, y=50) # print tkFont.families() # ('Century Schoolbook L', 'Droid Sans Mono', 'Droid Sans Ethiopic', 'Droid Sans Thai', 'DejaVu Sans Mono', 'URW Palladio L', 'Droid Arabic Naskh', 'URW Gothic L', 'Dingbats', 'URW Chancery L', 'FreeSerif', 'DejaVu Sans', 'Droid Sans Japanese', 'Droid Sans Georgian', 'Nimbus Sans L', 'Droid Serif', 'Droid Sans Hebrew', 'Droid Sans Fallback', 'Standard Symbols L', 'Nimbus Mono L', 'Nimbus Roman No9 L', 'FreeSans', 'DejaVu Serif', 'Droid Sans Armenian', 'FreeMono', 'URW Bookman L', 'Droid Sans') # start working self.update_clock() self.update_temperature() self.fetch_weather_thread() def update_clock(self): """ Updates the clock every ten seconds (less precision = less stuff to do) """ now = time.strftime("%H:%M") self.clock.configure(text=now) cal = time.strftime("%A, %B %d") self.calendar.configure(text=cal) self.parent.after(10000, self.update_clock) def update_temperature(self): """ Update the temperature every minute """ t = sensor.DS18B20(simulate=True) #FIXME should be set from CLI parameter temp = "%0.2f °C" % (t.read_temp()) self.temperature.configure(text=temp) self.parent.after(60*1000, self.update_temperature) def fetch_weather_thread(self): """ start a thread to fetch new weather data """ thread.start_new_thread(self.fetch_weather, ()) def fetch_weather(self): """ fetch new weather data """ apikey = "f4b0ead5b6a13da37d586a327730ae0b" # FIXME move to config location = "Berlin,de" values = { 'q': location, 'APPID': apikey, 'mode': json } try: response = urllib2.urlopen('http://api.openweathermap.org/data/2.5/forecast?' + urllib.urlencode(values)) data = response.read() weather_data = json.loads(data) self.weather.update_data(weather_data) # call again in 1 hour self.parent.after(1000 * 60 * 60, self.fetch_weather_thread) except urllib2.URLError as e: print e.reason # call again in 1 minute self.parent.after(1000 * 60 * 1, self.fetch_weather_thread)
class GUIRunner(Toplevel): #=========================================================================== # fields to set in the GUI #=========================================================================== info_text = None paddingArgs = {'padx':3, 'pady':3} def __init__(self, parent): ''' Constructor. ''' Toplevel.__init__(self, parent) self.wm_withdraw() self.resizable(height = FALSE, width = FALSE) #self.wm_deiconify() self.url = StringVar() self.login = IntVar() self.user = StringVar() self.password = StringVar() self.master = parent self.configure(borderwidth = 5) self.init_gui() def init_gui(self): ''' Initialize a simple gui. ''' top = Frame(self.master) top.grid(**self.paddingArgs) frame = Frame(top) frame.grid(column = 0, row = 0, columnspan = 2) text = Label(frame, text = 'OCCI service URL:') text.grid(column = 0, row = 0, **self.paddingArgs) self.url.set('http://localhost:8888') entry = Entry(frame, width = 25, textvariable = self.url) entry.grid(column = 1, row = 0, **self.paddingArgs) go = Button(frame, text = 'Go', command = self.run_tests) go.grid(column = 2, row = 0, **self.paddingArgs) reset = Button(frame, text = 'Reset', command = self.reset) reset.grid(column = 3, row = 0, **self.paddingArgs) login_frame = LabelFrame(top, borderwidth = 2, relief = 'groove', text = 'Session information') login_frame.grid(column = 0, row = 1, sticky = W + E + N + S, padx = 2, pady = 2) self.login.set(1) login_switch = Checkbutton(login_frame, text = 'Login required?', variable = self.login) login_switch.grid(column = 0, row = 0, columnspan = 2, **self.paddingArgs) self.user.set('foo') self.password.set('bar') user_text = Label(login_frame, text = 'Username:'******'Password:'******'groove', text = 'Service information') info_frame.grid(column = 1, row = 1, sticky = W + E + N + S, **self.paddingArgs) self.info_text = Label(info_frame, text = 'Please press "GO"') self.info_text.pack(side = 'top') test_frame = LabelFrame(top, borderwidth = 2, relief = 'groove', text = 'Tests') test_frame.grid(column = 0, row = 2, columnspan = 2, **self.paddingArgs) label = Label(test_frame, text = 'Checking for correct version information:') label.grid(column = 0, row = 0, sticky = W, **self.paddingArgs) self.version_test_label = Label(test_frame, text = '...') self.version_test_label.grid(column = 1, row = 0, sticky = W, **self.paddingArgs) label = Label(test_frame, text = 'Checking completeness of infrastructure model:') label.grid(column = 0, row = 1, sticky = W, **self.paddingArgs) self.infra_model_test_label = Label(test_frame, text = '...') self.infra_model_test_label.grid(column = 1, row = 1, sticky = W, **self.paddingArgs) label = Label(test_frame, text = 'Checking correct handling of Content-type/Accept headers:') label.grid(column = 0, row = 2, sticky = W, **self.paddingArgs) self.accept_header_test_label = Label(test_frame, text = '...') self.accept_header_test_label.grid(column = 1, row = 2, sticky = W, **self.paddingArgs) label = Label(test_frame, text = 'Testing instantiation of compute/storage/network kinds:') label.grid(column = 0, row = 3, sticky = W, **self.paddingArgs) self.creational_test_label = Label(test_frame, text = '...') self.creational_test_label.grid(column = 1, row = 3, sticky = W, **self.paddingArgs) label = Label(test_frame, text = 'Testing correct handling of user-defined mixins (tagging/grouping):') label.grid(column = 0, row = 4, sticky = W, **self.paddingArgs) self.mixin_test_label = Label(test_frame, text = '...') self.mixin_test_label.grid(column = 1, row = 4, sticky = W, **self.paddingArgs) label = Label(test_frame, text = 'Testing links between compute/storage compute/network:') label.grid(column = 0, row = 5, sticky = W, **self.paddingArgs) self.link_test_label = Label(test_frame, text = '...') self.link_test_label.grid(column = 1, row = 5, sticky = W, **self.paddingArgs) label = Label(test_frame, text = 'Triggering actions on compute/network/storage kinds:') label.grid(column = 0, row = 6, sticky = W, **self.paddingArgs) self.action_test_label = Label(test_frame, text = '...') self.action_test_label.grid(column = 1, row = 6, sticky = W, **self.paddingArgs) label = Label(test_frame, text = 'Testing filter mechanisms using Categories:') label.grid(column = 0, row = 7, sticky = W, **self.paddingArgs) self.filter_test_label = Label(test_frame, text = '...') self.filter_test_label.grid(column = 1, row = 7, sticky = W, **self.paddingArgs) label = Label(test_frame, text = 'Testing correct behaviour on location and "normal" paths:') label.grid(column = 0, row = 8, sticky = W, **self.paddingArgs) self.location_path_label = Label(test_frame, text = '...') self.location_path_label.grid(column = 1, row = 8, sticky = W, **self.paddingArgs) label = Label(test_frame, text = 'Simple syntax checks:') label.grid(column = 0, row = 9, sticky = W, **self.paddingArgs) self.syntax_test_label = Label(test_frame, text = '...') self.syntax_test_label.grid(column = 1, row = 9, sticky = W, **self.paddingArgs) label = Label(top, text = 'NOTE: Passing all tests only indicates that the service\nyou are testing is OCCI compliant - IT DOES NOT GUARANTE IT!') label.grid(column = 0, row = 4, columnspan = 2, **self.paddingArgs) quit_button = Button(top, text = 'Quit', command = self.quit) quit_button.grid(column = 1, row = 5, sticky = E, **self.paddingArgs) def run_tests(self): ''' run a set of tests. ''' url = self.url.get() if self.login.get() is 1: cookie = test_occi.get_session_cookie(self.url.get(), self.user.get(), self.password.get()) heads = {'Cookie': cookie} else: heads = {} # display basic information self.info_text.configure(text = 'Server version:\n' + test_occi.get_version(url, heads) + '\nNumber of registered categories:\n' + str(len(test_occi.get_categories(url, heads))), anchor = W, justify = LEFT) # run the tests... self.run_single_test(test_occi.test_version_information, url, heads, self.version_test_label) self.run_single_test(test_occi.test_infrastructure_model_for_completness, url, heads, self.infra_model_test_label) self.run_single_test(test_occi.test_accept_header, url, heads, self.accept_header_test_label) self.run_single_test(test_occi.test_create_kinds, url, heads, self.creational_test_label) self.run_single_test(test_occi.test_mixins, url, heads, self.mixin_test_label) self.run_single_test(test_occi.test_links, url, heads, self.link_test_label) self.run_single_test(test_occi.test_actions, url, heads, self.action_test_label) self.run_single_test(test_occi.test_filter, url, heads, self.filter_test_label) self.run_single_test(test_occi.test_location, url, heads, self.location_path_label) self.run_single_test(test_occi.test_syntax, url, heads, self.syntax_test_label) def run_single_test(self, test, url, heads, label): ''' Run a single test and display the outcome. ''' try: test(url, heads) except Exception as ae: logging.warn(str(ae)) label.configure(text = 'Failed', background = 'red') else: label.configure(text = 'OK') def reset(self): ''' Reset the gui... ''' self.info_text.configure(text = 'Please press "GO"') self.version_test_label.configure(text = '...') self.infra_model_test_label.configure(text = '...') self.accept_header_test_label.configure(text = '...') self.creational_test_label.configure(text = '...') self.mixin_test_label.configure(text = '...') self.link_test_label.configure(text = '...') self.action_test_label.configure(text = '...') self.filter_test_label.configure(text = '...') self.location_path_label.configure(text = '...') self.syntax_test_label.configure(text = '...') def quit(self): ''' Quit the master loop. ''' self.master.quit()
class Game: def __init__(self): self.root = Tk() self.frame1 = None self.frame2 = None self.w = None self.scoreC = None self.score = 0 self.hor = True self.upid = self.downid = self.rightid = self.leftid = 0 self.head = -1 self.time = 700 def home(self): self.frame1 = Frame(self.root, width=750, height=350, padx=250, bg="black") self.frame2 = Frame(self.root, height=250, width=750, bg="black", padx=25) self.root.wm_minsize(width=750, height=666) self.root.configure(bg="black") self.frame1.pack_propagate(0) self.frame1.update() self.frame1.configure(pady=self.frame1.cget("height") / 2.5) logo = PhotoImage(file="Game_Logo.gif") starth = Button(self.frame1, text="Hard", bg="orange", padx=25, pady=5, font=Font(family="comic sans MS", size=10), command=lambda: self.callgame(40)) startm = Button(self.frame1, text="Medium", bg="teal", padx=25, pady=5, font=Font(family="comic sans MS", size=10), command=lambda: self.callgame(60)) starte = Button(self.frame1, text="Easy", bg="orange", padx=25, pady=5, font=Font(family="comic sans MS", size=10), command=lambda: self.callgame(75)) self.frame2.pack_propagate(0) exp = """ This is a game in which the arrow keys are used to move the snake around and to get points""" exf = Font(family="comic sans MS", size=20) Label(self.frame2, image=logo, bg="black", text=exp, padx=10).pack(side="right") Label(self.frame2, fg="white", bg="black", text=exp, justify="left", font=exf).pack(side="left") starte.grid(row=0, columnspan=2) startm.grid(row=0, columnspan=2, column=4, padx=18) starth.grid(row=0, columnspan=2, column=8) head = Font(family="comic sans MS", size=30) self.H=Label(self.root, text="SNAKES", font=head, fg="orange", bg="black", pady=10) self.H.pack() self.frame2.pack(expand=True) self.frame1.pack(expand=True) self.root.mainloop() def callgame(self, time): self.time = time self.game() def calldown(self, key): if self.hor: self.w.after_cancel(self.leftid) self.w.after_cancel(self.rightid) self.down(0) def callup(self, key): if self.hor: self.w.after_cancel(self.leftid) self.w.after_cancel(self.rightid) self.up(0) def callright(self, key): if not self.hor: self.w.after_cancel(self.upid) self.w.after_cancel(self.downid) self.right(0) def callleft(self, key): if not self.hor: self.w.after_cancel(self.upid) self.w.after_cancel(self.downid) self.left(0) def game(self): self.score = 0 self.w = Canvas(self.root, width=750, height=500, relief="flat", highlightbackground="grey", highlightthickness=10) self.frame1.destroy() self.frame2.destroy() self.root.configure(width=1000, padx=10) self.root.pack_propagate(0) self.w.configure(background="black") self.w.pack(side="left") self.w.create_line(300, 250, 450, 250, width=10, fill="teal") self.scoreC = Label(self.root, text="Score\n" + str(self.score), bg="black", fg="teal", padx=25, pady=35, font=Font(family="comic sans MS", size=25)) self.head = self.w.create_line(450, 250, 455, 250, width=10, fill="white") self.scoreC.pack(side="top") self.root.bind("<Up>", self.callup) self.root.bind("<Down>", self.calldown) self.root.bind("<Right>", self.callright) self.root.bind("<Left>", self.callleft) self.createFood() self.right(0) def down(self, i): crd = self.w.coords(1) if len(crd) > 0: if crd[0] == crd[2]: if crd[1] > crd[3]: # print("inside if1") crd[1] -= 10 if crd[1] < crd[3]: # print("inside if2") crd[1] += 10 else: if crd[0] > crd[2]: crd[0] -= 10 if crd[0] < crd[2]: crd[0] += 10 crd[-1] += 10 if i == 0: crd.append(crd[-2]) crd.append(crd[-2]) crd[-3] -= 10 if crd[0] == crd[2] and crd[1] == crd[3]: crd = crd[2:] self.w.coords(1, *crd) self.w.delete(self.head) self.head = self.w.create_line(crd[-2], crd[-1], crd[-2], crd[-1] + 5, width=10, fill="orange") end = self.end() self.checkEaten() i += 1 self.hor = False if not end: self.downid = self.w.after(self.time, self.down, i) else: self.w.delete(1) self.w.delete(self.head) self.w.delete(self.food) self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25, font=Font(family="comic sans MS", size=15), command=lambda: self.callhome()) self.start.pack(side="bottom") def up(self, i): crd = self.w.coords(1) if len(crd)>0: if crd[0] == crd[2]: if crd[1] > crd[3]: # print("inside if1") crd[1] -= 10 if crd[1] < crd[3]: # print("inside if2") crd[1] += 10 else: if crd[0] > crd[2]: crd[0] -= 10 if crd[0] < crd[2]: crd[0] += 10 crd[-1] -= 10 if i == 0: crd.append(crd[-2]) crd.append(crd[-2]) crd[-3] += 10 if crd[0] == crd[2] and crd[1] == crd[3]: crd = crd[2:] self.w.coords(1, *crd) self.w.delete(self.head) self.head = self.w.create_line(crd[-2], crd[-1], crd[-2], crd[-1] - 5, width=10, fill="orange") end = self.end() self.checkEaten() i += 1 self.hor = False if not end: self.upid = self.w.after(self.time, self.up, i) else: self.w.delete(1) self.w.delete(self.head) self.w.delete(self.food) self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25, font=Font(family="comic sans MS", size=15), command=lambda: self.callhome()) self.start.pack(side="bottom") def right(self, i): crd = self.w.coords(1) if len(crd) > 0: if crd[0] == crd[2]: if crd[1] > crd[3]: # print("inside if1") crd[1] -= 10 if crd[1] < crd[3]: # print("inside if2") crd[1] += 10 else: if crd[0] > crd[2]: crd[0] -= 10 if crd[0] < crd[2]: crd[0] += 10 crd[-2] += 10 if i == 0: crd.append(crd[-2]) crd.append(crd[-2]) crd[-4] -= 10 if crd[0] == crd[2] and crd[1] == crd[3]: crd = crd[2:] self.w.coords(1, *crd) self.w.delete(self.head) self.head = self.w.create_line(crd[-2], crd[-1], crd[-2] + 5, crd[-1], width=10, fill="orange") end = self.end() self.checkEaten() i += 1 self.hor = True if not end: self.rightid = self.w.after(self.time, self.right, i) else: self.w.delete(1) self.w.delete(self.head) self.w.delete(self.food) self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25, font=Font(family="comic sans MS", size=15), command=lambda: self.callhome()) self.start.pack(side="bottom") def left(self, i): crd = self.w.coords(1) if len(crd) > 0: if crd[0] == crd[2]: if crd[1] > crd[3]: # print("inside if1") crd[1] -= 10 if crd[1] < crd[3]: # print("inside if2") crd[1] += 10 else: if crd[0] > crd[2]: crd[0] -= 10 if crd[0] < crd[2]: crd[0] += 10 crd[-2] -= 10 if i == 0: crd.append(crd[-2]) crd.append(crd[-2]) crd[-4] += 10 if crd[0] == crd[2] and crd[1] == crd[3]: crd = crd[2:] self.w.coords(1, *crd) self.w.delete(self.head) self.head = self.w.create_line(crd[-2], crd[-1], crd[-2] - 5, crd[-1], width=10, fill="orange") end = self.end() self.checkEaten() i += 1 self.hor = True if not end: self.leftid = self.w.after(self.time, self.left, i) else: self.w.delete(1) self.w.delete(self.head) self.w.delete(self.food) self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25, font=Font(family="comic sans MS", size=15), command=lambda: self.callhome()) self.start.pack(side="bottom") def createFood(self): # self.w.delete(self.food) #deleting old food. crd = self.w.coords(1) ext = [] for i in crd: ext.append(i) for j in range(-50, 50): ext.append(i + j) randx = random.randrange(20, 730) randy = random.randrange(20, 480) while randx not in ext and randy not in ext: randx = random.randrange(20, 730) randy = random.randrange(20, 480) self.food = self.w.create_line(randx, randy, randx + 12, randy, width=10, fill="yellow") def checkEaten(self): headcoords = self.w.coords(self.head) foodcoords = self.w.coords(self.food) # self.w.delete(self.food) flag = False # print(headcoords[-4]) # print(foodcoords[-4]) # print(foodcoords[-2]) if int(headcoords[-4]) in range(int(foodcoords[-4]) - 7, int(foodcoords[-2]) + 7) and int( headcoords[-3]) in range(int(foodcoords[-1]) - 10, int(foodcoords[-1] + 10)): flag = True if flag: self.grow() self.score += 10 self.scoreC.configure(text="Score\n" + str(self.score), bg="black", fg="teal", padx=25, pady=35, font=Font(family="comic sans MS", size=25)) self.w.delete(self.food) self.createFood() def grow(self): crd = self.w.coords(1) if crd[0] != crd[2]: # horizontal condition if crd[0] < crd[2]: crd[0] -= 20 else: crd[0] += 20 self.w.coords(1, *crd) else: if crd[3] < crd[1]: crd[1] += 20 else: crd[1] -= 20 self.w.coords(1, *crd) def end(self): crd = self.w.coords(1) h = self.w.coords(self.head) a = 0 while a < len(crd) - 2: if crd[a] == crd[a + 2]: if (h[0] == crd[a] and crd[a + 1] < h[1] < crd[a + 3]) or ( h[0] == crd[a] and crd[a + 1] > h[1] > crd[a + 3]): return True else: if (h[1] == crd[a + 1] and crd[a] < h[0] < crd[a + 2]) or (h[1] == crd[a + 1] and crd[a] > h[0] > crd[a + 2]): return True a += 2 if (h[0] == 0 and 0 < h[1] < 500) or (h[1] == 0 and 0 < h[0] < 750) or (h[1] == 510 and 0 < h[0] < 750) or (h[0] == 760 and 0<h[1]<500): return True return False def callhome(self): self.w.destroy() self.start.destroy() self.H.destroy() self.scoreC.destroy() self.home()
class path_planner_gui(StoppableThread): DEFAULT_START_LAT = 55.434352 #55.43526 #55.431122 DEFAULT_START_LON = 10.415182 #10.41086 #10.420436 DEFAULT_GOAL_LAT = 55.42474 #55.427203 DEFAULT_GOAL_LON = 10.41975 #10.419043 # for testing altitude - points near Hindsgavl, Middelfart # start_point_3dDICT = {'lat': 55.505618, 'lon': 9.681612, 'alt_rel': 0} # goal_point_3dDICT = {'lat': 55.518093, 'lon': 9.699519, 'alt_rel': 0} # goal inside geofence: 55.429331, 10.422770 DEFAULT_STEP_SIZE_HORZ_ASTAR = 100 DEFAULT_STEP_SIZE_VERT_ASTAR = 10 DEFAULT_STEP_SIZE_HORZ_RRT = 50 DEFAULT_STEP_SIZE_VERT_RRT = 10 DEFAULT_SEARCH_TIME_MAX = 120 # unit: s DEFAULT_ITERATIONS_MAX = 3000 DEFAULT_TIME_STEP = 1.0 # unit: s DEFAULT_ACCELERATION_FACTOR = 10.0 # unitless DEFAULT_STEP_SIZE_HORZ_LOCAL_ASTAR = 50 DEFAULT_STEP_SIZE_VERT_LOCAL_ASTAR = 5 DEFAULT_SEARCH_TIME_MAX_LOCAL = 180 # unit: s DEFAULT_STEP_SIZE_HORZ_LOCAL_RRT = 25 DEFAULT_STEP_SIZE_VERT_LOCAL_RRT = 5 DEFAULT_ITERATIONS_MAX_LOCAL = 3000 # unit: s INITIAL_PLANNER = 1 def __init__(self, parent_class, auto_start=False): # self.__class__ = type(self.__class__.__name__, (base_class, object), dict(self.__class__.__dict__)) # super(self.__class__, self).__init__() self.parent_class = parent_class StoppableThread.__init__(self) self.q = Queue() self.logger = logging.getLogger(__name__) if auto_start: self.start() def stop_thread(self): self.callback_close() self.stop() def callback_close(self): self.root.quit() self.logger.info( 'Tkinter GUI has stopped but thread will first be joined upon closing of the program' ) def on_main_thread(self, func): self.q.put(func) def check_queue(self): while True: try: task = self.q.get(block=False) except Empty: break else: self.root.after_idle(task) self.root.after(100, self.check_queue) def set_label_no_fly_zones(self, txt, color='black'): self.label_data_source_no_fly_zones_res.configure(text=txt) self.label_data_source_no_fly_zones_res.configure(fg=color) def set_label_height_map(self, txt, color='black'): self.label_data_source_height_map_res.configure(text=txt) self.label_data_source_height_map_res.configure(fg=color) def set_label_drone_id(self, txt, color='black'): self.label_data_source_droneID_res.configure(text=txt) self.label_data_source_droneID_res.configure(fg=color) def set_label_adsb(self, txt, color='black'): self.label_data_source_adsb_res.configure(text=txt) self.label_data_source_adsb_res.configure(fg=color) def set_label_weather(self, txt, color='black'): self.label_data_source_weather_res.configure(text=txt) self.label_data_source_weather_res.configure(fg=color) def set_label_rally_points(self, txt, color='black'): self.label_data_rally_point_res.configure(text=txt) self.label_data_rally_point_res.configure(fg=color) def set_global_plan_start_heuristic(self, val, color='black'): self.label_global_plan_start_heuristic_res.configure(text='%.02f' % val) self.label_global_plan_start_heuristic_res.configure(fg=color) def set_global_plan_cur_heuristic(self, val, color='black'): self.label_global_plan_cur_heuristic_res.configure(text='%.02f' % val) self.label_global_plan_cur_heuristic_res.configure(fg=color) def set_global_plan_horz_step_size(self, val, color='black'): self.label_global_plan_horz_step_size_res.configure(text='%.01f [m]' % val) self.label_global_plan_horz_step_size_res.configure(fg=color) def set_global_plan_vert_step_size(self, val, color='black'): self.label_global_plan_vert_step_size_res.configure(text='%.01f [m]' % val) self.label_global_plan_vert_step_size_res.configure(fg=color) def set_global_plan_status(self, txt, color='black'): self.label_global_plan_status_res.configure(text=txt) self.label_global_plan_status_res.configure(fg=color) def set_global_plan_search_time(self, val, color='black'): self.label_global_plan_search_time_res.configure(text='%.01f [s]' % val) self.label_global_plan_search_time_res.configure(fg=color) def set_global_plan_nodes_visited(self, val, color='black'): self.label_global_plan_nodes_visited_res.configure(text='%i' % val) self.label_global_plan_nodes_visited_res.configure(fg=color) def set_global_plan_nodes_explored(self, val, color='black'): self.label_global_plan_nodes_explored_res.configure(text='%i' % val) self.label_global_plan_nodes_explored_res.configure(fg=color) def set_label_gpe_fitness(self, val, color='black'): self.label_gpe_fitness_res.configure(text='%f' % val) self.label_gpe_fitness_res.configure(fg=color) def set_label_gpe_dist_tot(self, val, color='black'): self.label_gpe_dist_tot_res.configure(text='%.02f [m]' % val) self.label_gpe_dist_tot_res.configure(fg=color) def set_label_gpe_dist_horz(self, val, color='black'): self.label_gpe_dist_horz_res.configure(text='%.02f [m]' % val) self.label_gpe_dist_horz_res.configure(fg=color) def set_label_gpe_dist_vert(self, val, color='black'): self.label_gpe_dist_vert_res.configure(text='%.02f [m]' % val) self.label_gpe_dist_vert_res.configure(fg=color) def set_label_gpe_eta(self, val, color='black'): self.label_gpe_eta_res.configure(text='%.02f [s]' % val) self.label_gpe_eta_res.configure(fg=color) def set_label_gpe_wps(self, val, color='black'): self.label_gpe_wps_res.configure(text='%i' % val) self.label_gpe_wps_res.configure(fg=color) def set_label_gpe_runtime(self, val, color='black'): self.label_gpe_runtime_res.configure(text='%.02f [s]' % val) self.label_gpe_runtime_res.configure(fg=color) def set_label_gpe_bytes_tot(self, val, color='black'): self.label_gpe_bytes_tot_res.configure(text='%i' % val) self.label_gpe_bytes_tot_res.configure(fg=color) def set_label_gpe_objects_tot(self, val, color='black'): self.label_gpe_objects_tot_res.configure(text='%i' % val) self.label_gpe_objects_tot_res.configure(fg=color) def set_label_gpe_bytes_planner(self, val, color='black'): self.label_gpe_bytes_planner_res.configure(text='%i' % val) self.label_gpe_bytes_planner_res.configure(fg=color) def set_label_gpe_objects_planner(self, val, color='black'): self.label_gpe_objects_planner_res.configure(text='%i' % val) self.label_gpe_objects_planner_res.configure(fg=color) def set_scrolledtext_global_path(self, txt): self.scrolledtext_global_path.delete(1.0, END) self.scrolledtext_global_path.insert(INSERT, txt) def set_scrolledtext_local_path(self, txt): self.scrolledtext_local_path.delete(1.0, END) self.scrolledtext_local_path.insert(INSERT, txt) def enable_button_global_plan(self): self.button_global_plan.configure(state='normal') def diable_button_global_plan(self): self.button_global_plan.configure(state='disabled') def set_label_local_plan_status(self, txt, color='black'): self.label_local_plan_status_res.configure(text=txt) self.label_local_plan_status_res.configure(fg=color) def set_label_local_plan_time(self, val, color='black'): self.label_local_plan_time_res.configure(text='%.02f [s]' % val) self.label_local_plan_time_res.configure(fg=color) def set_label_local_uav_y(self, val, color='black'): self.label_local_uav_y_res.configure(text='%.01f [m]' % val) self.label_local_uav_y_res.configure(fg=color) def set_label_local_uav_x(self, val, color='black'): self.label_local_uav_x_res.configure(text='%.01f [m]' % val) self.label_local_uav_x_res.configure(fg=color) def set_label_local_uav_z_rel(self, val, color='black'): self.label_local_uav_z_rel_res.configure(text='%.01f [m]' % val) self.label_local_uav_z_rel_res.configure(fg=color) def set_label_local_uav_status(self, txt, color='black'): self.label_local_uav_status_res.configure(text=txt) self.label_local_uav_status_res.configure(fg=color) def global_planner_thread(self, point_start, point_goal, path_planner, step_size_horz, step_size_vert, search_time_max): if self.parent_class.plan_path_global( point_start, point_goal, path_planner, step_size_horz=step_size_horz, step_size_vert=step_size_vert, search_time_max=search_time_max ): # Plan path and test the result to update the GUI self.button_local_plan.configure(state='normal') self.button_global_plan.configure(state='normal') self.button_gen_global_sim_files.configure(state='normal') self.button_global_plan.configure(text='Start global planning') self.button_show_result_webpage_global.configure(state='normal') self.button_evaluate_path.configure(state='normal') self.button_web_visualize_global.configure(state='normal') else: # The global path planner failed and therefore diable the local path planner and change the option to continue self.button_local_plan.configure(state='disabled') self.button_global_plan.configure(state='normal') self.button_gen_global_sim_files.configure(state='disabled') self.button_show_result_webpage_global.configure(state='disabled') path_planner = str(self.combo_planner_type.get()) if path_planner == self.parent_class.PATH_PLANNER_NAMES[0]: self.button_global_plan.configure( text='Continue global planning') elif path_planner == self.parent_class.PATH_PLANNER_NAMES[1]: self.button_global_plan.configure(text='Retry global planning') self.button_evaluate_path.configure(state='disabled') self.button_web_visualize_global.configure(state='disabled') def start_global_path_planning(self): self.button_global_plan.configure(state='disabled') self.button_gen_global_sim_files.configure(state='disabled') self.button_local_plan.configure(state='disabled') self.button_show_result_webpage_global.configure(state='disabled') self.button_evaluate_path.configure(state='disabled') self.button_web_visualize_global.configure(state='disabled') # Get data from the GUI path_planner = self.combo_planner_type.get() start_point_3dDICT = { 'lat': float(self.input_start_point_lat.get()), 'lon': float(self.input_start_point_lon.get()), 'alt_rel': 0 } goal_point_3dDICT = { 'lat': float(self.input_goal_point_lat.get()), 'lon': float(self.input_goal_point_lon.get()), 'alt_rel': 0 } step_size_horz = float(self.input_step_size_horz.get()) step_size_vert = float(self.input_step_size_vert.get()) search_time_max = float(self.input_search_time_max.get()) # Create and start the thread thread_global_planning = threading.Thread( target=self.global_planner_thread, args=(start_point_3dDICT, goal_point_3dDICT, path_planner, step_size_horz, step_size_vert, search_time_max)) thread_global_planning.start() #thread_global_planning.join() def local_planner_thread(self, path_planner, step_size_horz, step_size_vert, max_search_time, time_step, acceleration_factor): self.parent_class.plan_path_local( path_planner=path_planner, step_size_horz=step_size_horz, step_size_vert=step_size_vert, max_search_time=max_search_time, time_step=time_step, acceleration_factor=acceleration_factor) self.button_global_plan.configure(state='normal') self.button_gen_global_sim_files.configure(state='normal') self.button_local_plan.configure(state='normal') self.button_web_visualize_local.configure(state='normal') self.button_show_result_webpage_local.configure(state='normal') self.button_gen_local_sim_files.configure(state='normal') def start_local_path_planning(self): self.button_global_plan.configure(state='disabled') self.button_gen_global_sim_files.configure(state='disabled') self.button_local_plan.configure(state='disabled') self.button_web_visualize_local.configure(state='disabled') self.button_show_result_webpage_local.configure(state='disabled') self.button_gen_local_sim_files.configure(state='disabled') # Get data from the GUI path_planner = str(self.combo_planner_type.get()) time_step = float(self.input_time_step.get()) acceleration_factor = float(self.input_acceleration_factor.get()) step_size_horz = float(self.input_replan_step_size_horz.get()) step_size_vert = float(self.input_replan_step_size_vert.get()) search_time_max = float(self.input_replan_search_time_max.get()) # Create and start the thread thread_local_planning = threading.Thread( target=self.local_planner_thread, args=(path_planner, step_size_horz, step_size_vert, search_time_max, time_step, acceleration_factor)) thread_local_planning.start() def show_result_webpage_global_thread(self): self.parent_class.draw_planned_path_global() self.parent_class.map_plotter_global.show_plot() def show_result_webpage_global(self): show_result_webpage_global = threading.Thread( target=self.show_result_webpage_global_thread) show_result_webpage_global.start() def gen_global_sim_files_thread(self): self.parent_class.generate_simulation_files_global() def gen_global_sim_files(self): gen_global_sim = threading.Thread( target=self.gen_global_sim_files_thread) gen_global_sim.start() def gen_local_sim_files_thread(self): self.parent_class.generate_simulation_files_local() def gen_local_sim_files(self): gen_local_sim = threading.Thread( target=self.gen_local_sim_files_thread) gen_local_sim.start() def show_result_webpage_local_thread(self): self.parent_class.draw_planned_path_local() self.parent_class.map_plotter_local.show_plot() def show_result_webpage_local(self): show_result_webpage_local = threading.Thread( target=self.show_result_webpage_local_thread) show_result_webpage_local.start() def show_web_visualize_global(self): route_id = self.parent_class.visualize_path_3d_global() if not None: url = 'http://uas.heltner.net/routes/' + str(route_id) + '/3d' webbrowser.open_new(url) def show_web_visualize_local(self): route_id = self.parent_class.visualize_path_3d_local() if not None: url = 'http://uas.heltner.net/routes/' + str(route_id) + '/3d' webbrowser.open_new(url) def path_evaluation_thread(self): self.parent_class.evaluate_path() def start_evaluation(self): # Create and start the thread thread_evaluate_path = threading.Thread( target=self.path_evaluation_thread) thread_evaluate_path.start() def change_planner(self, event=None): path_planner = str(self.combo_planner_type.get()) if path_planner == self.parent_class.PATH_PLANNER_NAMES[0]: self.input_step_size_horz.delete(0, END) self.input_step_size_horz.insert(0, self.DEFAULT_STEP_SIZE_HORZ_ASTAR) self.input_step_size_vert.delete(0, END) self.input_step_size_vert.insert(0, self.DEFAULT_STEP_SIZE_VERT_ASTAR) self.label_search_time_max.configure(text='Max search time [s]:') self.input_search_time_max.delete(0, END) self.input_search_time_max.insert(0, self.DEFAULT_SEARCH_TIME_MAX) self.input_replan_step_size_horz.delete(0, END) self.input_replan_step_size_horz.insert( 0, self.DEFAULT_STEP_SIZE_HORZ_LOCAL_ASTAR) self.input_replan_step_size_vert.delete(0, END) self.input_replan_step_size_vert.insert( 0, self.DEFAULT_STEP_SIZE_VERT_LOCAL_ASTAR) self.label_replan_search_time_max.configure( text='Replan max search time [s]:') self.input_replan_search_time_max.delete(0, END) self.input_replan_search_time_max.insert( 0, self.DEFAULT_SEARCH_TIME_MAX_LOCAL) elif path_planner == self.parent_class.PATH_PLANNER_NAMES[1]: self.input_step_size_horz.delete(0, END) self.input_step_size_horz.insert(0, self.DEFAULT_STEP_SIZE_HORZ_RRT) self.input_step_size_vert.delete(0, END) self.input_step_size_vert.insert(0, self.DEFAULT_STEP_SIZE_VERT_RRT) self.label_search_time_max.configure(text='Max iterations:') self.input_search_time_max.delete(0, END) self.input_search_time_max.insert(0, self.DEFAULT_ITERATIONS_MAX) self.input_replan_step_size_horz.delete(0, END) self.input_replan_step_size_horz.insert( 0, self.DEFAULT_STEP_SIZE_HORZ_LOCAL_RRT) self.input_replan_step_size_vert.delete(0, END) self.input_replan_step_size_vert.insert( 0, self.DEFAULT_STEP_SIZE_VERT_LOCAL_RRT) self.label_replan_search_time_max.configure( text='Replan max iterations:') self.input_replan_search_time_max.delete(0, END) self.input_replan_search_time_max.insert( 0, self.DEFAULT_ITERATIONS_MAX_LOCAL) def run(self): self.root = Tk() self.root.protocol("WM_DELETE_WINDOW", self.callback_close) self.root.title("UAV Path Planner") #self.root.geometry('{}x{}'.format(460, 350)) """ Left side layout """ row_num_left = 0 self.label_start_point = Label(self.root, text="Path Planning", font=("Arial Bold", 12)) self.label_start_point.grid(row=row_num_left, column=0, columnspan=2) row_num_left += 1 self.label_planner_type = Label(self.root, text="Type:") self.label_planner_type.grid(row=row_num_left, column=0) self.combo_planner_type = Combobox(self.root) self.combo_planner_type[ 'values'] = self.parent_class.PATH_PLANNER_NAMES if self.INITIAL_PLANNER == 0: self.combo_planner_type.current(0) elif self.INITIAL_PLANNER == 1: self.combo_planner_type.current(1) self.combo_planner_type.bind('<<ComboboxSelected>>', self.change_planner) self.combo_planner_type.grid(row=row_num_left, column=1) row_num_left += 1 self.label_start_point = Label(self.root, text="Start point (geodetic)", font=("Arial Bold", 10)) self.label_start_point.grid(row=row_num_left, column=0, columnspan=2) row_num_left += 1 self.label_start_point_lat = Label(self.root, text="Latitude [dd]:") self.label_start_point_lat.grid(row=row_num_left, column=0) self.input_start_point_lat = Entry(self.root, width=10) self.input_start_point_lat.insert(0, self.DEFAULT_START_LAT) self.input_start_point_lat.grid(row=row_num_left, column=1) row_num_left += 1 self.label_start_point_lon = Label(self.root, text="Longitude [dd]:") self.label_start_point_lon.grid(row=row_num_left, column=0) self.input_start_point_lon = Entry(self.root, width=10) self.input_start_point_lon.insert(0, self.DEFAULT_START_LON) self.input_start_point_lon.grid(row=row_num_left, column=1) row_num_left += 1 self.label_goal_point = Label(self.root, text="Goal point (geodetic)", font=("Arial Bold", 10)) self.label_goal_point.grid(row=row_num_left, column=0, columnspan=2) row_num_left += 1 self.label_goal_point_lat = Label(self.root, text="Latitude [dd]:") self.label_goal_point_lat.grid(row=row_num_left, column=0) self.input_goal_point_lat = Entry(self.root, width=10) self.input_goal_point_lat.insert(0, self.DEFAULT_GOAL_LAT) self.input_goal_point_lat.grid(row=row_num_left, column=1) row_num_left += 1 self.label_goal_point_lon = Label(self.root, text="Longitude [dd]:") self.label_goal_point_lon.grid(row=row_num_left, column=0) self.input_goal_point_lon = Entry(self.root, width=10) self.input_goal_point_lon.insert(0, self.DEFAULT_GOAL_LON) self.input_goal_point_lon.grid(row=row_num_left, column=1) row_num_left += 1 self.label_options = Label(self.root, text="Options global path planner", font=("Arial Bold", 10)) self.label_options.grid(row=row_num_left, column=0, columnspan=2) row_num_left += 1 self.label_step_size_horz = Label(self.root, text="Horizontal step-size [m]:") self.label_step_size_horz.grid(row=row_num_left, column=0) self.input_step_size_horz = Entry(self.root, width=10) if self.INITIAL_PLANNER == 0: self.input_step_size_horz.insert(0, self.DEFAULT_STEP_SIZE_HORZ_ASTAR) elif self.INITIAL_PLANNER == 1: self.input_step_size_horz.insert(0, self.DEFAULT_STEP_SIZE_HORZ_RRT) self.input_step_size_horz.grid(row=row_num_left, column=1) row_num_left += 1 self.label_step_size_vert = Label(self.root, text="Vertical step-size [m]:") self.label_step_size_vert.grid(row=row_num_left, column=0) self.input_step_size_vert = Entry(self.root, width=10) if self.INITIAL_PLANNER == 0: self.input_step_size_vert.insert(0, self.DEFAULT_STEP_SIZE_VERT_ASTAR) elif self.INITIAL_PLANNER == 1: self.input_step_size_vert.insert(0, self.DEFAULT_STEP_SIZE_VERT_RRT) self.input_step_size_vert.grid(row=row_num_left, column=1) row_num_left += 1 self.label_search_time_max = Label(self.root, text="") if self.INITIAL_PLANNER == 0: self.label_search_time_max.configure(text='Max search time [s]:') elif self.INITIAL_PLANNER == 1: self.label_search_time_max.configure(text='Max iterations:') self.label_search_time_max.grid(row=row_num_left, column=0) self.input_search_time_max = Entry(self.root, width=10) if self.INITIAL_PLANNER == 0: self.input_search_time_max.insert(0, self.DEFAULT_SEARCH_TIME_MAX) elif self.INITIAL_PLANNER == 1: self.input_search_time_max.insert(0, self.DEFAULT_ITERATIONS_MAX) self.input_search_time_max.grid(row=row_num_left, column=1) row_num_left += 1 self.button_global_plan = Button( self.root, text="Start global planning", command=self.start_global_path_planning) self.button_global_plan.configure(state='disabled') self.button_global_plan.grid(row=row_num_left, column=0, columnspan=2) row_num_left += 1 self.label_options_local = Label(self.root, text="Options local path planner", font=("Arial Bold", 10)) self.label_options_local.grid(row=row_num_left, column=0, columnspan=2) row_num_left += 1 self.label_time_step = Label(self.root, text="Time step [s]:") self.label_time_step.grid(row=row_num_left, column=0) self.input_time_step = Entry(self.root, width=10) self.input_time_step.insert(0, self.DEFAULT_TIME_STEP) self.input_time_step.grid(row=row_num_left, column=1) row_num_left += 1 self.label_acceleration_factor = Label(self.root, text="Playback speed:") self.label_acceleration_factor.grid(row=row_num_left, column=0) self.input_acceleration_factor = Entry(self.root, width=10) self.input_acceleration_factor.insert(0, self.DEFAULT_ACCELERATION_FACTOR) self.input_acceleration_factor.grid(row=row_num_left, column=1) row_num_left += 1 self.label_replan_step_size_horz = Label( self.root, text="Replan horizontal step-size [m]:") self.label_replan_step_size_horz.grid(row=row_num_left, column=0) self.input_replan_step_size_horz = Entry(self.root, width=10) if self.INITIAL_PLANNER == 0: self.input_replan_step_size_horz.insert( 0, self.DEFAULT_STEP_SIZE_HORZ_LOCAL_ASTAR) elif self.INITIAL_PLANNER == 1: self.input_replan_step_size_horz.insert( 0, self.DEFAULT_STEP_SIZE_HORZ_LOCAL_RRT) self.input_replan_step_size_horz.grid(row=row_num_left, column=1) row_num_left += 1 self.label_replan_step_size_vert = Label( self.root, text="Replan vertical step-size [m]:") self.label_replan_step_size_vert.grid(row=row_num_left, column=0) self.input_replan_step_size_vert = Entry(self.root, width=10) if self.INITIAL_PLANNER == 0: self.input_replan_step_size_vert.insert( 0, self.DEFAULT_STEP_SIZE_VERT_LOCAL_ASTAR) elif self.INITIAL_PLANNER == 1: self.input_replan_step_size_vert.insert( 0, self.DEFAULT_STEP_SIZE_VERT_LOCAL_RRT) self.input_replan_step_size_vert.grid(row=row_num_left, column=1) row_num_left += 1 self.label_replan_search_time_max = Label( self.root, text="Replan max search time [s]:") if self.INITIAL_PLANNER == 0: self.label_replan_search_time_max.configure( text='Replan max search time [s]:') elif self.INITIAL_PLANNER == 1: self.label_replan_search_time_max.configure( text='Replan max iterations:') self.label_replan_search_time_max.grid(row=row_num_left, column=0) self.input_replan_search_time_max = Entry(self.root, width=10) if self.INITIAL_PLANNER == 0: self.input_replan_search_time_max.insert( 0, self.DEFAULT_SEARCH_TIME_MAX_LOCAL) elif self.INITIAL_PLANNER == 1: self.input_replan_search_time_max.insert( 0, self.DEFAULT_ITERATIONS_MAX_LOCAL) self.input_replan_search_time_max.grid(row=row_num_left, column=1) row_num_left += 1 self.button_local_plan = Button(self.root, text="Start local planning", command=self.start_local_path_planning) self.button_local_plan.configure( state='disabled' ) # disable the button since it cannot make a local plan before it has made a global plan self.button_local_plan.grid(row=row_num_left, column=0, columnspan=2) row_num_left += 1 self.label_sim_info = Label(self.root, text="Simulation information", font=("Arial Bold", 12)) self.label_sim_info.grid(row=row_num_left, column=0, columnspan=2) row_num_left += 1 self.label_local_plan_status = Label(self.root, text="Status:") self.label_local_plan_status.grid(row=row_num_left, column=0) self.label_local_plan_status_res = Label(self.root, text="idle") self.label_local_plan_status_res.configure(fg='green') self.label_local_plan_status_res.grid(row=row_num_left, column=1) row_num_left += 1 self.label_local_plan_time = Label(self.root, text="Time:") self.label_local_plan_time.grid(row=row_num_left, column=0) self.label_local_plan_time_res = Label(self.root, text="N/A") self.label_local_plan_time_res.grid(row=row_num_left, column=1) row_num_left += 1 self.label_local_uav_y = Label(self.root, text="UAV y:") self.label_local_uav_y.grid(row=row_num_left, column=0) self.label_local_uav_y_res = Label(self.root, text="N/A") self.label_local_uav_y_res.grid(row=row_num_left, column=1) row_num_left += 1 self.label_local_uav_x = Label(self.root, text="UAV x:") self.label_local_uav_x.grid(row=row_num_left, column=0) self.label_local_uav_x_res = Label(self.root, text="N/A") self.label_local_uav_x_res.grid(row=row_num_left, column=1) row_num_left += 1 self.label_local_uav_z_rel = Label(self.root, text="UAV z_rel:") self.label_local_uav_z_rel.grid(row=row_num_left, column=0) self.label_local_uav_z_rel_res = Label(self.root, text="N/A") self.label_local_uav_z_rel_res.grid(row=row_num_left, column=1) row_num_left += 1 self.label_local_uav_status = Label(self.root, text="UAV status:") self.label_local_uav_status.grid(row=row_num_left, column=0) self.label_local_uav_status_res = Label(self.root, text="N/A") self.label_local_uav_status_res.grid(row=row_num_left, column=1) """ Right side layout """ row_num_right = 0 self.label_data_sources = Label(self.root, text="Data sources", font=("Arial Bold", 12)) self.label_data_sources.grid(row=row_num_right, column=2, columnspan=2) row_num_right += 1 self.label_data_source_no_fly_zones = Label(self.root, text="No-fly zones:") self.label_data_source_no_fly_zones.grid(row=row_num_right, column=2) self.label_data_source_no_fly_zones_res = Label(self.root, text="not loaded") self.label_data_source_no_fly_zones_res.configure(fg='red') self.label_data_source_no_fly_zones_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_data_source_height_map = Label(self.root, text="Altitude map:") self.label_data_source_height_map.grid(row=row_num_right, column=2) self.label_data_source_height_map_res = Label(self.root, text="not loaded") self.label_data_source_height_map_res.configure(fg='red') self.label_data_source_height_map_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_data_source_droneID = Label(self.root, text="DroneID:") self.label_data_source_droneID.grid(row=row_num_right, column=2) self.label_data_source_droneID_res = Label(self.root, text="not loaded") self.label_data_source_droneID_res.configure(fg='red') self.label_data_source_droneID_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_data_source_adsb = Label(self.root, text="ADS-B:") self.label_data_source_adsb.grid(row=row_num_right, column=2) self.label_data_source_adsb_res = Label(self.root, text="not loaded") self.label_data_source_adsb_res.configure(fg='red') self.label_data_source_adsb_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_data_source_weather = Label(self.root, text="Weather:") self.label_data_source_weather.grid(row=row_num_right, column=2) self.label_data_source_weather_res = Label(self.root, text="not loaded") self.label_data_source_weather_res.configure(fg='red') self.label_data_source_weather_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_data_rally_point = Label(self.root, text="Rally points:") self.label_data_rally_point.grid(row=row_num_right, column=2) self.label_data_rally_point_res = Label(self.root, text="not loaded") self.label_data_rally_point_res.configure(fg='red') self.label_data_rally_point_res.grid(row=row_num_right, column=3) row_num_right += 1 # gpe = global path evaluator self.label_gpe = Label(self.root, text="Global path evaluator", font=("Arial Bold", 12)) self.label_gpe.grid(row=row_num_right, column=2, columnspan=2) row_num_right += 1 self.button_evaluate_path = Button(self.root, text="Evaluate", command=self.start_evaluation) self.button_evaluate_path.configure( state='disabled') # Disabled because no global plan has been made self.button_evaluate_path.grid(row=row_num_right, column=2, columnspan=2) row_num_right += 1 self.label_gpe_fitness = Label(self.root, text="Fitness:") self.label_gpe_fitness.grid(row=row_num_right, column=2) self.label_gpe_fitness_res = Label(self.root, text="N/A") self.label_gpe_fitness_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_gpe_dist_tot = Label(self.root, text="Total distance:") self.label_gpe_dist_tot.grid(row=row_num_right, column=2) self.label_gpe_dist_tot_res = Label(self.root, text="N/A") self.label_gpe_dist_tot_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_gpe_dist_horz = Label(self.root, text="Horizontal distance:") self.label_gpe_dist_horz.grid(row=row_num_right, column=2) self.label_gpe_dist_horz_res = Label(self.root, text="N/A") self.label_gpe_dist_horz_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_gpe_dist_vert = Label(self.root, text="Vertical distance:") self.label_gpe_dist_vert.grid(row=row_num_right, column=2) self.label_gpe_dist_vert_res = Label(self.root, text="N/A") self.label_gpe_dist_vert_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_gpe_eta = Label(self.root, text="Estimated flight time:") self.label_gpe_eta.grid(row=row_num_right, column=2) self.label_gpe_eta_res = Label(self.root, text="N/A") self.label_gpe_eta_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_gpe_wps = Label(self.root, text="Waypoints:") self.label_gpe_wps.grid(row=row_num_right, column=2) self.label_gpe_wps_res = Label(self.root, text="N/A") self.label_gpe_wps_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_gpe_runtime = Label(self.root, text="Runtime:") self.label_gpe_runtime.grid(row=row_num_right, column=2) self.label_gpe_runtime_res = Label(self.root, text="N/A") self.label_gpe_runtime_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_gpe_bytes_tot = Label(self.root, text="Bytes total:") self.label_gpe_bytes_tot.grid(row=row_num_right, column=2) self.label_gpe_bytes_tot_res = Label(self.root, text="N/A") self.label_gpe_bytes_tot_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_gpe_objects_tot = Label(self.root, text="Objects total:") self.label_gpe_objects_tot.grid(row=row_num_right, column=2) self.label_gpe_objects_tot_res = Label(self.root, text="N/A") self.label_gpe_objects_tot_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_gpe_bytes_planner = Label(self.root, text="Bytes planner:") self.label_gpe_bytes_planner.grid(row=row_num_right, column=2) self.label_gpe_bytes_planner_res = Label(self.root, text="N/A") self.label_gpe_bytes_planner_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_gpe_objects_planner = Label(self.root, text="Objects planner:") self.label_gpe_objects_planner.grid(row=row_num_right, column=2) self.label_gpe_objects_planner_res = Label(self.root, text="N/A") self.label_gpe_objects_planner_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_planning_info = Label(self.root, text="Planning information", font=("Arial Bold", 12)) self.label_planning_info.grid(row=row_num_right, column=2, columnspan=2) row_num_right += 1 self.label_global_plan_status = Label(self.root, text="Status:") self.label_global_plan_status.grid(row=row_num_right, column=2) self.label_global_plan_status_res = Label(self.root, text="idle") self.label_global_plan_status_res.configure(fg='green') self.label_global_plan_status_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_global_plan_start_heuristic = Label(self.root, text="Start heuristic:") self.label_global_plan_start_heuristic.grid(row=row_num_right, column=2) self.label_global_plan_start_heuristic_res = Label(self.root, text="N/A") self.label_global_plan_start_heuristic_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_global_plan_cur_heuristic = Label(self.root, text="Best heuristic:") self.label_global_plan_cur_heuristic.grid(row=row_num_right, column=2) self.label_global_plan_cur_heuristic_res = Label(self.root, text="N/A") self.label_global_plan_cur_heuristic_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_global_plan_horz_step_size = Label( self.root, text="Horizontal step-size:") self.label_global_plan_horz_step_size.grid(row=row_num_right, column=2) self.label_global_plan_horz_step_size_res = Label(self.root, text="N/A") self.label_global_plan_horz_step_size_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_global_plan_vert_step_size = Label( self.root, text="Vertical step-size:") self.label_global_plan_vert_step_size.grid(row=row_num_right, column=2) self.label_global_plan_vert_step_size_res = Label(self.root, text="N/A") self.label_global_plan_vert_step_size_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_global_plan_search_time = Label(self.root, text="Search time:") self.label_global_plan_search_time.grid(row=row_num_right, column=2) self.label_global_plan_search_time_res = Label(self.root, text="N/A") self.label_global_plan_search_time_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_global_plan_nodes_visited = Label(self.root, text="Nodes visited:") self.label_global_plan_nodes_visited.grid(row=row_num_right, column=2) self.label_global_plan_nodes_visited_res = Label(self.root, text="N/A") self.label_global_plan_nodes_visited_res.grid(row=row_num_right, column=3) row_num_right += 1 self.label_global_plan_nodes_explored = Label(self.root, text="Nodes explored:") self.label_global_plan_nodes_explored.grid(row=row_num_right, column=2) self.label_global_plan_nodes_explored_res = Label(self.root, text="N/A") self.label_global_plan_nodes_explored_res.grid(row=row_num_right, column=3) """ Both sides """ if row_num_left > row_num_right: row_num_both = row_num_left else: row_num_both = row_num_right row_num_both += 1 self.label_global_path = Label(self.root, text="Global path:") self.label_global_path.grid(row=row_num_both, column=0) self.scrolledtext_global_path = tkst.ScrolledText(self.root, height=5) self.scrolledtext_global_path.grid(row=row_num_both, column=1, columnspan=3) row_num_both += 1 self.label_local_path = Label(self.root, text="Local path:") self.label_local_path.grid(row=row_num_both, column=0) self.scrolledtext_local_path = tkst.ScrolledText(self.root, height=5) self.scrolledtext_local_path.grid(row=row_num_both, column=1, columnspan=3) row_num_both += 1 self.button_show_result_webpage_global = Button( self.root, text="2D global path visualization (local)", command=self.show_result_webpage_global) self.button_show_result_webpage_global.configure( state='disabled') # Disabled because no global plan has been made self.button_show_result_webpage_global.grid(row=row_num_both, column=0, columnspan=2) #row_num_both += 1 self.button_show_result_webpage_local = Button( self.root, text="2D local path visualization (local)", command=self.show_result_webpage_local) self.button_show_result_webpage_local.configure( state='disabled') # Disabled because no global plan has been made self.button_show_result_webpage_local.grid(row=row_num_both, column=2, columnspan=2) row_num_both += 1 self.button_web_visualize_global = Button( self.root, text="3D global path visualization (online)", command=self.show_web_visualize_global) self.button_web_visualize_global.configure( state='disabled') # Disabled because no global plan has been made self.button_web_visualize_global.grid(row=row_num_both, column=0, columnspan=2) #row_num_both += 1 self.button_web_visualize_local = Button( self.root, text="3D local path visualization (online)", command=self.show_web_visualize_local) self.button_web_visualize_local.configure( state='disabled') # Disabled because no global plan has been made self.button_web_visualize_local.grid(row=row_num_both, column=2, columnspan=2) row_num_both += 1 self.button_gen_global_sim_files = Button( self.root, text="Generate global path simulation files", command=self.gen_global_sim_files) self.button_gen_global_sim_files.configure( state='disabled') # Disabled because no global plan has been made self.button_gen_global_sim_files.grid(row=row_num_both, column=0, columnspan=2) #row_num_both += 1 self.button_gen_local_sim_files = Button( self.root, text="Generate local path simulation files", command=self.gen_local_sim_files) self.button_gen_local_sim_files.configure( state='disabled') # Disabled because no global plan has been made self.button_gen_local_sim_files.grid(row=row_num_both, column=2, columnspan=2) row_num_both += 1 self.label_credit = Label( self.root, text="Copyright (c) 2018, Tobias Lundby, BSD 3-Clause License", fg="grey", font=("Arial 8 italic")) self.label_credit.grid(row=row_num_both, column=0, columnspan=4) # Configure the queue callback self.root.after(250, self.check_queue) # Start the main loop self.root.mainloop()
class WindowExample(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.result = 0 self.master.title("This is a test") self.master.minsize(width=600, height=800) #self.master. self.prompt = Label(self, text="Enter a number:", anchor="w", fg="#984301") self.entry = Entry(self, width=50, highlightcolor="red") self.submit = Button(self, text="Submit", command=self.calculate) self.exit = Button(self, text="Exit", command=parent.destroy, fg="red") self.output = Label(self, text="") self.menu = Menu(self, title="Menu test", bg="black") self.canvas = Canvas(self, cursor="circle", highlightcolor="blue", bg="#019bf0") self.button1 = Button(self, text = "tast antum", bg = "red", fg = "green", command = self.newWindow, \ activebackground = "red", activeforeground = "blue", relief = "sunken", cursor = "dot") self.newFrame = Frame(self, bg="green", highlightcolor="blue") self.button2 = Button(self.newFrame, text="This is a tast") self.button2.grid() self.scale = Scale(self, from_=50, to_=60, orient="horizontal", digits=3, resolution=0.25, highlightcolor="red", command=self.calculate) self.scale.pack() self.open_file_button = Button(self, text="Open File", command=self.openFile) self.prompt.pack(side="top", fill="x") self.entry.pack(side="top", fill="x") self.output.pack(side="top", fill="x", expand=True) self.submit.pack(side="right") self.exit.pack(side="left") self.button1.pack(fill="x") self.newFrame.pack(side="bottom", fill="x", expand=True) self.button2.grid() self.canvas.pack() self.open_file_button.pack() #self.slider.pack() #self.tk = Tkinter.Tk() #self.tk.withdrow() #self.file_path = Tkinter.filedialog.askopenfilename() #print("test") self.entry.insert(string="3", index=0) #self.entry.insert(string = "blahblah", index = 3) def calculate(self, integer): integer = float(integer) #try: # i = int(self.entry.get()) # self.result = "%s*2=%s" % (i, i*2) #except ValueError: # self.result = "Please enter numbers only" self.entry.delete(0, len(self.entry.get())) self.result = "%s*2=%s" % (integer, integer * 2) self.entry.insert(0, integer) self.output.configure(text=self.result) def newWindow(self): try: r2 = Tk() r2.mainloop() except ValueError: return None def openFile(self): file_in = tkFileDialog.askopenfilename() self.output.configure(text=file_in)
class PodSearch(object): '''This is the GUI class''' # Initialization of variables filename = "" # Initialization of GUI def __init__(self, master): '''Init of the GUI''' # Frame for progress bar self.bottomframe = Frame(master, highlightbackground="green", highlightcolor="green", highlightthickness=1, width=500, height=200) self.bottomframe.pack(side=BOTTOM) # Frame for buttons and entry self.leftframe = Frame(master, highlightbackground="blue", highlightcolor="blue", highlightthickness=1, width=400, height=400) self.leftframe.pack(side=LEFT) # Sub frame for buttons self.leftsubframe_top = Frame(self.leftframe, highlightbackground="yellow", highlightcolor="yellow", highlightthickness=1) self.leftsubframe_top.pack(side=TOP) # Sub frame for entry self.leftsubframe_bot = Frame(self.leftframe, highlightbackground="purple", highlightcolor="purple", highlightthickness=1) self.leftsubframe_bot.pack(side=BOTTOM) # Frame for wordcloud rightframe = Frame(master, highlightbackground="red", highlightcolor="red", highlightthickness=1, width=250, height=250) rightframe.pack(side=RIGHT) # Browse button self.browsebtn = Button(self.leftsubframe_top, text="Browse", command=self.browse) self.browsebtn.pack(side=LEFT) # Quit button self.quitbtn = Button(self.leftsubframe_top, text="Quit", command=self.leftframe.quit) self.quitbtn.pack(side=LEFT) # Filepath label self.pathlabel = Label(self.leftsubframe_bot, text="filename") self.pathlabel.pack() # Textbox self.searchentry = Entry(self.leftsubframe_bot) self.searchentry.pack() self.searchentry.bind('<Return>', lambda _: self.search()) # Search button self.searchbtn = Button(self.leftsubframe_bot, text="Search", command=self.search) self.searchbtn.pack() # Word label self.wordlabel = Label(self.bottomframe) self.wordlabel.pack() # Timestamp label self.timestamplabel = Label(self.bottomframe) self.timestamplabel.pack() # estimate label self.estimatelabel = Label(self.bottomframe) self.estimatelabel.pack() # Working Label self.workinglabel = Label(self.bottomframe) self.workinglabel.pack() # Progress Bar self.pbar_det = ttk.Progressbar(self.bottomframe, orient="horizontal", length=400, mode="indeterminate") # Wordcloud preparation self.imagefile = "wordcloudTools/black_background.png" self.imagefile = Image.open(self.imagefile) self.image1 = self.imagefile.resize((400, 400), Image.ANTIALIAS) self.image1 = ImageTk.PhotoImage(self.image1) self.panel1 = Label(rightframe, image=self.image1) self.display = self.image1 self.panel1.pack(side=TOP, fill=BOTH, expand=YES) # Non GUI initializations self.duration = 0 self.transcription = "" self.stemmed = "" self.transcription = "" self.imagefile2 = 0 self.image2 = 0 # Browse function def browse(self): '''browse for file''' if self.wordlabel != "": # clear the labels if necessary self.wordlabel.config(text="") self.pathlabel.config(text="") self.timestamplabel.config(text="") self.estimatelabel.config(text="") self.filename = askopenfilename( ) # openfile dialog and put file in filename if not self.filename: # leave method if cancel is clicked return self.pathlabel.config(text=basename( self.filename)) # show filename as label if self.filename.endswith('.txt'): return self.workinglabel.config(text="WORKING", font=("Helvetica", 20)) # Show WORKING when transcribing self.pbar_det.pack() # show the progress bar self.pbar_det.start() # Start the progress bar root.update() self.transcription = transcribe(self.filename) # Call transcribe wordcloud_path = wordcloud_create(self.transcription) self.transcription = removerlap(self.transcription.split(' ')) self.new_image(wordcloud_path) self.workinglabel.config(text="") # remove working label self.pbar_det.stop() # Stop progress bar self.pbar_det.pack_forget() # Remove progress bar # Search function def search(self): '''Search using text domain''' if not self.transcription == '': if not self.searchentry.get() == '': keyword = self.searchentry.get() # Get entry from textbox # ********************************************************************************* # Here coes code # ********************************************************************************* # Write result to label if wordlabel != "Word number": self.wordlabel.config(text=wordlabel) self.estimatelabel.config(text=time) self.timestamplabel.config(text=timestamplabel) else: self.wordlabel.config(text="Word not found") self.timestamplabel.config(text="") self.estimatelabel.config(text="") else: self.wordlabel.config(text="Enter word in search field") else: self.timestamplabel.config(text="No file selected") def new_image(self, path): '''Word Cloud image''' self.imagefile2 = Image.open(path) self.image2 = self.imagefile2.resize((400, 400), Image.ANTIALIAS) self.image2 = ImageTk.PhotoImage(self.image2) self.panel1.configure(image=self.image2) self.display = self.image2
class ListEditor(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent border_width = 1 border_style = SUNKEN background_colour = "#FFFFFF" default_height = 600 nav_frame = Frame( self, height=default_height, width=200, bd=border_width, relief=border_style, bg=background_colour ) content_frame = Frame(self, height=default_height, width=804, bd=border_width, relief=border_style) content_frame.parent = parent nav_frame.grid(column=0, row=0) content_frame.grid(column=1, row=0) nav_frame.grid_propagate(0) content_frame.pack_propagate(0) # Create fonts for navLabels fontMouseOver = tkFont.Font(family="Helvetica", size=14, underline=True) fontMouseOut = tkFont.Font(family="Helvetica", size=14, underline=False) # Creating Navigation Labels self.lNavStudentRecords = Label( nav_frame, text="Student Records", bg="white", font=fontMouseOut, bd=border_width, relief=border_style, width=20, ) self.lNavViewLists = Label( nav_frame, text="View Word Lists", bg="white", font=fontMouseOut, bd=border_width, relief=border_style, width=20, ) self.lNavCreateLists = Label( nav_frame, text="Create Word Lists", bg="white", font=fontMouseOut, bd=border_width, relief=border_style, width=20, ) buttonBack = Button(nav_frame, text="Back", command=self.parent.new_list) # Binding Mouse events to the Labels # Mouse Clicks self.lNavViewLists.bind("<Button-1>", partial(self.switch_frame, 2)) self.lNavCreateLists.bind("<Button-1>", partial(self.switch_frame, 1)) self.lNavStudentRecords.bind("<Button-1>", partial(self.switch_frame, 3)) # Mouse Movements self.lNavViewLists.bind("<Enter>", lambda (event): self.lNavViewLists.configure(font=fontMouseOver)) self.lNavCreateLists.bind("<Enter>", lambda (event): self.lNavCreateLists.configure(font=fontMouseOver)) self.lNavViewLists.bind("<Leave>", lambda (event): self.lNavViewLists.configure(font=fontMouseOut)) self.lNavCreateLists.bind("<Leave>", lambda (event): self.lNavCreateLists.configure(font=fontMouseOut)) self.lNavStudentRecords.bind("<Enter>", lambda (event): self.lNavStudentRecords.configure(font=fontMouseOver)) self.lNavStudentRecords.bind("<Leave>", lambda (event): self.lNavStudentRecords.configure(font=fontMouseOut)) # Gridding the labels # self.lNavStudentRecords.grid(column=0, row=0) self.lNavViewLists.grid(column=0, row=1) self.lNavCreateLists.grid(column=0, row=2) buttonBack.grid(column=0, row=3) # Creating the two views we have so far self.viewcreate = CreateView(content_frame, default_height, 800, border_style, border_width, background_colour) self.viewlists = ListView(content_frame, default_height, 800, border_style, border_width, background_colour) self.viewlists.pack() def switch_frame(self, frameNumber, event): if frameNumber == 1: self.viewlists.pack_forget() self.viewcreate.pack() self.lNavViewLists.configure(bg="white", fg="black") self.lNavCreateLists.configure(bg="#DDDDDD", fg="#8800AA") self.lNavStudentRecords.configure(bg="white", fg="black") self.viewcreate.update_category() elif frameNumber == 2: self.viewcreate.pack_forget() self.viewlists.pack() self.lNavCreateLists.configure(bg="white", fg="black") self.lNavViewLists.configure(bg="#DDDDDD", fg="#8800AA") self.lNavStudentRecords.configure(bg="white", fg="black") self.viewlists.update() else: self.viewcreate.pack_forget() self.viewlists.pack_forget() self.lNavCreateLists.configure(bg="white", fg="black") self.lNavViewLists.configure(bg="white", fg="black") self.lNavStudentRecords.configure(bg="#DDDDDD", fg="#8800AA")
class Palette_frame(Frame): def __init__(self, master, text=None, borderwidth=2, width=0, height=16, interior_padx=0, interior_pady=8, background=None, caption_separation=4, caption_font=None, caption_builder=None, icon_x=5): Frame.__init__(self, master) self._is_opened = False self._interior_padx = interior_padx self._interior_pady = interior_pady self._iconOpen = PhotoImage( data= "R0lGODlhEwATAPcAAAAAAAAAAQD/AAIAAQUAAgcFAAoEAAwHABALABQMBBUPARUSAhUTBhgQBBgVCRsUACEWACIcACYgACggACshACwoADElATEpADEtATQkADQpADYxBDctATk0AT8uAEA6AEE1AEU0AUY3AEY7AUc/Ako7AUpFBUxAA1BHAVE6AFRHAFU/AFdGAFdQAFhCAFlUAVpMAFxGAF1DAF5TAGBaAGNIAGRYAGReAmVSAGhMAGpPAGpWAmpfAm1SAG9RAHFXAHFhAXFrAXJbAXJnAHZuA3dYAHxcAnxfAXxkAHxuAH1gAH5qAX5zAIBcAoRiAIRxAIR5AIdmAIhqAIlyAImAAop6AIxmAI9xAY95AY+BAJJtAJRvAJSIAJV5AZWAAJd1AJl0App5AJtxAZuJAJx/AJyKAZyPAJ+UAKB2AKGAAKKIAaSUAKV7AKeAAaeJAKqeA6uQAKuaAKyVAa+BAK+JALCiALOEALORALSWALSiALWaALeqAbmLALuhALyXALyqALywAL6LAMC0AMGfAMGkAMKRAMOWAMOpAMOvAMO6AMqYAMqiAMqyAMunAMuuAMu+AMy5AM2dAs7DANGfAtG7AdKwANPFANWoANXFANihANi4ANi9ANmyANnEANrLANunAN6mAN/MAOC/AODFAOK5AOLRAOOsAOWxAOasAOfFAefWAOm5AenNAOnTAOu/AOyzBezaAO3YAO60Be7dAPDFAPG1APLQAPO9APPLAPPdAPPjAfS2APTBAPTDAPW/APa/APbAAPbDAPbXAPe/APfIAPfPAPi9APjLAPjjAPm9APnXAPnbAPnkAPrRAPrqAPu8APu/APvBAPvDAPvNAPvUAPvXAPvdAPviAPzHAPzLAPzTAfzWAPzdAPzhAPzkAPzlAPzuAP2+AP3MAP3PAP3VAP3ZAP3iAP3kAP3pAP3sAP3tAP3vAP68AP7FAP7IAP7KAP7RAP7TAf7XAP7aAP7dAP7fAP7jAP7lAP7oAP7qAP7xAP/GAP/pAP/uAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFBwACACwAAAAAEwATAAAIuAABCBxIsKDBgwgFRuBhpqHDLCYSjtiTq6LFVmM0aNyoIUKBEoSaiRzZbBSiPyj/EOrzZEKIQr5+AZsJLNgydThzqktEosShZcusCRV6L5/Ro/kSmTjB6J7Tp1CjIiLB1JzVq1izTj3hiJ7Xr2DDHqLaSJ7Zs2jRljtUokSjeHDjyp1LqO2icXjz6t07yK67v4ADC+5bwlC0w4gTKzYkwsMcU5AjS548xwMCDzkya97M2XLCz6ARBgQAIfkEBQYAAgAsAAACABMAEAAAAg+Uj6nL7Q+jnLTai7PeHBUAIfkEBQcAAgAsAAACABIACgAAAgyUj6nL7Q+jnLTaVgAAIfkEBQcAAgAsAwAFAAUAAgAAAgOUjwUAOw==" ) self._iconClose = PhotoImage( data= "R0lGODlhEwATAPcAAAAAAAAAAgD/AAEAAAEBAAIAAQUEAAoFAAsJAA4LABMOABUSBRcPAhkUABoYBx4XBB8YACEbASQfASgiACoeAC4jAS4nADEsADMvATQnADUuBTYuADk2ATsxADwtAT84AUI7AEQzAEQ5AEZBAEo5Ako9AUpDAU88AVBGAVBLAVQ9AVRCAFZQAVhGAFhLAVtUAV9CAF9LAWFQAmFZAWFaAGJRAGRLAWVHAGVeAGdiAGtTAmtZBGxZAGxkAG1PAG1iAnFdAHFpAXRUAnRWA3RZAXRiAXZeAHhqAXpiAXpvAXtzAYBcAIFrAYJjAoNgAYN1AoV9AYhrAop0AYtlAI2FAY59AY9jAJB4AJFrApFsApJyAZOFAZRoAZSMAZV+AJmCAJuPAJxmAJxzAJ15AJ2IAJ+CAKGQAaGXAaV6AKV7AKeLAKh8AKiRAKmXAatpAqyhAK2BAK+IAbGEALGYALKEBbOlArV6AbWIALaaAbiLALiUArihArqtAb2NAL+uAMCQA8CZAMGkAMGoAMOAAMO1AcWuAMaTAMa7AMeZAcuYA8uZAMunAMy1AM2YAM29Ac6wAM+bANLFAtSeANSoAdS3AdW+AdaCANahAdfMAdmIANqmAN2wAd3EAN3NAt6oAN7BAOCTAOC4AeHWAeKJAOOsAOSaAOStAOXJAOaMAOeQAOqTAOrQAOuyAOu9AOvKAOvWAOvfAuyWAO2gAO6oAO+bAO+2AO+4APGvAPG8APKfAPLeAPPPAPSiAPSoAPS7APTFAPTXAPW1APW4APXAAPXlAPbKAPemAPerAPfOAPfgAPfqAPjVAPjaAPmwAPm8APm/APnMAPq1APq5APrHAPrgAPvCAPvOAPvXAPvrAfzUAPzgAPzmAPztAPzvAP27AP3AAP3FAP3HAP3KAP3MAP3VAP3ZAP3iAP3kAP3qAP3vAP7FAP7IAP7JAP7MAP7PAP7SAP7TAP7XAP7YAP7cAf7eAP7fAP7jAP7nAP7qAP7sAP7uAP/QAP/TAP/bAP/oAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFBwACACwAAAAAEwATAAAIygABCBxIsKDBgwgHGlCwoGFDBQcSAugQRImSJ0+UBPkgEQosYiBB6jojgkRJkx0aCNyyDZ/Ll6sEBZo5c44MgVWuzdvJsyfPZVUEaoHWrqjRduOSjitaTIpALMGkSZ0aTZgwZ1id+dLC4IATVbFo0cpF1teys2iXVWLxotIuZHDRanv5Mh+xHj+SmdvLt6/fVS9kuPJJuOcjEyUWwVvMuLHjOR0yqFFKubLSMREUZKllq7Pnz55rRTEAgMQULKhTq07tJITE17ANBgQAIfkEBQYAAgAsAAACABMADwAACDUABQgcSLCgwYMIExoUIUKhQ4LMHkok2E7gtILRJmo8iMxhvnz4NoocqbCduJMoU6YkyVJAQAAh+QQFBwABACwBAAMAEgANAAAIHgADCBxIsKDBgwgTKlzIkKGVhhAjSpxIMaK4ihEDAgAh+QQFBwABACwCAAMAEAANAAAIIQADCBxIsKDBgwgTKlzIsOFAYQRzOUyYb6LFiwTbYWwYEAA7" ) height_of_icon = max(self._iconOpen.height(), self._iconClose.height()) width_of_icon = max(self._iconOpen.width(), self._iconClose.width()) containerFrame_pady = (height_of_icon // 2) + 1 self._height = height self._width = width self._containerFrame = Frame(self, borderwidth=borderwidth, width=width, height=height, relief=RIDGE, background=background) self._containerFrame.pack(expand=True, fill=X, pady=(containerFrame_pady, 0)) self.interior = Frame(self._containerFrame, background=background) self._collapseButton = Label(self, borderwidth=0, image=self._iconOpen, relief=RAISED) self._collapseButton.place(in_=self._containerFrame, x=icon_x, y=-(height_of_icon // 2), anchor=N + W, bordermode="ignore") self._collapseButton.bind("<Button-1>", lambda event: self.toggle()) if caption_builder is None: self._captionLabel = Label(self, anchor=W, borderwidth=1, text=text) if caption_font is not None: self._captionLabel.configure(font=caption_font) else: self._captionLabel = caption_builder(self) if not isinstance(self._captionLabel, Widget): raise Exception( "'caption_builder' doesn't return a Tkinter widget") self.after( 0, lambda: self._place_caption(caption_separation, icon_x, width_of_icon)) def _place_caption(self, caption_separation, icon_x, width_of_icon): self.update() x = caption_separation + icon_x + width_of_icon y = -(self._captionLabel.winfo_reqheight() // 2) self._captionLabel.place(in_=self._containerFrame, x=x, y=y, anchor=N + W, bordermode="ignore") def open(self): self._collapseButton.configure(image=self._iconClose) self._containerFrame.configure(height=self.interior.winfo_reqheight()) self.interior.pack(expand=True, fill=X, padx=self._interior_padx, pady=self._interior_pady) self._is_opened = True def close(self): self.interior.pack_forget() self._containerFrame.configure(height=self._height) self._collapseButton.configure(image=self._iconOpen) self._is_opened = False def toggle(self): if self._is_opened: self.close() else: self.open()
class SearchBox(Frame): def __init__(self, master, entry_width=30, entry_font=None, entry_background="white", entry_highlightthickness=1, button_text="Search", button_ipadx=10, button_background="#009688", button_foreground="white", button_font=None, opacity=0.8, placeholder=None, placeholder_font=None, placeholder_color="grey", spacing=3, command=None): Frame.__init__(self, master) self._command = command self.entry = Entry(self, width=entry_width, background=entry_background, highlightcolor=button_background, highlightthickness=entry_highlightthickness) self.entry.pack(side=LEFT, fill=BOTH, ipady=1, padx=(0, spacing)) if entry_font: self.entry.configure(font=entry_font) if placeholder: add_placeholder_to(self.entry, placeholder, color=placeholder_color, font=placeholder_font) self.entry.bind("<Escape>", lambda event: self.entry.nametowidget(".").focus()) self.entry.bind("<Return>", self._on_execute_command) opacity = float(opacity) if button_background.startswith("#"): r, g, b = hex2rgb(button_background) else: # Color name r, g, b = master.winfo_rgb(button_background) r = int(opacity * r) g = int(opacity * g) b = int(opacity * b) if r <= 255 and g <= 255 and b <= 255: self._button_activebackground = '#%02x%02x%02x' % (r, g, b) else: self._button_activebackground = '#%04x%04x%04x' % (r, g, b) self._button_background = button_background self.button_label = Label(self, text=button_text, background=button_background, foreground=button_foreground, font=button_font) if entry_font: self.button_label.configure(font=button_font) self.button_label.pack(side=LEFT, fill=Y, ipadx=button_ipadx) self.button_label.bind("<Enter>", self._state_active) self.button_label.bind("<Leave>", self._state_normal) self.button_label.bind("<ButtonRelease-1>", self._on_execute_command) def get_text(self): entry = self.entry if hasattr(entry, "placeholder_state"): if entry.placeholder_state.contains_placeholder: return "" else: return entry.get() else: return entry.get() def set_text(self, text): entry = self.entry if hasattr(entry, "placeholder_state"): entry.placeholder_state.contains_placeholder = False entry.delete(0, END) entry.insert(0, text) def clear(self): self.entry_var.set("") def focus(self): self.entry.focus() def _on_execute_command(self, event): text = self.get_text() self._command(text) def _state_normal(self, event): self.button_label.configure(background=self._button_background) def _state_active(self, event): self.button_label.configure(background=self._button_activebackground)
class TreeNode: def __init__(self, canvas, parent, item): self.canvas = canvas self.parent = parent self.item = item self.state = 'collapsed' self.selected = False self.children = [] self.x = self.y = None self.iconimages = {} # cache of PhotoImage instances for icons def destroy(self): for c in self.children[:]: self.children.remove(c) c.destroy() self.parent = None def geticonimage(self, name): try: return self.iconimages[name] except KeyError: pass file, ext = os.path.splitext(name) ext = ext or ".gif" fullname = os.path.join(ICONDIR, file + ext) image = PhotoImage(master=self.canvas, file=fullname) self.iconimages[name] = image return image def select(self, event=None): if self.selected: return self.deselectall() self.selected = True self.canvas.delete(self.image_id) self.drawicon() self.drawtext() def deselect(self, event=None): if not self.selected: return self.selected = False self.canvas.delete(self.image_id) self.drawicon() self.drawtext() def deselectall(self): if self.parent: self.parent.deselectall() else: self.deselecttree() def deselecttree(self): if self.selected: self.deselect() for child in self.children: child.deselecttree() def flip(self, event=None): if self.state == 'expanded': self.collapse() else: self.expand() self.item.OnDoubleClick() return "break" def expand(self, event=None): if not self.item._IsExpandable(): return if self.state != 'expanded': self.state = 'expanded' self.update() self.view() def collapse(self, event=None): if self.state != 'collapsed': self.state = 'collapsed' self.update() def view(self): top = self.y - 2 bottom = self.lastvisiblechild().y + 17 height = bottom - top visible_top = self.canvas.canvasy(0) visible_height = self.canvas.winfo_height() visible_bottom = self.canvas.canvasy(visible_height) if visible_top <= top and bottom <= visible_bottom: return x0, y0, x1, y1 = self.canvas._getints(self.canvas['scrollregion']) if top >= visible_top and height <= visible_height: fraction = top + height - visible_height else: fraction = top fraction = float(fraction) / y1 self.canvas.yview_moveto(fraction) def lastvisiblechild(self): if self.children and self.state == 'expanded': return self.children[-1].lastvisiblechild() else: return self def update(self): if self.parent: self.parent.update() else: oldcursor = self.canvas['cursor'] self.canvas['cursor'] = "watch" self.canvas.update() self.canvas.delete(ALL) # XXX could be more subtle self.draw(7, 2) x0, y0, x1, y1 = self.canvas.bbox(ALL) self.canvas.configure(scrollregion=(0, 0, x1, y1)) self.canvas['cursor'] = oldcursor def draw(self, x, y): # XXX This hard-codes too many geometry constants! dy = 20 self.x, self.y = x, y self.drawicon() self.drawtext() if self.state != 'expanded': return y + dy # draw children if not self.children: sublist = self.item._GetSubList() if not sublist: # _IsExpandable() was mistaken; that's allowed return y+17 for item in sublist: child = self.__class__(self.canvas, self, item) self.children.append(child) cx = x+20 cy = y + dy cylast = 0 for child in self.children: cylast = cy self.canvas.create_line(x+9, cy+7, cx, cy+7, fill="gray50") cy = child.draw(cx, cy) if child.item._IsExpandable(): if child.state == 'expanded': iconname = "minusnode" callback = child.collapse else: iconname = "plusnode" callback = child.expand image = self.geticonimage(iconname) id = self.canvas.create_image(x+9, cylast+7, image=image) # XXX This leaks bindings until canvas is deleted: self.canvas.tag_bind(id, "<1>", callback) self.canvas.tag_bind(id, "<Double-1>", lambda x: None) id = self.canvas.create_line(x+9, y+10, x+9, cylast+7, ##stipple="gray50", # XXX Seems broken in Tk 8.0.x fill="gray50") self.canvas.tag_lower(id) # XXX .lower(id) before Python 1.5.2 return cy def drawicon(self): if self.selected: imagename = (self.item.GetSelectedIconName() or self.item.GetIconName() or "openfolder") else: imagename = self.item.GetIconName() or "folder" image = self.geticonimage(imagename) id = self.canvas.create_image(self.x, self.y, anchor="nw", image=image) self.image_id = id self.canvas.tag_bind(id, "<1>", self.select) self.canvas.tag_bind(id, "<Double-1>", self.flip) def drawtext(self): textx = self.x+20-1 texty = self.y-4 labeltext = self.item.GetLabelText() if labeltext: id = self.canvas.create_text(textx, texty, anchor="nw", text=labeltext) self.canvas.tag_bind(id, "<1>", self.select) self.canvas.tag_bind(id, "<Double-1>", self.flip) x0, y0, x1, y1 = self.canvas.bbox(id) textx = max(x1, 200) + 10 text = self.item.GetText() or "<no text>" try: self.entry except AttributeError: pass else: self.edit_finish() try: self.label except AttributeError: # padding carefully selected (on Windows) to match Entry widget: self.label = Label(self.canvas, text=text, bd=0, padx=2, pady=2) theme = idleConf.CurrentTheme() if self.selected: self.label.configure(idleConf.GetHighlight(theme, 'hilite')) else: self.label.configure(idleConf.GetHighlight(theme, 'normal')) id = self.canvas.create_window(textx, texty, anchor="nw", window=self.label) self.label.bind("<1>", self.select_or_edit) self.label.bind("<Double-1>", self.flip) self.text_id = id def select_or_edit(self, event=None): if self.selected and self.item.IsEditable(): self.edit(event) else: self.select(event) def edit(self, event=None): self.entry = Entry(self.label, bd=0, highlightthickness=1, width=0) self.entry.insert(0, self.label['text']) self.entry.selection_range(0, END) self.entry.pack(ipadx=5) self.entry.focus_set() self.entry.bind("<Return>", self.edit_finish) self.entry.bind("<Escape>", self.edit_cancel) def edit_finish(self, event=None): try: entry = self.entry del self.entry except AttributeError: return text = entry.get() entry.destroy() if text and text != self.item.GetText(): self.item.SetText(text) text = self.item.GetText() self.label['text'] = text self.drawtext() self.canvas.focus_set() def edit_cancel(self, event=None): try: entry = self.entry del self.entry except AttributeError: return entry.destroy() self.drawtext() self.canvas.focus_set()