class UndoButton(Observer): '''Represent the 'undo' button in the Senku GUI.''' def __init__(self, game, parent): '''Constructor of UndoButton. Receive the game and the parent widget (frame, in this case).''' Observer.__init__(self) self._game = game self._game.add_observer(self, 'UNDO_STACK') self._button = Button(parent, text='Deshacer', command=self.undo) self._button.grid(row=1, column=1) def update(self, aspect, value): '''The aspect is always UNDO_STACK. If there's no undo actions, the button will be disabled.''' if value.is_empty(): self._button.config(state=DISABLED) else: self._button.config(state=NORMAL) def undo(self): '''Tell the model to perform the undo action, if it's possible.''' self._game.undo()
class ConfigWindow(Toplevel): '''Represent the configuration window.''' def __init__(self, parent=None): '''Constructor of ConfigWindow.''' Toplevel.__init__(self, parent) self.title('Configuracion') self._states = [IntVar(value=CONFIG['GAME_TRACKING']), IntVar(value=CONFIG['CONFIRM_EXIT'])] self._cbox_gtrack = Checkbutton(self, text='Seguimiento del juego') self._cbox_gtrack.config(variable=self._states[0]) self._cbox_confexit = Checkbutton(self, text='Confirmacion al salir') self._cbox_confexit.config(variable=self._states[1]) self._cbox_gtrack.grid(row=0, column=0, sticky=W) self._cbox_confexit.grid(row=1, column=0, sticky=W) self._button_cancel = Button(self, text='Cancelar', command=self.destroy) self._button_cancel.grid(row=3, column=1, sticky=E) self._button_accept = Button(self, text='Guardar y Salir') self._button_accept.config(command=self.save_config) self._button_accept.grid(row=3, column=0, sticky=E) def save_config(self): pass def get_state_game_tracking(self): return self._states[0].get() def get_state_confirm_exit(self): return self._states[1].get()
class GuiBasicSettings(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.pack() #Unit self.sizeUnits = {"Byte": 1, "KiB":1024, "MiB":1024**2, "GiB":1024**3} self._initFile() self._initSize() def _initFile(self): self._fileLbl = Label(self, text="File: ") self._fileTxt = Entry(self) self._fileTxt.insert(0, "/tmp/out.txt") self._fileBtn = Button(self, text="Create", command=self._callbackFun) self._fileLbl.grid(row=0, column=0) self._fileTxt.grid(row=0, column=1) self._fileBtn.grid(row=0, column=2) def _initSize(self): self._sizeLbl = Label(self, text="FileSize: ") self._sizeTxt = Entry(self) self._sizeTxt.insert(0, "1024") self._sizeVar = StringVar() self._sizeVar.set("Byte") #FIXME: replace "Byte" with variable sizeOptParam = (self, self._sizeVar) + tuple(self.sizeUnits.keys()) self._sizeOptMen = OptionMenu(*sizeOptParam) self._sizeLbl.grid(row=1, column=0) self._sizeTxt.grid(row=1, column=1) self._sizeOptMen.grid(row=1, column=2) def _callbackFun(self): print("_callbackBtn") self.outerCallback() def enableButton(self, enabled=True): if enabled: self._fileBtn.config(state="normal") else: self._fileBtn.config(state="disabled") def getFileName(self): return self._fileTxt.get() def getFileSize(self): mult = int(self.sizeUnits[self._sizeVar.get()]) val = int(self._sizeTxt.get()) return val * mult def setCallback(self, aCallback): self.outerCallback = aCallback
class Dashboard: #顯示儀表板 def showup(self): self.psr = Processor() self.root = Tk() self.root.title("MOPS資訊觀測站") frame = Frame(self.root) frame.grid(row=0, column=0, sticky="news") self.stateV = StringVar() self.stateV.set("日期格式:yyyymmdd") self.statebarL = Label(frame, textvariable=self.stateV) sdateL = Label(frame, text="開始日期") edateL = Label(frame, text="迄止日期") self.sdateE = Entry(frame) self.edateE = Entry(frame) self.goBtn = Button(frame, text="確定", command=self.runProcess) self.statebarL.grid(row=0, column=0, rowspan=1, columnspan=3, sticky="news") sdateL.grid(row=1, column=0, rowspan=1, columnspan=1, sticky="news") edateL.grid(row=2, column=0, rowspan=1, columnspan=1, sticky="news") self.sdateE.grid(row=1, column=1, rowspan=1, columnspan=1, sticky="news") self.edateE.grid(row=2, column=1, rowspan=1, columnspan=1, sticky="news") self.goBtn.grid(row=1, column=2, rowspan=2, columnspan=1, sticky="news") Grid.grid_rowconfigure(self.root, 0, weight=1) Grid.grid_columnconfigure(self.root, 0, weight=1) self.root.mainloop() #確定開始執行抓取資料 def runProcess(self): self.goBtn.config(state="disabled") try: sdate = self.sdateE.get() edate = self.edateE.get() datetime.strptime(sdate, "%Y%m%d") datetime.strptime(edate, "%Y%m%d") except ValueError: self.stateV.set("日期格式錯誤,正確為:yyyymmdd") return None print("from " + sdate + " to " + edate) self.psr.setDateRange(sdate, edate) self.psr.registerProgressObserver(self) #observer 需實作 updateProgress t = Timer(0, self.psr.runProcess) #啟動另一個 thread 執行,畫面才不會「沒有回應」 t.start() #進度更新 def updateProgress(self, progress): self.stateV.set("進度:" + str(progress) + "%") if progress == 100: self.goBtn.config(state="normal") self.stateV.set("已完成。重新輸入日期:yyyymmdd")
def list_entries(self, Medikom, results, entry_type): if entry_type == 0: # tasks (left column) x = self.SPACE_TWO else: # information (right column) x = self.WIN_WIDTH / 2 + (.25 * self.SPACE_ONE) for i, (id, ts, title) in enumerate(results): ts = self.format_ts(ts) task_button = Button( self, text=ts + title, font='Courier 10', anchor='w', command=Callable(self.view_details, Medikom, id)) task_button.place( x=x, y=(i + 1) * (self.ROW_HIGHT + self.ROW_SPACE), width=(self.WIN_WIDTH / 2) - (1.25 * self.SPACE_ONE), height=self.ROW_HIGHT) rm_task_button = Button( self, text='√', command=Callable(self.rm_entry, Medikom, id, title)) rm_task_button.place( x=x + (self.WIN_WIDTH / 2) - (1.25 * self.SPACE_ONE), y=(i + 1) * (self.ROW_HIGHT + self.ROW_SPACE), width=self.SPACE_TWO, height=self.ROW_HIGHT) # highlight selected entries and those with priority if self.selected_id and (id == self.selected_id): task_button.config(bg='lightblue') rm_task_button.config(bg='lightblue') if title.startswith('!'): task_button.config(bg='IndianRed2') rm_task_button.config(bg='IndianRed2')
def main(): root = Tk() a = Alarm(root) a.pack(side="bottom") textbox = Entry(root) textbox.pack(side="left") start = Button(root, text="Start",command= lambda: a.startTimer(int(textbox.get()), start, stop, textbox)) start.pack(side="left") stop = Button(root, text="Stop",command= lambda: a.stop(start,stop)) stop.config(state="disabled") stop.pack(side="left") reset = Button(root, text="Reset", command= lambda: a.reset(start,stop,textbox)) reset.pack(side="left") root.mainloop()
def __init__(self, game): '''Constructor of UISenku. Build the main window and the main frame.''' Observer.__init__(self) self._game = game self._root = Tk() self._root.title('PySenku') main_frame = Frame(self._root, width=280, height=330, bd=1) BoardArea(self._game, main_frame) start_button = Button(main_frame) start_button.config(text='Nuevo', command=self.start) start_button.grid(row=1, column=0) help_button = Button(main_frame) help_button.config(text='Mas info...', command=self.open_help) help_button.grid(row=1, column=2) UndoButton(self._game, main_frame) main_frame.pack() self._game.add_observer(self, 'GAME_OVER') self._root.protocol("WM_DELETE_WINDOW", self.quit)
def initButtons(self, ios, commands): for command in ios: cmdInstance = command() cmdButton = Button(self.topToolbar, image=self.res.get(command.get_id()), relief=GROOVE) cmdHandler = partial(self.onIOCommandClick, cmdButton, cmdInstance) cmdButton.config(command=cmdHandler) cmdButton.pack(side=LEFT, padx=2, pady=2) self.ioButtons.append(cmdButton) print("Added draw command: {} ({})".format(cmdInstance.get_name(), cmdInstance.get_description())) self.commandButtons = [] for command in commands: cmdButton = Button(self.topToolbar, image=self.res.get(command.get_id()), relief=FLAT) cmdHandler = partial(self.onDrawCommandButtonClick, cmdButton, command) cmdButton.config(command=cmdHandler) cmdButton.pack(side=LEFT, padx=2, pady=2) self.commandButtons.append(cmdButton) print("Added IO command: {} ({})".format(command.get_name(), command.get_description())) cmdColorPicker = Button(self.topToolbar, relief=RIDGE) cmdHandler = partial(self.onChangeColor, cmdColorPicker) cmdColorPicker.config(command=cmdHandler, background=self.colorPicker.getColor(), relief=GROOVE, width=2, highlightbackground='white') cmdColorPicker.pack(side=LEFT, padx=15, pady=2) self.colorPickerButton = cmdColorPicker
class Amel(LabelFrame): def __init__(self, boss, nom, amelioration, maximum, prix, up, logo): """ amelioration (str) : Nom de l'amélioration du bouton maximum (int) : Maximum de fois que l'on peut augmenter l'amélioration prix (int) : Prix de l'amélioration par niveau up (int) : Montant de point apporté par l'amélioration """ global imagesMag self.amel = amelioration self.max = maximum self.prix = prix self.up = up LabelFrame.__init__(self, boss) Label(self, image=imagesMag[logo]).pack(side=LEFT) Label(self, text=nom, width=18).pack(side=LEFT) self.button = Button(self, command=self.acheter, width = 6) self.level = Label(self, width=5) self.total = Label(self, width=11) self.total.pack(side=RIGHT) self.level.pack(side=RIGHT) self.button.pack(side=RIGHT) self.maj() def maj(self): global amel, stat self.button.config(text=(str((amel[self.amel]+1)*self.prix) + ' PO')) self.level.config(text=str(amel[self.amel]) + '/' + str(self.max)) self.total.config(text='Total : ' + str(stat[self.amel])) def acheter(self): global stat, OR, amel if ((OR >= (amel[self.amel]+1)*self.prix) and (amel[self.amel] < self.max)): OR -= (amel[self.amel]+1)*self.prix #A changer stat[self.amel] += self.up amel[self.amel] += 1 self.maj() __main__.menu.majPerso() __main__.menu.majOR()
class QCAT_Auto(Frame): def __init__(self, master=None): self.cur_dir = os.getcwd() Frame.__init__(self, master) self.master = master window_width = 460 window_heigh = 510 x_pos = (screen_width / 2) - (window_width / 2) y_pos = (screen_heigh / 2) - (window_heigh / 2) # self.master.geometry("420x200") self.master.geometry('%dx%d+%d+%d' % (window_width, window_heigh, x_pos, y_pos)) self.master.title("QCAT Automation") ###################################################################################################### self.config_file_PATH_label = Label(self.master, text="4G Config file path") self.config_file_PATH_label.grid(row=0, column=0, sticky=W, pady=2) self.config_file_PATH_txt = Text(self.master, heigh=1, width=35) self.config_file_PATH_txt.grid(row=0, column=1, pady=2) self.config_file_PATH_label_5g = Label(self.master, text="5G Config file path") self.config_file_PATH_label_5g.grid(row=1, column=0, sticky=W, pady=2) self.config_file_5g_PATH_txt = Text(self.master, heigh=1, width=35) self.config_file_5g_PATH_txt.grid(row=1, column=1, pady=2) self.raw_log_file_PATH_label = Label(self.master, text="Raw Log file path") self.raw_log_file_PATH_label.grid(row=3, column=0, sticky=W, pady=2) self.raw_log_file_PATH_txt = Text(self.master, heigh=1, width=35) self.raw_log_file_PATH_txt.grid(row=3, column=1, pady=2) # self.qcat_input_label = Label(self.master, text = '') self.log_type_label = Label(self.master, text="Information") self.log_type_label.grid(row=3, column=0, sticky=W) self.log_type_txt = ScrolledText(self.master, undo=True, width=55) self.log_type_txt.grid(row=4, rowspan=4, column=0, columnspan=3, sticky=W) self.QCAT_txt_dir_label = Label(self.master, text="QCAT Output\nDirectory") self.QCAT_txt_dir_label.grid(row=9, column=0, sticky=W) self.QCAT_txt_dir_txt = Text(self.master, heigh=1, width=35) self.QCAT_txt_dir_txt.grid(row=9, rowspan=2, column=0, columnspan=3, padx=80, sticky=W) ###################################################################################################### self.Import_txt_button = Button(self.master, text='Import to txt', command=self.call_import_txt) self.Import_txt_button.grid(row=9, column=1, columnspan=3, sticky=E, pady=2, padx=3) self.Import_txt_button.config(width=10, heigh=2) self.extract_config_button = Button(self.master, text="Extract", state=DISABLED, command=self.call_extract) self.extract_config_button.grid(row=0, column=2, sticky=E, padx=4) # self.view_log_button = Button(self.master, text = "View") # self.view_log_button.grid(row=1, column=2, sticky=E, padx=4) ############################################################################### # creating a menu instance self.menu = Menu(self.master) self.master.config(menu=self.menu) # create the file object) self.file = Menu(self.menu) # adds a command to the menu option, calling it exit, and the # command it runs on event is client_exit # self.file.add_command(label="QCAT Automation", command = self.openQCAT) self.file.add_command(label="Open 4G Config", command=self.open_config) self.file.add_command(label="Open 5G Config", command=self.open_config_5g) self.file.add_command(label="Open Raw Log", command=self.open_raw_log) self.file.add_command(label="Set Output Directory", command=self.set_output_directory) self.file.add_command(label="Exit", command=self.client_exit) self.menu.add_cascade(label="File", menu=self.file) # menu.add_cascade(label="Open config", menu=file) self.edit = Menu(self.menu) self.menu.add_cascade(label="Edit", menu=self.edit) self.help = Menu(self.menu) self.help.add_command(label="About", command=self.show_about) self.help.add_command(label="Instruction", command=self.show_instruction) self.menu.add_cascade(label="Help", menu=self.help) #################################################################################### def client_exit(self): exit() def is_uniconfig(self): if self.config_file_PATH_txt.get( '1.0', END) != '\n' and self.config_file_5g_PATH_txt.get( '1.0', END) != '\n': self.config_file_5g_PATH_txt.delete("1.0", "end") return False else: return True def open_config(self): ###Test # global config_file_PATH # config_file_PATH = r'G:\PycharmProjects\Log_Extractor\parser.cfg' filename = askopenfilename(initialdir=self.cur_dir, title="Select file", filetypes=(("config file", "*.cfg"), ("all files", "*.*"))) if filename: global QCAT_config_file_PATH QCAT_config_file_PATH = filename print(QCAT_config_file_PATH) # self.update_text() self.config_file_PATH_txt.delete("1.0", "end") self.config_file_5g_PATH_txt.delete("1.0", "end") self.config_file_PATH_txt.insert(END, QCAT_config_file_PATH) self.extract_config_button.config(state=NORMAL) else: showerror("Error", "No file selected") if self.is_uniconfig() == False: showerror("Error", "Cannot choose more than one config file!!!") def open_config_5g(self): ###Test # global config_file_PATH # config_file_PATH = r'G:\PycharmProjects\Log_Extractor\parser.cfg' if self.cur_dir == None: self.cur_dir = os.getcwd() filename = askopenfilename(initialdir=self.cur_dir, title="Select file", filetypes=(("config file", "*.cfg"), ("all files", "*.*"))) if filename: global config_file_PATH config_file_PATH = filename print(config_file_PATH) # self.update_text() self.config_file_PATH_txt.delete("1.0", "end") self.config_file_5g_PATH_txt.delete("1.0", "end") self.config_file_5g_PATH_txt.insert(END, config_file_PATH) self.extract_config_button.config(state=NORMAL) else: showerror("Error", "No file selected") if self.is_uniconfig() == False: showerror("Error", "Cannot choose more than two config files!!!") def open_raw_log(self): # Test # global log_file_PATH # log_file_PATH = r'G:\PycharmProjects\Log_Extractor\Test\log_test.txt' log_path = askopenfilenames(initialdir=self.cur_dir, title="Select file", filetypes=(("raw log file", "*.qmdl *.dlf *.isf"), ("dlf file", "*.dlf"), ("all files", "*.*"))) if log_path: global QCAT_raw_log_file_PATH # QCAT_raw_log_file_PATH = log_path for path in log_path: QCAT_raw_log_file_PATH.append(path) # print(log_path) self.raw_log_file_PATH_txt.delete("1.0", "end") self.raw_log_file_PATH_txt.insert(END, QCAT_raw_log_file_PATH) else: showerror("Error", "No file selected") def set_output_directory(self): csv_dir = askdirectory() if csv_dir: global QCAT_output_directory QCAT_output_directory = csv_dir self.QCAT_txt_dir_txt.delete("1.0", "end") self.QCAT_txt_dir_txt.insert(END, csv_dir) else: showerror("Error", "No directory selected") ##Test' # global csv_folder_PATH # csv_folder_PATH = r'C:\Users\Admin\Desktop\test' def change_file_name(self, log_path, exported_path): """Change exported file name from 'analyzer'.txt to 'log_analyser.txt'""" from tool_summary import is_file_exist if not is_file_exist(exported_path): return False if log_path.find('/'): split_log_path = log_path.split('/') log_name = split_log_path[-1].split('.')[ 0] # remove file extension, Ex. '.txt' exported_path = exported_path.replace('\\', '/') if exported_path.find('/'): cur_dir = os.getcwd() short_dir = exported_path.split( cur_dir) # Get short path from current directory split_exported_path = short_dir[1].split('/') exported_name = split_exported_path[-1] # Get file name if log_name and exported_name: new_path = os.path.join(*split_exported_path[:-1], log_name + '_' + exported_name) if not is_file_exist(new_path): os.rename(exported_path, new_path) return True return False def call_extract(self): global QCAT_config_file_PATH global QCAT_log_list_brief, QCAT_log_list_full, grids try: self.log_type_txt.delete("1.0", "end") self.log_type_txt.insert(END, "Extracting...\n") lines = read_file(QCAT_config_file_PATH) QCAT_log_list_brief, QCAT_log_list_full, grids = read_config_log_types( lines) if len(QCAT_log_list_brief) != 0: # self.log_type_txt.delete("1.0", "end") self.log_type_txt.insert(END, '\n#Packets\n') for log in QCAT_log_list_brief: self.log_type_txt.insert(END, log + '\n') if len(grids) != 0: self.log_type_txt.insert(END, '\n#Grids\n') for grid in grids.keys(): self.log_type_txt.insert(END, grid + '\n') self.log_type_txt.insert(END, "\nExtract successfully!!!\n") # showinfo("Respond", "Extract successfully") else: showwarning("Config Empty", "No log type found in config file. Try again!") except: # self.log_type_txt.delete("1.0", "end") self.log_type_txt.insert(END, "Error extracting\n") def call_import_txt(self): global QCAT_raw_log_file_PATH, QCAT_output_directory, QCAT_log_list_brief, grids self.log_type_txt.insert(END, "Importing! Please wait...\n") if QCAT_raw_log_file_PATH == '' or QCAT_output_directory == '' or len( QCAT_log_list_brief) == 0: self.log_type_txt.insert( END, "Error, Please check raw log path, output directory and config file\n" ) try: QCAT_Execute(QCAT_raw_log_file_PATH, QCAT_log_list_brief, QCAT_output_directory) # Export all grids according to analyzers in configuration file #TODO : Put import on the top from QCAT_Lib.QCAT_Basic import qcat_export_grids from tool_summary import path_to_outfile qcat_export_grids(QCAT_raw_log_file_PATH, grids.values(), QCAT_output_directory) # Change exported file name for grid in grids.keys(): outfile_path = path_to_outfile(grid) self.change_file_name(QCAT_raw_log_file_PATH, outfile_path) self.log_type_txt.insert(END, "Import successful") except: self.log_type_txt.insert(END, "Error importing\n") # def openQCAT(self): # self.newWindow = Toplevel(self.master) # self.app = QCAT_Auto(self.newWindow) def show_instruction(self): pass def show_about(self): pass
class GameScreen: def __init__(self, master, params, model=None): self.master = master self.controller = GameScreenController(params, model=model) self.width = self.controller.model.width self.height = self.controller.model.height self.graphic_init() self.is_run = True self.run() def draw(self): # Сделать 4 солнца model = self.controller.model x, y = model.sun_x, model.sun_y suns = [(x, y), (x - self.width, y), (x, y - self.height), (x - self.width, y - self.height)] for x, y in suns: self.canvas.create_rectangle( max(0, x), max(0, y), min(x + model.sun_size, self.width + 1), min(y + model.sun_size, self.height + 1), fill="yellow", ) for coord, creature in model.creatures.items(): color = "#00{:0>2}00".format(hex(int(creature.life * 255))[2:]) if not creature.alive: color = "red" func = self.canvas.create_oval func(coord[0], coord[1], coord[0] + 6, coord[1] + 6, fill=color) def graphic_init(self): self.frame = Frame(self.master, bd=2) self.button_frame = Frame(self.frame, bd=2) self.button_frame.grid_bbox(row=1, column=4) self.start_stop_button = Button(self.button_frame, text="Пауза", command=self.start_stop_pressed) self.start_stop_button.grid(row=1, column=2) self.save_button = Button(self.button_frame, text="Сохранить", command=self.save_pressed) self.save_button.grid(row=1, column=1) self.info_button = Button(self.button_frame, text="Инфо", command=self.info_pressed, state=DISABLED) self.info_button.grid(row=1, column=4) self.add_button = Button(self.button_frame, text="Добавить существо", command=self.add_pressed) self.add_button.grid(row=1, column=3) self.canvas = Canvas(self.frame, width=self.width, height=self.height) self.canvas.pack(side=TOP) self.button_frame.pack() self.frame.pack() def start_stop_pressed(self): self.is_run = not self.is_run self.start_stop_button.config(text="Пауза" if self.is_run else "Старт") self.info_button.config(state=DISABLED if self.is_run else ACTIVE) self.run() def save_pressed(self): filename = asksaveasfilename(title="Сохранить мир") if filename: try: self.controller.save_pressed(filename) except Exception as e: messagebox.showerror("Не удалось сохранить файл", str(e)) def info_pressed(self): InfoWindow(self.controller.model) def add_pressed(self): self.controller.add_pressed() def run(self): if self.is_run: self.canvas.delete("all") self.controller.run() self.draw() self.master.after(1, self.run)
class Main(): def __init__(self, parent, CPU_object): # Set up the basic variables and the frame self.cpu = CPU_object self.parent = parent self.parent.title("Main") self.frame = Frame(parent) self.frame.config(pady = 10) self.running = True self.reg_list = RegisterListener(self.update_regs) # Set up the label at the top self.label = Label(self.frame, text = "Registers: ") self.label.grid(row = 0, columnspan = 2) # Set up the labels and text-boxes for the registers self.register_text = [] self.register_label = [] # A loop for setting the registers text boxes and labels for x in range(11): # Use tricky-tricks to not have to write in the values for the labels label_text = REV_VALUES[x] + ": " if x > 7: label_text = REV_VALUES[x + 19] + ": " self.register_label.append(Label(self.frame, text = label_text)) self.register_text.append(Entry(self.frame, width = 25)) self.register_label[x].grid(row = x + 1, column = 0) self.register_text[x].grid(row = x + 1, column = 1) #Set up the buttons into the frame self.monitor_button = Button(self.frame, text = "Open monitor", width = 25, command = self.open_monitor) self.watcher_button = Button(self.frame, text = "Open watcher", width = 25, command = self.open_watcher) self.run_button = Button(self.frame, text = "Run program", width = 25, command = self.run_program) self.step_button = Button(self.frame, text = "Step program", width = 25, command = self.step_program) self.stop_button = Button(self.frame, text = "Stop program", width = 25, command = self.stop_program) # Pack the buttons self.monitor_button.grid(row = 12, columnspan = 2) self.watcher_button.grid(row = 13, columnspan = 2) self.run_button.grid(row = 14, columnspan = 2) self.step_button.grid(row = 15, columnspan = 2) self.stop_button.grid(row = 16, columnspan = 2) # Pack the frame self.frame.pack() # Handle the closing event (unregister the event listener) self.parent.protocol("WM_DELETE_WINDOW", self.handle_close) def step_program(self): # Step through the program and update the registers self.cpu.step() time.sleep(0.1) # Disable the buttons for step/run if len(self.cpu.text) == self.cpu.PC: self.step_button.config(state = DISABLED) self.run_button.config(state = DISABLED) def run(self): while(len(self.cpu.text) != self.cpu.PC and self.running): self.step_program() def stop_program(self): self.running = False def run_program(self): self.running = True t = threading.Thread(target=self.run) t.start() # self.run() def update_text(self, obj, text): # Update the text in an Entry object obj.delete(0, END) obj.insert(0, text) def update_regs(self, data): # Update the general registers for i, reg in enumerate(self.cpu.regs): self.update_text(self.register_text[i], hex(reg)) # Update SP, PC, and O self.update_text(self.register_text[8], hex(self.cpu.SP)) self.update_text(self.register_text[9], hex(self.cpu.PC)) self.update_text(self.register_text[10], hex(self.cpu.O)) def handle_close(self): self.reg_list.unregister() self.parent.quit() def open_watcher(self): self.watcher_window = Toplevel(self.parent) self.app = MemoryWatcher(self.watcher_window) def open_monitor(self): # Open the monitor self.monitor_window = Toplevel(self.parent) self.app = Monitor(self.monitor_window)
class myFirstGUI: def __init__(self, master): self.master = master self.my_blue_button = "#006a9b" self.background = "#4E4E50" master.title = ("Aquisição de dados") self.my_blue = "#13E7EB" #flag for HRV bar movement self.active = False self.increase = True self.background_label = Label(master, background=self.background) self.background_label.place(x=0, y=0, relwidth=1, relheight=1) self.title_string = StringVar() self.title_string.set("Bem-vindo!") self.title_w = Label(self.background_label, textvariable=self.title_string, font=("Helvetica", 30), foreground="#ffffff", background=self.background) self.title_w.place(relx=0.5, rely=0.3, anchor="center") self.instruction_string = StringVar() self.instruction_string.set( "O teste irá começar em breve. Por favor aguarde") self.instruction_label = Label(self.background_label, textvariable=self.instruction_string, font=("Helvetica", 18), foreground="#ffffff", background=self.background) self.instruction_label.place(relx=0.5, rely=0.4, anchor="center") self.button_string = StringVar() self.button_string.set("Clique para começar!") self.next_button = Button(self.background_label, textvariable=self.button_string, font=("Helvetica", 14), foreground="#ffffff", background=self.my_blue_button) self.next_button.config(width=len("Clique para começar!") + 2) self.next_button['command'] = lambda: self.start_callback() self.next_button.place(relx=0.5, rely=0.5, anchor="center") def start_callback(self): #create timestamps objects, to store all the relevant times self.experimentTimestamps = experimentTimeObject( time.perf_counter(), datetime.now(), time.time()) #change layout for heart rate variability instructions self.title_w.place_forget() self.title_string.set("Variabilidade da Frequência Cardíaca\n") self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.instruction_string.set( "No ecrã seguinte será apresentada uma animação. Tente que o seu padrão respiratório siga a animação. \n\n Tente manter-se relaxado.\n" ) self.button_string.set("Entendi") self.next_button['command'] = lambda: self.start_hrv_test() self.next_button.place(relx=0.5, rely=0.6) def start_hrv_test(self): self.experimentTimestamps.add_entry("t2", time.perf_counter()) #call function that skips one minute, to measure stuff at baseline self.my_yellow = "#F5F50F" #update HRV bar movement flag self.active = True self.baseline = True self.breathing_instruction = StringVar() self.breathing_instruction.set("INSPIRE") #Add key to skip HRV part of the test. If the user presses the "s" key, it will go to the next part of the test self.master.bind("<s>", self.start_pvt) #variables that define the interval between consecutive breathings and experiment duration self.total_duration = 4 * 60 #total time of 5 minutes, expressed in seconds self.breathing_interval = 5 #means that patient should inspire for 5 seconds, and expire for 5 seconds. 10 seconds total breathing intervals #hide previous layout self.instruction_label.place_forget() self.next_button.place_forget() self.title_w.place_forget() self.background_label.place_forget() self.background_label.place(x=0, y=0, relwidth=1, relheight=1) #add title again self.title_w.place(relx=0.5, rely=0.2, anchor="center") #draw background rectangle self.static_width = 800 self.rectangle = Canvas(self.background_label, bg=self.background, width=self.static_width, height=150) self.rectangle.place(relx=0.5, rely=0.4, anchor="center") #draw first moving rectangle self.variable_width = 0 self.rectangle_variable = Canvas(self.rectangle, bg=self.my_yellow, width=self.variable_width, height=150) self.rectangle_variable.place(relx=0, rely=0) #draw first breathing instruction self.instruction_widget = Label( self.background_label, textvariable=self.breathing_instruction, font=("Helvetica", 65), background=self.background, foreground=self.my_yellow) self.instruction_widget.place(relx=0.5, rely=0.65, anchor="center") #measure initial time self.initial_time = time.time() #call meque no botãthod that will start iterative updates self.master.bind("<d>", self.delete_this) #delete this!! self.move_rectangle() def hrv_clear_rectangles(self): #this function was developed later, that's why it's not used everywhere self.rectangle.place_forget() self.rectangle_variable.place_forget() self.instruction_widget.place_forget() self.title_w.place_forget() def hrv_place_rectangles(self): self.background_label.place(x=0, y=0, relwidth=1, relheight=1) self.rectangle.place(relx=0.5, rely=0.4, anchor="center") self.instruction_widget.place(relx=0.5, rely=0.65, anchor="center") self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.rectangle_variable.place(relx=0, rely=0) def rectangle_update(self): actual_time = time.time() #Decision if rectangle should grow or get smaller depends on 3 factors: time is an independent one and should be verified here. #The others factors are width below 0 or above 800. Any of these events will shift the direction of growth. if actual_time - self.iteration_start_time > 5: self.iteration_start_time = time.time() if self.increase: self.increase = False #update instruction widget self.breathing_instruction.set("EXPIRE") self.instruction_widget.place_forget() self.instruction_widget.config(foreground=self.my_blue) self.instruction_widget.place(relx=0.5, rely=0.65, anchor="center") self.title_w.place_forget() self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.rectangle_variable.config(bg=self.my_blue) else: self.increase = True #update instruction widget self.breathing_instruction.set("INSPIRE") self.instruction_widget.place_forget() self.instruction_widget.config(foreground=self.my_yellow) self.instruction_widget.place(relx=0.5, rely=0.65, anchor="center") self.title_w.place_forget() self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.rectangle_variable.config(bg=self.my_yellow) #Either way, increase or decrease is proportional to time left for 5 seconds if (self.increase): self.rectangle_variable.place_forget() #width increase self.variable_width = (self.static_width / self.breathing_interval) * ( actual_time - self.iteration_start_time) #Shift growth direction if self.variable_width > 800: self.variable_width = 800 self.increase = False self.iteration_start_time = time.time() #update instruction widget self.breathing_instruction.set("INSPIRE") self.instruction_widget.place_forget() self.instruction_widget.config(foreground=self.my_yellow) self.instruction_widget.place(relx=0.5, rely=0.65, anchor="center") self.title_w.place_forget() self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.rectangle_variable.config(bg=self.my_yellow) else: #width decrease self.variable_width = self.static_width - ( (self.static_width / self.breathing_interval) * (actual_time - self.iteration_start_time)) #shift growth direction if self.variable_width < 0: self.variable_width = 0 self.increase = True self.iteration_start_time = time.time() #update instruction widget self.breathing_instruction.set("EXPIRE") self.instruction_widget.place_forget() self.instruction_widget.config(foreground=self.my_blue) self.instruction_widget.place(relx=0.5, rely=0.65, anchor="center") self.title_w.place_forget() self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.rectangle_variable.config(bg=self.my_blue) #call functions to draw the new rectangle self.rectangle_variable.place_forget() self.rectangle_variable.config(width=self.variable_width) self.rectangle_variable.place(relx=0, rely=0) #after the update, check if the total experiment time was acchieved if actual_time - self.initial_time > self.total_duration: #move on to next test. Call method that starts PVT self.active = False self.start_pvt() def layout_baseline(self): #clear layout self.hrv_clear_rectangles() #set new layout self.title_w.place(relx=0.5, rely=0.20, anchor="center") #self.title_w.config self.relaxation_widget = Label(self.background_label, text="TENTE PERMANECER RELAXADO.", font=("Helvetica", 30), background=self.background, foreground=self.my_yellow) self.relaxation_widget2 = Label( self.background_label, text="IREMOS COMEÇAR DENTRO DE APROXIMADAMENTE UM MINUTO.", font=("Helvetica", 22), background=self.background, foreground=self.my_yellow) self.relaxation_widget.place(relx=0.5, rely=0.40, anchor="center") self.relaxation_widget2.place(relx=0.5, rely=0.65, anchor="center") def delete_this(self, event=None): self.initial_time = time.time() - 50 def move_rectangle(self): now = time.time() if self.active: if (now - self.initial_time) < 60: #the first minute is just to measure baseline and relax if self.baseline == True: self.layout_baseline() self.baseline = False else: if self.baseline == False: self.relaxation_widget.place_forget() self.relaxation_widget2.place_forget() self.hrv_clear_rectangles() self.hrv_place_rectangles() self.baseline = True #this is just to not verify this condition anymore. this will only run one time, and it's to set the first layout... self.iteration_start_time = time.time() self.rectangle_update() self.call_identifier = self.master.after(20, self.move_rectangle) def start_pvt(self, event=None): self.experimentTimestamps.add_entry("t3", time.perf_counter()) #make sure that hrv part has finished self.active = False #associate <s> key to skip this part of the test #self.master.bind("<s>", *nextmethod*) #clear screen self.rectangle.place_forget() self.rectangle_variable.place_forget() self.instruction_widget.place_forget() self.title_w.place_forget() self.relaxation_widget.place_forget() self.relaxation_widget2.place_forget() #set new title and instruction self.title_string.set("Tempo de Reação") self.instruction_string.set( "No ecrã seguinte, será apresentado um rectângulo de cor verde. \n Sempre que a cor mudar para vermelho, clique no botão esquerdo do rato.\n\n Caso tenha alguma questão, não hesite em perguntar." ) self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.instruction_label.place(relx=0.5, rely=0.4, anchor="center") self.next_button['command'] = lambda: self.pvt_test() self.next_button.place(relx=0.5, rely=0.60, anchor="center") def pvt_test(self): self.experimentTimestamps.add_entry("t4", time.perf_counter()) self.pvt_tries = 5 self.pvt_counter = 0 self.pvt_active = False self.pvt_green = "#20E820" self.pvt_red = "#ED1F1F" self.switch_time = {'0': 5, '1': 7, '2': 3, '3': 10, '4': 5} #associate <s> key to skip pvt test self.master.bind("<s>", self.signature_instruction_layout) #bind mouse1 to click self.master.bind("<Button-1>", self.pvt_click_detected) #configure screen layout self.next_button.place_forget() self.instruction_label.place_forget() self.title_w.place_forget() self.pvt_box = Canvas(self.background_label, bg=self.pvt_green, width=800, height=300) self.pvt_box.place(relx=0.5, rely=0.4, anchor="center") self.breathing_instruction.set("PREPARE-SE") self.instruction_widget.config(foreground=self.my_yellow, font=("Helvetica", 50)) self.instruction_widget.place(relx=0.5, rely=0.70, anchor="center") self.title_w.place(relx=0.5, rely=0.10, anchor="center") self.pvt_iteration_start_time = time.perf_counter() #get things rolling self.pvt_iteration() def pvt_iteration(self): if self.pvt_counter < 5: self.pvt_update() else: self.signature_instruction_layout() def pvt_update(self): time_dif = time.perf_counter() - self.pvt_iteration_start_time if time_dif >= self.switch_time[str(self.pvt_counter)]: self.title_w.place_forget() self.title_w.place(relx=0.5, rely=0.1, anchor="center") self.instruction_widget.place_forget() self.instruction_widget.place(relx=0.5, rely=0.70, anchor="center") self.pvt_active = True self.pvt_box.place_forget() self.pvt_box.config(bg=self.pvt_red) self.pvt_box.place(relx=0.5, rely=0.4, anchor="center") self.reaction_ini_time = time.perf_counter() else: if self.pvt_counter < 5: self.call_identifier = self.master.after(10, self.pvt_update) def pvt_click_detected(self, event=None): self.reaction_end_time = time.perf_counter() if self.pvt_active == False: #user clicked on mouse1 before the correct time #maybe display saying something like: chillout or a buzzing noise self.pvt_iteration_start_time = time.perf_counter() self.reaction_end_time = None self.experimentTimestamps.add_entry("PVT_MISTAKE", "MISTAKE") else: self.reaction_time = self.reaction_end_time - self.reaction_ini_time print('Reaction time number ', self.pvt_counter) self.experimentTimestamps.add_entry( "reaction_" + str(self.pvt_counter), str(self.reaction_time)) self.experimentTimestamps.add_entry( "t4" + str(2 * self.pvt_counter), self.reaction_ini_time) self.experimentTimestamps.add_entry( "t4" + str(2 * self.pvt_counter + 1), self.reaction_end_time) #restore control variables and layout self.title_w.place_forget() self.title_w.place(relx=0.5, rely=0.1, anchor="center") self.pvt_box.place_forget() self.pvt_box.config(bg=self.pvt_green) self.pvt_box.place(relx=0.5, rely=0.4, anchor="center") self.instruction_widget.place_forget() self.instruction_widget.place(relx=0.5, rely=0.70, anchor="center") self.pvt_active = False self.pvt_counter = self.pvt_counter + 1 self.pvt_iteration_start_time = time.perf_counter() self.pvt_iteration() def signature_instruction_layout(self, event=None): self.experimentTimestamps.add_entry("t5", time.perf_counter()) #control variables for this test self.number_signatures = 5 self.signature_counter = 0 #disable old flags self.pvt_active = False self.pvt_counter = 10 #just to be higher than 5, it's not necessary probably #unbind self.master.unbind("<Button-1>") self.master.unbind("<s>") #clear window self.title_w.place_forget() self.pvt_box.place_forget() self.instruction_widget.place_forget() self.next_button.place_forget() #set new layout self.title_string.set("Assinatura") self.instruction_string.set( "Nesta parte receberá uma folha em branco, que deverá assinar " + repr(self.number_signatures) + " vezes.\n\n De cada vez que terminar uma assinatura, deverá parar e clicar num botão de contagem que estará na página seguinte. \n\n Caso tenha alguma questão não hesite em perguntar." ) self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.instruction_label.place(relx=0.5, rely=0.4, anchor="center") self.next_button['command'] = lambda: self.signature_test() self.next_button.place(relx=0.5, rely=0.6, anchor="center") def signature_test(self): self.experimentTimestamps.add_entry("t6", time.perf_counter()) #change layout self.instruction_label.place_forget() self.title_w.place_forget() self.instruction_string.set( "Deve incrementar o contador abaixo sempre que terminar uma assinatura." ) self.breathing_instruction.set("NÚMERO DE ASSINATURAS OBTIDAS: " + repr(self.signature_counter)) self.button_string.set("Incrementar") self.instruction_widget.config(fg=self.pvt_green, font=("Helvetica", 40)) self.next_button['command'] = lambda: self.signature_increment() self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.instruction_label.place(relx=0.5, rely=0.3, anchor="center") self.instruction_widget.place(relx=0.5, rely=0.5, anchor="center") self.next_button.place(relx=0.5, rely=0.7, anchor="center") def signature_increment(self): self.experimentTimestamps.add_entry("t6" + str(self.signature_counter), time.perf_counter()) self.signature_counter = self.signature_counter + 1 self.clear_screen() self.breathing_instruction.set("NÚMERO DE ASSINATURAS OBTIDAS: " + repr(self.signature_counter)) self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.instruction_label.place(relx=0.5, rely=0.3, anchor="center") self.instruction_widget.place(relx=0.5, rely=0.5, anchor="center") self.next_button.place(relx=0.5, rely=0.7, anchor="center") if self.signature_counter == self.number_signatures: #call next method self.cognitive_tests_layout() def cognitive_tests_layout(self): self.experimentTimestamps.add_entry("t7", time.perf_counter()) #clear screen self.clear_screen() self.title_string.set("Trail Making Test - Parte A") self.instruction_string.set( "Nesta parte irá receber uma folha que contém diversas bolas numeradas. \n\n O objetivo é unir as diversas bolas de forma sequencial, o mais rapidamente possível e sem cometer erros. \n\n Caso tenha alguma dúvida não hesite em perguntar." ) self.button_string.set("Começar") self.next_button['command'] = lambda: self.start_trail_making_a() self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.instruction_label.place(relx=0.5, rely=0.4, anchor="center") self.next_button.place(relx=0.5, rely=0.6, anchor="center") def start_trail_making_a(self): self.experimentTimestamps.add_entry("t8", time.perf_counter()) self.clear_screen() self.instruction_string.set( "Quando terminar o teste, clique no botão abaixo.") self.button_string.set("Terminado") self.next_button['command'] = lambda: self.prepare_trail_making_b() self.add_common_widgets() self.ini_time_tma = datetime.now() def prepare_trail_making_b(self): self.experimentTimestamps.add_entry("t9", time.perf_counter()) self.end_time_tma = datetime.now() dif = self.end_time_tma - self.ini_time_tma print("TRAIL MAKING A: Demorou " + repr(dif.seconds) + " a completar a primeira parte do teste.") self.clear_screen() self.title_string.set("Trail Making Test - Parte B") self.instruction_string.set( "Nesta parte irá receber uma folha que contém diversas bolas, com números ou letras. \n\n O objetivo é unir as diversas bolas de forma sequencial, o mais rapidamente possível e sem cometer erros. \n \n Tenha em consideração que por exemplo a letra B é equivalente ao número 2. \n\n Caso tenha alguma dúvida não hesite em perguntar." ) self.button_string.set("Começar") self.next_button['command'] = lambda: self.start_trail_making_b() self.add_common_widgets() def start_trail_making_b(self): self.experimentTimestamps.add_entry("t10", time.perf_counter()) self.clear_screen() self.instruction_string.set( "Quando terminar o teste, clique no botão abaixo.") self.button_string.set("Terminado") self.next_button['command'] = lambda: self.store_end_time_tmb() self.add_common_widgets() self.ini_time_tmb = datetime.now() def store_end_time_tmb(self): self.experimentTimestamps.add_entry("t11", time.perf_counter()) self.end_time_tmb = datetime.now() dif = self.end_time_tmb - self.ini_time_tmb print("TRAIL MAKING B: Demorou " + repr(dif.seconds) + " a completar a primeira parte do teste.") self.physical_tests_layout() def physical_tests_layout(self): self.clear_screen() self.title_string.set("Testes físico") self.instruction_string.set( "Para esta parte deverá colocar a pulseira no seu braço não dominante. \n\n De seguida será explicado os exercícios que deverá efectuar." ) self.button_string.set("Iniciar") self.next_button['command'] = lambda: self.start_physical_tests() self.add_common_widgets() def start_physical_tests(self): self.experimentTimestamps.add_entry("t12", time.perf_counter()) self.ini_time_physical = datetime.now() self.physical_tests_counter = 0 self.number_physical_tests = 5 self.clear_screen() self.breathing_instruction.set("NÚMERO DE VOLTAS TERMINADAS: " + repr(self.physical_tests_counter)) self.instruction_string.set( "Clique no botão abaixo sempre que uma volta for completada") self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.instruction_label.place(relx=0.5, rely=0.3, anchor="center") self.instruction_widget.place(relx=0.5, rely=0.5, anchor="center") self.next_button.place(relx=0.5, rely=0.7, anchor="center") self.button_string.set("Incrementar") self.next_button['command'] = lambda: self.physical_increment() #self.add_common_widgets() def physical_increment(self, event=None): self.experimentTimestamps.add_entry( "t12" + str(self.physical_tests_counter), time.perf_counter()) self.physical_tests_counter = self.physical_tests_counter + 1 self.clear_screen() self.breathing_instruction.set("NÚMERO DE VOLTAS TERMINADAS: " + repr(self.physical_tests_counter)) self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.instruction_label.place(relx=0.5, rely=0.3, anchor="center") self.instruction_widget.place(relx=0.5, rely=0.5, anchor="center") self.next_button.place(relx=0.5, rely=0.7, anchor="center") if self.physical_tests_counter == self.number_physical_tests: #call next method self.store_end_time_physical() def store_end_time_physical(self): self.experimentTimestamps.add_entry("t13", time.perf_counter()) self.end_time_physical = datetime.now() dif1 = self.end_time_physical - self.ini_time_physical self.thank_you_layout() def thank_you_layout(self): self.clear_screen() self.title_string.set("Muito obrigado pelo seu contributo!") self.button_string.set("Exportar dados") self.next_button['command'] = lambda: self.export_time_intervals() self.title_w.place(relx=0.5, rely=0.5, anchor="center") self.next_button.place(relx=0.5, rely=0.7, anchor="center") #ADD LOGOS OF ISR and HBA def export_time_intervals(self): #prompt for patient name in self.patient_name = input("Escreva o nome do paciente: ") filename = self.patient_name + "_" + str( self.experimentTimestamps.epoch) filename = filename.replace(" ", "_") filename = filename.replace(":", "-") filename = filename.replace(".", "-") print("Name of file %s", filename) with open(filename + '.json', "w") as fp: json.dump(self.experimentTimestamps.stamp_dict, fp) def add_common_widgets(self): self.title_w.place(relx=0.5, rely=0.2, anchor="center") self.instruction_label.place(relx=0.5, rely=0.4, anchor="center") self.next_button.place(relx=0.5, rely=0.6, anchor="center") def clear_screen(self): self.title_w.place_forget() self.instruction_label.place_forget() self.next_button.place_forget() self.instruction_widget.place_forget()
def refreshWidget(self) : #print "refresh" self.card_win.pack_forget() import unicodedata #Card window self.card_win = PanedWindow(self.card_win.master, orient=VERTICAL) self.card_win.pack(side=TOP, expand=True, fill=BOTH, pady=2, padx=2) #Create the name zone name_zone=PanedWindow(self.card_win, orient=HORIZONTAL) name = StringVar() name.set(self.name) def modifName(*args) : try : assert('"' not in name.get()) name.get().encode('ascii') except Exception as e: print ("error on name") name.set(self.name) return old = self.name in Card.blocked_creature self.name=name.get() if old or self.name in Card.blocked_creature : self.refreshWidget() name.trace("w", modifName) name_wid=Entry(name_zone, width=30,textvariable=name) name_wid.pack() name_zone.add(name_wid) #Create the cost ad star stringvar #print int(floor(self.getCost())) self.cost=StringVar() self.stars=StringVar() cost_wid=Label(None, textvariable=self.cost, background='red',width=5, anchor=W) star_wid=Label(None, textvariable=self.stars, background='blue', anchor=E) self.cost.set(str(int(floor(self.getCost())))) self.stars.set("*"*self.getStars()) #Add them in name zone name_zone.add(cost_wid) name_zone.add(star_wid) #Create an Image Zone image_zone=Button(self.card_win, command=self.choosePhoto) if hasattr(self,"photofile") and self.photofile : print ("Image: ",self.photofile) try : pilImage=Image.open(self.photofile) img=PhotoImage(pilImage,master=image_zone) except : decomp=self.photofile.split('/') for i in range(1,6) : try : fname="/".join(decomp[-i:]) print ("try to open",fname) pilImage = Image.open(fname) img=PhotoImage(pilImage,master=image_zone) self.photofile=fname break except : self.photofile=None if self.photofile : w, h = img.width(), img.height() print('wh',w,h) if h>400 : print("reduction") img=PhotoImage(pilImage.resize((w//2,h//2), Image.ANTIALIAS),master=image_zone) image_zone=Button(self.card_win,image=img, command=self.choosePhoto) image_zone.image=img #image_zone.configure(image=image_zone.image,width=50,height=50,compound=RIGHT) #image_zone.pack() #print "IMAGE CHANGED" else : from os import path fname=self.name.replace(" ","_") if path.isfile("Cards/"+fname+".png") : image_zone.config(text='image can be taken from\n'+"Cards/"+fname+".png",background='white',anchor=CENTER) else : image_zone.config(text='clic to choose image',background='white',anchor=CENTER) #image_zone.pack() # POWER ZONE power_zone=PanedWindow(self.card_win, orient=VERTICAL) #fenetre=self.card_win.master def removePowerCreator(px) : def removePower(*args) : #print 'avant',list_pow self.bonus.remove(px) #print 'apres',list_pow #self.card_win.pack_forget() self.refreshWidget() return removePower for p in self.bonus : powline = PanedWindow(self.card_win, orient=HORIZONTAL) pow_wid=p.initWidget(powline) powline.add(pow_wid) removepow=Button(powline, text="X", command=removePowerCreator(p), anchor=E) removepow.pack() powline.add(removepow) power_zone.add(powline) def addPower(*args) : if addBonus.get()!= "add bonus": name=addBonus.get() else: name=add_cost_alteration.get() print ("added :",name) import CardPowers self.bonus+=[eval('CardPowers.'+name+'()')] self.bonus[-1].parent=self.bonus self.bonus[-1].card=self #self.card_win.pack_forget() self.refreshWidget() #Add bonus Option menu addBonus = StringVar(power_zone) addBonus.set("add bonus") # default value if not self.pv: addBonus_wid = Spell.getSpellMenu(power_zone, addBonus) else: addBonus_wid = getBonusMenu(power_zone, addBonus) addBonus.trace('w', addPower) if self.pv>0 or len(self.bonus)==0 or all([b.is_cost_alterator for b in self.bonus]): addBonus_wid.pack() #Add this to power zone power_zone.add(addBonus_wid) #Create save zone save_zone = PanedWindow(self.card_win, orient=HORIZONTAL) if self.monster_type != "all" and not(self.name in Card.blocked_creature) : save_wid = Button(save_zone, text="Save", command=self.postAndSave) elif self.monster_type != "all" : save_wid = Button(save_zone, text="creature in campaign", command=None) else: save_wid = Button(save_zone, text="nead type", command=None) save_wid.pack() #Create the open button save_zone.pack() if Card.monster_list.keys(): self.opening = StringVar(save_zone) self.opening.set("Open") choice = [na for na in Card.monster_list.keys() if na not in Card.blocked_creature] choice.sort() #print all_monsters.keys() open_wid = OptionMenu(save_zone, self.opening,*choice) self.opening.trace('w', self.Open) open_wid.pack() save_zone.add(open_wid) if Card.monster_list.keys(): self.delete = StringVar(save_zone) self.delete.set("Delete") choice = [na for na in Card.monster_list.keys() if na not in Card.blocked_creature] choice.sort() delete_wid = OptionMenu(save_zone, self.delete,*choice) self.delete.trace('w', self.clicDelete) delete_wid.pack() save_zone.add(delete_wid) #Create the type button self.category = StringVar(save_zone) self.category.set(self.monster_type) choice = [file2name(t,"_monsters.sav") for t in glob.glob("CardFiles/*_monsters.sav")] if "recup" in choice: choice.remove("recup") #print all_monsters.keys() category_wid = OptionMenu(save_zone, self.category,*choice) self.category.trace('w', self.setFile) category_wid.pack() #Add it to save zone save_zone.add(save_wid) save_zone.add(category_wid) #Create a new Strength zone for att and pv strength_zone=PanedWindow(self.card_win, orient=HORIZONTAL) att=StringVar() att.set(str(self.att)) pv=StringVar() ; pv.set(str(self.pv)) def modifiedAttPv(*args) : print ("modifiedAttPv") self.pv=int(pv.get()) if self.pv<1 and self.is_spell==False : if len(self.bonus)==0 : self.is_spell=True self.refreshWidget() else : self.pv=1 self.refreshWidget() if self.pv>0 and self.is_spell==True : if len(self.bonus)==0 : self.is_spell=False self.refreshWidget() else : self.pv=0 self.refreshWidget() self.att=int(att.get()) self.getCost() att_wid = Spinbox(strength_zone, from_=0, to=1000,textvariable=att,command=modifiedAttPv) att_wid.pack() strength_zone.add(att_wid) strength_zone.add(Label(strength_zone, text=' ', background='white', anchor=CENTER)) pv_wid = Spinbox(strength_zone, from_=0, to=1000,textvariable=pv,command=modifiedAttPv) pv_wid.pack() strength_zone.add(pv_wid) #Put it all in window self.card_win.add(name_zone) self.card_win.add(image_zone) self.card_win.add(power_zone) self.card_win.add(strength_zone) self.card_win.add(save_zone) self.card_win.pack()
addClassButton = Button(bottomFrame, text="Add class", fg="green", command=lambda: getCRN()) addClassButton.grid(row=1, column=2) userInfo = Label(bottomFrame, text="Your Villanova email is: " + usernameEntry.get()) userInfo.grid(columnspan=2) crnInfo = Label(bottomFrame, text="Your desired CRN is: " + crnEntry.get()) crnInfo.grid(columnspan=2) registerMe = Button(bottomFrame, text="Register me", fg="green", command=lambda: retrieve.registration(crnEntry.get(), usernameEntry.get())) registerMe.grid(row=5, column=5) if crnInfo['text'] == "Your desired CRN is: " and userInfo['text'] == "Your Villanova email is: ": registerMe.config(state="disabled") def check(): if crnInfo['text'] == "Your desired CRN is: " or userInfo['text'] == "Your Villanova email is: ": registerMe.config(state="disabled") else: registerMe.config(state="active") registerMe["command"] = lambda: retrieve.registration(crnEntry.get(), usernameEntry.get()) e = ttk.Progressbar(bottomFrame, orient=HORIZONTAL, length=200) e.grid(row=5, column=1) master.mainloop()
class MainWindow: def __init__(self): global root self.http_session = requests.Session() self.http_session.headers.update(HEADERS) self.menu_bar = Menu(root) self.menu_bar.add_command(label="Back", command=self.back_in_history) self.menu_bar.add_command(label="Toggle image", command=self.toggle_image) hist_menu = Menu(self.menu_bar, tearoff=0) hist_menu.add_command(label="All time", command=lambda: self.show_full_history(ALL_TIME)) hist_menu.add_command(label="Last day", command=lambda: self.show_full_history(DAY)) hist_menu.add_command(label="Two days", command=lambda: self.show_full_history(TWO_DAYS)) hist_menu.add_command(label="Week", command=lambda: self.show_full_history(WEEK)) hist_menu.add_command(label="Month", command=lambda: self.show_full_history(MONTH)) hist_menu.add_command( label="Three months", command=lambda: self.show_full_history(THREE_MONTHS)) self.menu_bar.add_cascade(label="History", menu=hist_menu) root.config(menu=self.menu_bar) self.session = None self.show_image = False self.hist_window = None self.proxies = None self.model_name = None self.update_title() self.level = 0 self.image_label = Label(root) self.level += 1 self.cb_model = ttk.Combobox(root, width=60) self.cb_model.bind("<FocusIn>", self.focus_callback) self.cb_model.bind("<Button-1>", self.drop_down_callback) self.cb_model.bind('<Return>', self.enter_callback) self.cb_model.focus_set() self.cb_model.grid(row=self.level, column=0, columnspan=4, sticky=W + E, padx=PAD, pady=PAD) self.btn_remove = Button(root, text="-", command=self.remove_from_favorites) self.btn_remove.grid(row=self.level, column=4, sticky=W + E, padx=PAD, pady=PAD) self.level += 1 self.btn_update = Button(root, text="Update info", command=lambda: self.update_model_info(True)) self.btn_update.grid(row=self.level, column=0, sticky=W + E, padx=PAD, pady=PAD) self.cb_resolutions = ttk.Combobox(root, state="readonly", values=[]) self.cb_resolutions.grid(row=self.level, column=1, columnspan=4, sticky=W + E, padx=PAD, pady=PAD) self.cb_resolutions['values'] = ['1080', '720', '480', '240'] self.level += 1 self.btn_show_recording = Button(root, text="Show recording model", command=self.show_recording_model, state=DISABLED) self.btn_show_recording.grid(row=self.level, column=0, sticky=W + E, padx=PAD, pady=PAD) self.use_proxy = BooleanVar() self.use_proxy.set(False) self.use_proxy.trace('w', self.on_use_proxy_change) self.chk_use_proxy = Checkbutton(root, text='Use proxy', variable=self.use_proxy) self.chk_use_proxy.grid(row=self.level, column=1, sticky=W, padx=PAD, pady=PAD) self.cb_proxy = ttk.Combobox(root, width=30, state=DISABLED) self.cb_proxy.grid(row=self.level, column=2, columnspan=3, sticky=W + E, padx=PAD, pady=PAD) self.level += 1 self.btn_start = Button(root, text="Start", command=self.on_btn_start) self.btn_start.grid(row=self.level, column=0, sticky=W + E, padx=PAD, pady=PAD) self.btn_stop = Button(root, text="Stop", command=self.on_btn_stop, state=DISABLED) self.btn_stop.grid(row=self.level, column=1, sticky=W + E, padx=PAD, pady=PAD) self.copy_button = Button(root, text="Copy", command=self.copy_model_name) self.copy_button.grid(row=self.level, column=2, sticky=W + E, padx=PAD, pady=PAD) self.paste_button = Button(root, text="Paste", command=self.paste_model_name) self.paste_button.grid(row=self.level, column=3, columnspan=2, sticky=W + E, padx=PAD, pady=PAD) self.level += 1 self.progress = ttk.Progressbar(root, orient=HORIZONTAL, length=120, mode='indeterminate') root.bind("<FocusIn>", self.focus_callback) root.protocol("WM_DELETE_WINDOW", self.on_close) self.play_list_url = None self.base_url = None self.model_image = None self.img_url = None self.hist_logger = logging.getLogger('history') self.hist_logger.setLevel(logging.INFO) self.fh_hist = logging.FileHandler( os.path.join(LOGS, f'hist_{int(time.time())}.log')) self.fh_hist.setLevel(logging.INFO) self.hist_logger.addHandler(self.fh_hist) self.proxy_logger = logging.getLogger('proxy') self.proxy_logger.setLevel(logging.INFO) self.fh_proxy = logging.FileHandler( os.path.join(LOGS, f'proxy_{int(time.time())}.log')) self.fh_proxy.setLevel(logging.INFO) self.proxy_logger.addHandler(self.fh_proxy) self.proxy_dict = {} self.load_proxy_dict() self.hist_stack = [] self.load_image() def on_btn_start(self): self.btn_start.config(state=DISABLED) self.stop() idx = self.cb_resolutions.current() success = self.update_model_info(True) if not success: self.set_default_state() return items_count = len(self.cb_resolutions['value']) if items_count == 0: return if items_count <= idx or idx < 0: idx = 0 self.cb_resolutions.current(idx) self.session = RecordSession(self, self.base_url, self.model_name, "chunks.m3u8") self.session.start() self.btn_stop.config(state=NORMAL) self.btn_show_recording.config(state=NORMAL) self.progress.grid(row=self.level, column=0, columnspan=5, sticky=W + E, padx=PAD, pady=PAD) self.progress.start() self.update_title() root.configure(background='green') def on_btn_stop(self): self.stop() self.set_default_state() def stop(self): if self.session is None: return self.session.stop() self.session = None def copy_model_name(self): clipboard.copy(self.cb_model.get()) def paste_model_name(self): self.cb_model.set(clipboard.paste()) self.cb_model.selection_range(0, END) def update_model_info(self, remember): if remember and (self.model_name is not None): if len(self.hist_stack) == 0 or (self.model_name != self.hist_stack[-1]): self.hist_stack.append(self.model_name) self.set_undefined_state() input_url = self.cb_model.get().strip() if len(input_url) == 0: self.set_undefined_state() return False proxy = self.cb_proxy.get().strip() if self.use_proxy.get() and len(proxy.strip()) != 0: self.proxies = { "http": "http://" + proxy, "https": "https://" + proxy } else: self.proxies = None ## https://live-edge66.bcvcdn.com/hls/stream_-icebabyice-/public/stream_-icebabyice-/chunks.m3u8 ## https://live-edge3.bcvcdn.com/hls/stream_TemariShi/public-aac/stream_TemariShi/chunks.m3u8 self.base_url = None if input_url.startswith('https://ded'): public_pos = input_url.rfind('public') self.base_url = input_url[:public_pos + 7] stream_pos = self.base_url.find('stream_') slash_pos = self.base_url.find('/', stream_pos) self.model_name = self.base_url[stream_pos + 7:slash_pos] elif input_url.startswith('https://live-edge'): slash_pos = input_url[:-1].rfind('/') self.base_url = input_url[:slash_pos + 1] stream_pos = self.base_url.find('stream_') slash_pos = self.base_url.find('/', stream_pos) self.model_name = self.base_url[stream_pos + 7:slash_pos] elif input_url.startswith('http'): slash_pos = input_url[:-1].rfind('/') self.model_name = input_url[slash_pos + 1:-1] if input_url.endswith( '/') else input_url[slash_pos + 1:] else: self.model_name = input_url if self.base_url is None: info = self.get_model_info() print(info) if 'localData' not in info: self.set_undefined_state() return False server_url = info['localData']['videoServerUrl'] self.model_name = info['performerData']['username'] self.cb_resolutions.set(info['performerData']['videoQuality']) self.base_url = f"https:{server_url}/hls/stream_{self.model_name}/public-aac/stream_{self.model_name}/" if self.use_proxy.get() and len(proxy) != 0: self.add_to_proxies(proxy) self.get_image_url() self.add_to_history(self.model_name) self.update_title() return True def add_to_history(self, name): if name not in self.cb_model['values']: self.cb_model['values'] = (name, *self.cb_model['values']) self.hist_logger.info(name) def remove_from_favorites(self): name = self.cb_model.get().strip() values = list(self.cb_model['values']) if name not in values: return values.remove(name) self.cb_model['values'] = tuple(values) if len(values) == 0: self.cb_model.set('') else: self.cb_model.set(values[0]) def add_to_proxies(self, proxy): if len(self.cb_proxy['values']) == 0: self.cb_proxy['values'] = proxy elif proxy not in self.cb_proxy['values']: self.cb_proxy['values'] = (proxy, *self.cb_proxy['values']) self.proxy_logger.info(proxy) count = self.proxy_dict.get(proxy, 0) self.proxy_dict[proxy] = count + 1 def focus_callback(self, event): self.cb_model.selection_range(0, END) if self.hist_window is not None: self.hist_window.lift() def drop_down_callback(self, event): self.cb_model.focus_set() self.cb_model.selection_range(0, END) self.cb_model.event_generate('<Down>') def enter_callback(self, event): self.update_model_info(True) def get_image_url(self): edge_pos = self.base_url.find('-edge') point_pos = self.base_url.find('.', edge_pos) # hyphen_pos = self.base_url.find('-', edge_pos + 1) # if point_pos > hyphen_pos: # point_pos = hyphen_pos vsid = self.base_url[edge_pos + 5:point_pos] self.img_url = f"https://mobile-edge{vsid}.bcvcdn.com/stream_{self.model_name}.jpg" def get_model_info(self): post_fields = { 'method': 'getRoomData', 'args[]': [self.model_name, "", ""] } headers = { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8', 'X-Requested-With': 'XMLHttpRequest' } try: response = self.http_session.post( "https://rt.chat-s-devushkami.com/tools/amf.php?x-country=a1", data=post_fields, headers=headers, proxies=self.proxies, timeout=TIMEOUT) except RequestException as error: print("GetRoomData exception model: " + self.model_name) print(error) traceback.print_exc() return {} return response.json() def load_image(self): global executor global root if (self.img_url is not None) or self.show_image: executor.submit(self.fetch_image) root.update_idletasks() root.after(DELAY, self.load_image) def fetch_image(self): global root try: response = self.http_session.get(self.img_url, timeout=TIMEOUT) img = Image.open(io.BytesIO(response.content)) w, h = img.size k = 200 / w img_resized = img.resize((200, int(h * k))) root.after_idle(self.update_image, img_resized) except BaseException as error: root.after_idle(self.set_undefined_state) print("Exception URL: " + self.img_url) print(error) traceback.print_exc() def update_image(self, img): self.model_image = ImageTk.PhotoImage(img) self.image_label.config(image=self.model_image) def on_close(self): global root self.stop() root.update_idletasks() root.destroy() self.fh_hist.close() self.hist_logger.removeHandler(self.fh_hist) self.fh_proxy.close() self.proxy_logger.removeHandler(self.fh_proxy) self.http_session.close() def set_default_state(self): global root self.session = None self.btn_stop.config(state=DISABLED) self.btn_start.config(state=NORMAL) self.btn_show_recording.config(state=DISABLED) self.progress.stop() self.progress.grid_forget() self.update_title() root.configure(background='SystemButtonFace') def update_title(self): global root root.title(self.model_name or '<Undefined>') if self.session is None: return if not self.session.is_alive(): return if self.session.model_name != root.title(): return root.title(root.title() + " - Recording") def set_undefined_state(self): self.model_image = None self.image_label.config(image=None) self.model_name = None self.img_url = None self.update_title() def show_recording_model(self): if self.session is None: return self.cb_model.set(self.session.model_name) self.cb_model.selection_range(0, END) self.update_model_info(True) def on_use_proxy_change(self, *args): if self.use_proxy.get(): self.cb_proxy.config(state=NORMAL) self.cb_proxy.focus_set() self.cb_proxy.selection_range(0, END) else: self.cb_proxy.config(state=DISABLED) def toggle_image(self): if self.show_image: self.model_image = None self.image_label.config(image=None) self.img_url = None self.image_label.grid_forget() self.show_image = False else: self.show_image = True self.image_label.grid(row=0, column=0, columnspan=5, sticky=W + E, padx=PAD, pady=PAD) self.update_model_info(True) def show_full_history(self, period): if self.hist_window is not None: self.hist_window.on_close() self.hist_window = HistoryWindow(self, Toplevel(root), load_hist_dict(period)) def back_in_history(self): if len(self.hist_stack) == 0: return self.cb_model.set(self.hist_stack.pop()) self.update_model_info(False) def load_proxy_dict(self): for file in os.listdir(LOGS): if not file.startswith('proxy_'): continue full_path = os.path.join(LOGS, file) if os.path.getsize(full_path) == 0: continue with open(full_path) as f: for line in f.readlines(): name = line.strip() count = self.proxy_dict.get(name, 0) self.proxy_dict[name] = count + 1 hist = sorted(self.proxy_dict.items(), key=lambda x: x[1], reverse=True) self.cb_proxy.configure(values=[x[0] for x in hist[:10]])
class Home: """This is the class which makes the app grid screen - If you log in with correct password""" AFTER = None def __init__(self, a=""): global truth global background global home global welcome_screen self.time1 = "" self.a = a home = Tk() home.title("Home") home.geometry(WINDOW_DIM) home.resizable(False, False) home.config(bg=background) home.lift() home.attributes("-topmost", True) self.clock = Label( home, font=("TIMES NEW ROMAN", 10), anchor="e", bg="black", fg="white", width=46, height=2, ) # clock label self.clock.place(x=0, y=0) self.tick1() wel1 = Label( home, text="Here are your apps", bg="black", fg="white", width=46, height=1, font=("century", 9), ) wel1.place(x=-23, y=45) if self.a == "y": truth = False welcome_screen.after_cancel(tick) welcome_screen.destroy() welcome_screen = None else: pass """App buttons""" sett = Button( home, text="Settings", height=5, bg="sky blue", fg="brown", width=10, font=("Bahnschrift", 12), command=self.settings, ) # settings button sett.place(x=2, y=100) calcbtn = Button( home, text="Calculator", height=5, width=10, bg="grey", fg="black", font=("Bahnschrift", 12), command=self.calc, ) # calculator button calcbtn.place(x=112, y=100) design = Button( home, text="Designs", height=5, width=10, bg="purple", fg="cyan", font=("Bahnschrift", 12), command=self.design, ) # design button design.place(x=222, y=100) notepad = Button( home, text="Notepad", height=5, width=10, bg="orange", fg="black", font=("Bahnschrift", 12), command=self.notepad, ) # notepad button notepad.place(x=2, y=250) click = Button( home, text="Click \n Game", height=5, width=10, bg="blue", fg="pink", font=("Bahnschrift", 12), command=self.click_game, ) # click test button click.place(x=112, y=250) sample = Button( home, text="Sample \n Pictures", height=5, width=10, bg="red", fg="yellow", font=("Bahnschrift", 12), command=self.sample, ) # sample pictures button sample.place(x=222, y=250) lock = Button( home, text="LOCK", bg="black", fg="yellow", command=welcome ) # lock button lock.place(x=143, y=368) home.mainloop() def tick1(self): """Clock""" global home time2 = strftime("%H:%M") newday = time2.split(":") if newday[0] == "00" and newday[1] == "00": self.ddate = asctime().split() self.day = ( self.ddate[0] + " " + self.ddate[1] + " " + self.ddate[2] ) if time2 != self.time1: self.time1 = time2 self.clock.config(text=day + " " + time2 + " ") try: Home.AFTER = home.after(200, self.tick1) except Exception: home.after_cancel(Home.AFTER) self.ddate = asctime().split() self.day = self.ddate[0] + " " + self.ddate[1] + " " + self.ddate[2] global truth if truth: welcome_screen.after_cancel(tick) def settings(self): """Called when Settings button is pressed""" global background self.setwin = Tk() self.setwin.title("Settings") self.setwin.lift() self.setwin.attributes("-topmost", True) self.setwin.geometry(WINDOW_DIM) self.setwin.resizable(False, False) self.homebtn = Button( self.setwin, text="HOME", bg="black", fg="white", command=self.home_button7, ) self.homebtn.place(x=140, y=370) self.setwin.config(bg=background) global home home.after_cancel(Home.AFTER) home.destroy() self.ss = Label( self.setwin, text="Choose a setting:", bg="black", fg="white", width=46, height=2, font=("Arial", 15), ) self.ss.place(x=-90, y=0) self.changingbtn = Button( self.setwin, text="Change Password", height=1, bg="sky blue", fg="brown", width=25, font=("Bahnschrift", 12), command=self.change_password, ) self.changingbtn.place(x=45, y=100) self.var = StringVar(self.setwin) self.var.set(background) self.bglab = Label( self.setwin, text="Background colour:", bg=background, fg="black", font=("Arial", 10), ) self.bglab.place(x=100, y=178) self.option = OptionMenu( self.setwin, self.var, "yellow", "green", "light blue", "pink", "white", ) self.option.place(x=120, y=200) background = self.var.get() def save1(): global background background = self.var.get() with open("data/background.txt", "w") as file: file.write(background) self.sv = Button( self.setwin, text="Save", command=save1, bg="cyan", fg="black" ) self.sv.place(x=140, y=235) """NOT WORKING ON SOME DEVICES""" def click_game(self): """Calls when click button is pressed""" global background self.clickwin = Tk() self.clickwin.title("Click Game") self.clickwin.lift() self.clickwin.attributes("-topmost", True) self.clickwin.geometry(WINDOW_DIM) self.clickwin.resizable(False, False) self.n = 0 self.clickwin.config(bg="cyan") self.w = Label(self.clickwin, text="CLICK TEST!") self.w.config(bg="black", fg="white", font=("broadway", 30)) self.w.pack(side=TOP) self.bt2 = Button( self.clickwin, text="Start timer", height="3", width="8", command=self.timer, ) self.bt2.config(bg="red") self.bt2.pack() self.tt = Label(self.clickwin) self.tt.pack() self.bt = Button( self.clickwin, text="CLICK!", height="10", width="20", state=DISABLED, command=self.number, ) self.bt.config(bg="yellow") self.bt.pack() self.ans = Label(self.clickwin) self.ans.pack() self.res = Label( self.clickwin, text=" " ) self.res.config( bg="dark green", fg=background, font=("arial narrow", 15) ) self.res.pack() self.bt3 = Button( self.clickwin, text="Reset", height="5", width="8", command=self.reset, ) self.bt3.pack(side=RIGHT) global home home.after_cancel(Home.AFTER) home.destroy() self.homebtn = Button( self.clickwin, text="HOME", bg="black", fg="white", command=self.home_button4, ) self.homebtn.place(x=140, y=370) self.clickwin.mainloop() def timer(self): self.bt2.config(state=DISABLED) self.homebtn.config(state=DISABLED) self.bt3.config(state=DISABLED) self.bt.config(state="normal") self.func1() def number(self): self.n += 1 self.ans.config(text=self.n) def reset(self): self.homebtn.config(state="normal") self.bt2.config(state="normal") self.bt.config(state=DISABLED) self.res["text"] = " " self.ans.config(text="0") self.n = 0 self.tt.config(text="Reset") def func1(self): # try: self.t = threading.Thread(target=self.func2) self.t.start() # except: # pass def func2(self): for i in range(0, 10): self.tt.config(text=10 - i) sleep(1) self.bt.config(state=DISABLED) self.tt.config(text="Time up") self.bt3.config(state="normal") if self.n < 50: self.res["text"] = ( str(self.n) + " clicks in 10 seconds: Bad clicker!" ) elif 50 <= self.n and self.n < 60: self.res["text"] = ( str(self.n) + " clicks in 10 seconds: Average clicker!" ) elif self.n >= 60 and self.n < 70: self.res["text"] = ( str(self.n) + " clicks in 10 seconds: Master clicker!" ) elif self.n >= 70: self.res["text"] = ( str(self.n) + " clicks in 10 seconds: Clicking god!" ) def notepad(self): """Called when notepad button is pressed""" global background self.notepad = Tk() self.notepad.title("Notepad") f = open("data/notes.txt", "r+") t = f.read() self.notepad.lift() self.notepad.attributes("-topmost", True) self.notepad.geometry(WINDOW_DIM) self.notepad.resizable(False, False) self.notepad.config(bg="purple") global home home.after_cancel(Home.AFTER) home.destroy() self.homebtn = Button( self.notepad, text="HOME", bg="black", fg="white", command=self.home_button3, ) self.homebtn.place(x=140, y=370) self.notes = Text( self.notepad, width=53, height=18, font=("Times New Roman", 10) ) self.notes.place(x=1, y=60) self.notes.insert(END, t) self.head = Label( self.notepad, text="NOTEPAD", bg=background, width=23, fg="purple", font=("Arial black", 15), ) self.head.place(x=0, y=10) self.sav = Button(self.notepad, text="Save", command=self.save) self.sav.place(x=146, y=340) def save(self): self.text = self.notes.get(0.0, END) with open("data/notes.txt", "w") as file: file.write(self.text) def sample(self): """Called when Sample pictures button is pressed""" global background global home home.after_cancel(Home.AFTER) home.destroy() self.samwin = Tk() self.samwin.title("Sample Pictures") self.samwin.lift() self.samwin.attributes("-topmost", True) self.samwin.geometry(WINDOW_DIM) self.samwin.resizable(False, False) self.samwin.config(bg="black") self.homebtn = Button( self.samwin, text="HOME", bg="white", fg="black", command=self.home_button6, ) self.homebtn.place(x=140, y=370) self.img = PhotoImage(file="sample_pictures/sample1.gif") self.pics = Label( self.samwin, width=325, image=self.img, bg="black", height=300 ) self.pics.place(x=0, y=0) self.nxt = Button( self.samwin, text=">", bg="yellow", font=("Bauhaus 93", 20), command=self.nxtfun, ) self.nxt.place(x=280, y=310) self.bck = Button( self.samwin, text="<", bg="yellow", font=("Bauhaus 93", 20), command=self.bckfun, state=DISABLED, ) self.bck.place(x=10, y=310) self.i = 1 self.samwin.bind("<Left>", self.lkey) self.samwin.bind("<Right>", self.rkey) def lkey(self, event): if self.i != 1: self.bckfun() def rkey(self, event): if self.i != 10: self.nxtfun() def nxtfun(self): self.i += 1 self.bck["state"] = "normal" if self.i == 1: self.img = PhotoImage(file="sample_pictures/sample1.gif") self.bck["state"] = DISABLED elif self.i == 2: self.img = PhotoImage(file="sample_pictures/sample2.gif") elif self.i == 3: self.img = PhotoImage(file="sample_pictures/sample3.gif") elif self.i == 4: self.img = PhotoImage(file="sample_pictures/sample4.gif") elif self.i == 5: self.img = PhotoImage(file="sample_pictures/sample5.gif") elif self.i == 6: self.img = PhotoImage(file="sample_pictures/sample6.gif") elif self.i == 7: self.img = PhotoImage(file="sample_pictures/sample7.gif") elif self.i == 8: self.img = PhotoImage(file="sample_pictures/sample8.gif") elif self.i == 9: self.img = PhotoImage(file="sample_pictures/sample9.gif") elif self.i == 10: self.img = PhotoImage(file="sample_pictures/sample10.gif") self.nxt["state"] = DISABLED self.pics["image"] = self.img def bckfun(self): self.i -= 1 self.nxt["state"] = "normal" if self.i == 1: self.img = PhotoImage(file="sample_pictures/sample1.gif") self.bck["state"] = DISABLED elif self.i == 2: self.img = PhotoImage(file="sample_pictures/sample2.gif") elif self.i == 3: self.img = PhotoImage(file="sample_pictures/sample3.gif") elif self.i == 4: self.img = PhotoImage(file="sample_pictures/sample4.gif") elif self.i == 5: self.img = PhotoImage(file="sample_pictures/sample5.gif") elif self.i == 6: self.img = PhotoImage(file="sample_pictures/sample6.gif") elif self.i == 7: self.img = PhotoImage(file="sample_pictures/sample7.gif") elif self.i == 8: self.img = PhotoImage(file="sample_pictures/sample8.gif") elif self.i == 9: self.img = PhotoImage(file="sample_pictures/sample9.gif") elif self.i == 10: self.img = PhotoImage(file="sample_pictures/sample10.gif") self.nxt["state"] = DISABLED self.pics["image"] = self.img def design(self): """Called when Designs button is pressed""" self.deswin = Tk() self.deswin.title("Designs") self.deswin.lift() self.deswin.attributes("-topmost", True) self.deswin.geometry(WINDOW_DIM) self.deswin.resizable(False, False) self.deswin.config(bg="black") global home home.after_cancel(Home.AFTER) home.destroy() self.homebtn = Button( self.deswin, text="HOME", bg="white", fg="black", command=self.home_button2, ) self.homebtn.place(x=140, y=370) self.choo = Label( self.deswin, text="Choose a design:", bg="black", fg="white", width=28, height=2, font=("Candara", 15), ) self.choo.place(x=0, y=10) self.des1 = Button( self.deswin, text="Design 1 ", font=("Elephant", 20), command=self.des1, ) self.des1.place(x=80, y=80) self.des2 = Button( self.deswin, text="Design 2", font=("Elephant", 20), command=self.des2, ) self.des2.place(x=80, y=150) self.des3 = Button( self.deswin, text="Design 3", font=("Elephant", 20), command=self.des3, ) self.des3.place(x=80, y=220) self.des4 = Button( self.deswin, text="Design 4", font=("Elephant", 20), command=self.des4, ) self.des4.place(x=80, y=290) def des1(self): self.deswin.destroy() self.deswin = Tk() self.deswin.title("Designs") self.deswin.lift() self.deswin.attributes("-topmost", True) self.deswin.geometry(WINDOW_DIM) self.deswin.config(bg="yellow") self.deswin.resizable(False, False) self.homebtn = Button( self.deswin, text="HOME", bg="black", fg="white", command=self.home_button2, ) self.homebtn.place(x=140, y=370) self.canvas = Canvas( master=self.deswin, width=325, height=350, bg="black" ) self.t = turtle.RawTurtle(self.canvas) self.canvas.place(x=0, y=0) colors = ["red", "purple", "blue", "green", "yellow", "orange"] self.t.speed(0) for x in range(160): self.t.pencolor(colors[x % 6]) self.t.width(x / 100 + 1) self.t.forward(x) self.t.left(59) def des2(self): self.deswin.destroy() self.deswin = Tk() self.deswin.title("Designs") self.deswin.lift() self.deswin.attributes("-topmost", True) self.deswin.geometry(WINDOW_DIM) self.deswin.resizable(False, False) self.deswin.config(bg="yellow") self.homebtn = Button( self.deswin, text="HOME", bg="black", fg="white", command=self.home_button2, ) self.homebtn.place(x=140, y=370) self.canvas = Canvas( master=self.deswin, width=325, height=350, bg="black" ) self.t = turtle.RawTurtle(self.canvas) self.canvas.place(x=0, y=0) for i in range(0, 24): self.t.speed(-9) self.t.right(46) self.t.pencolor("blue") self.t.circle(30) self.t.right(20) self.t.pencolor("green") self.t.circle(60) self.t.circle(70) self.t.pencolor("red") self.t.circle(55) self.t.circle(57) self.t.left(10) self.t.pencolor("yellow") self.t.right(5) def des3(self): self.deswin.destroy() self.deswin = Tk() self.deswin.title("Designs") self.deswin.lift() self.deswin.attributes("-topmost", True) self.deswin.geometry(WINDOW_DIM) self.deswin.resizable(False, False) self.deswin.config(bg="yellow") self.homebtn = Button( self.deswin, text="HOME", bg="black", fg="white", command=self.home_button2, ) self.homebtn.place(x=140, y=370) self.canvas = Canvas( master=self.deswin, width=325, height=350, bg="black" ) self.t = turtle.RawTurtle(self.canvas) self.canvas.place(x=0, y=0) for i in range(50): self.t.speed(20) self.t.pencolor("red") self.t.backward(100) self.t.pencolor("green") self.t.circle(30) self.t.right(70) def des4(self): self.deswin.destroy() self.deswin = Tk() self.deswin.title("Designs") self.deswin.lift() self.deswin.attributes("-topmost", True) self.deswin.geometry(WINDOW_DIM) self.deswin.resizable(False, False) self.deswin.config(bg="yellow") self.homebtn = Button( self.deswin, text="HOME", bg="black", fg="white", command=self.home_button2, ) self.homebtn.place(x=140, y=370) self.canvas = Canvas( master=self.deswin, width=325, height=350, bg="black" ) self.t = turtle.RawTurtle(self.canvas) self.canvas.place(x=0, y=0) self.t.speed(700) for i in range(180): self.t.forward(80) self.t.right(30) self.t.forward(20) self.t.left(60) self.t.forward(50) self.t.right(30) self.t.penup() self.t.setposition(0, 0) self.t.pendown() self.t.right(2) def calc(self): """Called when Calculator button is pressed""" try: global background self.calcwin = Tk() self.calcwin.title("Calculator") self.calcwin.lift() self.calcwin.attributes("-topmost", True) self.calcwin.geometry(WINDOW_DIM) self.calcwin.resizable(False, False) self.calcwin.config(bg=background) global home home.after_cancel(Home.AFTER) home.destroy() self.homebtn = Button( self.calcwin, text="HOME", bg="black", fg="white", command=self.home_button1, ) self.homebtn.place(x=140, y=370) self.num = Entry(self.calcwin, width=18, font=("Arial black", 20)) self.num.place(x=0, y=10) self.num.focus_set() self.ans = Label( self.calcwin, bg="light green", width=17, fg="black", font=("Arial black", 20), ) self.ans.place(x=0, y=60) self.plus_btn = Button( self.calcwin, text="+", font=("Elephant", 20), command=self.plus, ) self.plus_btn.config(width=3) self.plus_btn.place(x=0, y=120) self.calcwin.bind("+", self.plus) self.minus_btn = Button( self.calcwin, text="-", font=("Elephant", 20), command=self.minus, ) self.minus_btn.config(width=3) self.minus_btn.place(x=85, y=120) self.calcwin.bind("-", self.minus) self.mult_btn = Button( self.calcwin, text="x", font=("Elephant", 20), command=self.mult, ) self.mult_btn.config(width=3) self.mult_btn.place(x=170, y=120) self.calcwin.bind("*", self.mult) self.div_btn = Button( self.calcwin, text="/", font=("Elephant", 20), command=self.div ) self.div_btn.config(width=3) self.div_btn.place(x=255, y=120) self.calcwin.bind("/", self.div) self.sqroot_btn = Button( self.calcwin, text="sqrt", font=("Elephant", 20), command=self.sqroot, ) self.sqroot_btn.config(height=1, width=3) self.sqroot_btn.place(x=0, y=200) self.fact_btn = Button( self.calcwin, text="!", font=("Elephant", 20), command=self.fact, ) self.fact_btn.config(width=3) self.fact_btn.place(x=85, y=200) self.calcwin.bind("!", self.fact) self.power_btn = Button( self.calcwin, text="x^y", font=("Elephant", 20), command=self.power, ) self.power_btn.config(height=1, width=3) self.power_btn.place(x=170, y=200) self.calcwin.bind("^", self.power) self.clr_btn = Button( self.calcwin, text="C", font=("Elephant", 20), command=self.c ) self.clr_btn.config(height=1, width=3) self.clr_btn.place(x=255, y=200) self.calcwin.bind("<Delete>", self.c) self.calcwin.bind("c", self.c) self.sin_btn = Button( self.calcwin, text="sin", font=("Elephant", 20), command=self.sin, ) self.sin_btn.config(height=1, width=3) self.sin_btn.place(x=0, y=280) self.cos_btn = Button( self.calcwin, text="cos", font=("Elephant", 20), command=self.cos, ) self.cos_btn.config(height=1, width=3) self.cos_btn.place(x=85, y=280) self.tan_btn = Button( self.calcwin, text="tan", font=("Elephant", 20), command=self.tan, ) self.tan_btn.config(height=1, width=3) self.tan_btn.place(x=170, y=280) self.equal_btn = Button( self.calcwin, text="=", font=("Elephant", 20), command=self.equal, ) self.equal_btn.config(width=3) self.equal_btn.place(x=255, y=280) self.calcwin.bind("<Return>", self.equal) except TypeError: self.ans["text"] = "Invalid Input " except ValueError: self.ans["text"] = "Invalid Input " except OverflowError: self.ans["text"] = "Out of range" try: def plus(self, event=None): self.v = self.num.get() if "+" in self.v: self.a = self.v[:-1] else: self.a = self.v self.num.delete(0, END) self.num.focus_set() self.operator = "+" def minus(self, event=None): self.v = self.num.get() if "-" in self.v: self.a = self.v[:-1] else: self.a = self.v self.num.delete(0, END) self.num.focus_set() self.operator = "-" def mult(self, event=None): self.v = self.num.get() if "*" in self.v: self.a = self.v[:-1] else: self.a = self.v self.num.delete(0, END) self.num.focus_set() self.operator = "x" def div(self, event=None): self.v = self.num.get() if "/" in self.v: self.a = self.v[:-1] else: self.a = self.v self.num.delete(0, END) self.num.focus_set() self.operator = "/" def sqroot(self): try: self.a = self.num.get() if float(self.a) >= 0: self.ans["text"] = math.sqrt(float(self.a)) else: self.ans["text"] = "Not a real number" except ValueError: self.ans["text"] = "Invalid Input " except TypeError: self.ans["text"] = "Invalid Input " except OverflowError: self.ans["text"] = "Out of range" def fact(self, event=None): try: self.v = self.num.get() if "!" in self.v: self.a = self.v[:-1] else: self.a = self.v if int(self.a) >= 0: self.an = str(math.factorial(int(self.a))) self.ans["text"] = self.an if len(self.an) > 17: self.ans["text"] = "Out of Range" else: self.ans["text"] = "Error" except ValueError: self.ans["text"] = "Invalid Input " except TypeError: self.ans["text"] = "Invalid Input " except OverflowError: self.ans["text"] = "Out of range" def power(self, event=None): self.v = self.num.get() if "^" in self.v: self.a = self.v[:-1] else: self.a = self.v self.num.delete(0, END) self.num.focus_set() self.operator = "^" def sin(self): try: self.a = self.num.get() self.a = float(self.a) / 57.2958 self.an = str(math.sin(float(self.a))) self.ans["text"] = self.an if len(self.an) > 17: self.ans["text"] = "Out of Range" except ValueError: self.ans["text"] = "Invalid Input " except TypeError: self.ans["text"] = "Invalid Input " except OverflowError: self.ans["text"] = "Out of range" def cos(self): try: self.a = self.num.get() self.a = float(self.a) / 57.2958 self.an = str(math.cos(float(self.a))) self.ans["text"] = self.an if len(self.an) > 17: self.ans["text"] = "Out of Range" except ValueError: self.ans["text"] = "Invalid Input " except TypeError: self.ans["text"] = "Invalid Input " except OverflowError: self.ans["text"] = "Out of range" def tan(self): try: self.a = self.num.get() self.a = float(self.a) / 57.2958 self.an = str(math.tan(float(self.a))) self.ans["text"] = self.an if len(self.an) > 17: self.ans["text"] = "Out of Range" except ValueError: self.ans["text"] = "Invalid Input " except TypeError: self.ans["text"] = "Invalid Input " except OverflowError: self.ans["text"] = "Out of range" def c(self, event=None): """clear button for calculator""" self.a = 0 self.b = 0 self.num.delete(0, END) self.ans["text"] = "" def equal(self, event=None): try: self.b = self.num.get() if self.operator == "+": self.an = str(float(self.a) + float(self.b)) if len(self.an) < 17: self.ans["text"] = self.an else: self.ans["text"] = "Out of Range" elif self.operator == "-": self.an = str(float(self.a) - float(self.b)) if len(self.an) < 17: self.ans["text"] = self.an else: self.ans["text"] = "Out of Range" elif self.operator == "x": self.an = str(float(self.a) * float(self.b)) if len(self.an) < 17: self.ans["text"] = self.an else: self.ans["text"] = "Out of Range" elif self.operator == "^": self.an = str(math.pow(float(self.a), float(self.b))) if len(self.an) < 17: self.ans["text"] = self.an else: self.ans["text"] = "Out of Range" elif self.operator == "/": if float(self.b) != 0: self.an = str(float(self.a) / float(self.b)) if len(self.an) < 17: self.ans["text"] = self.an else: self.ans["text"] = "Out of Range" else: self.ans["text"] = "Not a number" except ValueError: self.ans["text"] = "Invalid Input " except TypeError: self.ans["text"] = "Invalid Input " except OverflowError: self.ans["text"] = "Out of range" except ValueError as e: self.ans["text"] = "Invalid Input " + e.message except TypeError as e: self.ans["text"] = "Invalid Input " + e.message except OverflowError: self.ans["text"] = "Out of range" def next(self): """Changing password""" global password if self.co == 1: self.next["text"] = "Next" self.prev = self.ent.get() self.k["text"] = " " if self.prev == password: self.co = 2 self.f = open("data/password.txt", "r+") self.ent.delete(0, END) self.ent.focus_set() self.lb["text"] = "Enter new password:"******"text"] = "Incorrect password, cannot change." self.k.place(x=0, y=260) self.next["text"] = "Retry" self.lb["text"] = "Enter previous password:"******"text"] = "Confirm new password:"******"data/password.txt", "wb") self.f.write(base64.b64encode(self.confirm.encode())) self.f.close() self.ent.delete(0, END) password = self.confirm self.lb["text"] = "Password changed!" self.k["text"] = "Password changed!" self.co = 1 else: self.k["text"] = "Passwords do not match, try again." self.k.place(x=0, y=260) self.next["text"] = "Retry" self.lb["text"] = "Enter previous password:"******"""Called when Change password button is pressed""" global password self.passwin = Tk() self.passwin.title("Settings") self.passwin.lift() self.passwin.attributes("-topmost", True) self.passwin.geometry(WINDOW_DIM) self.passwin.resizable(False, False) self.passwin.config(bg="light green") self.setwin.destroy() self.homebtn = Button( self.passwin, text="HOME", bg="black", fg="white", command=self.home_button5, ) self.homebtn.place(x=140, y=370) self.ent = Entry( self.passwin, show="*", width=18, font=("Arial black", 20) ) self.ent.place(x=0, y=100) self.next = Button( self.passwin, text="Next", bg="blue", fg="yellow", command=self.next, ) self.next.place(x=100, y=200) self.next.config(width=15) self.lb = Label( self.passwin, bg="light green", text="Enter previous password:"******"Georgia", 12), width=30, ) self.lb.place(x=20, y=70) self.k = Label( self.passwin, text="", bg="red", fg="pink", font=("Onyx", 20), width=40, ) self.k.place(x=0, y=260) self.show = Button( self.passwin, text="Show", bg="blue", fg="yellow", command=self.show, ) self.show.place(x=100, y=150) self.show.config(width=15) self.co = 1 self.sh = False def show(self): if not self.sh: self.ent["show"] = "" self.sh = True self.show.config(text="Hide") elif not self.sh: self.ent["show"] = "*" self.sh = False self.show.config(text="Show") def home_button1(self): """Home buttons for all screens""" global home_screen # home button for calculator self.calcwin.destroy() home_screen = Home() def home_button2(self): global home_screen # home button for design window self.deswin.destroy() home_screen = Home() def home_button3(self): global home_screen # home button for notepad window self.notepad.destroy() home_screen = Home() def home_button4(self): global home_screen # home button for click game window self.clickwin.destroy() home_screen = Home() def home_button5(self): global home_screen # home button for password change window self.passwin.destroy() home_screen = Home() def home_button6(self): global home_screen # home button for sample pictures window self.samwin.destroy() home_screen = Home() def home_button7(self): global home_screen # home button for settings window self.setwin.destroy() home_screen = Home()
class NumberConverterMasterFrame(Frame): def __init__(self, root): Frame.__init__(self, root) root.title("SeqPilot Order Number Fixer") self.parent = root self.initialize() # Initialize GUI elements def initialize(self): print('Setting up the GUI') # This is the directory the python executable is running from. FileAndPath = abspath(__file__) self.idir, self.ifile = split(FileAndPath) # GUI options #self.label_opt = {'fill': Tkconstants.BOTH, 'padx': 10, 'pady': 10} self.button_opt = {'fill': BOTH, 'padx': 50, 'pady': 15} # "Choose Directory" options change for windows and linux. In windows we want to default # to the swisslab directory. if (self.getPlatform() == 'Windows'): self.dir_opt = { 'initialdir': "Z:\\bin\\TalkMaster\\Output\\Swisslab", 'mustexist': True, 'parent': self, 'title': 'Choose a directory' } else: self.dir_opt = { 'initialdir': "/home", 'mustexist': True, 'parent': self, 'title': 'Choose a directory' } self.directoryFrame = self.makeDirectoryFrame() self.directoryFrame.pack() self.sampleFileFrame = self.makeSampleFileFrame() self.sampleFileFrame.pack() self.idChooserFrame = self.makeidChooserFrame() self.idChooserFrame.pack() self.pack() def makeDirectoryFrame(self): print('Setting up the directory Frame') chooseDirectoryFrame = Frame(self) self.chooseInputButton = Button(chooseDirectoryFrame, text='Kies Invoer Map', command=self.chooseInputDirectory) self.chooseInputButton.grid(row=0, column=0, sticky=W) #self.chooseOutputButton = Button(chooseDirectoryFrame, text='Choose Output Directory', # command=self.chooseReadOutputDirectory) #self.chooseOutputButton.grid(row=1, column=0, sticky=W) self.outputDirLabel = Label(chooseDirectoryFrame, text="Output Map:") self.outputDirLabel.grid(row=1, column=0) self.inputDirectoryText = StringVar() self.inputDirectoryText.set('Waar zitten de bestanden?') Entry(chooseDirectoryFrame, width=80, textvariable=self.inputDirectoryText).grid(row=0, column=1) self.outputDirectoryText = StringVar() self.outputDirectoryText.set('Output Map') Entry(chooseDirectoryFrame, width=80, textvariable=self.outputDirectoryText).grid(row=1, column=1) #self.outputDirEntry.config(state=DISABLED) return chooseDirectoryFrame def makeSampleFileFrame(self): print('Setting up the directory Frame') sampleFileFrame = Frame(self) self.fileFoundLabelText = StringVar() self.fileFoundLabelText.set("Kies een map.") self.fileFoundLabel = Label(sampleFileFrame, textvariable=self.fileFoundLabelText) self.fileFoundLabel.pack() return sampleFileFrame def makeidChooserFrame(self): print('Setting up the directory Frame') idChooserFrame = Frame(self) self.changeIDButton = Button(idChooserFrame, text='Verander ID in:', command=self.changeID, state=DISABLED) self.changeIDButton.grid(row=0, column=0, sticky=W) self.newIDEntryText = StringVar() self.newIDEntryText.trace_add("write", self.changeNewIDMethod) self.newIDEntryText.set( 'new_id' ) # Underscores arent allowed, but the callback should change this to "-" Entry(idChooserFrame, width=50, textvariable=self.newIDEntryText).grid(row=0, column=1) self.skipFileButton = Button(idChooserFrame, text='Bestand Overslaan: ', command=self.skipFile, state=DISABLED) self.skipFileButton.grid(row=1, column=0, sticky=W) self.stopButton = Button(idChooserFrame, text='Stoppen.', command=self.skipAllFiles, state=DISABLED) self.stopButton.grid(row=1, column=1, sticky=W) return idChooserFrame def changeNewIDMethod(self, *args): # This method triggers when the new ID changes. # might be hand-typed or come from input from the barcode scanner. # Either way we should never allow underscores in the ID. Change "_" to "-" # *args are 3 parameters about who sent the callback. Not really important to me. #print('These args passed into the callback: ' + str(args)) self.newIDEntryText.set(self.newIDEntryText.get().replace("_", '-')) # I borrowed this code from: # https://www.webucator.com/how-to/how-check-the-operating-system-with-python.cfm # Thanks Nat Dunn. def getPlatform(self): platforms = { 'linux1': 'Linux', 'linux2': 'Linux', 'darwin': 'OS X', 'win32': 'Windows' } if sys.platform not in platforms: return sys.platform return platforms[sys.platform] # chooseInputDirectory method is called when the user presses the input directory button def chooseInputDirectory(self): print('Choosing an input directory.') # File Dialog to get the new directory currentInputDirectory = filedialog.askdirectory(**self.dir_opt) # askdirectory returns an empty tuple when it fails. Why? that seems dumb. String when successful. if (currentInputDirectory == "" or currentInputDirectory == None or currentInputDirectory == ()): print( "Directory was not found, maybe you closed the window too early?" ) else: # Set the text object to new dir self.inputDirectoryText.set(normpath(currentInputDirectory)) self.fileList = listdir(currentInputDirectory) self.currentFileIndex = 0 print('These files found:' + str(self.fileList)) # Parse the path to generate the output directory. parentDir = abspath(join(currentInputDirectory, pardir)) leafDirName = basename(normpath(currentInputDirectory)) todaysDate = datetime.date.today().strftime('%Y%m%d') # print ('todays date is: ' + str(todaysDate)) currentOutputDirectory = join( parentDir, leafDirName + '_' + str(todaysDate) + '_fixed') self.outputDirectoryText.set(currentOutputDirectory) # If there are files in this directory if (len(self.fileList) > 0): # This output directory should exist if not exists(currentOutputDirectory): makedirs(currentOutputDirectory) # Change the GUI to not allow us to change the directory. Enable the ID buttons. self.chooseInputButton.config(state=DISABLED) # Present a file to the user. self.presentAFile() else: messagebox.showwarning( "No Files????", "There are no files in that directory. Try again.") def presentAFile(self): # Files Remaining? Nah I don't need to check i think. # Open File currentFile = self.fileList[self.currentFileIndex] currentFileFullPath = join(self.inputDirectoryText.get(), currentFile) with open(currentFileFullPath, 'r') as f: #reader = csv.reader(f, delimiter='\t') line = next(f) lineTokens = line.split('\t') # Get ID, it's the 2nd entry in a tab delimited file. self.oldSampleID = lineTokens[1] print('I found this sampleid:' + str(self.oldSampleID)) # Update Label with Instructions. Filename, ID number. self.fileFoundLabelText.set("(" + str(self.currentFileIndex + 1) + "/" + str(len(self.fileList)) + ") " + str(currentFile) + "\n" + "heeft ID " + str(self.oldSampleID) + "\n" + "Fix ID of Overslaan?") self.changeIDButton.config(state=NORMAL) self.skipFileButton.config(state=NORMAL) self.stopButton.config(state=NORMAL) # Update Suggested new ID number. self.newIDEntryText.set(self.oldSampleID) def changeID(self): print('Changing the ID') # Open Input File currentFileFullPath = join(self.inputDirectoryText.get(), self.fileList[self.currentFileIndex]) outputFileName = join(self.outputDirectoryText.get(), self.fileList[self.currentFileIndex]) outputFile = createOutputFile(outputFileName) newSampleID = self.newIDEntryText.get() print('Replacing old id ' + str(self.oldSampleID) + ' with new id ' + str(newSampleID)) with open(currentFileFullPath, 'r') as f: for line in f: newLine = line.replace(self.oldSampleID, newSampleID) outputFile.write(newLine) self.nextFilePlease() def skipFile(self): print('Skipping the File') # This method is just copying a file to the output directory. # Open Input File currentFileFullPath = join(self.inputDirectoryText.get(), self.fileList[self.currentFileIndex]) outputFileName = join(self.outputDirectoryText.get(), self.fileList[self.currentFileIndex]) outputFile = createOutputFile(outputFileName) with open(currentFileFullPath, 'r') as f: for line in f: outputFile.write(line) self.nextFilePlease() def skipAllFiles(self): while (self.currentFileIndex < len(self.fileList)): self.skipFile() def nextFilePlease(self): self.currentFileIndex += 1 # More files Remaining? # Get the next file in the list. if (self.currentFileIndex < len(self.fileList)): self.presentAFile() # Else? finish up else: self.fileFoundLabelText.set("Kies een map.") self.chooseInputButton.config(state=NORMAL) self.changeIDButton.config(state=DISABLED) self.skipFileButton.config(state=DISABLED) self.stopButton.config(state=DISABLED)
frame2 = Frame(root) frame3 = Frame(root) frame1.grid(column = 0, row = 0) signIn = Label(frame1, text = 'Sign In',fg = 'black',bg = 'tan', font = 'Arial 18 bold', padx =(50)) nameFL = Label(frame2, text = 'Name: ',fg = 'black',bg = 'tan', font = 'Arial 18 bold') password = Label(frame3, text = 'Password: '******'black',bg = 'tan', font = 'Arial 18 bold') entry1 = Entry(root, text='Name', width = 30) entry2 = Entry(root, show='*',text = 'Password', width = 30) frame1.grid(row=0, column = 0) frame2.grid(row=1) frame3.grid(row = 2) signIn.pack(side = 'top') nameFL.pack(side = 'top') entry1.grid(row=1, column = 1) password.pack(side = 'top') entry2.grid(row=2, column = 1) btn1 = Button(root, text='Sign In', command=show) btn1.config(height = 2, width = 20) btn1.grid(row=3,column=1) root.mainloop()
class CalibrationDialog(BeeDialog): _main_window = None #: tk.Tk _hive = None #: Hive _bar = None #: Progressbar _close_enabled = True _button_box = None #: Frame _start_button = None _calibration = None _humidity = None _yes_button = None _no_button = None _header = None _expected_weight_label = None #: : tk.Label _expected_weight_field = None #: : tk.Entry _expected_weight_box = None _weight_display = None _temp_display = None def __init__(self, main_window: tk.Tk, hive: Hive): self._main_window = main_window self._hive = hive super().__init__(parent=main_window, title="Waage kalibrieren", width=310, height=120) def _init_expected_weight_box(self): self._expected_weight_box = Frame(self) self._expected_weight_label = Label(self._expected_weight_box, text='Gewicht (g)', font=('Arial', 10), anchor='e', wraplength=100, background='#ffffcc') self._expected_weight_label.grid(column=0, row=0, sticky='e') self._expected_weight_field = Entry(self._expected_weight_box, font=('Arial', 8), width="20") self._expected_weight_field.grid(column=1, row=0) def open(self): pass def cancel(self, event=None): if self._close_enabled: super().cancel(event) def body(self, master): self._calibration = HiveCalibration() self._header = Label(master, text="") self._bar = Progressbar(master, length=210) self._init_expected_weight_box() self._weight_display = Label(master, text="") self._temp_display = Label(master, text="") self._prepare_tara() def _prepare_tara(self): self._header.config( text='Drücken Sie "Start" um die Waage\n zu tarieren.') self._header.pack() def _standard_buttons(self): self._button_box = Frame(self) self._button_box.pack() self._start_button = Button(self._button_box, text="Start", width=10, command=self._calc_offset, default=ACTIVE) self._start_button.pack(side=LEFT, padx=5, pady=5) w = Button(self._button_box, text="Abbrechen", width=10, command=self.cancel) w.pack(side=LEFT, padx=5, pady=5) def _yes_no_buttons(self): self._yes_no_button_box = Frame(self) self._yes_button = Button(self._yes_no_button_box, text="Ja", width=10, command=self._satisfied, default=ACTIVE) self._yes_button.pack(side=LEFT, padx=5, pady=5) self._no_button = Button(self._yes_no_button_box, text="Nein", width=10, command=self._not_satisfied) self._no_button.pack(side=LEFT, padx=5, pady=5) def init_calc_offset(self): pass def _satisfied(self): DbAccess.update_hive_calibration(self._calibration) self._close_enabled = True self.cancel() def _not_satisfied(self): self._start_button.config(command=self._calc_offset) self._calibration = HiveCalibration() self._yes_no_button_box.pack_forget() self._temp_display.pack_forget() self._weight_display.pack_forget() self._prepare_tara() self._button_box.pack() self.update_idletasks() def buttonbox(self): self._standard_buttons() self._yes_no_buttons() '''add standard button box. override if you do not want the standard buttons ''' ''' w = Button(box, text="OK", width=10, command=self.ok, default=ACTIVE) w.pack(side=LEFT, padx=5, pady=5) w = Button(box, text="Cancel", width=10, command=self.cancel) w.pack(side=LEFT, padx=5, pady=5) self.bind("<Return>", self.ok) self.bind("<Escape>", self.cancel) ''' def _progress(self, i, maximum=15): self._bar['value'] = int(210 / (maximum - i)) self.update_idletasks() def _calc_reference_unit(self, event=None): expected_weight_string = self._expected_weight_field.get() print('calc-reference-unit.expected_weight_string: ', expected_weight_string) expected = int(expected_weight_string) print('calc-reference-unit.expected: ', expected) self._calibration.entity_id = self._hive.get_id() self._humidity = None self._bar['value'] = 0 self._bar.pack() self.update_idletasks() try: self._close_enabled = False self._button_box.pack_forget() self._close_enabled = False self._bar.pack() self.update_idletasks() pins = self._hive.get_weight().get_bcm().split(",") data_pin = pins[0] clk_pin = pins[1] print('data_pin ' + data_pin) print('clk_pin ' + clk_pin) hx = HX711(int(data_pin), int(clk_pin), gain=128) hx.set_reading_format("LSB", "MSB") print('_offset:', self._calibration.offset) hx.set_offset(self._calibration.offset) self._calibration.value_per_gram = hx.calc_reference_unit( lambda i: self._progress(i, 10), expected) print('reference_unit -> ', self._calibration.value_per_gram) self._calc_temp() clean() self._start_button.config(command=self._check_weight) self._header.config( text='Drücken Sie Start um das Gewicht\nzu überprüfen.') self._button_box.pack() self._bar.pack_forget() self._expected_weight_box.pack_forget() self._weight_display.pack() self._temp_display.pack() self.update_idletasks() self._close_enabled = True except Exception as e: print('Error ', e) clean() self._calibration.offset = None self._close_enabled = True def _calc_temp(self): temp_sensor = self._hive.get_temperature_outside() if temp_sensor.get_bcm() == '' or temp_sensor.get_product() == '': return if temp_sensor.get_product() == 'DHT22': self._humidity, self._calibration.temp = dht.read_retry( dht.DHT22, int(temp_sensor.get_bcm())) print('Temp={0:0.1f}*C Humidity={1:0.1f}%'.format( self._calibration.temp, self._humidity)) elif temp_sensor.get_product() == 'DHT11': self._humidity, self._temp = dht.read_retry( dht.DHT11, int(temp_sensor.get_bcm())) print('Temp={0:0.1f}*C Humidity={1:0.1f}%'.format( self._calibration.temp, self._humidity)) else: print('Unsupported product ', temp_sensor.get_product()) def _check_weight(self): try: self._close_enabled = False pins = self._hive.get_weight().get_bcm().split(",") data_pin = pins[0] clk_pin = pins[1] hx = HX711(int(data_pin), int(clk_pin), gain=128) hx.set_reading_format("LSB", "MSB") print('_reference_unit:', self._calibration.value_per_gram) hx.set_reference_unit(self._calibration.value_per_gram) hx.reset() print('_offset:', self._calibration.offset) hx.set_offset(self._calibration.offset) val = hx.get_weight(5) print('value -> ', val) self._header.config(text='Sind Sie mit dem Ergebnis\nzufrieden?') self._weight_display.config( text=('Gewicht: {0:0.1f}g'.format(val))) if self._calibration.temp is not None: self._temp_display.config( text=('Temp: {0:0.1f}°C'.format(self._calibration.temp))) else: self._temp_display.config(text='') print('reference_unit -> ', self._calibration.value_per_gram) clean() self._button_box.pack_forget() self._yes_no_button_box.pack() self.update_idletasks() self._close_enabled = True except Exception as e: print('Error ', e) clean() self._calibration.offset = None self._close_enabled = True def _calc_offset(self, event=None): self._calibration.offset = None try: self._button_box.pack_forget() self._close_enabled = False self._bar.pack() self.update_idletasks() pins = self._hive.get_weight().get_bcm().split(",") data_pin = pins[0] clk_pin = pins[1] print('data_pin ' + data_pin) print('clk_pin ' + clk_pin) hx = HX711(int(data_pin), int(clk_pin), gain=128) hx.set_reading_format("LSB", "MSB") self._calibration.offset = hx.calc_offset( lambda i: self._progress(i)) print('offset -> ', self._calibration.offset) clean() self._start_button.config(command=self._calc_reference_unit) self._header.config(text='Geben Sie ein Gewicht auf die Waage.') self._expected_weight_box.pack() self._button_box.pack() self._bar.pack_forget() self.update_idletasks() except Exception as e: print('Fehler', e) clean() self._close_enabled = True self._calibration.offset = None
class MyGUI(): def __init__(self, probabilityInc, probabilityDec, master): self.probabilityInc = probabilityInc self.probabilityDec = probabilityDec self.master = master self.button = Button(self.master, text="Predict Now!", command=self.predict) self.restart_button1 = Button(self.master, text="Reset", command=self.restart_program) self.toggle = False def appOpen(self): self.master.title("Bitcoin Predictor") fm = Frame(self.master) fm.pack() self.photo = PhotoImage(file="Bitcoin.gif") self.label12 = Label(fm, image=self.photo) self.label12.image = self.photo self.label12.pack(side="top", anchor="n", fill="x", expand="yes") self.label2 = Label(fm, text=' ').pack(side="top", anchor="w", fill="x", expand="yes") self.label3 = Label(fm, text=' ').pack(side="top", anchor="w", fill="x", expand="yes") self.button.pack() #predict button self.restart_button1.pack() #reRun button self.restart_button1.config(state="disabled") #Close Button self.close_button = Button(self.master, text="Close", command=self.master.quit) self.close_button.pack() self.im = PIL.Image.open("Graph.png") self.photo = PIL.ImageTk.PhotoImage(self.im) self.label12 = Label(self.master, image=self.photo).pack(side="bottom") fm.pack(fill="both", expand="yes") ##print("probabilityInc, probabilityDec, accumMatch: ", self.probabilityInc,self.probabilityDec ,self.accumMatch) def predict(self): if (self.toggle != True): self.label1 = Label( self.master, text="Probability of Increase in the next hour: " + str(self.probabilityInc)).pack(side="top") self.label2 = Label( self.master, text="Probability of Decrease in the next hour: " + str(self.probabilityDec)).pack(side="top") self.toggle = True self.button.config(state="disabled") self.restart_button1.config(state="active") def restart_program(self): python = sys.executable os.execl(python, python, *sys.argv)
class Application(tk.Frame): load_model_btn: Button save_model_btn: Button image: Union[Label, Label] name: str acc: Union[Label, Label] loss: Union[Label, Label] current_epochs: Union[Label, Label] open_dialog_btn: Union[Button, Button] predict_frame: Union[Frame, Frame] train_epochs: Union[Entry, Entry] train_frame: Union[Frame, Frame] predict_btn: Button train_btn: Button progress_bar: Progressbar info_label: Union[Label, Label] num_images: Union[Label, Label] num_categories: Union[Label, Label] info_frame: Union[Frame, Frame] display: Text download_image_btn: Button left_frame: Frame def __init__(self, master=None): super().__init__(master) self.master = master self.classifier = Classifier() self.left_frame = Frame(master, style="My.TFrame") self.left_frame.pack( side=LEFT, fill=BOTH, ) # Separator(master, orient=VERTICAL).grid(column=1, row=0, sticky='ns') self.right_frame = Frame(master) self.right_frame.pack(side=RIGHT, fill=BOTH, padx=10) self.create_left() self.create_right() def create_left(self): self.create_download_frame() self.create_train_frame() self.create_predict_frame() self.create_info_frame() def create_info_frame(self): self.info_frame = Frame(self.left_frame) self.info_frame.pack() info_num_categories = Label(self.info_frame, text="Number of categories:") info_num_categories.grid(column=0, row=0, sticky=W) self.num_categories = Label(self.info_frame, text=self.classifier.num_categories) self.num_categories.grid(column=1, row=0) info_num_images = Label(self.info_frame, text="Number of images:") info_num_images.grid(column=0, row=1, sticky=W) self.num_images = Label(self.info_frame, text=len(self.classifier.image_paths)) self.num_images.grid(column=1, row=1) # ==== Training ==== label = Label(self.info_frame, text="Epochs:") label.grid(column=0, row=2, sticky=W) self.current_epochs = Label(self.info_frame, text=0) self.current_epochs.grid(column=1, row=2) label = Label(self.info_frame, text="Acc:") label.grid(column=0, row=3, sticky=W) self.acc = Label(self.info_frame, text=0) self.acc.grid(column=1, row=3) label = Label(self.info_frame, text="Loss:") label.grid(column=0, row=4, sticky=W) self.loss = Label(self.info_frame, text=0) self.loss.grid(column=1, row=4) Separator(self.info_frame).grid(row=5, sticky="ew", padx=4) self.info_label = Label(self.left_frame) self.info_label.pack(fill=X) self.progress_bar = Progressbar(self.left_frame, length=200, mode="determinate", orient=HORIZONTAL) self.progress_bar.pack(fill=X) self.image = Label(self.left_frame) self.image.pack(fill=X) def create_download_frame(self): self.winfo_toplevel().title("Trainer") self.download_image_btn = tk.Button(self.left_frame, text="Download Images", command=self.download) self.download_image_btn.pack(fill=X, pady=(20, 10)) self.save_model_btn = tk.Button(self.left_frame, text="Save Model", command=self.save, state=DISABLED) self.save_model_btn.pack(fill=X, pady=(20, 10)) self.load_model_btn = tk.Button(self.left_frame, text="Load Model", command=self.load) self.load_model_btn.pack(fill=X, pady=(20, 10)) def create_predict_frame(self): self.predict_frame = Frame(self.left_frame) self.predict_frame.pack(fill=X, pady=(20, 10)) self.open_dialog_btn = Button(self.predict_frame, text="Open File", command=self.openfile, state=DISABLED) self.open_dialog_btn.grid(column=0, row=0) self.predict_btn = tk.Button(self.predict_frame, text="Predict", command=self.predict, state=DISABLED) self.predict_btn.grid(column=1, row=0, padx=5, sticky='ew', columnspan=2) def create_train_frame(self): self.train_frame = Frame(self.left_frame) self.train_frame.pack(fill=X, pady=(20, 10)) label = Label(self.train_frame, text="Epochs:") label.grid(column=1, row=0) self.train_epochs = Entry(self.train_frame, width=6) self.train_epochs.grid(column=2, row=0) self.train_btn = tk.Button(self.train_frame, text="Train", command=self.train, state=DISABLED) self.train_btn.grid(column=3, row=0, columnspan=2, padx=5) def create_right(self): self.display = tk.Text(self.right_frame) self.display.pack(expand=True, fill=BOTH) def openfile(self): name = askopenfilename(filetypes=(("JPG File", "*.jpg"), ("PNG File", "*.png"), ("BMP File", "*.bmp"), ("All Files", "*.*")), title="Choose a file.") if name and self.classifier.model: self.predict_btn.config(state=ACTIVE) self.name = name def download(self): t = threading.Thread(target=self.classifier.load_images, args=(self.download_callback, )) t.start() def predict(self): t = threading.Thread(target=self.classifier.predict, args=( self.name, self.predict_callback, )) t.start() def train(self): epoch = self.train_epochs.get() if epoch is not None and epoch != "": for e in epoch: if e not in "0123456789": raise ValueError("Value error") t = threading.Thread(target=self.classifier.train, args=(int(epoch), self.train_callback)) t.start() self.train_btn.config(state=DISABLED) else: self.display.insert(END, "Epoch value error\n") def save(self): self.classifier.save() self.display.insert(END, "Model has been saved\n") def load(self): self.classifier.load() self.display.insert(END, "Model has been loaded\n") def train_callback(self, state: str, epoch: int = 0, loss: float = 0, acc: float = 0): if state == "start": self.display.insert(END, "Start training\n") self.info_label.config(text="Start training") elif state == "progress": total_epoch = int(self.train_epochs.get()) progress = ((epoch + 1) / total_epoch) * 100 self.progress_bar['value'] = progress self.current_epochs.config(text=epoch + 1) self.acc.config(text='{:.2f}%'.format(100 * acc)) self.loss.config(text=round(loss, 3)) self.display.insert(END, f"Started training on epoch {epoch}\n") elif state == "end": self.display.insert(END, "Finished training\n") self.info_label.config(text="Finished training") self.train_btn.config(state=ACTIVE) self.save_model_btn.config(state=ACTIVE) self.open_dialog_btn.config(state=ACTIVE) def predict_callback(self, data: dict): self.display.insert(END, "=====================\n") print(self.name) image1 = Image.open(self.name) image1.thumbnail((200, 200), Image.ANTIALIAS) photo_img = ImageTk.PhotoImage(image1) self.image.config(image=photo_img) self.image.image = photo_img self.display.insert( END, f"Prediction: {data['id']} {data['name']} {round(100 * data['acc'], 4)} %\n", ('important', )) self.display.insert(END, "=====================\n") def download_callback(self, label, num_completed, total): self.info_label.config(text=f"Processing {label}") progress = ((num_completed + 1) / total) * 100 self.progress_bar['value'] = progress if progress == 100: self.display.insert(END, f"{label} finished\n") self.info_label.config(text=f"{label} finished") self.train_btn.config(state=ACTIVE)
def interfejs(self): """ Funkcja tworzy etykiety obok pól, przyciski i określa obsługę kliknięcia przycisku. """ # tworze główną etykiete z tytułem Aplikacji, ustalam kolor tla i czcionki etykieta1 = Label(self.okno, text='Automat z napojami', foreground="white", background='black') etykieta1.grid(row=0, column=1, padx=5, pady=5, sticky=W + S + E + N) # ustalam ułożenie etykiety etykieta1.config( font=("Arial", 16, "italic")) # ustalam rodzaj czcionki i jej wielkość # tworze etykiete z tytułem Wrzucona kwota, ustalam kolor tla i czcionki etykieta2 = Label(self.okno, text='Wrzucona kwota', foreground="white", background='black') etykieta2.grid(row=1, column=0, padx=1, pady=1, sticky=W + S + E + N) # ustalam ułożenie etykiety etykieta2.config( font=("Arial", 13, "italic")) # ustalam rodzaj czcionki i jej wielkość # tworze etykiete z tytułem Wybrany numer, ustalam kolor tla i czcionki etykieta3 = Label(self.okno, text='Wybrany numer', foreground="white", background='black') etykieta3.grid(row=7, column=0, padx=4, pady=4) # ustalam ułożenie etykiety etykieta3.config( font=("Arial", 13, "italic")) # ustalam rodzaj czcionki i jej wielkość # tworze przycisk Zamknij i ustalam obsługe jego kliknięcia przycisk = Button(self.okno, text="Zamknij", command=self.zamknij) przycisk.grid(row=22, column=2, padx=4, pady=4, sticky=E) # ustalam ułożenie przycisku i jego wyrownanie przycisk.bind( "<Button-1>", self.zamknij ) # ustalam,że przycisk reaguje na pliknięcie na niego myszką # ustalam rodzaj czcionki, wielkość oraz kolor przycisku i czcionki przycisk.config(font=("Arial", 10, "italic"), background="silver", foreground='red') # tworze przycisk Przerwij i ustalam obsługe jego kliknięcia przycisk0 = Button(self.okno, text="Przerwij", command=self.przerwij) przycisk0.grid(row=6, column=1, padx=4, pady=4) # ustalam ułożenie przycisku przycisk0.bind( "<Button-1>", self.przerwij ) # ustalam,że przycisk reaguje na pliknięcie na niego myszką # ustalam rodzaj czcionki i jej wielkość oraz kolor przycisku i czcionki przycisk0.config(font=("Arial", 12, "italic"), foreground="black", background='silver') # tworze przyciski do wrzucania monet, ustalam obsługe ich kliknięcia, tytuł, rodzaj i wielkosc czcionki przycisk1 = Button(self.okno, text="1 gr", command=lambda: self.wrzucono_monete(1), font=("Arial", 14, "italic"), foreground="white", background='black') przycisk2 = Button(self.okno, text="2 gr", command=lambda: self.wrzucono_monete(2), font=("Arial", 14, "italic"), foreground="white", background='black') przycisk5 = Button(self.okno, text="5 gr", command=lambda: self.wrzucono_monete(5), font=("Arial", 14, "italic"), foreground="white", background='black') przycisk10 = Button(self.okno, text="10 gr", command=lambda: self.wrzucono_monete(10), font=("Arial", 14, "italic"), foreground="white", background='black') przycisk20 = Button(self.okno, text="20 gr", command=lambda: self.wrzucono_monete(20), font=("Arial", 14, "italic"), foreground="white", background='black') przycisk50 = Button(self.okno, text="50 gr", command=lambda: self.wrzucono_monete(50), font=("Arial", 14, "italic"), foreground="white", background='black') przycisk_1 = Button(self.okno, text="1 zł", command=lambda: self.wrzucono_monete(100), font=("Arial", 14, "italic"), foreground="white", background='black') przycisk_2 = Button(self.okno, text="2 zł", command=lambda: self.wrzucono_monete(200), font=("Arial", 14, "italic"), foreground="white", background='black') przycisk_5 = Button(self.okno, text="5 zł", command=lambda: self.wrzucono_monete(500), font=("Arial", 14, "italic"), foreground="white", background='black') # dodaje przyciski do wrzucania monet do zmiennej klasy Interfejs_automatu przyciski_monety(listy) przyciski = \ [przycisk1, przycisk2, przycisk5, przycisk10, przycisk20, przycisk50, przycisk_1, przycisk_2, przycisk_5] self.przyciski_monety = [n for n in przyciski] # list comprehension # ustalam położenie przycisków i ich rozciagniecie przycisk1.grid(row=2, column=0, padx=1, pady=1, sticky=W + S + E + N) przycisk2.grid(row=2, column=1, padx=1, pady=1, sticky=W + S + E + N) przycisk5.grid(row=2, column=2, padx=1, pady=1, sticky=W + S + E + N) przycisk10.grid(row=3, column=0, padx=1, pady=1, sticky=W + S + E + N) przycisk20.grid(row=3, column=1, padx=1, pady=1, sticky=W + S + E + N) przycisk50.grid(row=3, column=2, padx=1, pady=1, sticky=W + S + E + N) przycisk_1.grid(row=4, column=0, padx=1, pady=1, sticky=W + S + E + N) przycisk_2.grid(row=4, column=1, padx=1, pady=1, sticky=W + S + E + N) przycisk_5.grid(row=4, column=2, padx=1, pady=1, sticky=W + S + E + N) # tworze przyciski do wyboru numeru produktu i ustalam obsługe ich kliknięcia, tytuł, rodzaj i rozmiar czcionki przyc1 = Button(self.okno, text="1", command=lambda: self.kliknieto_przycisk(1), font=("Arial", 14, "italic"), foreground="white", background='black') przyc2 = Button(self.okno, text="2", command=lambda: self.kliknieto_przycisk(2), font=("Arial", 14, "italic"), foreground="white", background='black') przyc3 = Button(self.okno, text="3", command=lambda: self.kliknieto_przycisk(3), font=("Arial", 14, "italic"), foreground="white", background='black') przyc4 = Button(self.okno, text="4", command=lambda: self.kliknieto_przycisk(4), font=("Arial", 14, "italic"), foreground="white", background='black') przyc5 = Button(self.okno, text="5", command=lambda: self.kliknieto_przycisk(5), font=("Arial", 14, "italic"), foreground="white", background='black') przyc6 = Button(self.okno, text="6", command=lambda: self.kliknieto_przycisk(6), font=("Arial", 14, "italic"), foreground="white", background='black') przyc7 = Button(self.okno, text="7", command=lambda: self.kliknieto_przycisk(7), font=("Arial", 14, "italic"), foreground="white", background='black') przyc8 = Button(self.okno, text="8", command=lambda: self.kliknieto_przycisk(8), font=("Arial", 14, "italic"), foreground="white", background='black') przyc9 = Button(self.okno, text="9", command=lambda: self.kliknieto_przycisk(9), font=("Arial", 14, "italic"), foreground="white", background='black') przyc0 = Button(self.okno, text="0", command=lambda: self.kliknieto_przycisk(0), font=("Arial", 14, "italic"), foreground="white", background='black') # dodaje przyciski do wyboru numeru produktu do zmiennej klasy Interfejs_automatu pinpad(listy) przyc = [ przyc1, przyc2, przyc3, przyc4, przyc5, przyc6, przyc7, przyc8, przyc9, przyc0 ] self.pinpad = [n for n in przyc] # list comprehension # ustalam położenie przycisków i ich rozciagniecie przyc1.grid(row=8, column=0, padx=1, pady=1, sticky=W + S + E + N) przyc2.grid(row=8, column=1, padx=1, pady=1, sticky=W + S + E + N) przyc3.grid(row=8, column=2, padx=1, pady=1, sticky=W + S + E + N) przyc4.grid(row=9, column=0, padx=1, pady=1, sticky=W + S + E + N) przyc5.grid(row=9, column=1, padx=1, pady=1, sticky=W + S + E + N) przyc6.grid(row=9, column=2, padx=1, pady=1, sticky=W + S + E + N) przyc7.grid(row=10, column=0, padx=1, pady=1, sticky=W + S + E + N) przyc8.grid(row=10, column=1, padx=1, pady=1, sticky=W + S + E + N) przyc9.grid(row=10, column=2, padx=1, pady=1, sticky=W + S + E + N) przyc0.grid(row=11, column=1, padx=1, pady=1, sticky=W + S + E + N) ety = Label(self.okno, text='Napoje') # tworze etykiete z tytułem Napoje ety.grid(row=13, column=1, padx=5, pady=5) # ustalam ułożenie etykiety ety.config( font=("Arial", 15, "italic"), foreground="white", background='black' ) # ustalam rodzaj czcionki i jej wielkość, kolor tła i czcionki # tworze etykiety z numerami produktow i ich nazwami ety1 = Label(self.okno, text='30:woda gazowana') ety2 = Label(self.okno, text='31:woda niegazowana') ety3 = Label(self.okno, text='32:sok pomarańczowy') ety4 = Label(self.okno, text='33:sok porzeczkowy') ety5 = Label(self.okno, text='34:sok jabłkowy') ety6 = Label(self.okno, text='35:mirinda') ety7 = Label(self.okno, text='36:pepsi') ety8 = Label(self.okno, text='37:pepsi light') ety9 = Label(self.okno, text='38:cola') ety10 = Label(self.okno, text='39:cola zero') ety11 = Label(self.okno, text='40:nestea brzoskwiniowe') ety12 = Label(self.okno, text='41:nestea cytrynowe') ety13 = Label(self.okno, text='42:nestea zielona herbata') ety14 = Label(self.okno, text='43:tymbark pomarańcza-mięta') ety15 = Label(self.okno, text='44:tymbark jabłko-brzoskwinia') ety16 = Label(self.okno, text='45:tymbark jabłko-wiśnia') ety17 = Label(self.okno, text='46:tymbark jabłko-kiwi') ety18 = Label(self.okno, text='47:sprite') ety19 = Label(self.okno, text='48:7up') ety20 = Label(self.okno, text='49:oranżada cytrynowa') ety21 = Label(self.okno, text='50:oranżada wiśniowa') # ustalam ułozennie etykiet i ich wyrowanie ety1.grid(row=14, column=0, padx=1, pady=1, sticky=W) ety2.grid(row=14, column=1, padx=1, pady=1, sticky=W) ety3.grid(row=14, column=2, padx=1, pady=1, sticky=W) ety4.grid(row=15, column=0, padx=1, pady=1, sticky=W) ety5.grid(row=15, column=1, padx=1, pady=1, sticky=W) ety6.grid(row=15, column=2, padx=1, pady=1, sticky=W) ety7.grid(row=16, column=0, padx=1, pady=1, sticky=W) ety8.grid(row=16, column=1, padx=1, pady=1, sticky=W) ety9.grid(row=16, column=2, padx=1, pady=1, sticky=W) ety10.grid(row=17, column=0, padx=1, pady=1, sticky=W) ety11.grid(row=17, column=1, padx=1, pady=1, sticky=W) ety12.grid(row=17, column=2, padx=1, pady=1, sticky=W) ety13.grid(row=18, column=0, padx=1, pady=1, sticky=W) ety14.grid(row=18, column=1, padx=1, pady=1, sticky=W) ety15.grid(row=18, column=2, padx=1, pady=1, sticky=W) ety16.grid(row=19, column=0, padx=1, pady=1, sticky=W) ety17.grid(row=19, column=1, padx=1, pady=1, sticky=W) ety18.grid(row=19, column=2, padx=1, pady=1, sticky=W) ety19.grid(row=20, column=0, padx=1, pady=1, sticky=W) ety20.grid(row=20, column=1, padx=1, pady=1, sticky=W) ety21.grid(row=20, column=2, padx=1, pady=1, sticky=W) # ustalam kolor tla, kolor,rodzaj i wielkosc czcionki w etykietach ety1.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety2.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety3.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety4.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety5.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety6.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety7.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety8.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety9.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety10.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety11.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety12.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety13.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety14.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety15.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety16.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety17.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety18.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety19.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety20.config(font=("Arial", 11, "italic"), foreground="white", background='black') ety21.config(font=("Arial", 11, "italic"), foreground="white", background='black')
def queryDate(): dates=[] # returnDates = [] # dateButtons = [] today = datetime.now() daysForward = "" if today.weekday()<2: daysForward = 3 else: daysForward = 5 #remove the +1 for actual use for i in range(daysForward): thisDay = getDaysForward(i, True) if thisDay: dates.append(thisDay) bgC = "lavender" top = Tk() top.config(bg = bgC) L1 = Label(top, text="Please select the date to run on\nPlease only select one date.", bg = bgC, padx = 20) L1.config(font=("serif", 16)) L1.grid(row=0, column=0, sticky=constants.W+constants.E) dateVar=StringVar() dateVar.set(dates[-1]) f = Frame(top) f.grid(row=1, column=0) print("here") for date in dates: Radiobutton(f, text=date, variable=dateVar, value=date, bg=bgC, font = ("serif", 16)).pack() # check = BooleanVar() # checkButton = Checkbutton(top, text=date, variable=check, font=("serif", 16), bg=bgC) # checkButton.grid(row=i, column=0, sticky=constants.W+constants.E) # if i==daysForward: # check.set(True) # i+=1 # dateButtons.append((check, date)) def callbackDates(): # for button, date in dateButtons: # if button.get(): # returnDates.append(date) top.destroy() MyButton = Button(top, text="OK", command=callbackDates) MyButton.grid(row=2, column=0, sticky=constants.W+constants.E, padx = 20, pady = (0,20)) MyButton.config(font=("serif", 30), bg="green") top.update() w = top.winfo_width() # width for the Tk root h = top.winfo_height() # height for the Tk root ws = top.winfo_screenwidth() # width of the screen hs = top.winfo_screenheight() # height of the screen x = (ws/2) - (w/2) y = (hs/2) - (h/2) top.geometry('%dx%d+%d+%d' % (w, h, x, y)) top.update() top.lift() top.attributes('-topmost',True) top.after_idle(top.attributes,'-topmost',False) moveTo(MyButton.winfo_width()/2 + MyButton.winfo_rootx(), MyButton.winfo_height()/2 + MyButton.winfo_rooty()) top.mainloop() return dateVar.get()
command # Комманда exe при активации виджета(fx обратного вызова) # Полныи lst ⊃ args # Man options:https://www.tcl.tk/man/tcl8.5/TkCmd/options.htm # Man-страницы соотв виджета, напр man button(разделы "STANDART OPTIONS" & "WIDGET-SPECIFIC OPTIONS": # Http://www.tcl.tk/man/tcl8.5/TkCmd/button.htm МЕТОДЫ ВИДЖЕТОВ .config[ure](**kwargs) # Δ конфигурации ∃ виджета(при exe app) # ~ <widget>['<opt>'] = new_val # Examples btn0 = Button() btn0.config(text='send') .cget # Обратен .config[ure]() # Получение параметров виджета # ~ val = <widget>['opt'] .destroy() # Уничтожение виджета & ∀ его потомков .grid_remove() # Скрытие виджета, с сохранение взаимного расположения виджетов # Examples from tkinter import Tk, Label, Button ... ...
class GUIRoot(Tk): """The tkinter GUI root class.""" def __init__(self, thread_cls): super().__init__() self.thread_cls = thread_cls self.img = None self.title("Emotion API") self.grid() self.grid_columnconfigure(0, weight=1) self.grid_columnconfigure(1, weight=2) self.grid_rowconfigure(4, weight=1) # Create LabelFrames lf_key = LabelFrame(self, text="Emotion API Key") lf_key.grid(row=0, column=0, columnspan=1, sticky=W + E, padx=5, pady=3) lf_key.grid_columnconfigure(0, weight=1) lf_mode = LabelFrame(self, text="Mode") lf_mode.grid(row=1, column=0, columnspan=1, sticky=W + E, padx=5, pady=3) for i in range(3): lf_mode.grid_columnconfigure(i, weight=1) lf_source = LabelFrame(self, text="Image Source", height=50) lf_source.grid(row=2, column=0, columnspan=1, sticky=W + E, padx=5, pady=3) lf_source.rowconfigure(0, weight=1) lf_source.grid_propagate(False) lf_source.columnconfigure(0, weight=1) lf_source.columnconfigure(1, weight=5) lf_source.columnconfigure(2, weight=1) lf_request = LabelFrame(self, text="Request Result") lf_request.grid(row=3, column=0, columnspan=1, sticky=W + E, padx=5, pady=3) lf_request.grid_columnconfigure(0, weight=1) lf_console = LabelFrame(self, text="Console") lf_console.grid(row=4, column=0, columnspan=1, sticky=N + S + W + E, padx=5, pady=3) lf_console.grid_columnconfigure(0, weight=1) lf_console.grid_rowconfigure(0, weight=1) lf_img = LabelFrame(self, text="Output Image") lf_img.grid(row=0, column=1, rowspan=5, sticky=N + S + W + E) lf_img.grid_columnconfigure(0, weight=1) lf_img.grid_rowconfigure(0, weight=1) # Create Input Fields self.ety_key = Entry(lf_key) self.ety_key.insert(END, "bfe9b2f471e04b29a8fabfe3dd9f647d") self.ety_key.grid(sticky=W + E, padx=3) self.var_mode = StringVar() Radiobutton(lf_mode, text="Local Image", variable=self.var_mode, value='local', command=self.change_mode).grid(row=1, column=0) Radiobutton(lf_mode, text="URL Image", variable=self.var_mode, value='url', command=self.change_mode).grid(row=1, column=1) Radiobutton(lf_mode, text="Camera", variable=self.var_mode, value='cam', command=self.change_mode).grid(row=1, column=2) # Local Image Source self.lb_filename = Label(lf_source, text="..") self.btn_fileopen = Button(lf_source, text="Open..", command=self.get_local_img) # URL Image Source self.lb_url = Label(lf_source, text="URL") self.ety_url = Entry(lf_source) self.ety_url.insert(END, "https://i.imgflip.com/qiev6.jpg") self.btn_url = Button(lf_source, text="Get Image", command=self.get_url_img) # Camera Image Source self.btn_get_cam = Button(lf_source, text="Get the Camera Image", command=self.get_cam_img) # set default mode: local raw image self.var_mode.set('local') self.change_mode() # request btn self.btn_request = Button(lf_request, text="Request Result", command=self.run_request, state='disable') self.btn_request.grid(sticky=W + E) # Create Output Console self.console = ScrolledText(lf_console, state='disable', width=60, bg='gray20', fg='white') self.console.grid(sticky=N + S + W + E) # Create Output Image self.plot = ResultImg(lf_img) self.plot.grid(sticky=N + S + W + E) def change_mode(self): """Change the image source mode.""" if self.var_mode.get() == 'local': self.lb_filename.grid(row=0, column=0, columnspan=2) self.btn_fileopen.grid(row=0, column=2) self.lb_url.grid_forget() self.ety_url.grid_forget() self.btn_url.grid_forget() self.btn_get_cam.grid_forget() elif self.var_mode.get() == 'url': self.lb_filename.grid_forget() self.btn_fileopen.grid_forget() self.btn_get_cam.grid_forget() self.lb_url.grid(row=0, column=0) self.ety_url.grid(row=0, column=1, sticky=W + E, padx=3) self.btn_url.grid(row=0, column=2) else: self.lb_filename.grid_forget() self.btn_fileopen.grid_forget() self.lb_url.grid_forget() self.ety_url.grid_forget() self.btn_url.grid_forget() self.btn_get_cam.grid(row=0, column=0, columnspan=3) def run_request(self): """Create the requesting thread to request the result from Emotion API.""" source = self.ety_url.get() if self.var_mode.get( ) == 'url' else self.img self.thread_cls(self.ety_key.get(), self.var_mode.get(), source, self.plot, self.print_console).start() def get_local_img(self): """Open the dialog let user to choose test file and get the test data.""" max_name_len = 20 filename = askopenfilename(filetypes=(("JPEG", "*.jpg"), ("PNG", "*.png"), ("All Files", "*.*")), title="Choose an Image") if filename: with open(filename, 'rb') as f: self.img = f.read() self.plot.imshow(img_decode(self.img)) self.print_console("Open a local raw image file.") self.btn_request.config(state='normal') if len(filename) > max_name_len: self.lb_filename.config(text=".." + filename[-max_name_len:]) else: self.lb_filename.config(text=filename) def get_url_img(self): """Get the image from the given URL.""" try: self.plot.imshow( Image.open(BytesIO(requests.get(self.ety_url.get()).content))) except Exception as e: self.print_console(e.args) else: self.print_console("Open a online image from URL.") self.btn_request.config(state='normal') def get_cam_img(self): """Get the image from the laptop camera.""" cam = cv2.VideoCapture(0) # 0 -> index of camera s, self.img = cam.read() self.img = cv2.imencode('.jpg', self.img)[1].tostring() if s: # frame captured without any errors self.print_console("Camera image captured.") self.plot.imshow(img_decode(self.img)) self.btn_request.config(state='normal') def print_console(self, input_str): """Print the text on the conolse.""" self.console.config(state='normal') self.console.insert(END, "{}\n".format(input_str)) self.console.config(state='disable') self.console.see(END)
class wm_seg: """ Simple GUI application If the application inside a container, automatic updates are removed. The application uses two frames (tabs): - training - testing """ def __init__(self, master, container): self.master = master master.title("nicMSlesions") # running on a container self.container = container # gui attributes self.path = os.getcwd() self.default_config = None self.user_config = None self.current_folder = os.getcwd() self.list_train_pretrained_nets = [] self.list_test_nets = [] self.version = __version__ if self.container is False: # version_number self.commit_version = subprocess.check_output( ['git', 'rev-parse', 'HEAD']) # queue and thread parameters. All processes are embedded # inside threads to avoid freezing the application self.train_task = None self.test_task = None self.test_queue = Queue() self.train_queue = Queue() # -------------------------------------------------- # parameters. Mostly from the config/*.cfg files # -------------------------------------------------- # data parameters self.param_training_folder = StringVar() self.param_test_folder = StringVar() self.param_FLAIR_tag = StringVar() self.param_T1_tag = StringVar() self.param_MOD3_tag = StringVar() self.param_MOD4_tag = StringVar() self.param_mask_tag = StringVar() self.param_model_tag = StringVar() self.param_register_modalities = BooleanVar() self.param_skull_stripping = BooleanVar() self.param_denoise = BooleanVar() self.param_denoise_iter = IntVar() self.param_save_tmp = BooleanVar() self.param_debug = BooleanVar() # train parameters self.param_net_folder = os.path.join(self.current_folder, 'nets') self.param_use_pretrained_model = BooleanVar() self.param_pretrained_model = StringVar() self.param_inference_model = StringVar() self.param_num_layers = IntVar() self.param_net_name = StringVar() self.param_net_name.set('None') self.param_balanced_dataset = StringVar() self.param_fract_negatives = DoubleVar() # model parameters self.param_pretrained = None self.param_min_th = DoubleVar() self.param_patch_size = IntVar() self.param_weight_paths = StringVar() self.param_load_weights = BooleanVar() self.param_train_split = DoubleVar() self.param_max_epochs = IntVar() self.param_patience = IntVar() self.param_batch_size = IntVar() self.param_net_verbose = IntVar() self.param_t_bin = DoubleVar() self.param_l_min = IntVar() self.param_min_error = DoubleVar() self.param_mode = BooleanVar() self.param_gpu_number = IntVar() # load the default configuration from the conf file self.load_default_configuration() # self frame (tabbed notebook) self.note = Notebook(self.master) self.note.pack() os.system('cls' if platform.system() == 'Windows' else 'clear') print("##################################################") print("# ------------ #") print("# nicMSlesions #") print("# ------------ #") print("# MS WM lesion segmentation #") print("# #") print("# ------------------------------- #") print("# (c) Sergi Valverde 2018 #") print("# Neuroimage Computing Group #") print("# ------------------------------- #") print("##################################################\n)") print("Please select options for training or inference in the menu...") # -------------------------------------------------- # training tab # -------------------------------------------------- self.train_frame = Frame() self.note.add(self.train_frame, text="Training") self.test_frame = Frame() self.note.add(self.test_frame, text="Inference") # label frames cl_s = 5 self.tr_frame = LabelFrame(self.train_frame, text="Training images:") self.tr_frame.grid(row=0, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) self.model_frame = LabelFrame(self.train_frame, text="CNN model:") self.model_frame.grid(row=5, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) # training options self.inFolderLbl = Label(self.tr_frame, text="Training folder:") self.inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2) self.inFolderTxt = Entry(self.tr_frame) self.inFolderTxt.grid(row=0, column=1, columnspan=5, sticky="W", pady=3) self.inFileBtn = Button(self.tr_frame, text="Browse ...", command=self.load_training_path) self.inFileBtn.grid(row=0, column=5, columnspan=1, sticky='W', padx=5, pady=1) self.optionsBtn = Button(self.tr_frame, text="Other options", command=self.parameter_window) self.optionsBtn.grid(row=0, column=10, columnspan=1, sticky="W", padx=(100, 1), pady=1) # setting input modalities: FLAIR + T1 are mandatory # Mod 3 / 4 are optional self.flairTagLbl = Label(self.tr_frame, text="FLAIR tag:") self.flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2) self.flairTxt = Entry(self.tr_frame, textvariable=self.param_FLAIR_tag) self.flairTxt.grid(row=1, column=1, columnspan=1, sticky="W", pady=1) self.t1TagLbl = Label(self.tr_frame, text="T1 tag:") self.t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2) self.t1Txt = Entry(self.tr_frame, textvariable=self.param_T1_tag) self.t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1) self.mod3TagLbl = Label(self.tr_frame, text="mod 3 tag:") self.mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2) self.mod3Txt = Entry(self.tr_frame, textvariable=self.param_MOD3_tag) self.mod3Txt.grid(row=3, column=1, columnspan=1, sticky="W", pady=1) self.mod4TagLbl = Label(self.tr_frame, text="mod 4 tag:") self.mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2) self.mod4Txt = Entry(self.tr_frame, textvariable=self.param_MOD4_tag) self.mod4Txt.grid(row=4, column=1, columnspan=1, sticky="W", pady=1) self.maskTagLbl = Label(self.tr_frame, text="MASK tag:") self.maskTagLbl.grid(row=5, column=0, sticky='E', padx=5, pady=2) self.maskTxt = Entry(self.tr_frame, textvariable=self.param_mask_tag) self.maskTxt.grid(row=5, column=1, columnspan=1, sticky="W", pady=1) # model options self.modelTagLbl = Label(self.model_frame, text="Model name:") self.modelTagLbl.grid(row=6, column=0, sticky='E', padx=5, pady=2) self.modelTxt = Entry(self.model_frame, textvariable=self.param_net_name) self.modelTxt.grid(row=6, column=1, columnspan=1, sticky="W", pady=1) self.checkPretrain = Checkbutton(self.model_frame, text="use pretrained", var=self.param_use_pretrained_model) self.checkPretrain.grid(row=6, column=3, padx=5, pady=5) self.update_pretrained_nets() self.pretrainTxt = OptionMenu(self.model_frame, self.param_pretrained_model, *self.list_train_pretrained_nets) self.pretrainTxt.grid(row=6, column=5, sticky='E', padx=5, pady=5) # START button links self.trainingBtn = Button(self.train_frame, state='disabled', text="Start training", command=self.train_net) self.trainingBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1) # -------------------------------------------------- # inference tab # -------------------------------------------------- self.tt_frame = LabelFrame(self.test_frame, text="Inference images:") self.tt_frame.grid(row=0, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) self.test_model_frame = LabelFrame(self.test_frame, text="CNN model:") self.test_model_frame.grid(row=5, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) # testing options self.test_inFolderLbl = Label(self.tt_frame, text="Testing folder:") self.test_inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2) self.test_inFolderTxt = Entry(self.tt_frame) self.test_inFolderTxt.grid(row=0, column=1, columnspan=5, sticky="W", pady=3) self.test_inFileBtn = Button(self.tt_frame, text="Browse ...", command=self.load_testing_path) self.test_inFileBtn.grid(row=0, column=5, columnspan=1, sticky='W', padx=5, pady=1) self.test_optionsBtn = Button(self.tt_frame, text="Other options", command=self.parameter_window) self.test_optionsBtn.grid(row=0, column=10, columnspan=1, sticky="W", padx=(100, 1), pady=1) self.test_flairTagLbl = Label(self.tt_frame, text="FLAIR tag:") self.test_flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2) self.test_flairTxt = Entry(self.tt_frame, textvariable=self.param_FLAIR_tag) self.test_flairTxt.grid(row=1, column=1, columnspan=1, sticky="W", pady=1) self.test_t1TagLbl = Label(self.tt_frame, text="T1 tag:") self.test_t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2) self.test_t1Txt = Entry(self.tt_frame, textvariable=self.param_T1_tag) self.test_t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1) self.test_mod3TagLbl = Label(self.tt_frame, text="mod 3 tag:") self.test_mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2) self.test_mod3Txt = Entry(self.tt_frame, textvariable=self.param_MOD3_tag) self.test_mod3Txt.grid(row=3, column=1, columnspan=1, sticky="W", pady=1) self.test_mod4TagLbl = Label(self.tt_frame, text="mod 4 tag:") self.test_mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2) self.test_mod4Txt = Entry(self.tt_frame, textvariable=self.param_MOD4_tag) self.test_mod4Txt.grid(row=4, column=1, columnspan=1, sticky="W", pady=1) self.test_pretrainTxt = OptionMenu(self.test_model_frame, self.param_inference_model, *self.list_test_nets) self.param_inference_model.set('None') self.test_pretrainTxt.grid(row=5, column=0, sticky='E', padx=5, pady=5) # START button links cto docker task self.inferenceBtn = Button(self.test_frame, state='disabled', text="Start inference", command=self.infer_segmentation) self.inferenceBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1) # train / test ABOUT button self.train_aboutBtn = Button(self.train_frame, text="about", command=self.about_window) self.train_aboutBtn.grid(row=7, column=4, sticky='E', padx=(1, 1), pady=1) self.test_aboutBtn = Button(self.test_frame, text="about", command=self.about_window) self.test_aboutBtn.grid(row=7, column=4, sticky='E', padx=(1, 1), pady=1) # Processing state self.process_indicator = StringVar() self.process_indicator.set(' ') self.label_indicator = Label(master, textvariable=self.process_indicator) self.label_indicator.pack(side="left") # Closing processing events is implemented via # a master protocol self.master.protocol("WM_DELETE_WINDOW", self.close_event) def parameter_window(self): """ Setting other parameters using an emerging window CNN parameters, CUDA device, post-processing.... """ t = Toplevel(self.master) t.wm_title("Other parameters") # data parameters t_data = LabelFrame(t, text="data options:") t_data.grid(row=0, sticky="WE") checkPretrain = Checkbutton(t_data, text="Register modalities", var=self.param_register_modalities) checkPretrain.grid(row=0, sticky='W') checkSkull = Checkbutton(t_data, text="Skull-strip modalities", var=self.param_skull_stripping) checkSkull.grid(row=1, sticky="W") checkDenoise = Checkbutton(t_data, text="Denoise masks", var=self.param_denoise) checkDenoise.grid(row=2, sticky="W") denoise_iter_label = Label(t_data, text=" Denoise iter: ") denoise_iter_label.grid(row=3, sticky="W") denoise_iter_entry = Entry(t_data, textvariable=self.param_denoise_iter) denoise_iter_entry.grid(row=3, column=1, sticky="E") check_tmp = Checkbutton(t_data, text="Save tmp files", var=self.param_save_tmp) check_tmp.grid(row=4, sticky="W") checkdebug = Checkbutton(t_data, text="Debug mode", var=self.param_debug) checkdebug.grid(row=5, sticky="W") # model parameters t_model = LabelFrame(t, text="Model:") t_model.grid(row=5, sticky="EW") maxepochs_label = Label(t_model, text="Max epochs: ") maxepochs_label.grid(row=6, sticky="W") maxepochs_entry = Entry(t_model, textvariable=self.param_max_epochs) maxepochs_entry.grid(row=6, column=1, sticky="E") trainsplit_label = Label(t_model, text="Validation %: ") trainsplit_label.grid(row=7, sticky="W") trainsplit_entry = Entry(t_model, textvariable=self.param_train_split) trainsplit_entry.grid(row=7, column=1, sticky="E") batchsize_label = Label(t_model, text="Test batch size:") batchsize_label.grid(row=8, sticky="W") batchsize_entry = Entry(t_model, textvariable=self.param_batch_size) batchsize_entry.grid(row=8, column=1, sticky="E") mode_label = Label(t_model, text="Verbosity:") mode_label.grid(row=9, sticky="W") mode_entry = Entry(t_model, textvariable=self.param_net_verbose) mode_entry.grid(row=9, column=1, sticky="E") #gpu_mode = Checkbutton(t_model, # text="GPU:", # var=self.param_mode) #gpu_mode.grid(row=10, sticky="W") gpu_number = Label(t_model, text="GPU number:") gpu_number.grid(row=10, sticky="W") gpu_entry = Entry(t_model, textvariable=self.param_gpu_number) gpu_entry.grid(row=10, column=1, sticky="W") # training parameters tr_model = LabelFrame(t, text="Training:") tr_model.grid(row=12, sticky="EW") balanced_label = Label(tr_model, text="Balanced dataset: ") balanced_label.grid(row=13, sticky="W") balanced_entry = Entry(tr_model, textvariable=self.param_balanced_dataset) balanced_entry.grid(row=13, column=1, sticky="E") fraction_label = Label(tr_model, text="Fraction negative/positives: ") fraction_label.grid(row=14, sticky="W") fraction_entry = Entry(tr_model, textvariable=self.param_fract_negatives) fraction_entry.grid(row=14, column=1, sticky="E") # postprocessing parameters t_post = LabelFrame(t, text="Post-processing: ") t_post.grid(row=15, sticky="EW") t_bin_label = Label(t_post, text="Out probability th: ") t_bin_label.grid(row=16, sticky="W") t_bin_entry = Entry(t_post, textvariable=self.param_t_bin) t_bin_entry.grid(row=16, column=1, sticky="E") l_min_label = Label(t_post, text="Min out region size: ") l_min_label.grid(row=17, sticky="W") l_min_entry = Entry(t_post, textvariable=self.param_l_min) l_min_entry.grid(row=17, column=1, sticky="E") vol_min_label = Label(t_post, text="Min vol error (ml): ") vol_min_label.grid(row=18, sticky="W") vol_min_entry = Entry(t_post, textvariable=self.param_min_error) vol_min_entry.grid(row=18, column=1, sticky="E") def load_default_configuration(self): """ load the default configuration from /config/default.cfg This method assign each of the configuration parameters to class attributes """ default_config = ConfigParser.SafeConfigParser() default_config.read(os.path.join(self.path, 'config', 'default.cfg')) # dastaset parameters self.param_training_folder.set( default_config.get('database', 'train_folder')) self.param_test_folder.set( default_config.get('database', 'inference_folder')) self.param_FLAIR_tag.set(default_config.get('database', 'flair_tags')) self.param_T1_tag.set(default_config.get('database', 't1_tags')) self.param_MOD3_tag.set(default_config.get('database', 'mod3_tags')) self.param_MOD4_tag.set(default_config.get('database', 'mod4_tags')) self.param_mask_tag.set(default_config.get('database', 'roi_tags')) self.param_register_modalities.set( default_config.get('database', 'register_modalities')) self.param_denoise.set(default_config.get('database', 'denoise')) self.param_denoise_iter.set( default_config.getint('database', 'denoise_iter')) self.param_skull_stripping.set( default_config.get('database', 'skull_stripping')) self.param_save_tmp.set(default_config.get('database', 'save_tmp')) self.param_debug.set(default_config.get('database', 'debug')) # train parameters self.param_use_pretrained_model.set( default_config.get('train', 'full_train')) self.param_pretrained_model.set( default_config.get('train', 'pretrained_model')) self.param_inference_model.set(" ") self.param_balanced_dataset.set( default_config.get('train', 'balanced_training')) self.param_fract_negatives.set( default_config.getfloat('train', 'fraction_negatives')) # model parameters self.param_net_folder = os.path.join(self.current_folder, 'nets') self.param_net_name.set(default_config.get('model', 'name')) self.param_train_split.set( default_config.getfloat('model', 'train_split')) self.param_max_epochs.set(default_config.getint('model', 'max_epochs')) self.param_patience.set(default_config.getint('model', 'patience')) self.param_batch_size.set(default_config.getint('model', 'batch_size')) self.param_net_verbose.set(default_config.get('model', 'net_verbose')) self.param_gpu_number.set(default_config.getint('model', 'gpu_number')) # self.param_mode.set(default_config.get('model', 'gpu_mode')) # post-processing self.param_l_min.set(default_config.getint('postprocessing', 'l_min')) self.param_t_bin.set(default_config.getfloat('postprocessing', 't_bin')) self.param_min_error.set( default_config.getfloat('postprocessing', 'min_error')) def write_user_configuration(self): """ write the configuration into config/configuration.cfg """ user_config = ConfigParser.RawConfigParser() # dataset parameters user_config.add_section('database') user_config.set('database', 'train_folder', self.param_training_folder.get()) user_config.set('database', 'inference_folder', self.param_test_folder.get()) user_config.set('database', 'flair_tags', self.param_FLAIR_tag.get()) user_config.set('database', 't1_tags', self.param_T1_tag.get()) user_config.set('database', 'mod3_tags', self.param_MOD3_tag.get()) user_config.set('database', 'mod4_tags', self.param_MOD4_tag.get()) user_config.set('database', 'roi_tags', self.param_mask_tag.get()) user_config.set('database', 'register_modalities', self.param_register_modalities.get()) user_config.set('database', 'denoise', self.param_denoise.get()) user_config.set('database', 'denoise_iter', self.param_denoise_iter.get()) user_config.set('database', 'skull_stripping', self.param_skull_stripping.get()) user_config.set('database', 'save_tmp', self.param_save_tmp.get()) user_config.set('database', 'debug', self.param_debug.get()) # train parameters user_config.add_section('train') user_config.set('train', 'full_train', not (self.param_use_pretrained_model.get())) user_config.set('train', 'pretrained_model', self.param_pretrained_model.get()) user_config.set('train', 'balanced_training', self.param_balanced_dataset.get()) user_config.set('train', 'fraction_negatives', self.param_fract_negatives.get()) # model parameters user_config.add_section('model') user_config.set('model', 'name', self.param_net_name.get()) user_config.set('model', 'pretrained', self.param_pretrained) user_config.set('model', 'train_split', self.param_train_split.get()) user_config.set('model', 'max_epochs', self.param_max_epochs.get()) user_config.set('model', 'patience', self.param_patience.get()) user_config.set('model', 'batch_size', self.param_batch_size.get()) user_config.set('model', 'net_verbose', self.param_net_verbose.get()) # user_config.set('model', 'gpu_mode', self.param_mode.get()) user_config.set('model', 'gpu_number', self.param_gpu_number.get()) # postprocessing parameters user_config.add_section('postprocessing') user_config.set('postprocessing', 't_bin', self.param_t_bin.get()) user_config.set('postprocessing', 'l_min', self.param_l_min.get()) user_config.set('postprocessing', 'min_error', self.param_min_error.get()) # Writing our configuration file to 'example.cfg' with open(os.path.join(self.path, 'config', 'configuration.cfg'), 'w') as config_file: user_config.write(config_file) def load_training_path(self): """ Select training path from disk and write it. If the app is run inside a container, link the iniitaldir with /data """ initialdir = '/data' if self.container else os.getcwd() fname = askdirectory(initialdir=initialdir) if fname: try: self.param_training_folder.set(fname) self.inFolderTxt.delete(0, END) self.inFolderTxt.insert(0, self.param_training_folder.get()) self.trainingBtn['state'] = 'normal' except: pass def load_testing_path(self): """ Selecet the inference path from disk and write it If the app is run inside a container, link the iniitaldir with /data """ initialdir = '/data' if self.container else os.getcwd() fname = askdirectory(initialdir=initialdir) if fname: try: self.param_test_folder.set(fname) self.test_inFolderTxt.delete(0, END) self.test_inFolderTxt.insert(0, self.param_test_folder.get()) self.inferenceBtn['state'] = 'normal' except: pass def update_pretrained_nets(self): """ get a list of the different net configuration present in the system. Each model configuration is represented by a folder containing the network weights for each of the networks. The baseline net config is always included by default """ folders = os.listdir(self.param_net_folder) self.list_train_pretrained_nets = folders self.list_test_nets = folders def write_to_console(self, txt): """ to doc: important method """ self.command_out.insert(END, str(txt)) def write_to_test_console(self, txt): """ to doc: important method """ self.test_command_out.insert(END, str(txt)) def infer_segmentation(self): """ Method implementing the inference process: - Check network selection - write the configuration to disk - Run the process on a new thread """ if self.param_inference_model.get() == 'None': print("ERROR: Please, select a network model before starting...\n") return if self.test_task is None: self.inferenceBtn.config(state='disabled') self.param_net_name.set(self.param_inference_model.get()) self.param_use_pretrained_model.set(False) self.write_user_configuration() print("\n-----------------------") print("Running configuration:") print("-----------------------") print("Inference model:", self.param_model_tag.get()) print("Inference folder:", self.param_test_folder.get(), "\n") print("Method info:") print("------------") self.test_task = ThreadedTask(self.write_to_test_console, self.test_queue, mode='testing') self.test_task.start() self.master.after(100, self.process_container_queue) def train_net(self): """ Method implementing the training process: - write the configuration to disk - Run the process on a new thread """ if self.param_net_name.get() == 'None': print("ERROR: Please, define network name before starting...\n") return self.trainingBtn['state'] = 'disable' if self.train_task is None: self.trainingBtn.update() self.write_user_configuration() print("\n-----------------------") print("Running configuration:") print("-----------------------") print("Train model:", self.param_net_name.get()) print("Training folder:", self.param_training_folder.get(), "\n") print("Method info:") print("------------") self.train_task = ThreadedTask(self.write_to_console, self.test_queue, mode='training') self.train_task.start() self.master.after(100, self.process_container_queue) def check_update(self): """ check update version and propose to download it if differnt So far, a rudimentary mode is used to check the last version. """ # I have to discard possible local changes :( print("---------------------------------------") print("Updating software") print("current version:", self.commit_version) remote_commit = subprocess.check_output(['git', 'stash']) remote_commit = subprocess.check_output(['git', 'fetch']) remote_commit = subprocess.check_output( ['git', 'rev-parse', 'origin/master']) if remote_commit != self.commit_version: proc = subprocess.check_output(['git', 'pull', 'origin', 'master']) self.check_link.config(text="Updated") self.commit_version = remote_commit print("updated version:", self.commit_version) else: print("This software is already in the latest version") print("---------------------------------------") def about_window(self): """ Window showing information about the software and version number, including auto-update. If the application is run from a container, then auto-update is disabled """ def callback(event): """ open webbrowser when clicking links """ webbrowser.open_new(event.widget.cget("text")) # main window t = Toplevel(self.master, width=500, height=500) t.wm_title("About") # NIC logo + name title = Label(t, text="nicMSlesions v" + self.version + "\n" "Multiple Sclerosis White Matter Lesion Segmentation") title.grid(row=2, column=1, padx=20, pady=10) img = ImageTk.PhotoImage(Image.open('./logonic.png')) imglabel = Label(t, image=img) imglabel.image = img imglabel.grid(row=1, column=1, padx=10, pady=10) group_name = Label(t, text="Copyright Sergi Valverde (2018-) \n " + "NeuroImage Computing Group") group_name.grid(row=3, column=1) group_link = Label(t, text=r"http://atc.udg.edu/nic", fg="blue", cursor="hand2") group_link.grid(row=4, column=1) group_link.bind("<Button-1>", callback) license_content = "Licensed under the BSD 2-Clause license. \n" + \ "A copy of the license is present in the root directory." license_label = Label(t, text=license_content) license_label.grid(row=5, column=1, padx=20, pady=20) # if self.container is False: # # check version and updates # version_number = Label(t, text="commit: " + self.commit_version) # version_number.grid(row=6, column=1, padx=20, pady=(1, 1)) # # self.check_link = Button(t, # text="Check for updates", # command=self.check_update) # self.check_link.grid(row=7, column=1) def process_container_queue(self): """ Process the threading queue. When the threaded processes are finished, buttons are reset and a message is shown in the app. """ self.process_indicator.set('Running... please wait') try: msg = self.test_queue.get(0) self.process_indicator.set('Done. See log for more details.') self.inferenceBtn['state'] = 'normal' self.trainingBtn['state'] = 'normal' except multiprocessing.queues.Empty: self.master.after(100, self.process_container_queue) def close_event(self): """ Stop the thread processes using OS related calls. """ if self.train_task is not None: self.train_task.stop_process() if self.test_task is not None: self.test_task.stop_process() os.system('cls' if platform.system == "Windows" else 'clear') root.destroy()
class GUI_signup(): from Mysqsl_module import Connector as consql def __init__(self, clear: bool): self.id_user = -1 self.checked = False self.reader = PyFingerprint('/dev/ttyUSB0', 57600, 0xFFFFFFFF, 0x00000000) if clear: self.reader.clearDatabase() if (self.reader.verifyPassword() == False): raise ValueError('The given fingerprint sensor password is wrong!') options = [ 'User name:', 'User password:'******'Check in time:', 'Departure time:' ] self.txtWidgets = {} self.gui = Tk(className='Sign up a new fingerprint') self.gui.geometry("700x600+450+70") self.gui.config(bg="#3465A4") self.photo = getImage(os.path.dirname(__file__) + "/reader.gif") self.gui.iconphoto(False, self.photo) r = 0 for op in options: lbl = Label(text=op, relief=RIDGE) lbl.grid(row=r, column=0, padx=10, pady=10) lbl.config(width=20, height=2) txt = Text(bg="white", relief=SUNKEN, width=50, height=2, fg="black") txt.grid(row=r, column=1) self.txtWidgets.update({op: txt}) r += 1 self.txtVarAction = StringVar() self.lblAction = Label(bg="#3465A4", fg="white", textvariable=self.txtVarAction) self.lblAction.grid(row=r, column=0, padx=10, pady=20) self.txtVarAction.set("Not reading finger yet") r += 1 self.lblImageFinger = Label(bg="#729FCF", fg="black") self.lblImageFinger['image'] = self.photo self.lblImageFinger.grid(row=r, column=0, padx=10, pady=10) self.btnReadFinger = Button(text="Read fingerprint", command=self.startFingerPrint) self.btnReadFinger.grid(row=r + 1, column=0, padx=10) self.btnReadFinger.config(width=20, height=2) btnStore = Button(text="Store data in database", command=self.storageDatabase) btnStore.grid(row=r, column=1) def storageDatabase(self): for txts in self.txtWidgets.values(): if not txts.get(1.0, 'end').strip(): messagebox.showerror(message="All data files must be typed", title="Values empty") return if self.id_user == -1: messagebox.showerror( message="You must scan your finger to get your id", title="Not scanned finger yet") return msg, flag = self.consql.exeProcedure('Insert_user', [ self.id_user, self.txtWidgets['User name:'].get( 1.0, 'end').strip(), self.txtWidgets['User password:'******'end').strip(), self.txtWidgets['Check in time:'].get( 1.0, 'end').strip(), self.txtWidgets['Departure time:'].get(1.0, 'end').strip() ], (0, 1)) if flag == 0: messagebox.showerror(title='Error in insertion', message=msg) else: self.id_user = -1 self.lblImageFinger['image'] = self.photo messagebox.showinfo(title='All is ok', message=msg) def startFingerPrint(self): threading.Thread(target=self.readFingerPrint, args=("Thread Reader")).start() def readFingerPrint(self, *argss): try: print('Waiting for finger...') self.txtVarAction.set("Waiting for finger...") while (self.reader.readImage() == False): pass self.reader.convertImage(0x01) result = self.reader.searchTemplate() positionNumber = result[0] if (positionNumber >= 0): print('Template already exists at position #' + str(positionNumber)) self.txtVarAction.set("Template already\nexists") return print('Remove finger...') self.txtVarAction.set("Remove finger...") time.sleep(2) print('Waiting for same finger again...') self.txtVarAction.set('Waiting for same finger again...') ## Wait that finger is read again while (self.reader.readImage() == False): pass print('Downloading image (this take a while)...') self.txtVarAction.set('Downloading image\n(this take a while)...') imagePath = os.path.dirname(__file__) + "/fingerprint.bmp" self.reader.downloadImage(imagePath) self.reader.convertImage(0x02) if (self.reader.compareCharacteristics() == 0): print('Fingers do not match') self.txtVarAction.set('Fingers do not match') return self.reader.createTemplate() self.id_user = self.reader.storeTemplate() + 1 print('The image was saved to "' + imagePath + '".') print('Finger enrolled successfully!') self.txtVarAction.set('Finger enrolled successfully!') self.fingerImage = getImage(imagePath) self.lblImageFinger['image'] = self.fingerImage print('New template position #' + str(self.id_user - 1)) except Exception as e: print('Operation failed!') self.txtVarAction.set('Operation failed!') print('Exception message: ' + str(e)) return def run(self): self.gui.mainloop()
buttons[previousx,previousy]['text']= ' ' buttons[x,y]['text']= ' ' else: buttons[previousx,previousy]['command']=DISABLED buttons[x,y]['command']=DISABLED first=True win=Tk() winsound.PlaySound('Little_Jam.wav', winsound.SND_ALIAS | winsound.SND_ASYNC) win.title("TileMatcher") win.resizable(width=False,height=True) first=True previousx=0 previousy=0 buttons={} button_symbols={} symbol=[u'\u2702',u'\u2705',u'\u2708',u'\u2709',u'\u270B',u'\u270A',u'\u270C',u'\u270F',u'\u2712',u'\u2714',u'\u2716',u'\u2728', u'\u2702',u'\u2705',u'\u2708',u'\u2709',u'\u270B',u'\u270A',u'\u270C',u'\u270F',u'\u2712',u'\u2714',u'\u2716',u'\u2728'] random.shuffle(symbol) hel = tkFont.Font(size=22, weight='bold') for x in range(6): for y in range(4): button=Button(command= lambda x=x,y=y: show_symbol(x,y),width=8,height=4,bg='#000',fg='#fff',borderwidth="2px") button['font'] = hel button.config(relief=GROOVE) button.grid(column=x,row=y) buttons[x,y]=button button_symbols[x,y]=symbol.pop() win.mainloop()
class Wizard(Frame): def __init__(self, parent, data): super().__init__(parent) self.parent = parent self.current_step = None self.current_step_index = 0 self.steps = [] self.data = data self.button_frame = Frame(self, bd=1, relief="raised") self.content_frame = Frame(self) self.back_button = Button(self.button_frame, text="<< Back", command=self.back) self.next_button = Button(self.button_frame, text="Next >>", command=self.next) self.finish_button = Button(self.button_frame, text="Finish", command=self.finish) #self.content_frame.pack_propagate(0) # Don't allow the widgets inside to determine the frame's width / height self.content_frame.pack(side="top", fill="both", expand=True) #self.button_frame.pack_propagate(0) self.button_frame.pack(side="bottom", fill="x") print("wizard bound to step_complete event") self.bind("<<step_complete>>", self.step_complete) # Example custom event call for above bind() # self.event_generate("<<step_complete>>", when="tail") def step_complete(self, event): #print("Wizard:step_complete()") self.next_button.config(state="normal") self.finish_button.config(state="normal") def set_steps(self, steps): self.steps = steps def start(self): self.show_step(self.current_step_index) def back(self): self.current_step_index -= 1 self.show_step(self.current_step_index) def next(self): self.current_step_index += 1 self.show_step(self.current_step_index) def finish(self): self.current_step_index = 0 print("data is: ") print(self.data) self.parent.quit() def show_step(self, step): if step < len(self.steps): if self.current_step is not None: # remove current step self.current_step.onscreen_exit() self.current_step.pack_forget() self.current_step = self.steps[step] self.current_step.pack(fill="both", expand=True) self.current_step.onscreen_enter() if len(self.steps) != 0: if len(self.steps) == 1: self.back_button.pack_forget() self.next_button.pack_forget() self.finish_button.pack(side="right") elif step == 0: # first step self.back_button.pack_forget() self.next_button.pack(side="right") self.finish_button.pack_forget() elif step == len(self.steps)-1: # last step self.back_button.pack(side="left") self.next_button.pack_forget() self.finish_button.pack(side="right") else: # all other steps self.back_button.pack(side="left") self.next_button.pack(side="right") self.finish_button.pack_forget() else: self.back_button.pack_forget() self.next_button.pack_forget() self.finish_button.pack(side="right") if self.current_step is not None: if self.current_step.allow_next(): self.next_button.config(state="normal") self.finish_button.config(state="normal") else: self.next_button.config(state="disabled") self.finish_button.config(state="disabled") if not self.current_step.allow_previous(): self.back_button.pack_forget()
class QueryBrowserUI(Tk): appName = "PySQLiTk3 - query browser" initSize = "900x600" configFile = 'conf.ini' sqlSqliteUrl = "http://www.sqlite.org/lang.html" tablesAtLeft = True selectedTable = '' def __init__(self, app): self.app = app super().__init__() self.configureLocale() self.title(self.appName) self.geometry(self.initSize) self.createMenu() self.createContent() self.loadLastDataBaseFile() def configureLocale(self): if sys.platform.startswith('win'): import locale if os.getenv('LANG') is None: lang, enc = locale.getdefaultlocale() os.environ['LANG'] = lang textdomain("app") bindtextdomain("app","./locale") def start(self): self.mainloop() def createMenu(self): menu = Menu(self) self.config(menu=menu) #File mnFile = Menu(menu, tearoff=0) menu.add_cascade(label=_("File"), underline=0, menu=mnFile) mnFile.add_command(label=_("New..."), underline=0, command=lambda cmd='NEW': self.onCommand(cmd)) mnFile.add_command(label=_("Open..."), underline=0, command=lambda cmd='OPEN': self.onCommand(cmd)) mnFile.add_separator() mnFile.add_command(label=_("Quit"), underline=0, command=lambda cmd='EXIT': self.onCommand(cmd)) #View self.mnView = Menu(menu, tearoff=0) menu.add_cascade(label=_("View"), underline=0, menu=self.mnView) self.mnView.add_command(label=_("Tables at %s") % _('right'), underline=0, command=lambda cmd='TABLES_RL': self.onCommand(cmd)) #Help mnHelp = Menu(menu, tearoff=0) menu.add_cascade(label=_("Help"), underline=0, menu=mnHelp) mnHelp.add_command(label=_("SQL by SQLite..."), underline=0, command=lambda: webbrowser.open(self.sqlSqliteUrl)) mnHelp.add_command(label=_("About..."), underline=0, command=lambda cmd='ABOUT': self.onCommand(cmd)) def createContent(self): # Top Panel: --------------------------------- pnlTop = Frame(self) pnlTop.pack(side="top", fill="both", pady=10, padx=10) self.btnDB = Button(pnlTop, text=_("Open Data Base..."), command=lambda cmd='OPEN': self.onCommand(cmd)) self.btnDB.grid(row=1, column=2, padx=5) # Query Panel: ----------------------------------- self.pnlQuery = Frame(self) self.pnlQuery.pack(side="right", fill="both", expand=True, padx=10) #-- SQL Panel: pnlSQL = Frame(self.pnlQuery) pnlSQL.pack(side="top", fill="both") Label(pnlSQL, text = "SQL:").grid(row=1, column=1, padx=5) self.txtSQL = TextSQL(pnlSQL, height=10, width = 60) self.txtSQL.grid(row=1, column=2, padx=5, pady=10) Button(pnlSQL, text = _("Run"), command=lambda cmd='RUN': self.onCommand(cmd)).grid(row=1, column=3, padx=5) #-- Buttons Panel pnlBtns = Frame(pnlSQL) pnlBtns.grid(row=2, column=2) Button(pnlBtns, text='INSERT', width = 12, command=lambda cmd='QUERY',query='INSERT': self.onCommand(cmd,query=query)).grid(row=1, column=1) Button(pnlBtns, text='SELECT', width = 12, command=lambda cmd='QUERY',query='SELECT': self.onCommand(cmd,query=query)).grid(row=1, column=2) Button(pnlBtns, text='UPDATE', width = 12, command=lambda cmd='QUERY',query='UPDATE': self.onCommand(cmd,query=query)).grid(row=1, column=3) Button(pnlBtns, text='DELETE', width = 12, command=lambda cmd='QUERY',query='DELETE': self.onCommand(cmd,query=query)).grid(row=1, column=4) #-- Result Panel: self.pnlResult = Frame(self.pnlQuery) self.pnlResult.pack(side="top", fill="both", expand=True, pady=10, padx=10) self.resultGrid = TextResult(self.pnlResult) self.resultGrid.pack(side="top", fill="both", expand=True) #Table List Panel: --------------------------------------- self.pnlTables = Frame(self) self.pnlTables.pack(side="left", fill="both", pady=10, padx=10) #---Tables Buttons Panel: self.pnlTableList = Frame(self.pnlTables) self.pnlTableList.pack(side="top", fill="both", pady=10) #---Panel Nueva: Button pnlNewTable = Frame(self.pnlTables) pnlNewTable.pack(side="bottom", pady=10, padx=10) Button(pnlNewTable, text=_("New Table"), command=lambda cmd='QUERY',query='CREATE': self.onCommand(cmd,query=query,table='<table>')).grid(row=1, column=2, padx=5) def tableContextMenu(self, event, table=''): popup = Menu(self, tearoff=0) popup.add_command(label=_("Add Column"), command=lambda cmd='QUERY',query='ADD', table=table: self.onCommand(cmd,query=query,table=table)) popup.add_command(label=_("Rename Table"), command=lambda cmd='QUERY',query='RENAME', table=table: self.onCommand(cmd,query=query,table=table)) popup.add_command(label=_("Drop Table"), command=lambda cmd='QUERY',query='DROP', table=table: self.onCommand(cmd,query=query,table=table)) popup.post(event.x_root, event.y_root) def showTables(self): tables = self.app.getTables() self.pnlTableList.destroy() self.pnlTableList = Frame(self.pnlTables) self.pnlTableList.pack(side="top", fill="both", pady=10) self.btnTables = {} Label(self.pnlTableList, text=_('Tables')).grid(row=0, column=1) for n,table in enumerate(tables): self.btnTables[table] = Button(self.pnlTableList, text=table,width=20, command=lambda cmd='QUERY',query='SELECT',table=table: self.onCommand(cmd,query=query,table=table)) self.btnTables[table].grid(row=n+1, column=1) self.btnTables[table].bind("<Button-3>", lambda event, table=table:self.tableContextMenu(event, table)) if table == self.selectedTable: self.markTable(table) def onCommand(self, comando, **args): comandos = { 'NEW':self.newDataBaseFile, 'OPEN':self.openDataBaseFile, 'EXIT':self.exitApp, 'ABOUT':self.about, 'QUERY':self.showQuery, 'RUN':self.run, 'TABLES_RL': self.showTablesAtRightOrLeft } try: comandos[comando](**args) except KeyError: showerror(_('Error'), _('Unknown command: ')+ comando) def exitApp(self): self.destroy() def about(self): showinfo(_('About...'), self.appName+'\n'+_('Desarrollado por:')+'\n'+_('Martín Nicolás Carbone')+'\n'+_('Agosto 2014')) def showTablesAtRightOrLeft(self): self.tablesAtLeft = not self.tablesAtLeft querySide, tablesSide = ("right", "left") if self.tablesAtLeft else ("left", "right") self.pnlTables.pack(side=tablesSide, fill="both", pady=10, padx=10) self.pnlQuery.pack(side=querySide, fill="both", expand=True, padx=10) self.mnView.entryconfigure(0, label=_("Tables at %s") % _(querySide)) def selectTable(self, table): self.unMarkTable(self.selectedTable) self.selectedTable = table if table != '' else self.selectedTable self.markTable(self.selectedTable) return self.selectedTable def unMarkTable(self, table): try: self.btnTables[table].config(relief='raised') except KeyError: pass def markTable(self, table): try: self.btnTables[table].config(relief='sunken') except KeyError: pass def newDataBaseFile(self): path = asksaveasfilename(defaultextension=".db") if path != '': self.openDataBase(path) def openDataBaseFile(self): path = askopenfilename(filetypes=((_("Data base files"), "*.db;*.dat;*.sqlite;*.sqlite3;*.sql;"),(_("All files"), "*.*") )) if path != '': self.openDataBase(path) def loadLastDataBaseFile(self): path = self.readPath() if path != '': self.openDataBase(path) def savePath(self, path): with open(self.configFile, 'w') as f: f.write(str(path)) def readPath(self): try: with open(self.configFile, 'r') as f: return str(f.read()) except IOError: return '' def openDataBase(self, path): self.basePath = path if path != '' else self.basePath try: self.app.openDataBase(self.basePath) self.savePath(self.basePath) self.btnDB.config(text=self.basePath) self.selectedTable = '' self.showTables() except IOError: showerror(_('Error'),_('Error')+' '+_("Open Data Base...")) def showQuery(self, query, table=''): table = self.selectTable(table) sql=self.app.createQuery(query, table) self.txtSQL.setText(sql) def run(self): query = self.txtSQL.getText() result = self.app.runQuery(query) self.resultGrid.setText(result) if result == '': self.showTables()
lbl_apellido.grid(row=1, column=0, padx=10, pady=10, sticky="e") lbl_edad.grid(row=2, column=0, padx=10, pady=10, sticky="e") lbl_comentario.pack(side="left", fill="both", expand=True, padx=10, pady=10) # Colocando Entry entry_nombre.grid(row=0, column=1, padx=10, pady=10) entry_apellido.grid(row=1, column=1, padx=10, pady=10) entry_edad.grid(row=2, column=1, padx=10, pady=10) # Colocando el Text y los Scrollbar txt_comentario.grid(row=0, column=0, sticky="nsew") scrolly.grid(row=0, column=1, sticky="ns") scrollx.grid(row=1, column=0, sticky="ew") # Colocando el Button btn_enviar.pack(side="bottom", padx=10, pady=10) btn_enviar.config(relief="flat") fr_text.grid_rowconfigure(0, weight=1) fr_text.grid_columnconfigure(0, weight=1) # Colocando Frames fr_top.pack(side="top") fr_bottom.pack(side="bottom") fr_text.pack(side="right") fr_principal.pack(fill="both", expand=True) # Configurando la raiz root.title("Prueba Scrollbar") root.mainloop()
class GUI(Frame): def __init__(self, game, size, margin, colors=('black', 'white'), master=None): color = '#333333' Frame.__init__(self, master, bg=color) self.game = game self.cell_size = (size - 2*margin) / self.game.size self.coordinates = lambda position: self.cell_size * (np.array(position) + 1/2) + margin self.player_move = lambda event: self.move(pause=1000, event=event) self.grid() self.master.title("Pythello") self.colors = colors[::-1] # Flip color order so that the first color input corresponds to player 1 max_turns = self.game.size**2 - 4 figure = Figure(figsize=(size/100, size/100), dpi=100, facecolor=color) axes = figure.add_subplot(111, axisbg=color) self.line = axes.plot(0, 0, 'w-', [0, max_turns], [0, 0], 'w--')[0] axes.grid(True, color='w') axes.set_xlim(0, max_turns) axes.set_ylim(-max_turns, max_turns) [tick.set_color('w') for axis in [axes.xaxis, axes.yaxis] for tick in axis.get_ticklines()] [label.set_color('w') for axis in [axes.xaxis, axes.yaxis] for label in axis.get_ticklabels()] [axes.spines[side].set_color('w') for side in ['top', 'bottom', 'left', 'right']] self.canvas = Canvas(self, width=size, height=size, background=color, highlightthickness=0) self.canvas.create_rectangle(margin, margin, size - margin, size - margin, outline='white') self.canvas.grid(row=0, column=1, rowspan=50) self.figure = FigureCanvasTkAgg(figure, master=self) self.figure.get_tk_widget().grid(row=0, column=2, rowspan=50) self.refresh() if all([isinstance(player, AI) for player in self.game.players]): self.play_button = Button(self, text='Play', highlightbackground=color, command=self.play) self.move_button = Button(self, text='Move', highlightbackground=color, command=self.move) self.reset_button = Button(self, text='Reset', highlightbackground=color, command=self.reset) self.play_button.grid(row=0, column=0) self.move_button.grid(row=1, column=0) self.reset_button.grid(row=2, column=0) self.running = False else: Button(self, text='Reset', highlightbackground=color, command=self.reset).grid(row=0, column=0) self.running = True for i in range(self.game.size): line_shift = self.cell_size * (i+1) + margin self.canvas.create_text(margin-10, line_shift - self.cell_size/2, text=str(i+1), fill='white') self.canvas.create_text(line_shift - self.cell_size/2, margin-10, text=chr(97+i), fill='white') self.canvas.create_line(margin, line_shift, size - margin, line_shift, fill='white') self.canvas.create_line(line_shift, margin, line_shift, size - margin, fill='white') def configure_buttons(self): (state, text, command) = ('disabled', 'Pause', self.pause) if self.running else ('normal', 'Reset', self.reset) self.play_button.config(state=state) self.move_button.config(state=state) self.reset_button.config(text=text, command=command) def draw_piece(self, position, radius, color): (y, x) = self.coordinates(position) return self.canvas.create_oval(x-radius, y-radius, x+radius, y+radius, fill=color, tags='circle') def move(self, pause=10, event=None): if event is None: move = self.game.player.move(self.game) else: move = eval(self.canvas.gettags(event.widget.find_withtag("current"))[-2]) self.game.move(move) is_over = self.game.is_over() self.refresh() if not is_over and isinstance(self.game.player, AI) and self.running: self.after(pause, self.move) elif is_over: self.reset_button.config(text='Reset', command=self.reset) def pause(self): self.running = False self.configure_buttons() def play(self): self.running = True self.configure_buttons() self.move() def refresh(self): self.line.set_data(range(len(self.game.score)), self.game.score) self.figure.draw() [self.canvas.delete(tag) for tag in ['circle', 'text']] for position in zip(*np.nonzero(self.game.board)): color = self.colors[int((self.game.board[position] + 1) / 2)] self.draw_piece(position, (self.cell_size-2) / 2, color) if not isinstance(self.game.player, AI): for position in self.game.valid: (y, x) = self.coordinates(position) turned = len(self.game.valid[position]) - 1 valid = self.draw_piece(position, self.cell_size / 4, 'green') self.canvas.addtag(str(position), 'withtag', valid) text = self.canvas.create_text(x+1, y+1, text=str(turned), tags=('text', str(position))) [self.canvas.tag_bind(tag, "<Button-1>", self.player_move) for tag in [valid, text]] def reset(self): self.running = not all([isinstance(player, AI) for player in self.game.players]) self.game.reset() self.refresh() if not self.running: self.configure_buttons()
class h2incGUI: def __init__(self, master): self.sourcedir = StringVar() self.destdir = StringVar() self.addinc = StringVar() self.infofolder = 'Number of folders: 0' self.infofile = 'Number of headers: 0' self.sourcedir.set('Select source directory!') self.destdir.set('Select destination directory!') self.master = master self.master.title('Translate C-header files to Nasm include files!') self.master.grid_columnconfigure(1, weight=1) self.frame = LabelFrame(master, text='Select folders') self.frame.grid(row=0, column=0, columnspan=3, sticky=N + S + E + W, padx=5, pady=5) self.frame.grid_columnconfigure(1, weight=1) self.sourcelabel = Label(self.frame, text='Source: ') self.sourcelabel.grid(row=0, column=0, sticky=E, padx=(5, 1), pady=5) self.sourceentry = Entry(self.frame, textvariable=self.sourcedir) self.sourceentry.grid(row=0, column=1, sticky=E + W, pady=5) self.sourcedir_button = Button(self.frame, text="Source directory...", command=lambda: self.select_sourcedir( self.sourcedir, self.infofiles)) self.sourcedir_button.grid(row=0, column=2, sticky=W, padx=(3, 5), pady=5) self.destlabel = Label(self.frame, text='Destination: ') self.destlabel.grid(row=1, column=0, sticky=E, padx=(5, 1), pady=5) self.destlabel.config(state=DISABLED) self.destentry = Entry(self.frame, textvariable=self.destdir) self.destentry.grid(row=1, column=1, sticky=E + W, pady=5) self.destentry.config(state=DISABLED) self.destdir_button = Button( self.frame, text="Destination directory...", command=lambda: self.select_destdir(self.destdir)) self.destdir_button.grid(row=1, column=2, sticky=W, padx=(3, 5), pady=5) self.destdir_button.config(state=DISABLED) self.incchkbox = Checkbutton( self.frame, text='Create "include" folder if it does not exist.', variable=self.addinc, onvalue='yes', offvalue='no') self.incchkbox.grid(row=2, column=0, columnspan=2, sticky=W, padx=5, pady=5) self.incchkbox.config(state=DISABLED) self.addinc.set('yes') self.transframe = LabelFrame(master, text='Translation') self.transframe.grid(row=1, rowspan=2, column=0, columnspan=3, sticky=N + S + E + W, padx=5, pady=5) self.transframe.grid_columnconfigure(1, weight=1) self.transframe.grid_rowconfigure(1, weight=1) self.infoframe = LabelFrame(self.transframe, text='Source information') self.infoframe.grid(row=1, rowspan=2, column=0, columnspan=3, sticky=N + S + E + W, padx=5, pady=5) self.infoframe.grid_columnconfigure(1, weight=1) self.infofolders = Label(self.infoframe, text=self.infofolder) self.infofolders.grid(row=0, column=0, sticky=W, padx=5, pady=5) self.infofolders.config(state=DISABLED) self.infofiles = Label(self.infoframe, text=self.infofile) self.infofiles.grid(row=1, column=0, sticky=W, padx=5, pady=5) self.infofiles.config(state=DISABLED) self.translate_button = Button( self.transframe, text="Translate!", command=lambda: self.select_destdir(self.destdir)) self.translate_button.grid(row=3, column=0, sticky=W, padx=5, pady=5) self.translate_button.config(state=DISABLED) def select_sourcedir(self, sourcedir, infofile): root.directory = os.path.abspath(filedialog.askdirectory()) if root.directory: sourcedir.set(root.directory) filecnt = sourcedir_filecnt(root.directory) if filecnt > 0: tempstr = 'Number of headers: ' + str(filecnt) print('Source directory: ', sourcedir.get()) self.destlabel.config(state=NORMAL) self.destentry.config(state=NORMAL) self.destdir_button.config(state=NORMAL) self.infofiles.config(text=tempstr) foldercnt = sourcedir_foldercnt(root.directory) if foldercnt > 0: tempstr = 'Number of folders: ' + str(foldercnt) self.infofolders.config(text=tempstr) def select_destdir(self, destdir): root.directory = filedialog.askdirectory() if root.directory: destdir.set(root.directory) print('Destination directory: ', destdir.get()) self.incchkbox.config(state=NORMAL) self.infofolders.config(state=NORMAL) self.infofiles.config(state=NORMAL) self.translate_button.config(state=NORMAL)
class BackupGuiTk(Frame): """ The main widget of the robobackup GUI made with tkinter. """ def __init__(self, method=None, master=None): self.method = method self.picframe = Frame.__init__(self, master) self.master.title("Robobackup") self.image = PhotoImage() self.image["file"] = os.path.join(os.path.dirname(\ os.path.relpath(__file__)), "resources", "ASK.png") self.piclabel = Label(self.picframe, image=self.image) self.piclabel.grid(row=0, column=0, columnspan=4, rowspan=6) self.clocklabel = Label(self.picframe, text=_("Elapsed time:")) self.clocklabel.grid(row=0, column=4, sticky="NSEW") self.clock = Label(self.picframe, text="") self.clock.grid(row=1, column=4, sticky="NSEW") self.start = Button(self.picframe, text=_("Start Backup"), command=self.__clk) self.start.grid(row=3, column=4, sticky="NSEW") self.errorlabel = Label(self.picframe) self.errorlabel.grid(row=4, column=4, sticky="NSEW") self.close = Button(self.picframe, text=_("Close"), command=self.__cls) self.close.grid(row=5, column=4, sticky="NSEW") self.loglabel = Label(self.picframe, text=_("Log:"), justify="left") self.loglabel.grid(row=6, column=0, columnspan=5, sticky="NSEW") self.text = Text(self.picframe) self.text.grid(row=7, column=0, rowspan=6, columnspan=5, sticky="NSEW") self.timeout = False self.starttime = -1 def __clk(self): """ This method starts the backup. It is a slot which is connected to the signal "click" of the button "btnStart". """ self.start.config(state="disabled") self.close.config(state="disabled") self.clock_tick() try: self.method() except: if __debug__: logbook.exception("") self.set_backup_failure() messagebox.showinfo(_("Critical"), _("Robobackup " \ "failed. Contact your admin.")) finally: self.timeout = True self.close.config(state="normal") def __cls(self): """ This method is used to close the GUI. """ self.master.destroy() def clock_tick(self): """ This is used to count the seconds the backup method runs. """ if not self.timeout: self.starttime = int(time.time() * 1000) milliseconds = int(time.time() * 1000) - self.starttime seconds, milliseconds = divmod(milliseconds, 1000) minutes, seconds = divmod(seconds, 60) hours, minutes = divmod(minutes, 60) digitalclock = "{hh:02d}:{mm:02d}:{ss:02d}".format(hh=hours, \ mm=minutes, ss=seconds) self.clock.configure(text=digitalclock) if not self.timeout: self.master.after(1000, self.clock_tick) def update(self): """ This method will be called, if logs are changing. """ color = logbook.get_severity() self.set_log(logbook.get_string()) if color is Severity.green: self.set_backup_success() elif color is Severity.orange: self.set_backup_check() elif color is Severity.red: self.set_backup_failure() else: raise RuntimeError(_("Color does not match an action.")) def set_backup_success(self): """ Set everything green. """ self.errorlabel.configure(text=_("Success")) self.errorlabel["bg"] = "green" self.image["file"] = os.path.join(os.path.dirname(\ os.path.relpath(__file__)), "resources", "SUCCESS.png") def set_backup_check(self): """ Set everything orange. """ self.errorlabel.configure(text=_("Check backup")) self.errorlabel["bg"] = "orange" self.image["file"] = os.path.join(os.path.dirname(\ os.path.relpath(__file__)), "resources", "CHECK.png") def set_backup_failure(self): """ Set everything red. """ self.errorlabel.configure(text=_("Failure")) self.errorlabel["bg"] = "red" self.image["file"] = os.path.join(os.path.dirname(\ os.path.relpath(__file__)), "resources", "FAIL.png") def set_log(self, log): """ Write text to the GUI. """ self.text.delete("1.0", END) self.text.insert(END, log)
def view_details(self, Medikom, id): self.selected_id = id self.overview(Medikom) entry_results, attachments = Medikom.get_entry(id) ts, title, notes = entry_results ts = self.format_ts(ts)[:-3] details_text = 'Details zu %s (zuletzt geändert am %s)' % (title, ts) details_label = Label( self, text=details_text, font='Liberation 10', fg='Black', anchor='w') details_label.place( x=self.SPACE_TWO, y=(self.n + 2) * (self.ROW_HIGHT + self.ROW_SPACE), width=self.WIN_WIDTH - self.SPACE_TWO, height=self.ROW_HIGHT) details_label.bind(sequence='<Button-1>', func=Callable(self.view_edit_title, Medikom, id, title)) # add attachment button and list attachments attach_button = Button( self, text='Neuer Anhang', command=lambda: self.attach_file(Medikom, id)) attach_button.place( x=self.SPACE_TWO, y=(self.n + 3) * (self.ROW_HIGHT + self.ROW_SPACE), width=self.WIN_WIDTH / 8, height=self.ROW_HIGHT) if attachments: xpos = (1.5 * self.SPACE_TWO) + (self.WIN_WIDTH / 8) for i, attachment in enumerate(attachments): attachment = attachment[0] filename = '' if '\\' in attachment: filename = attachment.split('\\')[-1] elif '/' in attachment: filename = attachment.split('/')[-1] width = len(filename) * 7.2 attachment_button = Button( self, text=filename, font='Courier 9', fg="blue", command=Callable(self.open_attachment, attachment)) attachment_button.place( x=xpos, y=(self.n + 3) * (self.ROW_HIGHT + self.ROW_SPACE), width=width, height=self.ROW_HIGHT) xpos = xpos + width + (self.SPACE_TWO/2) attachment_button.config(relief='flat') attachment_button.bind(sequence='<Button-3>', func=Callable(self.unattach_file, Medikom, id, attachment)) # text element and scrollbar textframe = Text( self, font='Liberation 12', height=self.TEXT_FRAME_LINES, width=int(self.WIN_WIDTH / 4)) scrollbar = Scrollbar(self) textframe.place( x=self.SPACE_TWO, y=(self.n + 4) * (self.ROW_HIGHT + self.ROW_SPACE), width=self.WIN_WIDTH - self.SPACE_ONE - 10, height=self.ROW_HIGHT * self.TEXT_FRAME_LINES) scrollbar.place( x=self.SPACE_TWO + self.WIN_WIDTH - self.SPACE_ONE - 10, y=(self.n + 4) * (self.ROW_HIGHT + self.ROW_SPACE), width=10, height=self.ROW_HIGHT * self.TEXT_FRAME_LINES) scrollbar.config(command=textframe.yview) textframe.config(yscrollcommand=scrollbar.set) textframe.insert(END, notes) # update button update_button = Button( self, text='Text Aktualisieren', command=lambda: self.update_entry_notes( Medikom, id, textframe.get(1.0, END))) update_button.place( x=self.WIN_WIDTH / 2 - 0.125 * self.WIN_WIDTH, y=(self.n + 4) * (self.ROW_HIGHT + self.ROW_SPACE) + (self.ROW_HIGHT * self.TEXT_FRAME_LINES + 5), width=self.WIN_WIDTH/4, height=self.ROW_HIGHT)
class LintGui: """Build and control a window to interact with pylint""" def __init__(self, root=None): """init""" self.root = root or Tk() self.root.title("Pylint") # reporter self.reporter = None # message queue for output from reporter self.msg_queue = queue.Queue() self.msgs = [] self.filenames = [] self.rating = StringVar() self.tabs = {} self.report_stream = BasicStream(self) # gui objects self.lbMessages = None self.showhistory = None self.results = None self.btnRun = None self.information_box = None self.convention_box = None self.refactor_box = None self.warning_box = None self.error_box = None self.fatal_box = None self.txtModule = None self.status = None self.msg_type_dict = None self.init_gui() def init_gui(self): """init helper""" # setting up frames top_frame = Frame(self.root) mid_frame = Frame(self.root) radio_frame = Frame(self.root) res_frame = Frame(self.root) msg_frame = Frame(self.root) check_frame = Frame(self.root) history_frame = Frame(self.root) btn_frame = Frame(self.root) rating_frame = Frame(self.root) top_frame.pack(side=TOP, fill=X) mid_frame.pack(side=TOP, fill=X) history_frame.pack(side=TOP, fill=BOTH, expand=True) radio_frame.pack(side=TOP, fill=BOTH, expand=True) rating_frame.pack(side=TOP, fill=BOTH, expand=True) res_frame.pack(side=TOP, fill=BOTH, expand=True) check_frame.pack(side=TOP, fill=BOTH, expand=True) msg_frame.pack(side=TOP, fill=BOTH, expand=True) btn_frame.pack(side=TOP, fill=X) # Message ListBox rightscrollbar = Scrollbar(msg_frame) rightscrollbar.pack(side=RIGHT, fill=Y) bottomscrollbar = Scrollbar(msg_frame, orient=HORIZONTAL) bottomscrollbar.pack(side=BOTTOM, fill=X) self.lbMessages = Listbox( msg_frame, yscrollcommand=rightscrollbar.set, xscrollcommand=bottomscrollbar.set, bg="white" ) self.lbMessages.pack(expand=True, fill=BOTH) rightscrollbar.config(command=self.lbMessages.yview) bottomscrollbar.config(command=self.lbMessages.xview) # History ListBoxes rightscrollbar2 = Scrollbar(history_frame) rightscrollbar2.pack(side=RIGHT, fill=Y) bottomscrollbar2 = Scrollbar(history_frame, orient=HORIZONTAL) bottomscrollbar2.pack(side=BOTTOM, fill=X) self.showhistory = Listbox( history_frame, yscrollcommand=rightscrollbar2.set, xscrollcommand=bottomscrollbar2.set, bg="white" ) self.showhistory.pack(expand=True, fill=BOTH) rightscrollbar2.config(command=self.showhistory.yview) bottomscrollbar2.config(command=self.showhistory.xview) self.showhistory.bind("<Double-Button-1>", self.select_recent_file) self.set_history_window() # status bar self.status = Label(self.root, text="", bd=1, relief=SUNKEN, anchor=W) self.status.pack(side=BOTTOM, fill=X) # labels self.lblRatingLabel = Label(rating_frame, text="Rating:") self.lblRatingLabel.pack(side=LEFT) self.lblRating = Label(rating_frame, textvariable=self.rating) self.lblRating.pack(side=LEFT) Label(mid_frame, text="Recently Used:").pack(side=LEFT) Label(top_frame, text="Module or package").pack(side=LEFT) # file textbox self.txtModule = Entry(top_frame, background="white") self.txtModule.bind("<Return>", self.run_lint) self.txtModule.pack(side=LEFT, expand=True, fill=X) # results box rightscrollbar = Scrollbar(res_frame) rightscrollbar.pack(side=RIGHT, fill=Y) bottomscrollbar = Scrollbar(res_frame, orient=HORIZONTAL) bottomscrollbar.pack(side=BOTTOM, fill=X) self.results = Listbox( res_frame, yscrollcommand=rightscrollbar.set, xscrollcommand=bottomscrollbar.set, bg="white", font="Courier" ) self.results.pack(expand=True, fill=BOTH, side=BOTTOM) rightscrollbar.config(command=self.results.yview) bottomscrollbar.config(command=self.results.xview) # buttons Button(top_frame, text="Open", command=self.file_open).pack(side=LEFT) Button(top_frame, text="Open Package", command=(lambda: self.file_open(package=True))).pack(side=LEFT) self.btnRun = Button(top_frame, text="Run", command=self.run_lint) self.btnRun.pack(side=LEFT) Button(btn_frame, text="Quit", command=self.quit).pack(side=BOTTOM) # radio buttons self.information_box = IntVar() self.convention_box = IntVar() self.refactor_box = IntVar() self.warning_box = IntVar() self.error_box = IntVar() self.fatal_box = IntVar() i = Checkbutton( check_frame, text="Information", fg=COLORS["(I)"], variable=self.information_box, command=self.refresh_msg_window, ) c = Checkbutton( check_frame, text="Convention", fg=COLORS["(C)"], variable=self.convention_box, command=self.refresh_msg_window, ) r = Checkbutton( check_frame, text="Refactor", fg=COLORS["(R)"], variable=self.refactor_box, command=self.refresh_msg_window ) w = Checkbutton( check_frame, text="Warning", fg=COLORS["(W)"], variable=self.warning_box, command=self.refresh_msg_window ) e = Checkbutton( check_frame, text="Error", fg=COLORS["(E)"], variable=self.error_box, command=self.refresh_msg_window ) f = Checkbutton( check_frame, text="Fatal", fg=COLORS["(F)"], variable=self.fatal_box, command=self.refresh_msg_window ) i.select() c.select() r.select() w.select() e.select() f.select() i.pack(side=LEFT) c.pack(side=LEFT) r.pack(side=LEFT) w.pack(side=LEFT) e.pack(side=LEFT) f.pack(side=LEFT) # check boxes self.box = StringVar() # XXX should be generated report = Radiobutton( radio_frame, text="Report", variable=self.box, value="Report", command=self.refresh_results_window ) rawMet = Radiobutton( radio_frame, text="Raw metrics", variable=self.box, value="Raw metrics", command=self.refresh_results_window ) dup = Radiobutton( radio_frame, text="Duplication", variable=self.box, value="Duplication", command=self.refresh_results_window ) ext = Radiobutton( radio_frame, text="External dependencies", variable=self.box, value="External dependencies", command=self.refresh_results_window, ) stat = Radiobutton( radio_frame, text="Statistics by type", variable=self.box, value="Statistics by type", command=self.refresh_results_window, ) msgCat = Radiobutton( radio_frame, text="Messages by category", variable=self.box, value="Messages by category", command=self.refresh_results_window, ) msg = Radiobutton( radio_frame, text="Messages", variable=self.box, value="Messages", command=self.refresh_results_window ) report.select() report.grid(column=0, row=0, sticky=W) rawMet.grid(column=1, row=0, sticky=W) dup.grid(column=2, row=0, sticky=W) msg.grid(column=3, row=0, sticky=E) stat.grid(column=0, row=1, sticky=W) msgCat.grid(column=1, row=1, sticky=W) ext.grid(column=2, row=1, columnspan=2, sticky=W) # dictionary for check boxes and associated error term self.msg_type_dict = { "I": lambda: self.information_box.get() == 1, "C": lambda: self.convention_box.get() == 1, "R": lambda: self.refactor_box.get() == 1, "E": lambda: self.error_box.get() == 1, "W": lambda: self.warning_box.get() == 1, "F": lambda: self.fatal_box.get() == 1, } self.txtModule.focus_set() def select_recent_file(self, event): """adds the selected file in the history listbox to the Module box""" if not self.showhistory.size(): return selected = self.showhistory.curselection() item = self.showhistory.get(selected) # update module self.txtModule.delete(0, END) self.txtModule.insert(0, item) def refresh_msg_window(self): """refresh the message window with current output""" # clear the window self.lbMessages.delete(0, END) for msg in self.msgs: if self.msg_type_dict.get(msg[0])(): msg_str = self.convert_to_string(msg) self.lbMessages.insert(END, msg_str) fg_color = COLORS.get(msg_str[:3], "black") self.lbMessages.itemconfigure(END, fg=fg_color) def refresh_results_window(self): """refresh the results window with current output""" # clear the window self.results.delete(0, END) try: for res in self.tabs[self.box.get()]: self.results.insert(END, res) except: pass def convert_to_string(self, msg): """make a string representation of a message""" if msg[2] != "": return "(" + msg[0] + ") " + msg[1] + "." + msg[2] + " [" + msg[3] + "]: " + msg[4] else: return "(" + msg[0] + ") " + msg[1] + " [" + msg[3] + "]: " + msg[4] def process_incoming(self): """process the incoming messages from running pylint""" while self.msg_queue.qsize(): try: msg = self.msg_queue.get(0) if msg == "DONE": self.report_stream.output_contents() return False # adding message to list of msgs self.msgs.append(msg) # displaying msg if message type is selected in check box if self.msg_type_dict.get(msg[0])(): msg_str = self.convert_to_string(msg) self.lbMessages.insert(END, msg_str) fg_color = COLORS.get(msg_str[:3], "black") self.lbMessages.itemconfigure(END, fg=fg_color) except queue.Empty: pass return True def periodic_call(self): """determine when to unlock the run button""" if self.process_incoming(): self.root.after(100, self.periodic_call) else: # enabling button so it can be run again self.btnRun.config(state=NORMAL) def mainloop(self): """launch the mainloop of the application""" self.root.mainloop() def quit(self, _=None): """quit the application""" self.root.quit() def halt(self): """program halt placeholder""" return def file_open(self, package=False, _=None): """launch a file browser""" if not package: filename = askopenfilename( parent=self.root, filetypes=[("pythonfiles", "*.py"), ("allfiles", "*")], title="Select Module" ) else: filename = askdirectory(title="Select A Folder", mustexist=1) if filename == (): return self.txtModule.delete(0, END) self.txtModule.insert(0, filename) def update_filenames(self): """update the list of recent filenames""" filename = self.txtModule.get() if not filename: filename = os.getcwd() if filename + "\n" in self.filenames: index = self.filenames.index(filename + "\n") self.filenames.pop(index) # ensure only 10 most recent are stored if len(self.filenames) == 10: self.filenames.pop() self.filenames.insert(0, filename + "\n") def set_history_window(self): """update the history window with info from the history file""" # clear the window self.showhistory.delete(0, END) # keep the last 10 most recent files try: view_history = open(HOME + HISTORY, "r") for hist in view_history.readlines(): if not hist in self.filenames: self.filenames.append(hist) self.showhistory.insert(END, hist.split("\n")[0]) view_history.close() except IOError: # do nothing since history file will be created later return def run_lint(self, _=None): """launches pylint""" self.update_filenames() self.root.configure(cursor="watch") self.reporter = GUIReporter(self, output=self.report_stream) module = self.txtModule.get() if not module: module = os.getcwd() # cleaning up msgs and windows self.msgs = [] self.lbMessages.delete(0, END) self.tabs = {} self.results.delete(0, END) self.btnRun.config(state=DISABLED) # setting up a worker thread to run pylint worker = Thread(target=lint_thread, args=(module, self.reporter, self)) self.periodic_call() worker.start() # Overwrite the .pylint-gui-history file with all the new recently added files # in order from filenames but only save last 10 files write_history = open(HOME + HISTORY, "w") write_history.writelines(self.filenames) write_history.close() self.set_history_window() self.root.configure(cursor="")
class Convert_Table_Auto(Frame): def __init__(self, master=None): self.cur_dir = os.getcwd() Frame.__init__(self, master) self.master = master window_width = 460 window_heigh = 510 x_pos = (screen_width / 2) - (window_width / 2) y_pos = (screen_heigh / 2) - (window_heigh / 2) # self.master.geometry("420x200") self.master.geometry('%dx%d+%d+%d' % (window_width, window_heigh, x_pos, y_pos)) self.master.title("Conver Table Automation") ###################################################################################################### self.config_file_PATH_label = Label(self.master, text="4G Config file path") self.config_file_PATH_label.grid(row=0, column=0, sticky=W, pady=2) self.config_file_PATH_txt = Text(self.master, heigh=1, width=35) self.config_file_PATH_txt.grid(row=0, column=1, pady=2) self.config_file_PATH_label_5g = Label(self.master, text="5G Config file path") self.config_file_PATH_label_5g.grid(row=1, column=0, sticky=W, pady=2) self.config_file_5g_PATH_txt = Text(self.master, heigh=1, width=35) self.config_file_5g_PATH_txt.grid(row=1, column=1, pady=2) self.log_file_PATH_label = Label(self.master, text="Log files dir") self.log_file_PATH_label.grid(row=2, column=0, sticky=W, pady=2) self.log_file_PATH_txt = Text(self.master, heigh=1, width=35) self.log_file_PATH_txt.grid(row=2, column=1, pady=2) self.qcat_input_label = Label(self.master, text='') self.log_type_label = Label(self.master, text="Information") self.log_type_label.grid(row=3, column=0, sticky=W) self.log_type_txt = ScrolledText(self.master, undo=True, width=55) self.log_type_txt.grid(row=3, rowspan=4, column=0, columnspan=3, sticky=W) self.csv_dir_label = Label(self.master, text="CSV directory") self.csv_dir_label.grid(row=9, column=0, sticky=W) self.csv_dir_txt = Text(self.master, heigh=1, width=35) self.csv_dir_txt.grid(row=9, column=0, columnspan=3, padx=80, sticky=W) ###################################################################################################### self.convert_csv_button = Button(self.master, text='Convert to csv', command=self.call_convert_csv) self.convert_csv_button.grid(row=9, column=1, columnspan=2, sticky=E, pady=2, padx=3) self.convert_csv_button.config(width=11, heigh=2) self.extract_config_button = Button(self.master, text="Extract", command=self.call_extract) self.extract_config_button.grid(row=0, column=2, sticky=E, padx=4) # self.view_log_button = Button(self.master, text = "View") # self.view_log_button.grid(row=1, column=2, sticky=E, padx=4) ############################################################################### # creating a menu instance self.menu = Menu(self.master) self.master.config(menu=self.menu) # create the file object) self.file = Menu(self.menu) # adds a command to the menu option, calling it exit, and the # command it runs on event is client_exit # self.file.add_command(label="QCAT Automation", command = self.openQCAT) self.file.add_command(label="Open Config 4G", command=self.open_config) self.file.add_command(label="Open Config 5G", command=self.open_config_5g) self.file.add_command(label="Choose Log Files", command=self.open_log) self.file.add_command(label="Set CSV Directory", command=self.set_csv_directory) self.file.add_command(label="Exit", command=self.client_exit) self.menu.add_cascade(label="File", menu=self.file) # menu.add_cascade(label="Open config", menu=file) self.edit = Menu(self.menu) self.menu.add_cascade(label="Edit", menu=self.edit) self.help = Menu(self.menu) self.help.add_command(label="About", command=self.show_about) self.help.add_command(label="Instruction", command=self.show_instruction) self.menu.add_cascade(label="Help", menu=self.help) #################################################################################### def client_exit(self): exit() def is_uniconfig(self): if self.config_file_PATH_txt.get( '1.0', END) != '\n' and self.config_file_5g_PATH_txt.get( '1.0', END) != '\n': self.config_file_5g_PATH_txt.delete("1.0", "end") return False else: return True def open_config(self): ###Test # global config_file_PATH # config_file_PATH = r'G:\PycharmProjects\Log_Extractor\parser.cfg' if self.cur_dir == None: self.cur_dir = os.getcwd() filename = askopenfilename(initialdir=self.cur_dir, title="Select file", filetypes=(("config file", "*.cfg"), ("all files", "*.*"))) if filename: global config_file_PATH config_file_PATH = filename print(config_file_PATH) # self.update_text() self.config_file_PATH_txt.delete("1.0", "end") self.config_file_5g_PATH_txt.delete("1.0", "end") self.config_file_PATH_txt.insert(END, config_file_PATH) else: showerror("Error", "No file selected") if self.is_uniconfig() == False: showerror("Error", "Cannot choose more than two config files!!!") def open_config_5g(self): ###Test # global config_file_PATH # config_file_PATH = r'G:\PycharmProjects\Log_Extractor\parser.cfg' if self.cur_dir == None: self.cur_dir = os.getcwd() filename = askopenfilename(initialdir=self.cur_dir, title="Select file", filetypes=(("config file", "*.cfg"), ("all files", "*.*"))) if filename: global config_file_PATH config_file_PATH = filename print(config_file_PATH) # self.update_text() self.config_file_PATH_txt.delete("1.0", "end") self.config_file_5g_PATH_txt.delete("1.0", "end") self.config_file_5g_PATH_txt.insert(END, config_file_PATH) else: showerror("Error", "No file selected") if self.is_uniconfig() == False: showerror("Error", "Cannot choose more than one config file!!!") def open_log(self): # Test # global log_file_PATH # log_file_PATH = r'G:\PycharmProjects\Log_Extractor\Test\log_test.txt' if self.cur_dir == None: self.cur_dir = os.getcwd() log_paths = askopenfilenames(initialdir=self.cur_dir, title="Select file", filetypes=(("log file", "*.log *txt"), ("text file", "*.txt"), ("all files", "*.*"))) # log_path = askdirectory() if log_paths: global log_file_PATH for path in log_paths: log_file_PATH.append(path) # log_file_PATH = log_paths print(log_paths) self.log_file_PATH_txt.delete("1.0", "end") self.log_file_PATH_txt.insert(END, log_file_PATH) else: showerror("Error", "No file selected") def set_csv_directory(self): csv_dir = askdirectory() if csv_dir: global csv_folder_PATH csv_folder_PATH = csv_dir self.csv_dir_txt.delete("1.0", "end") self.csv_dir_txt.insert(END, csv_dir) else: showerror("Error", "No directory selected") ##Test' # global csv_folder_PATH # csv_folder_PATH = r'C:\Users\Admin\Desktop\test' def call_extract(self): global config_file_PATH global log_type_list_brief, log_type_list_full # if config_file_PATH == '': # self.log_type_txt.insert("Error, No file selected") # # showerror("Error", "No file selected") # return try: self.log_type_txt.delete("1.0", "end") self.log_type_txt.insert(END, "Extracting...\n") lines = read_file(config_file_PATH) log_type_list_brief, log_type_list_full, grids = read_config_log_types( lines) if len(log_type_list_brief) != 0: # self.log_type_txt.delete("1.0", "end") self.log_type_txt.insert(END, '\n#Packets\n') for log in log_type_list_brief: self.log_type_txt.insert(END, log + '\n') if len(grids) != 0: self.log_type_txt.insert(END, '\n#Grids\n') for grid in grids.keys(): self.log_type_txt.insert(END, grid + '\n') self.log_type_txt.insert(END, "\nExtract successfully!!!\n") # showinfo("Respond", "Extract successfully") else: showwarning("Config Empty", "No log type found in config file. Try again!") except: # self.log_type_txt.delete("1.0", "end") self.log_type_txt.insert(END, "Error extracting\n") def call_convert_csv(self): global csv_dict, csv_folder_PATH, log_file_PATH, log_type_list_brief, config_file_PATH print(log_type_list_brief) if csv_folder_PATH == '': self.log_type_txt.insert( END, "You need to select csv directory before convert\n") return try: #TODO: Fix error: No grid name 'LTE Serving Cell Meas vs .TIme) # Filter signaling message from tool_summary import concat_signaling self.log_type_txt.insert(END, "Filtering signal packets...\n") for log in log_file_PATH: concat_signaling(config_file_PATH, log, csv_folder_PATH) self.log_type_txt.insert(END, "Exported signal packets!\n") # Convert CSV self.log_type_txt.insert(END, "Converting! Please wait...\n") for t in log_type_list_brief: # init dict of log data list for csv csv_dict[t] = [0, []] for path in log_file_PATH: parse_log(path, log_type_list_brief, csv_dict) write_csv(csv_folder_PATH, csv_dict) self.log_type_txt.insert(END, "Converting successful\n") except: self.log_type_txt.insert(END, "Fail converting!\n") # showerror("Error", "Error Converting") # def openQCAT(self): # self.newWindow = Toplevel(self.master) # self.app = QCAT_Auto(self.newWindow) def show_instruction(self): pass def show_about(self): pass
class Momentary: def __init__(self, master, valves): self.valves = valves self.master = master self.frame1 = Frame(master) self.frame2 = Frame(master) self.master.configure(bg='sky blue') self.frame1.configure(bg='sky blue') self.frame2.configure(bg='sky blue') index = 0 while index < 6: self.frame1.grid_columnconfigure(index, minsize=6) self.frame2.grid_columnconfigure(index, minsize=6) self.frame1.grid_rowconfigure(index, minsize=140) self.frame2.grid_rowconfigure(index, minsize=140) index += 1 self.end_all_image = PhotoImage(file="img/stop.png").subsample(x=6, y=6) self.end_all_button = Button(self.master, image=self.end_all_image, command=lambda: self.end_all() ) self.end_all_button.config(bg='brown3', activebackground='brown4', border=5, width=850) self.label = [Label(self.frame1, textvariable=self.valves[0].get_name()), Label(self.frame1, textvariable=self.valves[1].get_name()), Label(self.frame1, textvariable=self.valves[2].get_name()), Label(self.frame1, textvariable=self.valves[3].get_name()), Label(self.frame2, textvariable=self.valves[4].get_name()), Label(self.frame2, textvariable=self.valves[5].get_name()), Label(self.frame2, textvariable=self.valves[6].get_name()), Label(self.frame2, textvariable=self.valves[7].get_name())] row = 0 for each in self.label: each.config(width=7, height=2) each.config(bg='sky blue', fg='RoyalBlue4', font=('Lucida Console', 30), padx=18) each.grid(row=row % 4, column=0) row += 1 self.lightsA = [LED(self.frame1, 30, 'green1', 'green', 'dark green', 'Dark Green', False), LED(self.frame1, 30, 'green1', 'green', 'dark green', 'Dark Green', False), LED(self.frame1, 30, 'green1', 'green', 'dark green', 'Dark Green', False), LED(self.frame1, 30, 'green1', 'green', 'dark green', 'Dark Green', False), LED(self.frame2, 30, 'green1', 'green', 'dark green', 'Dark Green', False), LED(self.frame2, 30, 'green1', 'green', 'dark green', 'Dark Green', False), LED(self.frame2, 30, 'green1', 'green', 'dark green', 'Dark Green', False), LED(self.frame2, 30, 'green1', 'green', 'dark green', 'Dark Green', False) ] self.lightsB = [LED(self.frame1, 30, 'red', 'dark red', 'red4', 'DarkRed', False), LED(self.frame1, 30, 'red', 'dark red', 'red4', 'DarkRed', False), LED(self.frame1, 30, 'red', 'dark red', 'red4', 'DarkRed', False), LED(self.frame1, 30, 'red', 'dark red', 'red4', 'DarkRed', False), LED(self.frame2, 30, 'red', 'dark red', 'red4', 'DarkRed', False), LED(self.frame2, 30, 'red', 'dark red', 'red4', 'DarkRed', False), LED(self.frame2, 30, 'red', 'dark red', 'red4', 'DarkRed', False), LED(self.frame2, 30, 'red', 'dark red', 'red4', 'DarkRed', False) ] self.v = [IntVar(), IntVar(), IntVar(), IntVar(), IntVar(), IntVar(), IntVar(), IntVar()] for each in self.v: each.set(3) self.a = [Radiobutton(self.frame1, text='A', command=lambda: self.activate_a(0), value=1), Radiobutton(self.frame1, text='A', command=lambda: self.activate_a(1), value=1), Radiobutton(self.frame1, text='A', command=lambda: self.activate_a(2), value=1), Radiobutton(self.frame1, text='A', command=lambda: self.activate_a(3), value=1), Radiobutton(self.frame2, text='A', command=lambda: self.activate_a(4), value=1), Radiobutton(self.frame2, text='A', command=lambda: self.activate_a(5), value=1), Radiobutton(self.frame2, text='A', command=lambda: self.activate_a(6), value=1), Radiobutton(self.frame2, text='A', command=lambda: self.activate_a(7), value=1)] index = 0 for each in self.a: each.grid(row=index % 4, column=2) each.config(width=4, height=2, indicatoron=0, variable=self.v[index], font=('Lucida Console', 30)) each.config(bg='SkyBlue4', activebackground='midnight blue', selectcolor='midnight blue', fg='white') each.config(activeforeground='white') index += 1 self.b = [Radiobutton(self.frame1, text='B', command=lambda: self.activate_b(0), value=0), Radiobutton(self.frame1, text='B', command=lambda: self.activate_b(1), value=0), Radiobutton(self.frame1, text='B', command=lambda: self.activate_b(2), value=0), Radiobutton(self.frame1, text='B', command=lambda: self.activate_b(3), value=0), Radiobutton(self.frame2, text='B', command=lambda: self.activate_b(4), value=0), Radiobutton(self.frame2, text='B', command=lambda: self.activate_b(5), value=0), Radiobutton(self.frame2, text='B', command=lambda: self.activate_b(6), value=0), Radiobutton(self.frame2, text='B', command=lambda: self.activate_b(7), value=0)] index = 0 for each in self.b: each.grid(row=index % 4, column=3) each.config(width=4, height=2, indicatoron=0, variable=self.v[index], font=('Lucida Console', 30)) each.config(bg='SkyBlue4', activebackground='midnight blue', selectcolor='midnight blue', fg='white') each.config(activeforeground='white') index += 1 self.end_image = PhotoImage(file="img/no.png").subsample(x=6, y=6) self.end_button = [Radiobutton(self.frame1, image=self.end_image, command=lambda: self.end(0)), Radiobutton(self.frame1, image=self.end_image, command=lambda: self.end(1)), Radiobutton(self.frame1, image=self.end_image, command=lambda: self.end(2)), Radiobutton(self.frame1, image=self.end_image, command=lambda: self.end(3)), Radiobutton(self.frame2, image=self.end_image, command=lambda: self.end(4)), Radiobutton(self.frame2, image=self.end_image, command=lambda: self.end(5)), Radiobutton(self.frame2, image=self.end_image, command=lambda: self.end(6)), Radiobutton(self.frame2, image=self.end_image, command=lambda: self.end(7)), ] index = 0 for each in self.end_button: each.grid(row=index % 4, column=5) each.config(value=2, variable=self.v[index], indicatoron=0) each.config(bg='brown3', activebackground='brown4') index += 1 def make_frame(self): self.frame1.grid(row=2, column=0, rowspan=5) self.frame2.grid(row=2, column=1, rowspan=5) self.end_all_button.grid(row=1, column=0, columnspan=2) row = 0 for each in self.lightsA: each.grid(row=row % 4, column=1, padx=20, pady=20) row += 1 row = 0 for each in self.lightsB: each.grid(row=row % 4, column=4, padx=20, pady=20) row += 1 def delete_frame(self): self.frame1.grid_remove() self.frame2.grid_remove() self.end_all_button.grid_remove() for each in self.lightsA: each.grid_remove() for each in self.lightsB: each.grid_remove() def activate_a(self, number): pin_number = 65 + number pin_opposite = 80 - number if self.v[number].get() == 1: self.lightsA[number].set_state(True) self.lightsB[number].set_state(False) wiringpi.digitalWrite(pin_number, 1) wiringpi.digitalWrite(pin_opposite, 0) def activate_b(self, number): pin_number = 80 - number pin_opposite = 65 + number if self.v[number].get() == 0: self.lightsA[number].set_state(False) self.lightsB[number].set_state(True) wiringpi.digitalWrite(pin_number, 1) wiringpi.digitalWrite(pin_opposite, 0) def end(self, number): pin_number = 65 + number pin_opposite = 80 - number wiringpi.digitalWrite(pin_number, 0) wiringpi.digitalWrite(pin_opposite, 0) self.v[number].set(3) self.lightsA[number].set_state(False) self.lightsB[number].set_state(False) def end_all(self): number = 0 while number < 8: self.end(number) number += 1
class EguanaGUI(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.initUI() # if not EguanaInit.eguana_root_dir_exists(): # EguanaInit.create_eguana_root_dir() def initUI(self): self.parent.title("EGUANA") self.style = ttk.Style() self.style.theme_use("alt") self.photoName = "eguana.gif" self.frame = Frame(self, relief=FLAT, borderwidth=10,bg='#FADC46') self.frame.pack(fill=BOTH, expand=True) self.pack(fill=BOTH, expand=True) self.setupMenuBar() self.setupTopBar() def setupMenuBar(self): self.menubar = EguanaMenu(self.parent,self) self.parent.config(menu=self.menubar) def setupTopBar(self): self.supportedDevices = [] for fileName in [name for name in os.listdir('./machineConfig') if os.path.isfile('./machineConfig/' + name) and not name == 'eguanaMachineConfig.py' and name.endswith('.py')]: # try:{ components = fileName.split('.') fileName = components[0] className = fileName[0].upper() + fileName[1:] try: module = __import__("machineConfig."+fileName,fromlist=["machineConfig."]) classVar = getattr(module,className) except: continue self.supportedDevices.append(classVar()) # except: # pass self.selectMachineFrame = Frame(self.frame,relief=FLAT,bg='#FADC46') self.selectMachineFrame.pack(fill=BOTH,expand=True) self.setupSelectMachineButtons() def setupSelectMachineButtons(self): numDevices = len(self.supportedDevices) numColumns = 3 numRows = math.ceil((numDevices+1)/3) self.photo = PhotoImage(file="eguana.gif") self.photo = self.photo.subsample(2); self.photo_label = Label(self.selectMachineFrame,image=self.photo,borderwidth=0,highlightthickness=0) self.photo_label.configure(bg='#FADC46') self.photo_label.grid(row=int(numRows/2),column=1, sticky=N+S+E+W,padx=2,pady =2) self.photo_label.image = self.photo index = 0 for i in range(numRows): for j in range(numColumns): if not(j == 1 and i == int(numRows/2)) and (index < numDevices): device = self.supportedDevices[index] b = Button(self.selectMachineFrame,text=device.name,relief=RAISED, command=lambda device=device :self.machineButtonPressed(device)) b.grid(row=i,column=j, sticky=N+S+E+W,padx=2,pady =2) index += 1 for i in range(numRows): self.selectMachineFrame.rowconfigure(i,weight=1) for i in range(numColumns): self.selectMachineFrame.columnconfigure(i,weight=1) def machineButtonPressed(self,inputDevice): dirStr = filedialog.askdirectory() if len(dirStr) and inputDevice.isDirectoryValid(dirStr): inputDevice.setDirPath(dirStr) EguanaModel().machine = inputDevice self.selectMachineFrame.destroy() self.menubar.inputSelected() self.photo_label.destroy() dirStr = 'Input Path : '+dirStr self.selectPlotFrame = Frame(self.frame, relief=FLAT,bg='#FADC46') self.selectPlotFrame.pack(fill=BOTH,expand=True) self.selectPlotFrame.rowconfigure(0,weight=1) self.selectPlotFrame.rowconfigure(1,weight=2) self.selectPlotFrame.columnconfigure(0,weight=1) self.infoFrame = Frame(self.selectPlotFrame, relief=FLAT, bg='#FADC46') self.infoFrame.grid(row=0,column=0, sticky=N+S+E+W,padx=2,pady =2) self.machineNameLabel = Label(self.infoFrame, text=inputDevice.name,relief=FLAT) self.machineNameLabel.grid(row=0,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2) self.directoryLabel = Label(self.infoFrame, text="No project currently selected",relief=FLAT) self.directoryLabel.grid(row=1,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2) self.directoryLabel.config(text=dirStr) self.outputDirButton = Button(self.infoFrame,text="No output directory selected. Click to select an output directory ",relief=RAISED,fg='red',command=self.askOutputDirectory) self.outputDirButton.grid(row=2,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2) self.filterButton = Button(self.infoFrame,text="No filter selected. Click to select a filter",relief=RAISED,fg='red',command=self.selectFilter) self.filterButton.grid(row=3,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2) self.trialLabel = Label(self.infoFrame,text="Trial Number",relief=FLAT,justify=RIGHT,anchor=E) self.trialLabel.grid(row=4,column=0, sticky=N+S+E+W,padx=2,pady =2) vcmd = (self.master.register(self.validate),'%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W') self.trialEntry = Entry(self.infoFrame,validate = 'key', validatecommand = vcmd) self.trialEntry.grid(row=4,column=1, sticky=N+S+E+W,padx=2,pady =2) self.infoFrame.columnconfigure(0, weight=1) self.infoFrame.columnconfigure(1, weight=1) self.infoFrame.rowconfigure(0, weight=1) self.infoFrame.rowconfigure(1, weight=10) self.infoFrame.rowconfigure(2, weight=10) self.infoFrame.rowconfigure(3, weight=10) self.infoFrame.rowconfigure(4, weight=10) self.showPlotTools() def validate(self, action, index, value_if_allowed, prior_value, text, validation_type, trigger_type, widget_name): if len(value_if_allowed)==0 : return True if text in '0123456789.-+ ': try: float(value_if_allowed) return True except ValueError: return False else: return False def askOutputDirectory(self): dirStr = filedialog.askdirectory() if len(dirStr): dirStr = 'Output Path : '+dirStr self.outputDirButton.config(text=dirStr) def showPlotTools(self): f2= Frame(self.selectPlotFrame, relief=FLAT,bg='#FADC46') f2.grid(row=1,column=0,sticky=N+S+E+W,padx=10,pady =10) b1 = Button(f2,text='3D K',relief=RAISED,command= lambda:self.plotButtonPressed(1)) b1.grid(row=0, column=0,sticky=N+S+E+W,padx=5,pady =5) b2 = Button(f2,text='3D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(2)) b2.grid(row=0, column=1,sticky=N+S+E+W,padx=5,pady =5) b3 = Button(f2,text='3D DP',relief=RAISED,command=lambda:self.plotButtonPressed(3)) b3.grid(row=0, column=2,sticky=N+S+E+W,padx=5,pady =5) b4 = Button(f2,text='2D K',relief=RAISED,command=lambda:self.plotButtonPressed(4)) b4.grid(row=1, column=0,sticky=N+S+E+W,padx=5,pady =5) b5 = Button(f2,text='2D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(5)) b5.grid(row=1, column=1,sticky=N+S+E+W,padx=5,pady =5) b6 = Button(f2,text='2D DP',relief=RAISED,command=lambda:self.plotButtonPressed(6)) b6.grid(row=1, column=2,sticky=N+S+E+W,padx=5,pady =5) b1.config(state=EguanaModel().machine.plot3DKButtonState) b2.config(state=EguanaModel().machine.plot3DDstButtonState) b3.config(state=EguanaModel().machine.plot3DDpButtonState) b4.config(state=EguanaModel().machine.plot2DKButtonState) b5.config(state=EguanaModel().machine.plot2DDstButtonState) b6.config(state=EguanaModel().machine.plot2DDpButtonState) f2.columnconfigure(0, weight=1) f2.columnconfigure(1, weight=1) f2.columnconfigure(2, weight=1) f2.rowconfigure(0, weight=1) f2.rowconfigure(1, weight=1) def plotButtonPressed(self,number): trialNum = self.trialEntry.get() try: trialNum = int(trialNum) print(EguanaModel().machine.ifTrialExists(trialNum)) if EguanaModel().machine.ifTrialExists(trialNum): self.plotFigure(number) return True else: messagebox.showerror( "Trial Number Error", "The trial doesn't exist" ) return False except ValueError: messagebox.showerror( "Trial Number Error", "Error with the trial number" ) return False def plotFigure(self,number): m = CoilNumDialog(self.frame) if m.isSet(): print(m.getValues()) EguanaModel().machine.getDataForTrialNumber(number) def selectFilter(self): ffPopup = FilterFunctionPopup(self) if ffPopup.selectedFilter is not None: EguanaModel().filterFunction = ffPopup.selectedFilter ftPopup = FilterTypePopup(self,ffPopup.selectedFilter) if (ftPopup.selectedHeadFilterType is not None) and (ftPopup.selectedHeadFilterType is not None): self.menubar.setSelectedFilters(ffPopup.selectedFilter,ftPopup.selectedHeadFilterType,ftPopup.selectedJawFilterType) EguanaModel().filterTypeHead = ftPopup.selectedHeadFilterType EguanaModel().filterTypeJaw = ftPopup.selectedJawFilterType EguanaModel().filterFunction = ffPopup.selectedFilter buttonText = '{} - Jaw Filter : {} - Head Filter {}'.format(ffPopup.selectedFilter.name,ftPopup.selectedJawFilterType.name, ftPopup.selectedHeadFilterType.name) self.filterButton.config(text=buttonText) def updateSelectedFilters(self,ffName,ftHeadName,ftJawName): buttonText = '{} - Jaw Filter : {} - Head Filter {}'.format(ffName,ftHeadName,ftJawName) self.filterButton.config(text=buttonText) def changeImage(self): self.photo = PhotoImage(file=self.photoName) self.photo = self.photo.subsample(2); self.photo_label.image = self.photo self.photo_label.config(image=self.photo) def cursorPosition(self,event): if event.widget == self.openButton3D: if self.photoName == "eguana2.gif": self.photoName = "eguana.gif" self.changeImage() elif event.widget == self.openButton2D: if self.photoName == "eguana.gif": self.photoName = "eguana2.gif" self.changeImage()
class Example(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.threading_start = None self.queue = Queue() self.initUI() def initUI(self): self.parent.title("Facebook searching tool") self.style = Style() self.style.theme_use("classic") self.pack(fill=BOTH, expand=1) frame1 = Frame(self) frame1.pack(fill=X) lbl1 = Label(frame1, text="Facebook searching tool !!!", font="VNI-Dom 15", width=50, foreground="blue") lbl1.pack(side=TOP, padx=8, pady=8, expand=True) menubar = Menu(self.parent) self.parent.config(menu=menubar) fileMenu = Menu(menubar) submenu = Menu(fileMenu) submenu.add_command(label="Watch result Button", command=self.onChoose2) submenu.add_command(label="Stop Button", command=self.onChoose3) submenu.add_command(label="Start Button", command=self.onChoose5) submenu.add_command(label="Extract Button", command=self.onChoose1) submenu.add_command(label="Background", command=self.onChoose6) fileMenu.add_cascade(label='Change colour', menu=submenu) fileMenu.add_separator() fileMenu.add_command(label="Go to the result folder", command=self.onOpen) fileMenu.add_separator() fileMenu.add_command(label="Exit", command=self.quit) menubar.add_cascade(label="Option", menu=fileMenu) frame1 = Frame(self) frame1.pack(fill=X) lbl1 = Label(frame1, text="Key word", font="VNI-Dom 12", foreground="black", width=13) lbl1.pack(side=LEFT, padx=18, pady=12) self.entry1 = Entry(frame1) self.entry1.insert(0, 'i want this shirt') self.entry1.pack(fill=X, padx=5, expand=True) frame2 = Frame(self) frame2.pack(fill=X) lbl2 = Label(frame2, text="Extract file", font="VNI-Dom 12", foreground="black", width=13) lbl2.pack(side=LEFT, padx=18, pady=12) self.entry2 = Entry(frame2) self.entry2.pack(fill=X, padx=5, expand=True) # bard = Image.open("28.jpg") # bardejov = ImageTk.PhotoImage(bard) # label1 = Label(self, image=bardejov) # label1.image = bardejov # label1.pack(side=BOTTOM, padx=10, expand=True) self.quitButton = Button(self, text="Quit", height=1, width=10, command=self.onQuest, background="black", foreground="white") self.quitButton.pack(side=RIGHT, padx=5, pady=5) self.newkeywordButton = Button(self, text="Delete key word", height=1, width=10, command=self.onDeleteentry, background="red", foreground="white") self.newkeywordButton.pack(side=RIGHT, padx=5, pady=5) self.deleteresultButton = Button(self, text="Delete result", height=1, width=10, command=self.deleteAllfile, background="red", foreground="white") self.deleteresultButton.pack(side=RIGHT, padx=5, pady=5) self.extractButton = Button(self, text="Extract", height=1, width=10, command=self.outFile, background="black", foreground="white") self.extractButton.pack(side=RIGHT, padx=5, pady=5) self.okButton1 = Button(self, text="Watch result", height=1, width=10, command=self.onshowImages, background="green", foreground="white") self.okButton1.pack(side=RIGHT, padx=5, pady=5) self.closeButton = Button(self, text="Stop", height=1, width=10, command=self.onStop, background="green", foreground="white") self.closeButton.pack(side=RIGHT, padx=5, pady=5) self.okButton = Button(self, text="Start", height=1, width=10, command=self.onStartentry, background="green", foreground="white") self.okButton.pack(side=RIGHT, padx=5, pady=5) def onQuest(self): outButton = mbox.askquestion("Question", "Are you sure to quit ?") if outButton == "yes": for i in range(1, 10): self.quit() def onStop(self): stopButton = mbox.askquestion("Question", "Do you want to stop ?") if stopButton == 'yes': setattr(self.queue, 'do_run', False) os.system("TASKKILL /F /IM firefox.exe") self.okButton.config(state=tk.NORMAL) def process_queue(self): self.queue = Queue(maxsize=0) num_threads = 5 for i in range(num_threads): worker = Thread(target=do_stuff, args=(self.queue, )) worker.setDaemon(True) worker.start() for x in range(50): self.queue.put(x) self.queue.join() self.okButton.config(state=tk.NORMAL) def onStartentry(self): # outButton = mbox.askquestion("Question", "Do you want to remove old images before start ?") # if outButton == "yes": # src = "./IM/" # for d in os.listdir(src): # sublink="{}{}".format(src,d) # os.remove(sublink) key_word = self.entry1.get() self.threading_start = Thread(target=self.process_queue) self.threading_start.setDaemon(True) self.threading_start.start() self.okButton.config(state=tk.DISABLED) def onOpen(self): ftypes = {('All files', '*'), ('Text files', '*.txt'), ('jpg file', '*.jpg'), ('gif file', '*.gif')} dlg = Open(self, filetypes=ftypes) fl = dlg.show() if fl != '': images = fl if images.endswith("png") \ or images.endswith("jpg") \ or images.endswith("jpeg") \ or images.endswith("gif") \ or images.endswith("tiff") \ or images.endswith("bmp") \ or images.endswith("PNG") \ or images.endswith("JPG") \ or images.endswith("JPEG") \ or images.endswith("GIF") \ or images.endswith("TIFF") \ or images.endswith("BMP"): window = tk.Toplevel() str = fl.split('/', 100) number_last = len(fl.split('/', 100)) - 1 window.title(str[number_last]) self.mg = Image.open(fl) w, h = Image.open(fl).size window.geometry(("%dx%d + 300 + 300") % (w, h)) window.configure(background='grey') path = fl self.img = Image.open(path) img = ImageTk.PhotoImage(Image.open(path)) panel = tk.Label(window, image=img) panel.pack(side="bottom", fill="both", expand=True) window.mainloop() else: mbox.showerror("Error", "Could not open file") def onChoose1(self): (rgb, hx) = askcolor() self.extractButton.config(bg=hx) def onChoose2(self): (rgb, hx) = askcolor() self.okButton1.config(bg=hx) def onChoose3(self): (rgb, hx) = askcolor() self.closeButton.config(bg=hx) def onChoose4(self): (rgb, hx) = askcolor() self.okButton.config(bg=hx) def onChoose5(self): (rgb, hx) = askcolor() self.newkeywordButton.config(bg=hx) def onChoose6(self): (rgb, hx) = askcolor() self.config(bg=hx) def deleteAllfile(self): outButton = mbox.askquestion("Question", "Do you want to remove all images ?") if outButton == "yes": src = "./IM/" for d in os.listdir(src): sublink = "{}{}".format(src, d) os.remove(sublink) def outFile(self): link = self.entry2.get() src = "./TestImages/" self.list_images = [] pdf = FPDF('p', 'mm', 'A4') x, y, w, h = 0, 0, 200, 250 for d in os.listdir(src): images = d if (images.endswith("png") or images.endswith("jpg") or images.endswith("jpeg") or images.endswith("gif") or images.endswith("tiff") or images.endswith("bmp") or images.endswith("PNG") or images.endswith("JPG") or images.endswith("JPEG") or images.endswith("GIF") or images.endswith("TIFF") or images.endswith("BMP")): sublink = "{}{}".format("./TestImages/", d) shutil.copy(sublink, link) pdf.add_page() pdf.image(sublink, x, y, w, h) now = datetime.now() current_year = now.year current_month = now.month current_day = now.day curent_hour = now.hour current_minute = now.minute current_second = now.second date_time = "Reportimages_%s_%s_%s_%s_%s_%s" % ( current_year, current_month, current_day, curent_hour, current_minute, current_second) outlink = "{}{}".format(link, date_time) pdf.output(outlink, "F") def onDeleteentry(self): self.entry1.delete(0, 10000) def onshowImages(self): root = tk.Toplevel() MyApp = ImageClassifyer(root) tk.mainloop()
class Uplink_Analysis(Frame): def __init__(self, master): Frame.__init__(self, master) self.master = master window_width = 480 window_heigh = 230 x_pos = (screen_width / 2) - (window_width / 2) y_pos = (screen_heigh / 2) - (window_heigh / 2) # self.master.geometry("420x200") self.master.geometry('%dx%d+%d+%d' % (window_width, window_heigh, x_pos, y_pos)) self.master.title("Uplink Analysis") self.Auto_detect_file_input_label = Label(self.master, text='Uplink Directory') self.Auto_detect_file_input_label.grid(row=0, column=0, sticky=W, pady=2) self.Auto_detect_file_input_txt = Text(self.master, heigh=1, width=35) self.Auto_detect_file_input_txt.grid(row=0, column=1, pady=2, padx=2) self.PwCtrl_file_PATH_label = Label(self.master, text="Power Control File Path") self.PwCtrl_file_PATH_label.grid(row=1, column=0, sticky=W, pady=2) self.PwCtrl_file_PATH_txt = Text(self.master, heigh=1, width=42) self.PwCtrl_file_PATH_txt.grid(row=1, column=1, columnspan=2, pady=2) self.DCI_file_PATH_label = Label(self.master, text="DCI File Path") self.DCI_file_PATH_label.grid(row=2, column=0, sticky=W, pady=2) self.DCI_file_PATH_txt = Text(self.master, heigh=1, width=42) self.DCI_file_PATH_txt.grid(row=2, column=1, columnspan=2, pady=2) self.TxReport_file_PATH_label = Label(self.master, text="Tx Report File Path") self.TxReport_file_PATH_label.grid(row=3, column=0, sticky=W, pady=2) self.TxReport_file_PATH_txt = Text(self.master, heigh=1, width=42) self.TxReport_file_PATH_txt.grid(row=3, column=1, columnspan=2, pady=2) self.PHICH_file_PATH_label = Label(self.master, text="PHICH File Path") self.PHICH_file_PATH_label.grid(row=4, column=0, sticky=W, pady=2) self.PHICH_file_PATH_txt = Text(self.master, heigh=1, width=42) self.PHICH_file_PATH_txt.grid(row=4, column=1, columnspan=2, pady=2) self.Output_dir_label = Label(self.master, text="Output directory") self.Output_dir_label.grid(row=5, column=0, sticky=W, pady=2) self.Output_dir_txt = Text(self.master, heigh=1, width=42) self.Output_dir_txt.grid(row=5, column=1, columnspan=2, pady=2) # Button config self.auto_button = Button(self.master, text='Auto find', command=self.find_files) self.auto_button.grid(row=0, column=2, columnspan=2, sticky=E) self.merge_button = Button(self.master, text='Merge Table', state=DISABLED, command=self.call_merge) self.merge_button.config(width=10, heigh=4) self.merge_button.grid(row=6, column=0, columnspan=3, sticky=E) #Merge condition in order to press merge button self.merge_condition_1 = False self.merge_condition_2 = False self.merge_condition_3 = False self.merge_condition_4 = False self.menu = Menu(self.master) self.master.config(menu=self.menu) # create the file object) self.file = Menu(self.menu) # adds a command to the menu option, calling it exit, and the # command it runs on event is client_exit self.file.add_command(label="Set input dir", command=self.set_input_dir) self.file.add_command(label="Open Power Control file", command=self.open_PwCtrl) self.file.add_command(label="Open DCI file", command=self.open_DCI) self.file.add_command(label="Open Tx Report file", command=self.open_TxReport) self.file.add_command(label="Open PHICH file", command=self.open_PHICH) self.file.add_command(label="Set oput directory", command=self.set_dir) self.file.add_command(label="Exit", command=self.client_exit) self.menu.add_cascade(label="File", menu=self.file) # menu.add_cascade(label="Open config", menu=file) self.edit = Menu(self.menu) self.menu.add_cascade(label="Edit", menu=self.edit) self.help = Menu(self.menu) self.help.add_command(label="About", command=self.show_about) self.help.add_command(label="Instruction", command=self.show_instruction) self.menu.add_cascade(label="Help", menu=self.help) def set_input_dir(self): dir = askdirectory() if dir: global input_dir input_dir = dir # print(input_dir) self.Auto_detect_file_input_txt.delete("1.0", "end") self.Auto_detect_file_input_txt.insert(END, input_dir) else: showerror("Error", "No directory selected") def check_merge_condition(self): #Check if merge conditions are met, then turn the button on/off if self.merge_condition_1 and (self.merge_condition_2 or self.merge_condition_3 or self.merge_condition_4): return True else: return False def find_files(self): global input_dir, pw_ctrl_path, dci_path, tx_report_path, phich_path for file in os.listdir(input_dir): if file.endswith(".csv"): if file == '0xB16C.csv': dci_path = os.path.join(input_dir, file) self.DCI_file_PATH_txt.delete("1.0", "end") self.DCI_file_PATH_txt.insert(END, dci_path) self.merge_condition_2 = True if self.check_merge_condition(): self.merge_button.config(state=NORMAL) elif file == '0xB139.csv': tx_report_path = os.path.join(input_dir, file) self.TxReport_file_PATH_txt.delete("1.0", "end") self.TxReport_file_PATH_txt.insert(END, tx_report_path) self.merge_condition_3 = True if self.check_merge_condition(): self.merge_button.config(state=NORMAL) elif file == '0xB16E.csv': pw_ctrl_path = os.path.join(input_dir, file) self.PwCtrl_file_PATH_txt.delete("1.0", "end") self.PwCtrl_file_PATH_txt.insert(END, pw_ctrl_path) self.merge_condition_1 = True if self.check_merge_condition(): self.merge_button.config(state=NORMAL) elif file == '0xB12C.csv': phich_path = os.path.join(input_dir, file) self.PHICH_file_PATH_txt.delete("1.0", "end") self.PHICH_file_PATH_txt.insert(END, phich_path) self.merge_condition_4 = True if self.check_merge_condition(): self.merge_button.config(state=NORMAL) def open_PwCtrl(self): filename = askopenfilename(initialdir='/', title="Select file", filetypes=(("csv file", "*.csv"), ("all files", "*.*"))) if filename: global pw_ctrl_path pw_ctrl_path = filename print(pw_ctrl_path) # self.update_text() self.PwCtrl_file_PATH_txt.delete("1.0", "end") self.PwCtrl_file_PATH_txt.insert(END, pw_ctrl_path) self.merge_condition_1 = True if self.check_merge_condition(): self.merge_button.config(state=NORMAL) else: showerror("Error", "No file selected") def open_DCI(self): filename = askopenfilename(initialdir='/', title="Select file", filetypes=(("csv file", "*.csv"), ("all files", "*.*"))) if filename: global dci_path dci_path = filename print(dci_path) # self.update_text() self.DCI_file_PATH_txt.delete("1.0", "end") self.DCI_file_PATH_txt.insert(END, dci_path) self.merge_condition_2 = True if self.check_merge_condition(): self.merge_button.config(state=NORMAL) else: showerror("Error", "No file selected") def open_TxReport(self): filename = askopenfilename(initialdir='/', title="Select file", filetypes=(("csv file", "*.csv"), ("all files", "*.*"))) if filename: global tx_report_path tx_report_path = filename print(tx_report_path) # self.update_text() self.TxReport_file_PATH_txt.delete("1.0", "end") self.TxReport_file_PATH_txt.insert(END, tx_report_path) self.merge_condition_3 = True if self.check_merge_condition(): self.merge_button.config(state=NORMAL) else: showerror("Error", "No file selected") def open_PHICH(self): filename = askopenfilename(initialdir='/', title="Select file", filetypes=(("csv file", "*.csv"), ("all files", "*.*"))) if filename: global phich_path phich_path = filename print(phich_path) # self.update_text() self.PHICH_file_PATH_txt.delete("1.0", "end") self.PHICH_file_PATH_txt.insert(END, phich_path) self.merge_condition_4 = True if self.check_merge_condition(): self.merge_button.config(state=NORMAL) else: showerror("Error", "No file selected") def set_dir(self): dir = askdirectory() if dir: global output_path output_path = dir print(output_path) self.Output_dir_txt.delete("1.0", "end") self.Output_dir_txt.insert(END, output_path) else: showerror("Error", "No directory selected") def call_merge(self): global pw_ctrl_path, dci_path, tx_report_path, phich_path, output_path try: Execute(pw_ctrl_path, dci_path, tx_report_path, phich_path, output_path) except: showerror("Error", "Check files or directory") def client_exit(self): exit() def show_about(self): pass def show_instruction(self): pass
def displayBoard(self, playing=True): self.destroyButtons() self.resetDist() if playing: self.lbl.config( text= "Click on a location to prepare a move. If a tank is available and you are surfaced then you can purchase it.", fg="black") if self.state.isOver(): self.lbl.config(text="GAMEOVER", fg="red") tanks = [tank for tank in self.state.tanks] self.cash = Label(self.master, text=" Cash: " + str(self.state.cash) + " ", font=("Helvetica", 15)) self.cash.grid(row=15, column=15) self.time = Label(self.master, text=" Time: " + str(self.state.timeLeft) + " ", font=("Helvetica", 15)) self.time.grid(row=16, column=15) self.oxygen = Label(self.master, text=" Oxygen Left: " + str(self.state.oxygenLeft) + " / " + str(self.state.tankSize), font=("Helvetica", 15)) self.oxygen.grid(row=17, column=15) self.holding = Label(self.master, text=" Holding: " + str(sum((self.state.holding))) + " ", font=("Helvetica", 15)) self.holding.grid(row=18, column=15) self.buttons['cash'] = self.cash self.buttons['time'] = self.time self.buttons['oxygen'] = self.oxygen self.buttons['holding'] = self.holding if playing: def clickTank(action): def executeMove(): def do(): self.move = action if self.move in self.state.getLegalActions(): self.var.set(1) if not self.showing: if (self.state.playerLoc == (0, 0) or self.state.playerLoc == (0, 9)) and self.state.cash >= action[0]: self.lbl.config(text="Tank | Cost: " + str(action[0]) + " | Size: " + str(action[1])) if hasattr(self, 'next'): self.next.destroy() self.next = Button(self.master, text="Execute Move", font=("Helvetica", 15), command=do) self.next.grid(row=5, column=15) self.buttons['next'] = self.next else: print(self.state.cash, action[1]) self.lbl.config(text="Cannot Buy Tank") if self.prevButton: prevbutton = self.buttons[self.prevButton] if self.prevButton != self.state.playerLoc: if self.prevButton == ( 0, 0) or self.prevButton == (0, 9): prevbutton.config(background="Green") elif len(self.prevButton) == 3: prevbutton.config(background="white") else: prevbutton.config(background="Light Gray") self.buttons[action].config(background="orange") self.prevButton = action return do return executeMove else: def clickTank(action): pass c = 0 if playing: enabled = "normal" else: enabled = "disabled" self.tanks = [] for tank in tanks: if tank in self.state.getLegalActions(): t = Button(self.master, text="Tank | Cost: " + str(tank[0]) + " | Size: " + str(tank[1]), font=("Helvetica", 15), command=clickTank(tank), state=enabled) t.grid(row=10 + c, column=15) self.tanks.append(t) self.buttons[tank] = t c += 1 else: t = Button(self.master, text="Tank | Cost: " + str(tank[0]) + " | Size: " + str(tank[1]), font=("Helvetica", 15), command=clickTank(tank), state=enabled) t.config(state="disabled") t.grid(row=10 + c, column=15) self.tanks.append(t) self.buttons[tank] = t c += 1 if self.state.playerLoc == ( 0, 0) or self.state.playerLoc == (0, 9) and playing: def exit(): self.move = (None, None, 'exit') self.var.set(1) print("EXIT") if (self.state.playerLoc == (0, 0) or self.state.playerLoc == (0, 9)): self.exit = Button(self.master, text="EXIT with all your current cash! ", font=("Helvetica", 15), command=exit, state=enabled) self.buttons['exit'] = self.exit self.exit.grid(row=19, column=15) for i in range(0, 20): for j in range(0, 10): if not (i == 0 and (j < 9 and j > 0)): bg = None fg = "black" color = "white" font = ("Helvetica", 11) if i > 0: color = "navy" if self.state.board[i][j]: color = "Light Gray" text = str(self.state.board[i][j]) elif (i, j) == (0, 0) or (i, j) == (0, 9): text = "" color = "Green" else: text = "" if self.state.playerLoc == (i, j): text = "P" color = "Yellow" fg = "brown4" font = ("Helvetica", 10, "bold") if self.state.playerLoc == ( i, j) and self.state.playerLoc[0] != 0: color = "Yellow" b = Button(self.master) b.grid(row=i, column=j) b.row = i b.column = j self.buttons[(i, j)] = b def click(action): i = action[0] j = action[1] def do(): valid = False def executeMove(action): def do(): self.move = action self.prevButton = None if self.move in self.state.getLegalActions( ): self.var.set(1) return do if not self.showing: if ((i, j) == (0, 0) or (i, j) == (0, 9)) and (i, j) != self.state.playerLoc: valid = True text = "Surface Location: " + str( (i, j) ) # + "| distance is " + str(manDist((i, j), self.state.playerLoc)) if self.state.board[i][j]: valid = True text = "Pick up " + str( self.state.board[i][j] ) + " at location " + str( (i, j) ) # + " | distance is " + str(manDist((i, j), self.state.playerLoc)) if valid: if self.prevButton: prevbutton = self.buttons[ self.prevButton] if self.prevButton != self.state.playerLoc: if self.prevButton == ( 0, 0 ) or self.prevButton == (0, 9): prevbutton.config( background="Green") else: prevbutton.config( background="Light Gray") self.buttons[(i, j)].config( background="orange") self.prevButton = (i, j) if not self.locations: self.distance += manDist( (i, j), self.state.playerLoc) else: self.distance += manDist( (i, j), self.locations[-1]) self.locations += [(i, j)] self.distanceLabel.config( text=str(self.locations) + ": " + str(self.distance)) self.lbl.config(text=text) if hasattr(self, 'next'): self.next.destroy() self.next = Button( self.master, text="Execute Move", font=("Helvetica", 15), command=executeMove(action), state=enabled) self.next.grid(row=5, column=15) self.buttons['next'] = self.next return do b.config(highlightthickness=0, text=text, width="3", height="2", font=font, fg=fg, command=click((i, j, "move")), background=color)
class BioInfo(Tk): def __init__(self): Tk.__init__(self) self.wm_title("BioInfo : comparaison des listes") self.resizable(width=FALSE, height=FALSE) self.SortDir = False # Lists Types self.typeList1 = None self.typeList2 = None # Frame content self.frameContent = Frame(self) self.frameContent.pack(side=TOP, fill=X) # ScrollBar scrollbar = Scrollbar(self.frameContent, orient=VERTICAL) scrollbar.pack(side=RIGHT, fill=Y) # Result Content self.dataCols = ('microArn_A', 'microArn_B', 'FoldC', 'p-Value', 'Note') self.tree = Treeview(self.frameContent, columns=self.dataCols, show = 'headings', yscrollcommand=scrollbar.set) # configure column headings for c in self.dataCols: self.tree.heading(c, text=c, command=lambda c=c: self.columnSort(c, self.SortDir)) self.tree.column(c, width=10) self.tree.pack(side=LEFT, fill=X, expand="yes") scrollbar.config(command=self.tree.yview) # Frame Lists self.frameLists = Frame(self) self.frameLists.pack(side=LEFT) # Frame Forms self.frameForms = Frame(self) self.frameForms.pack(side=LEFT, padx=20) #Liste n°1 selection self.frameList1 = Frame(self.frameLists) self.frameList1.pack() self.typeListStr1 = StringVar(self.frameList1) self.typeListStr1.set(str(ListBioType.TypeA)) self.buttonTypeList1 = OptionMenu(self.frameList1, self.typeListStr1, str(ListBioType.TypeA), str(ListBioType.TypeB)).pack(side=LEFT) self.entrylist1 = Entry(self.frameList1, width=30) self.entrylist1.pack(side=LEFT) self.buttonBrowseList1 = Button(self.frameList1, text="Parcourir", command=self.load_fileList1, width=10) self.buttonBrowseList1.pack(side=LEFT, padx=5) # List n°2 selection self.frameList2 = Frame(self.frameLists) self.frameList2.pack(side=BOTTOM) self.typeListStr2 = StringVar(self.frameList2) self.typeListStr2.set(str(ListBioType.TypeB)) self.buttonTypeList2 = OptionMenu(self.frameList2, self.typeListStr2, str(ListBioType.TypeA), str(ListBioType.TypeB)).pack(side=LEFT) self.entrylist2 = Entry(self.frameList2, width=30) self.entrylist2.pack(side=LEFT) self.buttonBrowseList2 = Button(self.frameList2, text="Parcourir", command=self.load_fileList2, width=10) self.buttonBrowseList2.pack(side=LEFT, padx=5) # Form pValue self.framePVal = Frame(self.frameForms) self.framePVal.pack() Label(self.framePVal, text="pValue").pack(side=LEFT) self.entryPVal = Entry(self.framePVal, width=6) self.entryPVal.pack(side=LEFT) # Form foldC self.frameFoldC = Frame(self.frameForms) self.frameFoldC.pack() Label(self.frameFoldC, text="foldCh").pack(side=LEFT) self.entryFoldC = Entry(self.frameFoldC, width=6) self.entryFoldC.pack(side=LEFT) # Form note self.frameNote = Frame(self.frameForms) self.frameNote.pack() Label(self.frameNote, text="note ").pack(side=LEFT) self.entryNote = Entry(self.frameNote, width=6) self.entryNote.pack(side=LEFT) # Bouton comparer self.buttonComparer = Button(self, text="Comparer", command=self.compare, width=10, state=DISABLED) self.buttonComparer.pack(fill= X, expand="yes", padx=20, pady=(10,0)) #Bouton exporter self.buttonExport = Button(self, text="Exporter", command=self.export, width=10, state=DISABLED) self.buttonExport.pack(fill= X, expand="yes", padx=20) # Réinitialiser self.buttonReset = Button(self, text="Réinitialiser", command=self.reset, width=10) self.buttonReset.pack(fill= X, expand="yes", padx=20, pady=(0,10)) # file members self.list1 = None self.list2 = None def load_fileList1(self): fname = askopenfilename(filetypes=(("CSV files", "*.csv"), ("All files", "*.*") )) if fname: self.entrylist1.delete(0, END) self.list1 = fname self.entrylist1.insert(0,fname) self.buttonComparer.config(state=NORMAL) def load_fileList2(self): fname = askopenfilename(filetypes=(("CSV files", "*.csv"), ("All files", "*.*") )) if fname: self.entrylist2.delete(0, END) self.list2 = fname self.entrylist2.insert(0,fname) self.buttonComparer.config(state=NORMAL) else: showerror("Erreur : fichier B", "La liste B est introuvable") def resetTree (self): for i in self.tree.get_children(): self.tree.delete(i) def reset(self): self.list1 = None self.entrylist1.delete(0, END) self.list2 = None self.entrylist2.delete(0, END) self.entryPVal.delete(0,END) self.entryFoldC.delete(0, END) self.entryNote.delete(0, END) self.typeList1 = None self.typeList2 = None self.buttonExport.config(state=DISABLED) self.buttonComparer.config(state=DISABLED) self.resetTree() def isValidfoldC(self, s): try: float(s) return True except ValueError: return False def isValidPValue(self, s): try: f = float(s) if f >= 0 and f <= 1: return True else: return False except: return False def isValidNote (self, s): try: f = int(s) return True except: return False def compare(self): self.buttonExport.config(state=NORMAL) # Détermination type Listes # List 1 if self.typeListStr1.get() == str(ListBioType.TypeA): self.typeList1 = ListBioType.TypeA elif self.typeListStr1.get() == str(ListBioType.TypeB): self.typeList1 = ListBioType.TypeB else: self.typeList1 = None # List 2 if self.typeListStr2.get() == str(ListBioType.TypeA): self.typeList2 = ListBioType.TypeA elif self.typeListStr2.get() == str(ListBioType.TypeB): self.typeList2 = ListBioType.TypeB else: self.typeList2 = None if not self.isValidfoldC(self.entryFoldC.get()) and not self.entryFoldC.get() == "": showerror("Erreur : foldC","La valeur fold Change n'est pas un nombre") elif not self.isValidPValue(self.entryPVal.get()) and not self.entryPVal.get() == "": showerror("Erreur : pValue","La valeur pValue n'est pas un nombre compris entre 0 et 1") elif not self.isValidNote(self.entryNote.get()) and not self.entryNote.get() == "": showerror("Erreur : note", "La valeur note n'est pas un nombre entier") # (List A and No List) or (No List and List A) elif ((self.list1 is not None and self.typeList1 == ListBioType.TypeA) and (self.list2 is None)) or\ ((self.list2 is not None and self.typeList2 == ListBioType.TypeA) and (self.list1 is None)): self.resetTree() try: listComp = ListComparator(self.list1, self.list2, self.entryPVal.get(), self.entryFoldC.get(), self.entryNote.get()) for e in listComp.getFilterListA(): self.tree.insert('', 'end', values=e) except IndexError: showerror("Erreur : liste A invalide", "Le fichier liste A n'est pas un fichier valide") # (List B and No List) or (No List and List B) elif ((self.list1 is not None and self.typeList1 == ListBioType.TypeB) and (self.list2 is None)) or\ ((self.list2 is not None and self.typeList2 == ListBioType.TypeB) and (self.list1 is None)): self.resetTree() try: listComp = ListComparator(self.list1, self.list2, self.entryPVal.get(), self.entryFoldC.get()) for e in listComp.getFilterListB(): self.tree.insert('', 'end', values=e) except IndexError: showerror("Erreur : liste A invalide", "Le fichier liste A n'est pas un fichier valide") # (List A and List B) or (List B and List A) elif ((self.list1 is not None and self.typeList1 == ListBioType.TypeA) and \ (self.list2 is not None and self.typeList2 == ListBioType.TypeB)) or \ ((self.list1 is not None and self.typeList1 == ListBioType.TypeB) and \ (self.list2 is not None and self.typeList2 == ListBioType.TypeA)): self.resetTree() listA = "" listB = "" if self.typeList1 == ListBioType.TypeA: listA = self.list1 else: listA = self.list2 if self.typeList1 == ListBioType.TypeB: listB = self.list1 else: listB = self.list2 try: listComp = ListComparator(listA, listB, self.entryPVal.get(), self.entryFoldC.get(), self.entryNote.get()) for e in listComp.getDiffAandB(): self.tree.insert('', 'end', values=e) except IndexError: showerror("Erreur : liste A ou B invalide", "Le fichier liste A ou B n'est pas un fichier valide") # (List A and List A) elif ((self.list1 is not None and self.typeList1 == ListBioType.TypeA) and \ (self.list2 is not None and self.typeList2 == ListBioType.TypeA)): self.resetTree() try: listComp = ListComparator(self.list1, self.list2, self.entryPVal.get(), self.entryFoldC.get(), self.entryNote.get()) for e in listComp.getDiffAandA(): self.tree.insert('', 'end', values=e) except IndexError: showerror("Erreur : liste A ou B invalide", "Le fichier liste A ou B n'est pas un fichier valide") # (List B and List B) elif ((self.list1 is not None and self.typeList1 == ListBioType.TypeB) and \ (self.list2 is not None and self.typeList2 == ListBioType.TypeB)): self.resetTree() try: listComp = ListComparator(self.list1, self.list2, self.entryPVal.get(), self.entryFoldC.get()) for e in listComp.getDiffBandB(): self.tree.insert('', 'end', values=e) except IndexError: showerror("Erreur : liste A ou B invalide", "Le fichier liste A ou B n'est pas un fichier valide") else: showerror("Erreur : Combinaisons de listes invalides", "Votre choix de types de listes ne correspond à aucune combinaison possible, contacter le developpeur") def export(self): if len(self.tree.get_children()) == 0: showinfo("Export", "Il n'y a rien à exporter") return fname = asksaveasfilename(filetypes=(("CSV files", "*.csv"), ("All files", "*.*") )) if fname: resExp = [] for it in self.tree.get_children(): resExp.append(self.tree.item(it)["values"]) expTabToCSV = TreeExportator(resExp, fname) expTabToCSV.export() showinfo("Export", "Exportation au format CSV réussi") def columnSort (self, col, descending=False): data = [(self.tree.set(child, col), child) for child in self.tree.get_children('')] data.sort(reverse=descending) for indx, item in enumerate(data): self.tree.move(item[1], '', indx) # reverse sort direction for next sort operation self.SortDir = not descending
def showPlotTools(self): f2= Frame(self.selectPlotFrame, relief=FLAT,bg='#FADC46') f2.grid(row=1,column=0,sticky=N+S+E+W,padx=10,pady =10) b1 = Button(f2,text='3D K',relief=RAISED,command= lambda:self.plotButtonPressed(1)) b1.grid(row=0, column=0,sticky=N+S+E+W,padx=5,pady =5) b2 = Button(f2,text='3D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(2)) b2.grid(row=0, column=1,sticky=N+S+E+W,padx=5,pady =5) b3 = Button(f2,text='3D DP',relief=RAISED,command=lambda:self.plotButtonPressed(3)) b3.grid(row=0, column=2,sticky=N+S+E+W,padx=5,pady =5) b4 = Button(f2,text='2D K',relief=RAISED,command=lambda:self.plotButtonPressed(4)) b4.grid(row=1, column=0,sticky=N+S+E+W,padx=5,pady =5) b5 = Button(f2,text='2D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(5)) b5.grid(row=1, column=1,sticky=N+S+E+W,padx=5,pady =5) b6 = Button(f2,text='2D DP',relief=RAISED,command=lambda:self.plotButtonPressed(6)) b6.grid(row=1, column=2,sticky=N+S+E+W,padx=5,pady =5) b1.config(state=EguanaModel().machine.plot3DKButtonState) b2.config(state=EguanaModel().machine.plot3DDstButtonState) b3.config(state=EguanaModel().machine.plot3DDpButtonState) b4.config(state=EguanaModel().machine.plot2DKButtonState) b5.config(state=EguanaModel().machine.plot2DDstButtonState) b6.config(state=EguanaModel().machine.plot2DDpButtonState) f2.columnconfigure(0, weight=1) f2.columnconfigure(1, weight=1) f2.columnconfigure(2, weight=1) f2.rowconfigure(0, weight=1) f2.rowconfigure(1, weight=1)
class LucteriosMainForm(Tk): def __init__(self): Tk.__init__(self) try: img = Image("photo", file=join( dirname(import_module('lucterios.install').__file__), "lucterios.png")) self.tk.call('wm', 'iconphoto', self._w, img) except: pass self.has_checked = False self.title(ugettext("Lucterios installer")) self.minsize(475, 260) self.grid_columnconfigure(0, weight=1) self.grid_rowconfigure(0, weight=1) self.running_instance = {} self.resizable(True, True) self.protocol("WM_DELETE_WINDOW", self.on_closing) self.ntbk = ttk.Notebook(self) self.ntbk.grid(row=0, column=0, columnspan=1, sticky=(N, S, E, W)) self.create_instance_panel() self.create_module_panel() stl = ttk.Style() stl.theme_use("default") stl.configure("TProgressbar", thickness=5) self.progress = ttk.Progressbar( self, style="TProgressbar", orient='horizontal', mode='indeterminate') self.progress.grid(row=1, column=0, sticky=(E, W)) self.btnframe = Frame(self, bd=1) self.btnframe.grid(row=2, column=0, columnspan=1) Button(self.btnframe, text=ugettext("Refresh"), width=20, command=self.refresh).grid( row=0, column=0, padx=3, pady=3, sticky=(N, S)) self.btnupgrade = Button( self.btnframe, text=ugettext("Search upgrade"), width=20, command=self.upgrade) self.btnupgrade.config(state=DISABLED) self.btnupgrade.grid(row=0, column=1, padx=3, pady=3, sticky=(N, S)) Button(self.btnframe, text=ugettext("Close"), width=20, command=self.on_closing).grid( row=0, column=2, padx=3, pady=3, sticky=(N, S)) def on_closing(self): all_stop = True instance_names = list(self.running_instance.keys()) for old_item in instance_names: if (self.running_instance[old_item] is not None) and self.running_instance[old_item].is_running(): all_stop = False if all_stop or askokcancel(None, ugettext("An instance is always running.\nDo you want to close?")): self.destroy() else: self.refresh() def destroy(self): instance_names = list(self.running_instance.keys()) for old_item in instance_names: if self.running_instance[old_item] is not None: self.running_instance[old_item].stop() del self.running_instance[old_item] Tk.destroy(self) def create_instance_panel(self): frm_inst = Frame(self.ntbk) frm_inst.grid_columnconfigure(0, weight=1) frm_inst.grid_rowconfigure(0, weight=1) frm_inst.grid_columnconfigure(1, weight=3) frm_inst.grid_rowconfigure(1, weight=0) self.instance_list = Listbox(frm_inst, width=20) self.instance_list.bind('<<ListboxSelect>>', self.select_instance) self.instance_list.pack() self.instance_list.grid(row=0, column=0, sticky=(N, S, W, E)) self.instance_txt = Text(frm_inst, width=75) self.instance_txt.grid(row=0, column=1, rowspan=2, sticky=(N, S, W, E)) self.instance_txt.config(state=DISABLED) self.btninstframe = Frame(frm_inst, bd=1) self.btninstframe.grid(row=1, column=0, columnspan=1) self.btninstframe.grid_columnconfigure(0, weight=1) Button(self.btninstframe, text=ugettext("Launch"), width=25, command=self.open_inst).grid( row=0, column=0, columnspan=2, sticky=(N, S)) Button(self.btninstframe, text=ugettext("Modify"), width=10, command=self.modify_inst).grid(row=1, column=0, sticky=(N, S)) Button(self.btninstframe, text=ugettext("Delete"), width=10, command=self.delete_inst).grid(row=1, column=1, sticky=(N, S)) Button(self.btninstframe, text=ugettext("Save"), width=10, command=self.save_inst).grid(row=2, column=0, sticky=(N, S)) Button(self.btninstframe, text=ugettext("Restore"), width=10, command=self.restore_inst).grid(row=2, column=1, sticky=(N, S)) Button(self.btninstframe, text=ugettext("Add"), width=25, command=self.add_inst).grid( row=3, column=0, columnspan=2, sticky=(N, S)) self.ntbk.add(frm_inst, text=ugettext('Instances')) def create_module_panel(self): frm_mod = Frame(self.ntbk) frm_mod.grid_columnconfigure(0, weight=1) frm_mod.grid_rowconfigure(0, weight=1) self.module_txt = Text(frm_mod) self.module_txt.grid(row=0, column=0, sticky=(N, S, W, E)) self.module_txt.config(state=DISABLED) self.ntbk.add(frm_mod, text=ugettext('Modules')) def do_progress(self, progressing): if not progressing: self.progress.stop() self.progress.grid_remove() else: self.progress.start(25) self.progress.grid(row=1, column=0, sticky=(E, W)) def enabled(self, is_enabled, widget=None): if widget is None: widget = self self.do_progress(not is_enabled) if is_enabled: widget.config(cursor="") else: widget.config(cursor="watch") if isinstance(widget, Button) and (widget != self.btnupgrade): if is_enabled and (not hasattr(widget, 'disabled') or not widget.disabled): widget.config(state=NORMAL) else: widget.config(state=DISABLED) else: for child_cmp in widget.winfo_children(): self.enabled(is_enabled, child_cmp) @ThreadRun def refresh(self, instance_name=None): if instance_name is None: instance_name = self.get_selected_instance_name() self.instance_txt.delete("1.0", END) self._refresh_instance_list() self.set_select_instance_name(instance_name) if not self.has_checked: self._refresh_modules() if self.instance_list.size() == 0: sleep(.3) self._refresh_modules() sleep(.3) self.after_idle(self.add_inst) def _refresh_modules(self): self.btnupgrade.config(state=DISABLED) self.module_txt.config(state=NORMAL) self.module_txt.delete("1.0", END) lct_glob = LucteriosGlobal() mod_lucterios, mod_applis, mod_modules = lct_glob.installed() self.module_txt.insert( END, ugettext("Lucterios core\t\t%s\n") % mod_lucterios[1]) self.module_txt.insert(END, '\n') self.module_txt.insert(END, ugettext("Application\n")) for appli_item in mod_applis: self.module_txt.insert( END, "\t%s\t%s\n" % (appli_item[0].ljust(30), appli_item[1])) self.module_txt.insert(END, ugettext("Modules\n")) for module_item in mod_modules: self.module_txt.insert( END, "\t%s\t%s\n" % (module_item[0].ljust(30), module_item[1])) extra_urls = lct_glob.get_extra_urls() if len(extra_urls) > 0: self.module_txt.insert(END, "\n") self.module_txt.insert(END, ugettext("Pypi servers\n")) for extra_url in extra_urls: self.module_txt.insert(END, "\t%s\n" % extra_url) self.module_txt.config(state=DISABLED) self.has_checked = True self.after(1000, lambda: Thread(target=self.check).start()) def _refresh_instance_list(self): self.instance_list.delete(0, END) luct_glo = LucteriosGlobal() instance_list = luct_glo.listing() for item in instance_list: self.instance_list.insert(END, item) if item not in self.running_instance.keys(): self.running_instance[item] = None instance_names = list(self.running_instance.keys()) for old_item in instance_names: if old_item not in instance_list: if self.running_instance[old_item] is not None: self.running_instance[old_item].stop() del self.running_instance[old_item] def set_select_instance_name(self, instance_name): cur_sel = 0 for sel_iter in range(self.instance_list.size()): if self.instance_list.get(sel_iter) == instance_name: cur_sel = sel_iter break self.instance_list.selection_set(cur_sel) self.select_instance(None) def get_selected_instance_name(self): if len(self.instance_list.curselection()) > 0: return self.instance_list.get(int(self.instance_list.curselection()[0])) else: return "" def set_ugrade_state(self, must_upgrade): if must_upgrade: self.btnupgrade.config(state=NORMAL) self.btnupgrade["text"] = ugettext("Upgrade needs") else: self.btnupgrade["text"] = ugettext("No upgrade") self.btnupgrade.config(state=DISABLED) def check(self): must_upgrade = False try: lct_glob = LucteriosGlobal() _, must_upgrade = lct_glob.check() finally: self.after(300, self.set_ugrade_state, must_upgrade) @ThreadRun def upgrade(self): self.btnupgrade.config(state=DISABLED) self.instance_list.config(state=DISABLED) try: from logging import getLogger admin_path = import_module( "lucterios.install.lucterios_admin").__file__ proc = Popen( [sys.executable, admin_path, "update"], stderr=STDOUT, stdout=PIPE) value = proc.communicate()[0] try: value = value.decode('ascii') except: pass six.print_(value) if proc.returncode != 0: getLogger("lucterios.admin").error(value) else: getLogger("lucterios.admin").info(value) showinfo(ugettext("Lucterios installer"), ugettext( "The application must restart")) python = sys.executable os.execl(python, python, *sys.argv) finally: self._refresh_modules() self.btnupgrade.config(state=NORMAL) self.instance_list.config(state=NORMAL) @ThreadRun def select_instance(self, evt): if self.instance_list['state'] == NORMAL: self.instance_list.config(state=DISABLED) try: instance_name = self.get_selected_instance_name() self.instance_txt.configure(state=NORMAL) self.instance_txt.delete("1.0", END) if instance_name != '': if instance_name not in self.running_instance.keys(): self.running_instance[instance_name] = None inst = LucteriosInstance(instance_name) inst.read() self.instance_txt.insert(END, "\t\t\t%s\n\n" % inst.name) self.instance_txt.insert( END, ugettext("Database\t\t%s\n") % inst.get_database_txt()) self.instance_txt.insert( END, ugettext("Appli\t\t%s\n") % inst.get_appli_txt()) self.instance_txt.insert( END, ugettext("Modules\t\t%s\n") % inst.get_module_txt()) self.instance_txt.insert( END, ugettext("Extra\t\t%s\n") % inst.get_extra_txt()) self.instance_txt.insert(END, '\n') if self.running_instance[instance_name] is not None and self.running_instance[instance_name].is_running(): self.instance_txt.insert(END, ugettext( "=> Running in http://%(ip)s:%(port)d\n") % {'ip': self.running_instance[instance_name].lan_ip, 'port': self.running_instance[instance_name].port}) self.btninstframe.winfo_children()[0]["text"] = ugettext( "Stop") else: self.running_instance[instance_name] = None self.instance_txt.insert(END, ugettext("=> Stopped\n")) self.btninstframe.winfo_children()[0]["text"] = ugettext( "Launch") else: self.btninstframe.winfo_children()[0]["text"] = ugettext( "Launch") self.btninstframe.winfo_children()[0].disabled = ( instance_name == '') self.btninstframe.winfo_children()[1].disabled = ( instance_name == '') self.btninstframe.winfo_children()[2].disabled = ( instance_name == '') self.btninstframe.winfo_children()[3].disabled = ( instance_name == '') self.btninstframe.winfo_children()[4].disabled = ( instance_name == '') self.instance_txt.configure(state=DISABLED) finally: setup_from_none() self.instance_list.config(state=NORMAL) @ThreadRun def add_modif_inst_result(self, result, to_create): inst = LucteriosInstance(result[0]) inst.set_extra("LANGUAGE_CODE='%s'" % result[5]) inst.set_appli(result[1]) inst.set_module(result[2]) inst.set_database(result[4]) if to_create: inst.add() else: inst.modif() inst = LucteriosInstance(result[0]) inst.set_extra(result[3]) inst.security() self.refresh(result[0]) def add_inst(self): self.enabled(False) try: self.do_progress(False) ist_edt = InstanceEditor() ist_edt.execute() ist_edt.transient(self) self.wait_window(ist_edt) finally: self.enabled(True) if ist_edt.result is not None: self.add_modif_inst_result(ist_edt.result, True) def modify_inst(self): self.enabled(False) try: self.do_progress(False) ist_edt = InstanceEditor() ist_edt.execute(self.get_selected_instance_name()) ist_edt.transient(self) self.wait_window(ist_edt) finally: self.enabled(True) if ist_edt.result is not None: self.add_modif_inst_result(ist_edt.result, False) @ThreadRun def delete_inst_name(self, instance_name): inst = LucteriosInstance(instance_name) inst.delete() self.refresh() def delete_inst(self): setup_from_none() instance_name = self.get_selected_instance_name() if askokcancel(None, ugettext("Do you want to delete '%s'?") % instance_name): self.delete_inst_name(instance_name) else: self.refresh() @ThreadRun def open_inst(self): instance_name = self.get_selected_instance_name() if instance_name != '': try: if instance_name not in self.running_instance.keys(): self.running_instance[instance_name] = None if self.running_instance[instance_name] is None: port = FIRST_HTTP_PORT for inst_obj in self.running_instance.values(): if (inst_obj is not None) and (inst_obj.port >= port): port = inst_obj.port + 1 self.running_instance[instance_name] = RunServer( instance_name, port) self.running_instance[instance_name].start() else: self.running_instance[instance_name].stop() self.running_instance[instance_name] = None finally: self.set_select_instance_name(instance_name) @ThreadRun def save_instance(self, instance_name, file_name): inst = LucteriosInstance(instance_name) inst.filename = file_name if inst.archive(): showinfo(ugettext("Lucterios installer"), ugettext( "Instance saved to %s") % file_name) else: showerror( ugettext("Lucterios installer"), ugettext("Instance not saved!")) self.refresh(instance_name) def save_inst(self): instance_name = self.get_selected_instance_name() if instance_name != '': file_name = asksaveasfilename( parent=self, filetypes=[('lbk', '.lbk'), ('*', '.*')]) if file_name != '': self.save_instance(instance_name, file_name) @ThreadRun def restore_instance(self, instance_name, file_name): if file_name[-4:] == '.bkf': rest_inst = MigrateFromV1(instance_name, withlog=True) else: rest_inst = LucteriosInstance(instance_name) rest_inst.filename = file_name if rest_inst.restore(): showinfo(ugettext("Lucterios installer"), ugettext( "Instance restore from %s") % file_name) else: showerror( ugettext("Lucterios installer"), ugettext("Instance not restored!")) self.refresh(instance_name) def restore_inst(self): instance_name = self.get_selected_instance_name() if instance_name != '': file_name = askopenfilename( parent=self, filetypes=[('lbk', '.lbk'), ('bkf', '.bkf'), ('*', '.*')]) if file_name != '': self.restore_instance(instance_name, file_name) def execute(self): self.refresh() center(self, (700, 300)) self.mainloop()
class TimeClock(Frame): def __init__(self, parent, *args, **kwargs): Frame.__init__(self,parent, *args, **kwargs) self.e=Entry(self,text='Message') self.e.delete(0,"end") self.e.pack() self.makebuttons() self.pack( expand='true', fill='x') def makebuttons(self): self.b1 = Button(self, text="Tock" , bg='BLUE', activebackground="Blue", activeforeground='White',fg='white', height='2', width='8' , command = self.write ) self.b2 = Button(self, text="Tick", activebackground='red', bg='red', activeforeground='White',fg='white', command = self.quit ) self.b1.pack(side='right', fill='both') self.b2.pack(side='left', fill='both') self.lastTime = "" self.start_timer() def start_timer(self): def callback(): #self.message=self.e.delete(0,"end") self.message=self.e.get() print ("input text is equal to->",self.message) root.title(self.message+":TIMER") self.e.destroy() self.B.destroy() self.B= Button(self,text='start', command=callback) self.B.pack() t=time.localtime() self.zeroTime = dt.timedelta(hours=t[3], minutes=t[4], seconds=t[5]) self.tick() def tick(self): self.now = dt.datetime(1, 1, 1).now() elapsedTime = self.now - self.zeroTime time2 = elapsedTime.strftime('%H:%M:%S') if time2 != self.lastTime: self.lastTime = time2 self.b1.config(text=time2) self.b2.config(text=self.now.strftime('%I:%M:%S')) self.after(20, self.tick) def write(self): g=time.localtime() Datename = dt.datetime(1,1,1).now().strftime('%Y%m%d') my_Time = dt.timedelta(hours=g[3], minutes=g[4], seconds=g[5]) #filename="C:\Users\jpeters\Timer.log\\"+Datename+"_demo.csv" filename="/home/jeff/Desktop/"+Datename+"_demo.csv" file =open(filename, 'a' ) file.write(str(Datename)) file.write(', ') file.write(str(my_Time)) file.write(', ') file.write((self.lastTime)) file.write(', ') file.write(str(self.message)) file.write('\n') file.close() self.start_timer() def quit(self): self.write() root.destroy()
class TrendProg(Frame): def __init__(self, parent): Frame.__init__(self, parent, background='white') # saved reference to parent widget. "Tk root window" self.parent = parent self._workbook = None self._file_path = None self._folder_path = None # set properties of buttons self.frame_1 = Frame(self, relief=RAISED) self.run_button = Button(self, text='Run', width=10, command=self.run_program) self.file_button = Button(self.frame_1, text='Select File', width=15, command=self.get_file) self.folder_button = Button(self.frame_1, text='Select Folder', width=15, command=self.get_folder) self.close_button = Button(self, text='Close', width=10, command=self.quit) self.init_gui() def init_gui(self): self.parent.title('Trending Analysis') # fill frame to take up whole of root window self.pack(fill=BOTH, expand=True) self.frame_1.pack(fill=BOTH, expand=True) # put buttons on GUI self.folder_button.pack(side=RIGHT, padx=5) self.file_button.pack(side=LEFT, padx=5, pady=5) self.close_button.pack(side=RIGHT, padx=5, pady=5) self.run_button.pack(side=RIGHT, pady=5) def get_file(self): self._file_path = filedialog.askopenfilename() if self._file_path != '': self.file_button.config(text='File Selected!') self.file_button.pack(fill=BOTH, expand=True, padx=5, pady=5) self.folder_button.destroy() def get_folder(self): self._folder_path = filedialog.askdirectory() if self._folder_path != '': self.folder_button.config(text='Folder Selected!') self.folder_button.pack(fill=BOTH, expand=True, padx=5, pady=5) self.file_button.destroy() def run_program(self): workbook = 'Draft_Detail_Findings.xlsx' worksheet = 'Template' # user selected one CAPA print('=' * 75) if self._folder_path == '' or self._folder_path is None: self._file_path = self.convert_to_docx(self._file_path) docx_to_xlsx.main(self._file_path, workbook, worksheet) print('=' * 75) # user selected a folder of CAPA's elif self._file_path == '' or self._file_path is None: for f in os.listdir(self._folder_path): # get full path name file_name = str(self._folder_path + '/' + f) file_name = self.convert_to_docx(file_name) docx_to_xlsx.main(file_name, workbook, worksheet) print('=' * 75) # get ready to end the program # pd = project_data.TrendData(workbook, worksheet) print('Done.') self.frame_1.destroy() self.run_button.destroy() self.close_button.config(text='Done.') self.close_button.pack(fill=BOTH, expand=True, padx=10, pady=10) @classmethod def convert_to_docx(cls, file_selected): """ Check that file(s) selected is .docx NOT .doc and convert if needed. """ if str(file_selected).endswith('.docx'): return file_selected else: new_file_name = re.sub('.doc', '.docx', file_selected) # full path to wordconv.exe word_conv = r'C:\Program Files (x86)\Microsoft Office\Office12\wordconv.exe' commands = ['wordconv.exe', '-oice', '-nme', file_selected, new_file_name] try: print('CONVERTING {}'.format(file_selected)) subprocess.Popen(commands, executable=word_conv) # wait for converted file to be created while not os.path.exists(new_file_name): time.sleep(1.5) print('REMOVING old .doc file ...') os.remove(file_selected) return new_file_name except OSError: print('FAILED to convert file. Check to see if it exists.')
class Experiment: def __init__(self, master): print("Ask") self.filename = "playdata/" + str(input()) master.maxsize(1600, 900) master.minsize(1600, 900) self.state = diveGame() self.master = master master.title("Calculator") self.topLabel = Label(master, text="", font=("Helvetica", 25)) self.topLabel.grid(row=0, column=15) self.lbl = Label( master, text= "Click on a location to prepare a move. If a tank is available and you are surfaced then you can purchase it.", font=("Helvetica", 15)) self.lbl.grid(row=4, column=15) self.var = tkinter.IntVar() self.showing = False self.distance = 0 self.locations = [] self.prevButton = None self.buttons = {} self.reset = Button(self.master, text="Reset Distance Counter", font=("Helvetica", 15), command=self.resetDist) self.reset.grid(row=7, column=15) self.distanceLabel = Label(self.master, text="", font=("Helvetica", 14)) self.distanceLabel.grid(row=8, column=15) self.file = {} # f = open('store.pckl', 'rb') # rR, rS, hR, hS, rA, hA = pickle.load(f) #self.showRollout(rR) self.experiment() #self.playGame() f = open(self.filename, "wb") pickle.dump(self.file, f) f.close() def resetDist(self): self.distance = 0 self.locations = [] self.distanceLabel.config(text=" ") def destroyButtons(self): for key, button in self.buttons.items(): button.destroy() self.prevButton = None def displayBoard(self, playing=True): self.destroyButtons() self.resetDist() if playing: self.lbl.config( text= "Click on a location to prepare a move. If a tank is available and you are surfaced then you can purchase it.", fg="black") if self.state.isOver(): self.lbl.config(text="GAMEOVER", fg="red") tanks = [tank for tank in self.state.tanks] self.cash = Label(self.master, text=" Cash: " + str(self.state.cash) + " ", font=("Helvetica", 15)) self.cash.grid(row=15, column=15) self.time = Label(self.master, text=" Time: " + str(self.state.timeLeft) + " ", font=("Helvetica", 15)) self.time.grid(row=16, column=15) self.oxygen = Label(self.master, text=" Oxygen Left: " + str(self.state.oxygenLeft) + " / " + str(self.state.tankSize), font=("Helvetica", 15)) self.oxygen.grid(row=17, column=15) self.holding = Label(self.master, text=" Holding: " + str(sum((self.state.holding))) + " ", font=("Helvetica", 15)) self.holding.grid(row=18, column=15) self.buttons['cash'] = self.cash self.buttons['time'] = self.time self.buttons['oxygen'] = self.oxygen self.buttons['holding'] = self.holding if playing: def clickTank(action): def executeMove(): def do(): self.move = action if self.move in self.state.getLegalActions(): self.var.set(1) if not self.showing: if (self.state.playerLoc == (0, 0) or self.state.playerLoc == (0, 9)) and self.state.cash >= action[0]: self.lbl.config(text="Tank | Cost: " + str(action[0]) + " | Size: " + str(action[1])) if hasattr(self, 'next'): self.next.destroy() self.next = Button(self.master, text="Execute Move", font=("Helvetica", 15), command=do) self.next.grid(row=5, column=15) self.buttons['next'] = self.next else: print(self.state.cash, action[1]) self.lbl.config(text="Cannot Buy Tank") if self.prevButton: prevbutton = self.buttons[self.prevButton] if self.prevButton != self.state.playerLoc: if self.prevButton == ( 0, 0) or self.prevButton == (0, 9): prevbutton.config(background="Green") elif len(self.prevButton) == 3: prevbutton.config(background="white") else: prevbutton.config(background="Light Gray") self.buttons[action].config(background="orange") self.prevButton = action return do return executeMove else: def clickTank(action): pass c = 0 if playing: enabled = "normal" else: enabled = "disabled" self.tanks = [] for tank in tanks: if tank in self.state.getLegalActions(): t = Button(self.master, text="Tank | Cost: " + str(tank[0]) + " | Size: " + str(tank[1]), font=("Helvetica", 15), command=clickTank(tank), state=enabled) t.grid(row=10 + c, column=15) self.tanks.append(t) self.buttons[tank] = t c += 1 else: t = Button(self.master, text="Tank | Cost: " + str(tank[0]) + " | Size: " + str(tank[1]), font=("Helvetica", 15), command=clickTank(tank), state=enabled) t.config(state="disabled") t.grid(row=10 + c, column=15) self.tanks.append(t) self.buttons[tank] = t c += 1 if self.state.playerLoc == ( 0, 0) or self.state.playerLoc == (0, 9) and playing: def exit(): self.move = (None, None, 'exit') self.var.set(1) print("EXIT") if (self.state.playerLoc == (0, 0) or self.state.playerLoc == (0, 9)): self.exit = Button(self.master, text="EXIT with all your current cash! ", font=("Helvetica", 15), command=exit, state=enabled) self.buttons['exit'] = self.exit self.exit.grid(row=19, column=15) for i in range(0, 20): for j in range(0, 10): if not (i == 0 and (j < 9 and j > 0)): bg = None fg = "black" color = "white" font = ("Helvetica", 11) if i > 0: color = "navy" if self.state.board[i][j]: color = "Light Gray" text = str(self.state.board[i][j]) elif (i, j) == (0, 0) or (i, j) == (0, 9): text = "" color = "Green" else: text = "" if self.state.playerLoc == (i, j): text = "P" color = "Yellow" fg = "brown4" font = ("Helvetica", 10, "bold") if self.state.playerLoc == ( i, j) and self.state.playerLoc[0] != 0: color = "Yellow" b = Button(self.master) b.grid(row=i, column=j) b.row = i b.column = j self.buttons[(i, j)] = b def click(action): i = action[0] j = action[1] def do(): valid = False def executeMove(action): def do(): self.move = action self.prevButton = None if self.move in self.state.getLegalActions( ): self.var.set(1) return do if not self.showing: if ((i, j) == (0, 0) or (i, j) == (0, 9)) and (i, j) != self.state.playerLoc: valid = True text = "Surface Location: " + str( (i, j) ) # + "| distance is " + str(manDist((i, j), self.state.playerLoc)) if self.state.board[i][j]: valid = True text = "Pick up " + str( self.state.board[i][j] ) + " at location " + str( (i, j) ) # + " | distance is " + str(manDist((i, j), self.state.playerLoc)) if valid: if self.prevButton: prevbutton = self.buttons[ self.prevButton] if self.prevButton != self.state.playerLoc: if self.prevButton == ( 0, 0 ) or self.prevButton == (0, 9): prevbutton.config( background="Green") else: prevbutton.config( background="Light Gray") self.buttons[(i, j)].config( background="orange") self.prevButton = (i, j) if not self.locations: self.distance += manDist( (i, j), self.state.playerLoc) else: self.distance += manDist( (i, j), self.locations[-1]) self.locations += [(i, j)] self.distanceLabel.config( text=str(self.locations) + ": " + str(self.distance)) self.lbl.config(text=text) if hasattr(self, 'next'): self.next.destroy() self.next = Button( self.master, text="Execute Move", font=("Helvetica", 15), command=executeMove(action), state=enabled) self.next.grid(row=5, column=15) self.buttons['next'] = self.next return do b.config(highlightthickness=0, text=text, width="3", height="2", font=font, fg=fg, command=click((i, j, "move")), background=color) def playGame(self): self.showing = False self.topLabel.config( text= " YOU ARE PLAYING THE GAME " ) stateActions = [] states = [] states.append(self.state) actions = [] times = [] self.displayBoard() self.move = None while (not self.state.isOver()): now = datetime.now() self.displayBoard() root.wait_variable(self.var) if self.move not in self.state.getLegalActions(): print(self.move, self.state.getLegalActions()) raise Exception stateActions.append((self.state, self.move)) actions.append(self.move) self.state = self.state.getSuccessor(self.move)[0] self.move = None self.var.set(0) states.append(self.state) then = datetime.now() times.append(then - now) self.lbl.config(text="Game Over, Your Score: " + str(self.state.cash)) self.topLabel.config(text="") if 'playthrough' not in self.file: self.file["playthrough"] = [] self.file["playthroughTimes"] = [] self.file['playthrough'].append((states, actions)) self.file['playthroughTimes'].append(times) return actions, states def playStates(self, states): self.showing = False self.topLabel.config( text= " Choose the next move in the state " ) stateActions = [] times = [] for state in states: now = datetime.now() self.state = state self.displayBoard() root.wait_variable(self.var) if self.move not in self.state.getLegalActions(): raise Exception stateActions.append((self.state, self.move)) self.move = None self.var.set(0) for tank in self.tanks: print("GI") tank.destroy() then = datetime.now() times.append(then - now) self.file['testStates'] = stateActions self.file['testStatesTimes'] = times return stateActions def showRollout(self, states): self.next.config(state="disabled") self.exit.config(state="disabled") self.showing = True self.topLabel.config( text="YOU ARE OBSERVING A SERIES OF STATES IN A PLAN") self.nextState = tkinter.IntVar() def nextState(): self.nextState.set(1) for index, state in states: self.lbl.config(text="STATE NUMBER: " + str(index), fg="green") self.state = state self.displayBoard(playing=False) self.nextStateButton = Button(self.master, text="Next State", font=("Helvetica", 15), command=nextState) self.nextStateButton.grid(row=5, column=16) root.wait_variable(self.nextState) self.nextState.set(0) self.nextStateButton.destroy() self.topLabel.config(text="") def showRolloutWithBack(self, states, ff=False): self.destroyButtons() times = [] actions = [] self.showing = True if ff: self.topLabel.config( text="YOU ARE VIEWING A SUPERIOR ALTERNATE PLAN") else: self.topLabel.config( text="YOU ARE OBSERVING A SERIES OF STATES IN A PLAN") self.nextState = tkinter.IntVar() def nextState(): self.nextState.set(1) self.prev = False actions.append("next") def prevState(): self.nextState.set(1) self.prev = True actions.append("prev") i = 0 while i < len(states): if ff: if i == len(states) - 2: self.topLabel.config( text= " Right before your Fatal Flaw", fg="red") elif i == len(states) - 1: self.topLabel.config( text= " Result of your Fatal Flaw", fg="red") else: self.topLabel.config( text=" YOU ARE OBSERVING A SERIES OF STATES IN A PLAN", fg="black") index, state = states[i] self.lbl.config(text="STATE NUMBER: " + str(index), fg="green") self.state = state self.displayBoard(playing=False) if hasattr(self, 'prevStateButton'): self.prevStateButton.destroy() self.nextStateButton.destroy() self.nextStateButton = Button(self.master, text="Next State", font=("Helvetica", 15), command=nextState) self.nextStateButton.grid(row=6, column=17) self.prevStateButton = Button(self.master, text="Prev State", font=("Helvetica", 15), command=prevState) self.prevStateButton.grid(row=6, column=16) self.buttons['prevStateButton'] = self.prevStateButton self.buttons['nextStateButton'] = self.nextStateButton now = datetime.now() root.wait_variable(self.nextState) after = datetime.now() times.append(after - now) if self.prev: if i > 0: i -= 1 else: i += 1 self.nextState.set(0) self.topLabel.config(text="") self.file["ShowRolloutActions"] = actions self.file["ShowRolloutTimes"] = times def experiment(self): f = open("General Test States", "rb") tStates = reconstructStates(pickle.load(f)) random.shuffle(tStates) stateActions = self.playStates(tStates)
class BorrowDetails(ItemDetails): def __init__(self, item, frame, row, maxDays, maxExtend): self.frame = frame self.maxDays = maxDays self.maxExtend = maxExtend self.item = item self.row = row self.reader = None self.entries = {} self.buttons = [] self.entries['period'] = StringVar() self.heading(row=row, text='Kölcsönzés') self.borrowerField(row=self.row + 1) self.selectPeriod() if self.get(): self.extendButton() else: self.borrowButton() def selectPeriod(self): self.optionMenu(row=self.row + 2, key='period', label='Kölcsönzési napok', options=range(1, self.maxDays + 1)) def buttonReset(self): # RESET BUTTONS [button.grid_forget() for button in self.buttons] self.buttons.clear() def borrowButton(self): self.buttonReset() # Create and Place Borrow Button self.buttons.append( self.button(self.row + 3, 'Kölcsönzés', command=self.borrow)) def extendButton(self): self.buttonReset() # Create and Place Extend Button self.buttons.append( self.button(self.row + 3, 'Hosszabbítás', command=self.extend)) # Create and Place Return Button self.buttons.append( self.button(self.row + 4, 'Visszatérítés', command=self.returnItem)) def borrowerField(self, row): # Create and Place Label self.label('Olvasó', row=row) # Fetch Borrower's Name try: borrower = self.get().readers.name except: borrower = '...' # CHOOSE BORROWER FIELD # Create Borrower Field self.borrower = Button(master=self.frame, text=borrower, command=self.select) # Place Borrower Field self.borrower.grid(row=row, column=1, sticky=W + E) def get(self): # Return Current Item's Borrow Record table = getattr(Borrow, self.item.__tablename__) return session.query(Borrow).filter( table.has(id=self.item.id)).join(Reader).first() def getDeadline(self): # RETURN DEADLINE DATE: # Current Date + Days to Borrow # If Extending: Date = Deadline on Record days = int(self.entries['period'].get() or 0) date = self.get().deadline if self.get() else datetime.now().date() return date + timedelta(days=days) def extend(self): # CURRENT ITEM'S BORROW RECORD borrow = self.get() period = self.entries['period'] # UPDATE BORROW RECORD # Increase Extended Counter # Update BorrowDeadline update = Borrow(id=borrow.id, deadline=self.getDeadline(), extended=Borrow.extended + 1) # Check If Maximum Number of Extensions Has Been Reached if borrow.extended <= self.maxExtend + 1: # Check If Lending Period Has Been Set if period.get(): # Insert Data To DB session.merge(update) session.commit() messagebox.showinfo('Hosszabbítás', 'Sikeresen meghosszabbítva') else: messagebox.showwarning('Hosszabbítás', 'A kölcsönzés többet nem hosszabbítható.') # RESET SELECT PERIOD FIELD period.set('') def returnItem(self): # Remove Returned Item from Borrows List self.delete() # Reset Fields self.borrowButton() self.borrowerField(self.row + 1) self.entries['period'].set('') def delete(self): # Remove Returned Item from Borrows List item = self.get() item and session.delete(item) session.commit() def borrow(self): # Delete Old Borrow self.delete() # Create New Borrow Record borrow = Borrow(readers=self.reader, deadline=self.getDeadline()) # Set Borrowed Item setattr(borrow, self.item.__tablename__, self.item) # Number of Borrowed Items count = session.query(Borrow).filter_by( reader_id=self.reader.id).count() # Check If Number of Borrowed Items Less Than 5 if count < 5: if self.reader: # Insert Data To DB session.merge(borrow) session.commit() self.extendButton() # Reset messagebox.showinfo('Kölcsönzés', 'Kikölcsönözve.') else: messagebox.showerror( 'Kölcsönzés', 'A maxiumum kölcsönözhető dokumentumok meghaladva.') # RESET SELECT PERIOD FIELD self.entries['period'].set('') def select(self): # Fetch Reader ID From Dialog readerId = ReadersDialog(self.frame).show() # Fetch Reader By ID self.reader = session.query(Reader).get(readerId) # Set Reader Name On Button self.borrower.config(text=self.reader.name) # Reset self.borrowButton()
class Gui: def __init__(self, root): self.root = root self.path = StringVar() self.outpath = StringVar() self.file_dir = '' self.save_dir = '' Label(self.root, text="").grid(row=0, column=0) Label(self.root, text="原始文件:").grid(row=1, column=0) Entry(self.root, textvariable=self.path, width=40).grid(row=1, column=1) Button(self.root, text="打开", command=self.selectPath).grid(row=1, column=3) Label(self.root, text="保存文件:").grid(row=2, column=0) Entry(self.root, textvariable=self.outpath, width=40).grid(row=2, column=1) Button(self.root, text="保存", command=self.select_outPath).grid(row=2, column=3) self.lb = Label(self.root, text='欢迎 !') self.lb.grid(row=3, column=1) self.bt = Button(self.root, text="生成报告", command=self.run) self.bt.grid(row=4, column=1) self.write_ok = False self.err = False def selectPath(self): self.file_dir = askdirectory() self.save_dir = self.file_dir self.path.set(self.file_dir) self.outpath.set(self.file_dir) self.err = False def select_outPath(self): self.save_dir = askdirectory() self.outpath.set(self.save_dir) def run(self): self.lb.config(text="运行...") th = threading.Thread(target=self.write) th.start() th2 = threading.Thread(target=self.ui) th2.start() def ui(self): if not self.write_ok: self.bt.config(state='disabled') while not self.write_ok: time.sleep(3) self.bt.config(state='normal') if not self.err: self.lb.config(text="完成!") def write(self): self.write_ok = False try: writer = Writer(self.file_dir, self.save_dir) writer.write_doc() writer.write_pdf() self.write_ok = True except Exception as e: print(e) self.err = True self.lb.config(text="路径或文件错误!") self.write_ok = True
class App(): global minutesEnd, secondsEnd, mode mode = -1 # -1 = timer off; 0 = workout (timer on); 1 = relax (timer on) def __init__(self): # main-window self.window = Tk() self.window.resizable(False, False) self.window.wm_geometry( "+%d+%d" % ((self.window.winfo_screenwidth() - self.window.winfo_reqwidth()) / 3, (self.window.winfo_screenheight() - self.window.winfo_reqheight()) / 3)) self.window.geometry("490x280") self.window.title("Workouts") # label with current time self.labelCurrentTime = Label(font=("", 25), pady=5) self.labelCurrentTime.grid(row=0, column=0, columnspan=4) self.label1 = Label(self.window, text="Number of minutes for workout:", anchor='w', width=23) self.label1.grid(row=1, column=0) self.entryMinutesForWork = Entry(self.window, width=2) self.entryMinutesForWork.insert(0, "5") self.entryMinutesForWork.grid(row=1, column=1) self.label2 = Label(self.window, text="Number of seconds for workout:", anchor='w', width=23) self.label2.grid(row=1, column=2) self.entrySecondsForWork = Entry(self.window, width=2) self.entrySecondsForWork.insert(0, "0") self.entrySecondsForWork.grid(row=1, column=3) self.label3 = Label(self.window, text="Number of minutes for relax:", anchor='w', width=23) self.label3.grid(row=2, column=0) self.entryMinutesForRelax = Entry(self.window, width=2) self.entryMinutesForRelax.insert(0, "5") self.entryMinutesForRelax.grid(row=2, column=1) self.label4 = Label(self.window, text="Number of seconds for relax:", anchor='w', width=23) self.label4.grid(row=2, column=2) self.entrySecondsForRelax = Entry(self.window, width=2) self.entrySecondsForRelax.insert(0, "0") self.entrySecondsForRelax.grid(row=2, column=3) # start/stop self.buttonStart = Button(self.window, text="Start", font=("", 20), pady=10) self.buttonStart.grid(row=3, column=0, columnspan=4) self.buttonStart.bind("<Button-1>", self.startStop) # timer self.labelTimer = Label(text="Press Start", font=("", 70), pady=15) self.labelTimer.grid(row=4, column=0, columnspan=4) # settings menu bar menubar = Menu() self.window.config(menu=menubar) fileMenu = Menu(menubar, tearoff=0) menubar.add_cascade(label="File", menu=fileMenu) fileMenu.add_command(label="About Minesweeper", command=self.aboutApp) fileMenu.add_separator() fileMenu.add_command(label="Exit", command=exit) self.startTimer() self.window.mainloop() # about-window def aboutApp(self): # creation about-window if there is not if self.window.winfo_children().__len__() == 12: aboutWindow = Toplevel(self.window) aboutWindow.title("About Workouts") aboutWindow.geometry("260x120") aboutWindow.resizable(False, False) aboutWindow.wm_geometry("+%d+%d" % ((aboutWindow.winfo_screenwidth() / 2 - aboutWindow.winfo_reqwidth()), (aboutWindow.winfo_screenheight() / 2 - aboutWindow.winfo_reqheight()))) _ = Label(aboutWindow, text="Workouts by Andrew Jeus", font=("", 18)).grid(row=0, column=0, padx=10, pady=10) _ = Label(aboutWindow, text="Version 1.0 (14 July 2019)", font=("", 18)).grid(row=1, column=0) labelInfo3 = Label(aboutWindow, text="View code in GitHub", font=("", 14)) labelInfo3.grid(row=2, column=0, padx=5, pady=5) # my font for link to GitHub myfont = font.Font(labelInfo3, labelInfo3.cget("font")) myfont.configure(underline=True) labelInfo3.configure(font=myfont) labelInfo3.bind( "<Button-1>", lambda _: webbrowser.open_new( "https://github.com/MickeyMouseMouse/Workouts")) def startTimer(self): global minutesEnd, secondsEnd, mode # update current time self.labelCurrentTime.config( text=time.strftime("%H:%M:%S", time.localtime())) if mode != -1: tmpSeconds = secondsEnd - int(time.strftime( "%S", time.localtime())) tmpMinutes = minutesEnd - int(time.strftime( "%M", time.localtime())) if tmpSeconds == 0 and tmpMinutes == 0: if mode == 0: mode = 1 else: mode = 0 self.setEndTime() if tmpSeconds < 0: tmpSeconds = secondsEnd + ( 60 - int(time.strftime("%S", time.localtime()))) tmpMinutes -= 1 if tmpMinutes < 0: tmpMinutes = minutesEnd + ( 60 - int(time.strftime("%M", time.localtime()))) self.labelTimer.config(text=tmpMinutes.__str__() + " : " + tmpSeconds.__str__()) # repeat this function after 1 second self.window.after(1000, self.startTimer) def setEndTime(self): global secondsEnd, minutesEnd, mode secondsEnd = int(time.strftime("%S", time.localtime())) minutesEnd = int(time.strftime("%M", time.localtime())) if mode == 0: secondsEnd += int(self.entrySecondsForWork.get()) minutesEnd += int(self.entryMinutesForWork.get()) self.labelTimer.config(fg="red") else: secondsEnd += int(self.entrySecondsForRelax.get()) minutesEnd += int(self.entryMinutesForRelax.get()) self.labelTimer.config(fg="green") if secondsEnd >= 60: secondsEnd %= 60 minutesEnd += 1 if minutesEnd >= 60: minutesEnd %= 60 # checking the correctness of the input values def isInputCorrect(self): if not (self.entryMinutesForWork.get().isdigit() and int(self.entryMinutesForWork.get()) in range(60)): return False if not (self.entrySecondsForWork.get().isdigit() and int(self.entrySecondsForWork.get()) in range(60)): return False if not (self.entryMinutesForRelax.get().isdigit() and int(self.entryMinutesForRelax.get()) in range(60)): return False if not (self.entrySecondsForRelax.get().isdigit() and int(self.entrySecondsForRelax.get()) in range(60)): return False if (self.entryMinutesForWork.get() == "0" and self.entrySecondsForWork.get() == "0" and self.entryMinutesForRelax.get() == "0" and self.entrySecondsForRelax.get() == "0"): return False return True # start/stop timer def startStop(self, _): global mode if mode == -1: if self.isInputCorrect(): mode = 0 self.buttonStart.config(text="Stop") self.labelTimer.config(text="") self.setEndTime() else: self.entryMinutesForWork.delete(0, 'end') self.entrySecondsForWork.delete(0, 'end') self.entryMinutesForRelax.delete(0, 'end') self.entrySecondsForRelax.delete(0, 'end') self.labelTimer.config(text="Incorrect Input") else: mode = -1 self.buttonStart.config(text="Start") self.labelTimer.config(fg="black") self.labelTimer.config(text="Press Start")
class _Tk_Nosy(object): """This class is the tkinter GUI object""" def __init__(self, master): self.dirname = os.path.abspath( os.curdir ) self.initComplete = 0 self.master = master self.x, self.y, self.w, self.h = -1,-1,-1,-1 # bind master to <Configure> in order to handle any resizing, etc. # postpone self.master.bind("<Configure>", self.Master_Configure) self.master.bind('<Enter>', self.bindConfigure) self.menuBar = Menu(master, relief = "raised", bd=2) top_Directory = Menu(self.menuBar, tearoff=0) top_Directory.add("command", label = "Change Dir", command = self.menu_Directory_Change_Dir) self.menuBar.add("cascade", label="Directory", menu=top_Directory) #top_Snippet = Menu(self.menuBar, tearoff=0) self.menuBar.add("command", label = "Run", command = self.menu_Run) master.config(menu=self.menuBar) # make a Status Bar self.statusMessage = StringVar() self.statusMessage.set(self.dirname) self.statusbar = Label(self.master, textvariable=self.statusMessage, bd=1, relief=SUNKEN) self.statusbar.pack(anchor=SW, fill=X, side=BOTTOM) self.statusbar_bg = self.statusbar.cget('bg') # save bg for restore myFont = tkinter.font.Font(family="Arial", size=12, weight=tkinter.font.BOLD) self.statusbar.config( font=myFont ) frame = Frame(master) frame.pack(anchor=NE, fill=BOTH, side=TOP) self.Pass_Fail_Button = Button(frame,text="Pass/Fail Will Be Shown Here", image="", width="15", background="green", anchor=W, justify=LEFT, padx=2) self.Pass_Fail_Button.pack(anchor=NE, fill=X, side=TOP) self.Pass_Fail_Button.bind("<ButtonRelease-1>", self.Pass_Fail_Button_Click) #self.master.title("tk_nosy") self.master.title('Python %s.%s.%s '%sys.version_info[:3]) self.oscillator = 1 # animates character on title self.oscillator_B = 0 # used to return statusbar to statusbar_bg self.lbframe = Frame( frame ) self.lbframe.pack(anchor=SE, side=LEFT, fill=BOTH, expand=1) scrollbar = Scrollbar(self.lbframe, orient=VERTICAL) self.Text_1 = Text(self.lbframe, width="80", height="24", yscrollcommand=scrollbar.set) scrollbar.config(command=self.Text_1.yview) scrollbar.pack(side=RIGHT, fill=Y) self.Text_1.pack(side=LEFT, fill=BOTH, expand=1) self.master.resizable(1,1) # Linux may not respect this self.numNosyCalls = 0 self.need_to_pick_dir = 1 if len(sys.argv)>1: # I don't care what the exception is, if there's a problem, bail # pylint: disable=W0702 try: dirname = os.path.abspath( sys.argv[1] ) self.try_change_to_new_dir( dirname ) except: pass # let Alarm force dir selection else: try: if os.path.isdir(os.path.join( self.dirname, 'tests' )): self.try_change_to_new_dir( self.dirname ) except: pass # let Alarm force dir selection print(LICENSE) self.Alarm() def try_change_to_new_dir(self, dirname): """A legal abspath will switch to dirname.""" # I don't care what the exception is, if there's a problem, bail # pylint: disable=W0702 if dirname: try: dirname = os.path.abspath( dirname ) except: return # let Alarm force dir selection else: return self.dirname = dirname print('Selected dirname =',dirname) fileD.clear() os.chdir( self.dirname ) self.reset_statusbar_bg() self.need_to_pick_dir = 0 #with open(NOSY_USER_DATA_FILE, 'w') as text_file: # text_file.write( self.dirname ) self.numNosyCalls = 0 def reset_statusbar_bg(self): """Return status bar to default state""" self.statusbar.config(bg=self.statusbar_bg) self.statusMessage.set(self.dirname) def set_statusbar_bg(self, c): """Set status bar to show new color and message""" self.statusbar.config(bg=c) self.oscillator_B = 1 # will return to initial color after a few cycles def menu_Directory_Change_Dir(self): """Menu selection to set directory in which to run nosetests""" dirname = self.AskDirectory( title='Choose Directory For Nose Tests', initialdir=".") if dirname: self.try_change_to_new_dir( dirname ) # >>>>>>insert any user code below this comment for section "menu_Directory_Change_Dir" # replace, delete, or comment-out the following print("called menu_Directory_Change_Dir") def menu_Run(self): """User initiates a nosetests run, not file change detection.""" print("called menu_Run") self.callNosy() def callNosy(self): """Run nosetests and display results""" self.numNosyCalls += 1 self.Text_1.delete(1.0, END) # turn indicator button gray while running the tests myFont = tkinter.font.Font(family="Arial", size=12, weight=tkinter.font.BOLD) self.Pass_Fail_Button.config(background="#999999", text='TESTING...', font=myFont) self.master.update() self.master.update_idletasks() # pylint: disable=W0201 self.passedAllTests, numPassed, numFailed, numErrors, numSkipped, outputTextL = \ run_nosetests(self.numNosyCalls) max_len_s = 42 num_lines = 1 for s in outputTextL: self.Text_1.insert(END, s) sL = s.split('\n') for ss in sL: max_len_s = max(max_len_s, len(ss)) num_lines += 1 if self.numNosyCalls % 2: myFont = tkinter.font.Font(family="Arial", size=12, weight=tkinter.font.BOLD) else: myFont = tkinter.font.Font(family="Arial", size=12) if self.passedAllTests: s = 'PASSED' if numPassed > 1: s = 'PASSED ALL %i TESTS'%numPassed elif numPassed == 1: s = 'PASSED ONE TEST' bg="#00ff00" if numSkipped==1: s = 'passed with 1 SKIP' bg = "#00cc00" elif numSkipped > 1: s = 'passed with %i SKIPS'%numSkipped bg = "#00cc00" elif numPassed==0: s = 'No Tests Found' bg="#ff8000" self.Pass_Fail_Button.config(background=bg, text=s, font=myFont) #self.master.geometry('200x50') else: s = 'FAILED %i, ERRORS %i, SKIP %i, PASSED %i'%(numFailed, numErrors, numSkipped, numPassed) self.Pass_Fail_Button.config(background="#ff0000", text=s, font=myFont) #self.master.geometry('516x385') # Show list of files being watched. #self.Text_1.insert(END, '_'*40+'\n') self.Text_1.insert(END, 'WATCHED *.py FILES'.center(40,'_') + '\n' ) self.Text_1.insert(END, '%s%s..\n\n'%(self.dirname,os.path.sep) ) num_lines += 3 len_dirname = len( self.dirname ) keyL = list(fileD.keys()) keyL.sort() lastdir = '' for key in keyL: dn = os.path.dirname( key ) if dn != lastdir: self.Text_1.insert(END, '..'+dn[len_dirname:] + '\n') max_len_s = max(max_len_s, len(dn)+1) lastdir = dn num_lines += 1 s = ' ' +os.path.basename( key ) self.Text_1.insert(END, s + '\n') max_len_s = max(max_len_s, len(s)+1) num_lines += 1 self.Text_1.config(width=max_len_s) self.Text_1.config(height=min(40, num_lines)) self.master.winfo_toplevel().wm_geometry("") def bindConfigure(self, event): """Part of goofy main window setup in tkinter.""" # tkinter requires arguments, but I don't use them # pylint: disable=W0613 if not self.initComplete: self.master.bind("<Configure>", self.Master_Configure) self.initComplete = 1 # return a string containing directory name def AskDirectory(self, title='Choose Directory', initialdir="."): """Run pop-up menu for user to select directory.""" # This is not an error # pylint: disable=E1101 if sys.version_info < (3,): dirname = tkFileDialog.askdirectory(parent=self.master, initialdir=initialdir,title=title) else: dirname = tkinter.filedialog.askdirectory(parent=self.master, initialdir=initialdir,title=title) return dirname # <-- string def Master_Configure(self, event): """Part of tkinter main window initialization""" if event.widget != self.master: if self.w != -1: return x = int(self.master.winfo_x()) y = int(self.master.winfo_y()) w = int(self.master.winfo_width()) h = int(self.master.winfo_height()) if (self.x, self.y, self.w, self.h) == (-1,-1,-1,-1): self.x, self.y, self.w, self.h = x,y,w,h if self.w!=w or self.h!=h: #print "Master reconfigured... make resize adjustments" self.w=w self.h=h def Pass_Fail_Button_Click(self, event): """Place-holder routine for user clicking Pass/Fail Button""" pass # alarm function is called after specified number of milliseconds def SetAlarm(self, milliseconds=1000): """Reinitialize tkinter alarm mechanism as well as update seconds counter in main window title bar. """ self.master.after( milliseconds, self.Alarm ) self.oscillator += 1 if self.oscillator > 5: self.oscillator = 0 if self.oscillator_B>0: self.oscillator_B += 1 if self.oscillator_B>5: self.oscillator_B = 0 self.reset_statusbar_bg() pad = '|'*self.oscillator #self.master.title("%i) tk_nosy "%self.numNosyCalls + pad ) s = '%s.%s.%s '%sys.version_info[:3] self.master.title('%i) Python %s '%(self.numNosyCalls , s + pad )) def Alarm(self): """Look for changed files every second, then reset alarm""" if self.need_to_pick_dir: dirname = self.AskDirectory( title='Choose Directory For Nose Tests', initialdir=".") self.try_change_to_new_dir( dirname ) #first call to numberOfChangedFiles will be > 0 if any .py files are found elif numberOfChangedFiles( self.dirname ) > 0: # or self.numNosyCalls==0 self.callNosy() self.SetAlarm()
class CurrencyConverterUI(Tk): """This display text field and button to interact with to change money""" def __init__(self, converter): """Creates a window to convert currency :param converter: the model of a currency converter """ Tk.__init__(self) self.title = 'Currency Converter' self.currency_converter = converter self.geometry("500x200") # Label self.intro_label = Label(self, text='Welcome to Real Time Currency Convertor', fg='blue', relief=RAISED, borderwidth=3) self.intro_label.config(font=('Courier', 15, 'bold')) self.date_label = Label( self, text=f"1 Canadian Dollar = " f"{self.currency_converter.convert('CAD', 'USD', 1)}" f" USD \n Date : {self.currency_converter.data['date']}", relief=GROOVE, borderwidth=5) self.intro_label.place(x=10, y=5) self.date_label.place(x=170, y=50) # Entry box valid = (self.register(self.restrict_number_only), '%P') # restric NumberOnly function will restrict this user to enter # invavalid number in Amount field. We will define it later in code self.amount_field = Entry(self, bd=3, relief=RIDGE, justify=CENTER, validate='key', validatecommand=valid) self.converted_amount_field_label = Label(self, text='', fg='black', bg='white', relief=RIDGE, justify=CENTER, width=17, borderwidth=3) # dropdown self.from_currency_variable = StringVar(self) self.from_currency_variable.set("CAD") # default value self.to_currency_variable = StringVar(self) self.to_currency_variable.set("USD") # default value font = ("Courier", 12, "bold") self.option_add('*TCombobox*Listbox.font', font) self.from_currency_dropdown = Combobox( self, textvariable=self.from_currency_variable, values=list(self.currency_converter.currencies.keys()), font=font, state='readonly', width=12, justify=CENTER) self.to_currency_dropdown = Combobox( self, textvariable=self.to_currency_variable, values=list( self.currency_converter.currencies.keys()), font=font, state='readonly', width=12, justify=CENTER) # placing self.from_currency_dropdown.place(x=30, y=120) self.amount_field.place(x=36, y=150) self.to_currency_dropdown.place(x=340, y=120) # self.converted_amount_field.place(x = 346, y = 150) self.converted_amount_field_label.place(x=346, y=150) # Convert button self.convert_button = Button(self, text="Convert", fg="black", command=self.perform) self.convert_button.config(font=('Courier', 10, 'bold')) self.convert_button.place(x=225, y=135) def perform(self): """Performs the conversion of a currency to another using the model :return: None """ amount = float(self.amount_field.get()) from_curr = self.from_currency_variable.get() to_curr = self.to_currency_variable.get() converted_amount = self.currency_converter.convert(from_curr, to_curr, amount) converted_amount = round(converted_amount, 2) self.converted_amount_field_label.config(text=str(converted_amount)) def restrict_number_only(self, string): """Restrict the uses of numbers only in text fields :param string: the input to validate :return: True if the input is number only, False otherwise """ regex = re.compile(r"[0-9,]*?(\.)?[0-9,]*$") result = regex.match(string) return string == "" or (string.count('.') <= 1 and result is not None)
class Vaisseaux(object): ''' classdocs ''' def __init__(self,grille,canvas,logo): self.grille = grille self.canvas = canvas self.logo= logo self.B = Button(self.canvas, text ="Commencer",command = self.ouvrirDialogue1) self.B.pack(side = tk.BOTTOM,pady=80) self.posX = 0 self.posY = 0 # Cette fonction est appelee pour placer les vaisseaux au debut du jeux def placer_vaisseaux1(self): self.grille.canvas.bind("<Button-1>", self.jouer1) self.B.config(state=DISABLED) # Cette fonction permet au joueur 1 de palcer ses vaisseaux def jouer1(self,event): if (self.grille.nbVaisseauxPlaces(self.grille.pos) < 5): if(self.grille.getCasePos(event.x//40,event.y//40,1).getcouleur() == "green" or self.grille.nbVaisseauxPlaces(self.grille.pos) == 0): self.effacerGreen(1) self.grille.getCasePos(event.x//40,event.y//40,1).setsituation(2) self.guider(event.x//40,event.y//40,1) self.grille._dessiner_grille() self.posX = event.x//40 self.posY = event.y//40 if(self.grille.nbVaisseauxPlaces(self.grille.pos) == 5): self.posX = 0 self.posY = 0 self.ouvrirDialogue2() #self.placer_vaisseaux2() # Cette fonction permet au joueur 2 de palcer ses vaisseaux def placer_vaisseaux2(self): self.grille.canvas1.bind("<Button-1>", self.jouer2) # Cette fonction permet au joueur 2 de palcer ses vaisseaux def jouer2(self,event): if (self.grille.nbVaisseauxPlaces(self.grille.pos2) < 5): if(self.grille.getCasePos(event.x//40,event.y//40,2).getcouleur() == "green" or self.grille.nbVaisseauxPlaces(self.grille.pos2) == 0): self.effacerGreen(2) self.grille.getCasePos(event.x//40,event.y//40,2).setsituation(2) self.guider(event.x//40,event.y//40,2) self.grille._dessiner_grille() self.posX = event.x//40 self.posY = event.y//40 if(self.grille.nbVaisseauxPlaces(self.grille.pos2) == 5): self.grille.commencer() self.grille._dessiner_grille() showinfo("Au joueur 1 de jouer", "Essayez de trouvez le vaisseau du joueur 2 !!") self.grille.permuterGrilles(self.grille.pos,self.grille.pos2) Jouer(self.grille,self.B) def guider(self,pos1,pos2,num): if(num == 1): tableau = self.grille.pos else: tableau = self.grille.pos2 if (self.posX == 0 and self.posY == 0): self.grille.getCasePos(pos1+1,pos2,num).setcouleur("green") self.grille.getCasePos(pos1-1,pos2,num).setcouleur("green") self.grille.getCasePos(pos1,pos2+1,num).setcouleur("green") self.grille.getCasePos(pos1,pos2-1,num).setcouleur("green") elif(pos1 > self.posX and self.grille.nbVaisseauxPlaces(tableau) < 5 ): if(pos1 == self.grille.width - 1): pos1 = pos1 - self.grille.nbVaisseauxPlaces(tableau) self.grille.getCasePos(pos1,pos2,num).setcouleur("green") else: self.grille.getCasePos(pos1+1,pos2,num).setcouleur("green") elif(pos1 < self.posX and self.grille.nbVaisseauxPlaces(tableau) < 5): if(pos1 == 0): pos1 = pos1 + self.grille.nbVaisseauxPlaces(tableau) self.grille.getCasePos(pos1,pos2,num).setcouleur("green") else: self.grille.getCasePos(pos1-1,pos2,num).setcouleur("green") elif(pos2 > self.posY and self.grille.nbVaisseauxPlaces(tableau) < 5 ): if(pos2 == self.grille.height - 1): pos2 = pos2 - self.grille.nbVaisseauxPlaces(tableau) self.grille.getCasePos(pos1,pos2,num).setcouleur("green") else: self.grille.getCasePos(pos1,pos2+1,num).setcouleur("green") elif(pos2 < self.posY and self.grille.nbVaisseauxPlaces(tableau) < 5 ): if(pos2 == 0): pos2 = pos2 + self.grille.nbVaisseauxPlaces(tableau) self.grille.getCasePos(pos1,pos2,num).setcouleur("green") else: self.grille.getCasePos(pos1,pos2-1,num).setcouleur("green") def effacerGreen(self,num): for i in range(self.grille.width): for j in range(self.grille.height): if(self.grille.getCasePos(i,j,num).getcouleur() == "green"): self.grille.getCasePos(i,j,num).setcouleur("black") self.grille._dessiner_grille() def placerVaisseauAleatoire(self): r = random.randint(1,10) for i in range(1,6): self.grille.getCasePos(r,i,1).setsituation(2) self.grille._dessiner_grille() self.ouvrirDialogue2() def placerVaisseauAleatoire2(self): r = random.randint(1,10) for i in range(1,6): self.grille.getCasePos(r,i,2).setsituation(2) self.grille._dessiner_grille() showinfo("Joueur 1", "Au joueur 1 de jouer !!") self.grille.commencer() self.grille._dessiner_grille() self.grille.permuterGrilles(self.grille.pos,self.grille.pos2) Jouer(self.grille,self.B) def ouvrirDialogue1(self): if messagebox.askquestion("Joueur 1", "Voulez vous placez les vaisseausx aléatoirement?")=="no": showinfo("Joueur 1", "Placez votre vaisseau en cliquant sur 5 cases de votre grille !!") self.placer_vaisseaux1() else: self.B.config(state=DISABLED) self.placerVaisseauAleatoire() def ouvrirDialogue2(self): if messagebox.askquestion("Joueur 2", "Voulez vous placez les vaisseausx aléatoirement?")=="no": showinfo("Joueur 2", "Placez votre vaisseau en cliquant sur 5 cases de votre grille !!") self.placer_vaisseaux2() else: self.placerVaisseauAleatoire2()
class AnalysisToolsManager: def __init__(self, controller): self.tab = None self.controller = controller self.tk_format = utils.TkFormat(self.controller.config_info) self.analysis_dialog = None self.exclude_artifacts = IntVar() self.abs_val = IntVar() self.use_max_for_centers = IntVar() self.use_delta = IntVar() self.neg_depth = IntVar() self.normalize_entry = None self.right_zoom_entry = None self.right_zoom_entry2 = None self.left_zoom_entry = None self.left_zoom_entry2 = None self.left_slope_entry = None self.right_slope_entry = None self.slopes_listbox = None self.abs_val_check = None self.use_max_for_centers_check = None self.use_delta_check = None self.neg_depth_check = None self.exclude_artifacts_check = None self.extra_analysis_check_frame = None self.plot_slope_var = None self.offset_entry = None self.offset_sample_var = None self.plot_slope_menu = None self.plot_slope_button = None self.analyze_var = None self.outer_slope_frame = None self.slope_results_frame = None def show(self, tab): self.tab = tab self.tab.freeze( ) # You have to finish dealing with this before, say, opening another analysis box. buttons = { "reset": { self.select_tab: [], self.tab.reset: [], self.uncheck_exclude_artifacts: [], self.disable_plot: [], # utils.thread_lift_widget: [], }, "close": {}, } self.analysis_dialog = VerticalScrolledDialog(self.controller, "Analyze Data", "", buttons=buttons, button_width=13) self.analysis_dialog.top.attributes("-topmost", True) outer_normalize_frame = Frame(self.analysis_dialog.interior, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15, highlightthickness=1) outer_normalize_frame.pack(expand=True, fill=BOTH) slope_title_label = Label(outer_normalize_frame, text="Normalize:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) slope_title_label.pack() normalize_frame = Frame(outer_normalize_frame, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15) normalize_frame.pack() normalize_label = Label(normalize_frame, text="Wavelength (nm):", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.normalize_entry = Entry( normalize_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) normalize_button = Button( normalize_frame, text="Apply", command=self.normalize, width=6, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) normalize_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) normalize_button.pack(side=RIGHT, padx=(10, 10)) self.normalize_entry.pack(side=RIGHT, padx=self.tk_format.padx) normalize_label.pack(side=RIGHT, padx=self.tk_format.padx) outer_offset_frame = Frame(self.analysis_dialog.interior, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15, highlightthickness=1) outer_offset_frame.pack(expand=True, fill=BOTH) slope_title_label = Label(outer_offset_frame, text="Add offset to sample:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) slope_title_label.pack(pady=(0, 15)) offset_sample_frame = Frame(outer_offset_frame, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=self.tk_format.pady) offset_sample_frame.pack() offset_sample_label = Label(offset_sample_frame, text="Sample: ", bg=self.tk_format.bg, fg=self.tk_format.textcolor) offset_sample_label.pack(side=LEFT) self.offset_sample_var = StringVar() sample_names = [] repeats = False max_len = 0 for sample in self.tab.samples: if sample.name in sample_names: repeats = True else: sample_names.append(sample.name) max_len = np.max([max_len, len(sample.name)]) if repeats: sample_names = [] for sample in self.tab.samples: sample_names.append(sample.title + ": " + sample.name) max_len = np.max([max_len, len(sample_names[-1])]) self.offset_sample_var.set(sample_names[0]) # pylint: disable = no-value-for-parameter offset_menu = OptionMenu(offset_sample_frame, self.offset_sample_var, *sample_names) offset_menu.configure( width=max_len, highlightbackground=self.tk_format.highlightbackgroundcolor) offset_menu.pack(side=LEFT) offset_frame = Frame(outer_offset_frame, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15) offset_frame.pack() offset_label = Label(offset_frame, text="Offset:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.offset_entry = Entry( offset_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) offset_button = Button( offset_frame, text="Apply", command=self.offset, width=6, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) offset_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) offset_button.pack(side=RIGHT, padx=(10, 10)) self.offset_entry.pack(side=RIGHT, padx=self.tk_format.padx) offset_label.pack(side=RIGHT, padx=self.tk_format.padx) outer_outer_zoom_frame = Frame(self.analysis_dialog.interior, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15, highlightthickness=1) outer_outer_zoom_frame.pack(expand=True, fill=BOTH) zoom_title_frame = Frame(outer_outer_zoom_frame, bg=self.tk_format.bg) zoom_title_frame.pack(pady=(5, 10)) zoom_title_label = Label(zoom_title_frame, text="Adjust plot x and y limits:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) zoom_title_label.pack(side=LEFT, pady=(0, 4)) outer_zoom_frame = Frame(outer_outer_zoom_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) outer_zoom_frame.pack(expand=True, fill=BOTH, pady=(0, 10)) zoom_frame = Frame(outer_zoom_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) zoom_frame.pack() zoom_label = Label(zoom_frame, text="x1:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.left_zoom_entry = Entry( zoom_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) zoom_label2 = Label(zoom_frame, text="x2:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.right_zoom_entry = Entry( zoom_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) zoom_button = Button( zoom_frame, text="Apply", command=self.apply_x, width=7, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) zoom_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) zoom_button.pack(side=RIGHT, padx=(10, 10)) self.right_zoom_entry.pack(side=RIGHT, padx=self.tk_format.padx) zoom_label2.pack(side=RIGHT, padx=self.tk_format.padx) self.left_zoom_entry.pack(side=RIGHT, padx=self.tk_format.padx) zoom_label.pack(side=RIGHT, padx=self.tk_format.padx) outer_zoom_frame2 = Frame(outer_outer_zoom_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) outer_zoom_frame2.pack(expand=True, fill=BOTH, pady=(0, 10)) zoom_frame2 = Frame(outer_zoom_frame2, bg=self.tk_format.bg, padx=self.tk_format.padx) zoom_frame2.pack() zoom_label3 = Label(zoom_frame2, text="y1:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.left_zoom_entry2 = Entry( zoom_frame2, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) zoom_label4 = Label(zoom_frame2, text="y2:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.right_zoom_entry2 = Entry( zoom_frame2, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) zoom_button2 = Button( zoom_frame2, text="Apply", command=self.apply_y, width=7, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) zoom_button2.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) zoom_button2.pack(side=RIGHT, padx=(10, 10)) self.right_zoom_entry2.pack(side=RIGHT, padx=self.tk_format.padx) zoom_label4.pack(side=RIGHT, padx=self.tk_format.padx) self.left_zoom_entry2.pack(side=RIGHT, padx=self.tk_format.padx) zoom_label3.pack(side=RIGHT, padx=self.tk_format.padx) outer_outer_slope_frame = Frame(self.analysis_dialog.interior, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15, highlightthickness=1) outer_outer_slope_frame.pack(expand=True, fill=BOTH) self.outer_slope_frame = Frame(outer_outer_slope_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) self.outer_slope_frame.pack(expand=True, fill=BOTH, pady=(0, 10)) slope_title_frame = Frame(self.outer_slope_frame, bg=self.tk_format.bg) slope_title_frame.pack(pady=(5, 5)) slope_title_label = Label(slope_title_frame, text="Analyze ", bg=self.tk_format.bg, fg=self.tk_format.textcolor) slope_title_label.pack(side=LEFT, pady=(0, 4)) self.analyze_var = StringVar() self.analyze_var.set("slope") analyze_menu = OptionMenu( slope_title_frame, self.analyze_var, "slope", "band depth", "band center", "reflectance", # "reciprocity", "difference", command=self.disable_plot, ) analyze_menu.configure( width=10, highlightbackground=self.tk_format.highlightbackgroundcolor) analyze_menu.pack(side=LEFT) # We'll put checkboxes for additional options into this frame at the time the user selects a given option (e.g. # select 'difference' from menu, add option to calculate differences based on absolute value self.extra_analysis_check_frame = Frame(self.outer_slope_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) self.extra_analysis_check_frame.pack() # Note that we are not packing this checkbutton yet. self.abs_val_check = Checkbutton( self.extra_analysis_check_frame, selectcolor=self.tk_format.check_bg, fg=self.tk_format.textcolor, text=" Use absolute values for average differences", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.abs_val, ) self.use_max_for_centers_check = Checkbutton( self.extra_analysis_check_frame, selectcolor=self.tk_format.check_bg, fg=self.tk_format.textcolor, text= " If band max is more prominent than\nband min, use to find center.", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.use_max_for_centers, ) self.use_max_for_centers_check.select() self.use_delta_check = Checkbutton( self.extra_analysis_check_frame, selectcolor=self.tk_format.check_bg, fg=self.tk_format.textcolor, text=" Center at max \u0394" + "R from continuum \nrather than spectral min/max. ", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.use_delta, ) self.use_delta_check.select() self.neg_depth_check = Checkbutton( self.extra_analysis_check_frame, selectcolor=self.tk_format.check_bg, fg=self.tk_format.textcolor, text= " If band max is more prominent than \nband min, report negative depth.", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.neg_depth, ) self.neg_depth_check.select() slope_frame = Frame(self.outer_slope_frame, bg=self.tk_format.bg, padx=self.tk_format.padx, highlightthickness=0) slope_frame.pack(pady=(15, 0)) slope_label = Label(slope_frame, text="x1:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.left_slope_entry = Entry( slope_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) slope_label_2 = Label(slope_frame, text="x2:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.right_slope_entry = Entry( slope_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) slope_button = Button( slope_frame, text="Calculate", command=self.calculate, width=7, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) slope_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) slope_button.pack(side=RIGHT, padx=(10, 10)) self.right_slope_entry.pack(side=RIGHT, padx=self.tk_format.padx) slope_label_2.pack(side=RIGHT, padx=self.tk_format.padx) self.left_slope_entry.pack(side=RIGHT, padx=self.tk_format.padx) slope_label.pack(side=RIGHT, padx=self.tk_format.padx) self.slope_results_frame = Frame(self.outer_slope_frame, bg=self.tk_format.bg) self.slope_results_frame.pack( fill=BOTH, expand=True ) # We'll put a listbox with slope info in here later after calculating. outer_plot_slope_frame = Frame(outer_outer_slope_frame, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=10) outer_plot_slope_frame.pack(expand=True, fill=BOTH) plot_slope_frame = Frame(outer_plot_slope_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) plot_slope_frame.pack(side=RIGHT) plot_slope_label = Label(plot_slope_frame, text="Plot as a function of", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.plot_slope_var = StringVar() self.plot_slope_var.set("e") self.plot_slope_menu = OptionMenu(plot_slope_frame, self.plot_slope_var, "e", "i", "g", "e,i", "theta", "az, e") self.plot_slope_menu.configure( width=2, highlightbackground=self.tk_format.highlightbackgroundcolor) self.plot_slope_button = Button( plot_slope_frame, text="Plot", command=self.plot, width=7, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) self.plot_slope_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, state=DISABLED, ) self.plot_slope_button.pack(side=RIGHT, padx=(10, 10)) self.plot_slope_menu.pack(side=RIGHT, padx=self.tk_format.padx) plot_slope_label.pack(side=RIGHT, padx=self.tk_format.padx) exclude_artifacts_frame = Frame(self.analysis_dialog.interior, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15, highlightthickness=1) exclude_artifacts_frame.pack(fill=BOTH, expand=True) self.exclude_artifacts_check = Checkbutton( exclude_artifacts_frame, selectcolor=self.tk_format.check_bg, fg=self.tk_format.textcolor, text= " Exclude data susceptible to artifacts\n (high g, 1000-1400 nm) ", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.exclude_artifacts, # TODO: check if the comma is meant to be there in the lambda definition command=lambda x="foo", : self.tab.set_exclude_artifacts( self.exclude_artifacts.get()), ) self.exclude_artifacts_check.pack() if self.tab.exclude_artifacts: self.exclude_artifacts_check.select() self.analysis_dialog.interior.configure(highlightthickness=1, highlightcolor="white") def calculate(self): try: self.controller.view_notebook.select(self.tab.top) except TclError: print("Error selecting tab in analysis_tools_manager.calculate().") print(self.tab) pass artifact_warning = False if self.analyze_var.get() == "slope": left, right, slopes, artifact_warning = self.tab.calculate_slopes( self.left_slope_entry.get(), self.right_slope_entry.get()) self.update_entries(left, right) self.populate_listbox(slopes) self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"]) elif self.analyze_var.get() == "band depth": left, right, depths, artifact_warning = self.tab.calculate_band_depths( self.left_slope_entry.get(), self.right_slope_entry.get(), self.neg_depth.get(), self.use_delta.get(), ) self.update_entries(left, right) self.populate_listbox(depths) self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"]) elif self.analyze_var.get() == "band center": left, right, centers, artifact_warning = self.tab.calculate_band_centers( self.left_slope_entry.get(), self.right_slope_entry.get(), self.use_max_for_centers.get(), self.use_delta.get(), ) self.update_entries(left, right) self.populate_listbox(centers) self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"]) elif self.analyze_var.get() == "reflectance": left, right, reflectance, artifact_warning = self.tab.calculate_avg_reflectance( self.left_slope_entry.get(), self.right_slope_entry.get()) self.update_entries(left, right) self.populate_listbox(reflectance) self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"]) elif self.analyze_var.get() == "reciprocity": left, right, reciprocity, artifact_warning = self.tab.calculate_reciprocity( self.left_slope_entry.get(), self.right_slope_entry.get()) self.update_entries(left, right) self.populate_listbox(reciprocity) self.update_plot_menu(["e", "i", "g", "e,i"]) elif self.analyze_var.get() == "difference": left, right, error, artifact_warning = self.tab.calculate_error( self.left_slope_entry.get(), self.right_slope_entry.get(), self.abs_val.get()) # Tab validates left and right values. If they are no good, put in min and max wavelengths available. self.update_entries(left, right) self.populate_listbox(error) self.update_plot_menu(["\u03bb", "e,i"]) if artifact_warning: ErrorDialog( self, "Warning", "Warning: Excluding data potentially\ninfluenced by artifacts from 1000-1400 nm." ) self.analysis_dialog.min_height = 1000 self.analysis_dialog.update() def update_plot_menu(self, plot_options): self.plot_slope_var.set(plot_options[0]) self.plot_slope_menu["menu"].delete(0, "end") # Insert list of new options (tk._setit hooks them up to var) max_len = len(plot_options[0]) for option in plot_options: max_len = np.max([max_len, len(option)]) # pylint: disable = protected-access self.plot_slope_menu["menu"].add_command(label=option, command=tkinter._setit( self.plot_slope_var, option)) self.plot_slope_menu.configure(width=max_len) def update_entries(self, left, right): self.left_slope_entry.delete(0, "end") self.left_slope_entry.insert(0, str(left)) self.right_slope_entry.delete(0, "end") self.right_slope_entry.insert(0, str(right)) def populate_listbox(self, results): if len(results) > 0: self.slope_results_frame.pack(fill=BOTH, expand=True, pady=(10, 10)) try: self.slopes_listbox.delete(0, "end") except (AttributeError, TclError): self.slopes_listbox = utils.ScrollableListbox( self.slope_results_frame, self.tk_format.bg, self.tk_format.entry_background, self.tk_format.listboxhighlightcolor, selectmode=EXTENDED, ) self.slopes_listbox.configure(height=8) for result in results: self.slopes_listbox.insert("end", result) self.slopes_listbox.pack(fill=BOTH, expand=True) self.plot_slope_button.configure(state=NORMAL) def plot(self): if self.analyze_var.get() == "slope": self.tab.plot_slopes(self.plot_slope_var.get()) elif self.analyze_var.get() == "band depth": self.tab.plot_band_depths(self.plot_slope_var.get()) elif self.analyze_var.get() == "band center": self.tab.plot_band_centers(self.plot_slope_var.get()) elif self.analyze_var.get() == "reflectance": self.tab.plot_avg_reflectance(self.plot_slope_var.get()) elif self.analyze_var.get() == "reciprocity": self.tab.plot_reciprocity(self.plot_slope_var.get()) elif self.analyze_var.get() == "difference": new = self.tab.plot_error(self.plot_slope_var.get()) if self.plot_slope_var.get() == "\u03bb": x1 = float(self.left_slope_entry.get()) x2 = float(self.right_slope_entry.get()) new.adjust_x(x1, x2) # TODO: plots not always fully updating # (e.g. contour plot labels not showing up until you do a screen wiggle. # utils.thread_lift_widget(self.analysis_dialog.top) def normalize(self): self.select_tab() try: self.slopes_listbox.delete(0, "end") self.plot_slope_button.configure(state="disabled") except (AttributeError, TclError): pass self.tab.normalize(self.normalize_entry.get()) # thread = Thread(target=utils.lift_widget, args=(self.analysis_dialog.top,)) # thread.start() def offset(self): self.tab.offset(self.offset_sample_var.get(), self.offset_entry.get()) # This doesn't work - it hangs between thread.start() and thread.join(). Likely because of calls to canvas.draw() # thread = Thread(target=self.tab.offset, args=(self.offset_sample_var.get(), self.offset_entry.get())) # thread.start() # thread.join() # utils.lift_widget(self.analysis_dialog.top) def remove_topmost(self): print("removing!!") self.analysis_dialog.top.attributes("-topmost", False) def apply_x(self): self.controller.view_notebook.select(self.tab.top) try: x1 = float(self.left_zoom_entry.get()) x2 = float(self.right_zoom_entry.get()) self.tab.adjust_x(x1, x2) # utils.lift_widget(self.analysis_dialog.top) except ValueError: # utils.lift_widget(self.analysis_dialog.top) ErrorDialog( self, title="Invalid Zoom Range", label="Error! Invalid x limits: " + self.left_zoom_entry.get() + ", " + self.right_zoom_entry.get(), ) def apply_y(self): self.controller.view_notebook.select(self.tab.top) try: y1 = float(self.left_zoom_entry2.get()) y2 = float(self.right_zoom_entry2.get()) self.tab.adjust_y(y1, y2) # utils.lift_widget(self.analysis_dialog.top) except ValueError: # utils.lift_widget(self.analysis_dialog.top) ErrorDialog( self, title="Invalid Zoom Range", label="Error! Invalid y limits: " + self.left_zoom_entry2.get() + ", " + self.right_zoom_entry2.get(), ) def uncheck_exclude_artifacts(self): self.exclude_artifacts.set(0) self.exclude_artifacts_check.deselect() # utils.lift_widget(self.analysis_dialog.top) def disable_plot(self, analyze_var="None"): try: self.slopes_listbox.delete(0, "end") except (AttributeError, TclError): pass self.plot_slope_button.configure(state="disabled") if analyze_var == "difference": self.analysis_dialog.frame.min_height = 850 self.neg_depth_check.pack_forget() self.use_max_for_centers_check.pack_forget() self.use_delta_check.pack_forget() self.abs_val_check.pack() self.extra_analysis_check_frame.pack() elif analyze_var == "band center": self.analysis_dialog.frame.min_height = 1000 self.neg_depth_check.pack_forget() self.abs_val_check.pack_forget() self.use_delta_check.pack_forget() self.use_max_for_centers_check.pack() self.use_delta_check.pack() self.extra_analysis_check_frame.pack() elif analyze_var == "band depth": self.analysis_dialog.frame.min_height = 1000 self.abs_val_check.pack_forget() self.use_max_for_centers_check.pack_forget() self.use_delta_check.pack_forget() self.neg_depth_check.pack() self.use_delta_check.pack() self.extra_analysis_check_frame.pack() else: self.analysis_dialog.frame.min_height = 850 self.abs_val_check.pack_forget() self.neg_depth_check.pack_forget() self.use_max_for_centers_check.pack_forget() self.use_delta_check.pack_forget() self.extra_analysis_check_frame.grid_propagate(0) self.extra_analysis_check_frame.configure( height=1) # for some reason 0 doesn't work. self.extra_analysis_check_frame.pack() self.outer_slope_frame.pack() # utils.lift_widget(self.analysis_dialog.top) # def calculate_photometric_variability(self): # photo_var = self.tab.calculate_photometric_variability( # self.right_photo_var_entry.get(), self.left_photo_var_entry.get() # ) # try: # self.photo_var_listbox.delete(0, "end") # except: # self.photo_var_listbox = utils.ScrollableListbox( # self.photo_var_results_frame, # self.tk_format.bg, # self.tk_format.entry_background, # self.tk_format.listboxhighlightcolor, # selectmode=EXTENDED, # ) # for var in photo_var: # self.photo_var_listbox.insert("end", var) # self.photo_var_listbox.pack(fill=BOTH, expand=True) def select_tab(self): self.controller.view_notebook.select(self.tab.top)
class GUI: def __init__(self, master): self.valves = self.get_valves() self.master = master self.master.configure(bg='sky blue') self.password = '******' self.momentary = Momentary(self.master, self.valves) self.edit = Edit(self.master, self.valves) self.summary = Summary(self.master, self.valves) self.preferences = Preferences(self.master, self.valves) self.run_screen = RunScreen(self.master, self.valves) self.header = self.make_header(self.master) self.home = self.home_page(self.master) self.frame = self.home def make_header(self, master): header = Frame(master, bg='sky blue') self.label = StringVar() self.label.set('NONE') self.start_label = StringVar() self.start_label.set('START') self.lock_label = StringVar() self.lock_label.set('LOCKED') self.title = Label(header, textvariable=self.label, pady=20, font=('Lucida Console', 50)) self.title.config(bg='sky blue', fg='RoyalBlue4') self.run_image = PhotoImage(file="img/animate.png").subsample(x=5, y=5) self.run_button = Button(header, image=self.run_image, command=self.run, bg='SkyBlue4', activebackground='midnight blue', border=5) self.start_button = Button(header, textvariable=self.start_label, font=('Lucida Console', 30), command=self.start_stop, height=5) self.start_button.config(bg='brown3', activebackground='brown4', fg='white', activeforeground='white', width=10, border=5) self.save_image = PhotoImage(file="img/save.png").subsample(x=5, y=5) self.save_button = Button(header, image=self.save_image, command=self.save, bg='SkyBlue4', activebackground='midnight blue', border=5) self.save_button.config(state='disabled') self.reset_image = PhotoImage(file="img/reset.png").subsample(x=5, y=5) self.reset_button = Button(header, image=self.reset_image, command=self.reset, bg='SkyBlue4', activebackground='midnight blue', border=5) self.home_image = PhotoImage(file="img/home.png").subsample(x=5, y=5) self.home_button = Button(header, image=self.home_image, command=self.to_home, bg='SkyBlue4', activebackground='midnight blue', border=5) self.locked_image = PhotoImage(file="img/lock.png").subsample(x=5, y=5) self.unlocked_image = PhotoImage(file="img/unlock.png").subsample(x=5, y=5) self.lock_button = Button(header, image=self.locked_image, command=self.lock, bg='SkyBlue4', activebackground='midnight blue', border=5, textvariable=self.lock_label) return header def home_page(self, master): frame = Frame(master) frame.grid(row=0, column=0) image = PhotoImage(file="img/guido.gif") bg = Label(frame, image=image) bg.image = image bg.grid(row=0, column=0, rowspan=4, columnspan=2) index = 0 while index < 3: frame.grid_columnconfigure(index, minsize=200) frame.grid_rowconfigure(index, minsize=80) index += 1 summary_button = HomeButton(frame, self.to_summary, 'img/summary.png') summary_button.grid(row=0, column=0, sticky='w') edit_button = HomeButton(frame, self.to_edit, 'img/edit.png') edit_button.grid(row=0, column=1, sticky='e') momentary_button = HomeButton(frame, self.to_momentary, 'img/momentary.png') momentary_button.grid(row=1, column=0, sticky='w') preferences_button = HomeButton(frame, self.to_pref, 'img/preferences.png') preferences_button.grid(row=1, column=1, sticky='e') music = HomeButton(frame, self.to_summary, 'img/music.png') music.grid(row=2, column=0, sticky='w') info = HomeButton(frame, self.to_summary, 'img/info.png') info.grid(row=2, column=1, sticky='e') return frame # CSV file input def get_valves(self): valves = [Valve('VALVE 1', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 2', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 3', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 4', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 5', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 6', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 7', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 8', 'DEFAULT', 'Action A', 'Action B', [0, 0])] file = open('data.csv', 'rt', newline='') try: reader = csv.reader(file, lineterminator='\n') index = 0 for row in reader: if index == 0: index += 1 continue else: run = int(row[4]) delay = int(row[5]) interval = [run, delay] valves[index - 1] = Valve(row[0], row[1], row[2], row[3], interval) index += 1 finally: file.close() return valves def lock(self): if self.lock_label.get() == 'LOCKED': window = Toplevel() window.geometry('318x550') self.keypad = Keypad(window, self, self.password) else: self.save_button.config(state='disabled') self.edit.lock() self.preferences.lock() self.lock_label.set('LOCKED') self.lock_button.config(image=self.locked_image) def save(self): self.save_pref() self.save_edit() def save_edit(self): file = open('data.csv', 'w') interval = self.edit.get_intervals() try: writer = csv.writer(file, lineterminator='\n') writer.writerow(('Name', 'Setting', 'Action A', 'Action B', 'Runtime', 'Delaytime')) index = 0 for i in self.valves: i.set_interval([interval[index].get(), interval[index + 8].get()]) valve_interval = i.get_interval() if self.edit.plusInterval[index].cget('state') == 'disabled' and self.edit.motor[index].cget('state') != 'disabled': i.set_setting('MOTOR') writer.writerow((i.get_name().get(), i.get_setting(), i.get_action_a().get(), i.get_action_b().get(), 0, 0)) elif interval[index].get() is 0: i.set_setting('INACTIVE') writer.writerow((i.get_name().get(), i.get_setting(), 'NONE', 'NONE', 0, 0)) else: i.set_setting('DEFAULT') writer.writerow((i.get_name().get(), i.get_setting(), i.get_action_a().get(), i.get_action_b().get(), valve_interval[0], valve_interval[1])) index += 1 finally: file.close() # must fix def save_pref(self): index = 0 for i in self.valves: num = index * 3 if self.preferences.entry_field[num].get(): i.set_name(self.preferences.entry_field[num].get()) self.preferences.entry_field[num].delete(0, 'end') if self.preferences.entry_field[num + 1].get(): i.set_action_a(self.preferences.entry_field[num + 1].get()) self.preferences.entry_field[num + 1].delete(0, 'end') if self.preferences.entry_field[num + 2].get(): i.set_action_b(self.preferences.entry_field[num + 2].get()) self.preferences.entry_field[num + 2].delete(0, 'end') index += 1 def start_stop(self): if self.start_label.get() == 'START': self.start_label.set('STOP') self.master.update() self.run_screen.run_all(True) self.home_button.config(state='disabled') else: self.start_label.set('START') self.run_screen.run_all(False) self.home_button.config(state='normal') def run(self): self.summary.grid_remove() self.run_button.pack_forget() self.run_screen.make_frame() self.frame = self.run_screen self.frame.grid(row=0, column=0) self.header.grid(row=0, column=1) self.label.set('RUN') self.title.pack(side='top') self.start_button.pack() self.home_button.pack(side='bottom') def to_home(self): self.momentary.end_all() self.momentary.delete_frame() self.lock_button.pack_forget() self.run_button.pack_forget() self.save_button.pack_forget() self.reset_button.pack_forget() self.home_button.pack_forget() self.start_button.pack_forget() self.preferences.grid_remove() self.frame.grid_remove() self.header.grid_remove() self.frame = self.home self.frame.grid(row=0, column=0) def to_summary(self): self.frame.grid_remove() self.label.set('SUMMARY') self.home_button.pack(side='right') self.run_button.pack(side='right') self.header.grid(row=0, column=0, columnspan=1, sticky='nsew') self.title.pack(side='left') self.summary = Summary(self.master, self.valves) self.frame = self.summary self.frame.grid(row=1, column=0) def to_edit(self): self.frame.grid_remove() self.label.set('EDIT PROGRAM') self.header.grid(row=0, column=0, columnspan=1, sticky='nsew') self.home_button.pack(side='right') self.save_button.pack(side='right') self.lock_button.pack(side='right') self.reset_button.pack(side='right') self.title.pack(side='left') self.frame = self.edit self.frame.grid(row=1, column=0) def to_momentary(self): self.frame.grid_forget() self.label.set('MOMENTARY') self.header.grid(row=0, column=0, columnspan=12, sticky='ew') self.title.pack(side='left') self.home_button.pack(side='right') self.momentary.make_frame() def to_pref(self): self.frame.grid_remove() self.label.set('PREFERENCES') self.header.grid(row=0, column=0, columnspan=1, sticky='nsew') self.home_button.pack(side='right') self.save_button.pack(side='right') self.lock_button.pack(side='right') self.reset_button.pack(side='right') self.title.pack(side='left') self.frame = self.preferences self.frame.grid(row=1, column=0) def reset(self): self.master.quit() def access_granted(self): self.lock_label.set('UNLOCKED') self.lock_button.config(image=self.unlocked_image) self.save_button.config(state='normal') index = 0 while index < 8: self.edit.minusInterval[index].config(state='normal') self.edit.minusDelay[index].config(state='normal') self.edit.plusInterval[index].config(state='normal') self.edit.plusDelay[index].config(state='normal') self.edit.motor[index].config(state='normal') self.edit.adv[index].config(state='normal') index += 1 for each in self.preferences.entry_field: each.config(state='normal') self.edit.set_seconds() self.save_button.config(state='normal')
Gender_Label = Label(framem, text=" Enter your height in meters \n to the right:") Gender_Label.grid(column=0, row=6, columnspan=2, pady=padding) Gender_Label.config(width=26, height=2, bg="#EDF7FD", fg="black", font=("Calibri bold", 14), justify="center") PressMe = Button(framem, text="Press to find \n your BMI", command=add) PressMe.grid(row=8, column=1, columnspan=2, pady=padding, sticky="w") PressMe.config(width=19, height=2, bg="dark blue", fg="white", bd=3, relief="ridge", font=("Calibri bold", 14, "bold")) v = IntVar() Gender_Male = Radiobutton(framem, text="Male", variable=v, value=1) Gender_Female = Radiobutton(framem, text="Female", variable=v, value=2) Gender_Male.grid(column=2, row=6) Gender_Male.config(width=5, bg="White", fg="black", justify="center", font=("Calibri", 12))