def show(self, **options):
# update instance options
for k, v in options.items():
self.options[k] = v
self._fixoptions()
# we need a dummy widget to properly process the options
# (at least as long as we use Tkinter 1.63)
w = Frame(self.master)
try:
s = w.tk.call(self.command, *w._options(self.options))
s = self._fixresult(w, s)
finally:
try:
# get rid of the widget
w.destroy()
except:
pass
return s
def go_action(self, actions):
"""
execute the action script
:param actions:
:return:
"""
# hide the menu and show a delay screen
self.hide_top()
delay = Frame(self, bg="#2d89ef")
delay.pack(fill=TkC.BOTH, expand=1)
label = Label(delay,
text="Executing...",
fg="white",
bg="#2d89ef",
font="Sans 30")
label.pack(fill=TkC.BOTH, expand=1)
self.parent.update()
# excute shell script
subprocess.call([self.path + '/pimenu.sh'] + actions)
# remove delay screen and show menu again
delay.destroy()
self.destroy_all()
self.show_top()
class ChoosingModePanel:
def __init__(self, root, switch_mode):
self.choosing_frame = Frame \
(root, height=60, width=100, bg='lightblue')
self.var = IntVar()
rbutton1 = Radiobutton(self.choosing_frame,
text='PvE',
variable=self.var,
value=1,
bg='lightblue')
rbutton2 = Radiobutton(self.choosing_frame,
text='PvP',
variable=self.var,
value=2,
bg='lightblue')
rbutton3 = Radiobutton(self.choosing_frame,
text='EvE',
variable=self.var,
value=3,
bg='lightblue')
button = Button(self.choosing_frame, text='Ok', bg='lightblue')
rbutton1.select()
rbutton1.pack(side='left')
rbutton2.pack(side='left')
rbutton3.pack(side='left')
button.pack(side='left')
button.bind('<1>', switch_mode)
def show(self):
self.choosing_frame.grid()
def destroy(self):
self.choosing_frame.destroy()
class _RowFrame(Frame):
def __init__(self, master, maxrow, **kw):
super().__init__(master, **kw)
self.maxrow = maxrow
self.saved = True
self.variables = []
self._build_dataframe()
def _build_dataframe(self):
lkw = dict(bd=1, relief="ridge", font=("Times New Roman", 14))
gkw = dict(row=0, sticky="news")
self.dataframe = Frame(self)
self.dataframe.pack(side="right", **pkw)
Label(self.dataframe, text="Mért érték", width=15,
**lkw).grid(column=0, **gkw)
Label(self.dataframe, text="Mérés dátuma", width=15,
**lkw).grid(column=1, **gkw)
Label(self.dataframe, text="Megjegyzés", width=30,
**lkw).grid(column=2, **gkw)
def display(self, values=(), dates=(), comments=(), datenow=True):
self.reset()
assert len(values) == len(dates)
assert len(values) <= self.maxrow
self.add_rows(values, dates, comments)
self.add_empties(self.maxrow - len(values), datenow)
def add_rows(self, values, dates, comments):
for value, date, comment in zip(values, dates, comments):
self.variables += [(StringVar(value=value), StringVar(value=date),
StringVar(value=comment))]
self.variables[-1][0].trace("w", self.varchange)
self.variables[-1][1].trace("w", self.varchange)
self.variables[-1][2].trace("w", self.varchange)
self.update_rows()
def add_empties(self, N, datenow=True):
datefill = datefmt(datetime.datetime.now()) if datenow else ""
self.add_rows(values=("" for _ in range(N)),
dates=(datefill for _ in range(N)),
comments=("" for _ in range(N)))
def update_rows(self):
self.dataframe.destroy()
self._build_dataframe()
for rown, (vvar, dvar, cvar) in enumerate(self.variables, start=1):
ve = Entry(self.dataframe, textvariable=vvar)
ve.grid(row=rown, column=0, sticky="news")
de = Entry(self.dataframe, textvariable=dvar)
de.grid(row=rown, column=1, sticky="news")
ce = Entry(self.dataframe, textvariable=cvar)
ce.grid(row=rown, column=2, sticky="news")
def reset(self):
self.variables = []
self.update_rows()
# noinspection PyUnusedLocal
def varchange(self, *args):
self.saved = False
def new_board(self, board=None, difficulty='easy'):
self.game = SudokuGame(board, difficulty)
self.game.start()
self.row, self.col = -1, -1
Frame.destroy(self)
Frame.__init__(self, self.parent)
self.__initUI()
class ChoosePlayerDialog(Toplevel):
"""Dialog used to prompt the user to choose a player."""
def __init__(self, program: GUIProgram):
super(ChoosePlayerDialog, self).__init__(program.app)
self.title('Choose Player')
self.program = program
self.body = Frame(self)
self.initial_focus = self.body
self.body.pack()
self.create_widgets()
self.initial_focus.focus_set()
# If this window is closed, terminate the application.
self.wm_protocol('WM_DELETE_WINDOW', self.on_close)
def create_widgets(self):
"""Generate the label and buttons to prompt the user for a player."""
Label(self.body, text='Choose your player:').pack()
for player in Player:
Button(self.body, text=player,
command=partial(self.click_handler, player),
**GUIProgram.standard_button_dimensions).pack()
def click_handler(self, player: Player):
"""Callback used to call back into the main program to handle the
player choice. Once complete, the dialog is closed.
"""
self.program.handle_player_choice(player)
self.body.destroy()
self.destroy()
def on_close(self):
"""Callback used to terminate the application if closed."""
self.program.window.quit()
class Widget_: def __init__(self, parent_frame, row, column, width=50, height=50): self.widget_frame = Frame(parent_frame, width=width, height=height) self.widget_frame.grid(row=row, column=column) self.width, self.height = width, height return def add_tag(self, tag_library, string): tag_library[string] = self def delete_widget(self): for child in self.widget_frame.winfo_children(): child.destroy() self.widget_frame.destroy() def hide_widget(self): self.widget_frame.grid_forget() def get_info(self): return def set_field(self): return pass
class Loading:
def __init__(self, root, main_frame, width, height):
self.root = root
self.main_frame = main_frame
self.loading_frame = Frame(self.root,
width=width, height=height)
self.text = Label(self.loading_frame, text='Идёт загрузка...', font=8)
self.text.pack(padx=width // 2 - 100)
self.progress_bar = ttk.Progressbar(self.loading_frame, orient="horizontal",
length=200, mode="determinate")
self.progress_bar.pack(padx=width // 2 - 100)
self.progress_bar['value'] = 0
self.progress_bar['maximum'] = 100
self.showed = False
def show_loading(self, percent):
if not self.showed:
self.main_frame.grid_remove()
self.loading_frame.grid()
self.showed = True
self.progress_bar['value'] = percent
def loading_failed(self):
self.text.destroy()
self.text = Label(self.loading_frame, text='Файл загрузки повреждён!', font=8)
self.text.pack()
self.progress_bar.destroy()
def close_loading(self):
self.showed = False
try:
self.loading_frame.destroy()
except TclError:
pass
self.main_frame.grid()
class ChoosingAIPanel:
def __init__(self, root, func):
self.choosing_frame = Frame \
(root, height=60, width=100, bg='lightblue')
self.var = IntVar()
rbutton1 = Radiobutton(self.choosing_frame,
text='Easy',
variable=self.var,
value=1,
bg='lightblue')
rbutton2 = Radiobutton(self.choosing_frame,
text='Hard',
variable=self.var,
value=2,
bg='lightblue')
rbutton3 = Radiobutton(self.choosing_frame,
text='Random',
variable=self.var,
value=3,
bg='lightblue')
button1 = Button(self.choosing_frame, text='Ok', bg='lightblue')
rbutton1.select()
rbutton1.pack(side='left')
rbutton2.pack(side='left')
rbutton3.pack(side='left')
button1.pack(side='left')
button1.bind('<1>', lambda e: func())
def show(self):
self.choosing_frame.grid()
def destroy(self):
self.choosing_frame.destroy()
class Block:
def __init__(self, val: Optional[int], index: int, parent: Frame, parent_stack):
# значение ячейки. чем оно меньше, тем больше его объем
self.value: Optional[int] = val
# выбираем рандомный цвет
self.color = choice(['red', 'yellow', 'green', 'blue'])
# задаём фиксированную высоту
self.height=0.05
# номер ячейки для отслеживания позиции в стеке и задания высоты
self.index = index
# слой, в котором размещается ячейка
self.parent = parent
# ссылка на стек, которому принадлежит блок
self.parent_stack: Hanoi = parent_stack
# сам фрейм
self.frame = Frame(master=self.parent, bg=self.color, highlightthickness=1, highlightbackground="black")
self.block_status = 0
# автоматически вычисляется ширина
@property
def width(self) -> float:
return 0.5 - 0.08 * (self.value - 1)
# автоматически вычисляется смешение блока к центру
@property
def width_offset(self) -> float:
return 0.25 + 0.04 * (self.value - 1)
# нахождение блока по высоте
@property
def y_offset(self):
return 1 - (self.index + 1) * 0.05
# отображение блока
def visual_block(self):
self.frame.place(relwidth=self.width, relheight=self.height, relx=self.width_offset, rely=self.y_offset)
# удаление блока
def destroy(self):
self.frame.destroy()
# сравнение блоков
def __lt__(self, other) -> bool:
return self.value < other.value
def __gt__(self, other) -> bool:
return self.value > other.value
def __le__(self, other) -> bool:
return self.value <= other.value
def __ge__(self, other) -> bool:
return self.value >= other.value
def __str__(self) -> str:
return str(self.value)
def destroy(self):
"""
Permet de détruire le dialogue entièrement,
il n'est plus réactivable par la suite.
"""
self.deactivate()
self.__destroyed = True
Frame.destroy(self)
self.dialog.destroy()
class LoginPage(object):
def __init__(self, master=None):
self.root = master # 定义内部变量root
self.root.geometry(
'%dx%d' %
(constants.PARAMS_WIDTH, constants.PARAMS_HEIGHT)) # 设置窗口大小
self.p1 = StringVar(value=constants.PARAMS_1)
self.p2 = StringVar(value=constants.PARAMS_2)
self.p3 = StringVar(value=constants.PARAMS_3)
self.p4 = StringVar(value=constants.PARAMS_4)
self.create_page()
def create_page(self):
self.page = Frame(self.root) # 创建Frame
self.page.pack()
Label(self.page).grid(row=0, stick=W)
Label(self.page, text='参数一: ').grid(row=1, stick=W, pady=10)
Entry(self.page, textvariable=self.p1).grid(row=1, column=1, stick=E)
Label(self.page, text='参数二: ').grid(row=2, stick=W, pady=10)
Entry(self.page, textvariable=self.p2).grid(row=2, column=1, stick=E)
Label(self.page, text='参数三: ').grid(row=3, stick=W, pady=10)
Entry(self.page, textvariable=self.p3).grid(row=3, column=1, stick=E)
Label(self.page, text='参数四: ').grid(row=4, stick=W, pady=10)
Entry(self.page, textvariable=self.p4).grid(row=4, column=1, stick=E)
Button(self.page, text='确认', command=self.login_check).grid(row=5,
stick=W,
pady=10)
Button(self.page, text='退出', command=self.page.quit).grid(row=5,
column=1,
stick=E)
def login_check(self):
p1 = self.p1.get()
p2 = self.p2.get()
p3 = self.p3.get()
p4 = self.p4.get()
if not all((p1, p2, p3, p4)):
# 弹出错误信息
showerror(title='错误', message='必填参数')
else:
# 跳转下一个页面
self.page.destroy()
kwargs = {
"p1": p1,
"p2": p2,
"p3": p3,
"p4": p4,
}
MainPage(self.root, **kwargs)
class Start:
def __init__(self, parent):
# GUI to get user to start game
self.start_frame = Frame(padx=10, pady=10)
self.start_frame.grid()
self.push_me_button = Button(text="Push Me", command=self.to_game)
self.push_me_button.grid(row=0, pady=10)
# hide start up window
self.start_frame.destroy()
class ShowCard:
def __init__(self, root, gamestate, handle_show_answerinput_view,
handle_show_frontpage_view):
self.root = root
self.gamestate = gamestate
self.current_card = 0
self.handle_show_answerinput_view = handle_show_answerinput_view
self.handle_show_frontpage_view = handle_show_frontpage_view
self.initialize()
def initialize(self):
self.frame = Frame(master=self.root)
img = create_card_image(self.frame,
self.gamestate.deck[self.current_card])
img.grid(row=0, column=0)
deck_size = self.gamestate.get_deck_size()
card_count = Label(master=self.frame,
text="Kortti: " + str(self.current_card + 1) + "/" +
str(deck_size))
card_count.config(font=("Courier", 10))
card_count.grid(row=1, column=0)
next_button = Button(master=self.frame,
text="Seuraava",
command=self.nextcard_button_pressed)
next_button.grid(padx=5, pady=5, sticky=constants.EW)
warning_text = Label(
master=self.frame,
text="Mikäli haluat luovuttaa pelin paina alla olevaa nappia:")
warning_text.config(font=("Courier", 10))
warning_text.grid(row=3, column=0)
give_up_button = Button(master=self.frame,
text="Lopeta peli",
command=self.handle_show_frontpage_view)
give_up_button.grid(padx=5, pady=5, sticky=constants.EW)
def nextcard_button_pressed(self):
if self.current_card < len(self.gamestate.deck) - 1:
self.current_card += 1
self.destroy()
self.initialize()
self.pack()
else:
self.destroy()
self.handle_show_answerinput_view(self.gamestate)
def pack(self):
self.frame.pack(fill=constants.X)
def destroy(self):
self.frame.destroy()
class RunView(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.is_running = True
self.title = Label(self, text='RUN')
self.middle_frame = Frame(self)
self.run_button = Button(self, text='Launch', command=self.launch)
self.stop_button = Button(self, text='Stop', command=self.stop)
self.title.pack()
self.middle_frame.pack()
self.run_button.pack()
self.stop_button.pack()
self.stop_button.pack_forget()
def launch(self):
self.service = MainService()
self.service.run()
self.is_running = True
t = Thread(target=self.poll)
t.setDaemon(True)
t.start()
self.run_button.pack_forget()
self.stop_button.pack()
def poll(self):
StatusBar().set_label('Polling has begun')
self.temp_frame = Frame(self.middle_frame)
self.temp_frame.pack()
while True:
lst = self.service.get_action_from_queue()
for action in lst:
StatusBar().set_label(f'Add {action} to queue')
view = ActionView(self.temp_frame, action)
view.forget_delete_button()
view.pack()
Speaker().add_to_queue(action.name)
Speaker().run_and_wait()
time.sleep(1)
if not self.is_running:
break
def stop(self):
StatusBar().set_label('Stop')
self.is_running = False
self.run_button.pack()
self.stop_button.pack_forget()
self.temp_frame.destroy()
class GuiController:
window = None
frame_tablero = None
def __init__(self):
self.window = Tk()
self.window.title("Buscaminas")
self.frame_tablero = Frame(self.window)
self.frame_tablero.grid()
def launch(self):
self.window.mainloop()
def add_celda_tablero(self, celda, left_click_action, right_click_action):
button = Button(self.frame_tablero, bg=Color.CELDA_DEFAULT, activebackground=Color.CELDA_DEFAULT_OVER)
button.bind("<Button-1>", left_click_action)
button.bind("<Button-3>", right_click_action)
button.config(height=1, width=1)
button.grid(row=celda.posicion_x, column=celda.posicion_y)
return button
def revela_celda_con_mina(self, celda):
celda.gui.configure(bg=Color.CELDA_MINA, state="disabled", text="X")
def revela_celda_sin_mina(self, celda):
celda.gui.configure(bg=Color.CELDA_LIBRE, state="disabled", text=str(celda.minas_cercanas))
def bloquear_celda(self, celda):
celda.gui.configure(bg=Color.CELDA_DEFAULT, activebackground=Color.CELDA_DEFAULT_OVER)
def desbloquear_celda(self, celda):
celda.gui.configure(bg=Color.CELDA_SEGURA, activebackground=Color.CELDA_SEGURA_OVER)
def reset_tablero(self):
self.frame_tablero.grid_forget()
self.frame_tablero.destroy()
self.frame_tablero = Frame(self.window)
self.frame_tablero.grid()
def game_over(self, game_controller):
if messagebox.askretrycancel("Game over", "BOOM!"):
game_controller.set_new_game()
else:
quit()
def winner(self, game_controller):
if messagebox.askquestion("You win", "¿Jugar de nuevo?"):
game_controller.set_new_game()
else:
quit()
class LoginScreen(Window):
def __init__(self, program):
super().__init__(program)
self.levels = None
self.settings = program.settings
self.level_handler = LevelHandler(program.settings)
self.frame = Frame(program.master, width=800, height=800)
self.frame.pack(side='top', fill='both', expand=1)
self.show()
def add_button(self, text, command):
button = Button(self.frame,
text=text,
width=100,
height=20,
command=command)
button.pack()
def dispose(self):
self.frame.pack_forget()
self.frame.destroy()
self.frame = None
def show(self):
self.add_button('New Game', self.new_game)
self.add_button('Load Game', self.load_game)
self.add_button('Exit', self.exit)
self.frame.tkraise()
def new_game(self):
self.dispose()
g = Game(self.program)
g.new()
self.change(Game(self.program))
def exit(self):
self.program.exit()
def load_game(self):
self.dispose()
lg = LoadGame(self.program)
lg.show()
self.change(lg)
def clear(self):
self.frame.pack_forget()
self.level_handler = None
self.frame.destroy()
class GRow():
def __init__(self, theme, root, data, size):
self.data = data
self.graphics = []
self.view = Frame(root, borderwidth=1)
for item in data:
self.graphics.append(GButton(theme, self.view, item, size))
self.graphics[-1].view.pack(side=LEFT)
def __hash__(self):
return hash(tuple(self.graphics))
def destroy(self):
self.view.destroy()
for graphic in self.graphics:
graphic.destroy
def frame_initiative(x):
'''===================================================================================
The frame for the initiative options is contained here.
need to add a section that automates the turn progression and gives stat readouts.
That might need to be in a seperate frame off to the right though.
Adding it here might make this definition too big.
=================================================================================='''
global frame_initiative_open
if frame_initiative_open == False:
print(
'DEBUG: frame initiative displayed'
) #Debug, delete this at some point.==================================
frame_initiative = Frame(window_main)
frame_initiative.pack(side=LEFT)
button_add_npc = Button(frame_initiative,
activebackground='#909090',
text="Add NPC",
activeforeground='#990099',
bd=10,
width=25,
command=add_npc)
button_close = Button(frame_initiative,
activebackground='#909090',
text="close",
activeforeground='#990099',
bd=10,
width=25,
command=frame_initiative.destroy())
button_add_npc.pack()
button_close.pack()
frame_initiative_open = True
class SpaceView(Frame):
VIEW_SIZE = 10
instance = None
def __init__(self, root):
SpaceView.instance = self
Frame.__init__(self, root)
self.cam = [0, 0]
self.content = Frame(self)
self.content.grid()
self.refresh_view()
def refresh_view(self):
if ToolBox.instance: ToolBox.instance.refresh_buttons_infos()
self.content.destroy()
self.content = Frame(self)
self.content.grid()
for x in range(self.VIEW_SIZE):
for y in range(self.VIEW_SIZE):
xw = x + self.cam[0]
yw = y + self.cam[1]
try:
txt = (Space.instance.data[xw, yw][GAME_OBJ] if Space.instance.data[xw, yw][GAME_OBJ] is not None else " ")\
+(("," + Space.instance.data[xw, yw][INDEX]) if Space.instance.data[xw, yw][INDEX] is not None else "")\
+(("," + Space.instance.data[xw, yw][AREA]) if Space.instance.data[xw, yw][AREA] is not None else "")
except KeyError:
txt = " "
Button(self.content,
text=txt,
command=lambda xw=xw, yw=yw: ToolBox.instance.
tile_selected(xw, yw)).grid(row=y, column=x)
def addObject(objectFrame, row, minorPLanet):
frame = Frame(objectFrame)
#name, score, ra...
name = Label(frame, text=minorPLanet.name)
remove = Button(frame, text="Remove", command=lambda: frame.destroy())
remove.grid(row=0, column=0)
name.grid(row=0, column=1)
frame.grid(row=row)
class ControlPanel:
def __init__(self, root, load, exit):
self.panel_frame = Frame(root, height=60, width=100)
def create_exit_btn(self, exit):
self.exit_btn = Button \
(self.panel_frame, text='Exit', bg='lightblue')
self.exit_btn.pack(side='right')
self.exit_btn.bind("<1>", exit)
def create_restart_btn(self, start):
# start('start')
self.restart_btn = Button \
(self.panel_frame, text='Restart', bg='lightblue')
self.restart_btn.pack(side='right')
self.restart_btn.bind("<1>", start)
def create_load_btn(self, load):
self.load_btn = Button \
(self.panel_frame, text='Load', bg='lightblue')
self.load_btn.pack(side='right')
self.load_btn.bind("<1>", load)
def create_save_btn(self, save):
self.save_btn = Button \
(self.panel_frame, text='Save', bg='lightblue')
self.save_btn.pack(side='left')
self.save_btn.bind("<1>", save)
def create_unturn_btn(self, unturn):
self.unturn_btn = Button \
(self.panel_frame, text='Turn somewhere else', bg='lightblue')
self.unturn_btn.pack(side='right')
self.unturn_btn.bind("<1>", unturn)
def show(self):
try:
self.panel_frame.grid()
except TclError:
return
def destroy(self):
self.panel_frame.destroy()
class TripleFrame:
'''
A frame renders a triple (or pair) of widget
pair = TripleFrame(root, Label, lambda pf: Button(pf, text = "Hello"))
'''
def __init__(self, parent, a, b, c=None, pad=20):
self.parent = parent
self.frame = Frame()
self.wa = a(self.frame)
self.wb = b(self.frame)
if c is not None: self.wc = c(self.frame)
self.pad = pad
def pack(self):
''' register to parent container '''
self.frame.pack()
self.wa.pack(side=LEFT, padx=self.pad)
if self.wc is not None: self.wc.pack(side=RIGHT)
self.wb.pack(side=RIGHT, padx=self.pad)
def destroy(self):
self.wa.forget()
self.wa.destroy()
self.wb.forget()
self.wb.destroy()
if self.wc is not None:
self.wc.forget()
self.wc.destroy()
self.frame.destroy()
def get_a(self):
return self.wa
def get_b(self):
return self.wb
def get_c(self):
return self.wc
a = property(get_a)
b = property(get_b)
c = property(get_c)
class LoadGame(Window):
def __init__(self, program):
super().__init__(program)
self.frame = Frame(program.master, width=800, height=800)
self.frame.pack(side='top', fill='both', expand=1)
self.listbox = Listbox()
self.save_names = []
def dispose(self):
self.listbox.pack_forget()
self.frame.pack_forget()
self.listbox.destroy()
self.frame.destroy()
self.listbox = None
self.frame = None
def show(self):
for file_name, file_path in self.program.settings.list_saves():
self.listbox.insert(END, file_name)
self.save_names.append(file_name)
self.listbox.pack()
self.add_button('Back', self.back)
self.add_button('Load', self.load)
def load(self):
selection = next(iter(map(int, self.listbox.curselection())))
self.dispose()
g = Game(self.program)
g.load(self.save_names[selection])
self.change(g)
def back(self):
self.dispose()
self.change(LoginScreen(self.program))
def add_button(self, text, command):
button = Button(self.frame,
text=text,
width=100,
height=20,
command=command)
button.pack()
class BaseWindow:
def __init__(self, root):
self.root = root
self.frame = Frame(root)
def move_to_window(self, window):
self.frame.destroy()
window.create_content()
def set_text(self, entry, text):
entry.delete(0, END)
entry.insert(0, text)
def check_fill_entry(self, button, entry_list):
for entry in entry_list:
if not entry.get():
button.config(state=DISABLED)
break
else:
button.config(state=NORMAL)
class InputBox:
def __init__(self, default_data=''):
self.default_data = default_data
self.area = root.focus_get()
self.frame = Frame(root, border=1, padx=3, pady=3)
self.entry = Entry(self.frame)
self.entry.config(background='grey')
self.entry.focus_set()
# Maybe there is a more elegant way.
self.entry.bind('<FocusOut>', lambda event: self.entry.focus_set())
self.entry.insert('end', default_data)
self.entry.pack(side='left', expand=True, fill=BOTH)
self.frame.grid(row=1, sticky='we')
def done(self):
self.entry.destroy()
self.frame.destroy()
self.area.focus_set()
def go_action(self, actions):
"""
execute the action script
:param actions:
:return:
"""
# hide the menu and show a delay screen
self.hide_top()
delay = Frame(self, bg="#2d89ef")
delay.pack(fill=TkC.BOTH, expand=1)
label = Label(delay, text="Executing...", fg="white", bg="#2d89ef", font="Sans 30")
label.pack(fill=TkC.BOTH, expand=1)
self.parent.update()
# excute shell script
subprocess.call([self.path + '/pimenu.sh'] + actions)
# remove delay screen and show menu again
delay.destroy()
self.destroy_all()
self.show_top()
class Canvas_widjet:
def __init__(self, some_quantity_of_column_row, some_size_column_row,
some_canvas, some_window, some_name):
self.root_window = some_window
self.canvas = some_canvas
self.canvas_centr_xy = int(some_quantity_of_column_row
* some_size_column_row/2)
def draw(self, some_record, some_name):
self.record = some_record
self.entry_string = some_name
self.frame = Frame(self.canvas)
self.window_on_canvas = self.canvas.create_window(self.canvas_centr_xy,
self.canvas_centr_xy,
height = 220,
width = 220,
window = self.frame)
self.label1 = Label(self.frame, text = "Congratulations !!", font = "arial 20")
self.entry = Entry(self.frame, width = 10, font = "arial 20")
self.entry.insert(0, self.entry_string)
self.label2 = Label(self.frame, text = "Your record: " + str(some_record),
font = "arial 20")
self.label1.grid(column = 0, row = 0)
self.entry.grid(column = 0, row = 1)
self.label2.grid(column = 0, row = 2)
def erase(self):
self.label1.destroy()
self.label2.destroy()
self.entry.destroy()
self.frame.destroy()
self.canvas.delete(self.window_on_canvas)
def hide(self):
self.canvas.itemconfig(self.window_on_canvas, state = HIDDEN)
def show(self):
self.canvas.itemconfig(self.window_on_canvas, state = NORMAL)
class SaveGui:
__name = None
def __init__(self, main_controller, window):
self.__main_controller = main_controller
self.__window = window
self.__menu = None
def show(self):
self.__menu = Frame(self.__window)
self.__menu.configure(padx=10, pady=20)
self.__menu.pack(fill=BOTH, expand=True)
line1 = Frame(self.__menu)
line1.pack(fill=X)
self.__name = StringVar()
self.__name.set("my_game_at_"+strftime("%H:%M")+"-"+strftime("%d.%m.%Y"))
name_input = Entry(line1)
name_input.configure(textvariable=self.__name)
name_input.pack(fill=X)
line2 = Frame(self.__menu)
line2.pack(fill=X, pady=20)
save_btn = Button(line2)
save_btn.configure(text="Save Game", command=self.save)
save_btn.pack(fill=X)
def remove(self):
if self.__menu is not None:
self.__menu.destroy()
self.__memu = None
def save(self):
if self.__name is not None:
self.__main_controller.save_game(self.__name.get())
self.remove()
self.__main_controller.show_game()
self.__main_controller.toggle_game()
self.__main_controller.toggle_game()
class GameSettings:
def __init__(self, root, handle_show_game_first_view):
self.root = root
self.card_number_entry = None
self.handle_show_game_first_view = handle_show_game_first_view
self.initialize()
def amount_handler(self):
"""checking that the input is int if not errormessage shown"""
amount = self.card_number_entry.get()
try:
val = int(amount)
gamestate = GameState(val)
self.handle_show_game_first_view(gamestate)
gamestate.print_status()
except ValueError:
messagebox.showinfo(
"VIRHE", "Ole ystävällinen ja syötä kokonaisluku. Kiitos!")
def initialize(self):
"""asking for amount of cards to be shown and giving the
input to amount_handler"""
self.frame = Frame(master=self.root)
card_amunt_label = Label(master=self.frame, text="Korttien määrä: ")
card_amunt_label.grid(row=0, column=0)
self.card_number_entry = Entry(master=self.frame)
self.card_number_entry.grid(row=0, column=1)
start_button = Button(master=self.frame,
text="Aloita peli",
command=self.amount_handler)
start_button.grid(padx=5, pady=5, sticky=constants.EW)
def pack(self):
self.frame.pack(fill=constants.X)
def destroy(self):
self.frame.destroy()
def populate(specs):
global objectframe
global row
#global selection
fr = Frame(objectframe)
fr.grid(row=row)
lb = Label(fr, text=specs.get("name").get())
#row doesn't have to be decreased because it doesn't leave blanks
qt = Button(fr, text="Remove", command=lambda: fr.destroy())
qt.pack(side=LEFT)
lb.pack(side=RIGHT)
row += 1
class Frontpage:
def __init__(self, root, handle_show_game_settings):
self.root = root
self.frame = None
self.handle_show_game_settings = handle_show_game_settings
self.initialize()
def initialize(self):
self.frame = Frame(master=self.root)
info_button = Button(master=self.frame,
text="Tietoja",
command=self.info_view)
start_button = Button(master=self.frame,
text="Aloita",
command=self.handle_show_game_settings)
score_button = Button(master=self.frame,
text="Huipputulokset",
command=print("tulossa"))
start_button.grid(padx=5, pady=5, sticky=constants.EW)
score_button.grid(padx=5, pady=5, sticky=constants.EW)
info_button.grid(padx=5, pady=5, sticky=constants.EW)
def info_view(self):
lines = [
"Tämä on muistipeli sovellus.",
"Pelin tavoite on muistaa korttipakan kortit järjestyksessä.",
"Paina aloita ja valitse korttien määrä aloittaaksesi."
]
messagebox.showinfo("Tietoja", "\n".join(lines))
def pack(self):
self.frame.pack(fill=constants.X)
def destroy(self):
self.frame.destroy()
class EndScreen(Screen):
ROUTENAME = "/end"
def clickButton(self):
self._screenManager.navigate("/")
def initBuild(self, txt):
self.frame = Frame(width=1000, height=800)
self.frame.place(x=0, y=0)
self.LabelEnd = Label(master=self.frame, text=txt, fg="#417D9E")
self.LabelEnd["font"] = font.Font(family='Arial',
size=50,
weight='bold')
self.LabelEnd.place(anchor="center", relx=0.5, rely=0.1)
self.ButtonPlay = Button(master=self.frame,
text="Zum Menü",
command=self.clickButton,
bg="#265B78",
activebackground="#265B78",
fg="#ffffff",
activeforeground="#ffffff",
borderwidth=0)
self.ButtonPlay["font"] = font.Font(family='Arial',
size=20,
weight='bold')
self.ButtonPlay.place(anchor="center",
relx=0.5,
rely=0.5,
width=210,
height=80)
def clear(self):
self.frame.destroy()
class Widget_: def __init__(self, parent_frame, x, y, width=50, height=50): self.widget_frame = Frame(parent_frame, width=width, height=height) self.widget_frame.place(x=x, y=y) self.x, self.y, self.width, self.height = x, y, width, height self.tags = [] return def add_tag(self, string): self.tag.append(string) return def resize(self, new_width, new_height): self.widget_frame.config(width=new_width, height=new_height) return def delete_widget(self): self.widget_frame.destroy() return def hide_widget(self): self.widget_frame.place_forget() return def show_widget(self, new_x, new_y): self.widget_frame.place(x=new_x, y=new_y) return def get_info(self): return def set_field(self): return pass
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 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()
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()
