def initialise(self):
self.hangman = Hangman(self)
self.my_word = StringVar()
self.my_word.set(
"Word: " +
self.hangman.word_of_underlines(len(self.hangman.word_to_guess)))
self.tried_so_far = StringVar()
self.tried_so_far.set('Letters tried so far: ')
self.guesses_left = StringVar()
self.update_no_of_guesses()
self.geometry('{}x{}'.format(545, 400))
self.grid()
word = Label(self, textvariable=self.my_word)
word.grid(column=1, row=7, sticky=W)
tried = Label(self, textvariable=self.tried_so_far)
tried.grid(column=1, row=8, sticky=W)
no_guesses = Label(self, textvariable=self.guesses_left)
no_guesses.grid(column=1, row=9, sticky=W)
turtle_canvas = Canvas(self, width=300, height=450)
self.th = TurtleHangman(turtle_canvas)
turtle_canvas.grid(column=1, row=10, rowspan=8, columnspan=3)
infotext = 'Hangman v1.0 by AML'
info = Label(self, text=infotext)
info.grid(column=4, row=12, columnspan=2)
def createWidgets(self):
"Create initial widget set."
# Objects
title = Label(self, text='Bandwidth (Gb/s)', bg=self.bg)
width = self.gwidth
height = self.gheight
scale = self.createScale()
graph = Canvas(self, width=width, height=height, background=self.bg)
xbar = Scrollbar(self, orient='horizontal', command=graph.xview)
ybar = Scrollbar(self, orient='vertical', command=self.yview)
graph.configure(xscrollcommand=xbar.set,
yscrollcommand=ybar.set,
scrollregion=(0, 0, width, height))
scale.configure(yscrollcommand=ybar.set)
# Layout
title.grid(row=0, columnspan=3, sticky='new')
scale.grid(row=1, column=0, sticky='nsew')
graph.grid(row=1, column=1, sticky='nsew')
ybar.grid(row=1, column=2, sticky='ns')
xbar.grid(row=2, column=0, columnspan=2, sticky='ew')
self.rowconfigure(1, weight=1)
self.columnconfigure(1, weight=1)
return title, scale, graph
def comboboxcallback(self, whichThread):
if TkCmdFrm.comboVar[whichThread].get() == "Single Step":
#Create a new button that is pulse
tmpCnvs = Canvas(self.cmdFrm, width=100, height=40)
tmpCnvs.grid(column = whichThread, row = 2)
tmpBtn = Button(self.cmdFrm, text="Single Step", command=lambda tmp=whichThread: self.toggle(tmp))
tmpBtn.grid(column = whichThread, row = 2, padx=4, pady=12)
TkCmdFrm.toggleBtn[whichThread] = tmpBtn
#Set the state variables
TkCmdFrm.toggleState[whichThread] = False
TkCmdFrm.threadSendStep[whichThread] = False
TkCmdFrm.threadRun[whichThread] = False
TkCmdFrm.btnCfgBitfield &= ~(1 << whichThread)
else:
#Create a new button that is toggle
tmpCnvs = Canvas(self.cmdFrm, width=100, height=40)
tmpCnvs.grid(column = whichThread, row = 2)
tmpBtn = Btn(self.cmdFrm, text="Run", command=lambda tmp=whichThread: self.toggle(tmp))
tmpBtn.grid(column = whichThread, row = 2, padx=8, pady=8)
TkCmdFrm.toggleBtn[whichThread] = tmpBtn
#Set the state variables
TkCmdFrm.toggleState[whichThread] = False
TkCmdFrm.threadSendStep[whichThread] = False
TkCmdFrm.threadRun[whichThread] = True
TkCmdFrm.btnCfgBitfield |= (1 << whichThread)
def addScrollingFigure(figure, frame):
global canvas, mplCanvas, interior, interior_id, cwid
# set up a canvas with scrollbars
canvas = Canvas(frame)
canvas.grid(row=1, column=1, sticky=Tkconstants.NSEW)
xScrollbar = Scrollbar(frame, orient=Tkconstants.HORIZONTAL)
yScrollbar = Scrollbar(frame)
xScrollbar.grid(row=2, column=1, sticky=Tkconstants.EW)
yScrollbar.grid(row=1, column=2, sticky=Tkconstants.NS)
canvas.config(xscrollcommand=xScrollbar.set)
xScrollbar.config(command=canvas.xview)
canvas.config(yscrollcommand=yScrollbar.set)
yScrollbar.config(command=canvas.yview)
# plug in the figure
figAgg = FigureCanvasTkAgg(figure, canvas)
mplCanvas = figAgg.get_tk_widget()
# and connect figure with scrolling region
cwid = canvas.create_window(0, 0, window=mplCanvas, anchor=Tkconstants.NW)
printBboxes("Init")
changeSize(figure, 1)
class MarcaFoto(Frame):
def __init__(self, root):
Frame.__init__(self, root)
self.grid(column=0, row=0)
self.canvas = Canvas(self, width=604, height=480)
self.canvas.grid(column=0, row=0, columnspan=2)
self.coords = Label(self)
self.coords.grid(column=0, row=1)
nome_arq_foto = 'turma1-640x480.gif'
self.foto = PhotoImage(file=nome_arq_foto)
self.canvas.create_image(0, 0, image=self.foto, anchor=NW)
self.canvas.bind('<Motion>', self.moveu)
self.canvas.bind('<ButtonPress>', self.marcar)
self.marca_ativa = None
def moveu(self, evento):
if self.marca_ativa is not None:
bbox = self.canvas.coords(self.marca_ativa)
bbox[2:4] = [evento.x, evento.y]
self.canvas.coords(self.marca_ativa, *bbox)
def marcar(self, evento):
if self.marca_ativa is None:
self.marca_ativa = self.canvas.create_oval(evento.x, evento.y, evento.x, evento.y,
outline='green', width=5)
else:
coords = [int(i) for i in self.canvas.coords(self.marca_ativa)]
self.coords['text'] = coords
print coords
self.marca_ativa = None
def createCanvas( self ):
"Create and return our scrolling canvas frame."
f = Frame( self )
canvas = Canvas( f, width=self.cwidth, height=self.cheight,
bg=self.bg )
# Scroll bars
xbar = Scrollbar( f, orient='horizontal', command=canvas.xview )
ybar = Scrollbar( f, orient='vertical', command=canvas.yview )
canvas.configure( xscrollcommand=xbar.set, yscrollcommand=ybar.set )
# Resize box
resize = Label( f, bg='white' )
# Layout
canvas.grid( row=0, column=1, sticky='nsew')
ybar.grid( row=0, column=2, sticky='ns')
xbar.grid( row=1, column=1, sticky='ew' )
resize.grid( row=1, column=2, sticky='nsew' )
# Resize behavior
f.rowconfigure( 0, weight=1 )
f.columnconfigure( 1, weight=1 )
f.grid( row=0, column=0, sticky='nsew' )
f.bind( '<Configure>', lambda event: self.updateScrollRegion() )
# Mouse bindings
canvas.bind( '<ButtonPress-1>', self.clickCanvas )
canvas.bind( '<B1-Motion>', self.dragCanvas )
canvas.bind( '<ButtonRelease-1>', self.releaseCanvas )
return f, canvas
def createCanvas( self ):
"Create and return our scrolling canvas frame."
f = Frame( self )
canvas = Canvas( f, width=self.cwidth, height=self.cheight,
bg=self.bg )
# Scroll bars
xbar = Scrollbar( f, orient='horizontal', command=canvas.xview )
ybar = Scrollbar( f, orient='vertical', command=canvas.yview )
canvas.configure( xscrollcommand=xbar.set, yscrollcommand=ybar.set )
# Resize box
resize = Label( f, bg='white' )
# Layout
canvas.grid( row=0, column=1, sticky='nsew')
ybar.grid( row=0, column=2, sticky='ns')
xbar.grid( row=1, column=1, sticky='ew' )
resize.grid( row=1, column=2, sticky='nsew' )
# Resize behavior
f.rowconfigure( 0, weight=1 )
f.columnconfigure( 1, weight=1 )
f.grid( row=0, column=0, sticky='nsew' )
f.bind( '<Configure>', lambda event: self.updateScrollRegion() )
# Mouse bindings
canvas.bind( '<ButtonPress-1>', self.clickCanvas )
canvas.bind( '<B1-Motion>', self.dragCanvas )
canvas.bind( '<ButtonRelease-1>', self.releaseCanvas )
return f, canvas
def __init__(self, root, width, height, app):
self.holiday_manager = app.holiday_manager
self.root = root
today = datetime.date.today()
self.month = today.month
self.year = today.year
self.month_label = Label(root, text=self.months[today.month] + " " + str(today.year))
self.month_label.grid(row=1)
win = Canvas(root, width=width, height=height)
win.grid(ipadx=10, ipady=10) # Places canvas on screen
self.canvas = win
self.calendar = calendar.Calendar()
self.rows = 6
self.columns = 7
self.box_width = width / self.columns
self.box_height = height / self.rows
self.boxes = self.__generate_boxes(self.rows * self.columns)
self.__draw_weekday_names()
self.draw_month(today.month, today.year)
def comboboxcallback(self, whichThread):
if TkCmdFrm.comboVar[whichThread].get() == "Single Step":
#Create a new button that is pulse
tmpCnvs = Canvas(self.cmdFrm, width=100, height=40)
tmpCnvs.grid(column=whichThread, row=2)
tmpBtn = Button(self.cmdFrm,
text="Single Step",
command=lambda tmp=whichThread: self.toggle(tmp))
tmpBtn.grid(column=whichThread, row=2, padx=4, pady=12)
TkCmdFrm.toggleBtn[whichThread] = tmpBtn
#Set the state variables
TkCmdFrm.toggleState[whichThread] = False
TkCmdFrm.threadSendStep[whichThread] = False
TkCmdFrm.threadRun[whichThread] = False
TkCmdFrm.btnCfgBitfield &= ~(1 << whichThread)
else:
#Create a new button that is toggle
tmpCnvs = Canvas(self.cmdFrm, width=100, height=40)
tmpCnvs.grid(column=whichThread, row=2)
tmpBtn = Btn(self.cmdFrm,
text="Run",
command=lambda tmp=whichThread: self.toggle(tmp))
tmpBtn.grid(column=whichThread, row=2, padx=8, pady=8)
TkCmdFrm.toggleBtn[whichThread] = tmpBtn
#Set the state variables
TkCmdFrm.toggleState[whichThread] = False
TkCmdFrm.threadSendStep[whichThread] = False
TkCmdFrm.threadRun[whichThread] = True
TkCmdFrm.btnCfgBitfield |= (1 << whichThread)
class canvasInterface(interfaceScreen):
def __init__(self,master,width,height):
interfaceScreen.__init__(self)
self.canvas = Canvas(master, width=width, height=height,bg='white')
self.canvas.grid(row=0,column=1)
"""
---------------Interfaz con objeto dibujante---------------------
"""
def deleteFromCanvas(self,id):
self.canvas.delete(id)
pass
def create_rectangle(self,x1, y1, x2, y2,*arg,**kargs):
return self.canvas.create_rectangle(x1, y1, x2, y2,*arg,**kargs)
pass
def create_line(self,x1, y1, x2, y2, *args,**kwargs):
return self.canvas.create_line(x1, y1, x2, y2, *args,**kwargs)
def create_text(self,x1, y1,*args,**kargs):
return self.canvas.create_text(x1, y1,*args,**kargs)
def scan_mark(self,x,y):
self.canvas.scan_mark(x, y)
def scan_dragto(self,x, y, *args,**kwargs):
self.canvas.scan_dragto(x, y, *args,**kwargs)
def winfo_height(self):
return self.canvas.winfo_height()
def winfo_width(self):
return self.canvas.winfo_width()
class ScrolledCanvas(Frame):
def __init__(self,
parent,
width=100,
height=100,
bg="white",
scrollregion=(0, 0, 300, 300)):
Frame.__init__(self, parent)
self.canvas = Canvas(self,
width=width - 20,
height=height - 20,
bg=bg,
scrollregion=scrollregion)
self.canvas.grid(row=0, column=0)
scv = Scrollbar(self, orient="vertical", command=self.canvas.yview)
sch = Scrollbar(self, orient="horizontal", command=self.canvas.xview)
self.canvas.configure(xscrollcommand=sch.set, yscrollcommand=scv.set)
scv.grid(row=0, column=1, sticky="ns")
sch.grid(row=1, column=0, sticky="ew")
self.bind("<Configure>", self.resize)
self.config = False
self.bind("<Configure>", self.resize)
def get_canvas(self):
return self.canvas
def resize(self, event):
if self.config:
self.width, self.height = self.winfo_width(), self.winfo_height()
self.canvas.config(width=self.width - 20, height=self.height - 20)
else:
self.config = True
def __init__(self):
self.app = Tk()
self.app.title('Connect4')
self.app.resizable(width=False, height=False)
self.board = Board()
self.buttons = {}
self.frame = Frame(self.app, borderwidth=1, relief="raised")
self.tiles = {}
for x in range(self.board.width):
handler = lambda x=x: self.move(x)
button = Button(self.app,
command=handler,
font=Font(family="Helvetica", size=14),
text=x + 1)
button.grid(row=0, column=x, sticky="WE")
self.buttons[x] = button
self.frame.grid(row=1, column=0, columnspan=self.board.width)
for x, y in self.board.fields:
tile = Canvas(self.frame,
width=60,
height=50,
bg="navy",
highlightthickness=0)
tile.grid(row=self.board.height - 1 - y, column=x)
self.tiles[x, y] = tile
handler = lambda: self.reset()
self.restart = Button(self.app, command=handler, text='reset')
self.restart.grid(row=2,
column=0,
columnspan=self.board.width,
sticky="WE")
self.update()
def comboboxcallback(self, bit):
if self.indBitOptMenu[bit].get() == "Pulse":
#Create a new button that is pulse
tmpCnvs = Canvas(self.bitFrms[bit], width=100, height=40)
tmpCnvs.grid(column=0, row=2, columnspan=2)
tmpBtn = Button(self.bitFrms[bit],
text="SimSwitch",
command=lambda tmp=bit: self.toggle(tmp))
tmpBtn.grid(column=0, row=2, columnspan=2, padx=4, pady=12)
self.toggleBtn[bit] = tmpBtn
#Set the state variables
self.toggleState[bit] = False
self.btnCfgBitfield &= ~(1 << bit)
self.simSwitchBits &= ~(1 << bit)
else:
#Create a new button that is toggle
tmpCnvs = Canvas(self.bitFrms[bit], width=100, height=40)
tmpCnvs.grid(column=0, row=2, columnspan=2)
tmpBtn = Btn(self.bitFrms[bit],
text="SimSwitch",
command=lambda tmp=bit: self.toggle(tmp))
tmpBtn.grid(column=0, row=2, columnspan=2, padx=8, pady=8)
self.toggleBtn[bit] = tmpBtn
#Set the state variables
self.btnCfgBitfield |= (1 << bit)
if self.toggleState[bit]:
self.simSwitchBits |= (1 << bit)
else:
self.simSwitchBits &= ~(1 << bit)
def comboboxcallback(self, bit):
if self.indBitOptMenu[bit].get() == "Pulse":
#Create a new button that is pulse
tmpCnvs = Canvas(self.bitFrms[bit], width=100, height=40)
tmpCnvs.grid(column = 0, row = 2, columnspan = 2)
tmpBtn = Button(self.bitFrms[bit], text="SimSwitch", command=lambda tmp=bit: self.toggle(tmp))
tmpBtn.grid(column = 0, row = 2, columnspan = 2, padx=4, pady=12)
self.toggleBtn[bit] = tmpBtn
#Set the state variables
self.toggleState[bit] = False
self.btnCfgBitfield &= ~(1 << bit)
self.simSwitchBits &= ~(1 << bit)
else:
#Create a new button that is toggle
tmpCnvs = Canvas(self.bitFrms[bit], width=100, height=40)
tmpCnvs.grid(column = 0, row = 2, columnspan = 2)
tmpBtn = Btn(self.bitFrms[bit], text="SimSwitch", command=lambda tmp=bit: self.toggle(tmp))
tmpBtn.grid(column = 0, row = 2, columnspan = 2, padx=8, pady=8)
self.toggleBtn[bit] = tmpBtn
#Set the state variables
self.btnCfgBitfield |= (1 << bit)
if self.toggleState[bit]:
self.simSwitchBits |= (1 << bit)
else:
self.simSwitchBits &= ~(1 << bit)
def __init__(self, parent, tile_size, grid_vm=None):
Frame.__init__(self, parent, relief=RAISED, borderwidth=1)
self.parent = parent
self.tile_size = tile_size
self.grid_vm = grid_vm
self.columnconfigure(0, weight=1)
self.columnconfigure(1, pad=3)
self.rowconfigure(0, weight=1)
self.rowconfigure(1, pad=3)
hbar = Scrollbar(self, orient=HORIZONTAL)
vbar = Scrollbar(self, orient=VERTICAL)
canvas = Canvas(self, xscrollcommand=hbar.set, yscrollcommand=vbar.set)
self.canvas = canvas
self.lines = []
canvas.bind_all("<MouseWheel>", self._on_mousewheel_vertical)
canvas.bind_all("<Shift-MouseWheel>", self._on_mousewheel_horizontal)
# Set up scroll bars
hbar.pack(side=BOTTOM, fill=X)
hbar.config(command=canvas.xview)
vbar.pack(side=RIGHT, fill=Y)
vbar.config(command=canvas.yview)
canvas.grid(column=0, row=0, sticky=N + W + E + S)
hbar.grid(column=0, row=1, sticky=W + E)
vbar.grid(column=1, row=0, sticky=N + S)
if grid_vm:
self.set_vm(grid_vm)
def __init__(self, filename, parentnotebook):
"""Create a new EditTab
Argument
filename -- name and path to the file being edited
parentnotebook -- the NoteBook in which this tab will be added
"""
Frame.__init__(self)
self._filename = filename
self._parentnotebook = parentnotebook
self._inputs = []
self.path = os.path.dirname(filename)
self._dirty = False
parentnotebook.add(self, state = 'normal')
self._setLabel()
#Set up GUI
self.rowconfigure(0, weight = 1)
self.columnconfigure(0, weight = 1)
vscroll = Scrollbar(self, orient = VERTICAL)
self._vscroll = vscroll
vscroll.grid(row=0, column=1, sticky=N+S)
hscroll = Scrollbar(self, orient = HORIZONTAL)
self._hscroll = hscroll
hscroll.grid(row=1, column=0, sticky=E+W)
canvas = Canvas(self, yscrollcommand = vscroll.set, xscrollcommand = hscroll.set)
self._canvas = canvas
canvas.grid(row = 0, column = 0, padx = 5, pady = 5, sticky = NSEW)
vscroll['command'] = canvas.yview
hscroll['command'] = canvas.xview
scrollframe = Frame(canvas)
self._scrollframe = scrollframe
canvas.create_window(0, 0, window = scrollframe, anchor = N + W)
scrollframe.rowconfigure(0, weight = 1)
scrollframe.columnconfigure(0, weight = 1)
self._mainframe = Frame(scrollframe)
self._mainframe.grid(row = 0, column = 0, padx = 5, pady = 5, sticky = NSEW)
cf = Frame(scrollframe)
self._control_frame = cf
cf.grid(row = 1, column = 0, padx = 5, pady = 5, sticky = E)
b = Button(cf, text = lang[lng.txtCopyImages], command = self._ehCopyImages)
self._btnCopy = b
b.grid(row = 0, column = 0, padx = 5, pady = 5)
b = Button(cf, text = lang[lng.txtSave], command = self._ehSave, state = DISABLED)
self._btnSave = b
b.grid(row = 0, column = 1, padx = 5, pady = 5)
b = Button(cf, text = lang[lng.txtClose], command = self._ehClose)
b.grid(row = 0, column = 2, padx = 5, pady = 5)
parentnotebook.after_idle(self._setCanvas)
def layout(self):
canvas = Canvas(self.Widget, width=400, height=10)
canvas.create_line(10, 2, 400, 2, fill='black', tags="line")
self.rowindex = self.rowindex + 1
canvas.grid(row=self.rowindex, column=1, columnspan=4)
lblTarget = Label(self.Widget,
text=self.conf.get("TargetDeviceName", "title",
"目标设备"),
font=self.fontSize)
lblTarget.grid(row=self.rowindex, column=1, columnspan=4)
lblTargetW = Label(self.Widget,
text=self.conf.get("TargetDeviceName", "width",
"宽度（px）"),
font=self.fontSize)
self.rowindex = self.rowindex + 1
lblTargetW.grid(row=self.rowindex, column=1)
entryTargetW = Entry(self.Widget, width=10, font=self.fontSize)
entryTargetW.grid(row=self.rowindex, column=2)
self.entryTargetW = entryTargetW
lblTargetH = Label(self.Widget,
text=self.conf.get("TargetDeviceName", "width",
"高度（px）"),
font=self.fontSize)
lblTargetH.grid(row=self.rowindex, column=3)
entryTargetH = Entry(self.Widget, width=10, font=self.fontSize)
entryTargetH.grid(row=self.rowindex, column=4)
self.entryTargetH = entryTargetH
fmBox = Frame(self.Widget)
scrollbar = Scrollbar(fmBox)
scrollbar.pack(side=RIGHT, fill=Y)
lb = Listbox(fmBox,
yscrollcommand=scrollbar.set,
width=25,
selectmode=EXTENDED)
lb.pack(side=LEFT, fill=BOTH)
scrollbar.config(command=lb.yview)
self.rowindex = self.rowindex + 1
fmBox.grid(row=self.rowindex, column=1, columnspan=2)
self.lb = lb
fmOper = Frame(self.Widget)
fmAdd = Frame(fmOper, pady=10)
btAdd = Button(fmAdd, text="添加", command=self.processAdd)
btAdd.pack()
fmDel = Frame(fmOper, pady=10)
btDel = Button(fmDel, text="删除", command=self.processDel)
btDel.pack()
fmAdd.pack(side=TOP)
fmDel.pack(side=BOTTOM)
fmOper.grid(row=self.rowindex, column=3)
canvas = Canvas(self.Widget, width=400, height=10)
canvas.create_line(10, 2, 400, 2, fill='black', tags="line")
self.rowindex = self.rowindex + 1
canvas.grid(row=self.rowindex, column=1, columnspan=4)
self.readDefDevice()
return self.rowindex
def __init__(self):
self.board = Board()
self.app = Tk()
message = "Connect" + str(self.board.connect) + " on Board : " + str(
self.board.width) + "x" + str(self.board.height)
self.app.title(message)
self.app.resizable(width=False, height=False)
self.buttons = {}
self.frame = Frame(self.app, borderwidth=1, relief="raised")
self.tiles = {}
self.flag = True
self.game = False
self.inputx = []
self.turnCount = 0
self.p1_positions, self.p2_positions = [], []
self.p1 = PlayerType(
int(input('Player 1 is :\n1. Human \n2. Bot \n3. Random \n\n')))
self.p2 = PlayerType(
int(input('\nPlayer 2 is :\n1. Bot \n2. Random \n\n')) + 1)
self.human_flag = self.p1.name == "Human" or self.p2.name == "Human"
for x in range(self.board.width):
handler = lambda x=x: self.input(x)
button = Button(self.app,
command=handler,
font=Font(family="Helvetica", size=14),
text=x + 1)
button.grid(row=0, column=x, sticky="WE")
self.buttons[x] = button
self.frame.grid(row=1, column=0, columnspan=self.board.width)
if not self.human_flag:
for x in range(self.board.width):
self.buttons[x]['state'] = 'disabled'
handler = lambda: self.autoplay()
self.auto = Button(self.app, command=handler, text='Next')
self.auto.grid(row=3,
column=0,
columnspan=self.board.width,
sticky="WE")
for x, y in self.board.fields:
tile = Canvas(self.frame,
width=60,
height=50,
bg="navy",
highlightthickness=0)
tile.grid(row=self.board.height - 1 - y, column=x)
self.tiles[x, y] = tile
handler = lambda: self.reset()
self.restart = Button(self.app, command=handler, text='Reset')
self.restart.grid(row=2,
column=0,
columnspan=self.board.width,
sticky="WE")
self.game = self.update()
def __init__(self, master, app):
Frame.__init__(self, master)
self.app = app
self.proxy = app.proxy
self.config(background=factory.bg())
canvas = Canvas(self,
width=gconfig["graph-width"],
height=gconfig["graph-height"],
background=gconfig["graph-fill"])
self.canvas = canvas
info_canvas = InfoCanvas(self)
self.info_canvas = info_canvas
info_canvas.grid(row=0,
column=0,
rowspan=1,
columnspan=1,
sticky='wns')
canvas.grid(row=0, column=1, rowspan=1, columnspan=1, sticky='nsew')
self.grid_rowconfigure(0, weight=1)
self.grid_rowconfigure(1, weight=0)
self.grid_columnconfigure(0, weight=0)
self.grid_columnconfigure(1, weight=1)
# toolbar buttons
def tbutton(col, text, command=None):
bwidth = 75
b = factory.button(self.canvas, text, command=command)
y0 = 15
x0 = 15
x = x0 + col * bwidth
b.place(x=x, y=y0, width=bwidth)
tbutton(0, 'sync', self.sync)
tbutton(1, '+Audio', self.add_audio_bus)
tbutton(2, "+Control", self.add_control_bus)
tbutton(3, "Align", self.allign_tokens)
self.synth_tokens = {} # map [sid] -> SynthToken
self.audio_bus_tokens = {} # map [bus-name] -> BusToken
self.control_bus_tokens = {}
self.current_token_and_port = None # (token,port) dragdrop source
self.current_allied_ports = []
self._drag_data = {
'x': 0,
'y': 0,
'anchor-x': 0,
'anchor-y': 0,
'port1': None,
#'port2' : None,
'rubberband': None
}
canvas.bind("<B1-Motion>", self.bus_drag)
canvas.bind("<ButtonPress-1>", self.bus_drag_pickup)
canvas.bind("<ButtonRelease-1>", self.bus_drop)
class ScrollFrame(Frame):
def __init__(self, parent, medium_changers=None,device=None):
Frame.__init__(self, master=parent)
# init all the stuff we need later on
self._widgets = None
self._medium_changers = medium_changers
self._device = device
# trick part, get this damn thing scrolling in the right place
self.grid(stick='nsew')
self.rowconfigure(0,weight=1)
self.columnconfigure(0,weight=1)
self.config(height= 380, width= 300)
self.grid_propagate(0)
# with a little help, preparing the scrollbar. The final setup happens
# in the special Slot Class
self._sbar = AutoScrollbar(self)
self._sbar.grid(row=0,column=1,stick='ns')
self._canv = Canvas(self, yscrollcommand=self._sbar.set)
self._canv.grid(row=0,column=0,stick='nswe')
self._sbar.config(command=self._canv.yview)
self.createWidgets()
@property
def device(self):
return self._device
@property
def canv(self):
return self._canv
@property
def sbar(self):
return self._sbar
@property
def mediumchangers(self):
return self._medium_changers
@property
def widgets(self):
return self._widgets
@widgets.setter
def widgets(self, value):
self._widgets = value
@classmethod
def createWidgets(cls):
print 'if you see this you did it wrong !!!'
def init_ui(self):
self.rowconfigure(3, weight=1)
self.columnconfigure(0, weight=1)
self.button_load_type = Button(self, text="Load Type JSON", command=lambda: browse_file(self, 1, ))
self.button_load_type.grid(
row=0, columnspan=2, sticky=W + E, pady=4, padx=5)
self.button_load_color = Button(
self, text="Load Color JSON", command=lambda: browse_file(self, 2))
self.button_load_color.grid(
row=1, columnspan=2, sticky=W + E, pady=4, padx=5)
button_load = Button(
self, text="Load Images", command=lambda: browse_images(self))
button_load.grid(row=2, columnspan=2, sticky=W + E, pady=4, padx=5)
button_learn = Button(
self,
text="Test",
command=
lambda: start_testing(self.dtype, self.dcolor, self.picture_frames)
)
button_learn.grid(row=4, columnspan=2, sticky=W + E, pady=4, padx=5)
canvas = Canvas(self)
canvas.grid(row=3, sticky=W + E + N + S, column=0, pady=4, padx=5)
frame = self.picture_frame = Frame(canvas)
canvas.create_window(0, 0, window=frame, anchor='nw')
scroll_bar = Scrollbar(self, orient="vertical", command=canvas.yview)
scroll_bar.grid(sticky=E + N + S, padx=5, row=3, column=1)
canvas.configure(yscrollcommand=scroll_bar.set)
# track changes to the canvas and frame width and sync them,
# also updating the scrollbar
def _configure_interior(event):
# update the scrollbars to match the size of the inner frame
size = (frame.winfo_reqwidth(), frame.winfo_reqheight())
canvas.config(scrollregion="0 0 %s %s" % size)
if frame.winfo_reqwidth() != canvas.winfo_width():
# update the canvas's width to fit the inner frame
canvas.config(width=frame.winfo_reqwidth())
frame.bind('<Configure>', _configure_interior)
def _configure_canvas(event):
if frame.winfo_reqwidth() != canvas.winfo_width():
# update the inner frame's width to fill the canvas
canvas.itemconfigure(frame, width=canvas.winfo_width())
canvas.bind('<Configure>', _configure_canvas)
class JoystickFrame(LabelFrame):
def __init__(self, master, tracker, text="Joystick", **options):
LabelFrame.__init__(self, master, text=text, **options)
self.tracker = tracker
self.width = 400
self.height = 400
self.canvas = Canvas(self, height=self.height, width=self.width)
self.canvas.grid()
self.canvas.create_oval((self.width/2 - 3, self.height/2 - 3,
self.width/2 + 3, self.height/2 + 3))
self.canvas.bind("<Button-1>",
bg_caller(lambda event: self.move_tracker(event)))
self.canvas.bind("<Motion>", self.update_label)
self.motion_label = Label(self, text="",
font=tkFont.Font(family="Courier"))
self.motion_label.grid()
f = LabelFrame(self, text="Sensitivity")
self.sensitivity_scale = Scale(f, from_=0, to=10,
resolution=0.01,
orient=HORIZONTAL,
length=self.width)
self.sensitivity_scale.set(5)
self.sensitivity_scale.grid()
f.grid()
@property
def sensitivity(self):
return self.sensitivity_scale.get() / 2000.
def get_delta(self, event):
dx = event.x - int(self.canvas['width'])/2.
dy = event.y - int(self.canvas['height'])/2.
dx_rad = dx*self.sensitivity
dy_rad = dy*self.sensitivity
dtheta = dy_rad
dphi = -dx_rad
return (dtheta, dphi)
def update_label(self, event):
dtheta, dphi = self.get_delta(event)
self.motion_label.configure(text="<{:8.5f}, {:8.5f}>".format(dtheta,
dphi))
def move_tracker(self, event):
dtheta, dphi = self.get_delta(event)
self.tracker.move(0, dtheta, dphi)
logger.info("Moved tracker by ({}, {})".format(dtheta, dphi))
def view_stack():
inputstring = u2_entry.get()
row, ste, sta, inp, act = process_input(inputstring)
print inputstring
show = Toplevel(master)
show.title("Stack Implementation")
show.geometry("%dx%d%+d%+d" % (1300, 1300, 0, 0))
canvas = Canvas(show, width=2000, height=1000)
canvas.grid(row=0, column=0)
row = row - 1
col = 4
m, a = 10, 10
n = 100
b = 125
for i in range(len(sta)):
canvas.create_text(a + 60, b + 15, text=i + 1, font="Times 15 bold")
canvas.create_text(a + 60 + 260,
b + 15,
text=sta[i],
font="Times 15 bold")
canvas.create_text(a + 60 + 400,
b + 15,
text=inp[i],
font="Times 15 bold")
canvas.create_text(a + 60 + 660,
b + 15,
text=act[i],
font="Times 15 bold")
b = b + 30
for i in range(0, row + 1):
for j in range(0, col):
print(m, n)
canvas.create_rectangle(m, n, m + 200, n + 30)
m = m + 200
m = 10
n = n + 30
print ste, sta, inp, act
canvas.create_text(65, 110, text="S.N.", font="Times 15 bold")
canvas.create_text(285, 110, text="Stack", font="Times 15 bold")
canvas.create_text(475, 110, text="Input", font="Times 15 bold")
canvas.create_text(665, 110, text="Action", font="Times 15 bold")
show.geometry("%dx%d%+d%+d" % (1300, 800, 0, 0))
class VerticalScrolledFrame(Frame):
"""A pure Tkinter scrollable frame that actually works!
* Use the 'interior' attribute to place widgets inside the scrollable frame
* Construct and pack/place/grid normally
* This frame only allows vertical scrolling
"""
def _configure_interior(self, event):
# update the scrollbars to match the size of the inner frame
size = (self.interior.winfo_reqwidth(),
self.interior.winfo_reqheight())
self.canvas.config(scrollregion="0 0 %s %s" % size)
if self.interior.winfo_reqwidth() != self.canvas.winfo_width():
# update the canvas's width to fit the inner frame
self.canvas.config(width=self.interior.winfo_reqwidth())
self.interior.bind('<Configure>', _configure_interior)
def _configure_canvas(self, event):
if self.interior.winfo_reqwidth() != self.canvas.winfo_width():
# update the inner frame's width to fill the canvas
self.canvas.itemconfigure(self.interior_id,
width=self.canvas.winfo_width())
self.canvas.bind('<Configure>', _configure_canvas)
return
def configure_scrolling(self):
# create a canvas object and a vertical scrollbar for scrolling it
vscrollbar = Scrollbar(self, orient='vertical')
vscrollbar.grid(row=0, column=1, sticky='nsw')
self.canvas = Canvas(self,
bd=0,
highlightthickness=0,
yscrollcommand=vscrollbar.set)
self.canvas.grid(row=0, column=0, sticky='nsew')
vscrollbar.config(command=self.canvas.yview)
# reset the view
self.canvas.xview_moveto(0)
self.canvas.yview_moveto(0)
# create a frame inside the canvas which will be scrolled with it
self.interior = interior = Frame(self.canvas)
self.interior.grid(row=0, column=0, sticky='nsew')
self.interior_id = self.canvas.create_window(0,
0,
window=interior,
anchor='nw')
def __init__(self, master, app):
Frame.__init__(self, master)
self.app = app
self.proxy = app.proxy
self.config(background=factory.bg())
canvas = Canvas(self,
width=gconfig["graph-width"],
height=gconfig["graph-height"],
background=gconfig["graph-fill"])
self.canvas = canvas
info_canvas = InfoCanvas(self)
self.info_canvas = info_canvas
info_canvas.grid(row=0,column=0,rowspan=1,columnspan=1, sticky='wns')
canvas.grid(row=0,column=1,rowspan=1,columnspan=1, sticky='nsew')
self.grid_rowconfigure(0, weight=1)
self.grid_rowconfigure(1, weight=0)
self.grid_columnconfigure(0, weight=0)
self.grid_columnconfigure(1, weight=1)
# toolbar buttons
def tbutton(col, text, command=None):
bwidth=75
b = factory.button(self.canvas, text,command=command)
y0 = 15
x0 = 15
x = x0+col*bwidth
b.place(x=x,y=y0,width=bwidth)
tbutton(0, 'sync', self.sync)
tbutton(1, '+Audio', self.add_audio_bus)
tbutton(2, "+Control", self.add_control_bus)
tbutton(3, "Align", self.allign_tokens)
self.synth_tokens = {} # map [sid] -> SynthToken
self.audio_bus_tokens = {} # map [bus-name] -> BusToken
self.control_bus_tokens = {}
self.current_token_and_port = None # (token,port) dragdrop source
self.current_allied_ports = []
self._drag_data = {'x': 0,
'y': 0,
'anchor-x' : 0,
'anchor-y' : 0,
'port1' : None,
#'port2' : None,
'rubberband' : None}
canvas.bind("<B1-Motion>", self.bus_drag)
canvas.bind("<ButtonPress-1>", self.bus_drag_pickup)
canvas.bind("<ButtonRelease-1>", self.bus_drop)
def put_image(self, data):
# print type(photo)
photo=data[0]
name = data[1]
if self.column_count > GUI.max_count-1:
self.column_count = 0
self.row_count += 2
canvas = Canvas(self.picture_frame, width=100, height=100)
canvas.grid(row=self.row_count, column=self.column_count, padx=3, pady=3)
self.put_oncanvas(canvas, photo) #put on canvas
text = Label(self.picture_frame, text=name)
text.grid(row=self.row_count+1, column=self.column_count, sticky=S, padx=3, pady=3)
self.column_count += 1
cimage = name.split('.')
self.picture_frames.append([cimage[0][0], cimage[0][1], photo])
def __init__(self, parent):
master = Frame(parent, bg = 'green')
master.grid(sticky = W + N + E + S)
master.rowconfigure(0, weight = 1)
master.columnconfigure(0, weight = 1)
canvas = Canvas(master)
self._canvas = canvas
canvas.grid(row = 0, column = 0, sticky = W + N + E + S)
hScroll = Scrollbar(master, orient = HORIZONTAL, command = canvas.xview)
hScroll.grid(row = 1, column = 0, sticky = W + E)
vScroll = Scrollbar(master, orient = VERTICAL, command = canvas.yview)
vScroll.grid(row = 0, column = 1, sticky = N + S)
canvas.configure(xscrollcommand = hScroll.set, yscrollcommand = vScroll.set)
Frame.__init__(self, canvas, bg = 'blue')
canvas.create_window(0, 0, window = self, anchor = N + W)
def put_image(self, photo):
# print type(photo)
if self.column_count > GUI.max_count-1:
self.column_count = 0
self.row_count += 2
canvas = Canvas(self.picture_frame, width=100, height=100)
canvas.grid(row=self.row_count, column=self.column_count, padx=3, pady=3)
self.put_oncanvas(canvas, photo) #put on canvas
text_var = StringVar()
text_var.set('Un-Tested')
text = Label(self.picture_frame, textvariable=text_var)
text.grid(row=self.row_count+1, column=self.column_count, sticky=S, padx=3, pady=3)
self.column_count += 1
self.picture_frames.append([photo, text_var])
class ScrolledCanvas:
def __init__(self, master, **opts):
if not opts.has_key('yscrollincrement'):
opts['yscrollincrement'] = 17
self.master = master
self.frame = Frame(master)
self.frame.rowconfigure(0, weight=1)
self.frame.columnconfigure(0, weight=1)
self.canvas = Canvas(self.frame, **opts)
self.canvas.grid(row=0, column=0, sticky="nsew")
self.vbar = Scrollbar(self.frame, name="vbar")
self.vbar.grid(row=0, column=1, sticky="nse")
self.hbar = Scrollbar(self.frame, name="hbar", orient="horizontal")
self.hbar.grid(row=1, column=0, sticky="ews")
self.canvas['yscrollcommand'] = self.vbar.set
self.vbar['command'] = self.canvas.yview
self.canvas['xscrollcommand'] = self.hbar.set
self.hbar['command'] = self.canvas.xview
self.canvas.bind("<Key-Prior>", self.page_up)
self.canvas.bind("<Key-Next>", self.page_down)
self.canvas.bind("<Key-Up>", self.unit_up)
self.canvas.bind("<Key-Down>", self.unit_down)
#if isinstance(master, Toplevel) or isinstance(master, Tk):
self.canvas.bind("<Alt-Key-2>", self.zoom_height)
self.canvas.focus_set()
def page_up(self, event):
self.canvas.yview_scroll(-1, "page")
return "break"
def page_down(self, event):
self.canvas.yview_scroll(1, "page")
return "break"
def unit_up(self, event):
self.canvas.yview_scroll(-1, "unit")
return "break"
def unit_down(self, event):
self.canvas.yview_scroll(1, "unit")
return "break"
def zoom_height(self, event):
ZoomHeight.zoom_height(self.master)
return "break"
def displayResults(master, text):
#Now display the results
from GtBurst import SubWindow
from GtBurst.fontDefinitions import NORMALFONT
from GtBurst import AutoHideScrollbar
from Tkinter import Canvas
from Tkinter import Text, W, E, N, S, INSERT
try:
sub = SubWindow.SubWindow(
master,
initialhint=
"Results of the last likelihood analysis. Select 'close' from the file menu to close this window.",
title="Likelihood results")
sub.bottomtext.config(height=3)
except:
#Cannot display the results. Oh, well...
raise
else:
helpscrollbar = AutoHideScrollbar.AutoHideScrollbar(sub.frame)
helptextCanvas = Canvas(sub.frame, yscrollcommand=helpscrollbar.set)
bottomtext = Text(helptextCanvas,
wrap='word',
height=30,
width=100,
yscrollcommand=helpscrollbar.set,
bg='white')
helpscrollbar.config(command=bottomtext.yview)
bottomtext.grid(row=0, column=0, sticky=W + E + N + S)
bottomtext.mark_set("beginning", INSERT)
bottomtext.insert("beginning", text)
bottomtext.config(state='disabled')
helptextCanvas.grid(row=0, column=0)
helpscrollbar.grid(row=0, column=1, sticky=W + E + N + S)
pass
class VerticalScrolledFrame(Frame):
"""A pure Tkinter scrollable frame that actually works!
* Use the 'interior' attribute to place widgets inside the scrollable frame
* Construct and pack/place/grid normally
* This frame only allows vertical scrolling
"""
def _configure_interior(self,event):
# update the scrollbars to match the size of the inner frame
size = (self.interior.winfo_reqwidth(), self.interior.winfo_reqheight())
self.canvas.config(scrollregion="0 0 %s %s" % size)
if self.interior.winfo_reqwidth() != self.canvas.winfo_width():
# update the canvas's width to fit the inner frame
self.canvas.config(width=self.interior.winfo_reqwidth())
self.interior.bind('<Configure>', _configure_interior)
def _configure_canvas(self,event):
if self.interior.winfo_reqwidth() != self.canvas.winfo_width():
# update the inner frame's width to fill the canvas
self.canvas.itemconfigure(self.interior_id, width=self.canvas.winfo_width())
self.canvas.bind('<Configure>', _configure_canvas)
return
def configure_scrolling(self):
# create a canvas object and a vertical scrollbar for scrolling it
vscrollbar = Scrollbar(self, orient='vertical')
vscrollbar.grid(row=0,column=1,sticky='nsw')
self.canvas = Canvas(self, bd=0, highlightthickness=0,
yscrollcommand=vscrollbar.set)
self.canvas.grid(row=0,column=0,sticky='nsew')
vscrollbar.config(command=self.canvas.yview)
# reset the view
self.canvas.xview_moveto(0)
self.canvas.yview_moveto(0)
# create a frame inside the canvas which will be scrolled with it
self.interior = interior = Frame(self.canvas)
self.interior.grid(row=0,column=0,sticky='nsew')
self.interior_id = self.canvas.create_window(0, 0, window=interior,
anchor='nw')
def run():
"""
Esegue l'emulatore del pdp8
"""
CD = pdp8()
principale = Tk()
principale.title("Pdp8 Emulator : Assembly Editor")
emulatore = Toplevel()
emulatore.title("Pdp8 Emulator")
emulatore.geometry("1015x589")
edit = Editor(principale, CD)
scrollbar1 = AutoScrollbar(emulatore)
scrollbar1.grid(row=0, column=1, sticky=N + S)
scrollbar2 = AutoScrollbar(emulatore, orient=HORIZONTAL)
scrollbar2.grid(row=1, column=0, sticky=E + W)
finestra = Canvas(emulatore,
yscrollcommand=scrollbar1.set,
xscrollcommand=scrollbar2.set)
finestra.grid(row=0, column=0, sticky=N + S + E + W)
scrollbar1.config(command=finestra.yview)
scrollbar2.config(command=finestra.xview)
emulatore.grid_rowconfigure(0, weight=1)
emulatore.grid_columnconfigure(0, weight=1)
emul = Emulatore(finestra, edit, CD, emulatore)
finestra.create_window(0, 0, anchor=NW, window=emul.master)
emul.master.update_idletasks()
finestra.config(scrollregion=finestra.bbox("all"))
principale.protocol("WM_DELETE_WINDOW", edit.exit)
emulatore.protocol("WM_DELETE_WINDOW", emul.exit)
principale.mainloop()
emulatore.mainloop()
def __canvas(self, master):
f = Frame(master)
f.grid_columnconfigure(0, weight=1)
f.grid_rowconfigure(0, weight=1)
h = Scrollbar(f, orient=HORIZONTAL)
v = Scrollbar(f, orient=VERTICAL)
canvas = Canvas(
f,
background="white",
xscrollcommand=h.set,
yscrollcommand=v.set,
)
h['command'] = canvas.xview
v['command'] = canvas.yview
canvas.bind("<4>", lambda e: self.scale_view(e, 1.0 * 1.1))
canvas.bind("<5>", lambda e: self.scale_view(e, 1.0 / 1.1))
# in windows, mouse wheel events always go to the root window o_O
self.master.bind("<MouseWheel>", lambda e: self.scale_view(
e, ((1.0 * 1.1) if e.delta > 0 else (1.0 / 1.1))
))
# Drag based movement
# def _sm(e):
# self.st = self.render_start.get()
# self.sx = e.x
# self.sy = e.y
# def _cm(e):
# self.render_start.set(self.st + float(self.sx - e.x)/self.scale.get())
# self.render()
# self.canvas.bind("<1>", _sm)
# self.canvas.bind("<B1-Motion>", _cm)
canvas.grid(column=0, row=0, sticky=(N, W, E, S))
v.grid(column=1, row=0, sticky=(N, S))
h.grid(column=0, row=1, sticky=(W, E))
self.canvas = canvas
return f
def run():
"""
Esegue l'emulatore del pdp8
"""
CD = pdp8()
principale = Tk()
principale.title("Pdp8 Emulator : Assembly Editor")
emulatore = Toplevel()
emulatore.title("Pdp8 Emulator")
emulatore.geometry("1015x589")
edit = Editor(principale, CD)
scrollbar1 = AutoScrollbar(emulatore)
scrollbar1.grid(row=0, column=1, sticky=N + S)
scrollbar2 = AutoScrollbar(emulatore, orient=HORIZONTAL)
scrollbar2.grid(row=1, column=0, sticky=E + W)
finestra = Canvas(emulatore,
yscrollcommand=scrollbar1.set,
xscrollcommand=scrollbar2.set)
finestra.grid(row=0, column=0, sticky=N + S + E + W)
scrollbar1.config(command=finestra.yview)
scrollbar2.config(command=finestra.xview)
emulatore.grid_rowconfigure(0, weight=1)
emulatore.grid_columnconfigure(0, weight=1)
emul = Emulatore(finestra, edit, CD, emulatore)
finestra.create_window(0, 0, anchor=NW, window=emul.master)
emul.master.update_idletasks()
finestra.config(scrollregion=finestra.bbox("all"))
principale.protocol("WM_DELETE_WINDOW", edit.exit)
emulatore.protocol("WM_DELETE_WINDOW", emul.exit)
principale.mainloop()
emulatore.mainloop()
def _init_ui(self): # Load an image self.img = ImageTk.PhotoImage(Image.open(r"images\dna5.png")) # Define a canvas in a frame frame = Frame(self) c = Canvas(frame, bg="white", height=475, width=475) # Display the image in the canvas c.create_image(0, 0, image=self.img, anchor=NW) # Y-scrollbar yscrollbar = Scrollbar(frame, command=c.yview) c.configure(yscrollcommand=yscrollbar.set) # X-scrollbar xscrollbar = Scrollbar(frame, orient=HORIZONTAL, command=c.xview) c.configure(xscrollcommand=xscrollbar.set) # Display widgets using grid layout. frame.grid(row=0, column=0) yscrollbar.grid(row=0, column=2, sticky=S + N) xscrollbar.grid(row=2, column=0, sticky=W + E) c.grid(row=0, column=0) self.pack(fill=BOTH, expand=1)
class Avatar(Frame):
def __init__(self,
parent=None,
width=100,
height=100,
ovalness=1,
bgFrameColor='Orange',
bgCanvasColor='Black'):
Frame.__init__(self,
parent,
width=width,
height=height,
bg=bgFrameColor)
self.grid()
#self.grid_propagate(0)
self.width = width
self.height = height
self.ovalness = ovalness
self.bgFrameColor = bgFrameColor
self.bgCanvasColor = bgCanvasColor
self.canvas1 = Canvas(self,
width=width / 2,
height=height / 2,
bg=bgCanvasColor,
borderwidth=0)
self.canvas1.grid(row=0, column=0, ipadx=0, ipady=0, padx=0, pady=0)
self.canvas1.grid_propagate(0)
self.canvas2 = Canvas(self,
width=width / 2,
height=height / 2,
bg=bgCanvasColor,
borderwidth=0)
self.canvas2.grid(row=1, column=1, ipadx=0, ipady=0, padx=0, pady=0)
self.canvas2.grid_propagate(0)
self.draw()
def draw(self):
pass
class ScrolledCanvas:
def __init__(self, master, **opts):
if 'yscrollincrement' not in opts:
opts['yscrollincrement'] = 17
self.master = master
self.frame = Frame(master)
self.frame.rowconfigure(0, weight=1)
self.frame.columnconfigure(0, weight=1)
self.canvas = Canvas(self.frame, **opts)
self.canvas.grid(row=0, column=0, sticky="nsew")
self.vbar = Scrollbar(self.frame, name="vbar")
self.vbar.grid(row=0, column=1, sticky="nse")
self.hbar = Scrollbar(self.frame, name="hbar", orient="horizontal")
self.hbar.grid(row=1, column=0, sticky="ews")
self.canvas['yscrollcommand'] = self.vbar.set
self.vbar['command'] = self.canvas.yview
self.canvas['xscrollcommand'] = self.hbar.set
self.hbar['command'] = self.canvas.xview
self.canvas.bind("<Key-Prior>", self.page_up)
self.canvas.bind("<Key-Next>", self.page_down)
self.canvas.bind("<Key-Up>", self.unit_up)
self.canvas.bind("<Key-Down>", self.unit_down)
#if isinstance(master, Toplevel) or isinstance(master, Tk):
self.canvas.bind("<Alt-Key-2>", self.zoom_height)
self.canvas.focus_set()
def page_up(self, event):
self.canvas.yview_scroll(-1, "page")
return "break"
def page_down(self, event):
self.canvas.yview_scroll(1, "page")
return "break"
def unit_up(self, event):
self.canvas.yview_scroll(-1, "unit")
return "break"
def unit_down(self, event):
self.canvas.yview_scroll(1, "unit")
return "break"
def zoom_height(self, event):
ZoomHeight.zoom_height(self.master)
return "break"
class MemoCaras(Frame):
def __init__(self, root):
Frame.__init__(self, root)
self.grid(column=0, row=0)
self.canvas = Canvas(self, width=604, height=480)
self.canvas.grid(column=0, row=0, columnspan=2)
self.bt_prox = Button(self, text='Próximo', command=self.proximo)
self.bt_prox.grid(column=0, row=1, sticky=W)
self.nome = Label(self, text='(passe aqui para ver o nome)')
self.nome.bind('<Enter>', self.mostra_nome)
self.nome.bind('<Leave>', self.esconde_nome)
self.nome.grid(column=1, row=1, sticky=EW)
self.foto = PhotoImage(file=NOME_ARQ_FOTO)
self.canvas.create_image(0, 0, image=self.foto, anchor=NW)
self.caras = {}
for nome, bbox in pessoas:
marca = self.canvas.create_oval(*bbox, outline='green', width=5,
state=HIDDEN)
self.caras[nome] = marca
self.sequencia = []
self.cara_ativa = None
def proximo(self):
if self.cara_ativa is not None:
marca = self.caras[self.cara_ativa]
self.canvas.itemconfigure(marca, state=HIDDEN)
if len(self.sequencia) == 0:
self.sequencia = self.caras.keys()
shuffle(self.sequencia)
self.cara_ativa = self.sequencia.pop()
marca = self.caras[self.cara_ativa]
self.canvas.itemconfigure(marca, state=NORMAL)
def mostra_nome(self, evento):
self.texto_nome = self.nome['text']
self.nome['text'] = self.cara_ativa
def esconde_nome(self, evento):
self.nome['text'] = self.texto_nome
def initUI(self):
self.parent.title("Othello")
self.style = Style()
self.style.theme_use("default")
self.pack(fill=BOTH, expand=1)
self.columnconfigure(1, weight=1)
self.columnconfigure(3, pad=7)
self.rowconfigure(3, weight=1)
self.rowconfigure(5, pad=7)
canvas = Canvas(self, width=400, height=400)
self.canvas = canvas
self.createBoard()
# self.redrawBoard(self.board)
canvas.pack(fill=BOTH, expand=1)
canvas.grid(row=1, column=0, columnspan=2, rowspan=4,
padx=5, sticky=E+W+S+N)
class Avatar(Frame):
def __init__(self,parent=None,width=100,height=100,ovalness=1,bgFrameColor='Orange',bgCanvasColor='Black'):
Frame.__init__(self,parent,width=width,height=height,bg=bgFrameColor)
self.grid()
#self.grid_propagate(0)
self.width=width
self.height=height
self.ovalness=ovalness
self.bgFrameColor=bgFrameColor
self.bgCanvasColor=bgCanvasColor
self.canvas1=Canvas(self,width=width/2,height=height/2,bg=bgCanvasColor,borderwidth=0)
self.canvas1.grid(row=0,column=0,ipadx=0,ipady=0,padx=0,pady=0)
self.canvas1.grid_propagate(0)
self.canvas2=Canvas(self,width=width/2,height=height/2,bg=bgCanvasColor,borderwidth=0)
self.canvas2.grid(row=1,column=1,ipadx=0,ipady=0,padx=0,pady=0)
self.canvas2.grid_propagate(0)
self.draw()
def draw(self):
pass
def __init__(self):
self.app = Tk()
self.app.title('Connect4')
self.app.resizable(width=False, height=False)
self.board = Board()
self.buttons = {}
self.frame = Frame(self.app, borderwidth=1, relief="raised")
self.tiles = {}
for x in range(self.board.width):
handler = lambda x=x: self.move(x)
button = Button(self.app, command=handler, font=Font(family="Helvetica", size=14), text=x+1)
button.grid(row=0, column=x, sticky="WE")
self.buttons[x] = button
self.frame.grid(row=1, column=0, columnspan=self.board.width)
for x,y in self.board.fields:
tile = Canvas(self.frame, width=60, height=50, bg="navy", highlightthickness=0)
tile.grid(row=self.board.height-1-y, column=x)
self.tiles[x,y] = tile
handler = lambda: self.reset()
self.restart = Button(self.app, command=handler, text='reset')
self.restart.grid(row=2, column=0, columnspan=self.board.width, sticky="WE")
self.update()
class MixerFrame(Frame):
def __init__(self, master, mixer):
Frame.__init__(self, master)
scrollbar_h = Scrollbar(self, orient='horizontal')
scrollbar_v = Scrollbar(self, orient='vertical')
self.canvas = Canvas(self,
background='gray',
scrollregion=(0, 0, (3 + len(mixer) * FADER_WIDTH), FADER_HEIGHT),
yscrollcommand=scrollbar_v.set,
xscrollcommand=scrollbar_h.set)
scrollbar_v.config(command=self.canvas.yview)
scrollbar_h.config(command=self.canvas.xview)
master.bind("<MouseWheel>",
lambda e: self.canvas.yview_scroll(-e.delta, 'units'))
master.bind("<Shift-MouseWheel>",
lambda e: self.canvas.xview_scroll(-e.delta, 'units'))
Sizegrip(self).grid(column=2, row=1, sticky='se')
self.canvas.grid(column=0, row=0, sticky='nwes')
scrollbar_h.grid(column=0, row=1, sticky='we')
scrollbar_v.grid(column=1, row=0, sticky='sn')
master_fader = AudioFader(self, mixer.getVolume, mixer.setVolume, "Master")
master_fader.grid(column=2, row=0, sticky='nwes')
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
for i, channel in enumerate(mixer):
if channel.device.id_variable is not None:
name = channel.device.id_variable
else:
name = channel.device.name_id
fader = AudioFader(self.canvas, channel.get_gain, channel.set_gain, name)
self.canvas.create_window(i * FADER_WIDTH, 0, anchor='nw', window=fader)
def displayResults(master, text):
#Now display the results
from GtBurst import SubWindow
from GtBurst.fontDefinitions import NORMALFONT
from GtBurst import AutoHideScrollbar
from Tkinter import Canvas
from Tkinter import Text, W, E, N, S, INSERT
try:
sub = SubWindow.SubWindow(master,
initialhint="Results of the last likelihood analysis. Select 'close' from the file menu to close this window.",
title="Likelihood results")
sub.bottomtext.config(height=3)
except:
#Cannot display the results. Oh, well...
raise
else:
helpscrollbar = AutoHideScrollbar.AutoHideScrollbar(sub.frame)
helptextCanvas = Canvas(sub.frame,yscrollcommand=helpscrollbar.set)
bottomtext = Text(helptextCanvas, wrap='word',height=30,width=100,
yscrollcommand=helpscrollbar.set, bg='white')
helpscrollbar.config(command=bottomtext.yview)
bottomtext.grid(row=0,column=0,sticky=W+E+N+S)
bottomtext.mark_set("beginning", INSERT)
bottomtext.insert("beginning", text)
bottomtext.config(state='disabled')
helptextCanvas.grid(row=0,column=0)
helpscrollbar.grid(row=0,column=1,sticky=W+E+N+S)
pass
def createWidgets(self):
"Create initial widget set."
# Objects
title = Label(self, text="Bandwidth (Gb/s)", bg=self.bg)
width = self.gwidth
height = self.gheight
scale = self.createScale()
graph = Canvas(self, width=width, height=height, background=self.bg)
xbar = Scrollbar(self, orient="horizontal", command=graph.xview)
ybar = Scrollbar(self, orient="vertical", command=self.yview)
graph.configure(xscrollcommand=xbar.set, yscrollcommand=ybar.set, scrollregion=(0, 0, width, height))
scale.configure(yscrollcommand=ybar.set)
# Layout
title.grid(row=0, columnspan=3, sticky="new")
scale.grid(row=1, column=0, sticky="nsew")
graph.grid(row=1, column=1, sticky="nsew")
ybar.grid(row=1, column=2, sticky="ns")
xbar.grid(row=2, column=0, columnspan=2, sticky="ew")
self.rowconfigure(1, weight=1)
self.columnconfigure(1, weight=1)
return title, scale, graph
def draw( self, tree,row=0,col=0): self.findCoords(tree) self.grid(row=row,column=col,sticky=N+S+E+W) xOff, yOff = 50 - self.minX, 50 - self.minY self.minX += xOff self.maxX += xOff self.minY += yOff self.maxY += yOff canvas = Canvas(self) for line in self.linesToDraw: ((sX,sY),(eX,eY)) = line canvas.create_line(sX+xOff,sY+yOff,eX+xOff,eY+yOff) for circle in self.circlesToDraw: x,y,c = circle canvas.create_oval(x+xOff-5,y+yOff-5,x+xOff+5,y+yOff+5,fill=c) canvas.grid(row=row,column=col,sticky=N+S+E+W)
class Lamp(object):
def __init__(self, queue):
self.root = Tk()
self.root.wm_title("lamp")
self.circle = Canvas(self.root, width=100, height=100, bg='gray')
self.circle.grid(padx=10, pady=10)
self.queue = queue
self.turnoff = True
self.color = DEFAULT_COLOR
self.circle.create_oval(20, 20, 80, 80, fill = self.color)
def mainloop(self):
self.root.mainloop()
def action(self):
xtype, xlen, xcolor = self.queue.get(block = True)
if xcolor is not None:
self.color = xcolor
try:
getattr(self, '_' + TYPE_MAP[xtype])()
except Exception, e:
error('action error %s' % e)
finally:
# each time bets are placed, update all three inputs
#-------------------------------------------------------------------------
# Create root window
root = Tkinter.Tk()
root.title('Wits & Wagers')
root.configure(bg='#FFFFFF')
root.resizable(0, 0)
#get the directory of the file.
dir_path = os.path.dirname(os.path.abspath(__file__))
# Create and place a canvas
canvas = Canvas(root, width=800, height=600)
canvas.grid()
canvas.focus_set()
file_path = os.path.join(dir_path, 'wagerboard.gif')
#get a handle to the file we imported
wagerboard = PhotoImage(file=file_path)
#add the handle to an image which we can see and manipulate
#this is a container for our image, we also set the x,y position
wagerBoard = canvas.create_image(0, 0, anchor=NW, image=wagerboard)
helv16 = tkFont.Font(family='Verdana', size=16)
helv14 = tkFont.Font(family='Verdana', size=14)
team1_score = canvas.create_text(120, 40, text="$10", anchor=NW, font=helv16)
team2_score = canvas.create_text(220, 40, text="$10", anchor=NW, font=helv16)
team3_score = canvas.create_text(318, 40, text="$10", anchor=NW, font=helv16)
class Display(ttkFrame):
'''
Displays the drone state on a graphical interface
'''
REFRESH_PERIOD = 0.2 #5Hz by default
ARM_LENGTH = 23 #pixels
PIXELS_METER = 100.0 #pixels/meter
_instance = None
@staticmethod
def getInstance():
if Display._instance == None:
root = Tk()
root.geometry()
Display._instance = Display(root)
return Display._instance
def __init__(self, parent):
'''
Constructor
'''
ttkFrame.__init__(self, parent)
self._refreshTime = Display.REFRESH_PERIOD
self._stateProvider = None
self._launcherMethod = None
self._isRunning = False
self._droneThread = None
self._parent = parent
self._initUI()
def setStateProvider(self, stateProvider):
'''
Set the flight state provider
'''
self._stateProvider = stateProvider
return self
def setLauncherMethod(self, launcherMethod):
'''
Set the method which controlls the process.
It is required since the main thread (main loop) is used by the GUI.
Therefore, the process for the business logic must be executed within another thread.
'''
self._launcherMethod = launcherMethod
return self
def setRefreshTime(self, refreshTime):
self._refreshTime = refreshTime
return self
def start(self):
if self._launcherMethod and not self._droneThread:
self._droneThread = Thread(target=self._launcherMethod)
self._droneThread.start()
self._isRunning = True
if self._stateProvider:
self._refresh()
self._parent.mainloop()
def stop(self):
self._isRunning = False
if self._droneThread and self._droneThread.isAlive():
self._droneThread.join(5.0)
def quit(self):
self.stop()
ttkFrame.quit(self)
def _initUI(self):
self._parent.title("Drone Flight Emulator")
self.style = Style()
self.style.theme_use("default")
self.pack(fill=BOTH, expand=1)
#Draw frame
drawFrame = tkFrame(self)
drawFrame.grid(column=0, row=0, sticky="W")
self._canvasYZ = Canvas(drawFrame, bg="white", height=200, width=200)
self._canvasYZ.grid(column=0, row=0, sticky="W", padx=(2,0), pady=(2,0))
self._canvasXZ = Canvas(drawFrame, bg="white", height=200, width=200)
self._canvasXZ.grid(column=1, row=0, sticky="E", padx=(2,2), pady=(2,0))
self._canvasXY = Canvas(drawFrame, bg="white", height=200, width=400)
self._canvasXY.grid(column=0, row=1, columnspan=2, sticky="S", padx=(2,2), pady=(0,2))
self._linesXY = [self._canvasXY.create_line(200,100, 200, 90, fill="#ff0000"), \
self._canvasXY.create_line(200,100, 210, 100, fill="#0000ff"), \
self._canvasXY.create_line(200,100, 200, 110, fill="#0000ff"), \
self._canvasXY.create_line(200,100, 190, 100, fill="#0000ff")]
self._linesYZ = [self._canvasYZ.create_line(100,200, 90, 200, fill="#0000ff"), \
self._canvasYZ.create_line(100,200, 110, 200, fill="#0000ff")]
self._linesXZ = [self._canvasXZ.create_line(100,200, 90, 200, fill="#0000ff"), \
self._canvasXZ.create_line(100,200, 110, 200, fill="#0000ff")]
#Info frame
infoFrame = tkFrame(self)
infoFrame.grid(column=1, row=0, sticky="NE", padx=4)
#Angles
Label(infoFrame, text="Coords").grid(column=0, row=0, sticky="WE")
self._coordTexts = [StringVar(),StringVar(),StringVar()]
for index in range(3):
Entry(infoFrame, textvariable=self._coordTexts[index], state=DISABLED, width=5).grid(column=index, row=1)
#Angles
Label(infoFrame, text="Angles").grid(column=0, row=2, sticky="WE")
self._angleTexts = [StringVar(),StringVar(),StringVar()]
for index in range(3):
Entry(infoFrame, textvariable=self._angleTexts[index], state=DISABLED, width=5).grid(column=index, row=3)
#Accels
Label(infoFrame, text="Accels").grid(column=0, row=4, sticky="WE")
self._accelTexts = [StringVar(),StringVar(),StringVar()]
for index in range(3):
Entry(infoFrame, textvariable=self._accelTexts[index], state=DISABLED, width=5).grid(column=index, row=5)
#Speeds
Label(infoFrame, text="Speeds").grid(column=0, row=6, sticky="WE")
self._speedTexts = [StringVar(),StringVar(),StringVar()]
for index in range(3):
Entry(infoFrame, textvariable=self._speedTexts[index], state=DISABLED, width=5).grid(column=index, row=7)
def _plotXY(self, coord, angles):
x = int((coord[0]*Display.PIXELS_METER + 200.0) % 400.0)
y = int((100.0 - coord[1]*Display.PIXELS_METER) % 200.0)
sinz = sin(angles[2])
cosz = cos(angles[2])
lines = [Vector.rotateVector(line, sinz, cosz) \
for line in [ [0, Display.ARM_LENGTH], \
[Display.ARM_LENGTH, 0], \
[0, -Display.ARM_LENGTH], \
[-Display.ARM_LENGTH, 0]] ]
for index in range(4):
self._canvasXY.coords(self._linesXY[index], x, y, x+lines[index][0], y-lines[index][1])
def _plotHeight(self, x, y, angle, canvas, lines):
cosine = cos(angle)
sine = sin(angle)
vectors = [Vector.rotateVector(vector, sine, cosine) \
for vector in [[-Display.ARM_LENGTH, 0], \
[Display.ARM_LENGTH, 0]] ]
for index in range(2):
canvas.coords(lines[index], x, y, x+vectors[index][0], y+vectors[index][1])
def _plotXZ(self, coord, angles):
x = 100
y = int(200.0 - (coord[2]*Display.PIXELS_METER%200.0))
self._plotHeight(x, y, angles[1], self._canvasXZ, self._linesXZ)
def _plotYZ(self, coord, angles):
x = 100
y = int(200.0 - (coord[2]*Display.PIXELS_METER%200.0))
self._plotHeight(x, y, -angles[0], self._canvasYZ, self._linesYZ)
def _refresh(self):
if self._isRunning:
state = self._stateProvider.getState()
if not state._crashed:
angles = [radians(angle) for angle in state._angles]
self._plotXY(state._coords, angles)
self._plotXZ(state._coords, angles)
self._plotYZ(state._coords, angles)
for index in range(3):
self._coordTexts[index].set("{0:.3f}".format(state._coords[index]))
self._angleTexts[index].set("{0:.3f}".format(state._angles[index]))
self._accelTexts[index].set("{0:.3f}".format(state._accels[index]))
self._speedTexts[index].set("{0:.3f}".format(state._speeds[index]))
else:
self._canvasXY.create_text((200,100), text="CRASHED!", fill="#ff0000")
self._canvasXZ.create_text((100,100), text="CRASHED!", fill="#ff0000")
self._canvasYZ.create_text((100,100), text="CRASHED!", fill="#ff0000")
self.update_idletasks()
self.after(int(self._refreshTime * 1000.0), self._refresh)
def __init__(self, filename, parentnotebook):
"""Create a new EditTab
Argument
filename -- name and path to the file being edited
parentnotebook -- the NoteBook in which this tab will be added
"""
Frame.__init__(self)
self._filename = filename
self._parentnotebook = parentnotebook
self._inputs = []
self.path = os.path.dirname(filename)
self._dirty = False
parentnotebook.add(self, state='normal')
self._setLabel()
#Set up GUI
self.rowconfigure(0, weight=1)
self.columnconfigure(0, weight=1)
vscroll = Scrollbar(self, orient=VERTICAL)
self._vscroll = vscroll
vscroll.grid(row=0, column=1, sticky=N + S)
hscroll = Scrollbar(self, orient=HORIZONTAL)
self._hscroll = hscroll
hscroll.grid(row=1, column=0, sticky=E + W)
canvas = Canvas(self,
yscrollcommand=vscroll.set,
xscrollcommand=hscroll.set)
self._canvas = canvas
canvas.grid(row=0, column=0, padx=5, pady=5, sticky=NSEW)
vscroll['command'] = canvas.yview
hscroll['command'] = canvas.xview
scrollframe = Frame(canvas)
self._scrollframe = scrollframe
canvas.create_window(0, 0, window=scrollframe, anchor=N + W)
scrollframe.rowconfigure(0, weight=1)
scrollframe.columnconfigure(0, weight=1)
self._mainframe = Frame(scrollframe)
self._mainframe.grid(row=0, column=0, padx=5, pady=5, sticky=NSEW)
cf = Frame(scrollframe)
self._control_frame = cf
cf.grid(row=1, column=0, padx=5, pady=5, sticky=E)
b = Button(cf,
text=lang[lng.txtCopyImages],
command=self._ehCopyImages)
self._btnCopy = b
b.grid(row=0, column=0, padx=5, pady=5)
b = Button(cf,
text=lang[lng.txtSave],
command=self._ehSave,
state=DISABLED)
self._btnSave = b
b.grid(row=0, column=1, padx=5, pady=5)
b = Button(cf, text=lang[lng.txtClose], command=self._ehClose)
b.grid(row=0, column=2, padx=5, pady=5)
parentnotebook.after_idle(self._setCanvas)
class SudokuUI(Frame):
"""
Sudoku grid UI class.
Adapted from: http://newcoder.io/gui/part-4/
"""
def __init__(self, parent, board):
self.game = board
Frame.__init__(self, parent)
self.parent = parent
self.row, self.col = -1, -1
self.new_entry = None
self.previous_guess = None
self.game_state = 0
self.scores = []
self.__initUI()
def __initUI(self):
"""
Initialize sudoku playing field grid and bind clicking and entry handlers."""
self.parent.title("Sudoku")
self.pack(fill=BOTH, expand=1)
self.canvas = Canvas(self, width=WIDTH, height=HEIGHT)
self.canvas.grid(row=1, column=0)
self.__draw_grid()
self.__draw_puzzle()
self.__draw_scores()
self.canvas.bind("<Button-1>", self.__cell_clicked)
self.canvas.bind("<Key>", self.__key_pressed)
def __draw_grid(self):
"""
Draw Sudoku 3x3 x 3x3 grid."""
for i in xrange(10):
color = "blue" if i % 3 == 0 else "gray"
x0 = MARGIN + i * SIDE
y0 = MARGIN
x1 = MARGIN + i * SIDE
y1 = HEIGHT - MARGIN
self.canvas.create_line(x0, y0, x1, y1, fill=color)
x0 = MARGIN
y0 = MARGIN + i * SIDE
x1 = WIDTH - MARGIN
y1 = MARGIN + i * SIDE
self.canvas.create_line(x0, y0, x1, y1, fill=color)
def __draw_puzzle(self):
"""
Draw Sudoku solution numbers."""
self.canvas.delete("numbers")
for i in xrange(9):
for j in xrange(9):
answer = self.game.board[i][j]
if answer != 0:
x = MARGIN + j * SIDE + SIDE / 2
y = MARGIN + i * SIDE + SIDE / 2
self.canvas.create_text(x, y, text=answer, tags="numbers")
def __cell_clicked(self, event):
"""
Handle a single cell click and highlight the clicked cell.
:param event:
"""
x, y = event.x, event.y
if MARGIN < x < WIDTH - MARGIN and MARGIN < y < HEIGHT - MARGIN:
self.canvas.focus_set()
# get row and col numbers from x,y coordinates
row, col = (y - MARGIN) / SIDE, (x - MARGIN) / SIDE
# if cell was selected already - deselect it
if (row, col) == (self.row, self.col):
self.row, self.col = -1, -1
elif self.game.board[row][col] == 0:
self.row, self.col = row, col
self.__draw_cursor()
def __draw_cursor(self):
"""
Draw the red outline for the selected square."""
self.canvas.delete("cursor")
if self.row >= 0 and self.col >= 0:
x0 = MARGIN + self.col * SIDE + 1
y0 = MARGIN + self.row * SIDE + 1
x1 = MARGIN + (self.col + 1) * SIDE - 1
y1 = MARGIN + (self.row + 1) * SIDE - 1
self.canvas.create_rectangle(x0,
y0,
x1,
y1,
outline="green",
tags="cursor")
def __key_pressed(self, event):
"""
Handle solution number entry."""
if self.row >= 0 and self.col >= 0 and event.char in "123456789" and self.game_state == 1:
self.new_entry = (self.row, self.col, int(event.char))
self.col, self.row = -1, -1
self.__draw_puzzle()
self.__draw_cursor()
def __draw_scores(self):
self.score_list = Treeview(self, columns=('name', 'score'))
self.score_list['show'] = 'headings'
self.score_list.heading('name', text='Name')
self.score_list.column('name', width=80, anchor=CENTER)
self.score_list.heading('score', text='Score')
self.score_list.column('score', width=80, anchor=CENTER)
self.score_list.grid(row=1, column=1, padx=(0, 20))
def __update_scores(self, scores):
self.score_list.delete(*self.score_list.get_children())
for entry in scores:
self.score_list.insert('', 'end', values=(entry[0], entry[1]))
def show_winner(self, score, user_id):
if score[2] == user_id:
winner_text = "YOU HAVE WON!"
else:
winner_text = "Player " + str(score[0]) + " has won!"
tkMessageBox.showwarning("A WINNER IS FOUND", winner_text)
def update_board(self, root, board, scores, new_game_state):
"""
Update board during the gameplay. If all players are not connected, solution entry is not permitted.
In case of a wrong answer the selected square is flashed red for a fraction of a second to notify
the player about his life decisions.
:param root:
:param board:
:param new_game_state:
:return entered value:
"""
return_val = None
self.__update_scores(scores)
# Check for game state, if it is "0", just return, else continue the game
if self.game_state == 0:
root.update()
if new_game_state != 0:
self.game_state = new_game_state
return return_val
# If previous guess was not correct flash it red
if self.previous_guess is not None and board[self.previous_guess[0]][self.previous_guess[1]] != \
self.previous_guess[2]:
row, col, _ = self.previous_guess
x0 = MARGIN + col * SIDE + 1
y0 = MARGIN + row * SIDE + 1
x1 = MARGIN + (col + 1) * SIDE - 1
y1 = MARGIN + (row + 1) * SIDE - 1
self.canvas.create_rectangle(x0,
y0,
x1,
y1,
fill="red",
tags="fail")
else:
self.canvas.delete("fail")
# Initiate return value to none, update the board and draw it
self.game.update_board(board)
self.__draw_puzzle()
root.update()
# If user has entered anything in between, write it into the return value and previous guess and return
if self.new_entry is not None:
return_val = self.new_entry
self.previous_guess = self.new_entry
self.new_entry = None
else:
self.previous_guess = None
return return_val
class Scrolling_Area(Frame, object):
def __init__(self, master, width=None, anchor=N, height=None, mousewheel_speed = 2, scroll_horizontally=True, xscrollbar=None, scroll_vertically=True, yscrollbar=None, outer_background=None, inner_frame=Frame, **kw):
Frame.__init__(self, master, class_=self.__class__)
if outer_background:
self.configure(background=outer_background)
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
self._width = width
self._height = height
self.canvas = Canvas(self, background=outer_background, highlightthickness=0, width=width, height=height)
self.canvas.grid(row=0, column=0, sticky=N+E+W+S)
if scroll_vertically:
if yscrollbar is not None:
self.yscrollbar = yscrollbar
else:
self.yscrollbar = Scrollbar(self, orient=VERTICAL)
self.yscrollbar.grid(row=0, column=1,sticky=N+S)
self.canvas.configure(yscrollcommand=self.yscrollbar.set)
self.yscrollbar['command']=self.canvas.yview
else:
self.yscrollbar = None
if scroll_horizontally:
if xscrollbar is not None:
self.xscrollbar = xscrollbar
else:
self.xscrollbar = Scrollbar(self, orient=HORIZONTAL)
self.xscrollbar.grid(row=1, column=0, sticky=E+W)
self.canvas.configure(xscrollcommand=self.xscrollbar.set)
self.xscrollbar['command']=self.canvas.xview
else:
self.xscrollbar = None
self.rowconfigure(0, weight=1)
self.columnconfigure(0, weight=1)
self.innerframe = inner_frame(self.canvas, **kw)
self.innerframe.pack(anchor=anchor)
self.canvas.create_window(0, 0, window=self.innerframe, anchor='nw', tags="inner_frame")
self.canvas.bind('<Configure>', self._on_canvas_configure)
Mousewheel_Support(self).add_support_to(self.canvas, xscrollbar=self.xscrollbar, yscrollbar=self.yscrollbar)
@property
def width(self):
return self.canvas.winfo_width()
@width.setter
def width(self, width):
self.canvas.configure(width= width)
@property
def height(self):
return self.canvas.winfo_height()
@height.setter
def height(self, height):
self.canvas.configure(height = height)
def set_size(self, width, height):
self.canvas.configure(width=width, height = height)
def _on_canvas_configure(self, event):
width = max(self.innerframe.winfo_reqwidth(), event.width)
height = max(self.innerframe.winfo_reqheight(), event.height)
self.canvas.configure(scrollregion="0 0 %s %s" % (width, height))
self.canvas.itemconfigure("inner_frame", width=width, height=height)
def update_viewport(self):
self.update()
window_width = self.innerframe.winfo_reqwidth()
window_height = self.innerframe.winfo_reqheight()
if self._width is None:
canvas_width = window_width
else:
canvas_width = min(self._width, window_width)
if self._height is None:
canvas_height = window_height
else:
canvas_height = min(self._height, window_height)
self.canvas.configure(scrollregion="0 0 %s %s" % (window_width, window_height), width=canvas_width, height=canvas_height)
self.canvas.itemconfigure("inner_frame", width=window_width, height=window_height)
# Create the three button widgets
red_button = Button(traffic_window, text='Red', width=6, command=red_light)
yellow_button = Button(traffic_window,
text='Yellow',
width=6,
command=yellow_light)
green_button = Button(traffic_window,
text='Green',
width=6,
command=green_light)
# Create the drawing canvas
traffic_light = Canvas(traffic_window, width=200, height=200, bg='white')
# Call the geometry manager to place the widgets onto
# the window (in a grid arrangement, with a margin)
margin_size = 5
traffic_light.grid(padx=margin_size,
pady=margin_size,
row=0,
column=0,
columnspan=3)
green_button.grid(pady=margin_size, row=1, column=2)
yellow_button.grid(pady=margin_size, row=1, column=1)
red_button.grid(pady=margin_size, row=1, column=0)
# Start the event loop to react to user inputs
traffic_window.mainloop()
global captured
global cnt
cnt = 0
captured = False
def capture():
global captured
captured = True
root = Tkinter.Tk()
cap = cv2.VideoCapture(0)
canvas = Canvas(root, width=800, height=600)
canvas.grid(row=0, column=0)
button = Button(root, text="Capture", command=capture)
button.grid(row=1, column=0)
ret = False
while not ret:
ret, img = cap.read()
while True:
ret, img = cap.read()
img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
photo = ImageTk.PhotoImage(image=img)
canvas.create_image(0, 0, anchor='nw', image=photo)
root.update_idletasks()
root.update()
global captured
if captured:
#Draw a line
from tkinter import *
def draw_line(event):
global click_number
global x1, y1
if click_number == 0:
x1 = event.x
y1 = event.y
click_number = 0
my_window = Tk()
my_canvas = Canvas(my_window, width=400, height=400, background='white')
my_canvas.grid(row=0, column=0)
my_canvas.bind('<Button-1>', draw_line)
click_number = 0
my_window.mainloop()
#Final Flood fill
from tkinter import *
def draw_line(event):
global click_number
global x1, y1
if click_number == 0:
x1 = event.x
y1 = event.y
click_number = 0
class Board:
"""
This is our board for the game
"""
def __init__(self, parent, size, color):
self.parent = parent
self.size = size
self.color = color
# design to fit tkinter grid(row, col)two params
self.unused_cells_dict = CELLS_DICT.copy()
# creating main container for the board
self.container = Frame(self.parent)
self.container.pack()
# creating canvas for the container
self.canvas = Canvas(self.container,
width=self.size * 3,
height=self.size * 3)
self.canvas.grid(row=0, column=0, rowspan=3, sticky=W + E + N + S)
def draw_board(self):
''' Draw the board '''
for row in xrange(3):
for col in xrange(3):
self.canvas.create_rectangle(self.size * col,
self.size * row,
self.size * (col + 1),
self.size * (row + 1),
fill=self.color)
def get_unused_cells_dict(self):
return self.unused_cells_dict
def update_unused_cells_dict(self, key):
''' Remove used key from the dictionary '''
self.unused_cells_dict.pop(key)
def check_if_key_available(self, key):
if not key in self.unused_cells_dict.keys():
return False
return True
def reset_unused_cells_dict(self):
self.unused_cells_dict = CELLS_DICT.copy()
def get_event_coord(self, e):
''' Get the event coordinates '''
return e.x, e.y
def get_floor_coord(self, col, row):
floor_col = col // self.size
floor_row = row // self.size
return floor_col, floor_row
def convert_coord_to_key(self, col, row):
return str(col) + str(row)
def get_selected_cell_coords(self, event):
"""
finding coordinates of a cell in a 9-cell grid
:param event: this should be triggered by a user click
:return: tuple of column and row
"""
col, row = self.get_event_coord(event)
floor_col, floor_row = self.get_floor_coord(col, row)
corner_col = floor_col * self.size + self.size
corner_row = floor_row * self.size + self.size
return corner_col, corner_row
def translate_cells_dict_key_to_text_coords(self, key):
"""
This function will get the top left corner of the rectangle coordinates
to enable us to draw the text in the right rectangle
:param key: is a key in the CELLS_DICT
:return: x & y of the top left corner of the rectangle
"""
x_key = int(key[0])
y_key = int(key[1])
x = x_key * self.size + self.size / 2
y = y_key * self.size + self.size / 2
return x, y
def convert_vals_to_keys(self, res):
ret_keys = []
for i in res:
if i not in self.unused_cells_dict.values():
continue
for key, value in CELLS_DICT.iteritems():
if value == i:
ret_keys.append(key)
return ret_keys
@property
def winning_combos(self):
return WINNING_COMBOS
class App:
grid_size = 15
num_pixels = 30
ser = None
t = None
pixel_dictionary = {}
def __init__(self, master):
# Set main window's title
master.title("ADNS3080ImageGrabber")
frame = Frame(master)
frame.grid(row=0, column=0)
self.comPortStr = StringVar()
ports = serial_ports()
if not ports:
ports = ['No serial ports found']
self.comPortStr.set(ports[0]) # Set first port as default
comports = apply(OptionMenu, (frame, self.comPortStr) + tuple(ports))
comports.grid(row=0, column=0)
self.baudrateStr = StringVar()
self.baudrateStr.set('115200')
baudrates = apply(OptionMenu, (frame, self.baudrateStr) + tuple(Serial.BAUDRATES))
baudrates.grid(row=0, column=1)
button = Button(frame, text="Open", command=self.open)
button.grid(row=0, column=2)
button = Button(frame, text="Close", command=self.close)
button.grid(row=0, column=3)
self.canvas = Canvas(master, width=self.grid_size*self.num_pixels, height=self.grid_size*self.num_pixels)
self.canvas.grid(row=1)
def __del__(self):
self.close()
def close(self):
self.stop_read_loop()
self.close_serial()
def open(self):
# Close the serial port
self.close_serial()
# Open the serial port
try:
self.ser = Serial(port=self.comPortStr.get(), baudrate=self.baudrateStr.get(), timeout=.1)
print("Serial port '" + self.comPortStr.get() + "' opened at " + self.baudrateStr.get())
self.read_loop() # Read from serial port
except SerialException:
print("Failed to open serial port '" + self.comPortStr.get() + "'")
def close_serial(self):
if self.ser and self.ser.isOpen():
try:
self.ser.close()
print("Closed serial port")
except SerialException:
pass # Do nothing
def read_loop(self):
if self.t:
self.stop_read_loop()
if self.ser.isOpen():
try:
self.read_from_serial()
except (IOError, TypeError):
pass
self.t = Timer(0.0, self.read_loop)
self.t.start()
def stop_read_loop(self):
try:
self.t.cancel()
except AttributeError:
print("Failed to cancel timer")
def read_from_serial(self):
while self.ser and self.ser.isOpen() and self.ser.inWaiting() > 0:
# Process the line read
line = self.ser.readline()
if line.find("start") == 0:
# print('Started reading image')
pixels = self.ser.read(self.num_pixels * self.num_pixels)
if len(pixels) == self.num_pixels * self.num_pixels:
for row in range(self.num_pixels):
# print(row)
col = 0
for p in pixels[row * self.num_pixels:(row + 1) * self.num_pixels]:
try:
colour = ord(p)
except TypeError:
colour = 0
# print('Colour', colour)
self.display_pixel(self.num_pixels - 1 - row, self.num_pixels - 1 - col, colour)
col += 1
# print('Done reading image')
else:
print(len(pixels))
# print("Bad line: " + pixels)
else:
# Display the line if we couldn't understand it
print('Error while processing string:', line)
self.ser.flushInput() # Flush the input, as this was likely caused by a timeout
def display_default_image(self):
# Display the grid
for x in range(self.num_pixels):
for y in range(self.num_pixels):
colour = x * y / 3.53
self.display_pixel(x, y, colour)
def display_pixel(self, x, y, colour):
if 0 <= x < self.num_pixels and 0 <= y < self.num_pixels:
# Find the old pixel if it exists and delete it
if x+y*self.num_pixels in self.pixel_dictionary:
old_pixel = self.pixel_dictionary[x+y*self.num_pixels]
self.canvas.delete(old_pixel)
del old_pixel
fill_colour = "#%02x%02x%02x" % (colour, colour, colour)
# Draw a new pixel and add to pixel_array
new_pixel = self.canvas.create_rectangle(x*self.grid_size, y*self.grid_size, (x+1)*self.grid_size,
(y+1)*self.grid_size, fill=fill_colour)
self.pixel_dictionary[x+y*self.num_pixels] = new_pixel
class App:
def __init__(self, master):
self.master = master
self.file = 'grid.csv'
self.ownZepName = "goud"
self.updatingFlag = False
self.btnUpPressed = False
self.btnDownPressed = False
self.btnLeftPressed = False
self.btnRightPressed = False
self.btnPlusPressed = False
self.btnMinusPressed = False
#keyListener aanzetten
master.bind("<Key>", self.keyPressed)
master.bind("<KeyRelease>", self.keyReleased)
leftFrame = Frame(master, width = 200, height = 640)
leftFrame.grid(row = 0, column = 0)
debugFrame = Frame(leftFrame, width = 200, height = 400)
debugFrame.grid(row = 0, column = 0)
controlFrame = Frame(leftFrame, width = 200, height = 200)
controlFrame.grid(row = 1, column = 0, pady = 10)
rasterFrame = Frame(master, width = 600, height = 640)
rasterFrame.grid(row = 0, column = 1)
#Scrolledtext in leftTopFrame
self.scrDebug = ScrolledText(debugFrame, wrap = WORD, state = "disabled", fg = "dark red", width=80)
self.scrDebug.grid(row = 0, column = 0, padx = 10, pady = 10)
#Buttons
#simulator
self.btnToggleSimu = Button(controlFrame, text = "Simulator", width = 14, bg = 'gray85', command = lambda: self.toggleSimulator())
self.btnToggleSimu.grid(row = 3, column = 2)
self.btnMoveToSimu = Button(controlFrame, text = "Ga naar (Sim)", width = 14, bg = 'gray85', command = lambda: self.moveTo(Name = "goudsimu"))
self.btnMoveToSimu.grid(row = 1, column = 4)
self.btnHeightSimu = Button(controlFrame, text = "Kies hoogte (Sim)", width = 14, bg = 'gray85', command = lambda: self.setGewensteHoogte(Name ="goudsimu"))
self.btnHeightSimu.grid(row = 2, column = 4)
#hoogte
self.gemetenHoogteString = StringVar()
self.gemetenHoogteString.set(str(0))
self.lblGemetenHoogte = Label(controlFrame, text="Gemeten Hoogte: ", anchor = "w")
self.lblGemetenHoogteVar = Label(controlFrame, textvariable = self.gemetenHoogteString, width = 20)
self.lblGemetenHoogte.grid(row=0, column=2)
self.lblGemetenHoogteVar.grid(row=0, column=3)
#move to
self.btnMoveTo = Button(controlFrame, text="Ga naar (Zep)", bg = 'gray85', width = 14, command = lambda: self.moveTo())
self.btnMoveTo.grid(row=1,column=2)
self.txtMoveTo = Entry(controlFrame, width=24)
self.txtMoveTo.grid(row=1, column=3)
self.txtMoveTo.bind('<Return>', self.moveTo)
#hoogte
self.btnHeight = Button(controlFrame, text="Kies hoogte (Zep)", bg = 'gray85', width = 14, command = lambda: self.setGewensteHoogte())
self.btnHeight.grid(row=2,column=2)
self.txtHeight = Entry(controlFrame, width=24)
self.txtHeight.grid(row=2, column=3)
self.txtHeight.bind('<Return>', self.setGewensteHoogte)
#images
self.display = Canvas(rasterFrame, width=600, height=570, bd=0, highlightthickness=0)
self.display.grid(row=0, column = 0, sticky=W+E+N+S)
foundFigures = Label(controlFrame, text = "Herkende figuren:")
foundFigures.grid(row = 0, column = 0)
self.display2 = Canvas(controlFrame, width = 220, height=165, bd=2, relief = "groove", highlightthickness=0)
self.display2.grid(row=1, column = 0, sticky=W+E+N+S, rowspan=12)
self.latestphoto = Image.new("RGB", (220,165), (150,150,150))
self.latestImage = ImageTk.PhotoImage(self.latestphoto)
self.display2.create_image(0, 0, image=self.latestImage, anchor=NW)
#goal
original = Image.open('goalPin.png')
resized = original.resize((60,60),Image.ANTIALIAS)
self.goalImage = ImageTk.PhotoImage(resized)
self.makeBackground()
self.initZeppelins()
self.paintCanvas()
self.sim = None
mq.setGUI(self)
def initZeppelins(self):
self.zeppelins = []
self.goal = (-100,-100)
# self.zeppelins.append(AbstractZeppelin('red', 'simu'))
self.zeppelins.append(AbstractZeppelin('#EBB400', self.ownZepName))
def convToPixelCoords(self, pos):
cmHeight = 34.6410162
cmWidth = 40.0
xcm, ycm = pos
x = self.evenXStart + (xcm/cmWidth)*self.triangleWidth
y = self.yStart + (ycm/cmHeight)*self.triangleHeight
result = (x,y)
return result
def createPhoto(self, cvresults):
self.latestphoto = Image.new("RGB", (220,165), (150,150,150))
cv = eval(cvresults)
width = cv[0]
height = cv[1]
figures = cv[2]
coordinates = cv[3]
for i in xrange(0,len(figures)):
j = self.allShapes.index(figures[i])
image = self.shapeImages[j]
xcoord = int(coordinates[i][0]/(width*1.0)*220)
ycoord = int(coordinates[i][1]/(height*1.0)*165)
self.latestphoto.paste(image, (xcoord-12, ycoord-12), mask = image)
self.latestImage = ImageTk.PhotoImage(self.latestphoto)
self.display2.create_image(0, 0, image=self.latestImage, anchor=NW)
def makeBackground(self):
#rooster inlezen:
f = open("../positioning/"+ str(self.file), 'r')
shapesText = f.read()
self.raster = []
self.tabletLocations = []
nrows = 0
ncol = 0
for line in shapesText.split("\n"):
temp = line.split(",")
if not len(temp) == 2:
nrows += 1
if ncol == 0:
ncol = len(temp)
for s in temp:
self.raster.append(s.strip())
else:
self.tabletLocations.append((int(temp[0]), int(temp[1])))
f.close()
tempWidth1 = 600/ncol
tempHeight1 = int(round((math.sqrt(tempWidth1**2 - (tempWidth1/2)**2)), 0))
tempHeight2 = 570/nrows+2
tempWidth2 = int(round((math.sqrt(4/3 * tempHeight2**2)),0))
#raster
self.resizedRaster = Image.new("RGB", (600,570), (240,240,240))
#vormpjes
self.allShapes = ['BC','BH','BR','BS','GC','GH','GR','GS','RC','RH','RR','RS','WC','WH','WR','WS','YC','YH','YR','YS']
self.shapeImages = []
for i in range(20):
imgFile = "vormpjes/" + self.allShapes[i] + ".png"
original = Image.open(imgFile)
self.shapeImages.append(original.resize((24, 24),Image.ANTIALIAS))
original = Image.open("tablet.png")
self.tabletIm = original.resize((40,40),Image.ANTIALIAS)
self.xlen = ncol
self.ylen = nrows
self.triangleWidth = min(tempWidth1, tempWidth2)
self.triangleHeight = min(tempHeight1, tempHeight2)
self.evenXStart = (600-((ncol)*self.triangleWidth))/2 + self.triangleWidth/4
self.oddXStart = self.evenXStart + self.triangleWidth/2
self.yStart = (600-((nrows)*self.triangleHeight))/2 + self.triangleHeight/4
draw = ImageDraw.Draw(self.resizedRaster)
#grid tekenen
for y in range(self.ylen):
for x in range(self.xlen):
ycoord = self.yStart + y*self.triangleHeight
zelf = self.raster[y*self.xlen + x] != "XX"
if y>0:
boven = self.raster[(y-1)*self.xlen + x] != "XX"
if y<self.ylen-1:
onder = self.raster[(y+1)*self.xlen + x] != "XX"
if y>0 and x < self.xlen-1:
oddboven = self.raster[(y-1)*self.xlen + x+1] != "XX"
if y<self.ylen-1 and x < self.xlen-1:
oddonder = self.raster[(y+1)*self.xlen + x+1] != "XX"
if x<self.xlen-1:
naast = self.raster[y*self.xlen + x+1] != "XX"
if y % 2 == 0:
xcoord = self.evenXStart + x*self.triangleWidth
if x < self.xlen-1 and naast and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth, ycoord), fill = 0)
if y < self.ylen-1 and onder and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth/2, ycoord+self.triangleHeight), fill = 0)
if y > 0 and boven and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth/2, ycoord-self.triangleHeight), fill = 0)
else:
xcoord = self.oddXStart + x*self.triangleWidth
if x < self.xlen-1 and naast and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth, ycoord), fill = 0)
if y < self.ylen-1 and x < self.xlen-1 and oddonder and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth/2, ycoord+self.triangleHeight), fill = 0)
if y > 0 and x < self.xlen-1 and oddboven and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth/2, ycoord-self.triangleHeight), fill = 0)
del draw
for loc in self.tabletLocations:
conv = self.convToPixelCoords((loc[0]/10, loc[1]/10))
self.resizedRaster.paste(self.tabletIm, (int(conv[0])-20, int(conv[1])-20), mask = self.tabletIm)
#vormpjes tekenen
for y in range(self.ylen):
for x in range(self.xlen):
index = y*self.xlen + x
if y % 2 == 0:
xcoord = self.evenXStart + x*self.triangleWidth
else:
xcoord = self.oddXStart + x*self.triangleWidth
ycoord = self.yStart + y*self.triangleHeight
shape = self.raster[index]
if shape != 'XX':
image = self.shapeImages[self.allShapes.index(shape)]
self.resizedRaster.paste(image, (xcoord-12, ycoord-12), mask = image)
self.rasterImage = ImageTk.PhotoImage(self.resizedRaster)
def updatePath(self):
self.rasterBackup = self.rasterImage
draw = ImageDraw.Draw(self.resizedRaster)
for z in self.zeppelins:
length = len(z.locations)
if length > 1:
prev = self.convToPixelCoords(z.locations[length-2])
current = self.convToPixelCoords(z.locations[length-1])
draw.line((prev[0], prev[1], current[0], current[1]), fill=z.color, width = 3)
self.rasterImage = ImageTk.PhotoImage(self.resizedRaster)
del draw
def paintCanvas(self):
#clear the canvas
#self.display.delete('all')
#rooster tekenen
self.updatePath()
self.display.create_image(0, 0, image=self.rasterImage, anchor=NW)
#Testcode voor zeppelin locatie
for z in self.zeppelins:
if z.orientationFound:
point1x = self.convToPixelCoords(z.location)[0]+16*math.sin(math.radians(z.orientation + 20))
point1y = self.convToPixelCoords(z.location)[1]+16*math.cos(math.radians(z.orientation + 20))
point2x = self.convToPixelCoords(z.location)[0]+16*math.sin(math.radians(z.orientation - 20))
point2y = self.convToPixelCoords(z.location)[1]+16*math.cos(math.radians(z.orientation - 20))
point3x = self.convToPixelCoords(z.location)[0]+28*math.sin(math.radians(z.orientation))
point3y = self.convToPixelCoords(z.location)[1]+28*math.cos(math.radians(z.orientation))
arrowPoints = [point1x, point1y, point2x, point2y, point3x, point3y]
self.display.create_polygon(arrowPoints, fill=z.color, outline='black', width = 1)
self.display.create_oval(self.convToPixelCoords(z.location)[0]-12, self.convToPixelCoords(z.location)[1]-12,self.convToPixelCoords(z.location)[0]+12, self.convToPixelCoords(z.location)[1]+12, fill=z.color)
self.display.create_image(self.convToPixelCoords(self.goal)[0]+6, self.convToPixelCoords(self.goal)[1]-18, image = self.goalImage, anchor=CENTER)
def toggleSimulator(self):
if self.sim == None:
enemy = "goudsimu"
self.zeppelins.append(AbstractZeppelin("red", enemy))
mq.initEnemy(enemy)
self.sim = simulator.simulator(100,100, enemy)
return
self.sim.toggleActive()
def updateGoal(self, location, tablet):
self.debugPrint("Nieuw doel voor simulator: " + str(tablet) + " " + str(location))
self.goal = self.convToPixelCoords(location)
self.paintCanvas()
def updateLocation(self, location, n):
self.debugPrint("Nieuwe locatie voor " + n + " ontvangen: " + str(location))
for z in self.zeppelins:
if z.name == n:
z.updateLocation((location[0]/10, location[1]/10))
self.paintCanvas()
def updateHeight(self, height, n):
self.debugPrint("Nieuwe hoogte voor " + n + " ontvangen: " + str(height))
if self.ownZepName == n:
self.gemetenHoogteString.set(str(height))
def updateAngle(self, angle, n):
self.debugPrint("Nieuwe orientatie voor " + n + " ontvangen: " + str(angle) + " graden")
for z in self.zeppelins:
if z.name == n:
z.updateAngle(angle)
self.paintCanvas()
def showCvResults(self, body):
self.debugPrint("Nieuwe foto vertaling ontvangen: " + body)
self.createPhoto(body)
#gewenste hoogte aanpassen
def setGewensteHoogte(self, event = None, Name = "goud"):
x = self.txtHeight.get()
self.txtHeight.delete(0, END)
self.master.focus()
try:
x = int(x)
except:
return
if isinstance(x, int) and x > 0 and x < 8000:
global neededHeight
neededHeight = x
message = "Hoogte instellen op " + str(neededHeight) + " aangevraagd"
self.debugPrint(message)
mq.elevate(x, Name)
#gewenste hoogte aanpassen
def moveTo(self, event = None, Name = "goud"):
st = self.txtMoveTo.get()
self.txtMoveTo.delete(0, END)
self.master.focus()
try:
xst, yst = st.split(',')
x = int(xst)
y = int(yst)
except:
return
if isinstance(x, int) and isinstance(y, int):
message = "Bewegen naar (" + str(x) + "," + str(y) + ") aangevraagd"
self.debugPrint(message)
self.goal = x/10,y/10
self.paintCanvas()
mq.moveTo(x, y, Name)
#tekst weergeven in debug venster
def debugPrint(self, tekst):
self.scrDebug.config(state = "normal")
self.scrDebug.insert(END, ">> " + tekst + "\n")
self.scrDebug.config(state = "disabled")
self.scrDebug.yview_pickplace("end")
def toggleAutomaticPilot(self):
if not self.connected:
return
self.debugPrint("Automatische piloot toggle aangevraagd")
self.client.toggleAutomaticPilot()
def createClient(self):
try:
self.client = cl(self, self.ownZepName)
self.zeppelins.append(AbstractZeppelin('red', self.ownZepName, self, self.client))
self.connected = True
self.connectedString.set("Verbonden")
self.lblConnected.config(fg = "green")
self.debugPrint("Verbonden met Raspberry Pi")
except:
self.debugPrint("Verbinding met Rapsberry Pi niet mogelijk:\n -Staat de Raspberry Pi aan?\n -Staat de server aan?\n -Zit deze computer op de ad-hoc?")
def moveForward(self):
self.debugPrint("Voorwaarts vliegen aangevraagd")
mq.setMotor1PWM(100)
mq.setMotor2PWM(100)
def moveBackward(self):
self.debugPrint("Achterwaarts vliegen aangevraagd")
mq.setMotor1PWM(-100)
mq.setMotor2PWM(-100)
def moveLeft(self):
self.debugPrint("Links draaien aangevraagd")
mq.setMotor1PWM(100)
def moveRight(self):
self.debugPrint("Rechts draaien aangevraagd")
mq.setMotor2PWM(100)
def moveUp(self):
self.debugPrint("Omhoog vliegen aangevraagd")
mq.setMotor3PWM(100)
def moveDown(self):
self.debugPrint("Omlaag vliegen aangevraagd")
mq.setMotor3PWM(-100)
def horizontalOff(self):
self.debugPrint("Horizontale motors stoppen aangevraagd")
mq.setMotor1PWM(0)
mq.setMotor2PWM(0)
def verticalOff(self):
self.debugPrint("Verticale motor stoppen aangevraagd")
mq.setMotor3PWM(0)
#toetsenbord invoer
def keyPressed(self, event):
k = event.keysym
if k == 'Up':
if not self.btnUpPressed:
self.btnUpPressed = True
self.moveForward()
elif k == 'Down':
if not self.btnDownPressed:
self.btnDownPressed = True
self.moveBackward()
elif k == 'Left':
if not self.btnLeftPressed:
self.btnLeftPressed = True
self.moveLeft()
elif k == 'Right':
if not self.btnRightPressed:
self.btnRightPressed = True
self.moveRight()
elif k == 'plus':
if not self.btnPlusPressed:
self.btnPlusPressed = True
self.moveUp()
elif k == 'minus':
if not self.btnMinusPressed:
self.btnMinusPressed = True
self.moveDown()
def keyReleased(self, event):
k = event.keysym
if k == 'Up':
self.btnUpPressed = False
self.horizontalOff()
elif k == 'Down':
self.btnDownPressed = False
self.horizontalOff()
elif k == 'Left':
self.btnLeftPressed = False
self.horizontalOff()
elif k == 'Right':
self.btnRightPressed = False
self.horizontalOff()
elif k == 'plus':
self.btnPlusPressed = False
self.verticalOff()
elif k == 'minus':
self.btnMinusPressed = False
self.verticalOff()
class ScrolledCanvas:
def __init__(self, master, **opts):
if not opts.has_key('yscrollincrement'):
opts['yscrollincrement'] = 20
self.master = master
self.frame = TFrame(master, style="FlatFrame")
self.frame.rowconfigure(0, weight=1)
self.frame.columnconfigure(0, weight=1)
self.canvas = Canvas(self.frame, **opts)
self.canvas.grid(row=0, column=0, sticky="nsew")
self.vbar = TScrollbar(self.frame, name="vbar")
self.vbar.grid(row=0, column=1, sticky="nse")
self.hbar = TScrollbar(self.frame, name="hbar", orient="horizontal")
self.hbar.grid(row=1, column=0, sticky="ews")
self.canvas['yscrollcommand'] = lambda f, l: self.scroll_sh(self.vbar, f, l)
self.vbar['command'] = self.canvas.yview
self.canvas['xscrollcommand'] = lambda f, l: self.scroll_sh(self.hbar, f, l)
self.hbar['command'] = self.canvas.xview
self.canvas.bind("<Key-Prior>", self.page_up)
self.canvas.bind("<Key-Next>", self.page_down)
self.canvas.bind("<Key-Up>", self.unit_up)
self.canvas.bind("<Key-Down>", self.unit_down)
self.canvas.bind("<Alt-Key-2>", self.zoom_height)
self.canvas.bind("<Button-4>", self.unit_up)
self.canvas.bind("<Button-5>", self.unit_down)
self.canvas.focus_set()
def page_up(self, event):
self.canvas.yview_scroll(-1, "page")
return "break"
def page_down(self, event):
self.canvas.yview_scroll(1, "page")
return "break"
def unit_up(self, event):
first,last=self.vbar.get()
if first <= 0 and last >= 1:
return "break"
self.canvas.yview_scroll(-1, "unit")
return "break"
def unit_down(self, event):
first,last=self.vbar.get()
if first <= 0 and last >= 1:
return "break"
self.canvas.yview_scroll(1, "unit")
return "break"
def zoom_height(self, event):
return "break"
def scroll_sh(self, scroll, first, last):
first, last = float(first), float(last)
if first <= 0 and last >= 1:
scroll.grid_remove()
else:
scroll.grid()
scroll.set(first, last)
