def get_pixels():
root = Tk()
root.title("Pixel Printer")
root.grid()
inner_top = Frame(root)
inner_top.grid(row=0, column=0)
t1 = Entry(inner_top, width=40)
t2 = Entry(inner_top, width=40)
v = StringVar()
root.columnconfigure(0, weight=1)
root.columnconfigure(1, weight=1)
b1 = Button(inner_top, text="Source")
b2 = Button(inner_top, text="Dest")
b3 = Button(inner_top, text="Calc")
b1.configure(command=lambda: get_source(t1))
b2.configure(command=lambda: get_dest(t2))
b3.configure(command=lambda: calculate(t1, t2, v))
t1.grid(row=0, column=0)
b1.grid(row=0, column=1, sticky=E + W)
t2.grid(row=1, column=0)
b2.grid(row=1, column=1, sticky=E + W)
b3.grid(row=2, column=1, sticky=E + W)
root.mainloop()
def get_pixels():
root = Tk()
root.title("Pixel Printer")
root.grid()
inner_top = Frame(root)
inner_top.grid(row=0, column=0)
t1 = Entry(inner_top, width = 40)
t2 = Entry(inner_top, width = 40)
v = StringVar()
root.columnconfigure(0, weight=1)
root.columnconfigure(1, weight=1)
b1 = Button(inner_top, text = "Source")
b2 = Button(inner_top, text = "Dest")
b3 = Button(inner_top, text = "Calc")
b1.configure(command= lambda:get_source(t1))
b2.configure(command= lambda:get_dest(t2))
b3.configure(command= lambda:calculate(t1, t2, v))
t1.grid(row=0, column=0)
b1.grid(row=0, column=1, sticky=E+W)
t2.grid(row=1, column=0)
b2.grid(row=1, column=1, sticky=E+W)
b3.grid(row=2, column=1, sticky=E+W)
root.mainloop()
def main(config=config):
"""
Creates an application instance.
"""
root = Tk()
root.columnconfigure(0, weight=1)
root.wm_title("ayy lmap")
app = Application(master=root, config=config)
return app
def main(config=config):
"""
Creates an application instance.
"""
root = Tk()
root.columnconfigure(0, weight=1)
root.wm_title("ayy lmap")
app = Application(master=root, config=config)
return app
def test_frame():
c = Customers()
p = Payments()
root = Tk()
rf = ReportsFrame(root,c,p,output_text)
rf.grid(sticky='nsew')
root.rowconfigure(0,weight=1)
root.columnconfigure(0,weight=1)
root.mainloop()
def testFrame():
c = Customers()
p = Payments()
root = Tk()
pf = PaymentFrame(root, c, p, output_text, refresh)
pf.grid(sticky='nsew')
root.rowconfigure(0,weight=1)
root.columnconfigure(0,weight=1)
root.mainloop()
def run():
""" starting the interface
"""
from gui import GUI
from Tkinter import Tk
import system
root = Tk()
root.columnconfigure(0,weight=1)
root.rowconfigure(1,weight=1)
root.title(system.name + " " + system.version)
root.minsize(width= system.minwidth , height=system.minheight)
root.geometry(system.defsize)
gui = GUI(root)
gui.makeGUI()
root.iconbitmap('hat2.ico')
root.mainloop()
class GUI:
def __init__(self, model, title='PyCX Simulator', interval=0, stepSize=1,
param_gui_names=None):
self.model = model
self.titleText = title
self.timeInterval = interval
self.stepSize = stepSize
self.param_gui_names = param_gui_names
if param_gui_names is None:
self.param_gui_names = {}
self.param_entries = {}
self.statusStr = ""
self.running = False
self.modelFigure = None
self.currentStep = 0
self.initGUI()
def initGUI(self):
#create root window
self.rootWindow = Tk()
self.statusText = StringVar(value=self.statusStr)
self.setStatusStr("Simulation not yet started")
self.rootWindow.wm_title(self.titleText)
self.rootWindow.protocol('WM_DELETE_WINDOW', self.quitGUI)
self.rootWindow.geometry('550x700')
self.rootWindow.columnconfigure(0, weight=1)
self.rootWindow.rowconfigure(0, weight=1)
self.frameSim = Frame(self.rootWindow)
self.frameSim.pack(expand=YES, fill=BOTH, padx=5, pady=5, side=TOP)
self.status = Label(self.rootWindow, width=40, height=3, relief=SUNKEN,
bd=1, textvariable=self.statusText)
self.status.pack(side=TOP, fill=X, padx=1, pady=1, expand=NO)
self.runPauseString = StringVar()
self.runPauseString.set("Run")
self.buttonRun = Button(self.frameSim, width=30, height=2,
textvariable=self.runPauseString,
command=self.runEvent)
self.buttonRun.pack(side=TOP, padx=5, pady=5)
self.showHelp(self.buttonRun,
"Runs the simulation (or pauses the running simulation)")
self.buttonStep = Button(self.frameSim, width=30, height=2,
text="Step Once", command=self.stepOnce)
self.buttonStep.pack(side=TOP, padx=5, pady=5)
self.showHelp(self.buttonStep, "Steps the simulation only once")
self.buttonReset = Button(self.frameSim, width=30, height=2,
text="Reset", command=self.resetModel)
self.buttonReset.pack(side=TOP, padx=5, pady=5)
self.showHelp(self.buttonReset, "Resets the simulation")
for param in self.model.params:
var_text = self.param_gui_names.get(param, param)
can = Canvas(self.frameSim)
lab = Label(can, width=25, height=1 + var_text.count('\n'),
text=var_text, anchor=W, takefocus=0)
lab.pack(side='left')
ent = Entry(can, width=11)
val = getattr(self.model, param)
if isinstance(val, bool):
val = int(val) # Show 0/1 which can convert back to bool
ent.insert(0, str(val))
ent.pack(side='left')
can.pack(side='top')
self.param_entries[param] = ent
if self.param_entries:
self.buttonSaveParameters = Button(self.frameSim, width=50,
height=1, command=self.saveParametersCmd,
text="Save parameters to the running model", state=DISABLED)
self.showHelp(self.buttonSaveParameters,
"Saves the parameter values.\n" +
"Not all values may take effect on a running model\n" +
"A model reset might be required.")
self.buttonSaveParameters.pack(side='top', padx=5, pady=5)
self.buttonSaveParametersAndReset = Button(self.frameSim, width=50,
height=1, command=self.saveParametersAndResetCmd,
text="Save parameters to the model and reset the model")
self.showHelp(self.buttonSaveParametersAndReset,
"Saves the given parameter values and resets the model")
self.buttonSaveParametersAndReset.pack(side='top', padx=5, pady=5)
can = Canvas(self.frameSim)
lab = Label(can, width=25, height=1, text="Step size ", justify=LEFT,
anchor=W, takefocus=0)
lab.pack(side='left')
self.stepScale = Scale(can, from_=1, to=500, resolution=1,
command=self.changeStepSize, orient=HORIZONTAL,
width=25, length=150)
self.stepScale.set(self.stepSize)
self.showHelp(self.stepScale,
"Skips model redraw during every [n] simulation steps\n" +
"Results in a faster model run.")
self.stepScale.pack(side='left')
can.pack(side='top')
can = Canvas(self.frameSim)
lab = Label(can, width=25, height=1,
text="Step visualization delay in ms ", justify=LEFT,
anchor=W, takefocus=0)
lab.pack(side='left')
self.stepDelay = Scale(can, from_=0, to=max(2000, self.timeInterval),
resolution=10, command=self.changeStepDelay,
orient=HORIZONTAL, width=25, length=150)
self.stepDelay.set(self.timeInterval)
self.showHelp(self.stepDelay, "The visualization of each step is " +
"delays by the given number of " +
"milliseconds.")
self.stepDelay.pack(side='left')
can.pack(side='top')
def setStatusStr(self, newStatus):
self.statusStr = newStatus
self.statusText.set(self.statusStr)
#model control functions
def changeStepSize(self, val):
self.stepSize = int(val)
def changeStepDelay(self, val):
self.timeInterval = int(val)
def saveParametersCmd(self):
for param, entry in self.param_entries.items():
val = entry.get()
if isinstance(getattr(self.model, param), bool):
val = bool(int(val))
setattr(self.model, param, val)
# See if the model changed the value (e.g. clipping)
new_val = getattr(self.model, param)
if isinstance(new_val, bool):
new_val = int(new_val)
entry.delete(0, END)
entry.insert(0, str(new_val))
self.setStatusStr("New parameter values have been set")
def saveParametersAndResetCmd(self):
self.saveParametersCmd()
self.resetModel()
def runEvent(self):
if not self.running:
self.running = True
self.rootWindow.after(self.timeInterval, self.stepModel)
self.runPauseString.set("Pause")
self.buttonStep.configure(state=DISABLED)
if self.param_entries:
self.buttonSaveParameters.configure(state=NORMAL)
self.buttonSaveParametersAndReset.configure(state=DISABLED)
else:
self.stopRunning()
def stopRunning(self):
self.running = False
self.runPauseString.set("Continue Run")
self.buttonStep.configure(state=NORMAL)
self.drawModel()
if self.param_entries:
self.buttonSaveParameters.configure(state=NORMAL)
self.buttonSaveParametersAndReset.configure(state=NORMAL)
def stepModel(self):
if self.running:
if self.model.step() is True:
self.stopRunning()
self.currentStep += 1
self.setStatusStr("Step " + str(self.currentStep))
self.status.configure(foreground='black')
if (self.currentStep) % self.stepSize == 0:
self.drawModel()
self.rootWindow.after(int(self.timeInterval * 1.0 / self.stepSize),
self.stepModel)
def stepOnce(self):
self.running = False
self.runPauseString.set("Continue Run")
self.model.step()
self.currentStep += 1
self.setStatusStr("Step " + str(self.currentStep))
self.drawModel()
if self.param_entries:
self.buttonSaveParameters.configure(state=NORMAL)
def resetModel(self):
self.running = False
self.runPauseString.set("Run")
self.model.reset()
self.currentStep = 0
self.setStatusStr("Model has been reset")
self.drawModel()
def drawModel(self):
if self.modelFigure is None:
self.modelFigure = plt.figure()
plt.ion()
self.model.draw()
# Tell matplotlib to redraw too. The darwin-version works with more
# types of matplotlib backends, but seems to fail on some Linux
# machines. Hence we use the TkAgg specific method when available.
if sys.platform == 'darwin':
self.modelFigure.canvas.manager.show()
else:
self.modelFigure.canvas.manager.window.update()
def start(self):
if self.model.step.__doc__:
self.showHelp(self.buttonStep, self.model.step.__doc__.strip())
self.model.reset()
self.drawModel()
self.rootWindow.mainloop()
def quitGUI(self):
plt.close('all')
self.rootWindow.quit()
self.rootWindow.destroy()
def showHelp(self, widget, text):
def setText(self):
self.statusText.set(text)
self.status.configure(foreground='blue')
def showHelpLeave(self):
self.statusText.set(self.statusStr)
self.status.configure(foreground='black')
widget.bind("<Enter>", lambda e: setText(self))
widget.bind("<Leave>", lambda e: showHelpLeave(self))
NewCustomerDialog.add_customer(self,event)
if self.close:
self.output_text("+ - Modified: " + name + " (" + self.payment.get() + ")\n")
def output_text(text):
print text,
def refresh():
print "refreshing...."
if __name__ == '__main__':
c = Customers()
pprint(c.get_list())
root = Tk()
ncf = CustomerFrame(root, c, output_text, refresh)
ncf.grid(sticky='nsew')
root.rowconfigure(0,weight=1)
root.columnconfigure(0,weight=1)
root.mainloop()
# c = Customers()
# pprint(c.get_list())
# root = Frame()
# ncd = NewCustomerDialog(root, c)
# Button(root,text='New Customer',command=ncd.show).pack()
# root.pack()
# root.mainloop()
scrollx = Scrollbar(root, orient="horizontal", command=scrollframe.xview)
scrollx.grid(row=1, column=0, sticky="nwse")
scrolly = Scrollbar(root, orient="vertical", command=scrollframe.yview)
scrolly.grid(row=0, column=1, sticky="nwse")
scrollframe["xscrollcommand"] = scrollx.set
scrollframe["yscrollcommand"] = scrolly.set
scrollframe.grid(row=0, column=0, sticky="nwse")
checkvar = BooleanVar(root, value=scrollframe["stretch"])
def set_stretch():
scrollframe["stretch"] = True if checkvar.get() else False
scrollframe.update_scrollregion()
stretch = Checkbutton(root,
anchor="w",
onvalue=True,
offvalue=False,
variable=checkvar,
text="Stick contained frame to container",
command=set_stretch)
stretch.grid(sticky="nwse", padx=2, pady=2)
root.title("Scrolled Frame")
root.columnconfigure(0, weight=1)
root.rowconfigure(0, weight=1)
root.mainloop()
def editSettings(cls):
def commitSettings(messageInDialogIn):
# Temp vars
ip = settings.serverIp
p = settings.port
settingsVars.serverIp = IPAddressBox.get()
settingsVars.port = portBox.get()
settingsVars.numberOfMessagesToGet = int(numberToGetBox.get())
settingsVars.refreshInterval = int(refreshIntervalBox.get())
if not cls.isServerActive():
settingsVars.serverIp = ip
settingsVars.port = p
tkMessageBox.showerror(message='Invalid Server Address ' + 'http://' + IPAddressBox.get() + ':' + portBox.get() + '/')
logging.warning('Invalid Server Address ' + 'http://' + IPAddressBox.get() + ':' + portBox.get() + '/')
messageInDialogIn.destroy()
settingsDialog = Tk()
settingsDialog.title('Settings')
if os.name == "nt":
settingsDialog.wm_iconbitmap(bitmap='images/icon.ico')
settingsDialog.columnconfigure(0, weight=1)
settingsDialog.rowconfigure(0, weight=1)
settingsDialog.minsize(width=100, height=50)
frame = Frame(settingsDialog)
addressLabel = Label(frame)
addressLabel['text'] = 'Server Address'
addressLabel.pack()
IPAddressBox = Entry(frame)
IPAddressBox.insert(0, cls.serverIp)
IPAddressBox.pack(fill='both')
portLabel = Label(frame)
portLabel['text'] = 'Server Port'
portLabel.pack()
portBox = Entry(frame)
portBox.insert(0, cls.port)
portBox.pack(fill='both')
numberToGetLabel = Label(frame)
numberToGetLabel['text'] = '# of Messages To Get'
numberToGetLabel.pack()
numberToGetBox = Entry(frame)
numberToGetBox.insert(0, cls.numberOfMessagesToGet)
numberToGetBox.pack(fill='both')
refreshIntervalLabel = Label(frame)
refreshIntervalLabel['text'] = 'Refresh Interval'
refreshIntervalLabel.pack()
refreshIntervalBox = Entry(frame)
refreshIntervalBox.insert(0, cls.refreshInterval)
refreshIntervalBox.pack(fill='both')
submitButton = Button(frame)
submitButton['text'] = 'Ok'
submitButton['command'] = lambda: commitSettings(settingsDialog)
submitButton.pack(side="left", expand="yes", fill="both", padx=5, pady=3)
cancelButton = Button(frame)
cancelButton['text'] = 'Cancel'
cancelButton['command'] = settingsDialog.destroy
cancelButton.pack(fill='both', expand="yes", padx=5, pady=3)
frame.pack(fill='both', expand="yes", padx=0, pady=0)
return settingsDialog
def create_widgets():
global list_box, canvas, label, zoom_label
#
root = Tk()
#
list_box = Listbox(root, exportselection=False)
list_box.grid(row=0, column=0, rowspan=2, sticky=NS)
cardsets_list = list(cardsets_dict)
cardsets_list.sort()
for cs in cardsets_list:
list_box.insert(END, cs)
list_box.bind('<<ListboxSelect>>', show_cardset)
#
sb = Scrollbar(root)
sb.grid(row=0, column=1, rowspan=2, sticky=NS)
list_box.config(yscrollcommand=sb.set)
sb.config(command=list_box.yview)
#
canvas = Canvas(root, bg='#5eab6b')
canvas.grid(row=0, column=2, sticky=NSEW)
canvas.bind('<4>', lambda e: canvas.yview_scroll(-5, 'unit'))
canvas.bind('<5>', lambda e: canvas.yview_scroll(5, 'unit'))
#
sb = Scrollbar(root)
sb.grid(row=0, column=3, sticky=NS)
canvas.config(yscrollcommand=sb.set)
sb.config(command=canvas.yview)
#
if True:
sb = Scrollbar(root, orient=HORIZONTAL)
sb.grid(row=1, column=2, sticky=EW)
canvas.config(xscrollcommand=sb.set)
sb.config(command=canvas.xview)
#
label = Label(root)
label.grid(row=2, column=0, columnspan=4)
#
b_frame = Frame(root)
b_frame.grid(row=3, column=0, columnspan=4, sticky=EW)
button = Button(b_frame, text='Quit', command=root.quit, width=8)
button.pack(side=RIGHT)
button = Button(b_frame, text='Info', command=show_info, width=8)
button.pack(side=RIGHT)
if Image:
global rotate_var, filter_var
rotate_var = IntVar(root)
filter_var = StringVar(root)
button = Button(b_frame, text=' + ', command=zoom_in)
button.pack(side=LEFT)
button = Button(b_frame, text=' - ', command=zoom_out)
button.pack(side=LEFT)
button = Button(b_frame, text=' = ', command=zoom_cancel)
button.pack(side=LEFT)
button = Checkbutton(b_frame,
text='Rotate',
indicatoron=0,
selectcolor=b_frame['bg'],
width=8,
variable=rotate_var,
command=show_cardset)
button.pack(side=LEFT, fill='y')
om = OptionMenu(b_frame,
filter_var,
'NEAREST',
'BILINEAR',
'BICUBIC',
'ANTIALIAS',
command=show_cardset)
filter_var.set('NEAREST')
om.pack(side=LEFT, fill='y')
zoom_label = Label(b_frame)
zoom_label.pack(side=LEFT)
#
root.columnconfigure(2, weight=1)
root.rowconfigure(0, weight=1)
root.title('Show Cardsets')
return root
# Criação da Janela principal
window = MainWindow()
# Variável de nome do usuario
userName = StringVar()
userName.set('Player')
# Variável de endereco para conexao
currentServerAddress = StringVar()
currentServerAddress.set(DEFAULT_ADDRESS)
# Propriedades da Janela
window.title('RobRehabGUI')
window.resizable(width=False, height=False)
window.columnconfigure(1, minsize=300)
window.columnconfigure(2, minsize=300)
# Frame de apresentação do programa
headerFrame = LabelFrame(window)
headerFrame.grid(row=1, column=1, columnspan=2, pady=5)
# Label do Título
titleLabel = Label(headerFrame, width=50, height=5)
titleLabel['text'] = '''ROBOTIC REHABILITATION SYSTEM
\n\nCONTROL AND MONITORING GRAPHICAL INTERFACE'''
titleLabel['font'] = ('sans', 32, 'bold')
titleLabel.grid(row=1, column=2)
# Logos
robRehabLogo = PhotoImage(file='rehab_resized.gif')
robRehabLabel = Label(headerFrame, image=robRehabLogo)
robRehabLabel.grid(row=1, column=1, padx=10, pady=10)
def editSettings(cls):
def commitSettings(messageInDialogIn):
# Temp vars
ip = settings.serverIp
p = settings.port
settingsVars.serverIp = IPAddressBox.get()
settingsVars.port = portBox.get()
settingsVars.numberOfMessagesToGet = int(numberToGetBox.get())
settingsVars.refreshInterval = int(refreshIntervalBox.get())
if not cls.isServerActive():
settingsVars.serverIp = ip
settingsVars.port = p
tkMessageBox.showerror(message='Invalid Server Address ' +
'http://' + IPAddressBox.get() + ':' +
portBox.get() + '/')
logging.warning('Invalid Server Address ' + 'http://' +
IPAddressBox.get() + ':' + portBox.get() + '/')
messageInDialogIn.destroy()
settingsDialog = Tk()
settingsDialog.title('Settings')
if os.name == "nt":
settingsDialog.wm_iconbitmap(bitmap='images/icon.ico')
settingsDialog.columnconfigure(0, weight=1)
settingsDialog.rowconfigure(0, weight=1)
settingsDialog.minsize(width=100, height=50)
frame = Frame(settingsDialog)
addressLabel = Label(frame)
addressLabel['text'] = 'Server Address'
addressLabel.pack()
IPAddressBox = Entry(frame)
IPAddressBox.insert(0, cls.serverIp)
IPAddressBox.pack(fill='both')
portLabel = Label(frame)
portLabel['text'] = 'Server Port'
portLabel.pack()
portBox = Entry(frame)
portBox.insert(0, cls.port)
portBox.pack(fill='both')
numberToGetLabel = Label(frame)
numberToGetLabel['text'] = '# of Messages To Get'
numberToGetLabel.pack()
numberToGetBox = Entry(frame)
numberToGetBox.insert(0, cls.numberOfMessagesToGet)
numberToGetBox.pack(fill='both')
refreshIntervalLabel = Label(frame)
refreshIntervalLabel['text'] = 'Refresh Interval'
refreshIntervalLabel.pack()
refreshIntervalBox = Entry(frame)
refreshIntervalBox.insert(0, cls.refreshInterval)
refreshIntervalBox.pack(fill='both')
submitButton = Button(frame)
submitButton['text'] = 'Ok'
submitButton['command'] = lambda: commitSettings(settingsDialog)
submitButton.pack(side="left",
expand="yes",
fill="both",
padx=5,
pady=3)
cancelButton = Button(frame)
cancelButton['text'] = 'Cancel'
cancelButton['command'] = settingsDialog.destroy
cancelButton.pack(fill='both', expand="yes", padx=5, pady=3)
frame.pack(fill='both', expand="yes", padx=0, pady=0)
return settingsDialog
class GUI:
def __init__(self,
model,
title='PyCX Simulator',
interval=0,
step_size=1,
param_gui_names=None):
self.model = model
self.titleText = title
self.timeInterval = interval
self.stepSize = step_size
self.param_gui_names = param_gui_names
if param_gui_names is None:
self.param_gui_names = {}
self.param_entries = {}
self.statusStr = ""
self.running = False
self.modelFigure = None
self.currentStep = 0
self.init_gui()
def init_gui(self):
# create root window
self.rootWindow = Tk()
self.statusText = StringVar(value=self.statusStr)
self.set_status_str("Simulation not yet started")
self.rootWindow.wm_title(self.titleText)
self.rootWindow.protocol('WM_DELETE_WINDOW', self.quit_gui)
self.rootWindow.geometry('550x700')
self.rootWindow.columnconfigure(0, weight=1)
self.rootWindow.rowconfigure(0, weight=1)
self.frameSim = Frame(self.rootWindow)
self.frameSim.pack(expand=YES, fill=BOTH, padx=5, pady=5, side=TOP)
self.status = Label(self.rootWindow,
width=40,
height=3,
relief=SUNKEN,
bd=1,
textvariable=self.statusText)
self.status.pack(side=TOP, fill=X, padx=1, pady=1, expand=NO)
self.runPauseString = StringVar()
self.runPauseString.set("Run")
self.buttonRun = Button(self.frameSim,
width=30,
height=2,
textvariable=self.runPauseString,
command=self.run_event)
self.buttonRun.pack(side=TOP, padx=5, pady=5)
self.show_help(
self.buttonRun,
"Runs the simulation (or pauses the running simulation)")
self.buttonStep = Button(self.frameSim,
width=30,
height=2,
text="Step Once",
command=self.step_once)
self.buttonStep.pack(side=TOP, padx=5, pady=5)
self.show_help(self.buttonStep, "Steps the simulation only once")
self.buttonReset = Button(self.frameSim,
width=30,
height=2,
text="Reset",
command=self.reset_model)
self.buttonReset.pack(side=TOP, padx=5, pady=5)
self.show_help(self.buttonReset, "Resets the simulation")
for param in self.model.params:
var_text = self.param_gui_names.get(param, param)
can = Canvas(self.frameSim)
lab = Label(can,
width=25,
height=1 + var_text.count('\n'),
text=var_text,
anchor=W,
takefocus=0)
lab.pack(side='left')
ent = Entry(can, width=11)
val = getattr(self.model, param)
if isinstance(val, bool):
val = int(val) # Show 0/1 which can convert back to bool
ent.insert(0, str(val))
ent.pack(side='left')
can.pack(side='top')
self.param_entries[param] = ent
if self.param_entries:
self.buttonSaveParameters = Button(
self.frameSim,
width=50,
height=1,
command=self.save_parameters_cmd,
text="Save parameters to the running model",
state=DISABLED)
self.show_help(
self.buttonSaveParameters,
"Saves the parameter values.\n Not all values may take effect "
"on a running model\n A model reset might be required.")
self.buttonSaveParameters.pack(side='top', padx=5, pady=5)
self.buttonSaveParametersAndReset = Button(
self.frameSim,
width=50,
height=1,
command=self.save_parameters_and_reset_cmd,
text="Save parameters to the model and reset the model")
self.show_help(
self.buttonSaveParametersAndReset,
"Saves the given parameter values and resets the model")
self.buttonSaveParametersAndReset.pack(side='top', padx=5, pady=5)
can = Canvas(self.frameSim)
lab = Label(can,
width=25,
height=1,
text="Step size ",
justify=LEFT,
anchor=W,
takefocus=0)
lab.pack(side='left')
self.stepScale = Scale(can,
from_=1,
to=500,
resolution=1,
command=self.change_step_size,
orient=HORIZONTAL,
width=25,
length=150)
self.stepScale.set(self.stepSize)
self.show_help(
self.stepScale,
"Skips model redraw during every [n] simulation steps\n" +
" Results in a faster model run.")
self.stepScale.pack(side='left')
can.pack(side='top')
can = Canvas(self.frameSim)
lab = Label(can,
width=25,
height=1,
text="Step visualization delay in ms ",
justify=LEFT,
anchor=W,
takefocus=0)
lab.pack(side='left')
self.stepDelay = Scale(can,
from_=0,
to=max(2000, self.timeInterval),
resolution=10,
command=self.change_step_delay,
orient=HORIZONTAL,
width=25,
length=150)
self.stepDelay.set(self.timeInterval)
self.show_help(
self.stepDelay, "The visualization of each step is " +
"delays by the given number of " + "milliseconds.")
self.stepDelay.pack(side='left')
can.pack(side='top')
def set_status_str(self, new_status):
self.statusStr = new_status
self.statusText.set(self.statusStr)
# model control functions
def change_step_size(self, val):
self.stepSize = int(val)
def change_step_delay(self, val):
self.timeInterval = int(val)
def save_parameters_cmd(self):
for param, entry in self.param_entries.items():
val = entry.get()
if isinstance(getattr(self.model, param), bool):
val = bool(int(val))
setattr(self.model, param, val)
# See if the model changed the value (e.g. clipping)
new_val = getattr(self.model, param)
if isinstance(new_val, bool):
new_val = int(new_val)
entry.delete(0, END)
entry.insert(0, str(new_val))
self.set_status_str("New parameter values have been set")
def save_parameters_and_reset_cmd(self):
self.save_parameters_cmd()
self.reset_model()
def run_event(self):
if not self.running:
self.running = True
self.rootWindow.after(self.timeInterval, self.step_model)
self.runPauseString.set("Pause")
self.buttonStep.configure(state=DISABLED)
if self.param_entries:
self.buttonSaveParameters.configure(state=NORMAL)
self.buttonSaveParametersAndReset.configure(state=DISABLED)
else:
self.stop_running()
def stop_running(self):
self.running = False
self.runPauseString.set("Continue Run")
self.buttonStep.configure(state=NORMAL)
self.draw_model()
if self.param_entries:
self.buttonSaveParameters.configure(state=NORMAL)
self.buttonSaveParametersAndReset.configure(state=NORMAL)
def step_model(self):
if self.running:
if self.model.step() is True:
self.stop_running()
self.currentStep += 1
self.set_status_str("Step " + str(self.currentStep))
self.status.configure(foreground='black')
if self.currentStep % self.stepSize == 0:
self.draw_model()
self.rootWindow.after(int(self.timeInterval * 1.0 / self.stepSize),
self.step_model)
def step_once(self):
self.running = False
self.runPauseString.set("Continue Run")
self.model.step()
self.currentStep += 1
self.set_status_str("Step " + str(self.currentStep))
self.draw_model()
if self.param_entries:
self.buttonSaveParameters.configure(state=NORMAL)
self.currentStep += 1
def reset_model(self):
self.running = False
self.runPauseString.set("Run")
self.model.reset()
self.currentStep = 0
self.set_status_str("Model has been reset")
self.draw_model()
def get_point_color(self, data):
point_colors = []
for i in data:
point_colors.append([0, 0, 0, i / self.model.k])
return point_colors
def draw_model(self):
if self.modelFigure is None:
self.modelFigure = plt.figure()
ax = self.modelFigure.add_subplot(111)
xax = ax.xaxis
xax.tick_top()
points = self.init_values()
ax.axis([0, len(points[0]) + 1, 0, 100])
ax.invert_yaxis()
plt.scatter(points[0],
points[1],
c=self.get_point_color(points[2]),
s=5,
marker='s')
plt.gray()
plt.ion()
dpi = self.modelFigure.get_dpi()
self.modelFigure.set_size_inches(550.0 / float(dpi),
550.0 / float(dpi))
self.modelFigure.canvas.manager.window.resizable("false", "false")
plt.show()
if sys.platform == 'darwin':
self.modelFigure.canvas.manager.show()
else:
points = self.init_values()
plt.scatter(points[0],
points[1],
c=self.get_point_color(points[2]),
s=5,
marker='s')
self.modelFigure.canvas.manager.window.update()
def init_values(self):
data = self.model.draw()
x = []
point_value = 1
for _ in data:
x.append(point_value)
point_value += 1
t = np.empty(len(x))
t.fill(self.currentStep)
return [x, t, data]
def start(self):
if self.model.step.__doc__:
self.show_help(self.buttonStep, self.model.step.__doc__.strip())
self.model.reset()
self.draw_model()
self.rootWindow.mainloop()
def quit_gui(self):
plt.close('all')
self.rootWindow.quit()
self.rootWindow.destroy()
def show_help(self, widget, text):
def set_text(self):
self.statusText.set(text)
self.status.configure(foreground='blue')
def show_help_leave(self):
self.statusText.set(self.statusStr)
self.status.configure(foreground='black')
widget.bind("<Enter>", lambda e: set_text(self))
widget.bind("<Leave>", lambda e: show_help_leave(self))
class GUI:
def __init__(self,
model,
title='PyCX Simulator',
interval=0,
stepSize=1,
param_gui_names=None):
self.model = model
self.titleText = title
self.timeInterval = interval
self.stepSize = stepSize
self.param_gui_names = param_gui_names
if param_gui_names is None:
self.param_gui_names = {}
self.param_entries = {}
self.statusStr = ""
self.running = False
self.modelFigure = None
self.currentStep = 0
self.initGUI()
def initGUI(self):
#create root window
self.rootWindow = Tk()
self.statusText = StringVar(value=self.statusStr)
self.setStatusStr("Simulation not yet started")
self.rootWindow.wm_title(self.titleText)
self.rootWindow.protocol('WM_DELETE_WINDOW', self.quitGUI)
self.rootWindow.geometry('550x700')
self.rootWindow.columnconfigure(0, weight=1)
self.rootWindow.rowconfigure(0, weight=1)
self.frameSim = Frame(self.rootWindow)
self.frameSim.pack(expand=YES, fill=BOTH, padx=5, pady=5, side=TOP)
self.status = Label(self.rootWindow,
width=40,
height=3,
relief=SUNKEN,
bd=1,
textvariable=self.statusText)
self.status.pack(side=TOP, fill=X, padx=1, pady=1, expand=NO)
self.runPauseString = StringVar()
self.runPauseString.set("Run")
self.buttonRun = Button(self.frameSim,
width=30,
height=2,
textvariable=self.runPauseString,
command=self.runEvent)
self.buttonRun.pack(side=TOP, padx=5, pady=5)
self.showHelp(
self.buttonRun,
"Runs the simulation (or pauses the running simulation)")
self.buttonStep = Button(self.frameSim,
width=30,
height=2,
text="Step Once",
command=self.stepOnce)
self.buttonStep.pack(side=TOP, padx=5, pady=5)
self.showHelp(self.buttonStep, "Steps the simulation only once")
self.buttonReset = Button(self.frameSim,
width=30,
height=2,
text="Reset",
command=self.resetModel)
self.buttonReset.pack(side=TOP, padx=5, pady=5)
self.showHelp(self.buttonReset, "Resets the simulation")
for param in self.model.params:
var_text = self.param_gui_names.get(param, param)
can = Canvas(self.frameSim)
lab = Label(can,
width=25,
height=1 + var_text.count('\n'),
text=var_text,
anchor=W,
takefocus=0)
lab.pack(side='left')
ent = Entry(can, width=11)
val = getattr(self.model, param)
if isinstance(val, bool):
val = int(val) # Show 0/1 which can convert back to bool
ent.insert(0, str(val))
ent.pack(side='left')
can.pack(side='top')
self.param_entries[param] = ent
if self.param_entries:
self.buttonSaveParameters = Button(
self.frameSim,
width=50,
height=1,
command=self.saveParametersCmd,
text="Save parameters to the running model",
state=DISABLED)
self.showHelp(
self.buttonSaveParameters, "Saves the parameter values.\n" +
"Not all values may take effect on a running model\n" +
"A model reset might be required.")
self.buttonSaveParameters.pack(side='top', padx=5, pady=5)
self.buttonSaveParametersAndReset = Button(
self.frameSim,
width=50,
height=1,
command=self.saveParametersAndResetCmd,
text="Save parameters to the model and reset the model")
self.showHelp(
self.buttonSaveParametersAndReset,
"Saves the given parameter values and resets the model")
self.buttonSaveParametersAndReset.pack(side='top', padx=5, pady=5)
can = Canvas(self.frameSim)
lab = Label(can,
width=25,
height=1,
text="Step size ",
justify=LEFT,
anchor=W,
takefocus=0)
lab.pack(side='left')
self.stepScale = Scale(can,
from_=1,
to=500,
resolution=1,
command=self.changeStepSize,
orient=HORIZONTAL,
width=25,
length=150)
self.stepScale.set(self.stepSize)
self.showHelp(
self.stepScale,
"Skips model redraw during every [n] simulation steps\n" +
"Results in a faster model run.")
self.stepScale.pack(side='left')
can.pack(side='top')
can = Canvas(self.frameSim)
lab = Label(can,
width=25,
height=1,
text="Step visualization delay in ms ",
justify=LEFT,
anchor=W,
takefocus=0)
lab.pack(side='left')
self.stepDelay = Scale(can,
from_=0,
to=max(2000, self.timeInterval),
resolution=10,
command=self.changeStepDelay,
orient=HORIZONTAL,
width=25,
length=150)
self.stepDelay.set(self.timeInterval)
self.showHelp(
self.stepDelay, "The visualization of each step is " +
"delays by the given number of " + "milliseconds.")
self.stepDelay.pack(side='left')
can.pack(side='top')
def setStatusStr(self, newStatus):
self.statusStr = newStatus
self.statusText.set(self.statusStr)
#model control functions
def changeStepSize(self, val):
self.stepSize = int(val)
def changeStepDelay(self, val):
self.timeInterval = int(val)
def saveParametersCmd(self):
for param, entry in self.param_entries.items():
val = entry.get()
if isinstance(getattr(self.model, param), bool):
val = bool(int(val))
setattr(self.model, param, val)
# See if the model changed the value (e.g. clipping)
new_val = getattr(self.model, param)
if isinstance(new_val, bool):
new_val = int(new_val)
entry.delete(0, END)
entry.insert(0, str(new_val))
self.setStatusStr("New parameter values have been set")
def saveParametersAndResetCmd(self):
self.saveParametersCmd()
self.resetModel()
def runEvent(self):
if not self.running:
self.running = True
self.rootWindow.after(self.timeInterval, self.stepModel)
self.runPauseString.set("Pause")
self.buttonStep.configure(state=DISABLED)
if self.param_entries:
self.buttonSaveParameters.configure(state=NORMAL)
self.buttonSaveParametersAndReset.configure(state=DISABLED)
else:
self.stopRunning()
def stopRunning(self):
self.running = False
self.runPauseString.set("Continue Run")
self.buttonStep.configure(state=NORMAL)
self.drawModel()
if self.param_entries:
self.buttonSaveParameters.configure(state=NORMAL)
self.buttonSaveParametersAndReset.configure(state=NORMAL)
def stepModel(self):
if self.running:
if self.model.step() is True:
self.stopRunning()
self.currentStep += 1
self.setStatusStr("Step " + str(self.currentStep))
self.status.configure(foreground='black')
if (self.currentStep) % self.stepSize == 0:
self.drawModel()
self.rootWindow.after(int(self.timeInterval * 1.0 / self.stepSize),
self.stepModel)
def stepOnce(self):
self.running = False
self.runPauseString.set("Continue Run")
self.model.step()
self.currentStep += 1
self.setStatusStr("Step " + str(self.currentStep))
self.drawModel()
if self.param_entries:
self.buttonSaveParameters.configure(state=NORMAL)
def resetModel(self):
self.running = False
self.runPauseString.set("Run")
self.model.reset()
self.currentStep = 0
self.setStatusStr("Model has been reset")
self.drawModel()
def drawModel(self):
if self.modelFigure is None:
self.modelFigure = plt.figure()
plt.ion()
# plt.show() will cause the plot to be actually displayed
plt.show()
self.model.draw()
# Tell matplotlib to redraw too. The darwin-version works with more
# types of matplotlib backends, but seems to fail on some Linux
# machines. Hence we use the TkAgg specific method when available.
if sys.platform == 'darwin':
self.modelFigure.canvas.manager.show()
else:
self.modelFigure.canvas.manager.window.update()
def start(self):
if self.model.step.__doc__:
self.showHelp(self.buttonStep, self.model.step.__doc__.strip())
self.model.reset()
self.drawModel()
self.rootWindow.mainloop()
def quitGUI(self):
plt.close('all')
self.rootWindow.quit()
self.rootWindow.destroy()
def showHelp(self, widget, text):
def setText(self):
self.statusText.set(text)
self.status.configure(foreground='blue')
def showHelpLeave(self):
self.statusText.set(self.statusStr)
self.status.configure(foreground='black')
widget.bind("<Enter>", lambda e: setText(self))
widget.bind("<Leave>", lambda e: showHelpLeave(self))
if gameinstance.is_gameover():
if gameinstance.winner == self.marker:
return 1 # Won
elif gameinstance.winner == self.opponentmarker:
return -1 # Opponent won
return 0 # Draw
########################################################################
master = Tk()
master.title("TIC TAC TOE :")
master.style = Style()
master.configure("TButton", padding=(0, 30, 0, 30),font='serif 10')
master.configure("TFrame", background="#786")
master.columnconfigure(0, pad=3)
master.columnconfigure(1, pad=3)
master.columnconfigure(2, pad=3)
master.rowconfigure(0, pad=3)
master.rowconfigure(1, pad=3)
master.rowconfigure(2, pad=3)
master.rowconfigure(3, pad=3)
entry = Entry(self)
entry.grid(row=0, columnspan=4, sticky=W+E)
T1 = Button(self, text="_")
T1.grid(row=1, column=0)
T2 = Button(self, text="_")
T2.grid(row=1, column=1)
