def show_source_tree(head):
root = Tk()
frame = Frame(root)
frame.pack(fill = 'both')
tree = tkinter.ttk.Treeview(frame)
#insert root subroutine
# @type head Node
parent_id = tree.insert('', 'end', '', text = head.name)
for child in head.children:
child.insert_to_tree(tree, parent_id)
#add scrollbar
v_scrollbar = Scrollbar(frame, orient = VERTICAL, command = tree.yview)
h_scrollbar = Scrollbar(frame, orient = HORIZONTAL, command = tree.xview)
tree.configure(yscrollcommand = v_scrollbar.set, xscrollcommand = h_scrollbar.set)
v_scrollbar.pack(side = 'right', fill = 'y')
h_scrollbar.pack(side = 'bottom', fill = 'x')
tree.pack(fill = 'both')
root.geometry("600x600")
root.mainloop()
def startGui():
try:
import_tk()
except:
logging.error("Error Starting GUI. Could Not Find Tkinter module" + "Please install the Python Tkinter module")
return
root = Tk()
root.wm_title("Eagle V6 to KiCad Converter")
root.wm_minsize(400, 200)
frame = Frame(root, relief=RIDGE, bg="BLUE", borderwidth=2)
frame.pack(fill=BOTH, expand=1)
label = Label(frame, font=20, bg="BLUE", text="What Would You Like to Do:")
label.pack(fill=X, expand=1)
butBrd = Button(frame, text="Convert Board", command=convertBoardGUI)
butBrd.pack(fill=X, expand=1)
butLib = Button(frame, text="Convert Library", command=convertLibGUI)
butLib.pack(fill=X, expand=1)
butSch = Button(frame, text="Convert Schematic", command=convertSchGUI)
butSch.pack(fill=X, expand=1)
label = Label(frame, bg="BLUE", text="www.github.com/Trump211")
label.pack(fill=X, expand=1)
root.mainloop()
def __init__(self, parent, title=None):
Toplevel.__init__(self, parent)
self.transient(parent)
if title:
self.title(title)
self.parent = parent
self.result = None
body = Frame(self)
self.initial_focus = self.body(body)
body.pack(padx=5, pady=5)
self.buttonbox()
self.grab_set()
if not self.initial_focus:
self.initial_focus = self
self.protocol("WM_DELETE_WINDOW", self.cancel)
self.geometry("+%d+%d" % (parent.winfo_rootx() + 50,
parent.winfo_rooty() + 50))
self.initial_focus.focus_set()
self.wait_window(self)
class Wall(object):
MIN_RED = MIN_GREEN = MIN_BLUE = 0x0
MAX_RED = MAX_GREEN = MAX_BLUE = 0xFF
PIXEL_WIDTH = 50
def __init__(self, width, height):
self.width = width
self.height = height
self._tk_init()
self.pixels = [(0, 0, 0) for i in range(self.width * self.height)]
def _tk_init(self):
self.root = Tk()
self.root.title("ColorWall %d x %d" % (self.width, self.height))
self.root.resizable(0, 0)
self.frame = Frame(self.root, bd=5, relief=SUNKEN)
self.frame.pack()
self.canvas = Canvas(self.frame,
width=self.PIXEL_WIDTH * self.width,
height=self.PIXEL_WIDTH * self.height,
bd=0, highlightthickness=0)
self.canvas.pack()
self.root.update()
def set_pixel(self, x, y, hsv):
self.pixels[self.width * y + x] = hsv
def get_pixel(self, x, y):
return self.pixels[self.width * y + x]
def draw(self):
self.canvas.delete(ALL)
for x in range(len(self.pixels)):
x_0 = (x % self.width) * self.PIXEL_WIDTH
y_0 = (x / self.width) * self.PIXEL_WIDTH
x_1 = x_0 + self.PIXEL_WIDTH
y_1 = y_0 + self.PIXEL_WIDTH
hue = "#%02x%02x%02x" % self._get_rgb(self.pixels[x])
self.canvas.create_rectangle(x_0, y_0, x_1, y_1, fill=hue)
self.canvas.update()
def clear(self):
for i in range(self.width * self.height):
self.pixels[i] = (0, 0, 0)
def _hsv_to_rgb(self, hsv):
rgb = colorsys.hsv_to_rgb(*hsv)
red = self.MAX_RED * rgb[0]
green = self.MAX_GREEN * rgb[1]
blue = self.MAX_BLUE * rgb[2]
return (red, green, blue)
def _get_rgb(self, hsv):
red, green, blue = self._hsv_to_rgb(hsv)
red = int(float(red) / (self.MAX_RED - self.MIN_RED) * 0xFF)
green = int(float(green) / (self.MAX_GREEN - self.MIN_GREEN) * 0xFF)
blue = int(float(blue) / (self.MAX_BLUE - self.MIN_BLUE) * 0xFF)
return (red, green, blue)
class GUI(object):
"""
The base class for GUI builder
"""
__metaclass__ = ABCMeta
def __init__(self, root):
self.colorPicker = ColorPicker(root)
self.topToolbar = Frame(root, bd=1, relief=RAISED)
self.topToolbar.pack(side=TOP, fill=X)
self.canvas = DrawingCanvas(root, self.colorPicker)
self.canvas.pack(expand=YES, fill=BOTH)
# Initializes IO and Draw commands.
@abstractmethod
def initButtons(self, ios, commands):
pass
# Event handler when users click on an IO command.
@abstractmethod
def onIOCommandClick(self, button, command):
pass
# Event handler when users click on a draw command.
@abstractmethod
def onDrawCommandClick(self, button, command):
pass
# Event handler when users change the selected color.
@abstractmethod
def onChangeColor(self, command):
pass
def initUI(self):
self.lineCounter = 0
# create a custom font
self.customFontHeader = font.Font(family="Calibri", slant = "italic") #family="Helvetica", weight="bold", slant="italic")
self.customFontMessage = font.Font(family="Calibri")
self.parent.title("Python Chat")
frame = Frame(self.parent)
frame.pack(fill=BOTH, expand=1, side=LEFT)
self.box = ScrolledText(frame, wrap=WORD, relief = GROOVE, width=30, height=18, font=self.customFontMessage)
self.box.insert(END, 'Welcome to Python Chat!')
self.box.config(state=DISABLED)
self.box.pack(expand="yes", fill=BOTH, side=TOP)
self.textarea = Text(frame, width=30, height=5)
#self.textarea.insert(END, "")
self.textarea.bind("<KeyRelease-Return>", self.gettext) #Se metto on press, rimane una newline in piu
self.textarea.pack(expand="yes", fill=BOTH, side=TOP)
okButton = Button(frame, text="Panic Button", activebackground="red", command=self.sendFile)
okButton.pack(expand="no", fill=BOTH, side=TOP)
self.usersFrame = Frame(self.parent)
self.usersFrame.pack(fill=BOTH, expand=1, side=RIGHT)
self.userListbox = Listbox(self.usersFrame, width=3)
self.userListbox.pack(fill=BOTH, expand=1)
self.updateUsersFrame()
def show_captcha(self,img_file):
dialogRoot = Tk()
dialogRoot.title("Input text.")
img = PhotoImage(file=img_file)
frame = Frame(dialogRoot)
imal = Label(frame, image=img)
imal.pack()
label = Label(frame)
label['text'] = "Your Input:"
label.pack(side=LEFT)
inputEntry = Entry(frame)
inputEntry["width"] = 50
inputEntry.pack(side=LEFT)
def getInputText():
'''callback of button'''
# global inputEntry, dialogRoot
if inputEntry.get().strip() == "":
print("Please enter a message.")
else:
self.captcha_ans = inputEntry.get().strip()
dialogRoot.destroy()
button = Button(frame, text="Submit", command=getInputText)
button.pack(side=LEFT)
frame.pack()
dialogRoot.mainloop()
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()
def makeWindow():
'create GUI'
frame = Frame(width=100, height=100, background = "blue")
frame.bind("<Button-1>", handler)
frame.bind('<Button-3>', handler2)
frame.pack()
frame.mainloop()
def ua_win_tk(url, pipe = None):
from tkinter import Tk, Frame, Label, Entry, StringVar, BOTH, Button, RIGHT
import sys
sys.stdout.flush()
instructions = "Visit the following URL to authorize the application:"
response = {"x": False}
root = Tk()
root.title("oAuth2 Authorization Required")
webbox = Frame(root)
instructions = Label(webbox, text = instructions)
instructions.pack(padx = 5, pady = 5)
urlstr = StringVar(value = url)
urlbox = Entry(webbox, textvariable = urlstr, state = "readonly")
urlbox.pack(padx = 5, pady = 5)
def open_browser():
from subprocess import Popen
p = Popen(["sensible-browser", url])
browserbutton = Button(webbox, text = "Open in web browser", command = open_browser)
browserbutton.pack(padx = 5, pady = 5)
webbox.pack(fill = BOTH, expand = 1)
if pipe:
def poll():
if pipe.poll():
root.destroy()
#Mutability ftw... wat
response["x"] = True
else:
root.after(300, poll)
root.after(300, poll)
cancelbutton = Button(root, text = "Cancel", command = root.destroy)
cancelbutton.pack(side = RIGHT, padx = 5, pady = 5)
root.mainloop()
return response["x"]
def initUI(self):
self.parent.title('PyZilla')
self.padding = 5
self.pack(fill=BOTH, expand=1)
# Create a menubar
mnuMenu = Menu(self.parent)
self.parent.config(menu=mnuMenu)
# Create menubar
mnuFileMenu = Menu(mnuMenu)
# Add File menu items
mnuFileMenu.add_command(label='Open', command=self.onBtnOpenFile)
mnuFileMenu.add_command(label='Exit', command=self.quit)
# Add File menu items to File menu
mnuMenu.add_cascade(label='File', menu=mnuFileMenu)
# Create frame for all the widgets
frame = Frame(self)
frame.pack(anchor=N, fill=BOTH)
# Create file open dialog
btnOpenFile = Button(frame, text="Load file", command=self.onBtnOpenFile)
btnOpenFile.pack(side=RIGHT, pady=self.padding)
# Create filename label
self.lblFilename = Label(frame, text='No filename chosen...')
self.lblFilename.pack(side=LEFT, pady=self.padding, padx=self.padding)
# Create the text widget for the results
self.txtResults = Text(self)
self.txtResults.pack(fill=BOTH, expand=1, pady=self.padding, padx=self.padding)
def create_widgets(self):
""" Login form """
frame_top = Frame(self, pady=15, padx=15)
frame_top.pack()
self.email = StringVar()
self.email_label = Label(frame_top, text="Email")
self.email_entry = Entry(frame_top, textvariable=self.email)
self.password = StringVar()
self.password_label = Label(frame_top, text="Password")
self.password_entry = Entry(frame_top,
textvariable=self.password, show='*')
frame_bottom = Frame(self, pady=15, padx=15)
frame_bottom.pack()
self.submit = Button(frame_bottom)
self.submit["text"] = "Login"
self.submit["command"] = self.sign_in
#layout widgets in grid
self.email_label.grid(row=1, column=0)
self.email_entry.grid(row=1, column=1)
self.password_label.grid(row=2, column=0)
self.password_entry.grid(row=2, column=1)
self.submit.grid(row=2, column=0)
class PyBooguNote(Frame):
"""Main class"""
def __init__(self, parent):
super().__init__(parent)
self.parent = parent
self.create_toolbar()
self.sc = ScrolledCanvas(parent, bg="white", highlightthickness=0, takefocus=1)
self.sc.frame.pack(expand=1, fill='both')
def create_toolbar(self):
self.toolbar = Frame(self.parent)
self.btn_new = Button(self.toolbar, text='New', command=self.new_file)
self.btn_new.grid(row=0, column=0)
self.btn_open = Button(self.toolbar, text='Open', command=self.open_file)
self.btn_open.grid(row=0, column=1)
self.toolbar.pack(fill='both')
def open_file(self):
self.file_path = askopenfilename(filetypes=[('BooguNote Files', '.boo')])
self.dom = parse(self.file_path)
curItem = None
pyBt = PyBooguTree(self.sc.canvas, self.file_path, self.dom)
def new_file(self):
self.file_path = asksaveasfilename()
print(self.file_path)
def __init__(self, parent, handler):
'''Initialization method.'''
Frame.__init__(self, parent)
button_frame = Frame(self)
button_frame.pack(side=TOP)
self.deal_button = Button(button_frame, text="Deal",
command=lambda: handler("deal"))
self.deal_button.pack(side=LEFT, padx=5, pady=5)
self.quit_button = Button(button_frame, text="Quit",
command=lambda: handler("quit"))
self.quit_button.pack(side=RIGHT, padx=5, pady=5)
self.exchange_button = Button(button_frame, text="Exchange",
command=lambda: handler("exchange"))
self.exchange_button.pack(side=RIGHT, padx=5, pady=5)
self.show_button = Button(button_frame, text="Show",
command=lambda: handler("show"))
self.show_button.pack(side=RIGHT, padx=5, pady=5)
label_frame = Frame(self)
label_frame.pack(side=BOTTOM)
self.status_label = Label(label_frame, relief=SUNKEN)
self.set_status_text("No text to show")
self.status_label.pack(side=TOP, padx=5, pady=5)
def __init__(self, *args, **kwargs):
self._app = Scripting.root_node
self.__topwin = kwargs.pop('topwin')
super().__init__(*args, **kwargs)
frm = Frame(self)
self.__gui_images = []
imageMatFileBtn = ImageTk.PhotoImage(
file=Scripting.root_node.get_gui_image_path('Pattern_SaveMat_Button.png'))
self.__gui_images.append(imageMatFileBtn)
Button(
frm,
image=imageMatFileBtn,
command=self._on_save_mat_file).pack(side='top')
Button(
frm,
text='mat',
width=6).pack(side='top')
frm.pack(side='left')
frm = Frame(self)
imageExcelFileBtn = ImageTk.PhotoImage(
file=Scripting.root_node.get_gui_image_path('Pattern_SaveExcel_Button.png'))
self.__gui_images.append(imageExcelFileBtn)
Button(frm, image=imageExcelFileBtn).pack(side='top')
Button(frm, text='xlsx', width=6).pack(side='top')
frm.pack(side='left')
self.name = 'Corr Matrix'
def append_algorithm(self, algorithm):
#To do: when algo is reset, the frm should be removed
for algoName in self.__frameDict:
self.__frameDict[algoName]['frame'].pack_forget()
frm = Frame(self)
frm.pack()
paramInfo = {}
params = algorithm['parameters']
for index, name in enumerate(params):
param = params[name]
paramitem = LabeledEntry(frm)
paramitem.label_text = name
paramitem.label_width = 5
paramitem.entry_width = 8
if self.balloon:
tip = f'''{param.shortdesc}
Type: {param.type.__name__}.'''
self.balloon.bind_widget(paramitem.label, balloonmsg=tip)
if param.type is int:
paramitem.checker_function = self._app.gui.value_checker.check_int
elif param.type is float:
paramitem.checker_function = self._app.gui.value_checker.check_float
paramitem.grid(row=index%self.__MAXROW, column=index//self.__MAXROW)
#self.__params[param.name] = {'gui':paramitem, 'meta':param}
paramInfo[param.name] = {'gui':paramitem, 'meta':param}
self.__algo = algorithm
#self.__frameDict[algorithm.meta.name] = frm
self.__frameDict[algorithm['name']] = dict(frame=frm, paramInfo=paramInfo)
self.__params = paramInfo
def __init__(self, root, title):
self.root = root
self.root.title(title)
# Variable that stores file handle (may be unnecessary)
self.file_handle = ""
master_frame = Frame(root)
master_frame.pack(expand="yes", fill="both")
# Create left button frame and buttons
button_frame = Frame(master_frame)
self.open_button = Button(button_frame, text="Choose File", command=self.load_file)
self.open_button.pack(expand="yes", fill="both")
self.apply_button = Button(button_frame, text="Apply", command=self.apply_consistent, state="disabled")
self.apply_button.pack(expand="yes", fill="both")
self.save_button = Button(button_frame, text="Save File", command=self.save_file, state="disabled")
self.save_button.pack(expand="yes", fill="both")
# Create text frame and initialize text widget
text_frame = Frame(master_frame)
self.text_box = Text(text_frame, height=10, width=50, state="disabled")
self.text_box.pack(side="top", expand="yes", fill="both")
# Configure weights for grid elements
master_frame.columnconfigure(0, weight=1)
master_frame.columnconfigure(1, weight=5)
for i in range(3):
master_frame.rowconfigure(i, weight=1)
# Position button and text frames
button_frame.grid(row=0, column=0, rowspan=3, sticky="nsew")
text_frame.grid(row=0, column=1, rowspan=3, sticky="nsew")
self.root.minsize(500, 200)
def addPathFrame(self):
frame=Frame(self)
frame.pack(fill=tk.X,expand=0,side=tk.TOP,padx=8,pady=5)
frame.columnconfigure(1,weight=1)
#------------------Database file------------------
label=tk.Label(frame,text=dgbk('ting.sqlite文件:'),\
bg='#bbb')
label.grid(row=0,column=0,\
sticky=tk.W,padx=8)
self.db_entry=tk.Entry(frame)
self.db_entry.grid(row=0,column=1,sticky=tk.W+tk.E,padx=8)
self.db_button=tk.Button(frame,text=dgbk('打开'),command=self.openFile)
self.db_button.grid(row=0,column=2,padx=8,sticky=tk.E)
#--------------------Output dir--------------------
label2=tk.Label(frame,text=dgbk('导出到文件夹:'),\
bg='#bbb')
label2.grid(row=2,column=0,\
sticky=tk.W,padx=8)
self.out_entry=tk.Entry(frame)
self.out_entry.grid(row=2,column=1,sticky=tk.W+tk.E,padx=8)
self.out_button=tk.Button(frame,text=dgbk('选择'),command=self.openDir)
self.out_button.grid(row=2,column=2,padx=8,sticky=tk.E)
class GuiGenerateCount(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.pack()
#step increment len
self._stepLenFrm = Frame(self); self._stepLenFrm.pack()
self._stepLenLbl = Label(self._stepLenFrm, text="Step Len: "); self._stepLenLbl.pack(side=LEFT)
self._stepLenSpin = Spinbox(self._stepLenFrm, from_=0, to=1000); self._stepLenSpin.pack(side=LEFT)
#start value
self._startFrm = Frame(self); self._startFrm.pack()
self._startLbl = Label(self._startFrm, text="Start Value: "); self._startLbl.pack(side=LEFT)
self._startTxt = Entry(self._startFrm); self._startTxt.pack(side=LEFT)
self._startTxt.insert(0, "0")
def getSettings(self):
return { "StepLen": self._stepLenSpin.get(),
"StartValue": self._startTxt.get()
}
def getName(self):
return "Counter"
def getGeneratorFunction(self):
return generateCounter
class Example(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.toolbar = Frame(self, bg="#eee")
self.toolbar.pack(side="top", fill="x")
self.bold = Button(self.toolbar, text="Bold", command=self.make_bold)
self.bold.pack(side="left")
self.clear = Button(self.toolbar, text="Clear", command=self.clear)
self.clear.pack(side="left")
# Creates a bold font.
self.bold_font = Font(family="Helvetica", size=14, weight="bold")
self.text = Text(self)
self.text.insert("end", "Select part of text and then click 'Bold'...")
self.text.focus()
self.text.pack(fill="both", expand=True)
# Configures a tag called BOLD.
self.text.tag_configure("BOLD", font=self.bold_font)
def make_bold(self):
# tk.TclError exception is raised if not text is selected.
try:
self.text.tag_add("BOLD", "sel.first", "sel.last")
except TclError:
pass
def clear(self):
self.text.tag_remove("BOLD", "1.0", 'end')
def game_window(self):
##Window##
self.root.grid()
self.root.title("Equations")
##Canvas##
#Frame
frame=Frame(self.root)
frame.pack()
self.canvas=tk.Canvas(frame, bg="white", width=800, height=500)
self.canvas.pack()
#Background/label
bg_image=tk.PhotoImage(file="EQUATIONSbackground.gif")
self.canvas.create_image(0, 250, image=bg_image, anchor="w")
##Score Display##
score_label=tk.Label(self.root, text=["Score:", self.score], font=("Courier", 20), fg="red", bg="white")
score_label.pack()
score_label.place(x=650, y=450)
##Popup Menu##
popupmenu=tk.Label(self.canvas, text=("Answer all eight equations correctly!"), font=("Courier", 12), anchor="n", bg="white", fg="black", height=7)
popupmenu.place(x=280, y=180)
#Return to Menu Button
returnmenu=tk.Button(self.canvas, text="Main Menu", bg="white", command=self.returntomenu)
returnmenu.place(x=425, y=240)
#Start Button
start=tk.Button(self.canvas, text="Start", bg="white")
start.config(command= lambda: self.gameplay(popupmenu, start, returnmenu, score_label, 8))
start.place(x=325, y=240)
##Keep running##
self.root.mainloop()
def receivePrivateChat(self, connectingUser):
global conversationBoxList
print("CHAT PRIVATA in arrivo con "+connectingUser)
newWindow = Toplevel(self.parent)
newWindow.title("Python Chat requested by "+connectingUser)
newWindow.minsize(400, 475)
newWindow.focus()
def disconnectPM():
del conversationBoxList[connectingUser]
newWindow.destroy()
newWindow.protocol('WM_DELETE_WINDOW', disconnectPM)
#label = Label(newWindow, text="PROVA PROVA")
#label.pack(side="top", fill="both", padx=10, pady=10)
frame = Frame(newWindow)
frame.pack(fill=BOTH, expand=1, side=LEFT)
box = ScrolledText(frame, wrap=WORD, relief = GROOVE, width=30, height=18, font=self.customFontMessage)
box.config(state=DISABLED)
box.pack(expand="yes", fill=BOTH, side=TOP)
textarea = Text(frame, width=30, height=5)
textarea.bind("<KeyRelease-Return>", lambda event : self.getprivatetext(event, textarea, connectingUser))
textarea.pack(expand="yes", fill=BOTH, side=TOP)
#aggiungo alla mappa globale il box di conversazione
conversationBoxList[connectingUser] = box
def _init_paging(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.prev = prev = Button(innerframe, text='Previous', command=self.previous, width='10', borderwidth=1, highlightthickness=1, state='disabled')
prev.pack(side='left', anchor='center')
self.next = next = Button(innerframe, text='Next', command=self.__next__, width='10', borderwidth=1, highlightthickness=1, state='disabled')
next.pack(side='right', anchor='center')
innerframe.pack(side='top', fill='y')
self.current_page = 0
def __init__(self, master):
frame = Frame(master)
frame.pack()
self.entry = Entry(frame)
self.entry.pack(side=LEFT)
self.entry.bind('<Return>', self.on_click)
class ParseGUI(object):
"""Class used for the GUI
The object parameter is the root widget for the Tkinter GUI
"""
def __init__(self, master):
"""Constructor method
:param master: A "master" wigdet
"""
self.mainframe = Frame(master) # Create a Frame child widget
self.mainframe.pack() # Make the widget visible
self.path = '' # Define default path for the .xmcd file
self.texfile_path = '' # Define path for the .tex file
self.name = Label(self.mainframe, text="Welcome to Mathcad to LaTeX converter") # Create a static text label
self.name.pack(side="top") # Make the widget visible and define location
self.filename = StringVar() # Create a dynamic string variable
self.filename.set("Current selected file: none") # Set the string value
self.filename_label = Label(self.mainframe, textvariable=self.filename) # Create a label with the dynamic var
self.filename_label.pack()
self.text_updater = Entry(self.mainframe, textvariable=self.filename) # Create a Entry widget for auto updates
self.status = StringVar() # Used for displaying the status of the file operation
self.status.set("Status: Not parsed")
self.status_label = Label(self.mainframe, textvariable=self.status)
self.status_label.pack()
self.text_updater2 = Entry(self.mainframe, textvariable=self.status)
self.parse_file = Button(self.mainframe, text="Parse and save!", command=self.parse_file) # Button for parsing
self.parse_file.pack(side="right")
self.parse_file = Button(self.mainframe, text="Open LaTeX file", command=self.open_file)
self.parse_file.pack(side="right")
self.select_file = Button(self.mainframe, text="Select file", command=self.select_file) # Runs a class method
self.select_file.pack(side="right")
def select_file(self): # Method used for selecting a file
self.path = askopenfilename() # Display native os file dialog for choosing a file
self.filename.set("Current selected file: " + os.path.basename(self.path)) # Change the dynamic variable
self.status.set("Status: Not parsed") # Set status
def open_file(self): # Method used for opening the parsed LaTeX file
self.texfile_path = os.path.dirname(self.path) + '/ParsedLatexFile/' + os.path.splitext(os.path.basename(self.path))[0] + '.tex'
if self.status.get() == "Status: File tried parsed! Look under the folder \ParsedLatexFile !":
os.system("start " + "\"\" \"" + self.texfile_path + "\"")
def parse_file(self): # Method for parsing the chosen file
# Make sure a file is selected and it is a Mathcad file before trying to parse it
if self.filename.get() != 'Current selected file: none' and os.path.splitext(self.path)[1] == '.xmcd':
self.status.set("Status: Tring to parse... (most files takes a few seconds)")
MathcadXMLParser(self.path) # Call the MathcadXMLParser class with the path
self.status.set("Status: File tried parsed! Look under the folder \ParsedLatexFile !")
# Display a error message to the user
else:
self.status.set("Status: You need to select a .xmcd (Mathcad) file!")
def __init__(self, *, multiple_runner_class, input_spec, left_name,
right_name):
"""Sets up windows and the instance of RunMultipleTimes that will do the actual work."""
#: The input_spec is an iterable of
#: :py:class:`farg.core.read_input_spec.SpecificationForOneRun`.
self.input_spec = input_spec
#: Class responsible for the actual running multiple times.
self.multiple_runner_class = multiple_runner_class
#: Main window
self.mw = mw = Tk()
#: Statistics thus far, grouped by input.
self.stats = AllStats(left_name=left_name, right_name=right_name)
#: Are we in the process of quitting?
self.quitting = False
self.status_label = Label(
mw, text='Not Started', font=('Times', 20), foreground='#000000')
self.status_label_text = self.status_label.cget('text')
self.status_label.pack(side=TOP, expand=True, fill=X)
#: Has a run started? Used to ensure single run.
self.run_started = False
details_frame = Frame(mw)
details_frame.pack(side=TOP)
#: listbox on left listing inputs.
frame = Frame(details_frame)
scrollbar = Scrollbar(frame, orient=VERTICAL)
listbox = Listbox(
frame,
yscrollcommand=scrollbar.set,
height=25,
width=70,
selectmode=SINGLE)
scrollbar.config(command=listbox.yview)
scrollbar.pack(side=RIGHT, fill=Y)
listbox.pack(side=LEFT, fill=BOTH, expand=1)
listbox.bind('<ButtonRelease-1>', self.SelectForDisplay, '+')
frame.pack(side=LEFT)
self.listbox = listbox
#: Canvas on right for details
self.canvas = Canvas(
details_frame,
width=kCanvasWidth,
height=kCanvasHeight,
background='#FFFFFF')
self.canvas.pack(side=LEFT)
#: which input are we displaying the details of?
self.display_details_for = None
#: Thread used for running
self.thread = None
self.mw.bind('<KeyPress-q>', lambda e: self.Quit())
self.mw.bind('<KeyPress-r>', lambda e: self.KickOffRun())
self.Refresher()
self.mw.after(1000, self.KickOffRun)
def toolbox_window(self):
"""Creates the window which will host the toolbox buttons"""
toolbox_root = Toplevel()
toolbox_root.title("Toolbox")
toolbox_root.geometry("455x256")
toolbox_frame = Frame(toolbox_root)
toolbox_frame.pack(fill=BOTH)
def gameplay(self):
##Window##
self.root.grid()
self.root.title("Animals") #Name of the window
##Canvas##
#Frame
frame=Frame(self.root)
frame.pack()
self.canvas=tk.Canvas(frame, bg="white", width=800, height=500)
self.canvas.pack()
#Background/label
bg_image=tk.PhotoImage(file="ANIMALSbackground.gif")
self.canvas.create_image(0, 200, image=bg_image, anchor="w")
##Score Display##
score_label=tk.Label(self.root, text=["Score:", self.score], font=("Courier", 20), fg="red", bg="white")
score_label.pack()
score_label.place(x=650, y=450)
##Popup Menu##
popupmenu1=tk.Label(self.canvas, text=("Count all the"), font=("Courier", 12), anchor="n", bg="white", fg="black", height=7, width=20)
popupmenu2=tk.Label(self.canvas, text=(self.chosen_animal), font=("Courier", 12), anchor="n", bg="white", fg="red", height=7)
popupmenu1.place(x=330, y=180)
popupmenu2.place(x=473, y=180)
#Return to Menu Button
returnmenu=tk.Button(self.canvas, text="Main Menu", bg="white", command=self.returntomenu)
returnmenu.place(x=420, y=240)
#Start Button
start=tk.Button(self.canvas, text="Start", bg="white")
start.config(command=lambda: self.RandomAnimals(popupmenu1, popupmenu2, start, returnmenu, tiger, zebra, lemur, elephant, panda, 20, score_label))
start.place(x=350, y=240)
##Making Animals Into Images##
#Tiger
tiger_image=tk.PhotoImage(file="Tiger.gif")
tiger=tiger_image.subsample(3, 3)
#Zebra
zebra_image=tk.PhotoImage(file="Zebra.gif")
zebra=zebra_image.subsample(3, 3)
#Lemur
lemur_image=tk.PhotoImage(file="Lemur.gif")
lemur=lemur_image.subsample(3, 3)
#Elephant
elephant_image=tk.PhotoImage(file="Elephant.gif")
elephant=elephant_image.subsample(6, 6)
#Panda
panda_image=tk.PhotoImage(file="Panda.gif")
panda=panda_image.subsample(5, 5)
#Keep running
self.root.mainloop()
def _init_query_box(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
another = Frame(innerframe, background=self._BACKGROUND_COLOUR)
self.query_box = Entry(another, width=60)
self.query_box.pack(side='left', fill='x', pady=25, anchor='center')
self.search_button = Button(another, text='Search', command=self.search, borderwidth=1, highlightthickness=1)
self.search_button.pack(side='left', fill='x', pady=25, anchor='center')
self.query_box.bind('<KeyPress-Return>', self.search_enter_keypress_handler)
another.pack()
innerframe.pack(side='top', fill='x', anchor='n')
class Application(Frame):
def __init__(self):
master = Tk()
Frame.__init__(self, master)
master.title(PROGRAM_TITLE)
self.mid_ax = BooleanVar()
self.button1_text = 'Reset'
self.points = []
self.window_geometry()
self.create_widgets()
self.redraw()
def create_points(self, num_x, num_y):
x_min = -(num_x // 2)
x_max = num_x // 2
x_delta = num_x % 2
y_min = -(num_y // 2)
y_max = num_y // 2
y_delta = num_y % 2
for i in range( x_min, x_max + x_delta ):
for j in range( y_min, y_max + y_delta):
self.points.append(Point(i, j, self.canvas))
def add_point(self, x, y):
self.points.append(
Point(x, y, self.canvas)
)
self.redraw()
def make_transform(self):
tr_matrix = self.trans.get_matrix()
for pnt in self.points:
p = tr_matrix * pnt
pnt.matrix = p.matrix
pnt.x = p.matrix[0][0]
pnt.y = p.matrix[1][0]
self.redraw()
#print("sucess")
def create_widgets(self):
self.canvas = Canvas(
self,
bg=CANVAS_BACKGROUND_COLOR,
bd=0,
highlightthickness=0,
relief=FLAT
)
self.canvas.pack(side=LEFT, fill=BOTH, expand=1)
self.control_panel = Frame(
self,
bg=CONTROL_PANEL_BACKGROUND_COLOR,
width=500,
#width=self.width/9
)
self.control_panel.pack(side=LEFT, fill=Y, expand=0)
self.cp_wrap = Frame(
self.control_panel,
bg=CONTROL_PANEL_BACKGROUND_COLOR,
width=150,
#width=self.width/9
)
self.cp_wrap.pack(fill=X, expand=0)
self.button1 = Button(
self.control_panel,
text=self.button1_text,
command=self.reset
)
self.button1.pack()
self.trans = TransformationInputs(
self.control_panel,
bg=CONTROL_PANEL_BACKGROUND_COLOR
)
self.check_button1 = Checkbutton(
self.control_panel,
text='Axes on mid',
bg=CONTROL_PANEL_BACKGROUND_COLOR,
bd=0,
variable=self.mid_ax,
onvalue=True, offvalue=False
)
self.trans.pack()
self.check_button1.pack(side=TOP)
self.trans.create_elements()
def reset(self):
self.canvas.delete(ALL)
identity = [[1,0], [0,1]]
self.trans.set_matrix_to_input(identity)
if self.points == []:
self.create_points(PNTS_ON_X, PNTS_ON_Y)
else:
self.points = []
self.button1_text = '+Points'
self.redraw()
def redraw(self):
self.canvas.delete(ALL)
if self.mid_ax.get():
self.draw_mid_axes(points=POINTS_ON_SCREEN // 2)
else:
self.draw_edge_axes(points=POINTS_ON_SCREEN // 2)
for pnt in self.points:
pnt.draw()
def window_geometry(self, width=780, height=420):
self.width = width
self.height = height
self.master.minsize(width=width, height=height)
x = (self.master.winfo_screenwidth() - width) / 2
y = (self.master.winfo_screenheight() - height) / 2
self.master.geometry('%dx%d+%d+%d' % (width, height, x, y))
self.pack(fill=BOTH, expand=1)
def run(self):
self.mainloop()
def draw_edge_axes(self, col='black', points=8):
mx , my = (self.canvas.winfo_width() / 2, self.canvas.winfo_height() / 2)
x, y = mx, my
bot_y = my * 2 - 20
length = max(x, y)
len_x, len_y = 2*x, 2*y
OFFSET = 25
#draw x
self.canvas.create_line(
x - length,
len_y - OFFSET,
x + length,
len_y - OFFSET,
fill=col,
width=1,
capstyle=PROJECTING,
)
#draw y
self.canvas.create_line(
OFFSET,
y - length,
OFFSET,
y + length,
fill=col,
width=1,
capstyle=PROJECTING,
)
# markings on axes
N = points
spacing = min(x,y) / N
for i in range(-N, N + 1):
#mark x line
self.canvas.create_line(
x + spacing*i,
len_y - OFFSET - 2,
x + spacing*i,
len_y - OFFSET + 2,
fill=col
)
#mark y line
self.canvas.create_line(
OFFSET - 2,
y + spacing*i,
OFFSET + 2,
y + spacing*i,
fill=col
)
#write numbers on axes
self.canvas.create_text(x + spacing*i, len_y - OFFSET + 8, text='%d'% (i))
self.canvas.create_text(OFFSET - 7, y + spacing*i, text='%d'% (-i))
self.canvas.create_text(OFFSET + 7, 25, text='y')
self.canvas.create_text(x*2 - 25, y*2 - OFFSET + 7, text='x')
def draw_mid_axes(self, col='black', points=8):
mx , my = (self.canvas.winfo_width() / 2, self.canvas.winfo_height() / 2)
#mid = x,y
x, y = mx, my
length = max(x, y)
#draw x
self.canvas.create_line(
x - length,
y,
x + length,
y,
fill=col,
width=1,
capstyle=PROJECTING,
)
#draw y
self.canvas.create_line(
x,
y - length,
x,
y + length,
fill=col,
width=1,
capstyle=PROJECTING,
)
# markings on axes
N = points
spacing = min(x,y) / N
for i in range(1,N):
self.canvas.create_line(
x + spacing*i,
y - 2,
x + spacing*i,
y + 2,
fill=col
)
self.canvas.create_line(
x - spacing*i,
y - 2,
x - spacing*i,
y + 2,
fill=col
)
self.canvas.create_line(
x - 2,
y + spacing*i,
x + 2,
y + spacing*i,
fill=col
)
self.canvas.create_line(
x - 2,
y - spacing*i,
x + 2,
y - spacing*i,
fill=col
)
self.canvas.create_text(x + spacing*i, y + 7, text='%d'% (i))
self.canvas.create_text(x - spacing*i, y + 7, text='%d'% (-i))
self.canvas.create_text(x - 6, y + spacing*i, text='%d'% (-i))
self.canvas.create_text(x - 6, y - spacing*i, text='%d'% (i))
self.canvas.create_text(x + 7, 25, text='y')
self.canvas.create_text(x*2 - 25, y + 7, text='x')
class CollocationsView:
_BACKGROUND_COLOUR = "#FFF" # white
def __init__(self):
self.queue = q.Queue()
self.model = CollocationsModel(self.queue)
self.top = Tk()
self._init_top(self.top)
self._init_menubar()
self._init_widgets(self.top)
self.load_corpus(self.model.DEFAULT_CORPUS)
self.after = self.top.after(POLL_INTERVAL, self._poll)
def _init_top(self, top):
top.geometry("550x650+50+50")
top.title("NLTK Collocations List")
top.bind("<Control-q>", self.destroy)
top.protocol("WM_DELETE_WINDOW", self.destroy)
top.minsize(550, 650)
def _init_widgets(self, parent):
self.main_frame = Frame(
parent, dict(background=self._BACKGROUND_COLOUR, padx=1, pady=1, border=1)
)
self._init_corpus_select(self.main_frame)
self._init_results_box(self.main_frame)
self._init_paging(self.main_frame)
self._init_status(self.main_frame)
self.main_frame.pack(fill="both", expand=True)
def _init_corpus_select(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.var = StringVar(innerframe)
self.var.set(self.model.DEFAULT_CORPUS)
Label(
innerframe,
justify=LEFT,
text=" Corpus: ",
background=self._BACKGROUND_COLOUR,
padx=2,
pady=1,
border=0,
).pack(side="left")
other_corpora = list(self.model.CORPORA.keys()).remove(
self.model.DEFAULT_CORPUS
)
om = OptionMenu(
innerframe,
self.var,
self.model.DEFAULT_CORPUS,
command=self.corpus_selected,
*self.model.non_default_corpora()
)
om["borderwidth"] = 0
om["highlightthickness"] = 1
om.pack(side="left")
innerframe.pack(side="top", fill="x", anchor="n")
def _init_status(self, parent):
self.status = Label(
parent,
justify=LEFT,
relief=SUNKEN,
background=self._BACKGROUND_COLOUR,
border=0,
padx=1,
pady=0,
)
self.status.pack(side="top", anchor="sw")
def _init_menubar(self):
self._result_size = IntVar(self.top)
menubar = Menu(self.top)
filemenu = Menu(menubar, tearoff=0, borderwidth=0)
filemenu.add_command(
label="Exit", underline=1, command=self.destroy, accelerator="Ctrl-q"
)
menubar.add_cascade(label="File", underline=0, menu=filemenu)
editmenu = Menu(menubar, tearoff=0)
rescntmenu = Menu(editmenu, tearoff=0)
rescntmenu.add_radiobutton(
label="20",
variable=self._result_size,
underline=0,
value=20,
command=self.set_result_size,
)
rescntmenu.add_radiobutton(
label="50",
variable=self._result_size,
underline=0,
value=50,
command=self.set_result_size,
)
rescntmenu.add_radiobutton(
label="100",
variable=self._result_size,
underline=0,
value=100,
command=self.set_result_size,
)
rescntmenu.invoke(1)
editmenu.add_cascade(label="Result Count", underline=0, menu=rescntmenu)
menubar.add_cascade(label="Edit", underline=0, menu=editmenu)
self.top.config(menu=menubar)
def set_result_size(self, **kwargs):
self.model.result_count = self._result_size.get()
def _init_results_box(self, parent):
innerframe = Frame(parent)
i1 = Frame(innerframe)
i2 = Frame(innerframe)
vscrollbar = Scrollbar(i1, borderwidth=1)
hscrollbar = Scrollbar(i2, borderwidth=1, orient="horiz")
self.results_box = Text(
i1,
font=Font(family="courier", size="16"),
state="disabled",
borderwidth=1,
yscrollcommand=vscrollbar.set,
xscrollcommand=hscrollbar.set,
wrap="none",
width="40",
height="20",
exportselection=1,
)
self.results_box.pack(side="left", fill="both", expand=True)
vscrollbar.pack(side="left", fill="y", anchor="e")
vscrollbar.config(command=self.results_box.yview)
hscrollbar.pack(side="left", fill="x", expand=True, anchor="w")
hscrollbar.config(command=self.results_box.xview)
# there is no other way of avoiding the overlap of scrollbars while using pack layout manager!!!
Label(i2, text=" ", background=self._BACKGROUND_COLOUR).pack(
side="left", anchor="e"
)
i1.pack(side="top", fill="both", expand=True, anchor="n")
i2.pack(side="bottom", fill="x", anchor="s")
innerframe.pack(side="top", fill="both", expand=True)
def _init_paging(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.prev = prev = Button(
innerframe,
text="Previous",
command=self.previous,
width="10",
borderwidth=1,
highlightthickness=1,
state="disabled",
)
prev.pack(side="left", anchor="center")
self.next = next = Button(
innerframe,
text="Next",
command=self.__next__,
width="10",
borderwidth=1,
highlightthickness=1,
state="disabled",
)
next.pack(side="right", anchor="center")
innerframe.pack(side="top", fill="y")
self.reset_current_page()
def reset_current_page(self):
self.current_page = -1
def _poll(self):
try:
event = self.queue.get(block=False)
except q.Empty:
pass
else:
if event == CORPUS_LOADED_EVENT:
self.handle_corpus_loaded(event)
elif event == ERROR_LOADING_CORPUS_EVENT:
self.handle_error_loading_corpus(event)
self.after = self.top.after(POLL_INTERVAL, self._poll)
def handle_error_loading_corpus(self, event):
self.status["text"] = "Error in loading " + self.var.get()
self.unfreeze_editable()
self.clear_results_box()
self.freeze_editable()
self.reset_current_page()
def handle_corpus_loaded(self, event):
self.status["text"] = self.var.get() + " is loaded"
self.unfreeze_editable()
self.clear_results_box()
self.reset_current_page()
# self.next()
collocations = self.model.next(self.current_page + 1)
self.write_results(collocations)
self.current_page += 1
def corpus_selected(self, *args):
new_selection = self.var.get()
self.load_corpus(new_selection)
def previous(self):
self.freeze_editable()
collocations = self.model.prev(self.current_page - 1)
self.current_page = self.current_page - 1
self.clear_results_box()
self.write_results(collocations)
self.unfreeze_editable()
def __next__(self):
self.freeze_editable()
collocations = self.model.next(self.current_page + 1)
self.clear_results_box()
self.write_results(collocations)
self.current_page += 1
self.unfreeze_editable()
def load_corpus(self, selection):
if self.model.selected_corpus != selection:
self.status["text"] = "Loading " + selection + "..."
self.freeze_editable()
self.model.load_corpus(selection)
def freeze_editable(self):
self.prev["state"] = "disabled"
self.next["state"] = "disabled"
def clear_results_box(self):
self.results_box["state"] = "normal"
self.results_box.delete("1.0", END)
self.results_box["state"] = "disabled"
def fire_event(self, event):
# Firing an event so that rendering of widgets happen in the mainloop thread
self.top.event_generate(event, when="tail")
def destroy(self, *e):
if self.top is None:
return
self.top.after_cancel(self.after)
self.top.destroy()
self.top = None
def mainloop(self, *args, **kwargs):
if in_idle():
return
self.top.mainloop(*args, **kwargs)
def unfreeze_editable(self):
self.set_paging_button_states()
def set_paging_button_states(self):
if self.current_page == -1 or self.current_page == 0:
self.prev["state"] = "disabled"
else:
self.prev["state"] = "normal"
if self.model.is_last_page(self.current_page):
self.next["state"] = "disabled"
else:
self.next["state"] = "normal"
def write_results(self, results):
self.results_box["state"] = "normal"
row = 1
for each in results:
self.results_box.insert(str(row) + ".0", each[0] + " " + each[1] + "\n")
row += 1
self.results_box["state"] = "disabled"
from tkinter import Listbox, END, Button, ANCHOR, Label, Frame, Scrollbar, VERTICAL, RIGHT, Y, Tk, MULTIPLE
import tkinter as tk
root = tk.Tk()
root.geometry("600x640")
root.config(bg="#353130")
#! selcet mode CHECK LINE 19 20
# Create Frame
my_frame = Frame(root)
my_frame.pack()
#scroll bar
scroll_bar_4_my_listbox = Scrollbar(my_frame, orient=VERTICAL)
scroll_bar_4_my_listbox.pack(side=RIGHT,
fill=Y) #? y is to fill UP and DOWN all the way
#? pack in on RIGHT hand side
#Listbox
#* SELECT MODE = SINGLE IS AT DEFAULT. <OTHER OPTIONS> BROWSE, MULTIPLE, EXTENDED
my_listbox = Listbox(
my_frame,
width=50,
bg="#353130",
fg="white",
yscrollcommand=scroll_bar_4_my_listbox.set,
selectmode=MULTIPLE) #?yscrollcommand -> is for horizontal scrollbar
my_listbox.pack(pady=15)
## coz of my_listbox no defined so got to put it here
scroll_bar_4_my_listbox.config(command=my_listbox.yview)
r2 = text.get('1.0', 'end')
print('Адрес: \n', r1)
print('Коментарий: \n', r2)
if __name__ == '__main__':
root = Tk()
# Ex1
frame1 = Frame(root)
label1 = Label(frame1, text='Ваш адрес:')
entry = Entry(frame1)
label2 = Label(frame1, text='Коментарий:')
text = Text(frame1, width='15', height='5')
btn = Button(frame1, text='Отправить', bg='cyan', command=response)
# Pack1
frame1.pack()
label1.pack()
entry.pack()
label2.pack()
text.pack()
btn.pack()
# Ex2
frame2 = Frame(root)
label3 = Label(frame2, text='Сколько штук?')
value = IntVar()
value.set(1)
rb1 = Radiobutton(frame2, text='0-10', variable=value, value=1)
rb2 = Radiobutton(frame2, text='11-20', variable=value, value=2)
rb3 = Radiobutton(frame2, text='21-30', variable=value, value=3)
rb4 = Radiobutton(frame2, text='31-40', variable=value, value=4)
label4 = Label(frame2, text='Какого цвета?')
def __init__(self, parent, *args, **kwargs):
"""Constructor
Args:
parent (tk.widget): parent widget to make the frame a child of
*args: Variable length argument list
**kwargs: Arbitrary keyword argument list
"""
ttk.Frame.__init__(self, parent, *args, **kwargs)
self.parent = parent
# Mutex for the networking thread
self.socket_queue = Queue()
# Socket server
self.server = Server(port=25565)
self.server.start(self.socket_queue)
# Instantiated signals class to generate signals
self.ecg_signals = Signals()
# ============ GUI Variables ============
# Instructor realtime setting variables
self.hr = IntVar(self, value=80)
self.threshold = IntVar(self, value=20)
self.hr_paced = IntVar(self, value=80)
# Manual Override variables
self.position = IntVar(self, value=0)
self.override_position = BooleanVar(self, value=False)
self.hr1 = StringVar(self, value='0')
self.pathway_1 = IntVar(self, value=0)
self.pathway_2 = IntVar(self, value=0)
self.is_paced = BooleanVar(self, value=False)
# Serial in position
self.serial_position = IntVar(self, value='0')
# Command variables
self.wait_for_update = BooleanVar(self, value=False)
self.wait_for_position = BooleanVar(self, value=False)
self.wait_for_pathway_1 = BooleanVar(self, value=False)
self.wait_for_pathway_2 = BooleanVar(self, value=False)
# ============ Main Frame Sides ===========
# Signals frame
frame_signals = Frame(self, bg='black')
frame_signals.pack(side=tk.LEFT)
# Monitor value frame
frame_values = Frame(self, bg='black')
frame_values.pack(side=tk.RIGHT, padx=10)
# Take care of plotting
self.plot_point = 0
self.new_x = [0.0]
self.new_y = [0.0]
self.last_x = 0
self.last_x_lim = 0
self.position_to_show = 0
self.variation = 0
self.flat_span = False
self.end_flat = 0
self.flat_span_y = 0
# HR Monitor setup
tk.Label(frame_values,
text="HR",
font=self.header_2_style,
bg="black",
fg="lime green").pack()
tk.Label(frame_values,
textvariable=self.hr1,
font=self.header_1_style,
bg="black",
fg="lime green").pack()
# Serial selection setup
Options = ['']
Options.extend(serial.tools.list_ports.comports())
self.s = 'RIP'
self.ser = None
self.variable = StringVar(self)
self.variable.set(Options[0]) #Default option
w = OptionMenu(frame_signals, self.variable, *Options)
w.grid(row=2, column=1)
self.variable.trace('w', self.change_dropdown)
# Create plotting canvas
fig = plt.Figure(figsize=(14, 4.5),
dpi=100,
facecolor='k',
edgecolor='k')
canvas = FigureCanvasTkAgg(fig, master=frame_signals)
canvas.get_tk_widget().grid(row=1, column=1)
# Sets plot customisations
self.ax = fig.add_subplot(111)
self.ax.set_xlim(self.last_x_lim, 4)
self.ax.set_ylim(-3.0, 3.0)
self.ax.set_yticklabels([])
self.ax.set_xticklabels([])
self.ax.xaxis.set_tick_params(width=1, top=True)
self.ax.set_facecolor('black')
self.line, = self.ax.plot(0, 0)
self.ax.get_lines()[0].set_color("xkcd:lime")
# Starts an animated plot for the ECG signal
self.ani = animation.FuncAnimation(fig,
self.animate,
interval=24,
blit=True)
# Polling Initialisation for socket connection
self.after(10, self.read_socket)
class VacuumEnvironmentGUISimulator:
def __init__(self):
self.vacuum_env = None
self.agent = None
self.grid_frame = None
self.grid = None
self.previous_dims = None
self.is_running = False
self.marked_agent_pos = (0, 0)
self.marked_agent_rot = (1, 0)
self.setup_gui()
self.setup_images()
self.setup_selection_menus()
self.setup_buttons()
self.update_all(force=True)
def setup_gui(self):
command = yaml.load(open(CONFIG_FILE_NAME))['simulation']['command']
self.root = Tk()
self.root.title("Vacuum Environment")
self.root.minsize(1024, 768)
self.root.resizable(width=True, height=True)
self.agent_btn_dims = 22
self.host_frame = Frame(self.root)
if command:
self.setup_command_widget()
self.setup_log_widget()
if command:
self.command_frame.pack(side="top")
self.options_frame.pack(side="top")
self.host_frame.pack(expand=True, fill=BOTH)
def setup_log_widget(self):
self.log = Text(self.host_frame, width=50, borderwidth=2)
self.log.pack(side="right", expand=True, fill="y")
self.log.configure(state="disabled")
self.options_frame = Frame(self.host_frame)
def setup_command_widget(self):
command_frame = Frame(self.host_frame)
txt = Entry(command_frame, bd=2, width=100)
txt.pack(side="left")
self.command_text = txt
b = Button(command_frame, text="Do It!")
b.pack(side="right")
b.config(command=lambda: self.send_user_command)
txt.bind('<Return>', self.send_user_command)
self.command_frame = command_frame
def setup_images(self):
self.agent_img = dict()
self.agent_img[(1, 0)] = PhotoImage(file="images/agent_east.png")
self.agent_img[(0, 1)] = PhotoImage(file="images/agent_south.png")
self.agent_img[(-1, 0)] = PhotoImage(file="images/agent_west.png")
self.agent_img[(0, -1)] = PhotoImage(file="images/agent_north.png")
self.images = {
ENV_CLEAN: PhotoImage(file="images/blank.png"),
ENV_DIRTY: PhotoImage(file="images/dirt.png"),
ENV_WALL: PhotoImage(file="images/wall.png"),
ENV_GOLD: PhotoImage(file="images/gold.png")
}
self.blank_img = PhotoImage(file="images/blank.png")
def setup_selection_menus(self):
# Environment wall bias
self.wall_bias_getter = self.create_selection_menu(
self.update_all,
*[(str(bias), bias) for bias in [0.0, 0.1, 0.2, 0.3, 0.4, 0.5]])
# Environment dirt bias
self.dirt_bias_getter = self.create_selection_menu(
self.update_all,
*[(str(bias), bias)
for bias in [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7]])
# Environment goal bias
self.gold_bias_getter = self.create_selection_menu(
self.update_all,
*[(str(bias), bias) for bias in [0, 1, 2, 3, 4, 5, 0.01, 0.05]])
# Environment PRF seed
self.seed_getter = self.create_selection_menu(
self.update_all, ("Random", None), ("Seed 1", FIXED_SEED_1),
("Seed 2", FIXED_SEED_2),
always_trigger_onselect=True)
self.recon_getter = self.create_selection_menu(
self.update_all, ("None", "None"), ("Full", "Full"),
("WallsAndGold", "WallsAndGold"), ("WallsOnly", "WallsOnly"),
always_trigger_onselect=True)
self.agent_getter = self.create_selection_menu(
self.update_all,
*list(map(lambda p: (p[1], p), agents())),
always_trigger_onselect=True)
self.delay_getter = self.create_selection_menu(
None,
*[(str(time) + "ms", time) for time in [100, 500, 1000, 10, 50]])
def make_button(self, text, callback):
b = Button(self.options_frame, text=text)
b.pack(side="left")
b.config(command=callback)
def setup_buttons(self):
self.make_button("Prepare", self.update_all)
self.make_button("Run", self.start)
self.make_button("Stop", self.stop)
self.make_button("Step", self.step)
self.make_button("Clear Log", self.log_clear)
def send_user_command(self, ignore=None):
self.agent.is_alive = True
self.agent.send_user_command(self.command_text.get())
self.start()
self.command_text.delete(0, 'end')
def start_main_loop(self):
self.root.mainloop()
def append_log(self, text, end="\r\n"):
self.log.configure(state="normal")
self.log.insert("end", str(text) + end)
self.log.see(END)
self.log.configure(state="disabled")
def log_clear(self):
self.log.configure(state="normal")
self.log.replace("0.0", END, "")
self.log.configure(state="disabled")
def refresh_tile(self, x, y):
if PLATFORM_WINDOWS:
state = self.vacuum_env.world[x][y]
new_state = WORLD_COLOR_CLEAN if state == ENV_CLEAN\
else WORLD_COLOR_DIRTY if state == ENV_DIRTY\
else WORLD_COLOR_GOLD if state == ENV_GOLD\
else WORLD_COLOR_WALL
# Apply color to tile (if necessary)
if new_state != self.grid[x][y].cget("bg"):
self.grid[x][y].configure(bg=new_state)
else:
new_image = self.images[self.vacuum_env.world[x][y]]
if new_image != self.grid[x][y].cget("image"):
self.grid[x][y].configure(image=new_image)
def refresh(self):
for x in range(self.vacuum_env.env_x):
for y in range(self.vacuum_env.env_y):
self.refresh_tile(x, y)
self.draw_agent()
def step(self):
"""
Run one step in environment simulation.
This automatically refreshes tiles.
"""
self.vacuum_env.step()
self.refresh()
def start(self):
if self.is_running:
#self.append_log("Already running")
return
#self.append_log("Starting...")
self.is_running = True
self.run()
def run(self):
if self.is_running:
self.step()
self.root.after(self.delay_getter(),
self.run) # Trigger a timer for next call
def stop(self):
if self.is_running:
self.append_log("Stopped")
self.is_running = False
def make_env_frame(self):
"""
Create the grid layout representing the state of the vacuum environment
:return: None
"""
width, height = STANDARD_ENV_DIMS
previous_width, previous_height = (self.previous_dims or (-1, -1))
if (width != previous_width
or height != previous_height) and self.grid:
self.grid[self.marked_agent_pos[0]][
self.marked_agent_pos[1]].configure(image=self.blank_img)
padx = 5 if width > 15 else 8
pady = 2 if height > 15 else 4
def make_callback(x, y):
"""
Create a callback function for the given coordinate
:param x: X-coordinate
:param y: Y-coordinate
:return: Callback function for the given coordinate
"""
return lambda: self.grid_click_callback(x, y)
def make_button(x, y, container_frame):
"""
Shorthand for creating a button in the tile grid
:param x: X-coordinate of button
:param y: Y-coordinate of button
:param container_frame: Frame to hold button
:return: Reference to button
"""
nonlocal padx
nonlocal pady
btn = Button(container_frame,
text="",
height=self.agent_btn_dims,
width=self.agent_btn_dims,
padx=padx,
pady=pady,
image=self.blank_img)
btn.pack(side="right")
btn.config(command=make_callback(x, y))
return btn
# Create an unpopulated button ref grid (filled with None for debug purposes)
grid = [[None for _ in range(height)] for _ in range(width)]
frame_pad = 0 if height > 30 else 8 * (30 - height)
if self.grid is None:
frame = Frame(self.host_frame, pady=frame_pad, padx=0)
for y in range(height - 1, -1, -1):
row_frame = Frame(frame)
for x in range(width - 1, -1, -1):
grid[x][y] = make_button(x, y, row_frame)
row_frame.pack(side="bottom")
frame.pack(side="bottom")
self.grid_frame = frame
else:
# Optimization to hopefully be a bit nicer on GC (if nothing else)
for y in range(height - 1, -1, -1):
rel_y = height - 1 - y
row_frame = Frame(
self.grid_frame
) if rel_y >= previous_height else self.grid[0][previous_height
- 1 -
rel_y].master
for x in range(width - 1, -1, -1):
rel_x = width - 1 - x
grid[x][y] = self.grid[previous_width - 1 - rel_x][
previous_height - 1 -
rel_y] if rel_x < previous_width and rel_y < previous_height else make_button(
x, y, row_frame)
if rel_x < previous_width and rel_y < previous_height:
grid[x][y].configure(padx=padx, pady=pady)
grid[x][y].config(command=make_callback(x, y))
row_frame.pack(side="bottom")
for y in range(previous_height):
if previous_height - y > height:
self.grid[0][y].master.pack_forget()
continue
for x in range(previous_width):
if previous_width - x > width:
self.grid[x][y].pack_forget()
self.grid_frame.configure(pady=frame_pad, width=frame_pad)
self.grid_frame.pack(side="bottom")
# Update grid
self.grid = grid
self.previous_dims = (width, height)
self.draw_agent()
def draw_agent(self):
self.grid[self.marked_agent_pos[0]][
self.marked_agent_pos[1]].configure(image=self.blank_img)
self.grid[self.agent.location[0]][self.agent.location[1]].configure(
image=self.agent_img[self.agent.facing])
self.marked_agent_pos = self.agent.location
self.marked_agent_rot = self.agent.facing
def update_all(self, force=False):
"""
Trigger a full refresh. This recreates the environment, agent and grid, as well as updates tile colours.
:param force: Force update.
:return: None
"""
if self.vacuum_env is not None or force:
# Ensure we stop the agent
if self.is_running:
self.stop()
self.create_sim()
self.make_env_frame()
self.refresh()
def grid_click_callback(self, x, y):
"""
Callback to manually mark a tile as clean, dirty or a wall. Outer walls cannot be changed.
Tile at coordinate (1, 1) cannot be a wall; only clean or dirty since this is where agents are spawned.
:param x: X-coordinate of tile
:param y: Y-coordinate of tile
:return: None
"""
w, h = self.grid_dims_getter()
current = self.vacuum_env.world[x][y]
if x != 0 and x != w - 1 and y != 0 and y != h - 1:
self.vacuum_env.world[x][y] = ENV_DIRTY if current == ENV_WALL or (
x == 1 and y == 1 and current == ENV_CLEAN
) else ENV_CLEAN if current == ENV_DIRTY else ENV_WALL
self.refresh_tile(x, y)
def create_selection_menu(self,
cb_on_select,
*opts,
always_trigger_onselect=False,
no_destructure=False,
pass_selection_to_callback=False):
"""
Quick way of creating a drop-down menu with a set of options and selection callbacks.
:param cb_on_select: Menu item selection event callback
:param opts: Menu options. These should be a list of two-element tuples where the first item is the label and the second is the corresponding value
:param always_trigger_onselect: Whether the selection callback should be triggered even if an already-selected item was selected
:param no_destructure: Whether option values should be destructured into the arguments of the callback
:param pass_selection_to_callback: Whether or not to pass the selected value to the selection callback function
:return: Getter function for the currently selected `value` (not label)
"""
options_dict = dict()
selection_active = StringVar(self.root)
selection_previous = StringVar(self.root)
for (key, value) in opts:
options_dict[key] = value
menu = OptionMenu(self.options_frame, selection_active,
*options_dict.keys())
def on_select(*args):
"""
Callback function for when a menu item is selected
:param args: Ignored arguments. Just contains the modified variable
:return: None
"""
# Check if a previously un-selected item was selected (or if the event should be processed anyway)
if selection_active.get() != selection_previous.get(
) or always_trigger_onselect:
selection_previous.set(selection_active.get())
# Call callback if one was specified
if cb_on_select:
if pass_selection_to_callback:
# Attempt to destructure parameter as much as possible
# This is just a lazy way of passing sets of arguments in less LOC
if (not no_destructure) and dir(
options_dict[selection_active.get(
)]).__contains__("__iter__"):
if type(options_dict[
selection_active.get()]) is dict:
cb_on_select(
**options_dict[selection_active.get()])
else:
cb_on_select(
*(options_dict[selection_active.get()]))
else:
cb_on_select(options_dict[selection_active.get()])
else:
cb_on_select()
# Set a callback for when variable changes value
selection_active.trace("w", on_select)
# Pack menu if a side as packed, else assume packing will be done elsewhere
menu.pack(side="left")
# Select a menu option. This also triggers an initial callback
selection_active.set(opts[0][0])
# Return a getter function to the active *value* (not key)
return lambda: options_dict[selection_active.get()]
def get_agent(self):
file_name, agent_class_name = self.agent_getter(
) # this is (file, name)
return make_agent(file_name, agent_class_name, self.append_log)
def create_sim(self):
"""
Create environment and agent and add agent to environment
"""
self.vacuum_env = VacuumEnvironment(*STANDARD_ENV_DIMS,
self.dirt_bias_getter(),
self.wall_bias_getter(),
self.gold_bias_getter(),
self.seed_getter())
self.agent = self.get_agent()
self.vacuum_env.add_thing(self.agent, DEFAULT_AGENT_LOCATION)
recon = self.recon_getter()
self.vacuum_env.prep_agent(self.agent, recon)
class ConcordanceSearchView(object):
_BACKGROUND_COLOUR = "#FFF" # white
# Colour of highlighted results
_HIGHLIGHT_WORD_COLOUR = "#F00" # red
_HIGHLIGHT_WORD_TAG = "HL_WRD_TAG"
_HIGHLIGHT_LABEL_COLOUR = "#C0C0C0" # dark grey
_HIGHLIGHT_LABEL_TAG = "HL_LBL_TAG"
# Percentage of text left of the scrollbar position
_FRACTION_LEFT_TEXT = 0.30
def __init__(self):
self.queue = q.Queue()
self.model = ConcordanceSearchModel(self.queue)
self.top = Tk()
self._init_top(self.top)
self._init_menubar()
self._init_widgets(self.top)
self.load_corpus(self.model.DEFAULT_CORPUS)
self.after = self.top.after(POLL_INTERVAL, self._poll)
def _init_top(self, top):
top.geometry("950x680+50+50")
top.title("NLTK Concordance Search")
top.bind("<Control-q>", self.destroy)
top.protocol("WM_DELETE_WINDOW", self.destroy)
top.minsize(950, 680)
def _init_widgets(self, parent):
self.main_frame = Frame(
parent, dict(background=self._BACKGROUND_COLOUR, padx=1, pady=1, border=1)
)
self._init_corpus_select(self.main_frame)
self._init_query_box(self.main_frame)
self._init_results_box(self.main_frame)
self._init_paging(self.main_frame)
self._init_status(self.main_frame)
self.main_frame.pack(fill="both", expand=True)
def _init_menubar(self):
self._result_size = IntVar(self.top)
self._cntx_bf_len = IntVar(self.top)
self._cntx_af_len = IntVar(self.top)
menubar = Menu(self.top)
filemenu = Menu(menubar, tearoff=0, borderwidth=0)
filemenu.add_command(
label="Exit", underline=1, command=self.destroy, accelerator="Ctrl-q"
)
menubar.add_cascade(label="File", underline=0, menu=filemenu)
editmenu = Menu(menubar, tearoff=0)
rescntmenu = Menu(editmenu, tearoff=0)
rescntmenu.add_radiobutton(
label="20",
variable=self._result_size,
underline=0,
value=20,
command=self.set_result_size,
)
rescntmenu.add_radiobutton(
label="50",
variable=self._result_size,
underline=0,
value=50,
command=self.set_result_size,
)
rescntmenu.add_radiobutton(
label="100",
variable=self._result_size,
underline=0,
value=100,
command=self.set_result_size,
)
rescntmenu.invoke(1)
editmenu.add_cascade(label="Result Count", underline=0, menu=rescntmenu)
cntxmenu = Menu(editmenu, tearoff=0)
cntxbfmenu = Menu(cntxmenu, tearoff=0)
cntxbfmenu.add_radiobutton(
label="60 characters",
variable=self._cntx_bf_len,
underline=0,
value=60,
command=self.set_cntx_bf_len,
)
cntxbfmenu.add_radiobutton(
label="80 characters",
variable=self._cntx_bf_len,
underline=0,
value=80,
command=self.set_cntx_bf_len,
)
cntxbfmenu.add_radiobutton(
label="100 characters",
variable=self._cntx_bf_len,
underline=0,
value=100,
command=self.set_cntx_bf_len,
)
cntxbfmenu.invoke(1)
cntxmenu.add_cascade(label="Before", underline=0, menu=cntxbfmenu)
cntxafmenu = Menu(cntxmenu, tearoff=0)
cntxafmenu.add_radiobutton(
label="70 characters",
variable=self._cntx_af_len,
underline=0,
value=70,
command=self.set_cntx_af_len,
)
cntxafmenu.add_radiobutton(
label="90 characters",
variable=self._cntx_af_len,
underline=0,
value=90,
command=self.set_cntx_af_len,
)
cntxafmenu.add_radiobutton(
label="110 characters",
variable=self._cntx_af_len,
underline=0,
value=110,
command=self.set_cntx_af_len,
)
cntxafmenu.invoke(1)
cntxmenu.add_cascade(label="After", underline=0, menu=cntxafmenu)
editmenu.add_cascade(label="Context", underline=0, menu=cntxmenu)
menubar.add_cascade(label="Edit", underline=0, menu=editmenu)
self.top.config(menu=menubar)
def set_result_size(self, **kwargs):
self.model.result_count = self._result_size.get()
def set_cntx_af_len(self, **kwargs):
self._char_after = self._cntx_af_len.get()
def set_cntx_bf_len(self, **kwargs):
self._char_before = self._cntx_bf_len.get()
def _init_corpus_select(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.var = StringVar(innerframe)
self.var.set(self.model.DEFAULT_CORPUS)
Label(
innerframe,
justify=LEFT,
text=" Corpus: ",
background=self._BACKGROUND_COLOUR,
padx=2,
pady=1,
border=0,
).pack(side="left")
other_corpora = list(self.model.CORPORA.keys()).remove(
self.model.DEFAULT_CORPUS
)
om = OptionMenu(
innerframe,
self.var,
self.model.DEFAULT_CORPUS,
command=self.corpus_selected,
*self.model.non_default_corpora()
)
om["borderwidth"] = 0
om["highlightthickness"] = 1
om.pack(side="left")
innerframe.pack(side="top", fill="x", anchor="n")
def _init_status(self, parent):
self.status = Label(
parent,
justify=LEFT,
relief=SUNKEN,
background=self._BACKGROUND_COLOUR,
border=0,
padx=1,
pady=0,
)
self.status.pack(side="top", anchor="sw")
def _init_query_box(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
another = Frame(innerframe, background=self._BACKGROUND_COLOUR)
self.query_box = Entry(another, width=60)
self.query_box.pack(side="left", fill="x", pady=25, anchor="center")
self.search_button = Button(
another,
text="Search",
command=self.search,
borderwidth=1,
highlightthickness=1,
)
self.search_button.pack(side="left", fill="x", pady=25, anchor="center")
self.query_box.bind("<KeyPress-Return>", self.search_enter_keypress_handler)
another.pack()
innerframe.pack(side="top", fill="x", anchor="n")
def search_enter_keypress_handler(self, *event):
self.search()
def _init_results_box(self, parent):
innerframe = Frame(parent)
i1 = Frame(innerframe)
i2 = Frame(innerframe)
vscrollbar = Scrollbar(i1, borderwidth=1)
hscrollbar = Scrollbar(i2, borderwidth=1, orient="horiz")
self.results_box = Text(
i1,
font=Font(family="courier", size="16"),
state="disabled",
borderwidth=1,
yscrollcommand=vscrollbar.set,
xscrollcommand=hscrollbar.set,
wrap="none",
width="40",
height="20",
exportselection=1,
)
self.results_box.pack(side="left", fill="both", expand=True)
self.results_box.tag_config(
self._HIGHLIGHT_WORD_TAG, foreground=self._HIGHLIGHT_WORD_COLOUR
)
self.results_box.tag_config(
self._HIGHLIGHT_LABEL_TAG, foreground=self._HIGHLIGHT_LABEL_COLOUR
)
vscrollbar.pack(side="left", fill="y", anchor="e")
vscrollbar.config(command=self.results_box.yview)
hscrollbar.pack(side="left", fill="x", expand=True, anchor="w")
hscrollbar.config(command=self.results_box.xview)
# there is no other way of avoiding the overlap of scrollbars while using pack layout manager!!!
Label(i2, text=" ", background=self._BACKGROUND_COLOUR).pack(
side="left", anchor="e"
)
i1.pack(side="top", fill="both", expand=True, anchor="n")
i2.pack(side="bottom", fill="x", anchor="s")
innerframe.pack(side="top", fill="both", expand=True)
def _init_paging(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.prev = prev = Button(
innerframe,
text="Previous",
command=self.previous,
width="10",
borderwidth=1,
highlightthickness=1,
state="disabled",
)
prev.pack(side="left", anchor="center")
self.next = next = Button(
innerframe,
text="Next",
command=self.__next__,
width="10",
borderwidth=1,
highlightthickness=1,
state="disabled",
)
next.pack(side="right", anchor="center")
innerframe.pack(side="top", fill="y")
self.current_page = 0
def previous(self):
self.clear_results_box()
self.freeze_editable()
self.model.prev(self.current_page - 1)
def __next__(self):
self.clear_results_box()
self.freeze_editable()
self.model.next(self.current_page + 1)
def about(self, *e):
ABOUT = "NLTK Concordance Search Demo\n"
TITLE = "About: NLTK Concordance Search Demo"
try:
from tkinter.messagebox import Message
Message(message=ABOUT, title=TITLE, parent=self.main_frame).show()
except:
ShowText(self.top, TITLE, ABOUT)
def _bind_event_handlers(self):
self.top.bind(CORPUS_LOADED_EVENT, self.handle_corpus_loaded)
self.top.bind(SEARCH_TERMINATED_EVENT, self.handle_search_terminated)
self.top.bind(SEARCH_ERROR_EVENT, self.handle_search_error)
self.top.bind(ERROR_LOADING_CORPUS_EVENT, self.handle_error_loading_corpus)
def _poll(self):
try:
event = self.queue.get(block=False)
except q.Empty:
pass
else:
if event == CORPUS_LOADED_EVENT:
self.handle_corpus_loaded(event)
elif event == SEARCH_TERMINATED_EVENT:
self.handle_search_terminated(event)
elif event == SEARCH_ERROR_EVENT:
self.handle_search_error(event)
elif event == ERROR_LOADING_CORPUS_EVENT:
self.handle_error_loading_corpus(event)
self.after = self.top.after(POLL_INTERVAL, self._poll)
def handle_error_loading_corpus(self, event):
self.status["text"] = "Error in loading " + self.var.get()
self.unfreeze_editable()
self.clear_all()
self.freeze_editable()
def handle_corpus_loaded(self, event):
self.status["text"] = self.var.get() + " is loaded"
self.unfreeze_editable()
self.clear_all()
self.query_box.focus_set()
def handle_search_terminated(self, event):
# todo: refactor the model such that it is less state sensitive
results = self.model.get_results()
self.write_results(results)
self.status["text"] = ""
if len(results) == 0:
self.status["text"] = "No results found for " + self.model.query
else:
self.current_page = self.model.last_requested_page
self.unfreeze_editable()
self.results_box.xview_moveto(self._FRACTION_LEFT_TEXT)
def handle_search_error(self, event):
self.status["text"] = "Error in query " + self.model.query
self.unfreeze_editable()
def corpus_selected(self, *args):
new_selection = self.var.get()
self.load_corpus(new_selection)
def load_corpus(self, selection):
if self.model.selected_corpus != selection:
self.status["text"] = "Loading " + selection + "..."
self.freeze_editable()
self.model.load_corpus(selection)
def search(self):
self.current_page = 0
self.clear_results_box()
self.model.reset_results()
query = self.query_box.get()
if len(query.strip()) == 0:
return
self.status["text"] = "Searching for " + query
self.freeze_editable()
self.model.search(query, self.current_page + 1)
def write_results(self, results):
self.results_box["state"] = "normal"
row = 1
for each in results:
sent, pos1, pos2 = each[0].strip(), each[1], each[2]
if len(sent) != 0:
if pos1 < self._char_before:
sent, pos1, pos2 = self.pad(sent, pos1, pos2)
sentence = sent[pos1 - self._char_before : pos1 + self._char_after]
if not row == len(results):
sentence += "\n"
self.results_box.insert(str(row) + ".0", sentence)
word_markers, label_markers = self.words_and_labels(sent, pos1, pos2)
for marker in word_markers:
self.results_box.tag_add(
self._HIGHLIGHT_WORD_TAG,
str(row) + "." + str(marker[0]),
str(row) + "." + str(marker[1]),
)
for marker in label_markers:
self.results_box.tag_add(
self._HIGHLIGHT_LABEL_TAG,
str(row) + "." + str(marker[0]),
str(row) + "." + str(marker[1]),
)
row += 1
self.results_box["state"] = "disabled"
def words_and_labels(self, sentence, pos1, pos2):
search_exp = sentence[pos1:pos2]
words, labels = [], []
labeled_words = search_exp.split(" ")
index = 0
for each in labeled_words:
if each == "":
index += 1
else:
word, label = each.split("/")
words.append(
(self._char_before + index, self._char_before + index + len(word))
)
index += len(word) + 1
labels.append(
(self._char_before + index, self._char_before + index + len(label))
)
index += len(label)
index += 1
return words, labels
def pad(self, sent, hstart, hend):
if hstart >= self._char_before:
return sent, hstart, hend
d = self._char_before - hstart
sent = "".join([" "] * d) + sent
return sent, hstart + d, hend + d
def destroy(self, *e):
if self.top is None:
return
self.top.after_cancel(self.after)
self.top.destroy()
self.top = None
def clear_all(self):
self.query_box.delete(0, END)
self.model.reset_query()
self.clear_results_box()
def clear_results_box(self):
self.results_box["state"] = "normal"
self.results_box.delete("1.0", END)
self.results_box["state"] = "disabled"
def freeze_editable(self):
self.query_box["state"] = "disabled"
self.search_button["state"] = "disabled"
self.prev["state"] = "disabled"
self.next["state"] = "disabled"
def unfreeze_editable(self):
self.query_box["state"] = "normal"
self.search_button["state"] = "normal"
self.set_paging_button_states()
def set_paging_button_states(self):
if self.current_page == 0 or self.current_page == 1:
self.prev["state"] = "disabled"
else:
self.prev["state"] = "normal"
if self.model.has_more_pages(self.current_page):
self.next["state"] = "normal"
else:
self.next["state"] = "disabled"
def fire_event(self, event):
# Firing an event so that rendering of widgets happen in the mainloop thread
self.top.event_generate(event, when="tail")
def mainloop(self, *args, **kwargs):
if in_idle():
return
self.top.mainloop(*args, **kwargs)
class AnalysisOptionsInputForm(Frame):
# Initialize the GUI
def __init__(self, root, prospectorFormObject):
Frame.__init__(self, root)
root.title("Choose Read Stat and Demultiplexing options")
self.parent = root
# keep a handle on the parent object. I can specify configuration using this handle
self.prospectorFormObject = prospectorFormObject
# To define the exit behavior. Save and exit.
self.parent.protocol('WM_DELETE_WINDOW', self.saveOptions)
# Define the return behavior. Same as "close window" etc
root.bind('<Return>', self.returnFunction)
# This window should not be resizeable. I guess.
self.parent.resizable(width=False, height=False)
#Standard Inputs widths for the form elements
self.formInputWidth = 10
self.labelInputWidth = 60
self.makeAnalysisGeneralOptionsFrame()
self.makeDemultiplexInstructionsFrame()
self.makeDemultiplexOptionsFrame()
self.makeLengthAndQualityFilterFrame()
self.makeSaveOptionsFrame()
self.makeBlastInstructionsFrame()
self.makeBlastOptionsFrame()
self.loadOptions()
def makeAnalysisGeneralOptionsFrame(self):
self.generalOptionsFrame = Frame(self)
# TODO: Add parameters for # of threads.
# Other generic parameters?
# TODO Should I worry about the # of ram the user is using? I have never ran into the limit before.
self.generalOptionsFrame.pack()
def makeDemultiplexInstructionsFrame(self):
self.instructionsFrame = Frame(self)
self.instructionText = StringVar()
self.instructionText.set(
'\nOptions: Read statistics and Demultiplexing.\n')
Label(self.instructionsFrame,
width=85,
height=3,
textvariable=self.instructionText).pack()
self.instructionsFrame.pack()
def makeDemultiplexOptionsFrame(self):
# Demultiplexing
self.demultiplexOptionFrame = Frame(self)
self.demultiplexInstrStringVar = StringVar()
self.demultiplexInstrStringVar.set(
'Demultiplex the reads, using 96x barcode kit:')
self.demultiplexInstrLabel = Label(
self.demultiplexOptionFrame,
width=self.labelInputWidth,
height=1,
textvariable=self.demultiplexInstrStringVar).grid(row=0, column=0)
self.chooseDemultiplexIntVar = IntVar()
#self.chooseDemultiplexIntVar.set(2)
Radiobutton(self.demultiplexOptionFrame,
text="Yes",
variable=self.chooseDemultiplexIntVar,
value=1).grid(row=0, column=1)
Radiobutton(self.demultiplexOptionFrame,
text="No",
variable=self.chooseDemultiplexIntVar,
value=2).grid(row=0, column=2)
self.demultiplexOptionFrame.pack()
def makeLengthAndQualityFilterFrame(self):
# Length and Quality
self.lengthParamsFrame = Frame(self)
self.lengthParamsStringVar = StringVar()
self.lengthParamsStringVar.set('Minimum & Maximum Read Length:')
self.demultiplexInstrLabel = Label(
self.lengthParamsFrame,
width=self.labelInputWidth,
height=1,
textvariable=self.lengthParamsStringVar).grid(row=0, column=0)
self.inputMinLength = StringVar()
self.inputMinLengthEntry = Entry(
self.lengthParamsFrame,
width=self.formInputWidth,
textvariable=self.inputMinLength).grid(row=0, column=1)
self.inputMaxLength = StringVar()
self.inputMaxLengthEntry = Entry(
self.lengthParamsFrame,
width=self.formInputWidth,
textvariable=self.inputMaxLength).grid(row=0, column=2)
self.qualityParamsStringVar = StringVar()
self.qualityParamsStringVar.set('Minimum & Maximum Quality (Q-Score):')
self.demultiplexInstrLabel = Label(
self.lengthParamsFrame,
width=self.labelInputWidth,
height=1,
textvariable=self.qualityParamsStringVar).grid(row=1, column=0)
self.inputMinQuality = StringVar()
self.inputMinLengthEntry = Entry(
self.lengthParamsFrame,
width=self.formInputWidth,
textvariable=self.inputMinQuality).grid(row=1, column=1)
self.inputMaxQuality = StringVar()
self.inputMaxLengthEntry = Entry(
self.lengthParamsFrame,
width=self.formInputWidth,
textvariable=self.inputMaxQuality).grid(row=1, column=2)
self.lengthParamsFrame.pack()
def makeBlastInstructionsFrame(self):
self.blastInstructionsFrame = Frame(self)
self.blastInstructionText = StringVar()
self.blastInstructionText.set(
'\nOptions: Blast Sorting.\n' +
'What genes do you want to sort against?\n' +
'(More genes = more analysis time)')
Label(self.blastInstructionsFrame,
width=85,
height=5,
textvariable=self.blastInstructionText).pack()
self.blastInstructionsFrame.pack()
def makeBlastOptionsFrame(self):
self.blastOptionsFrame = Frame(self)
# TODO: I have been adding genes as we use them. Should I add more?
# HLA Allele Analysis makes these reference files now.
# I can add DMA DMB DOA DOB DPA1 DPB1 DQA1 DQB1 DRA DRB1 DRB3 DRB4 DRB5
# And E and F
self.geneAIntVar = IntVar()
Checkbutton(self.blastOptionsFrame,
text="HLA-A",
variable=self.geneAIntVar).grid(row=0, sticky=W)
self.geneBIntVar = IntVar()
Checkbutton(self.blastOptionsFrame,
text="HLA-B",
variable=self.geneBIntVar).grid(row=1, sticky=W)
self.geneCIntVar = IntVar()
Checkbutton(self.blastOptionsFrame,
text="HLA-C",
variable=self.geneCIntVar).grid(row=2, sticky=W)
self.geneEIntVar = IntVar()
Checkbutton(self.blastOptionsFrame,
text="HLA-E",
variable=self.geneEIntVar).grid(row=3, sticky=W)
self.geneDRAIntVar = IntVar()
Checkbutton(self.blastOptionsFrame,
text="HLA-DRA",
variable=self.geneDRAIntVar).grid(row=4, sticky=W)
self.geneDQA1IntVar = IntVar()
Checkbutton(self.blastOptionsFrame,
text="HLA-DQA1",
variable=self.geneDQA1IntVar).grid(row=5, sticky=W)
self.geneDQB1IntVar = IntVar()
Checkbutton(self.blastOptionsFrame,
text="HLA-DQB1",
variable=self.geneDQB1IntVar).grid(row=6, sticky=W)
self.geneDRB1IntVar = IntVar()
Checkbutton(self.blastOptionsFrame,
text="HLA-DRB1",
variable=self.geneDRB1IntVar).grid(row=7, sticky=W)
self.blastOptionsFrame.pack()
def makeSaveOptionsFrame(self):
# Make a frame for the save options button.
self.saveOptionsFrame = Frame(self)
Button(self.saveOptionsFrame,
text='Save Options',
command=self.saveOptions).grid(row=0, column=0)
self.saveOptionsFrame.pack()
# I needed a function for the return keypress to latch onto.
# It is just a wrapper for the saveOptions method.
def returnFunction(self, event):
self.saveOptions()
def loadOptions(self):
# Read the configuration file.
loadConfigurationFile()
#TODO: Number of threads. Configure this.
if getConfigurationValue('demultiplex_reads') is not None:
self.chooseDemultiplexIntVar.set(
int(getConfigurationValue('demultiplex_reads')))
if getConfigurationValue('min_length') is not None:
self.inputMinLength.set(getConfigurationValue('min_length'))
if getConfigurationValue('max_length') is not None:
self.inputMaxLength.set(getConfigurationValue('max_length'))
if getConfigurationValue('min_quality') is not None:
self.inputMinQuality.set(getConfigurationValue('min_quality'))
if getConfigurationValue('max_quality') is not None:
self.inputMaxQuality.set(getConfigurationValue('max_quality'))
if getConfigurationValue('analyze_hla_a') is not None:
self.geneAIntVar.set(getConfigurationValue('analyze_hla_a'))
if getConfigurationValue('analyze_hla_b') is not None:
self.geneBIntVar.set(getConfigurationValue('analyze_hla_b'))
if getConfigurationValue('analyze_hla_c') is not None:
self.geneCIntVar.set(getConfigurationValue('analyze_hla_c'))
if getConfigurationValue('analyze_hla_e') is not None:
self.geneEIntVar.set(getConfigurationValue('analyze_hla_e'))
if getConfigurationValue('analyze_hla_dra') is not None:
self.geneDRAIntVar.set(getConfigurationValue('analyze_hla_dra'))
if getConfigurationValue('analyze_hla_dqa1') is not None:
self.geneDQA1IntVar.set(getConfigurationValue('analyze_hla_dqa1'))
if getConfigurationValue('analyze_hla_dqb1') is not None:
self.geneDQB1IntVar.set(getConfigurationValue('analyze_hla_dqb1'))
if getConfigurationValue('analyze_hla_drb1') is not None:
self.geneDRB1IntVar.set(getConfigurationValue('analyze_hla_drb1'))
def saveOptions(self):
print('Saving Options')
#TODO: Number of threads. Configure this.
assignConfigurationValue('demultiplex_reads',
str(self.chooseDemultiplexIntVar.get()))
assignConfigurationValue('min_length', self.inputMinLength.get())
assignConfigurationValue('max_length', self.inputMaxLength.get())
assignConfigurationValue('min_quality', self.inputMinQuality.get())
assignConfigurationValue('max_quality', self.inputMaxQuality.get())
assignConfigurationValue('analyze_hla_a', (self.geneAIntVar.get()))
assignConfigurationValue('analyze_hla_b', (self.geneBIntVar.get()))
assignConfigurationValue('analyze_hla_c', (self.geneCIntVar.get()))
assignConfigurationValue('analyze_hla_e', (self.geneEIntVar.get()))
assignConfigurationValue('analyze_hla_dra', (self.geneDRAIntVar.get()))
assignConfigurationValue('analyze_hla_dqa1',
(self.geneDQA1IntVar.get()))
assignConfigurationValue('analyze_hla_dqb1',
(self.geneDQB1IntVar.get()))
assignConfigurationValue('analyze_hla_drb1',
(self.geneDRB1IntVar.get()))
writeConfigurationFile()
self.parent.destroy()
def create_voting_screen(player_names,
vote_function,
player_message="Time to vote",
reset_at_beggining=True,
reset_at_end=True):
'''voting screen populating function'''
global just_voted, title_label_refernce
while window_open is False:
pass
player_window = WindowSingleton.get_instance().window
if reset_at_beggining is False:
just_voted = False
player_window.title(player_message)
title_label_refernce.configure(text=player_message)
while (not just_voted) and window_open:
pass
if reset_at_end is True:
WindowSingleton.reset_instance()
return
WindowSingleton.reset_instance()
background_color = ANTI_FLASH_WHITE
player_window.configure(background=background_color)
player_window.title(player_message)
logs_frame = Frame(player_window)
if player_message != "Chose a game to play!":
logs_frame.pack(side=LEFT)
scrollbar = Scrollbar(player_window)
scrollbar.pack(side=RIGHT)
logs_label = Listbox(logs_frame,
height=60,
width=30,
font=("bold", 10),
background=BROWN,
foreground=ANTI_FLASH_WHITE,
yscrollcommand=scrollbar.set)
for individual_log in log_history:
logs_label.insert(END, individual_log)
logs_label.pack(side=TOP)
game_frame = Frame(player_window)
game_frame.configure(background=background_color)
game_frame.pack(side=LEFT)
title_frame = Frame(game_frame)
title_frame.configure(background=background_color)
title_frame.pack()
text_label = Label(title_frame,
text=player_message,
width=40,
font=("bold", 20),
bg=UMBER,
fg=ANTI_FLASH_WHITE,
anchor="w",
justify="center")
title_label_refernce = text_label
text_label.pack()
top_frame = Frame(game_frame)
top_frame.pack()
top_frame.configure(background=background_color)
bottom_frame = Frame(game_frame)
bottom_frame.pack()
bottom_frame.configure(background=background_color)
number_of_players = len(player_names)
for i in range(0, number_of_players):
player_name = player_names[i]
if i < number_of_players / 2:
curr_frame = top_frame
else:
curr_frame = bottom_frame
vote_button = Button(curr_frame,
bg=SPICY_MIX,
font=("Courier", 10),
fg=ANTI_FLASH_WHITE,
height=20,
width=17,
text=player_name,
command=vote_function(player_name))
vote_button.pack(side=LEFT)
just_voted = False
while (not just_voted) and window_open:
pass
if reset_at_end is True:
WindowSingleton.reset_instance()
"""App entry point"""
# System imports
from tkinter import (Frame, LEFT, X)
from front import main
if __name__ == "__main__":
window = main.MainWindow()
root = window.create_window()
root.configure(bg="black")
publication_frame = Frame(root, bg="red")
publication_frame.pack(side=LEFT)
article_frame = Frame(root)
article_frame.pack()
root.mainloop()
booking.connect((serverIP,7777))
booking.send(str(chr(i+65)+str(j)).encode())
ack=booking.recv(1024)
print(ack)
booking.close()
except timeout:
server=bully()
if server:
test = socket(AF_INET, SOCK_DGRAM)
test.connect(("8.8.8.8", 80))
th.start_new_thread(serve,(test.getsockname()[0],))
test.close()
'''
#UI code
root = Tk()
root.title("Book Ticket Online")
root.geometry("720x360")
f = Frame(root)
b = []
for i in range(0, 4):
for j in range(0, 7):
b.append(
Button(f,
text=chr(i + 65) + str(j),
height=2,
width=6,
command=lambda: book(i, j)).grid(row=i, column=j))
f.pack()
root.mainloop()
multiprocessing.freeze_support()
#Super cool json file
with open('./json_settings.json', 'r') as settingsfile:
jsondata = settingsfile.read()
loadedjsonsettings = json.loads(jsondata)
settingsfile.close()
#beutiful gui
root = Tk()
root.title('Open_Clicker ' + loadedjsonsettings['about']['displayVersion'])
root.config(bg='#0F151D')
root.resizable(0, 0)
root.tk.call('wm', 'iconphoto', root._w, PhotoImage(file='./favicon.png'))
#high quality 10/10 button shit for the modern skid
buttonFrame = Frame(root, bg='#0F151D')
buttonFrame.pack(side=LEFT)
#Start/Stop button
toggleButtonImage = PhotoImage(file='./icons/general/play.png')
toggleButton = Button(
buttonFrame,
command=lambda: toggle(lcbbuttonvar.get(), mcbbuttonvar.get(),
rcbbuttonvar.get(), keyboardentry.get(),
cpsvalue.get(), loadedjsonsettings),
image=toggleButtonImage,
bg='#2B2D31',
fg='#C96C00',
activebackground='#1E1B15',
activeforeground='#066D9F')
toggleButton.image = toggleButtonImage
toggleButton.pack(anchor=E)
toggleButtonTTP = toolTip.CreateToolTip(
}
theme_choice = StringVar()
theme_choice.set('Default')
for k in sorted(color_schemes):
themes_menu.add_radiobutton(label=k, variable=theme_choice)
menu_bar.add_cascade(label='View', menu=view_menu)
about_menu = Menu(menu_bar, tearoff=0)
about_menu.add_command(label='About')
about_menu.add_command(label='Help')
menu_bar.add_cascade(label='About', menu=about_menu)
root.config(menu=menu_bar)
shortcut_bar = Frame(root, height=25, background='light sea green')
shortcut_bar.pack(expand='no', fill='x')
line_number_bar = Text(root, width=4, padx=3, takefocus=0, border=0,
background='khaki', state='disabled', wrap='none')
line_number_bar.pack(side='left', fill='y')
content_text = Text(root, wrap='word', undo=1)
content_text.pack(expand='yes', fill='both')
scroll_bar = Scrollbar(content_text)
content_text.configure(yscrollcommand=scroll_bar.set)
scroll_bar.config(command=content_text.yview)
scroll_bar.pack(side='right', fill='y')
# Shortcut key bindings for this iteration
content_text.bind('<Control-N>', new_file)
content_text.bind('<Control-n>', new_file)
content_text.bind('<Control-O>', open_file)
class Session:
def __init__(self, name, server):
self.name = name
self.server = server
self.clients = {}
self.scoreboard = {}
self.quiz_state = 0
self.is_accepting_answer = False
def add_client(self, conn, name):
if name in self.clients:
conn.send(
'{ "data": false, "error": "Nama panggilan sudah dipakai oleh pengguna lain" }'
.encode("UTF-8"))
conn.close()
else:
self.clients[conn] = name
self.scoreboard[name] = 0
conn.send('{ "data": true, "error": null }'.encode("UTF-8"))
def __get_status(self):
switcher = {
0: ("Open", "DodgerBlue2", "Start"),
1: ("Running", "limegreen", "Running"),
2: ("Finished", "red2", "Delete")
}
return switcher.get(self.quiz_state)
def bind_gui(self, master):
self.session_frame = Frame(master)
self.session_frame.pack()
name_label = Label(self.session_frame, text=self.name)
name_label.grid(row=0, column=0, sticky="NSEW")
self.session_frame.grid_columnconfigure(0, weight=5)
status_frame = Frame(self.session_frame)
status_frame.grid(row=0, column=1, sticky="NSEW")
self.session_frame.grid_columnconfigure(0, weight=2)
label = self.__get_status()
self.status_label = Label(status_frame, text=label[0], fg=label[1])
self.status_button = Button(status_frame,
text=label[2],
command=self.__start_quiz)
detail_button = Button(status_frame,
text="Status",
command=self.__show_status)
self.status_label.grid(row=0, column=0, sticky="NSEW")
self.status_button.grid(row=0, column=1, sticky="NSEW")
detail_button.grid(row=0, column=2, sticky="NSEW")
def __start_quiz(self):
self.quiz_state = 1
label = self.__get_status()
self.status_label["text"] = label[0]
self.status_label["fg"] = label[1]
self.status_button["text"] = label[2]
self.status_button["fg"] = "light grey"
self.status_button["state"] = "disabled"
if len(self.clients) > 0:
quiz_loop = Thread(target=self.__begin_quiz_loop, daemon=True)
quiz_loop.start()
else:
self.stop_quiz()
def __begin_quiz_loop(self):
self.number = 0
for conn in self.clients:
try:
conn.send(
'{ "data": "Kuis akan dimulai dalam waktu 5 detik, selamat berjuang!", "error": null }'
.encode("UTF-8"))
except ConnectionResetError:
name = self.clients[conn]
del self.clients[conn]
del self.scoreboard[name]
if len(self.clients) == 0:
self.stop_quiz()
return
sleep(5)
self.session_soal = deepcopy(file_soal)
shuffle(self.session_soal)
while self.number < len(self.session_soal):
self.is_accepting_answer = True
self.answers = {} # string-tuple = (jawaban, waktu)
soal = {
"soal": self.session_soal[self.number]["soal"] +
" (anda memiliki waktu 1 menit untuk menjawab)",
"pilihan": self.session_soal[self.number]["pilihan"]
}
payload = self.__serialize({
"data": self.__serialize(soal),
"error": None
}).encode("UTF-8")
listeners = []
for conn in self.clients:
try:
conn.send(payload)
listener = Thread(target=self.__ask_answer,
args=(conn, ),
daemon=True)
listeners.append(listener)
except ConnectionResetError:
del self.clients[conn]
continue
for listener in listeners:
listener.start()
sleep(60) # Ubah waktu disini
self.is_accepting_answer = False
self.__update_scoreboard()
self.__post_scoreboard()
sleep(3)
self.number += 1
result = "Kuis Selesai!\nPemenang dari kuis adalah: "
winner = []
for client in self.scoreboard:
winner.append((client, self.scoreboard[client]))
winner = sorted(winner, key=lambda x: x[1], reverse=True)
result += winner[0][0] + " dengan skor " + str(winner[0][1])
payload = self.__serialize({
"data": result,
"error": None
}).encode("UTF-8")
for conn in self.clients:
conn.send(payload)
conn.close()
self.stop_quiz()
def __ask_answer(self, conn):
while self.is_accepting_answer == True:
try:
answer = conn.recv(1024).decode("UTF-8")
client = self.clients[conn]
if client in self.answers:
conn.send(
'{ "data": null, "error": "Anda telah menjawab untuk soal ini!" }'
.encode("UTF-8"))
self.answers[client] = (answer, time())
break
except ConnectionResetError:
del self.clients[conn]
continue
def __update_scoreboard(self):
answers = []
for answer in self.answers:
answers.append(
(self.answers[answer][0], self.answers[answer][1], answer))
answers = sorted(answers, key=lambda x: x[1])
cur_score = len(self.clients)
for answer in answers:
if answer[0].lower() == self.session_soal[
self.number]["jawaban"].lower():
self.scoreboard[answer[2]] += cur_score
cur_score -= 1
def __post_scoreboard(self):
announcements = "Jawaban benar: " + self.session_soal[
self.number]["jawaban"] + ".\n"
announcements += "Score saat ini:"
winner = []
for client in self.scoreboard:
winner.append((client, self.scoreboard[client]))
winner = sorted(winner, key=lambda x: x[1], reverse=True)
for client in winner:
announcements += "\n" + client[0] + ": " + str(client[1])
announcements += "\nSoal selanjutnya dikirim dalam 3 detik lagi"
announcements = announcements
for conn in self.clients:
try:
verdict = ""
name = self.clients[conn]
if name in self.answers:
verdict += "Jawaban anda: " + self.answers[name][0]
else:
verdict += "Anda tidak menjawab dalam batas waktu yang telah ditentukan"
verdict += "\n"
payload = self.__serialize({
"data": verdict + announcements,
"error": None
}).encode("UTF-8")
conn.send(payload)
except ConnectionResetError:
del self.clients[conn]
continue
def stop_quiz(self):
self.quiz_state = 2
label = self.__get_status()
self.status_label["text"] = label[0]
self.status_label["fg"] = label[1]
self.status_button["text"] = label[2]
self.status_button["state"] = "normal"
self.status_button["fg"] = "black"
self.status_button["command"] = self.__delete_session
def __delete_session(self):
self.session_frame.destroy()
self.server.delete_session(self.name)
def __serialize(self, obj):
return dumps(obj, indent=4)
def __show_status(self):
label = "Jumlah klien yang terhubung dengan sesi ini: " + str(
len(self.scoreboard))
if len(self.scoreboard) > 0:
label += "\n"
label = "Daftar klien beserta skor saat ini:"
for client in self.scoreboard:
label += "\n" + client + ": " + str(self.scoreboard[client])
messagebox.showinfo("Current Status", label)
def make_env_frame(self):
"""
Create the grid layout representing the state of the vacuum environment
:return: None
"""
width, height = STANDARD_ENV_DIMS
previous_width, previous_height = (self.previous_dims or (-1, -1))
if (width != previous_width
or height != previous_height) and self.grid:
self.grid[self.marked_agent_pos[0]][
self.marked_agent_pos[1]].configure(image=self.blank_img)
padx = 5 if width > 15 else 8
pady = 2 if height > 15 else 4
def make_callback(x, y):
"""
Create a callback function for the given coordinate
:param x: X-coordinate
:param y: Y-coordinate
:return: Callback function for the given coordinate
"""
return lambda: self.grid_click_callback(x, y)
def make_button(x, y, container_frame):
"""
Shorthand for creating a button in the tile grid
:param x: X-coordinate of button
:param y: Y-coordinate of button
:param container_frame: Frame to hold button
:return: Reference to button
"""
nonlocal padx
nonlocal pady
btn = Button(container_frame,
text="",
height=self.agent_btn_dims,
width=self.agent_btn_dims,
padx=padx,
pady=pady,
image=self.blank_img)
btn.pack(side="right")
btn.config(command=make_callback(x, y))
return btn
# Create an unpopulated button ref grid (filled with None for debug purposes)
grid = [[None for _ in range(height)] for _ in range(width)]
frame_pad = 0 if height > 30 else 8 * (30 - height)
if self.grid is None:
frame = Frame(self.host_frame, pady=frame_pad, padx=0)
for y in range(height - 1, -1, -1):
row_frame = Frame(frame)
for x in range(width - 1, -1, -1):
grid[x][y] = make_button(x, y, row_frame)
row_frame.pack(side="bottom")
frame.pack(side="bottom")
self.grid_frame = frame
else:
# Optimization to hopefully be a bit nicer on GC (if nothing else)
for y in range(height - 1, -1, -1):
rel_y = height - 1 - y
row_frame = Frame(
self.grid_frame
) if rel_y >= previous_height else self.grid[0][previous_height
- 1 -
rel_y].master
for x in range(width - 1, -1, -1):
rel_x = width - 1 - x
grid[x][y] = self.grid[previous_width - 1 - rel_x][
previous_height - 1 -
rel_y] if rel_x < previous_width and rel_y < previous_height else make_button(
x, y, row_frame)
if rel_x < previous_width and rel_y < previous_height:
grid[x][y].configure(padx=padx, pady=pady)
grid[x][y].config(command=make_callback(x, y))
row_frame.pack(side="bottom")
for y in range(previous_height):
if previous_height - y > height:
self.grid[0][y].master.pack_forget()
continue
for x in range(previous_width):
if previous_width - x > width:
self.grid[x][y].pack_forget()
self.grid_frame.configure(pady=frame_pad, width=frame_pad)
self.grid_frame.pack(side="bottom")
# Update grid
self.grid = grid
self.previous_dims = (width, height)
self.draw_agent()
imglabel.pack()
root.pack()
def show(event):
img = ImageTk.PhotoImage(Image.open("A:/mario.jpg"))
imglabel = Label(root, image=img)
imglabel.pack()
root.pack()
#ento image kanabadatle kani empty di paste avtundi root window lo paste avtundaa elaaa switch control cheyu chupi naku\
root = Tk()
fr = Frame(root)
fr.pack()
b0 = Button(fr, text="choose image")
b0.bind("<Button-1>", ask)
b1 = Button(fr, text="brightness")
b1.bind("<Button-1>", brighten)
b2 = Button(fr, text="split")
b2.bind("<Button-1>", split)
b3 = Button(fr, text="sharpness")
b3.bind("<Button-1>", sharpen)
b4 = Button(fr, text="contrast")
b4.bind("<Button-1>", contrast)
b5 = Button(fr, text="show output image")
b5.bind("<Button-1>", show)
b0.pack(side=TOP)
b1.pack(side=TOP)
b2.pack(side=TOP)
root = Tk()
root.title("Text Editor")
root.geometry("1000x700")
# Text Editor Label
Label(root, text="Text Editor", font="Helvetica 20 bold").pack(pady=20)
# Main Text Box
editor = Text(root, height=30, width=100, bd=3)
editor.pack()
# Button Frame
button_frame = Frame(root)
button_frame.pack()
# Open Button
Button(
button_frame,
text="OPEN",
height=2,
width=15,
font="Helvetica 15 bold",
bd=3,
command=open_func,
).pack(pady=20, padx=20, side=LEFT)
# Save Button
Button(
button_frame,
class App(Tk):
def __init__(self, testing_mode, *args, **kwargs):
Tk.__init__(self, *args, **kwargs)
icon_filepath = 'img/budget.ico'
self.wm_iconbitmap(icon_filepath)
self.iconbitmap(default=icon_filepath)
self.resizable(False, False)
self.set_style()
self.testing_mode = testing_mode
self.title("Budget Transaction Processor")
self.backend = Backend()
self.container = Frame(self)
self.container.pack(side="top",
fill="both",
expand=True,
padx=15,
pady=15)
self.container.grid_rowconfigure(0, weight=1)
self.container.grid_columnconfigure(0, weight=1)
self.home_frame = HomeFrame(self.container, self)
self.home_frame.grid(row=0, column=0, sticky='nsew')
self.file_select_frame = FileSelectFrame(self.container, self)
self.file_select_frame.grid(row=0, column=0, sticky='nsew')
self.create_menubar()
self.file_select_frame.tkraise()
if self.testing_mode:
self.file_select_frame.submit()
def show_frame(self, name):
if name == 'home':
self.home_frame.tkraise()
elif name == 'file_select':
self.file_select_frame.tkraise()
else:
raise ValueError("name must be either 'home' or 'file_select'")
def create_menubar(self):
self.menu = Menu(self)
self.config(menu=self.menu)
self.file_menu = Menu(self.menu, tearoff=0)
self.file_menu.add_command(
label="Select File Screen",
command=lambda: self.show_frame('file_select'))
self.file_menu.add_separator()
self.file_menu.add_command(label="Exit",
command=lambda: self.destroy())
self.menu.add_cascade(label="File", menu=self.file_menu)
self.insert_menu = Menu(self.menu, tearoff=0)
self.insert_menu.add_command(
label="Category",
command=lambda: CategoryEntryPopup(self.home_frame))
self.insert_menu.add_command(
label="Vendor", command=lambda: VendorEntryPopup(self.home_frame))
self.menu.add_cascade(label="Insert", menu=self.insert_menu)
def set_style(self):
style = ttk.Style(self)
style.configure('.', font=('Arial', 9)) # set root style font
style.configure(
'DropDown.TCombobox',
borderwidth=1,
bordercolor='black',
relief='solid',
)
style.configure('DropDown.TCombobox.textarea', font=('Arial', 9))
style.configure('DropDown.TCombobox.border', relief='solid')
style.configure('TableRow.TLabel',
height=1,
bd=1,
relief="solid",
background="white",
highlightbackground="blue",
padding=(1, 1, 0, 0))
style.configure('TableHeader.TLabel',
foreground="white",
background="dark slate gray",
bd=1,
relief="flat",
padding=(1, 1, 0, 0))
style.configure('Submit.TButton', font=('Arial', 8))
style.configure('Title.TLabel',
font=("Arial", 18),
padding=(0, 15),
anchor='center')
style.configure('SelectFile.TButton', font=('Arial', 8), padding=5)
from tkinter import Tk, Frame, Menu
from tkinter import TOP, RIGHT, LEFT, X, Y, BOTH
# Frame https://www.tutorialspoint.com/python/tk_frame.htm
# pack() https://www.tutorialspoint.com/python/tk_pack.htm
# Menu https://www.tutorialspoint.com/python/tk_menu.htm
# Init
root = Tk()
root.title("Layout Example")
root.geometry('800x640')
# Layout
header = Frame(root, height=100, bg='red')
header.pack(side=TOP, fill=X)
appcontent = Frame(root, bg='blue')
appcontent.pack(fill=BOTH, expand=1)
# Extended Layout
right = Frame(appcontent, bg='green')
right.pack(side=RIGHT, fill=BOTH, expand=1)
middle = Frame(appcontent, bg='yellow')
middle.pack(side=RIGHT, fill=BOTH, expand=1)
left = Frame(appcontent, bg='purple')
left.pack(side=RIGHT, fill=BOTH, expand=1)
class Wall(object):
MIN_RED = MIN_GREEN = MIN_BLUE = 0x0
MAX_RED = MAX_GREEN = MAX_BLUE = 0xFF
PIXEL_WIDTH = 50
def __init__(self, width, height):
#width and height default defined in run.py; can override w/ args
self.width = width
self.height = height
self._tk_init()
#Create list object of pixels: (0, 0, 0) tuple for total number of pixels
self.pixels = [(0, 0, 0) for i in range(self.width * self.height)]
def _tk_init(self):
self.root = Tk()
#Create new window (canvas), title it with dimensions
self.root.title("ColorWall %d x %d" % (self.width, self.height))
#Can it be resized? Two arguments for height & width. False = No; True = Yes
self.root.resizable(False, False)
self.frame = Frame(self.root, bd=5, relief=SUNKEN)
self.frame.pack()
self.canvas = Canvas(self.frame,
width=self.PIXEL_WIDTH * self.width,
height=self.PIXEL_WIDTH * self.height,
bd=0,
highlightthickness=0)
self.canvas.pack()
self.root.update()
def set_pixel(self, x, y, hsv):
self.pixels[self.width * y + x] = hsv
def get_pixel(self, x, y):
return self.pixels[self.width * y + x]
def draw(self):
self.canvas.delete(ALL)
for x in range(len(self.pixels)):
x_0 = (x % self.width) * self.PIXEL_WIDTH
#Fix floor division for Python 3
y_0 = (x // self.width) * self.PIXEL_WIDTH
x_1 = x_0 + self.PIXEL_WIDTH
y_1 = y_0 + self.PIXEL_WIDTH
hue = "#%02x%02x%02x" % self._get_rgb(self.pixels[x])
self.canvas.create_rectangle(x_0, y_0, x_1, y_1, fill=hue)
self.canvas.update()
def clear(self):
for i in range(self.width * self.height):
self.pixels[i] = (0, 0, 0)
def _hsv_to_rgb(self, hsv):
rgb = colorsys.hsv_to_rgb(*hsv)
red = self.MAX_RED * rgb[0]
green = self.MAX_GREEN * rgb[1]
blue = self.MAX_BLUE * rgb[2]
return (red, green, blue)
def _get_rgb(self, hsv):
red, green, blue = self._hsv_to_rgb(hsv)
red = int(float(red) / (self.MAX_RED - self.MIN_RED) * 0xFF)
green = int(float(green) / (self.MAX_GREEN - self.MIN_GREEN) * 0xFF)
blue = int(float(blue) / (self.MAX_BLUE - self.MIN_BLUE) * 0xFF)
return (red, green, blue)
menubar = Menu(top)
menubar.add_command(label="生成封面", command=runCover)
menubar.add_command(label="转码", command=runChange)
top['menu'] = menubar
'''
布局
'''
frmLeft = LabelFrame(width=300, height=100, text='状态', labelanchor='nw')
frmSelectPath = Frame(width=100, height=100)
frmTop = Frame(width=100, height=100)
frmBottom = LabelFrame(width=500, text='下载列表', height=400)
frmLeft.pack(side='left', fill='y', padx='5', pady='5')
frmSelectPath.pack(side='top', fill='x', padx='5', pady='5')
frmTop.pack(side='top', fill='x', padx='5', pady='5')
frmBottom.pack(side='right', fill=BOTH, expand='yes', padx='5', pady='5')
'''
控件
'''
clupValue = IntVar()
clipButton = Checkbutton(frmLeft,
text="剪贴板",
onvalue=1,
offvalue=0,
height=1,
variable=clupValue)
clipButton.pack(side='top', expand='no', fill=None)
menu = Menu(root) root.config(menu = menu) fileMenu = Menu(menu) menu.add_cascade(label = "File", menu = fileMenu) fileMenu.add_command(label = "New", command = newFile) fileMenu.add_command(label = "Open", command = openFile) fileMenu.add_command(label = "Save", command = saveFile) fileMenu.add_command(label = "Find", command = findInFile) fileMenu.add_separator() fileMenu.add_command(label = "Exit", command = exitEditor) helpMenu = Menu(menu) menu.add_cascade(label = "Help", menu = helpMenu) helpMenu.add_command(label = "Help", command = help) helpMenu.add_command(label = "About", command = about) actionMenu = Menu(menu) menu.add_cascade(label = "Action", menu = actionMenu) actionMenu.add_command(label = "Shell", command = shell) actionMenu.add_command(label = "Run", command = runFile) left.pack(side="left", expand=True, fill="both") right.pack(side="right", expand=True, fill="both") # Keep window open root.mainloop()
class Game():
def __init__(self, root):
self.root = root
self.gameFrame = ""
self.interFrame = ""
def initGameCallBack(self):
if isinstance(self.interFrame, Frame):
self.interFrame.destroy()
self.timer.destroy()
self.counter.destroy()
if isinstance(self.gameFrame, Frame):
self.gameFrame.destroy()
storage = Storage()
self.mines = storage.get("mines")
h = storage.get("height")
w = storage.get("width")
self.isGameStarted = False
self.tiles = [[j for j in range(w)] for i in range(h)]
self.bombs = set()
self.bombsPrediction = set()
self.tilesAmount = w * h
self.board = Board(w, h, self.mines)
self.root.bind_class('Label', '<Button-1>', self.openTileEvent)
self.root.bind_class('Label', '<Button-2>', self.flagTileEvent)
self.root.bind('<KeyPress>', self.keyboardEvent)
self.code = ""
self.__createFrame()
self.__initInterface()
def showAll(self):
for i in self.tiles:
for tile in i:
tile.open()
if not isinstance(tile, Bomb) and tile.getFlagLevel() != 0:
tile.setImage("../res/images/bombmisflagged.gif")
def showAllMines(self):
print("showing...")
for tile in self.bombs:
tile.shade()
def __initInterface(self):
self.interFrame = Frame(self.root, bg="green")
self.timer = MyTimer(self.interFrame)
self.timer.pack(side=LEFT, padx=20)
self.counter = Counter(self.interFrame)
self.counter.setVal(self.mines)
self.counter.pack(side=RIGHT, padx=20)
self.interFrame.pack()
def __createFrame(self):
tileFactory = TileFactory()
self.gameFrame = Frame(self.root)
for row in range(self.board.getWidth()):
for column in range(self.board.getHeight()):
point = Point(row, column)
type = self.board(point)
tile = tileFactory.getTile(self.gameFrame, type, point)
if isinstance(tile, Bomb):
self.bombs.add(tile)
self.tiles[row][column] = tile
tile.grid(row=row, column=column)
self.gameFrame.pack(side=BOTTOM, padx=20, pady=20)
def startGame(self):
if not self.isGameStarted:
self.timer.start()
self.isGameStarted = True
def keyboardEvent(self, event):
self.startGame()
self.code = self.code + event.char
if self.code == "xyzzy":
self.showAllMines()
Timer(2, self.bounce).start()
def bounce(self):
self.code = ""
def flagTileEvent(self, event):
self.startGame()
if event.widget.getFlagLevel() == 1:
self.counter.down()
self.newPrediction(event.widget)
elif event.widget.getFlagLevel() == 2:
self.counter.up()
self.bombsPrediction.remove(event.widget)
def openTileEvent(self, event):
self.startGame()
if self.tilesAmount == self.mines:
self.gameOver("wygrałeś")
tile = event.widget
point = tile.point
if not tile.isActive():
return
tile.disActive()
if isinstance(tile, Bomb) and tile.getFlagLevel() == 0:
self.root.after(10, tile.boom)
self.gameOver("przegrałeś")
if isinstance(tile, Number) and tile.getValue() == 0:
zeros = self.board.getZerosFrom(point)
for zero in zeros:
tmpTile = self.tiles[zero[0]][zero[1]]
tmpTile.open()
tmpTile.disActive()
self.tilesAmount -= 1
self.board.clearZeros()
else:
self.tilesAmount -= 1
self.checkTilesAmount()
def checkTilesAmount(self):
if self.tilesAmount == self.mines:
self.gameOver("wygrałeś")
def newPrediction(self, bomb):
self.bombsPrediction.add(bomb)
newSet = self.bombs - self.bombsPrediction
if not len(newSet):
self.gameOver("wygrałeś")
def gameOver(self, text):
self.timer.stop()
self.showAll()
messagebox.showerror("koniec Gry", text)
class UserMenu():
"""
Wrapper class for tkinter user menu.
"""
def _parse_solvers(self):
"""
Based on selected items fetch `solvers` and `puzzle_size`.
"""
self._is_destroyed = False
self._puzzle_data = dict()
solvers = []
if self._tk_var_wastar_dynamic.get():
solvers.append(Solvers.WASTAR_D)
if self._tk_var_wastar_static.get():
solvers.append(Solvers.WASTAR_S)
if self._tk_var_idastar.get():
solvers.append(Solvers.IDASTAR)
if self._tk_var_astar.get():
solvers.append(Solvers.ASTAR)
self._puzzle_data["solvers"] = solvers
# fetching solvers
if len(solvers) != 2:
solvers_popup = Tk()
solvers_popup.wm_title("!")
tk_lbl_solvers = Label(solvers_popup,
text="Select 2 algorithms",
padx=PADDING_X,
pady=PADDING_Y)
tk_lbl_solvers.pack(side="top", anchor="center")
tk_btn_solvers = Button(solvers_popup,
text="OK",
command=solvers_popup.destroy,
padx=PADDING_X)
tk_btn_solvers.pack()
solvers_popup.mainloop()
# fetching puzzle size
if self._tk_var_puzzle_size.get() == 3:
self._puzzle_data["size"] = 3
elif self._tk_var_puzzle_size.get() == 4:
self._puzzle_data["size"] = 4
else:
puzzle_size_popup = Tk()
puzzle_size_popup.wm_title("!")
tk_lbl_puzzle_size = Label(puzzle_size_popup,
text="Select puzzle size",
padx=PADDING_X,
pady=PADDING_Y)
tk_lbl_puzzle_size.pack(side="top", anchor="center")
tk_btn_puzzle_size = Button(puzzle_size_popup,
text="OK",
command=puzzle_size_popup.destroy,
padx=PADDING_X)
tk_btn_puzzle_size.pack()
puzzle_size_popup.mainloop()
# if everything is selected, we close user window
if len(solvers) == 2 and self._puzzle_data.get("size") is not None:
if not self._is_destroyed:
self._is_destroyed = True
self._root.destroy()
def _setup_cb(self):
"""Setup all checkboxes in the user menu."""
cb_shared_params = {
"onvalue": True,
"offvalue": False,
"padx": PADDING_X,
"pady": PADDING_Y
}
self._tk_cb_wastar_dynamic = Checkbutton(
self._tk_frame_cb,
text="Dynamic weighted A*",
variable=self._tk_var_wastar_dynamic,
**cb_shared_params)
self._tk_cb_wastar_dynamic.pack(side=TOP, anchor=W)
self._tk_cb_wastar_static = Checkbutton(
self._tk_frame_cb,
text="Static weighted A*",
variable=self._tk_var_wastar_static,
**cb_shared_params)
self._tk_cb_wastar_static.pack(side=TOP, anchor=W)
self._tk_cb_idastar = Checkbutton(self._tk_frame_cb,
text="Iterative deepening A*",
variable=self._tk_var_idastar,
**cb_shared_params)
self._tk_cb_idastar.pack(side=TOP, anchor=W)
self._tk_cb_astar = Checkbutton(self._tk_frame_cb,
text="Standard A*",
variable=self._tk_var_astar,
**cb_shared_params)
self._tk_cb_astar.pack(side=TOP, anchor=W)
def _setup_rb(self):
"""Setup all radio buttons in the user menu."""
rb_shared_params = {"padx": PADDING_X, "pady": PADDING_Y}
self._tk_rb_3x3 = Radiobutton(self._tk_frame_rb,
text="3x3",
variable=self._tk_var_puzzle_size,
value=3,
**rb_shared_params)
self._tk_rb_3x3.pack(side=TOP, anchor=W)
self._tk_rb_4x4 = Radiobutton(self._tk_frame_rb,
text="4x4",
variable=self._tk_var_puzzle_size,
value=4,
**rb_shared_params)
self._tk_rb_4x4.pack(side=TOP, anchor=W)
def _setup_submit(self):
self._tk_btn_submit = Button(self._tk_frame_btn,
text="Submit",
command=self._parse_solvers)
self._tk_btn_submit.pack(side=TOP, anchor=CENTER)
def __init__(self):
"""Tkinter constructor."""
self._root = Tk()
self._root.wm_title("Loyd Puzzle A* Solvers")
path = os.path.join(IMAGES_PATH, "icon.png")
self._root.iconphoto(True, PhotoImage(file=path))
self._root.resizable(False, False)
self._root.config(background="white")
self._tk_frame_btn = Frame(self._root)
# three separate containers for content of the menu
self._tk_frame_btn.pack(side="bottom", fill="both", expand=False)
self._tk_frame_cb = Frame(self._root)
self._tk_frame_cb.pack(side="left", fill="both", expand=False)
self._tk_frame_rb = Frame(self._root)
self._tk_frame_rb.pack(side="right", fill="both", expand=False)
# special tkinter variables that contains informations from checkboxes
self._tk_var_wastar_dynamic = BooleanVar()
self._tk_var_wastar_static = BooleanVar()
self._tk_var_idastar = BooleanVar()
self._tk_var_astar = BooleanVar()
self._tk_var_puzzle_size = IntVar()
def show(self):
self._setup_rb()
self._setup_cb()
self._setup_submit()
self._root.mainloop()
self._puzzle_data = Namespace(**self._puzzle_data)
def get_puzzle_data(self):
return self._puzzle_data
class Table:
"""
A display widget for a table of values, based on a ``MultiListbox``
widget. For many purposes, ``Table`` can be treated as a
list-of-lists. E.g., table[i] is a list of the values for row i;
and table.append(row) adds a new row with the given lits of
values. Individual cells can be accessed using table[i,j], which
refers to the j-th column of the i-th row. This can be used to
both read and write values from the table. E.g.:
>>> table[i,j] = 'hello'
The column (j) can be given either as an index number, or as a
column name. E.g., the following prints the value in the 3rd row
for the 'First Name' column:
>>> print(table[3, 'First Name'])
John
You can configure the colors for individual rows, columns, or
cells using ``rowconfig()``, ``columnconfig()``, and ``itemconfig()``.
The color configuration for each row will be preserved if the
table is modified; however, when new rows are added, any color
configurations that have been made for *columns* will not be
applied to the new row.
Note: Although ``Table`` acts like a widget in some ways (e.g., it
defines ``grid()``, ``pack()``, and ``bind()``), it is not itself a
widget; it just contains one. This is because widgets need to
define ``__getitem__()``, ``__setitem__()``, and ``__nonzero__()`` in
a way that's incompatible with the fact that ``Table`` behaves as a
list-of-lists.
:ivar _mlb: The multi-column listbox used to display this table's data.
:ivar _rows: A list-of-lists used to hold the cell values of this
table. Each element of _rows is a row value, i.e., a list of
cell values, one for each column in the row.
"""
def __init__(self,
master,
column_names,
rows=None,
column_weights=None,
scrollbar=True,
click_to_sort=True,
reprfunc=None,
cnf={},
**kw):
"""
Construct a new Table widget.
:type master: Tkinter.Widget
:param master: The widget that should contain the new table.
:type column_names: list(str)
:param column_names: A list of names for the columns; these
names will be used to create labels for each column;
and can be used as an index when reading or writing
cell values from the table.
:type rows: list(list)
:param rows: A list of row values used to initialze the table.
Each row value should be a tuple of cell values, one for
each column in the row.
:type scrollbar: bool
:param scrollbar: If true, then create a scrollbar for the
new table widget.
:type click_to_sort: bool
:param click_to_sort: If true, then create bindings that will
sort the table's rows by a given column's values if the
user clicks on that colum's label.
:type reprfunc: function
:param reprfunc: If specified, then use this function to
convert each table cell value to a string suitable for
display. ``reprfunc`` has the following signature:
reprfunc(row_index, col_index, cell_value) -> str
(Note that the column is specified by index, not by name.)
:param cnf, kw: Configuration parameters for this widget's
contained ``MultiListbox``. See ``MultiListbox.__init__()``
for details.
"""
self._num_columns = len(column_names)
self._reprfunc = reprfunc
self._frame = Frame(master)
self._column_name_to_index = dict(
(c, i) for (i, c) in enumerate(column_names))
# Make a copy of the rows & check that it's valid.
if rows is None:
self._rows = []
else:
self._rows = [[v for v in row] for row in rows]
for row in self._rows:
self._checkrow(row)
# Create our multi-list box.
self._mlb = MultiListbox(self._frame, column_names, column_weights,
cnf, **kw)
self._mlb.pack(side="left", expand=True, fill="both")
# Optional scrollbar
if scrollbar:
sb = Scrollbar(self._frame,
orient="vertical",
command=self._mlb.yview)
self._mlb.listboxes[0]["yscrollcommand"] = sb.set
# for listbox in self._mlb.listboxes:
# listbox['yscrollcommand'] = sb.set
sb.pack(side="right", fill="y")
self._scrollbar = sb
# Set up sorting
self._sortkey = None
if click_to_sort:
for i, l in enumerate(self._mlb.column_labels):
l.bind("<Button-1>", self._sort)
# Fill in our multi-list box.
self._fill_table()
# /////////////////////////////////////////////////////////////////
# { Widget-like Methods
# /////////////////////////////////////////////////////////////////
# These all just delegate to either our frame or our MLB.
def pack(self, *args, **kwargs):
"""Position this table's main frame widget in its parent
widget. See ``Tkinter.Frame.pack()`` for more info."""
self._frame.pack(*args, **kwargs)
def grid(self, *args, **kwargs):
"""Position this table's main frame widget in its parent
widget. See ``Tkinter.Frame.grid()`` for more info."""
self._frame.grid(*args, **kwargs)
def focus(self):
"""Direct (keyboard) input foxus to this widget."""
self._mlb.focus()
def bind(self, sequence=None, func=None, add=None):
"""Add a binding to this table's main frame that will call
``func`` in response to the event sequence."""
self._mlb.bind(sequence, func, add)
def rowconfigure(self, row_index, cnf={}, **kw):
""":see: ``MultiListbox.rowconfigure()``"""
self._mlb.rowconfigure(row_index, cnf, **kw)
def columnconfigure(self, col_index, cnf={}, **kw):
""":see: ``MultiListbox.columnconfigure()``"""
col_index = self.column_index(col_index)
self._mlb.columnconfigure(col_index, cnf, **kw)
def itemconfigure(self, row_index, col_index, cnf=None, **kw):
""":see: ``MultiListbox.itemconfigure()``"""
col_index = self.column_index(col_index)
return self._mlb.itemconfigure(row_index, col_index, cnf, **kw)
def bind_to_labels(self, sequence=None, func=None, add=None):
""":see: ``MultiListbox.bind_to_labels()``"""
return self._mlb.bind_to_labels(sequence, func, add)
def bind_to_listboxes(self, sequence=None, func=None, add=None):
""":see: ``MultiListbox.bind_to_listboxes()``"""
return self._mlb.bind_to_listboxes(sequence, func, add)
def bind_to_columns(self, sequence=None, func=None, add=None):
""":see: ``MultiListbox.bind_to_columns()``"""
return self._mlb.bind_to_columns(sequence, func, add)
rowconfig = rowconfigure
columnconfig = columnconfigure
itemconfig = itemconfigure
# /////////////////////////////////////////////////////////////////
# { Table as list-of-lists
# /////////////////////////////////////////////////////////////////
def insert(self, row_index, rowvalue):
"""
Insert a new row into the table, so that its row index will be
``row_index``. If the table contains any rows whose row index
is greater than or equal to ``row_index``, then they will be
shifted down.
:param rowvalue: A tuple of cell values, one for each column
in the new row.
"""
self._checkrow(rowvalue)
self._rows.insert(row_index, rowvalue)
if self._reprfunc is not None:
rowvalue = [
self._reprfunc(row_index, j, v)
for (j, v) in enumerate(rowvalue)
]
self._mlb.insert(row_index, rowvalue)
if self._DEBUG:
self._check_table_vs_mlb()
def extend(self, rowvalues):
"""
Add new rows at the end of the table.
:param rowvalues: A list of row values used to initialze the
table. Each row value should be a tuple of cell values,
one for each column in the row.
"""
for rowvalue in rowvalues:
self.append(rowvalue)
if self._DEBUG:
self._check_table_vs_mlb()
def append(self, rowvalue):
"""
Add a new row to the end of the table.
:param rowvalue: A tuple of cell values, one for each column
in the new row.
"""
self.insert(len(self._rows), rowvalue)
if self._DEBUG:
self._check_table_vs_mlb()
def clear(self):
"""
Delete all rows in this table.
"""
self._rows = []
self._mlb.delete(0, "end")
if self._DEBUG:
self._check_table_vs_mlb()
def __getitem__(self, index):
"""
Return the value of a row or a cell in this table. If
``index`` is an integer, then the row value for the ``index``th
row. This row value consists of a tuple of cell values, one
for each column in the row. If ``index`` is a tuple of two
integers, ``(i,j)``, then return the value of the cell in the
``i``th row and the ``j``th column.
"""
if isinstance(index, slice):
raise ValueError("Slicing not supported")
elif isinstance(index, tuple) and len(index) == 2:
return self._rows[index[0]][self.column_index(index[1])]
else:
return tuple(self._rows[index])
def __setitem__(self, index, val):
"""
Replace the value of a row or a cell in this table with
``val``.
If ``index`` is an integer, then ``val`` should be a row value
(i.e., a tuple of cell values, one for each column). In this
case, the values of the ``index``th row of the table will be
replaced with the values in ``val``.
If ``index`` is a tuple of integers, ``(i,j)``, then replace the
value of the cell in the ``i``th row and ``j``th column with
``val``.
"""
if isinstance(index, slice):
raise ValueError("Slicing not supported")
# table[i,j] = val
elif isinstance(index, tuple) and len(index) == 2:
i, j = index[0], self.column_index(index[1])
config_cookie = self._save_config_info([i])
self._rows[i][j] = val
if self._reprfunc is not None:
val = self._reprfunc(i, j, val)
self._mlb.listboxes[j].insert(i, val)
self._mlb.listboxes[j].delete(i + 1)
self._restore_config_info(config_cookie)
# table[i] = val
else:
config_cookie = self._save_config_info([index])
self._checkrow(val)
self._rows[index] = list(val)
if self._reprfunc is not None:
val = [
self._reprfunc(index, j, v) for (j, v) in enumerate(val)
]
self._mlb.insert(index, val)
self._mlb.delete(index + 1)
self._restore_config_info(config_cookie)
def __delitem__(self, row_index):
"""
Delete the ``row_index``th row from this table.
"""
if isinstance(row_index, slice):
raise ValueError("Slicing not supported")
if isinstance(row_index, tuple) and len(row_index) == 2:
raise ValueError("Cannot delete a single cell!")
del self._rows[row_index]
self._mlb.delete(row_index)
if self._DEBUG:
self._check_table_vs_mlb()
def __len__(self):
"""
:return: the number of rows in this table.
"""
return len(self._rows)
def _checkrow(self, rowvalue):
"""
Helper function: check that a given row value has the correct
number of elements; and if not, raise an exception.
"""
if len(rowvalue) != self._num_columns:
raise ValueError("Row %r has %d columns; expected %d" %
(rowvalue, len(rowvalue), self._num_columns))
# /////////////////////////////////////////////////////////////////
# Columns
# /////////////////////////////////////////////////////////////////
@property
def column_names(self):
"""A list of the names of the columns in this table."""
return self._mlb.column_names
def column_index(self, i):
"""
If ``i`` is a valid column index integer, then return it as is.
Otherwise, check if ``i`` is used as the name for any column;
if so, return that column's index. Otherwise, raise a
``KeyError`` exception.
"""
if isinstance(i, int) and 0 <= i < self._num_columns:
return i
else:
# This raises a key error if the column is not found.
return self._column_name_to_index[i]
def hide_column(self, column_index):
""":see: ``MultiListbox.hide_column()``"""
self._mlb.hide_column(self.column_index(column_index))
def show_column(self, column_index):
""":see: ``MultiListbox.show_column()``"""
self._mlb.show_column(self.column_index(column_index))
# /////////////////////////////////////////////////////////////////
# Selection
# /////////////////////////////////////////////////////////////////
def selected_row(self):
"""
Return the index of the currently selected row, or None if
no row is selected. To get the row value itself, use
``table[table.selected_row()]``.
"""
sel = self._mlb.curselection()
if sel:
return int(sel[0])
else:
return None
def select(self, index=None, delta=None, see=True):
""":see: ``MultiListbox.select()``"""
self._mlb.select(index, delta, see)
# /////////////////////////////////////////////////////////////////
# Sorting
# /////////////////////////////////////////////////////////////////
def sort_by(self, column_index, order="toggle"):
"""
Sort the rows in this table, using the specified column's
values as a sort key.
:param column_index: Specifies which column to sort, using
either a column index (int) or a column's label name
(str).
:param order: Specifies whether to sort the values in
ascending or descending order:
- ``'ascending'``: Sort from least to greatest.
- ``'descending'``: Sort from greatest to least.
- ``'toggle'``: If the most recent call to ``sort_by()``
sorted the table by the same column (``column_index``),
then reverse the rows; otherwise sort in ascending
order.
"""
if order not in ("ascending", "descending", "toggle"):
raise ValueError('sort_by(): order should be "ascending", '
'"descending", or "toggle".')
column_index = self.column_index(column_index)
config_cookie = self._save_config_info(index_by_id=True)
# Sort the rows.
if order == "toggle" and column_index == self._sortkey:
self._rows.reverse()
else:
self._rows.sort(key=operator.itemgetter(column_index),
reverse=(order == "descending"))
self._sortkey = column_index
# Redraw the table.
self._fill_table()
self._restore_config_info(config_cookie, index_by_id=True, see=True)
if self._DEBUG:
self._check_table_vs_mlb()
def _sort(self, event):
"""Event handler for clicking on a column label -- sort by
that column."""
column_index = event.widget.column_index
# If they click on the far-left of far-right of a column's
# label, then resize rather than sorting.
if self._mlb._resize_column(event):
return "continue"
# Otherwise, sort.
else:
self.sort_by(column_index)
return "continue"
# /////////////////////////////////////////////////////////////////
# { Table Drawing Helpers
# /////////////////////////////////////////////////////////////////
def _fill_table(self, save_config=True):
"""
Re-draw the table from scratch, by clearing out the table's
multi-column listbox; and then filling it in with values from
``self._rows``. Note that any cell-, row-, or column-specific
color configuration that has been done will be lost. The
selection will also be lost -- i.e., no row will be selected
after this call completes.
"""
self._mlb.delete(0, "end")
for i, row in enumerate(self._rows):
if self._reprfunc is not None:
row = [self._reprfunc(i, j, v) for (j, v) in enumerate(row)]
self._mlb.insert("end", row)
def _get_itemconfig(self, r, c):
return dict((k, self._mlb.itemconfig(r, c, k)[-1]) for k in (
"foreground",
"selectforeground",
"background",
"selectbackground",
))
def _save_config_info(self, row_indices=None, index_by_id=False):
"""
Return a 'cookie' containing information about which row is
selected, and what color configurations have been applied.
this information can the be re-applied to the table (after
making modifications) using ``_restore_config_info()``. Color
configuration information will be saved for any rows in
``row_indices``, or in the entire table, if
``row_indices=None``. If ``index_by_id=True``, the the cookie
will associate rows with their configuration information based
on the rows' python id. This is useful when performing
operations that re-arrange the rows (e.g. ``sort``). If
``index_by_id=False``, then it is assumed that all rows will be
in the same order when ``_restore_config_info()`` is called.
"""
# Default value for row_indices is all rows.
if row_indices is None:
row_indices = list(range(len(self._rows)))
# Look up our current selection.
selection = self.selected_row()
if index_by_id and selection is not None:
selection = id(self._rows[selection])
# Look up the color configuration info for each row.
if index_by_id:
config = dict((
id(self._rows[r]),
[self._get_itemconfig(r, c) for c in range(self._num_columns)],
) for r in row_indices)
else:
config = dict((
r,
[self._get_itemconfig(r, c) for c in range(self._num_columns)])
for r in row_indices)
return selection, config
def _restore_config_info(self, cookie, index_by_id=False, see=False):
"""
Restore selection & color configuration information that was
saved using ``_save_config_info``.
"""
selection, config = cookie
# Clear the selection.
if selection is None:
self._mlb.selection_clear(0, "end")
# Restore selection & color config
if index_by_id:
for r, row in enumerate(self._rows):
if id(row) in config:
for c in range(self._num_columns):
self._mlb.itemconfigure(r, c, config[id(row)][c])
if id(row) == selection:
self._mlb.select(r, see=see)
else:
if selection is not None:
self._mlb.select(selection, see=see)
for r in config:
for c in range(self._num_columns):
self._mlb.itemconfigure(r, c, config[r][c])
# /////////////////////////////////////////////////////////////////
# Debugging (Invariant Checker)
# /////////////////////////////////////////////////////////////////
_DEBUG = False
"""If true, then run ``_check_table_vs_mlb()`` after any operation
that modifies the table."""
def _check_table_vs_mlb(self):
"""
Verify that the contents of the table's ``_rows`` variable match
the contents of its multi-listbox (``_mlb``). This is just
included for debugging purposes, to make sure that the
list-modifying operations are working correctly.
"""
for col in self._mlb.listboxes:
assert len(self) == col.size()
for row in self:
assert len(row) == self._num_columns
assert self._num_columns == len(self._mlb.column_names)
# assert self._column_names == self._mlb.column_names
for i, row in enumerate(self):
for j, cell in enumerate(row):
if self._reprfunc is not None:
cell = self._reprfunc(i, j, cell)
assert self._mlb.get(i)[j] == cell
class Grid():
def __init__(self, master):
# Top menu
self.menu = Frame(master)
self.menu.pack(fill='both', expand=True)
self.save_button = Button(master, text='Save', command=self.save_grid)
self.save_button.pack(in_=self.menu, side='right')
self.load_button = Button(master, text='Load', command=self.load_grid)
self.load_button.pack(in_=self.menu, side='right')
# Place the canvas
self.canvas = Canvas(master,
width=MAP_CELL_SIZE * MAP_SIZE,
height=MAP_CELL_SIZE * MAP_SIZE)
self.grid = [[Cell(self.canvas, row, col) for col in range(MAP_SIZE)]
for row in range(MAP_SIZE)]
self.canvas.bind("<Button-1>", self.event_set_cell)
self.canvas.bind("<B1-Motion>", self.event_set_cell)
self.canvas.pack()
# Tools
self.tools = Frame(master)
self.tools.pack(fill='both', expand=True)
self.fill_button = Button(self.tools,
text="Fill",
command=self.fill_grid)
self.fill_button.pack(side='left')
types = list(list_draw_types())
self.draw_type = StringVar(master)
self.draw_type.set(DEFAULT_CELL_TYPE)
self.dd_draw_type = OptionMenu(self.tools, self.draw_type,
DEFAULT_CELL_TYPE, *types)
self.dd_draw_type.pack(side='left')
self.symetry = StringVar(master)
self.symetry.set(SYMETRY[0])
self.dd_symetry = OptionMenu(self.tools, self.symetry, SYMETRY[0],
*SYMETRY)
self.dd_symetry.pack(side='right')
self.draw()
def draw(self):
for row in self.grid:
for cell in row:
cell.draw()
# ____ _ _
# / ___|___| | |___
# | | / _ \ | / __|
# | |__| __/ | \__ \
# \____\___|_|_|___/
#
@staticmethod
def inside_grid(row, col):
return 0 <= row < MAP_SIZE and 0 <= col < MAP_SIZE
def set_cell(self, row, col):
self.grid[row][col].set(self.draw_type.get())
opp = get_opp((row, col), self.symetry.get())
if opp is not None:
self.grid[opp[0]][opp[1]].set(self.draw_type.get())
def fill_grid(self):
for row in self.grid:
for cell in row:
cell.set(self.draw_type.get())
# _____ _ _ _ _ _ _
# | ____|_ _____ _ __ | |_ | | | | __ _ _ __ __| | (_)_ __ __ _
# | _| \ \ / / _ \ '_ \| __| | |_| |/ _` | '_ \ / _` | | | '_ \ / _` |
# | |___ \ V / __/ | | | |_ | _ | (_| | | | | (_| | | | | | | (_| |
# |_____| \_/ \___|_| |_|\__| |_| |_|\__,_|_| |_|\__,_|_|_|_| |_|\__, |
# |___/
def event_set_cell(self, event):
row = int(event.y / MAP_CELL_SIZE)
col = int(event.x / MAP_CELL_SIZE)
if self.inside_grid(row, col):
self.set_cell(row, col)
# ____ _ _ _ _ _
# / ___| ___ _ __(_) __ _| (_)______ _| |_(_) ___ _ __
# \___ \ / _ \ '__| |/ _` | | |_ / _` | __| |/ _ \| '_ \
# ___) | __/ | | | (_| | | |/ / (_| | |_| | (_) | | | |
# |____/ \___|_| |_|\__,_|_|_/___\__,_|\__|_|\___/|_| |_|
#
def save_grid(self):
filename = asksaveasfilename()
if not filename:
return
with open(filename, 'w+') as f:
# Init raw and list outputs datas
raw_output = dict()
list_output = dict()
for name, conf in CELL_TYPES.items():
if conf['serialize']['method'] == 'raw':
default_data = [0, 0] + ([0] * len(conf['extra'])
if 'extra' in conf else [])
raw_output[conf['serialize']['order']] = default_data
elif conf['serialize']['method'] == 'list':
list_output[conf['serialize']['order']] = []
# Serialize the grid and catch raw and list outputs
for row, row_data in enumerate(self.grid):
for col, cell in enumerate(row_data):
conf = get_type_conf(cell.cell_type)
data = [row, col]
# Add extra infos if necessary
if 'extra' in conf:
data += [
conf['default'][field] for field in conf['extra']
]
# Serialization of the grid
if 'ascii' in conf['serialize']:
f.write(conf['serialize']['ascii'])
else:
f.write(CELL_TYPES[DEFAULT_CELL_TYPE]['serialize']
['ascii'])
# Register for raw and list outputs
if conf['serialize']['method'] == 'raw':
raw_output[conf['serialize']['order']] = data
elif conf['serialize']['method'] == 'list':
list_output[conf['serialize']['order']].append(data)
f.write('\n')
# Serialize raw and list outputs
order_keys = sorted(
list(raw_output.keys()) + list(list_output.keys()))
for order in order_keys:
if order in raw_output:
f.write('{}\n'.format(' '.join(map(str,
raw_output[order]))))
else:
f.write('{}\n'.format(len(list_output[order])))
for item in list_output[order]:
f.write('{}\n'.format(' '.join(map(str, item))))
def load_grid(self, filename=None):
if filename is None:
filename = askopenfilename()
# Index of symbols to consider in the grid
from_ascii = {
conf['serialize']['ascii']: name
for name, conf in CELL_TYPES.items()
if conf['serialize']['method'] == 'ascii'
}
# Ordered list of items to catch after reading the grid
from_raw_or_list = [(name, conf['serialize']['order'])
for name, conf in CELL_TYPES.items()
if conf['serialize']['method'] in ['raw', 'list']]
from_raw_or_list.sort(key=lambda x: x[1])
from_raw_or_list = map(lambda x: x[0], from_raw_or_list)
# Need to match exactly a preset when 'extra' is specified, create
# an index to get which preset is used
fullname_index = dict()
for full_name in list_draw_types():
if ':' in full_name:
conf = get_type_conf(full_name)
parent_name, preset_name = full_name.split(':')
key = tuple(
[parent_name] +
[conf['default'][field] for field in conf['extra']])
fullname_index[key] = full_name
else:
fullname_index[(full_name, )] = full_name
with open(filename, 'r') as f:
# Read the grid
for row in range(MAP_SIZE):
for col, char in enumerate(f.readline()):
if self.inside_grid(row, col) and char in from_ascii:
self.grid[row][col].set(from_ascii[char])
# Read raw and list infos
for name in from_raw_or_list:
conf = CELL_TYPES[name]
if conf['serialize']['method'] == 'raw':
row, col, *extra = map(int, f.readline().split(' '))
self.grid[row][col].set(name)
elif conf['serialize']['method'] == 'list':
n = int(f.readline())
for _ in range(n):
row, col, *extra = map(int, f.readline().split(' '))
identifier = (name, ) + tuple(extra)
if identifier in fullname_index:
self.grid[row][col].set(fullname_index[identifier])
self.draw()
def __init__(self):
# root is the Tkinter root widget
self.root = Tk()
self.root.title("Input Device Utility")
# self.root.configure(background='grey')
self.root.resizable(False, False)
# define response to main window closing
self.root.protocol("WM_DELETE_WINDOW", self.app_exit)
self.my_device = ''
self.my_device_display = StringVar()
self.device_list = []
self.matches = 0
# overall display
root_frame = Frame(self.root)
root_frame.pack(side=LEFT)
devices_frame = Frame(root_frame, padx=5, pady=10)
devices_frame.pack(side=LEFT)
devices_label = Label(devices_frame, text="Devices in dev/input")
devices_label.pack(side=TOP)
devices_list_frame = Frame(devices_frame, padx=5, pady=10)
devices_list_frame.pack(side=TOP)
selected_device_title = Label(devices_frame, text='Selected device')
selected_device_title.pack(side=TOP)
self.selected_device_var = StringVar()
selected_device = Label(devices_frame,
textvariable=self.selected_device_var,
fg="red")
selected_device.pack(side=TOP)
events_frame = Frame(root_frame, padx=5, pady=10)
events_frame.pack(side=LEFT)
events_title = Label(events_frame, text='Received Events')
events_title.pack(side=TOP)
events_list_frame = Frame(events_frame, padx=5, pady=10)
events_list_frame.pack(side=TOP)
# list of devices
scrollbar = Scrollbar(devices_list_frame, orient=VERTICAL)
self.devices_display = Listbox(devices_list_frame,
selectmode=SINGLE,
height=20,
width=60,
bg="white",
activestyle=NONE,
fg="black",
yscrollcommand=scrollbar.set)
scrollbar.config(command=self.devices_display.yview)
scrollbar.pack(side=RIGHT, fill=Y)
self.devices_display.pack(side=LEFT, fill=BOTH, expand=1)
self.devices_display.bind("<ButtonRelease-1>", self.e_select_device)
# events display
scrollbar = Scrollbar(events_list_frame, orient=VERTICAL)
self.events_display = Text(events_list_frame,
width=40,
height=20,
wrap='word',
font="arial 11",
padx=5,
yscrollcommand=scrollbar.set)
scrollbar.config(command=self.events_display.yview)
scrollbar.pack(side=RIGHT, fill=Y)
self.events_display.pack(side=LEFT, fill=BOTH, expand=1)
self.events_display.config(state=NORMAL)
self.events_display.delete(1.0, END)
self.events_display.config(state=DISABLED)
self.selected_device_index = -1
self.matches = 0
self.get_all_devices()
self.refresh_devices_display()
self.root.after(10, self.event_loop)
# and enter Tkinter event loop
self.root.mainloop()
def askAjouterHeure(heureMin, heureMax, totalHeure):
nbHeure = None
position = None
def onClose(bouton):
# Permet de modifier les valeurs des variables
nonlocal nbHeure, position
if bouton == 'Ok':
position = varRadioBouton.get()
nbHeure = int(sb.get())
if varRadioGestion.get() == "Retirer":
nbHeure = nbHeure * -1
fen.destroy()
# Pour adapter le nombre d'heure max du spinBoc
def adapteSpinbox():
newVar = 0
if varRadioGestion.get() == "Retirer":
newVar = totalHeure
elif varRadioGestion.get() == "Ajouter":
if varRadioBouton.get() == "Apres":
newVar = heureMax.total_seconds() // 3600
elif varRadioBouton.get() == "Avant":
newVar = heureMin.hour
# On config
sb.config(to=newVar)
# Si on dépasse, on reset au max
if int(sb.get()) > newVar:
sb.set(int(newVar))
fen = Dialog(title="Nombre d'heure à ajouter",
buttons=("Ok", "Annuler"),
command=onClose,
exitButton=('Ok', 'Annuler', "WM_DELETE_WINDOW"))
# Binding des touches
fen.bind_all("<Return>", lambda e: fen.execute("Ok"))
fen.bind_all("<Escape>", lambda e: fen.execute("Annuler"))
# Mettre les widgets
frameGestion = Frame(fen)
varRadioGestion = StringVar()
rG1 = Radiobutton(frameGestion,
text="Ajouter les heures",
variable=varRadioGestion,
value="Ajouter",
command=adapteSpinbox)
rG2 = Radiobutton(frameGestion,
text="Retirer les heures",
variable=varRadioGestion,
value="Retirer",
command=adapteSpinbox)
rG1.grid(row=0, sticky="w")
rG2.grid(row=1, sticky="w")
frameHeure = Labelframe(fen, text="Combien d'heure ajouter ?")
lb = Label(frameHeure, text="Nombre d'heure :")
sb = Spinbox(frameHeure, from_=0, to=heureMax.total_seconds() // 3600)
sb.set(0)
lb.pack(side=LEFT, fill=BOTH)
sb.pack(side=LEFT, fill=X, expand=YES)
framePos = Labelframe(fen, text="Où rajouter les heures ?")
varRadioBouton = StringVar()
r1 = Radiobutton(framePos,
text="Au début de la journée",
variable=varRadioBouton,
value="Avant",
command=adapteSpinbox)
r2 = Radiobutton(framePos,
text="À la fin de la journée",
variable=varRadioBouton,
value="Apres",
command=adapteSpinbox)
r1.grid(row=0, sticky="w")
r2.grid(row=1, sticky="w")
frameGestion.pack(side=TOP, expand=YES, fill=BOTH)
frameHeure.pack(side=TOP, expand=YES, fill=BOTH)
framePos.pack(side=TOP, expand=YES, fill=BOTH)
varRadioGestion.set("Ajouter")
varRadioBouton.set("Apres")
# Active et attend (un peu comme une mainloop)
fen.activateandwait()
return nbHeure, position
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, width)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
window = Tk()
window.title("title")
window.resizable(0, 0)
window.geometry("1500x800+20+20")
# 웹캠 구간
lmain = Label(window)
lmain.pack(side="left")
# 오른쪽 구간
sub_frame = Frame(window)
sub_frame.pack(side="left")
# 등록 버튼
register_btn = Button(sub_frame,
text="Register",
width=10,
height=5,
command=register_btn_click)
register_btn.grid(row=0, column=0, rowspan=3, columnspan=3, padx=5, pady=5)
# 레이블과 이름 입력 엔트리
register_label = Label(sub_frame, text="Input Name :")
register_label.grid(row=4, column=0, padx=5, pady=5)
register_name = Entry(sub_frame, width=10)
register_name.grid(row=4, column=1, padx=5, pady=5)
sleep(0.5)
if __name__ == '__main__':
root = Tk()
root.title('cliptrans')
root.geometry('300x100')
root.resizable(0, 0)
root.iconbitmap('.\\icon.ico')
root.attributes('-topmost', True)
frame = Frame(root)
scrollbar = Scrollbar(frame, orient=VERTICAL)
text = Text(frame,
state='disable',
font=(
'宋体',
12,
),
yscrollcommand=scrollbar.set)
scrollbar.pack(side=RIGHT, fill=Y)
scrollbar.config(command=text.yview)
text.pack()
frame.pack(expand=True, fill='both')
thread = Thread(target=translate)
thread.daemon = True
thread.start()
root.mainloop()
def initUI(self):
#top frame using all the remaining space
innerTopFrame = Frame(self, background="black")
innerTopFrame.pack(fill=BOTH, expand=1)
#CLOSE Label
innerBottomLeftFrame = Frame(self, background="black")
innerBottomLeftFrame.place(x=0, width=self.wRoot/2,
y=self.hRoot-200, height=200)
closeLabel = Label(innerBottomLeftFrame, bg="black", fg="black",
text="CLOSE", font=("Comic Sans MS", 48, "bold"))
innerBottomLeftFrame.bind("<Enter>", lambda f: closeLabel.config(fg="white"))
innerBottomLeftFrame.bind("<Leave>", lambda f: closeLabel.config(fg="black"))
innerBottomLeftFrame.bind("<Button-1>", lambda f: self.root.quit())
closeLabel.bind("<Button-1>", lambda f: self.root.quit())
closeLabel.pack(fill=BOTH)
#SHUT DOWN Label
innerBottomRightFrame = Frame(self, background="black")
innerBottomRightFrame.place(x=self.wRoot/2, width=self.wRoot/2,
y=self.hRoot-200, height=200)
shutdownLabel = Label(innerBottomRightFrame, bg="black", fg="black",
text="SHUT DOWN", font=("Comic Sans MS", 48, "bold"))
innerBottomRightFrame.bind("<Enter>", lambda f: shutdownLabel.config(fg="white"))
innerBottomRightFrame.bind("<Leave>", lambda f: shutdownLabel.config(fg="black"))
innerBottomRightFrame.bind("<Button-1>", self.shutdown)
shutdownLabel.bind("<Button-1>", self.shutdown)
shutdownLabel.pack(fill=BOTH)
#design the FullScreenApp
self.pack(fill=BOTH, expand=1)
